终端打开python

python

退出

exit()

utf-8是不等长编码

一、基础

赋值

可同时给多个变量赋值

a,b,c={'1':1,'2':2,'3':3} #map字典

a,b,c=(1,2,3) #元组

a,b,c=[1,2,3] #列表

以上都可以同时赋值

标识符

函数名与变量命名规则一样

1. 字母
   
2. 数字（不能作为开头）
   
3. 下划线
   

函数

• 默认参数必须在函数的参数列表最右边
  

输入与输出

input()

str = input(tipmsg)

说明：

• str 表示一个字符串类型的变量，input 会将读取到的字符串放入 str 中。遇到回车符，那么一次输入就结束了
  
• tipmsg 表示提示信息，它会显示在控制台上，告诉用户应该输入什么样的内容；如果不写 tipmsg，就不会有任何提示信息。
  

类型转换

我们可以使用 Python 内置函数将字符串转换成想要的类型，比如：

• int(string) 将字符串转换成 int 类型；
  
• float(string) 将字符串转换成 float 类型；
  
• bool(string) 将字符串转换成 bool 类型。
  

也可以使用map进行类型转换，并且可以同时给多个变量赋值

lower,upper = map(int,input().split(" "))

# 将空格作为分割符，分割输入字符串；同时存入map中，类型是int；同时给两个变量赋值

多变量同时赋值

字典、元组、集合、字符串等可迭代对象应该都可以多变量同时赋值

• 字典多变量赋值时，赋予的是key值

a,b={"key1":1,"key2":2}

print(a,b) # key1 key2

a,b=(1,2)

a,b=[1,2]

a,b="12"

a,b={1,2}

print(a,b) # 1 2

print()

defprint(self, *args, sep=' ', end='\n', file=None): # known special case of print

   """

   print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

   

   Prints the values to a stream, or to sys.stdout by default.

   Optional keyword arguments:

   file:  a file-like object (stream); defaults to the current sys.stdout.

   sep:   string inserted between values, default a space.

   end:   string appended after the last value, default a newline.

   flush: whether to forcibly flush the stream.

   """

   pass

数据类型

Python有五个标准的数据类型：

• Numbers（数字）
  
• String（字符串）
  
• List（列表）
  
• Tuple（元组）
  
• Dictionary（字典）
  

字符串String

• python没有char类型，字符即长度为1的字符串
  
• C语言中字符串使用'\0'作为结束符以防止越界，但python中字符串其实是一个固定长度的字符数组，并不需要结束符
  
• 既可以用单引号，也可以用双引号创建字符串
  
• 在三引号字符串中可以包含换行回车等特殊字符

>>>str1 = """

... List of name:

... Hua Li # LiHua

... Chao Deng # DengChao

... """

>>>print(str1)

 

Listofname:

HuaLi# LiHua

ChaoDeng# DengChao

转义字符\

在需要在字符中使用特殊字符时，python 用反斜杠 \ 转义字符。如下表：

字符串运算符

下表实例变量 a 值为字符串 "Hello"，b 变量值为 "Python"：

大小写转换

可以用在当忽略大小写时，全部转换成小写

s.upper() #把所有字符中的小写字母转换成大写字母

s.lower() #把所有字符中的大写字母转换成小写字母

s.capitalize() #把第一个字母转化为大写字母，其余小写

s.title() #把每个单词的第一个字母转化为大写，其余小写

• 复数类型complex：实部和虚部两个部分构成：real+imag（虚部后缀为j或J）
  

运算符

以下假设变量a为10，变量b为21：

取次方

importmath

print"5 的平方 = 5 ** 2 = ", 5**2

print  "5 的平方 = math.pow(5,2) = ", math.pow(5,2)

运算符优先级

算术运算、关系运算、赋值运算

1. 算术运算：加减乘除
   
2. 关系运算：即比较运算
   
3. 赋值运算：=
   

运算符结合性

所谓结合性，就是当一个表达式中出现多个优先级相同的运算符时，先执行哪个运算符：先执行左边的叫左结合性，先执行右边的叫右结合性。

比较运算符是右结合性。如下，输出True：

print(3>2>=2)

逻辑运算符

and 和 or 执行布尔逻辑演算，如你所期待的一样。但是它们并不返回布尔值，而是返回它们实际进行比较的值之一

在布尔环境中，0、”、[]、()、{}、None为假；其它任何东西都为真。但是可以在类中定义特定的方法使得类实例的演算值为假

