[Python知识库]Python初学小知识（一）

0、其他

• dir(builtins)可以看到python所有内置函数
• 在交互文本中，用Alt+P可以显示上一行代码
• GitHub上有各种资料，可以用awesome+关键词搜索

一、变量

1. 变量名通常由字母、数字、下划线构成，数字不能开头；
2. 赋值时别忘了引号（赋数字不用）；
3. 中文名也能做变量名（不推荐）；
4. python在互换x,y时，可以不用z：

x = 3
y = 5
x,y = y,x
print(x,y) 
#最终结果：5,3

二、字符串

1. python用字符串来表示文本；
2. 单引号、双引号都可，但要确保两边的引号成对；
3. 但是，当要打印的句子同时需要显示单、双引号，需用转义字符来实现：

print('\"Let\'s happy\"')  
'''两边的单引号也可以改成双引号，此时已不受影响;
两边的反斜杠也可以删掉'"Let\'s happy"'（不过删掉后，显而易见，两边就必须是单引号了）'''
#输出为"Let's happy"

4. 转义字符：
   
5. 如果需要输出\，也一样用\转义；但是当\太多时，可以在引号前加上r，表示原始输出字符串：

print(r'D:\my\page\one')  
#输出为D:\my\page\one

但是 r 表示法不能表示多行字符串，也不能表示包含 ’ 和 " 的字符串。如果要表示多行字符串，可以用三个单引号表示：

'''Line 1
Line 2
Line 3'''
#上面这个字符串的表示方法和下面的是完全一样的：

'Line 1\nLine 2\nLine 3'

#还可以在多行字符串前面添加r，把这个多行字符串也变成一个raw字符串：

r'''Python is created by "Guido".
It is free and easy to learn.
Let's start learn Python in imooc!'''

6. 在输出末端加上\，表示这件事还没完，可以换行：

print("
ab\n\
   fsd\n\
gsd\n")  #最后一行结束了，可以换行
#输出为：

ab
   fsd
gsd

7. 用三引号可以更简便地实现上面的效果：

word = '''
ab\n\
   fsd\n\
gsd\n'''
print(word)
#输出为：

ab
   fsd
gsd

但是三引号有注释的作用，不要搞混

8. 字符串的相加叫做拼接，同样可以相乘复制

三、一些简单代码

1. input返回的是字符串，如果要和数字毕竟，需要int()；
2. 在判断语句中，is：判断两个对象的id是否相等；is not：判断两个对象的id是否不相等；
3. Ctrl+C：打断运行；
4. 循环：
   
   break：跳出当前循环
5. random产生伪随机数（真正的随机数只有等到量子计算机诞生的那一天才能实现，只有利用量子纠缠才能够产生真正的随机数）

import random 

random.randint(a,b)  #随机获取一个属于[a,b]的整数
x = random.getstate() #获取随机数生成之后随机数的内部状态
random.setstate(x)     #重新设置随机数生成器的内部状态

四、数字类型

1. 两个整数相除是浮点数，用round()保留小数位数：

>>> num = 10 / 3
>>> num
3.3333333333333335
>>> round(num, 2)   # 使用round保留两位小数
3.33

3. python表示浮点数会有一定程度的误差，所以可以用decimal（十进制）模块：

import decimal

a = decimal.Decimal('0.1')
b = decimal.Decimal('0.2')
print(a+b)  #结果为精确的0.3

4. E记法（科学计数法），用来表示一些比较极端的数，比如说用5e-05表示0.00005；
5. 复数都是用浮点数表示的，如：

x = 1 + 2j
x.real    #获取实部：1.0
x.imag  #获取虚部：2.0

6. 数值运算：

x // y                     #地板除向下取整:-3//2=-2
x % y                       #x除以y的余数
-x                           #x的相反数
+x                           #x本身
abs(x)                   #x的绝对值，复数返回模
int(x)                   #将x转换成整数（字符串、浮点数），对浮点数取整是去尾
float(x)               #将x转换成浮点数（字符串、整数）
                              #int()、float()内如果是字符串，则字符串不能带有空格
complex(re，im)  #返回一个复数,re是实部，im是虚部
c .conjugate()    #返回c的共辄复数
divmod(x，y)       #返回(x // y, x % y), x == (x // y) * y + (x % y)
                             #divmod(-3,2) = (-2,1)
pow(x, y)             #计算x的y次方
x ** y                   #计算x的y次方c
                             #上面两个的差别是，pow()可以加入第三个参数：pow(a, b, c)表示a ** b % c

7. 用==type()==得到数字类型

五、布尔类型、短路逻辑、优先运算

1. 使用bool()内置函数可以直接给出Ture或False的结果：

bool("False")  #结果是True，对于字符串来说，只有空字符串结果是False
bool(1)             #数字一般是True，0、0.0、0j表示零，是False

其中Fraction(0,1)表示 $\frac{0}{1}$

2. 布尔类型用来判断条件的结果
3. 注意：

>>> 2 == True
False
>>> 1 == True
True
>>> bool(2)
True
>>> True - False
1                            #当True和False用在计算中，就是1，0

4. and、or、not与或非，对于and和or，计算结果不一定是True、False，取决于它的操作数（python中任何对象都可以支持真值测试）：

>>> 3 < 4 and 4 > 5
False                      #相当于True and False，结果是False
>>> 0 and 1
0                           #第一个就是False，不用计算后面的了
>>> 0 or 1
1
>>> 'boy' and 'girl'
'girl'
>>> 'girl' and 'boy'
'boy'
>>> "A" and 2
2
>>> 2 and 'A'
'A'                        #and运算要一直计算到最后，所以取最后值
>>> "A" or 2
'A'
>>> 2 or "A"
2                             #or运算如果第一个值为True，则放弃计算后值，节约计算量
>>> 3 and 4
4                             #两边都是True，道理同上，直接用最后一个
>>> 4 or 3
4

从上面的例子也可以看出，and和or都遵从短路逻辑：从左往右，只有当第一个操作数的值无法确定逻辑运算的结果时，才对第二个操作数进行求值；
从python的角度来看，根本没有必要把最终的测试结果判断完再汇报，更高效率的方法是直接把影响结果的关键值扔出来。

5. 对于not，计算结果一定是True、False

>>> not True
False
>>> not False
True
>>> not 2
False
>>> not 0
True

6. 运算符优先级（从上往下越高，最下面的优先级最高）：
   

六、分支、循环

1. if … elif … elif … (else) …
2. 一种不常用的：条件成立时执行的语句 if condition else 条件不成立时执行的语句：

>>>age = 16
>>>if age < 18:
    	print("no")
else:
    	print("yes")
no

改为：

>>>age = 16
>>>print("no") if age < 18 else print("yes")
no

优势是将四行语句转换成了一行：

#分数分级
>>> score = 66
>>> level = ("D" if 0 <= score < 60 else
	     "C" if 60 <= score < 80 else
	     "B" if 80 <= score < 90 else
	     "A" if 90 <= score < 100 else
	     "S" if score == 100 else
	     '请输入0~100之间的分值')
>>> print(level)
C

3. break退出循环体，再也不会回来；continue跳出本轮循环，之后还会再回来。else同样可以用在循环中：

i = 1
while i < 5:
    print("循环内的i是：",i)
    i += 1
else:  
    print("循环外的i是：",i)

当循环内的条件不为真时，执行else语句；若使用break语句，循环内的条件依旧为真，else语句不执行。else语句可以非常方便地检测循环体的退出情况：

#7天坚持学习打卡小程序
day = 1
while day <= 7:
    answer = input("今天有好好学习吗？")
    if answer == "有":
        day += 1
    else:
        print("你已经连续学习了",day-1,"天")
        print("你第",day,"天没有好好学习")
        break
else:
    print("你已经学习了7天")

'''
结果：
今天有好好学习吗？有
今天有好好学习吗？有
今天有好好学习吗？有
今天有好好学习吗？没有
你已经连续学习了 3 天
你第 4 天没有好好学习'''

4. 循环的嵌套

#打印九九乘法表
i = 1
while i <= 9:
    j = 1
    while j <= i:
        print(j,'×',i,'=',j*i,end=' ')  #end=' '的作用是使print打印出的为横排
        j += 1
    else:
        print()  #起到换行的作用，如果用'\n'，会空一行
    i += 1
    
'''结果：
1 × 1 = 1 
1 × 2 = 2 2 × 2 = 4 
1 × 3 = 3 2 × 3 = 6 3 × 3 = 9 
1 × 4 = 4 2 × 4 = 8 3 × 4 = 12 4 × 4 = 16 
1 × 5 = 5 2 × 5 = 10 3 × 5 = 15 4 × 5 = 20 5 × 5 = 25 
1 × 6 = 6 2 × 6 = 12 3 × 6 = 18 4 × 6 = 24 5 × 6 = 30 6 × 6 = 36 
1 × 7 = 7 2 × 7 = 14 3 × 7 = 21 4 × 7 = 28 5 × 7 = 35 6 × 7 = 42 7 × 7 = 49 
1 × 8 = 8 2 × 8 = 16 3 × 8 = 24 4 × 8 = 32 5 × 8 = 40 6 × 8 = 48 7 × 8 = 56 8 × 8 = 64 
1 × 9 = 9 2 × 9 = 18 3 × 9 = 27 4 × 9 = 36 5 × 9 = 45 6 × 9 = 54 7 × 9 = 63 8 × 9 = 72 9 × 9 = 81 
'''

5. for循环：
   

for i in "abcd":
	print(i)

	
a
b
c
d

错误用法：

>>> sum = 0
>>> for i in 100:
	sum += i

	
Traceback (most recent call last):
  File "<pyshell#47>", line 1, in <module>
    for i in 100:
TypeError: 'int' object is not iterable

100并不是可迭代序列，这里使用range：

>>> for i in range(4): #从0到4-1的整数序列
	print(i)

0
1
2
3

>>> for i in range(1,4): #从1到4-1的整数序列
	print(i)

	
1
2
3

>>> for i in range(5,10,2):
	print(i)

	
5
7
9
>>> for i in range(10,5,-2):
	print(i)

	
10
8
6

七、列表List

1. 列表同时包含多种数据类型，下标索引从0开始，最后一个元素的下标索引值是-1，以此类推，倒数第二个是-2：

>>> word = [10,5,'you',0.1]
>>> for i in word:
	print(i)

10
5
you
0.1
>>> word[1]
5
>>> word[-2]
'you'

2. 列表切片，打印的是下标对应的值，不包括最后一个

>>> word[1:3]  
[5, 'you']
>>> word[:2]  #从头开始没必要把头写进去
[10, 5]
>>> word[2:]  #一直到结尾没必要把尾写进去
['you', 0.1]
>>> word[:]
[10, 5, 'you', 0.1]
>>> word[0:4:2]  #跨进
[10, 'you']
>>> word[::2]  #跨进
[10, 'you']
>>> word[::-1]  #倒序输出
[0.1, 'you', 5, 10]

3. 列表的增删改查
   3.1 增

'''append与extend'''
>>> heros = ['钢铁侠','绿巨人']
>>> heros.append('黑寡妇')  #只能添加一个对象
>>> heros
['钢铁侠', '绿巨人', '黑寡妇']
>>> heros.extend(['鹰眼','灭霸','雷神'])  #添加可迭代对象
>>> heros
['钢铁侠', '绿巨人', '黑寡妇', '鹰眼', '灭霸', '雷神']

'''还可以使用切片的方式增加'''
>>> s = [1,'a',2,'d']
>>> s[len(s):] = [4,'add']
>>> s
[1, 'a', 2, 'd', 4, 'add']
>>> s[1:3] = [344,87]  #用切片替换了原有的s[1:3]
>>> s
[1, 344, 87, 'd', 4, 'add']

'''在指定位置insert插入'''
>>> s.insert(1,'boy')  #insert(位置,元素)
>>> s
[1, 'boy', 344, 87, 'd', 4, 'add']

3.2 删

'''remove删除指定元素：如果列表中存在多个匹配的元素，只会删除第一个'''
>>> heros = ['钢铁侠', '绿巨人', '黑寡妇', '鹰眼', '灭霸', '雷神']
>>> heros.remove('灭霸')
>>> heros
['钢铁侠', '绿巨人', '黑寡妇', '鹰眼', '雷神']

'''pop(下标)删除指定位置的元素'''
>>> heros.pop(2)
'黑寡妇'
>>> heros
['钢铁侠', '绿巨人', '鹰眼', '雷神']

'''clear()清空列表'''
>>> heros.clear()
>>> heros
[]

3.3 改

>>> heros = ['钢铁侠', '绿巨人', '黑寡妇', '鹰眼', '灭霸', '雷神']
>>> heros[4] = '钢铁侠'
>>> heros
['钢铁侠', '绿巨人', '黑寡妇', '鹰眼', '钢铁侠', '雷神']
>>> heros[3:] = ['武松','林冲','李逵']
>>> heros
['钢铁侠', '绿巨人', '黑寡妇', '武松', '林冲', '李逵']

'''sort()从小到大排序，sort(key=None, reverse=False)，key用于指定一个比较的函数，reverse用于指定排序结果是否反转'''
>>> num = [3,2,6,3,8,9,6,4,1,55]
>>> num.sort()
>>> num
[1, 2, 3, 3, 4, 6, 6, 8, 9, 55]

'''reverse()从大到小排序'''
>>> num.reverse()
>>> num
[55, 9, 8, 6, 6, 4, 3, 3, 2, 1]
#但是，如果是初始的num列表，结果是这样：
>>> num = [3,2,6,3,8,9,6,4,1,55]
>>> num.reverse()
>>> num
[55, 1, 4, 6, 9, 8, 3, 6, 2, 3]
#reverse()其实是原地反转函数，并不是真的从大到小排序，所以包含字符串的列表也可以用reverse：
>>> heros.reverse()
>>> heros
['李逵', '林冲', '武松', '黑寡妇', '绿巨人', '钢铁侠']

3.4 查

'''count()查找列表中某个元素出现的次数（包括数字、字符串）'''
>>> num = [3,2,6,3,8,9,6,4,1,55]
>>> num.count(3)  
2
>>> heros = ['钢铁侠', '绿巨人', '黑寡妇', '鹰眼', '钢铁侠', '雷神']
>>> heros.count('钢铁侠')   
2

'''index(x, start, end)查找元素索引值'''
>>> heros.index('钢铁侠')
0  #有多个元素的，只出现第一个元素的索引值
>>> heros.index('绿巨人')
1
>>> heros[heros.index('钢铁侠')] = '神奇女侠'
>>> heros
['神奇女侠', '绿巨人', '黑寡妇', '鹰眼', '钢铁侠', '雷神']
#通过利用索引值替换元素，有多个元素时，只操作第一个
>>> num.index(3,1,20)  #end超出了列表长度也没关系
3

'''copy()拷贝列表'''
>>> num_copy1 = num.copy()
>>> num_copy1
[3, 2, 6, 3, 8, 9, 6, 4, 1, 55]
>>> num.pop(-1)
55
>>> num
[3, 2, 6, 3, 8, 9, 6, 4, 1]
>>> num_copy1
[3, 2, 6, 3, 8, 9, 6, 4, 1, 55]
>>> num_copy2 = num[:]
>>> num_copy2
[3, 2, 6, 3, 8, 9, 6, 4, 1]
>>> 

4. 列表的加法和乘法

>>> s = [1,2,3]
>>> t = [4,5,6]
>>> s + t  #加法是拼接
[1, 2, 3, 4, 5, 6]
>>> s * 3  #乘法是重复
[1, 2, 3, 1, 2, 3, 1, 2, 3]

5. 列表的嵌套

>>> matrix = [[1,2,3],[4,5,6],[7,8,9]]
>>> matrix = [[1,2,3],
	      [4,5,6],
	      [7,8,9]]
>>> matrix
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

'''访问嵌套列表：'''
>>> for i in matrix:
			for j in i:
				print(j,end='')
			print()

123
456
789

>>> for i in matrix:
			for j in i:
				print(j,end=' ')  #end=''的单引号中间如果加了空格，那么打印出来的才会有空格
			print()
	
1 2 3 
4 5 6 
7 8 9 

>>> matrix[0]  #下标访问嵌套列表
[1, 2, 3]
>>> matrix[0][0]
1

>>> A = [0] * 4
>>> for i in range(2):
			A[i] = [1] * 2
	
>>> A
[[1, 1], [1, 1], 0, 0]

6. python对于不同的对象，存储机制是不一样的：

>>> x = 'abc'
>>> y = 'abc'
>>> x is y
True   #字符串可以相等
>>> x = [1,2,3]
>>> y = [1,2,3]
>>> x is y
False  #列表就不行

python中的赋值并不是放入一个盒子中，而是引用，如果我们改变上面的x，则y也会跟着改变；如果想得到两个独立的列表，应该用拷贝。

7. 拷贝分为浅拷贝和深拷贝：

'''浅拷贝就是copy或者切片'''
#copy
>>> x = [1,2,3]
>>> y = x.copy()
>>> x[1] = 1
>>> x
[1, 1, 3]
>>> y
[1, 2, 3]
#切片
>>> x = [1,2,3]
>>> y = x[:]
>>> x[1] = 1
>>> x
[1, 1, 3]
>>> y
[1, 2, 3]

但是浅拷贝无法作用在嵌套列表上：

>>> x = [[1,2,3],[4,5,6],[7,8,9]]
>>> y = x.copy()
>>> x[1][1] = 0
>>> x
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
>>> y
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]  