and找假，or找真

and

>>> 'a' and 'b'

'b'

>>> '' and 'b'

''

>>> 'a' and 'b' and 'c'

'c'

• 找到假值，立即返回
  
• 找不到假值，返回最后一个元素
  

or

>>> 'a' or 'b'

'a'

>>> '' or 'b'

'b'

>>> '' or [] or{}

{}

• 找到真值，立即返回
  
• 找不到真值，返回最后一个元素
  

常用函数

format()

Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

基本语法是通过 {} 和 : 来代替以前的 % 。

format 函数可以接受不限个参数，位置可以不按顺序。

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序

'hello world'

 

>>> "{0} {1}".format("hello", "world")  # 设置指定位置

'hello world'

 

>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置

'world hello world'

数字格式化

{}相当于占位符，可以在里面书写格式控制语句

下表展示了 str.format() 格式化数字的多种方法：

>>> print("{:.2f}".format(3.1415926)) #小数点两位

3.14

^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。

+ 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格

b、d、o、x 分别是二进制、十进制、八进制、十六进制。

实例：将十进制转为二进制

a=5

print("{:0>8b}".format(a))

#00000101

split()

split() 方法：返回分割后的字符串列表

string.split(str="", num=string.count(str)).

• str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
  
• num -- 分割次数。默认为 -1, 即分隔所有。
  

str = "Line1-abcdef \nLine2-abc \nLine4-abcd";

printstr.split( );       # 以空格为分隔符，包含 \n

printstr.split(' ', 1 ); # 以空格为分隔符，分割1次，成为两部分

以上实例输出结果如下：

['Line1-abcdef', 'Line2-abc', 'Line4-abcd']

['Line1-abcdef', '\nLine2-abc \nLine4-abcd']

eval()

eval(<字符串>)能够以Python表达式的方式解析并执行字符串，并将返回结果输出。eval()函数将去掉字符串的两个引号，将其解释为一个变量。

a. 处理数字

单引号，双引号，eval()函数都将其解释为int类型；三引号则解释为str类型。

b.处理字符串类型的字符串

对于eval()括号中的的字符串(非数字)，如果字符串带的是单引号或者是双引号都会引起NameError,这是因为eval()函数在处理字符串时会去掉其两个引号。正确应该使用一个单引号包含一个双引号组成的三引号来包含字符串。

>>>x = 7

>>> eval( '3 * x' )

21

>>> eval('pow(2,2)')

4

>>> eval('2 + 2')

4

>>> n=81

>>> eval("n + 4")

85

接收用户输入的数字

a = eval(input('请输入一个数字：'))

map()

map() 会根据提供的函数对指定序列做映射，返回新的可迭代对象

map(function, iterable, ...)

将function作用在可迭代对象的每一个元素上，结果会添加到新的可迭代对象

>>> def square(x) :         # 计算平方数

...     return x ** 2

...

>>> map(square, [1,2,3,4,5])    # 计算列表各个元素的平方

<map object at 0x100d3d550>     # 返回迭代器

>>> list(map(square, [1,2,3,4,5]))   # 使用 list() 转换为列表

[1, 4, 9, 16, 25]

>>> list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))   # 使用 lambda 匿名函数

[1, 4, 9, 16, 25]

>>>

将list中的string转换为int

results = ['1', '2', '3']

results = list(map(int, results))#map函数将results列表中每个元素转换为int类型，然后再将得到的可迭代对象转换成list

输入列表，求列表元素和

a=list(map(int,eval(input())))

print(sum(a))

将输入3 4 5分别赋给不同的值

m, n, k = map(int, input().split())

range()

Python3 range() 返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表

   """

   range(stop) -> range object

   range(start, stop[, step]) -> range object

   

   Return an object that produces a sequence of integers from start (inclusive)

   to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.

   start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.

   These are exactly the valid indices for a list of 4 elements.

   When step is given, it specifies the increment (or decrement).

   """

常用于for循环控制次数

for i in range(0,10):

   print(i)

列表生成式

>>> range(0,5)      #生成一个range object,而不是[0,1,2,3,4]

range(0, 5)  

>>> c = [i for i in range(0,5)]   #从0 开始到4，不包括5，默认的间隔为1

>>> c

[0, 1, 2, 3, 4]

>>> c = [i for i in range(0,5,2)]   #间隔设为2