copy之后，改变了x里面的内容，y一样改变，因为浅拷贝只是拷贝了外层的对象。
于是使用深拷贝来解决这个问题：

>>> import copy
>>> x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> y = copy.copy(x)  #前一个copy表示copy模块，后一个copy表示copy函数
>>> x[1][1] = 0
>>> x
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
>>> y
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]  #以上的还是浅拷贝

'''深拷贝deepcopy'''
>>> x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> y = copy.deepcopy(x)
>>> x[1][1] = 0
>>> x
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
>>> y
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

但是还是用浅拷贝更多，因为效率更高。

8. 列表推导式： [expression for target in intrable]

如果想把列表中的元素×2，怎么做？

>>> x = [1,2,3,4,5]
>>> for i in range(len(x)):
	x[i] = x[i] * 2

	
>>> x
[2, 4, 6, 8, 10]

如果用列表推导式：

>>> x = [1,2,3,4,5]
>>> x = [i * 2 for i in x]
>>> x
[2, 4, 6, 8, 10]

通常列表推导式的效率比循环语句要快上一倍左右：因为列表推导式在python中是用C语言执行的，比使用python脚本的虚拟机pym里面以步进的速度来运行for循环要快得多。

8.1 列表推导式： [expression for target in intrable]

>>> x = [i for i in range(10)]
>>> x
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
#把i换成i+1就可以得到1到10

'''字符串同理'''
>>> y = [i * 2 for i in 'nxy']
>>> y
['nn', 'xx', 'yy']

'''把字符转换成对应的Unicode编码'''
>>> code = [ord(i) for i in 'nxy']
>>> code
[110, 120, 121]

'''提取二维列表某一列的元素'''
>>> matrix = [[1,2,3],
	      [4,5,6],
	      [7,8,9]]
>>> col2 = [row[1] for row in matrix]  #提取第二列
#通过row语句提取matrix里面的每一行，存放的是row[1]
>>> col2
[2, 5, 8]

'''获取主对角线元素'''
>>> diag = [matrix[i][i] for i in range(len(matrix))]  #获取i是1，2，3
>>> diag
[1, 5, 9]
如果是右对角线？

循环是通过迭代来修改原列表中的元素，而列表推导式是直接创建一个新的列表然后赋值为原先的变量名。
利用循环来创建一个嵌套列表：

>>> for i in range(3):
	A[i] = [1] * 2
	
>>> A
[[1, 1], [1, 1], [1, 1]]
>>> A[0][1] = 0
>>> A
[[1, 0], [1, 1], [1, 1]]

利用列表推导式来创建一个嵌套列表：

>>> S = [[1] * 2 for i in range(3)]
>>> S
[[1, 1], [1, 1], [1, 1]]
>>> S[0][1] = 0
>>> S
[[1, 0], [1, 1], [1, 1]]