>>> c

[0, 2, 4]

list()

将可迭代对象转化成列表

class list(object):

   """

   Built-in mutable sequence. 内置可变序列

   

   If no argument is given, the constructor creates a new empty list.

   The argument must be an iterable if specified.

   空参会构造一个空列表，有参则必须是可迭代对象

   """

可用于将输入进来的字符串转为列表，每个字符是一个元素

s = list(input())

print(s)

123

['1', '2', '3']

join()列表转字符串

用于将序列中的元素以指定的字符连接生成一个新的字符串

   def join(self, ab=None, pq=None, rs=None): # real signature unknown; restored from __doc__

       """

       Concatenate any number of strings.

       

       The string whose method is called is inserted in between each given string.

       The result is returned as a new string.

       

       Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'

       """

       pass

zip()

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

>>>a = [1,2,3]

>>> b = [4,5,6]

>>> c = [4,5,6,7,8]

>>> zipped = zip(a,b)     # 打包为元组的列表

[(1, 4), (2, 5), (3, 6)]

>>> zip(a,c)              # 元素个数与最短的列表一致

[(1, 4), (2, 5), (3, 6)]

>>> zip(*zipped)          # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式

[(1, 2, 3), (4, 5, 6)]

dict()

用于创建一个字典

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

参数说明：

• **kwargs -- 关键字
  
• mapping -- 元素的容器。
  
• iterable -- 可迭代对象。
  

>>>dict()                        # 创建空字典

{}

>>> dict(a='a', b='b', t='t')     # 传入关键字

{'a': 'a', 'b': 'b', 't': 't'}

>>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典

{'three': 3, 'two': 2, 'one': 1}

>>> dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典

{'three': 3, 'two': 2, 'one': 1}

>>>

max()

min()则相反

def max(*args, key=None): # known special case of max

   """

   max(iterable, *[, default=obj, key=func]) -> value

   max(arg1, arg2, *args, *[, key=func]) -> value

   

   With a single iterable argument, return its biggest item. The

   default keyword-only argument specifies an object to return if

   the provided iterable is empty.

   With two or more arguments, return the largest argument.

   

    使用单个可迭代参数，返回其最大的项

    如果提供的可迭代参数为空，则默认关键字参数指定要返回的对象

    对于两个或更多参数，返回最大的参数

   """

   pass

去除字符串空白

replace()

去除字符串中间空白

>>> a = 'hello world'

>>> a.replace(' ', '')

'helloworld'

strip()

去除字符串两端空白

   def strip(self, *args, **kwargs): # real signature unknown

       """

       Return a copy of the string with leading and trailing whitespace removed.

       

       If chars is given and not None, remove characters in chars instead.

       返回字符串的副本，删除前导和尾随空格。

如果给出了char而不是None，则删除char中的字符。

       """

       pass

lstrip：删除左边的空格

rstrip：删除右连的空格

strip：删除两端的空格

str.strip([chars])

其中，str 表示原字符串，[chars] 用来指定要删除的字符，可以同时指定多个，如果不手动指定，则默认会删除空格以及制表符、回车符、换行符等特殊字符。其他两个类似

判断字符串内容类型

1. isdigit

只能识别正整数，无法识别负数和小数

   def isdigit(self, *args, **kwargs): # real signature unknown

       """

       Return True if the string is a digit string, False otherwise.

       

       A string is a digit string if all characters in the string are digits and there

       is at least one character in the string.

       如果字符串是数字字符串则返回True，否则返回False。

如果字符串中的所有字符都是数字，那么该字符串就是数字字符串

字符串中至少有一个字符。

       """

       pass

2. 捕获类型转换异常

不能转换成float的肯定不是数字

s=input()

try:

   s=float(s)

except Exception as e:

   print("Input Error")

3. isalpha

字符串是否是字母

4. isspace

字符串是否是空格

排序

sorted(iterable[, key][, reverse])

list.sort(*, key=None, reverse=None)

#key 是带一个参数的函数，返回一个值用来排序，默认为 None

• key 是带一个参数的函数，返回一个值用来排序，默认为 None
  
• reverse 表示排序结果是否反转
  

sort()

sort() 是Python列表的一个内置的排序方法，list.sort() 方法排序时直接修改原列表，返回None

sorted()（常用）

• sorted() 函数接受一切迭代器，返回新列表
  
• sorted()可以接受排序函数，自定义排序规则
  

1. lambda表达式

解决列表中既有字符又有数字的排序问题

a=['1',1,'a',3,7,'n']

a=sorted(a,key=lambda x:ord(x) if type(x)==str else x)

print(a)

使用lambda+三元表达式

2. 比较函数

比较函数的定义是，传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。

#数值小的优先，即可实现逆序排列

def reversed_cmp(x, y):

   if x > y:

       return -1

   if x < y:

       return 1

   return 0

这样，调用 sorted() 并传入 reversed_cmp 就可以实现倒序排序：

>>> sorted([36, 5, 12, 9, 21], reversed_cmp)

[36, 21, 12, 9, 5]

sorted()也可以对字符串进行排序，字符串默认按照ASCII大小来比较：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'])

['Credit', 'Zoo', 'about', 'bob']

'Zoo'排在'about'之前是因为'Z'的ASCII码比'a'小。

进制转换

python 中，除了十进制整型，其他进制的只能用字符串来表示：

其他进制转为十进制

int()

可以将 二进制，八进制，十六进制转换成十进制整型：

>>>int('1111', 2)

15

>>>int('f', 16)

15

>>>int('17', 8)

15

十进制转为其他进制

hex()

将十进制转换为十六进制：

>>>hex(255)

'0xff'

oct()

将十进制转换为八进制：

>>>oct(255)

'0377'

bin()

将十进制转换为二进制：

>>> bin(255)

'0b11111111'

chr()

character：字符。该方法返回的也是参数对应的字符

python中【chr(i)】函数用来返回整数i所对应的Unicode字符，参数i为整数，取值范围必须在【0 - 1114111(十六进制为0x10FFFF)】之间，否则将引发ValueError错误。 chr(i)函数的作用是返回整数i 所对应的Unicode 字符。

print(chr(65)) #A

print(chr(97)) #a

ord()

ordinal：序号；此方法返回的也是参数对应的序号

ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。

>>>ord('a')

97

>>> ord('b')

98

>>> ord('c')

99

常用模块

math

求对数

• math.log(x) 以e为底的对数(自然对数)
  
• math.log10(x) 以10为底的对数
  
• math.log2(x) 以2为底的对数
  

开平方

sqrt() 方法返回数字x的平方根（浮点型）。sqrt()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法

import math

math.sqrt( 4 ) # 2.0

numpy

import numpy as np

arange()

arange函数用于创建等差数组

np.arange([start, ]stop, [step, ]dtype=None)

start:可忽略不写，默认从0开始;起始值

stop:结束值；生成的元素不包括结束值

step:可忽略不写，默认步长为1；步长

dtype:默认为None，设置显示元素的数据类型

   

nd1 = np.arange(5)#array([0, 1, 2, 3, 4])

nd2 = np.arange(1,5)#array([1, 2, 3, 4])

random()

np.random.randint(low[, high, size]) 返回随机的整数，位于半开区间 [low, high)

>>> np.random.randint(10,size=10)

array([4, 1, 4, 3, 8, 2, 8, 5, 8, 9])

transpose()翻转数组

transpose：转置：一个矩阵M, 把它的第一行变成第一列，第二行变成第二列，......,最末一行变为最末一列

import numpy as np

 

a = np.arange(12).reshape(3,4)

 

print ('原数组：')

print (a )

print ('\n')

 

print ('对换数组：')

print (np.transpose(a))

输出结果如下：

原数组：

[[ 0  1  2  3]

[ 4  5  6  7]

[ 8  9 10 11]]

对换数组：

[[ 0  4  8]

[ 1  5  9]

[ 2  6 10]

[ 3  7 11]]

random

1、random.random

random.random()用于生成一个0到1的随机符点数: 0 <= n < 1.0

2、random.uniform

random.uniform(a, b)，用于生成一个指定范围内的随机符点数，两个参数其中一个是上限，一个是下限。

如果a < b，则生成的随机数n: b>= n >= a。

如果 a >b，则生成的随机数n: a>= n >= b。

print random.uniform(10, 20)

print random.uniform(20, 10)

# 14.73

# 18.579

3、random.randint

random.randint(a, b)，用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，生成的随机数n: a <= n <= b

print random.randint(1, 10)

4、random.randrange

random.randrange([start], stop[, step])，从指定范围内，按指定基数递增的集合中 获取一个随机数。