8.2 添加用于筛选的if分句：[expression for target in intrable if condition]

>>> even = [i for i in range(10) if i % 2 == 0]
>>> even
[0, 2, 4, 6, 8]
>>> even = [i + 1 for i in range(10) if i % 2 == 0]
>>> even
[1, 3, 5, 7, 9]  #把上面的结果都+1→i+1
'''先执行for语句，再执行if语句，最后才是左侧的表达式'''

>>> word = ['agg', 'boy', 'cat', 'dog', 'apple', 'and']
>>> a_in = [i for i in word if 'a' in i]
>>> a_in
['agg', 'cat', 'apple', 'and']  #含有a的单词
>>> a_begin = [i for i in word if 'a' in i[0]]
>>> a_begin
['agg', 'apple', 'and']  #a开头的单词，也可以if 'a' == i[0]

8.3 列表推导式还可以用来嵌套：
[expression for target1 in intrable1
for target2 in intrable2
……
for targetN in intrableN]
嵌套的外层循环放前面。

>>> matrix = [[1,2,3], [4,5,6], [7,8,9]]
>>> fold = []
>>> for a in matrix:  #取出来matrix里面的元素，即[1,2,3], [4,5,6], [7,8,9]
			for b in a:
				fold.append(b)
				print(fold)

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

8.4 最后发展出的终极语法：
[expression for target1 in intrable1 if condition1
for target2 in intrable2 if condition2
……
for targetN in intrableN if conditionN]**

>>> [[x,y] for x in range(6) if x % 2 == 0 for y in range(9) if y % 3 == 0]
[[0, 0], [0, 3], [0, 6], [2, 0], [2, 3], [2, 6], [4, 0], [4, 3], [4, 6]]

但是不必为了炫耀搞得过于复杂