如：random.randrange(10, 100, 2)，结果相当于从[10, 12, 14, 16, ... 96, 98]序列中获取一个随机数。

5、random.choice

random.choice从序列中获取一个随机元素。其函数原型为：random.choice(sequence)。参数sequence表示一个有序类型。

这里要说明 一下：sequence在python不是一种特定的类型，而是泛指一系列的类型。list, tuple, 字符串都属于sequence。

print random.choice("Python")

print random.choice(["JGood", "is", "a", "handsome", "boy"])

print random.choice(("Tuple", "List", "Dict"))

6、random.shuffle

random.shuffle(x[, random])，用于将一个列表中的元素打乱。

如:

p = ["Python", "is", "powerful", "simple", "and so on..."]

random.shuffle(p)

print p

# ['powerful', 'simple', 'is', 'Python', 'and so on...']

7、random.sample

random.sample(sequence, k)，从指定序列中随机获取指定长度的片断。sample函数不会修改原有序列。

例如：

list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10,11,12]

slice = random.sample(list, 6) # 从list中随机获取6个元素，作为一个片断返回

print slice

print list # 原有序列并没有改变

循环

for……else

1. 当for j in xx时xx中没有数据或依次取完了，就会使用else
   
2. 使用break跳出当前循环，else也同样跳出不会执行
   

==与is的区别

• == 是比较两个对象的内容，不比较地址
  
• is 是比较两个对象的地址
  python中对于None值的比较：使用is
  

使用is注意python对于小整数使用对象池存储问题

使用python命令行时对于小整数[-5,256]区间内的整数，python会创建小整数对象池，这些对象一旦创建，就不会回收，所有新创建的在这个范围的整数都是直接引用他即可。所以造成在[-5,256]区间内的整数不同变量只要值相同，引用地址也相同

python中虽然字符串对象也是不可变对象，但python有个intern机制，简单来说就是维护一个字典，这个字典维护已经创建字符串（key）和它的字符串对象的地址（value），每次创建字符串对象都会和这个字典比较，没有就创建，重复了就用指针引用即可。相当于python对于字符串也是采用了对象池的原理（区别是intern机制中的字典是程序运行中创建并不断添加的，而小整数对象池是运行程序之前就创建好了的）。（特别注意：如果字符串（含有空格），不可修改，没开启intern机制，不共用对象。比如"a b"和"a b",这种情况is是不成立的）

可变对象与不可变对象

• 可变对象：list dict set
  
• 不可变对象：tuple string int float bool
  

可变对象：当前地址的内容可以改变

不可变对象：当前地址的内容不可以改变，如果要改变，需要复制到别的地址再进行改变

由于python规定参数传递都是传递引用，也就是传递给函数的是原变量实际所指向的内存空间，修改的时候就会根据该引用的指向去修改该内存中的内容，所以按道理说我们在函数内改变了传递过来的参数的值的话，原来外部的变量也应该受到影响。但是上面我们说到了python中有可变类型和不可变类型，这样的话，当传过来的是可变类型(list,dict)时，我们在函数内部修改就会影响函数外部的变量。而传入的是不可变类型时在函数内部修改改变量并不会影响函数外部的变量，因为修改的时候会先复制一份再修改。

io操作

1. 以读模式打开文件时，文件指针指向文件开始处
   
2. 文件对象是可以迭代的
   

三元表达式

#如果条件为真，返回真 否则返回假

condition_is_trueifconditionelsecondition_is_false

1. 限制只有最后一个输出才换行

end=" "ifcount!=snelse"\n"

异常处理

try:

<语句>        #运行别的代码

except<名字>：

<语句>        #如果在try部份引发了'name'异常

except<名字>，<数据>:

<语句>        #如果引发了'name'异常，获得附加的数据

else:

<语句>        #如果没有异常发生

使用except而不带任何异常类型

try:

   正常的操作

  ......................

except:

   发生异常，执行这块代码

  ......................

else:

   如果没有异常执行这块代码

以上方式try-except语句捕获所有发生的异常。

序列

序列的类型

1.有三种基本序列类型：list（列表）, tuple（元组） 和 range 对象。

2.为处理 二进制数据 和 文本字符串 而特别定制了附加序列类型

1. 文本序列类型 --- str
   
2. 二进制序列类型 --- bytes, bytearray, memoryview
   

通用序列操作

大多数序列类型，包括可变类型和不可变类型都支持下表中的操作

相同类型的序列也支持比较。 特别地，tuple 和 list 的比较是通过比较对应元素的字典顺序。 这意味着想要比较结果相等，则每个元素比较结果都必须相等，并且两个序列长度必须相同。

列表list

元组tuple

1、使用括弧“0”来创建，例如，a=(1，2，3)；元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用

2、使用逗号来创建，例如，b=2，4；

3、使用 tuple0函数把其他种类的序列转化为元组，例如，c= tuple(“Good!”)。

元组与列表相同，也是容器对象，可以存储不同类型的内容。元组与列表有两个不同点。

1. 元组的声明使用小括号，而列表使用方括号，当声明只有一个元素的元组时，需要在这个元素的后面添加英文逗号；
   
2. 元组声明和赋值后，不能像列表一样添加、删除和修改元素，也就是说元组在程序运行过程中不能被修改。
   

>>> tup1 = (50)

>>> type(tup1)     # 不加逗号，类型为整型

<class 'int'>

>>> tup1 = (50,)

>>> type(tup1)     # 加上逗号，类型为元组

<class 'tuple'>

字典dict

创建字典

1. 直接赋值创建

>>> d={'name':'Allen','age':21,'gender':'male'}

>>> d

{'age': 21, 'name': 'Allen', 'gender': 'male'}

2. 动态分配键值

>>> d={}

>>> d['name']='Allen'

>>> d['age']=21

>>> d['gender']='male'

>>> d

{'age': 21, 'name': 'Allen', 'gender': 'male'}

字典与列表不同，不能通过偏移量进行赋值，只能通过键来读取或赋值，当然访问不存在的键会报错

3. 字典键值表

>>> c = dict(name='Allen', age=14, gender='male')

>>> c

{'gender': 'male', 'name': 'Allen', 'age': 14}

因为这种形式语法简单，不易出错，所以非常流行。

这种形式所需的代码比常量少，但是键必须是字符串，值任意，所以下列代码会报错：

>>> c = dict(name='Allen', age=14, gender='male', 1='abcd')

SyntaxError: keyword can't be an expression

字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

dict的key必须是不可变对象，这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。

要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key

1. 使用for遍历dict，得到的是key

dic={'1':'a','2':'b'}

for i in dic:

   print(i)

#输出

1

2

Python字典包含了以下内置方法：

集合set

集合（set）是一个无序的不重复元素序列。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建：

parame = {value01,value02,...}

或者

set(value)  # value是一个可迭代对象

>>>basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}

>>>print(basket)                      # 这里演示的是去重功能

{'orange', 'banana', 'pear', 'apple'}

>>>'orange'inbasket                 # 快速判断元素是否在集合内

True

>>>'crabgrass'inbasket

False

>>># 下面展示两个集合间的运算.

...

>>>a = set('abracadabra')

>>>b = set('alacazam')

>>>a                                  

{'a', 'r', 'b', 'c', 'd'}

>>>a-b                              # 集合a中包含而集合b中不包含的元素

{'r', 'd', 'b'}

>>>a|b                              # 集合a或b中包含的所有元素

{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}

>>>a&b                              # 集合a和b中都包含了的元素

{'a', 'c'}

>>>a^b                              # 不同时包含于a和b的元素

{'r', 'd', 'b', 'm', 'z', 'l'}

有 2 个集合，分别为 set1={1,2,3} 和 set2={3,4,5}，它们既有相同的元素，也有不同的元素

高级特性

切片Slice

Sequence[start:end:step]python 的序列切片中，第一个:隔离了 起始索引 和 结束索引，第二个:隔离了 结束索引和 步长

• step为正，则从左到右切片，如果 start > end，则为空
  
• step为负，则从右到左切片，如果 start < end，则为空
  
• start 和 end 填空，前者表示最开始，后者表示最后一个, 同时为空的时候，表示取所有。至于方向，取决于 step
  

>>> L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']

1. L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。如果第一个索引是0，还可以省略：L[:3]
   

>>> L[:3]

['Michael', 'Sarah', 'Tracy']

2. 类似的，既然Python支持L[-1]取倒数第一个元素，那么它同样支持倒数切片

>>> L[-2:] #从-2到最后

['Bob', 'Jack']

>>> L[-2:-1] #从-2到-1之前

['Bob']

2. 记住倒数第一个元素的索引是-1。

切片操作十分有用。我们先创建一个0-99的数列：

>>> L = list(range(100))

>>> L

[0, 1, 2, 3, ..., 99]

可以通过切片轻松取出某一段数列。比如前10个数：

>>> L[:10]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

后10个数：

>>> L[-10:]

[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

翻转序列

a='abc'

a=a[::-1] # 此时a='cba'

• 如果开始索引等于结束索引，则切片表达式将返回空字符串
  

迭代

如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代（Iteration）

只要是可迭代对象，无论有无下标，都可以迭代，比如dict就可以迭代：

>>> d = {'a': 1, 'b': 2, 'c': 3}

>>> for key in d:

...     print(key)

...

a

c

b

因为dict的存储不是按照list的方式顺序排列，所以，迭代出的结果顺序很可能不一样。

默认情况下，dict迭代的是key。如果要迭代value，可以用for value in d.values()，如果要同时迭代key和value，可以用for k, v in d.items()。

列表生成式

列表生成式即List Comprehensions，是Python内置的非常简单却强大的可以用来创建list的生成式。

1. list(range(1, 11))
   
2. [x * x for x in range(1, 11)]
   

举个例子，要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]可以用list(range(1, 11))：

>>> list(range(1, 11))

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

但如果要生成[1x1, 2x2, 3x3, ..., 10x10]怎么做？

>>> [x * x for x in range(1, 11)]

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

for循环前面可以对迭代出来的元素进行操作

写列表生成式时，把要生成的元素x * x放到前面，后面跟for循环，就可以把list创建出来

for循环后面还可以加上if判断，这样我们就可以筛选出仅偶数的平方：

>>> [x * x for x in range(1, 11) if x % 2 == 0]

[4, 16, 36, 64, 100]

在一个列表生成式中，for前面的if ... else是表达式，而for后面的if是过滤条件，不能带else。

生成器

列表生成式是直接生成一个列表，而有些时候，我们只是想获取某个结果值，中间内容是不需要的，一边循环一边计算即可，则无需创建完整的list，从而节省大量空间。python中称之为生成器generator

方法一：把一个列表生成式的[]改成()，就创建了一个generator：

>>> L = [x * x for x in range(10)]

>>> L

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> g = (x * x for x in range(10))

>>> g

<generator object <genexpr> at 0x1022ef630>

创建L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。

方法二：如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator

变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

生成器generator，很少用用next()，而是通过for循环来迭代

迭代器

我们已经知道，可以直接作用于for循环的数据类型有以下几种：

1. 一类是集合数据类型，如list、tuple、dict、set、str等；
   
2. 一类是generator，包括生成器和带yield的generator function。
   

这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。

凡是可作用于next()函数的对象都是Iterator（迭代器）类型，它们表示一个惰性计算的序列；

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

Python的for循环本质上就是通过不断调用next()函数实现的

for x in [1, 2, 3, 4, 5]:

   pass

实际上完全等价于：

# 首先获得Iterator对象:

it = iter([1, 2, 3, 4, 5])

# 循环:

while True:

   try:

       # 获得下一个值:

       x = next(it)

   except StopIteration:

       # 遇到StopIteration就退出循环

       break

函数式编程

匿名函数

关键字lambda表示匿名函数，冒号前面的x表示函数参数。

匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

匿名函数lambda x: x * x实际上就是：

def f(x):

   return x * x

pip下载

python扩展库和标准库在使用前都需要导入

标准库是指安装Python就已经安装好了

windows

1. 直接在user目录中创建一个pip目录，如：C:\Users\xxx\pip
   
2. 新建文件pip.ini
   
3. 输入以下内容：
   

[global]

index-url = https://pypi.tuna.tsinghua.edu.cn/simple

linux

1.创建目录

mkdir ~/.pip

2.创建并编辑文件

vim ~/.pip/pip.conf

将文件中的内容填写或者修改为下面的内容：

[global]

index-url = https://pypi.tuna.tsinghua.edu.cn/simple

pep8编码规范

pip install autopep8

tools

去除字符串中的空格及标点符号及全部转为小写

s=list(input().strip())

s_=[]

forcins:

   if (ord(c)>=65)&(ord(c)<=122):

       s_.append(c)

print(''.join(s_).lower())

判断是否回文

1.

s=input()

flag=1

for i in range(0,len(s)):

   if s[i]!=s[-1-i]:

       flag=0

       break

if flag:

   print("%s\nYes"%s)

else:

   print("%s\nNo"%s)

2.

s=input()

if s==s[::-1]:

   print("%s\nYes"%s)

else:

   print("%s\nNo"%s)

水仙花数

一个N位的数

%10得到首位

//10，再%10，得到第二位

//10，……

直到//10结果为0

n=int(input())

if n==3:

   for i in range(100,1000):

       a=int(i/100);b=int(i/10)%10;c=i%10

       if a*a*a+b*b*b+c*c*c==i:

           print(i)

if n==4:

   for i in range(1000,10000):

       a=int(i/1000);b=int(i/100)%10;c=int(i/10)%10;d=i%10

       if a*a*a*a+b*b*b*b+c*c*c*c+d*d*d*d==i:

               print(i)

if n==5:

   for i in range(10000,100000):

       a=int(i/10000);b=int(i/1000)%10;c=int(i/100)%10;d=int(i/10)%10;e=i%10

       if a*a*a*a*a+b*b*b*b*b+c*c*c*c*c+d*d*d*d*d+e*e*e*e*e==i:

               print(i)

质数

质数（Prime number），又称素数，指在大于 1 的自然数中，除了 1 和该数自身外，无法被其他自然数整除的数

求某个范围内的质数

输入一个正整数n(n>=2)，输出所有n位的素数和，如n=2，即输出的是10-99之间的所有素数的和。

1. 枚举法

要进行优化，不然会超时。

判断当前数是否是质数，只需要判断math.sqrt(i)次即可，因为以此为分界，前后因式一样

import math

n=int(input())

x=10**(n-1) #10

y=10**n-1 #99

sum=0

for i in range(x+1,y+1,2):# 11-99,2

   flag = 1

   for j in range(2,int(math.sqrt(i))+1):

       if i%j==0:#不是素数，跳出循环

           flag=0

           break

   if flag==1:

       sum=sum+i

print("{}-{}之间所有的素数和={}".format(x,y,sum))

2. 埃氏筛

因为当前是求某个范围内的素数和，因此用数组不太合适，转而使用字典，键值对这种形式

n = int(input())

x = 10**(n - 1)  # 10

y = 10**n - 1  # 99

sum = 0

# 创建一个存放y个元素的列表，初始值都为1

isPrime = [1] * y

# 埃氏筛，把不大于根号y的所有质数的倍数赋值为0，即非质数。筛选到根号y即可，

for i in range(2, int(y**0.5) + 1):

   if isPrime[i] == 1:

       for j in range(i * i, y, i):# 这里到y-1即可，否则数组下标会越界

           isPrime[j] = 0

for i in range(x, y):# 这里到y-1即可，否则数组下标会越界

   if isPrime[i] == 1:

       sum += i

print("{}-{}之间所有的素数和={}".format(x, y, sum))

求整数进行因式分解

所谓因数分解，是指把一个整数变成其所有质因数相乘的形式

在这里给出函数被调用进行测试的例子。例如：

'''

你写的函数在这里

'''

facs=[]

n=int(input())

factors(n)

result='*'.join(map(str,facs))

if n==eval(result):

   print(n,'='+result)

解答：

不需要判断是否是质数

def factors(n):

   #从2开始查找因数

   for i in range(2,int(n**0.5)+1):

       #找到一个因数

       if n%i==0:

           facs.append(i)

           #继续分解，重复这个过程

           factors(n//i)

           #分解完成跳出循环

           break

       #不可分解了，自身也是个因数

       else:

           facs.append(n)

词云

import jieba.analyse

import matplotlib.pyplot as plt  # 数学绘图模块

from wordcloud import WordCloud  # 词云模块

import PIL.Image as Image ##图像转换模块

import numpy as np

file = "txt/西游记.txt"

topK = 50

content = open(file, 'rb').read()

# withWeight=True：将权重值一起返回

tags = jieba.analyse.extract_tags(content, topK=topK, withWeight=True)

#修改为字典格式

frequencies1 = dict(tags)

# 解决中文乱码

font = r'C:\Windows\Fonts\simfang.ttf'

img=np.array(Image.open(r'img/五瓣花.png'))#词云图样

wordcloud = WordCloud(max_font_size=40, font_path=font,relative_scaling=.5,mask=img).fit_words(frequencies1)

plt.figure()

plt.imshow(wordcloud)

plt.axis("off")

plt.show()