1.交换两个变量的值
（1）temp = x x =y y = temp
（2）x,y = y,x
-
字符串可以用“ ”也可以用‘ ’
例如：“abcasdasd’asdsad’asd’asd”
‘asdasdasd""asdasdasdsad’
3.转义字符
\b 退格
\n 换行
\t 制表
\r 回车
\
" "
’ ’
4.想要打印print(“D:\t\n\r\now”)
（1）使用转义字符，转义
print(“D:\t\n\r\now”)
（2）使用原始字符串（转义字符不再有效）
print(r"D:\t\n\r\now")ps： print（）方法中 end 参数默认为"\n"换行，改变end参数的值就不会换行了
5.print()中想要跨多行显示
（1）在字符串末尾加\（表示这事还没完）
print(“你好呀\n
哈哈哈
嘿嘿嘿”)
（2）使用长字符串（长字符串就是为了实现跨行字符串）
“”" 哈哈哈哈
啦啦啦啦
嘿嘿嘿嘿"""
‘’’ 哈哈哈哈
啦啦啦啦
嘿嘿嘿嘿’’’
6.字符串加法等于拼接 字符串乘法等于复制 字符串也支持切片
“520”+“1314” “520” * 3000 “abcd”[1:]
“5201314” 3000个520 “bcd”
7.input（）用于接受用户的输入并且返回一个字符串类型，参数是一个字符串，即显示在屏幕上用于跟用户交互的文本内容
例如：temp = input（“输入一个数字：”）
8.int（）用于将一个字符串或数字转换为整型
9. #单行注释 ，""" “”" /’’’ ‘’’（长字符串） 多行注释
10.若想使用python模块，必须将其导入，import 模块名
例如：import random
random.randint（a，b） 获取一个a-b范围内的随机数（包括a和b）
11.python有三种不同的数字类型
（1）整数 python的整数长度是不受限制的，即有无限大的精度
（2）浮点数 python的浮点数具有误差 0.3 < 0.1 + 0.2
如何精确计算？
【1】导入decimal模块
import decimal
【2】实例化 decimal.Deciaml 的对象（可以传递给Decimal整型或者字符串参数，但不能是浮点数据，因为浮点数据本身就不准确）
a = decimal.Decimal（‘0.1’）
b = decimal.Deciaml（‘0.2’）
【3】计算即可得到精确的答案
print（a + b）
e-05 表示 10^-5
例如：5e-05 表示 5*10^-5
（3）复数 包含实部和虚部，实部和虚部都是以浮点数形式存放的
例如：x = 1+2j（1是实部，2是虚部）
x.real来获取实部1.0；x.imag来获取虚部2.0
12.python支持的数字运算
（1）x+y x-y xy
（2）x/y 结果是浮点数 例如：3/2 = 1.5
（3）x//y（地板除） 结果向下（小的）取整 例如：3//2 = 1 -3//2 = -2
（4）x%y 取余 例如：3%2=1
（5）-x x的相反数
（6）+x x本身
内置函数：
（7）abs（x） 返回x的绝对值，若传入复数（a+bj）则返回复数的模（根下(a2+b2)）
（8）int（x） 将x转换为整数
（9）float（x） 将x转换为浮点数，也可以传入科学计数法 例如：5e2（5102）5e-2（5*10-2） -5e2（-510^2） -5e-2（-510^-2）
（10）complex（re，im） 返回一个复数，re是实部，im是虚部
（11）divmod（x，y） 返回（x//y，x%y） ps：x = x//y * y + x%y
（12）pow（x，y） 计算x的y次方
pow（x，y，z） 计算x的y次方再%z
（13）x**y 计算x的y次方
13.布尔类型
bool（） 直接返回true或false
例如： 字符串：
bool（""） 返回False，只有空字符串返回False
bool（" "） 返回True
bool（“哈哈”） 返回True
数值：
bool（0） 返回False，只有数值为0返回False
bool（0.0） 返回False
bool（0j） 返回False
bool（50） 返回True
bool（250） 返回True
bool（None） 返回False
bool（False） 返回False
空的序列和集合也为False
1 == True
0 == False
True + False = 1 True - False = 1 True * Flase = 0 False / True = 0
14.逻辑运算符
优先级：* / % //>+ -> 比较运算符 >not>and>or
（1）and 短路逻辑 3 and 4 == 4 0 and 3 ==0
（2）or 短路逻辑 3 or 4 == 3 0 or 4 == 4
例如：（not 1）or （0 and 1）or （3 and 4）or（5 and 6）or （7 and 8 and 9） == 4
false or 0 or 4 or 6 or 9 == 4
not 1 or 0 and 1 or 3 and 4 or 5 and 6 or 7 and 8 and 9 == 4
false or 0 or 4 or 6 or 9 == 4
（3）not
15.分支结构
（1）if 条件1：
语句1
elif 条件2:
语句2
elif 条件3:
语句3
else:
语句4
（2）条件表达式（三目运算符）
条件成立执行的语句 if 条件 else 条件不成立执行的语句
例如： a = 3 ; b=5
small = a if a<b else b
ps: 若一行代码要横跨数行 解决方法（1）每行末尾加\ （2）用( )包裹代码
level = ('D' if score>=0 and score<60 else
'C' if score>=60 and score<80 else
'B' if score>=80 and score<90 else
'A' if score>=90 and score<100 else
'S' if score ==100 else
"不合法")
level = 'D' if score>=0 and score<60 else \
'C' if score>=60 and score<80 else \
'B' if score>=80 and score<90 else \
'A' if score>=90 and score<100 else \
'S' if score ==100 else \
"不合法"
16.循环结构
（1）while 条件:
语句
else：
当while循环完整执行完后（中途break不算完整执行）会执行else当中的语句
ps：break用于跳出循环
continue用于跳过本次循环
他俩只能作用于一层循环
（2）for 变量 in 可迭代对象：
语句
else：
当 for 循环完整执行完（中途break不算完整执行），才会运行 else 语句。
例如：
for x in "FishC":
print(x)
ps： len（x） 用于获取对象的长度 len（"Fishc"）==5
range（） 用于生成一个数字序列
range(stop) 生成从0到stop-1的整数序列
range(start,stop) 生成从start到stop-1的整数序列
range(start,stop,step) 生成从start到stop-1的整数序列，步长为step（step可以为负数）
例如： for i in range(10,5,-1):
print(i)
参数均为整型
17.列表
（1）创建列表（可以容纳不同类型的数据）
item = [1,2,3,“zrf”,0.9,5e2,1+2j]
（2）访问列表
item[下标]
下标从0–len-1
（3）遍历列表
for x in item:
print(x)
或者
for i in range( 0 , len( item ) ):
print(item[i])
（4）列表切片（是一个新的对象，而非修改对象本身）
item[0 ：3] 获取下标为0-2的元素
item[3 ：6] 获取下标为3-5的元素
item[ ：3] 获取下标为0-2的元素
item[3 ： ] 获取下标为3-最后一个元素
item[ ： ] 获取第一个元素-最后一个元素
item[0：6：2] 获取0-5范围内步长为2的元素
item[ ：: -1] 获取从最后一个元素-第一个元素（倒序输出）
18.列表的方法
增：
（1）append（obj）方法（在列表末尾来添加一个指定的元素）
例如：items = [“钢铁侠”，“绿巨人”]
items.append(”黑寡妇“)
（2）extend（）方法（允许直接添加一个可迭代对象）
例如：items = [“钢铁侠”，“绿巨人”]
temp = [”灭霸“，“鹰眼”，“雷神”]
items.extend(temp)
等价于
items[len(items)：] = ["美队"]
items[len(items)：] = ["奇异博士"，"惊奇队长"，"蜘蛛侠"]
（3）insert(pos,ele) 方法（在pos位置插入ele元素）
例如：items = [1，3，4，5]
items.insert(1，2) // 在下标1处插入元素2
删：
（1）remove（obj）方法（将指定的元素删除）
例如：items.remove(“灭霸”)
ps：如果列表中存在多个匹配的元素，只会删除第一个元素
如果指定的元素不存在，则程序会报错
（2）pop（index）方法（删除指定下标的元素）
例如：items.pop(2)
（3）clear（）方法（清空整个列表）
例如：items.clear()
改：
（1）替换单个元素（使用下标赋值即可）
例如：items[3] = "章鱼博士"
（2）替换多个连续元素（使用切片）
例如：items[3：] = [“武松”，“林冲”，“李逵”]
下标从3到最后的元素替换为“武松”，“林冲”，“李逵”
排序：
（1）sort（）方法（列表元素从小到大排序）
sort（比较函数，指定排序结果是否反转 默认Flase）（自定义排序方式）
例如：items.sort（）
items.sort（reverse=True）
*key参数的值为一个函数，函数的参数就是列表中的每个元素，它在每个元素比较前对这个元素进行处理并且返回一个值用来进行比较（很快）
list1 = [[3,1],[5,3],[8,0],[0,4],[3,3],[7,5],[6,8]]
list1.sort(key = lambda x : x[0]) //按照每个子列表中第一个元素升序排序 [[0, 4], [3, 1], [3, 3], [5, 3], [6, 8], [7, 5], [8, 0]]
list1.sort(key = lambda x : x[1],reverse = True) //按照每个子列表中第二个元素降序排序 [[6, 8], [7, 5], [0, 4], [5, 3], [3, 3], [3, 1], [8, 0]]
*使用比较函数（类似java）
import functools //需要使用该模块的cmp_to_key()方法 将cmp函数转换为key
list1 = [[3,1],[5,3],[8,0],[0,4],[3,3],[7,5],[6,8]]
list1.sort(key = functools.cmp_to_key(lambda x1,x2 : x2[1] - x1[1])) //按照每个子列表中第二个元素降序排序 [[6, 8], [7, 5], [0, 4], [5, 3], [3, 3], [3, 1], [8, 0]]
反转：
（1）reverse（）方法（反转列表里的元素）
例如：items.reverse（）
查：
（1）count（x）方法（返回x元素出现的次数）
例如：items.count（3）
（2）index（x）方法（返回第一个x元素的下标）
例如：items.index（“绿巨人”）
items[items.index("绿巨人")]=“神奇女侠”
拷贝（浅拷贝）：得到两个独立的列表
（1）列表的copy（）方法
item = items.copy（）
（2）item = items[:]
19.列表的加法（拼接）
例如：s = [1，2，3]
t = [4，5，6]
s+t（[1，2，3，4，5，6]）
20.列表的乘法（重复列表内的所有元素若干次）
例如：s = [1，2，3]
s*3（[1，2，3，1，2，3，1，2，3]）
s[0] is s[3]（True）
s[1] is s[4]（True）
t = [[0,0,0]]
t*3（[[0, 0, 0], [0, 0, 0], [0, 0, 0]]）
t[0] is t[1]（True）
t[1] is t[2]（True）
.*：实际上拷贝了外层的对象，对于二维列表只是拷贝了其引用，本质其实使用的浅拷贝
21.嵌套列表（二维列表）
例如：items = [[1，2，3]，[4，5，6]，[7，8，9]]
22.访问嵌套列表
（1）for i in items：
for j in i：
print（ j ，end=“ ”)
print（）
（2）for i in range(0,len(items)):
for j in range(0,len(items[i])):
print(items[i][j]，end=“ ”)
print（）
23.循环创建二维列表
A = [0]*3 （A =[0,0,0]）
for i in range(0,3)：
A[i] =[0]*3
24. is运算符（用于检验两个变量是否指向同一对象即两个变量的地址是否相同）
例如：x = “FishC”
y = “FishC”
x is y （True）
*：由于字符串是不可变的，所以只需要在内存中开辟一块空间来存放就可以了
x = [1,2,3]
y = [1,2,3]
x is y（False）
25.浅拷贝与深拷贝
（1）浅拷贝（只是拷贝了外层的对象，对于二维列表只是拷贝了其引用）
x = [1][2][3]
|
/
y = [1][2][3]
x = [ ] [ ] [ ]
| | |
\/ \/ \/
[1][2] [3][4] [5][6]
/\ /\ /\
| | |
y = [ ] [ ] [ ]
（2）深拷贝（需要借助copy模块）
import copy //copy模块的copy()实现浅拷贝
x = [[1,2,3],[4,5,6],[7,8,9]]
y = copy.copy(x) //copy模块的copy()方法
import copy //copy模块的deepcopy()实现深拷贝
x = [[1,2,3],[4,5,6],[7,8,9]]
y = copy.deepcopy(x) //copy模块的deepcopy()方法
.*：deepcopy()在将外层对象拷贝的同时，也将外层对象中所有引用的子对象一并进行了拷贝
x = [ ] [ ] [ ]
| | |
\/ \/ \/
[1][2] [3][4] [5][6]
y = [ ] [ ] [ ]
| | |
\/ \/ \/
[1][2] [3][4] [5][6]
26.列表推导式
结果一定是一个列表 相当于循环体，用来最终确定存放在列表中的数据 列表推导式的结果列表是使用一组数据来填充的 用于筛选条件
| | | |
[ 表达式 for target in 可迭代对象（可有多个来实现嵌套） if 条件（每个for都可以跟一个if）]
例如：x = [ i+1 for i in range(10) ] x = [ c*2 for c in "FishC" ] x = [[0]*3 for i in range(0,3)] x = [ i for i in range(10) if i % 2 == 0 ]
x = [1,2,3,4,5,6,7,8,9,10] x = ['FF', 'ii', 'ss', 'hh', 'CC'] x = [[0, 0, 0], [0, 0, 0], [0, 0, 0]] x = [0, 2, 4, 6, 8]
x = [[1,2,3],[4,5,6],[7,8,9]] x = []
x = [ j for i in x x = [ [ i , j ] for i in range(0,10) if i%2==0 for j in range(0,10) if j%3==0 ]
for j in i if j >= 5 ] x=[[0, 0], [0, 3], [0, 6], [0, 9], [2, 0], [2, 3], [2, 6], [2, 9], [4, 0], [4, 3], [4, 6], [4, 9], [6, 0], [6, 3], [6, 6], [6, 9], [8, 0], [8, 3], [8, 6], [8, 9]]
x = [5, 6, 7, 8, 9]
.*：ord（'x'） 用于将单个字符转换为对应的Unicode编码
27.元组
.*：既能像列表一样同时容纳多种类型的对象，也拥有字符串不可变的特性
（1）创建元组
列表：[元素1，元素2，....]
元组：(元素1，元素2，....)
例如：item = (1,2,3,4,5,"上山打老虎")
（2）访问元组
item[下标]
下标从0--len-1
（3）遍历列表
for x in item:
print(x)
或者
for i in range( 0 , len( item ) ):
print(item[i])
（4）元组不可变
无法修改元组内容
item[0]=5 会报错
（5）元组也支持切片
例如：item[2:]
28.元组的方法
查：
（1）count（x）方法（返回x元素出现的次数）
例如：items.count（3）
（2）index（x）方法（返回第一个x元素的下标）
例如：items.index（“绿巨人”）
items[items.index(“绿巨人”)]=“神奇女侠”
29.元组的加法（拼接）
例如：s = （1，2，3）
t = （4，5，6）
s+t =（1，2，3，4，5，6）
例如：item = ("张芮凡"，"江静涵"，"王毅"，"张圣易")
item = item[ : 2] + ("高宇",) + item[ 2：]
item = ("张芮凡"，"江静涵"，"高宇"，"王毅"，"张圣易")
30.元组的乘法（重复元组内的所有元素若干次）
例如：s = （1，2，3）
s3 (1, 2, 3, 1, 2, 3, 1, 2, 3)
s[0] is s[3]（True）
s[1] is s[4]（True）
.：实际上拷贝了外层的对象，本质其实使用的浅拷贝
31.如何生成只有一个元素的元组
x = (520,)
否则只是生成了一个int整数
32.序列（元组、列表、字符串） 的打包与解包
（1）打包（即生成一个元组、列表、字符串）
例如： t = (123，“FishC”，3.14) / [123，“FishC”，3.14] / “ABC”
（2）解包（将上面的元组一次性赋值给3个变量）
例如：x，y，z = t
.：x，y = 5，10 内部逻辑为
t = (5，10) //先打包
x，y = t //再解包
33.元组真的固若金汤吗？
.：元组中的元素是不可变的，但如果元组中的元素指向一个可变的列表，那么依然可以修改列表里面的内容的
例如:
t = (1，2，3) //1 2 3 都不可修改
t = ([1，2，3]，[4，5，6]) //则两个列表中的内容可以修改 t = （[ ] ， [ ]）
t[0][0]=0 | |
\/ \/
t = ([0，2，3]，[4，5，6]) [1,2,3] [4,5,6]
34.字符串的内置方法（实际上返回一个新字符串）
（1）获取单个字符（使用切片）
例如：str[3]
（2）字符串的插入（使用切片+拼接）
例如：str[:6] + "插入的内容" + str[6:]
.*：实际上创建了一个新的字符串
（3）capitalize() 将字符串的第一个字符改为大写，其余改为小写（返回一个新字符串）
例如：str = "abc"
str = str.capitalize() （Abc）
（4）casefold() 把整个字符串的所有字符改为小写（返回一个新字符串）
例如：str = "DDDDDD"
str = str.casefold() （ddddddd）
（5）center(width) 将字符串居中，并使用空格填充至长度width的新字符串（返回一个新字符串）
例如：str = "abcdef"
str = str.center(40) （ abcdef ）
（6）count(sub) 返回子字符串sub在字符串里出现的次数
例如：str="abcbcbc"
str.count('bc') （3）
（7）endswith(sub) 检查字符串是否以sub子字符串结尾
例如：str = "jjhzrf"
str.endswith("zrf") （true）
startswith(prefix) 检查字符串是否以prefix子字符串开头
例如：str = "jjhzrf"
str.startswith("jjh") （true）
（8）expandtabs(空格数) 将字符串中的tab符号(\t)转换为空格，默认空格数为8
例如：str = "abc\tjjh\tzrf\t"
str = str.expandtabs() //abc jjh zrf
（9）find(sub) 从左边开始 检测字符串中是否包含sub子字符串，如果包含返回下标，否则返回-1
例如：str = "I love fishC"
str.find("love")
rfind(sub) 从右边开始 检测字符串中是否包含sub子字符串，如果包含返回下标，否则返回-1
（10）index(sub) 从左边开始 检测字符串中是否包含sub子字符串，如果包含返回下标，否则报异常
rindex(sub) 从右边开始 检测字符串中是否包含sub子字符串，如果包含返回下标，否则报异常
（11）isalnum() 若字符串所有字符都是字母或数字则返回true，否则返回false
例如：str = "abcd12345"
str.isalnum() （true）
（12）isalpha() 若字符串所有字符都是字母则返回true，否则返回false
（13）isdecimal() 若字符串只包含十进制数字则返回true，否则返回false
（14）isdigit() 若字符串只包含数字则返回true，否则返回false
例如：str="12345"
str.isdigit() （true）
（15）isnumeric() 若字符串只包含数字字符则返回true，否则返回false
例如：str="一二三四五"
str.isnumeric() （true）
（16）islower() 若字符串所有字符都是小写则返回true，否则返回false
（17）isupper() 若字符串所有字符都是大写则返回true，否则返回false
（18）isspace() 若字符串只包含空格则返回true，否则返回false
（19）istitle() 若所有单词都是首字母大写，其余字母均小写则返回true，否则返回false
例如：str = "I Love Fishc And I Like Eat Shit"
str.istitle() （true）
title() 返回标题化的字符串（所有单词都是首字母大写，其余字母均小写）
（20）join(sub) 以字符串作为分隔符，插入到sub中所有字符之间
例如： ",".join("12345") （"1,2,3,4,5"）
（21）lower() 把整个字符串的所有字符改为小写（只对 ASCII 也就是 'A-Z'有效）
例如：str="ABCDE"
str.lower() （abcde）
（22）upper() 把整个字符串的所有字符改为大写（只对 ASCII 也就是 'A-Z'有效）
例如：str="abcde"
str.upper() （ABCDE）
（23）swapcase() 翻转字符串中的大小写
（24）lstrip() 去掉字符串左边的所有空格
例如：str=" abc"
str.lstrip() （"abc"）
rstrip() 去掉字符串右边的所有空格
strip(char) 去掉字符串前边和后边所有空格，参数char可以指定删除的字符
例如：str=" abc "
str.strip() ("abc")
str="sssssssssaaaaassssssssss"
str.strip("s") ("'aaaaa'")
（25）replace(old,new) 把字符串中old子字符串替换成new子字符串
例如：str="I love fishc"
str.replace("fishc","FishC") ("I love FishC")
（26）split() 按分隔符切割字符串,返回切割后的列表
例如：str="I,love,fishc"
str.split(",") (['I', 'love', 'fishc'])
（27）splitlines() 按\n切割字符串，返回切割后的列表
例如：str = "aaa\nbbb\nccc\nddd"
s.splitlines() (['aaa', 'bbb', 'ccc', 'ddd'])
35.字符串的格式化方法format()
（1）位置参数
例如："{0} love {1}.{2}".format(“I”,“FishC”,“com”) //位置参数 下标从0开始
I love FishC.com
（2）关键字参数
例如： “{a} love {b}.{c}”.format(a=“I”,b=“FishC”,c=“com”)//关键字参数
I love FishC.com
.*：也可以两种方式混合使用，但位置参数必须在关键字参数之前
"{0} love {1}.{c}".format("I","FishC",c="com")
（3）打印{}
例如："{{0}}".format("不打印") //{0}被{}转义了，变成一个普通字符串而不再是位置参数了
（4）格式化符号
：表示格式化符号的开始，后面紧跟格式化符号
例如："{0:.1f}{1}".format(27.658,"GB") // .1 四舍五入保留一位小数 f 打印定点数
"27.7GB"
36.字符串格式化符号
（1）%c 格式化字符以及其ASCII码
例如：’%c’ %97 //97用ASCII码转义为字符 即是’a’
.*：python支持两种形式的输入参数（1）元组（2）字典
例如：'%c %c %c' %(97,98,99) //多个参数用元组括起来
（2）%s 格式化字符串
例如：'%s' % 'I love FishC'
"I love FishC"
例如："%s%s%s" %("jjh"," love ","zrf") //多个参数用元组括起来
"jjh love zrf"
（3）%d 格式化整数
例如："%d + %d = %d" %( 3 , 5 , 3+5 )
"3 + 5 = 8"
（4）%o 格式化无符号八进制数
例如："%o" %10 //10转换为8进制为12
"12"
（5）%x 格式化无符号十六进制数
例如："%x" %160
"a0"
（6）%X 格式化无符号十六进制数(大写)
例如："%X" %160
"A0"
（7）%f 格式化定点数，可指定小数点后的精度
例如："%f" % 27.658
"27.658000" //默认精确到6位小数，会自动补充0
例如："%.1f" % 27.658 //.1f 四舍五入保留一位小数
"27.7"
（8）%e 用科学计数法格式化定点数
例如："%e" %27.658
"2.765800e+01" //2.7658*10^1
37.格式化符号辅助命令
（1）m.n m是显示的最小总宽度，n是小数点后的位数
例如："%5.1f" % 27.658 //最小总宽度为5 保留一位小数
" 27.7" //整个字符串长度等于5
"%.2e" % 27.658
"2.77e+01"
（2）- 用于左对齐
例如："%10d" % 5
" 5" //整个字符串长度为10
"%-10d" % 5
"5 " //左对齐
（3）+ 在正数前面显示+号
例如："%+d" % 5
"+5"
（4）# 在八进制数前显示'0o'，在十六进制数前显示'0X'
例如："%#o" % 10
"0o12"
"%#x" % 108
"0x6c"
"%#X" % 108
"0X6C"
（5）0 显示的数字前面填充"0"取代空格
例如："%10d" % 5
" 5"
"%010d" % 5
"0000000005"
-
序列（列表、元组、字符串）的内置方法
（1）list(可迭代对象) 把一个可迭代对象转换为列表例如：s = list() //创建一个空列表 a = "520 jjh" // 字符串转换为列表 s = list(a) // ['5','2','0','j','j','h'] a = (1,2,3,4) // 元组转换为列表 s = list(a) // [1, 2, 3, 4]（2）tuple(可迭代对象) 把一个可迭代对象转换为元组
例如：s = tuple() //创建一个空元组 a = "520 jjh" // 字符串转换为元组 s = tuple(a) // ('5','2','0','j','j','h') a = [1,2,3,4] // 列表转换为元组 s = tuple(a) // (1, 2, 3, 4)（3）str(obj) 把obj对象转换为字符串
例如：a = 5 s = str(a)（4）len(sub) 返回sub参数的长度
例如：a = [1,2,3,4,5] len(a) // 5（5）max() 返回序列或参数集合中的最大值
例如：max(3,1,2,7,5) // 7a = [3,1,2,7,5] max(a) // 7 a = (1,5,9,7,6,3,4) max(a) // 9 a = "jjhzrf" max(a) //'z' .*：max()和min()要保证序列或参数中的数据类型是相同的 max(1,2,3,'a') 会报异常（6）min() 返回序列或参数集合中的最小值
例如：min(3,1,2,7,5) // 1a = [1,0,2,7,5] min(a) // 0 a = (1,5,9,7,6,3,4) min(a) // 1 a = "jjhzrf" min(a) //'f'（7）sum(可迭代对象) 返回可迭代对象的总和
例如：a = ( 3.1 , 2.3 , 3.4 )
sum(a) // 8.8a = [ 1 , 2 , 0 , 5.5 , 'a' ] sum(a) // 报异常 a = [ 1 , 5 , 7 , -3] sum(a,5) // 15 会加上可选参数5 .*：字符串不能使用sum()，否则会报错（8）sorted(序列 [,key,reverse]) 默认从小到大排序，与列表的sort()效果相同
例如：a = [1,5,9,7,5,3,6,8,4,2]
a.sort() //默认升序排序 [1, 2, 3, 4, 5, 5, 6, 7, 8, 9]
a = sorted(a) //默认升序排序 [1, 2, 3, 4, 5, 5, 6, 7, 8, 9]*key参数的值为一个函数，函数的参数就是序列中的每个元素，它在每个元素比较前对这个元素进行处理并且返回一个值用来进行比较（很快） a = [[3,1],[5,3],[8,0],[0,4],[3,3],[7,5],[6,8]] a = sorted(a,key = lambda x : x[0] ) //按照每个子列表第一个元素升序排序 [[0, 4], [3, 1], [3, 3], [5, 3], [6, 8], [7, 5], [8, 0]] a = sorted(a,key = lambda x : x[1],reverse = True) //按照每个子列表第二个元素降序排序 [[6, 8], [7, 5], [0, 4], [5, 3], [3, 3], [3, 1], [8, 0]] *使用比较函数（类似java） import functools //需要使用该模块的cmp_to_key()方法 将cmp函数转换为key list1 = [[3,1],[5,3],[8,0],[0,4],[3,3],[7,5],[6,8]] list1 = sorted(list1,key = functools.cmp_to_key(lambda x1,x2 : x2[1]-x1[1] )) //按照每个子列表第二个元素降序排序 [[6, 8], [7, 5], [0, 4], [5, 3], [3, 3], [3, 1], [8, 0]]（9）reversed() 反转序列中的元素
例如：a = [1,2,3,4,5]
reversed(a) //<list_reverseiterator object at 0x000001FF830EEBA8> 返回一个迭代器对象
list(reversed(a)) //转化为list [5, 4, 3, 2, 1]（10）enumerate() 生成由每个元素的index和item组成的元组
例如：a = [‘a’,‘b’,‘c’,‘d’]
enumerate(a) //<enumerate object at 0x0000019D8A71A3A8> 返回一个枚举对象
list(enumerate(a)) // 转化为list [(0, ‘a’), (1, ‘b’), (2, ‘c’), (3, ‘d’)]（11）zip 打包
例如：a = [1,2,3,4,5,6,7,8]
b = [4,5,6,7,8]
zip(a,b) // <zip object at 0x00000256E3B36FC8> 返回一个zip对象
list(zip(a,b)) //转化为list [(1, 4), (2, 5), (3, 6), (4, 7), (5, 8)]
39.函数
（1）创建函数
def myFirstFunc():
print(“第一个函数”)
（2）调用函数
myFirstFunc()
（3）带参数的函数
def mySecondFunc(name):
print(name+" 你好 ")
mySecondFunc("小甲鱼")
def add(num1,num2):
print(num1+num2)
add(2,3)
（4）函数的返回值
def add(num1,num2):
return num1+num2
print(add(5,6))
（5） 函数文档（便于别人理解函数）
例如：def MyFirstFunction():
'这就是函数文档' //作为函数的一部分存储起来，作用和注释一样
print("我的第一个函数")
MyFirstFunction.__doc__ //调用函数默认属性，打印函数文档
（6）关键字参数
例如：def SaySome(name,words):
print(name+"->"+words)
SaySome("小甲鱼","让编程改变世界！") //未用关键字参数
SaySome(words="让编程改变世界！",name="小甲鱼") //使用关键字参数显示指定，这样参数的顺序就可以任意指定了
（7）默认参数（定义函数时给参数赋予默认值）
例如：def SaySome(name="小甲鱼",words="让编程改变世界")
print(name+"->"+words)
SaySome() //即使不给参数，也会打印 小甲鱼->让编程改变世界！
（8）可变参数
例如：def MyFunction(*params): //将参数用元组打包起来
print(params) //输出整个元组 (1, 2, 3, '小甲鱼', 3.14)
print("参数的长度为",len(params)) //输出元组的长度 参数的长度为 5
print("第二个参数为",params[1]) //输出元组中第二个元素 第二个参数为 2
MyFunction(1,2,3,"小甲鱼",3.14)
def MyFunction(*params,exp): //既有可变参数params，又有其他普通参数exp
print(params,exp)
MyFunction(1,2,3,4,5,8) //会报错,会将所有参数归结到params中，缺少exp
MyFunction(1,2,3,4,5,exp=8) //必须使用关键字参数显示指定exp
建议：def MyFunction(*params,exp=8): //exp赋予默认值
print(params,exp)
MyFunction(1,2,3,4,5) //这样即使没给exp赋值也不会报错
40.函数与过程
（1）函数：有返回值
（2）过程：没有返回值
（3）python只有函数没有过程
例如：def function(): //function()返回None
print(“hello”)
def function(): //function返回int
return 1
（4）python函数可以返回多个值（列表、元组）
例如：def function():
return [1,"小甲鱼",3.14] / (1,"小甲鱼",3.14)
（5）局部变量
函数当中定义的参数和变量称为局部变量，作用域为整个函数，都是存储在栈当中，当函数执行完，栈就被清空，所以函数外部无法访问局部变量
（6）全局变量
全局变量的作用域为整个代码文件
python允许在函数中访问全局变量，但是不要试图在函数内部修改全局变量，因为这样会在函数当中创建一个同名的局部变量（屏蔽，为了保护全局变量），从而修改的实际上是函数体中的局部变量
（7）global关键字（允许在函数中修改全局变量）
例如：count = 5
def function():
global count //count不再是局部变量，而变为全局变量
count = 10
print(count)
.*：x = [1,2,3]
def fun1():
x = [4,5,6] //若要修改全局变量x引用的对象必须加上global关键字，否则会被创建一个局部变量x屏蔽掉
fun1()
print(x) //[1,2,3]
x = [1,2,3]
def fun1():
global x //x不再是局部变量而变为全局变量
x = [4,5,6]
fun1()
print(x) //[4,5,6]
x = [1,2,3]
def fun2():
x[0]=5 //只是更改x引用的对象的内容. x仍然引用相同的列表
x[1]=9
fun2()
print(x) //[5, 9, 3]
42.内嵌函数（允许在函数内部创建另一个函数）
例如：def func1():
print(“func1()正在被调用”)
def func2():
print(“func2()正在被调用”)
func2()
func1()
.*：func2()只能在func1()内部调用，出了func1()之后就不能调用了
43.闭包（在内部函数里对外部作用域(不是全局作用域)中的变量进行引用，这个内部函数就构成闭包）
例如：def funX(x):
def funY(y):
return x*y
return funY
funX(8)(5) //40
.*：在内部函数中只能对外部函数的局部变量进行访问，而不能进行修改（类似全局变量与局部变量），因为会创建一个同名的局部变量屏蔽
例如：def function1():
x=5
def function2():
x*=x //x是局部变量会报错
return x
return function2()
function1() //会报错
.*：可以使用nonlocal关键字，用法和global相同
例如：def function1():
x=5
def function2():
nonlocal x //x不再是局部变量，而变为function1中的外部变量x
x*=x
return x
return function2()
function1()
44.lambda表达式（使代码更加精简）
（1）lambda创建匿名函数（有的函数可能只使用一次就不使用了，没有必要为它起名字）
例如：def ds(x):
return x*2+1
ds(5)
等价于
f = lambda x : x*2+1 //返回一个function对象
| |
\/ \/
参数 返回值
f(5)
def add(x,y):
return x+y
add(3,4)
等价于
f = lambda x , y : x+y //返回一个function对象
f(3,4)
45.filter()内置函数
filter(函数或None，可迭代对象) //将可迭代对象当作函数的参数传入，并将返回True的对象筛选出来
例如：filter(None,[1,0,False,True]) //返回一个filter 对象
list(filter(None,[1,0,False,True])) //转换为list [1, True]
def odd(x):
return x%2!=0
list(filter(odd,[0,1,2,3,4,5])) //返回一个列表包含所有奇数 [1,3,5]
等价于
list(filter(lambda x : x%2!=0,[0,1,2,3,4,5])) //[1,3,5]
46.map()内置函数
map(函数，可迭代对象) //将可迭代对象当作函数的参数传入，进行运算后返回一个运算后的新序列
例如：list(map(lambda x: x2,range(10))) //将range生成的0-9依次2以后，生成一个新的序列并转化为list [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
47.递归
（1）设置python最大递归层数
import sys
sys.setrecursionlimit(100) //python3 默认设置100层
48.汉诺塔
def hani(n,x,z,y):
if n==1:
print("%d从%s->%s" %(n,x,z))
else:
hani(n-1,x,y,z)
print("%d从%s->%s" %(n,x,z))
hani(n-1,y,z,x)
def hanio(n,x,z,y):
if n==1:
print("%d从%s->%s" %(n,x,z))
return 1
else:
first = hanio(n-1,x,y,z)
print("%d从%s->%s" %(n,x,z))
last = hanio(n-1,y,z,x)
return first + 1 + last
49.字典（键-值对）
.*：字典是映射类型，字符串、列表、元组是序列类型
（1）创建字典
例如： dict1 = {“李宁” : “一切皆有可能” , “耐克” : “just do it” , “鱼C工作室” : “让编程改变世界”}
dict2 = {1 : “one” , 2 : “two” , 3 : “three”}
dict3 = {} //创建一个空字典
dict4 = dict([[“小白”,78],[“小黑” ,65 ],[“小黄”,100]]) //将一个列表转换为字典 {‘小白’: 78, ‘小黑’: 65, ‘小黄’: 100}
dict5 = dict(((“小白”,78),(“小黑” ,65 ),(“小黄”,100))) //将一个元组转换为字典 {‘小白’: 78, ‘小黑’: 65, ‘小黄’: 100}
dict6 = dict(小甲鱼=“让编程改变世界”,耐克=“just do it”) //使用dict()方法的关键字参数创建字典（参数不加""） {‘小甲鱼’: ‘让编程改变世界’, ‘耐克’: ‘just do it’}
（2）访问字典
例如： print(dict1[“鱼C工作室”]) //“让编程改变世界”
print(dict2[3]) //“three”
（3）修改键对应的值（如果键存在则修改值，否则创建一个新键值对添加）
例如： dict1 = {"李宁" : "一切皆有可能" , "耐克" : "just do it" , "鱼C工作室" : "让编程改变世界"}
dict1["李宁"] = "奥里给" //修改键为"李宁"的值为"奥里给" {'李宁': '奥里给', '耐克': 'just do it', '鱼C工作室': '让编程改变世界'}
dict1["王闯"] = "我是王闯" //增加键值对"王闯":"我是王闯" {'李宁': '奥里给', '耐克': 'just do it', '鱼C工作室': '让编程改变世界', '王闯': '我是王闯'}
50.字典的BIF函数
（1）fromkeys(s,[v]) 用于创建并返回一个新的字典，s为创建的字典的键，v为创建的字典统一的值（可选）
例如：dict1 = {}
dict1.fromkeys((1,2,3)) //重新创建 {1: None, 2: None, 3: None}
dict1.fromkeys((1,2,3),“number”) //重新创建 {1: ‘number’, 2: ‘number’, 3: ‘number’}
dict1.fromkeys((1,2,3),(“one”,“two”,“three”)) //重新创建 {1: (‘one’, ‘two’, ‘three’), 2: (‘one’, ‘two’, ‘three’), 3: (‘one’, ‘two’, ‘three’)}
（2）keys() 返回字典所有键的引用
例如：dict1 = dict1.fromkeys(range(5),"number") //{0: 'number', 1: 'number', 2: 'number', 3: 'number', 4: 'number'}
keys = dict1.keys()
for key in keys: //0 1 2 3 4
print(key)
（3）values() 返回字典所有值的引用
例如：dict1 = dict1.fromkeys(range(5),"number") //{0: 'number', 1: 'number', 2: 'number', 3: 'number', 4: 'number'}
values = dict1.values()
for value in values: //number number number number number
print(value)
（4）items() 返回字典所有项 ( 键值对 ) 的引用
例如：dict1 = dict1.fromkeys(range(5),"number") //{0: 'number', 1: 'number', 2: 'number', 3: 'number', 4: 'number'}
items = dict1.items()
for item in items: //(0, 'number') (1, 'number') (2, 'number') (3, 'number') (4, 'number')
print(item)
（5）get(key[,报错的提示信息]) 根据键获取值（采用更宽松的方式，不会报错）
例如：dict1 = dict1.fromkeys(range(5),"number") //{0: 'number', 1: 'number', 2: 'number', 3: 'number', 4: 'number'}
dict1[4] //'number'
dict1.get(4) //'number'
dict1[5] //报错 keyerror
dict1.get(5) //None
dict1.get(5,"没有啊") //'没有啊'
dict1.get(4,"没有啊") //'number'
.*：判断字典中 键 是否存在
4 in dict1 //True
5 in dict1 //False
x=["王毅","王闯","张芮凡"]
"王毅" in x //True
"张芮凡" in x //True
"江静涵" in x //False
（6）clear() 清空字典
例如：dict1 = {}
dict1 = dict1.fromkeys(range(5),"number") //{0: 'number', 1: 'number', 2: 'number', 3: 'number', 4: 'number'}
dict1.clear() //{}
（7）pop(key) 根据传入的key弹出对应的value
例如：dict1 = {}
dict1 = dict1.fromkeys(range(5),"number") //{0: 'number', 1: 'number', 2: 'number', 3: 'number', 4: 'number'}
dict1.pop(2) //{0: 'number', 1: 'number', 3: 'number', 4: 'number'}
（8）popitem() 弹出最后一个的item（键值对）
例如：dict1 = {}
dict1 = dict1.fromkeys(range(5),"number") //{0: 'number', 1: 'number', 2: 'number', 3: 'number', 4: 'number'}
dict1.popitem() //{0: 'number', 1: 'number', 2: 'number', 3: 'number'}
（9）copy() 浅拷贝
例如：dict1 = {}
dict1 = dict1.fromkeys(range(5),"number") //{0: 'number', 1: 'number', 2: 'number', 3: 'number', 4: 'number'}
dict2 = dict1.copy() //{0: 'number', 1: 'number', 2: 'number', 3: 'number', 4: 'number'}
（10）update(字典) 利用一个字典更新另一个字典
例如：dict1 = { 1 : "one" , 2 : "two" , "小白" : None }
dict2 = { "小白" : "狗" }
dict1.update(dict2) //用 dict2 更新 dict1 {1: 'one', 2: 'two' , '小白': '狗'}
51.集合（无序、唯一）
.*：集合中的元素无序所以不能通过下标索引得到
集合也是用{}表示，只不过其中的元素没有映射关系
（1）创建集合
例如：set1 = {1,2,3,4,5,4,3,2,1} //{1, 2, 3, 4, 5}
set1 = set([1,2,3,4,5,5,4,3,2,1]) //将列表转化为集合 {1, 2, 3, 4, 5}
set1 = set((1,2,3,4,5,5,4,3,2,1)) //将元组转化为集合 {1, 2, 3, 4, 5}
（2）练习：去掉列表中的重复元素 [0,1,2,3,4,5,5,3,1]
list1 = [0,1,2,3,4,5,5,3,1]
temp = []
for x in list1:
if x not in temp:
temp.append(x) //temp [0, 1, 2, 3, 4, 5]
list1 = [0,1,2,3,4,5,5,3,1]
list1 = list(set(list1)) //temp [0, 1, 2, 3, 4, 5]
（3）访问集合中的元素
*使用for循环将元素依次读取出来
set1 = {1,2,3,4,5}
for x in set1:
print(x) //1 2 3 4 5
*可以通过in和not in判断一个元素是否在集合中已经存在
set1 = {1,2,3,4,5}
1 in set1 //True
5 in set1 //True
"小甲鱼" in set1 //False
6 in set1 //False
（3）add(x) 添加元素
例如：set1 = {1,2,3,4,5}
set1.add(6) //{1, 2, 3, 4, 5, 6}
（4）remove(x) 删除元素
例如：set1 = {1,2,3,4,5}
set1.remove(3) //{1, 2, 4, 5}
（5）frozenset(序列) 转换为不可变集合（不能随意增加或删除集合中的元素）
例如：set1 = frozenset([1,2,3,4,5]) //将列表转化为不可变集合 {1, 2, 3, 4, 5}
set1.add(6) //报错
set1.remove(5) //报错
（6）clear() 清空集合
例如：set1 = {1,2,3,4,5}
set1.clear()
（7）intersection(集合) 取交集
例如：set1 = {1,2,3}
set2 = {3,4,5}
set1 = set1.intersection(set2) //{3}
（8）union(集合) 取并集
例如：set1 = {1,2,3}
set2 = {3,4,5}
set1 = set1.union(set2) //{1, 2, 3, 4, 5}
（9）difference(集合) 取差集
例如：set1 = {1,2,3}
set2 = {3,4,5}
set1 = set1.difference(set2) //{1, 2}
（10）copy() 浅拷贝（两个独立的列表）
例如：set1 = {1,2,3}
set2 = set1.copy()
52.文件
（1）open(file_path,mode) 打开文件并返回文件对象
*打开模式
‘r’ 以只读的方式打开文件（默认）
‘w’ 以写入的方式打开文件，如果文件不存在则会自动创建文件，如果文件已经存在则会被新创建的文件替换
‘x’ 如果文件已经存在，使用此模式打开将会引发异常
‘a’ 以写入的方式打开文件，如果文件不存在将会自动创建文件，如果文件已经存在则在末尾追加
‘b’ 以二进制模式打开文件
‘t’ 以文本模式打开文件（默认）
‘+’ 可读写模式
‘U’ 通用换行符支持
例如：file = open("E:\\record.txt","rt") //默认rt
53.文件对象的方法
（1）close() 关闭文件，文件关闭后会自动刷新缓冲区
例如：file = open(“E:\record.txt”) //默认rt
file.close()
（2）read([size]) 从文件读取size个字符，当未给定size或给定负值的时候，将读取剩余所有字符
例如：file = open(“E:\record.txt”)
file.read(5) //“小客服:小” 读取前五个字符
file.read() //读取剩余所有字符
（3）readline([size]) 读取并返回一行（包括行结束符），如果有size有定义则返回size个字符
例如：file = open("E:\\record.txt")
file.readline() //读取一行内容
file.readline(5) //读取一行内容，返回5个字符
（4）tell() 返回当前文件指针的位置
例如：file = open("E:\\record.txt")
file.read(5) //"小客服:小"
file.tell() //9 一个汉字占2个字节，一个英文字母占1个字节，一个英文标点占1个字节
（5）seek(offset,from) 移动文件指针位置，从from（0代表文件起始位置，1代表当前位置，2代表文件末尾）偏移offset个字节
.*：迭代读取文本中每一行
file = open("E:\\record.txt")
for str in file: //直接遍历file对象即可
print(str)
.*：写入文件时，确保打开模式为 'w' 或 'a'
（6）write(str) 将字符串str写入文件
例如：file = open("E:\\record.txt")
file.write("I love FishC.com")
file.flush() //刷新缓冲区
（7）writelines(seq) 向文件写入字符串的可迭代对象（列表、元组）
例如：file = open("E:\\record.txt")
file.writelines("I love FishC.com")
file.writelines(["张芮凡","江静涵","小甲鱼C"])
file.flush() //刷新缓冲区
（8）flush() 刷新缓冲区，即将缓冲区中的数据立刻写入文件
例如：file = open("E:\\record.txt")
file.write("I love FishC.com")
file.flush() //刷新缓冲区
*复制文件
file_from = open(r"C:\Users\ZRF\Desktop\QQ图片20201127165555.png","rb") //二进制读取
file_to = open(r"C:\Users\ZRF\Desktop\有趣的代码\temp.jpg","wb") //二进制写入
file_to.write(file_from.read()) //写入读取的数据
file_from.close()
file_to.close()
54.OS（操作系统）模块
.*：模块是一个包含所有定义的函数和变量的文件，后缀是.py。模块可以被别的程序引入，以使用该模块中的函数等功能
有了OS模块，我们不需要关心什么操作系统下使用什么模块，OS模块会帮你选择正确的模块并调用，这样window，Linux都可以使用该模块来直接操作文件
（1）导入OS模块
例如：import os
（2）getcwd() 返回当前工作目录的路径
例如：os.getcwd() //返回 'C:\\Users\\ZRF\\AppData\\Local\\Programs\\Python\\Python37'
（3）chdir(path) 改变当前工作目录路径（类似cd）
例如：os.chdir("E:\\")
os.getcwd() //返回 'E:\\'
os.chdir("E:\\A\\..")
os.getcwd() //返回 'E:\\'
（4）listdir(path) 列举指定目录下的文件名并返回一个列表（'.' 表示当前目录，'..' 表示上一级目录）
例如：os.listdir("D:\\") //['1.mp3', 'Fun.java', 'game.data', 'game.sav', 'GetPoint.java', 'record.txt', 'Root.java', 'Statistics.java', '激烈空战.jpg']
（5）mkdir(path) 创建单层目录，若该目录已存在则抛出异常
例如：os.mkdir("D:\\A") //创建A目录
os.mkdir("D:\\A\\B") //在A目录中创建B目录（A目录必须存在，否则报错‘系统找不到指定的路径’）
（6）makedirs(path) 创建多层目录，若该目录已存在则抛出异常（ 'E:\\A\\B' 和 'E:\\A\\C' 并不会冲突）
例如：os.makedirs("D:\\A\\B\\C\\D\\E\\F") //创建多层目录
os.makedirs("D:\\A\\B\\C\\D\\E\\J") //不会冲突
（7）remove(path) 删除文件
例如：os.remove("D:\\A\\B\\zrf.txt") //删除文件
（8）rmdir(path) 删除单层目录，如该目录非空则抛出异常
例如：os.rmdir("D:\\A") //A目录不为空，会报错
os.remove("D:\\A\\zrf.txt") //先删除文件
os.rmdir("D:\\A") //再删除目录
（9）removedirs(path) 删除多层目录，从子目录到到父目录逐层尝试删除，遇到目录非空则抛出异常
例如：os.removedirs("D:\\A\\B\\C") //递归删除多层目录
（10）rename(old_path,new_path) 将文件old重命名为new
例如：os.rename("D:\\zrf.txt","D:\\jjh.txt") //重命名文件
os.rename("D:\\A","D:\\B") //重命名目录
（11）system(command) 运行系统的shell命令
例如：os.system("cmd") //打开cmd命令行面板
os.system("calc") //打开计算器
（12）OS模块当中的定义
os.curdir 代表当前目录 ' . '
os.pardir 代表上一级目录 ' .. '
os.sep 代表操作系统的路径分隔符
os.name 指代当前使用的操作系统
*os.path模块中常用方法
（1）basename(path) 去掉目录路径，单独返回文件名
例如：os.path.basename(r"C:\Users\ZRF\Desktop\有趣的代码\激烈空战.jpg") // '激烈空战.jpg'
（2）dirname(path) 去掉文件名，单独返回路径名
例如：os.path.dirname(r"C:\Users\ZRF\Desktop\有趣的代码\激烈空战.jpg") // 'C:\\Users\\ZRF\\Desktop\\有趣的代码'
（3）join(path1,path2...) 将各部分组合成一个路径名
例如：os.path.join("A","B","C") // 'A\\B\\C'
os.path.join("C:\\","A","B") // 'C:\\A\\B'
（4）split(path) 分割文件名和路径名，返回一个元组
例如：os.path.split(r"C:\Users\ZRF\Desktop\有趣的代码\激烈空战.jpg") // ('C:\\Users\\ZRF\\Desktop\\有趣的代码', '激烈空战.jpg')
os.path.split(r"C:\A\B\C") // ('C:\\A\\B', 'C')
（5）splitext(path) 分割文件名与扩展名，返回一个元组
例如：os.path.splitext(r"C:\Users\ZRF\Desktop\有趣的代码\激烈空战.jpg") //('C:\\Users\\ZRF\\Desktop\\有趣的代码\\激烈空战', '.jpg')
（6）getsize(path) 返回指定文件的尺寸，单位是字节
例如：os.path.getsize(r"C:\Users\ZRF\Desktop\有趣的代码\record.txt") //1057B
（7）getatime(path) 返回文件最近的访问（access）时间
例如：access_time = os.path.getatime(r"C:\Users\ZRF\Desktop\有趣的代码\record.txt") //1607438078.7664866
import time //使用time模块的localtime()换算
list(time.localtime(access_time)) //[2020, 12, 8, 22, 34, 38, 1, 343, 0] 年 月 日 时 分 秒
.*：import time
time.time() //获取当前时间毫秒
list(time.localtime(time.time())) //将当前时间毫秒换算 [2020, 12, 9, 12, 2, 34, 2, 344, 0]
（8）getctime(path) 返回文件的创建（create）时间
例如：os.path.getctime(r"C:\Users\ZRF\Desktop\有趣的代码\record.txt")
（9）getmtime(path) 返回文件最近的修改（modify）时间
例如：os.path.getmtime(r"C:\Users\ZRF\Desktop\有趣的代码\record.txt")
（10）os.utime(path,(atime, mtime)) 用于设置文件最后的修改和访问时间，(atime, mtime)为元组
例如：os.utime(r"C:\Users\ZRF\Desktop\有趣的代码\111.txt",(1330712280, 1330712292))
.*：以下函数返回True或False
（10）exists(path) 判断指定文件或目录是否存在
例如：os.path.exists(r"C:\Users\ZRF\Desktop\有趣的代码\激烈空战.jpg") //True
os.path.exists(r"C:\Users\ZRF\Desktop\有趣的代码\zrf.jpg") //False
（11）isabs(path) 判断路径是否为绝对路径
*：相对路径 .\\A\\B\\C
绝对路径 E:\\A\\B\\C
例如：os.path.isabs(r"C:\Users\ZRF\Desktop\有趣的代码\激烈空战.jpg") //Ture
os.path.isabs(r".\ZRF\激烈空战.jpg") //False
（12）isdir(path) 判断是否是一个目录
例如：os.path.isdir(r"C:\Users\ZRF\Desktop\有趣的代码") //True
os.path.isdir(r"C:\Users\ZRF\Desktop\有趣的代码\激烈空战.jpg") //False
（13）isfile(path) 判断是否是一个文件
例如：os.path.isfile(r"C:\Users\ZRF\Desktop\有趣的代码\激烈空战.jpg") //True
os.path.isfile(r"C:\Users\ZRF\Desktop\有趣的代码") //False
（14）ismount(path) 判断是否是一个根目录
例如：os.path.ismount("D:\\") //True
os.path.ismount("D:\\A") //False
*遍历一个目录中所有的txt文件
import os
os.walk("C:\\Users\\ZRF\\Desktop\\有趣的代码") //遍历文件夹
//当前遍历的文件夹 root，当前遍历的文件夹下的所有文件夹 dirs，当前遍历的文件夹下的所有文件 files
root dirs files
('C:\\Users\\ZRF\\Desktop\\有趣的代码', ['B'], ['1.mp3', '111.txt', '222.txt', 'Root.java', 'Statistics.java', '一千年以后高潮.mp3', '一千年以后高潮.txt', '一千年以后高潮2.mp3', '激烈空战.jpg']),
root dirs files
('C:\\Users\\ZRF\\Desktop\\有趣的代码\\B', ['1'], []),
root dirs files
('C:\\Users\\ZRF\\Desktop\\有趣的代码\\B\\1', [], ['wc.txt'])
for root,dirs,files in os.walk("C:\\Users\\ZRF\\Desktop\\有趣的代码"):
list_txt = list(filter(lambda file:file.lower().endswith(".txt"),files))
for txt in list_txt:
print(os.path.join(root,txt))
*遍历一个目录中所有文件 方式2
import os
def kill(path):
list_files = os.listdir(path)
for file in list_files:
if os.path.isdir(os.path.join(path,file)):
kill(os.path.join(path,file))
elif os.path.isfile(os.path.join(path,file)):
if file.lower().endswith(".txt"):
print(os.path.join(path,file))
kill(r"C:\Users\ZRF\Desktop\有趣的代码")
55.pickle模块（用于将列表、字典等复杂对象转化为二进制形式存放）
* 对象->二进制（存放）：pickling
* 二进制->对象（读取）：unpickling
（1）对象->二进制（存放）
例如：import pickle
my_list = [1,3.14,“小甲鱼”,[1+2j]]
file = open(“C:\Users\ZRF\Desktop\有趣的代码\save.pkl”,“wb”) //后缀任意起，wb以二进制写入的方式打开文件
pickle.dump(my_list,file) //将my_list以二进制的形式倒入到file当中
file.close() //关闭文件，刷新缓冲区
（2）二进制->对象（读取）
例如：import pickle
file = open(“C:\Users\ZRF\Desktop\有趣的代码\save.pkl”,“rb”) //打开该文件，rb以二进制读取的方式打开文件
my_list = pickle.load(file) //将刚才保存的二进制数据转化为对象读取出来
file.close() //关闭文件
print(my_list) //[1,3.14,“小甲鱼”,[1+2j]]
56.异常处理
（https://fishc.com.cn/forum.php?mod=viewthread&tid=45814&extra=page%3D1%26filter%3Dtypeid%26typeid%3D403）
（1）AssertionError 断言语句错误
例如：x = []
assert len(x) > 0 //AssertionError
（2）AttributeError 尝试访问未知的对象属性
例如：x = []
x.fishc() //AttributeError: 'list' object has no attribute 'fishc'
（3）IndexError 索引超出序列范围
例如：x = [1,2,3]
x[3] //IndexError: list index out of range
（4）KeyError 字典中查找一个不存在的key
例如：x = {"one":1,"two":2,"three":3}
x["four"] //KeyError: 'four'
（5）NameError 尝试访问一个不存在的变量
例如：print(fishc) //NameError: name 'fishc' is not defined
（6）OSError 操作系统产生的异常（例如打开一个不存在的文件）
例如：file = open(r"D:\fishc.txt") //FileNotFoundError（OSError的一个子类）
（7）OverflowError 数值运算超出最大限制
一般不会出现
（8）SyntaxError 语法错误
例如：print "fishc.com" //SyntaxError
（9）TypeError 不同类型间的无效操作
例如：1 +“1” //TypeError: unsupported operand type(s) for +: 'int' and 'str'
（10）ZeroDivisionError 除数为0
例如：5/0 //ZeroDivisionError: division by zero
57.try-except 语句
（1）try:
检测范围
except 要捕获的异常类型 as 异常小名(包含异常信息):
出现异常后的处理代码
else:
当 try块 中没有出现异常时，才会运行 else 语句
finally:
无论如何都会被执行的代码
.*：try后可以跟多个except语句
.*：try块中一旦出现异常，后面的语句将不会执行
例如：
try:
file = open("奥里给.txt")
x = 1 +"1"
except OSError as reason:
print("文件找不到")
print("错误原因："+str(reason))
except TypeError as reason:
print("错误原因："+str(reason))
else:
print("没有出现异常")
finally:
file.close()
.*：若想让except针对所有异常进行处理
try:
file = open("奥里给.txt")
except:
print("出错了")
finally:
file.close()
.*：若想让except针对多个异常进行处理
try:
代码
except (OSError,TypeError) as reason:
print("错误原因："+str(reason))
58.raise语句
.*：使用raise语句来主动抛出异常
例如：raise ZeroDivisionError(“除数为0的异常”) //ZeroDivisionError: 除数为0的异常
59.python时间格式化
（1）获取当前时间的 年、月、日、时、分、秒
例如：import time 年 月 日 时 分 秒 星期几（0-6） 一年中的第几天 是否为夏令时
list(time.localtime(time.time())) //[2020, 12, 14, 11, 58, 26, 0, 349, 0]
（2）时间变量->字符串
strftime(格式化字符串,时间变量)
年 月 日 时 分 秒
例如：t = time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(time.time())) //‘2020-12-14 12:19:25’
（3）字符串->时间变量
strptime(时间字符串,格式化字符串)
例如：t = time.strptime("2020-12-14 12:19:25","%Y-%m-%d %H:%M:%S")
（4）测量经过的时间
perf_counter() 返回一个CPU级别的精确时间计数值，单位为秒，由于该计数值起点不确定，连续调用差值才有意义
例如：start = time.perf_counter() //318.6659
end = time.perf_counter() //341.3905
sub = end - start //22.7245
（5）休眠程序
sleep(休眠的秒数)
例如：time.sleep(5.3) //程序休眠5.3秒
（6）时间戳_>时间变量
localtime(时间戳)
例如：time.localtime(time.time())
（7）时间变量->时间戳
mktime(时间变量)
例如：time.mktime(time.localtime(time.time())) //1608810918.0
60.with语句（类似TWR）
.*：当文件不使用的时候，会自动帮我们关闭
例如：with open(r"C:\Users\ZRF\Desktop\有趣的代码\record.txt") as file: //当文件不使用时，会自动帮我们调用file.close()
for line in file:
print(line)
61.EasyGUI
（https://www.cnblogs.com/hcxy2007107708/articles/10091466.html）
（1）安装EasyGUI
cmd->cd 进入EasyGUI的目录->python setup.py install
（2）导入EazyGUI
import easygui as g
g.msgbox("你好，小甲鱼","问候")
-----------对话框
（3）msgbox(msg,title,ok_button,image) 只有一个确认按钮的对话框
例如：g.msgbox(“小甲鱼”,“问候”,“确定”)
（4）ccbox(msg,title,choices=('C[o]ntinue', 'C[a]ncel'),image,default_choice) 具有continue和cancel两个按钮的对话框
.*：相应的返回 True 或者 False。
例如：g.ccbox("你确定要继续么","请选择",("确定","取消"),default_choice="确定")
（5）buttonbox(msg,title,choices=('Button[1]', 'Button[2]', 'Button[3]'),image) 显示一组由你自定义的按钮
.*：当用户点击任意一个按钮的时候，buttonbox() 返回按钮的文本内容。
例如：choice = g.buttonbox("你喜欢吃哪种水果？","请选择",("香蕉","苹果","桃子"))
（6）indexbox(msg,title,choices=('Button[1]', 'Button[2]', 'Button[3]'),image) 和buttonbox()相同
.*：当用户点击任意一个按钮的时候，buttonbox() 返回按钮的下标（从0开始）
例如：index = g.indexbox("你喜欢吃哪种水果？","请选择",("香蕉","苹果","桃子"))
.*：如何在 buttonbox 里边显示图片？
可以为关键字参数 image 赋值，可以设置一个 .gif 格式的图像（PNG 格式的图像也是支持的哦^_^）
----------列表
（7）choicebox(msg,title,choices) 单选列表，使用序列（元祖或列表）作为选项，返回一个字符串
例如：choice = g.choicebox(“请选择您想学习的技能”,“请选择”,[“编程”,“琴棋书画”,“画画”])
（8）multchoicebox(msg,title,choices) 多选列表，使用序列（元祖或列表）作为选项，返回一个列表
例如：choice_list = g.multchoicebox("请选择您想学习的技能","请选择",["编程","琴棋书画","画画"])
----------输入框
（9）enterbox(msg,title,default) 提供一个简单的输入框，返回值为用户输入的字符串
例如：content = g.enterbox("请输入内容","请输入",default="默认内容")
（10）integerbox(msg,title,default,lowerbound,upperbound) 提供一个简单的输入框，用户只能输入范围内 [lowerbound,upperbound] 的整型数值
例如：num = g.integerbox("请输入0-99范围的数字","请输入","50",lowerbound=0,upperbound=99)
（11）multenterbox(msg,title,fields=[], values=[]) 提供多个简单的输入框，返回一个列表
例如：list_info = g.multenterbox("请输入个人信息","账号中心",fields=["账号","密码","手机号"],values=["736381914","zrf990924","17852165691"])
.*：如果用户输入的值比选项少的话，则返回列表中的值用空字符串填充用户未输入的选项。
如果用户输入的值比选项多的话，则返回的列表中的值将截断为选项的数量。
如果用户取消操作，则返回None 值。
（12）passwordbox(msg,title,default) 提供一个输入密码框（显示为*****）
例如：g.passwordbox("请输入密码","请输入")
（13）multpasswordbox(msg,title,fields=[], values=[]) 与multenterbox()相同，但最后一个输入框显示为密码的形式（***）：
例如：g.multpasswordbox("请输入用户名和密码","登录",fields=["用户名","密码"],values=["736381914","zrf990924"])
----------显示文本
（14）textbox(msg,title,text) 显示可编辑的文本内容，返回一个字符串
.*：text 参数设置可编辑文本区域的内容，可以是字符串、列表或者元祖类型。
例如：with open(r"C:\Users\ZRF\Desktop\有趣的代码\record.txt") as file:
list_file = file.readlines()
content = g.textbox("record.txt的内容如下","显示文本",list_file)
----------目录与文件
（15）diropenbox(msg,title) 提供一个对话框，返回用户选择的目录名（带完整路径），如果用户选择 “Cancel” 则返回 None。
例如： g.diropenbox("请选择目录","浏览目录")
（16）fileopenbox(msg, title, default='*', filetypes, multiple) 提供一个对话框，返回用户选择的文件名（带完整路径），如果用户选择 “Cancel” 则返回 None。
.*：关于 default 参数的设置方法：
*default 参数指定一个默认路径，通常包含一个或多个通配符。
*如果设置了 default 参数，fileopenbox() 显示默认的文件路径和格式。
*default 默认的参数是 '*'，即匹配所有格式的文件。
例如：
default="c:/fishc/*.py" 即显示 C:\fishc 文件夹下所有的 Python 文件。
default="c:/fishc/test*.py" 即显示 C:\fishc 文件夹下所有的名字以 test 开头的 Python 文件。
.*：关于 filetypes 参数的设置方法：
*filetypes 参数 表示可以匹配的文件格式
*可以是包含文件掩码的字符串列表，例如：filetypes = ["*.txt","*.java"]
.*：multiple 参数，如果为 True 则表示可以同时选择多个文件，返回一个列表。
例如：g.fileopenbox("请选择文件","浏览文件",default="c:/fishc/*.py",filetypes = ["*.txt","*.java"], multiple=True)
（17）filesavebox(msg,title,default,filetypes) 提供一个对话框，用于选择文件需要保存的路径（带完整路径），如果用户选择 “Cancel” 则返回 None
.*：default 和 filetypes 与上面相同
例如：g.filesavebox("请选择保存位置","保存文件",default="c:/fishc/*.py",filetypes = ["*.txt","*.java"])
62.类和对象
（1）类名约定以大写字母开头
例如：class Turtle
#属性
color = “green”
weight = 10
legs = 4
#方法 第一个参数必须是self（可以随意命名），表示调用该方法的对象
def eat(self):
print(“有的吃，真满足！”)
def sleep(self):
print(“睡觉啦，晚安！”)
（2）创建实例对象 （对象 = 属性 + 方法）
例如：turtle = Turtle()
turtle.eat()
turtle.sleep()
（3）OO的特征
*封装
*继承：
例如：class MyList(list): //MyList类继承了list类，并且共享list类中的属性和方法
pass //占位符，表示不做任何操作
list2 = MyList() //创建一个MyList类的实例
list2.append(1) //[1]
list2.append(5) //[1,5]
list2.append(3) //[1,5,3]
list2.sort() //[1,3,5]
*多态
（4）self是什么？（类似java的this）
.*：self表示当前正在调用该方法的对象
例如：class Student:
def setName(self,name): //python的类的属性，可以不用声明，在赋值时直接生效
self.name = name
def printName(self):
print("我的名字是"+self.name)
（5）构造方法
.*：该方法会在对象被创建的时候自动调用
.*：在python中一个类只能有一个构造方法，默认有一个无参构造方法 __init__(self)
.*：构造函数的返回值只能是None
例如：class Student:
def __init__(this,name,age): //python的类的属性，可以不用声明，在赋值时直接生效
this.name = name
this.age = age
stu = Student("小甲鱼",18)
（6）公有和私有
.*：默认上来说对象的属性和方法都是公有的
.*：在变量名或函数名前加上"__"两个下划线，这个变量或函数就变为私有了，私有变量或函数只能在类的内部进行访问
例如：class Student:
__name = "小甲鱼"
def getName(this):
print(this.__name) //通过类内部访问私有变量
stu = Student()
stu.__name //报错
stu.getName()
.*：实际上可以通过 _类名__私有变量 来访问私有变量或函数
例如：class Student:
__name = "小甲鱼"
def __eat(this):
print("吃饭啦")
stu = Student()
stu._Student__name //访问私有变量 "小甲鱼"
stu._Student__eat() //调用私有函数 "吃饭啦"
（7）继承
.*：子类继承父类的属性和方法，私有属性和私有方法不会被继承
语法：class 子类（父类）:
例如：class Parent:
def hello(this):
print("这是父类的方法")
class Child(Parent): //Child类继承Parent类
pass
c = Child()
c.hello() //调用继承的父类方法 "这是父类的方法"
.*：如果子类中定义了与父类同名的方法或属性，则会自动覆盖父类对应的方法或属性（子类重写父类方法）
例如：class Parent:
def hello(this):
print("这是父类的方法")
class Child(Parent):
def hello(this):
print("这是子类的方法")
c = Child()
c.hello() //调用子类自身的方法 "这是子类的方法"
.*：子类调用父类的方法或属性，使用super()
例如：class Fish:
def __init__(self):
self.x = random.randint(0,10)
self.y = random.randint(0,10)
def move(self):
self.x -=1
print("向左移动以后的坐标为",(self.x,self.y))
class Shark(Fish):
def __init__(self): //覆盖了父类的构造方法，导致x和y属性缺失，调用move()会报错
super().__init__() //子类调用父类构造方法
class Fish:
name = "小甲鱼" //父类公有属性
__age = 20 //父类私有属性，不会被子类继承
def __init__(self): //父类构造方法
print("父类构造")
def fish(this):
print("父类fish方法")
def eat(this):
print("父类eat方法")
class Shark(Fish):
def __init__(this): //子类构造方法
super().__init__() //调用父类构造方法
print("子类构造")
def fish(this):
super().fish() //调用父类fish()
print("子类fish方法")
def sleep(this):
super().eat() //调用父类eat()
def access(this):
print("父类name",super().name) //访问父类公有属性name
print("父类age",super()._Fish__age) //访问父类私有属性__age
.*：Python支持多重继承
语法：class 子类（父类1,父类2....）:
例如：class Parent1:
def fool1(this):
print("Parent1的方法")
class Parent2:
def fool2(this):
print("Parent2的方法")
class Child(Parent1,Parent2):
pass
child = Child()
child.fool1() //调用父类1的fool1()方法 “Parent1的方法”
child.fool2() //调用父类2的fool2()方法 “Parent2的方法”
（8）组合（一个类中组合其他的类）
例如：class Turtle:
num = ""
def __init__(this,num):
this.num = num
class Fish:
num = ""
def __init__(this,num):
this.num = num
class Pool:
turtle = ""
fish = ""
def __init__(this,tutle_num,fish_num):
this.turtle = Turtle(tutle_num)
this.fish = Fish(fish_num)
def printNum(this):
print("乌龟的数量是"+str(this.turtle.num),"鱼的数量是"+str(this.fish.num))
pool = Pool(5,3)
pool.printNum() //乌龟的数量是5 鱼的数量是3
（9）类、类对象、实例对象
例如：class C: //类定义C，当类定义C写完以后就生成了类对象C
count = 0 //静态属性
a = C() //实例对象
b = C() //实例对象
c = C() //实例对象
C.count = 100 //类对象中的静态属性改为100
a.count //100
b.count //100
c.count //100
c.count = 5 //当对 实例对象c 中的count进行赋值时，相当于生成了一个 实例属性count 来覆盖了 类对象C中的静态属性count
C.count = 10 //类对象中的静态属性改为10
a.count //10
b.count //10
c.count //5
类定义 C（静态count）
|
类对象 C（静态count = 100）
/ | \
实例对象 a b c（实例count = 5）
.*：如果属性名和方法名相同，属性会覆盖方法
例如：class C:
def test(this):
print("这是test方法")
c = C()
c.test =5 //在c中创建一个test属性
c.test() //报错
.*：python要求方法需要有实例才能被调用
例如：turtle.eat(turtle) //实际上会传入turtle对象当作self
63.类和对象相关的BIF
（1）issubclass(class1，classinfo) 判断class1是否是classinfo的子类，如果是返回True，否则返回False
.：一个类被认为是其自身的子类
.：classinfo可以是类对象组成的元组，只要class1是其中任何一个候选类的子类，则返回True
例如：class A:
pass
class B(A):
pass
class C:
pass
issubclass(B,A) //True B是A的子类
issubclass(B,B) //True B是B的子类
issubclass(B,object) //True B是object的子类，object是所有类的基类
issubclass(B,C) //False B不是C的子类
issubclass(B,(A,C)) //True B是A候选类的子类
（2）isinstance(object,classinfo) 判断 object 是否是 classinfo类 的一个实例
.*：如果第一个参数object不是对象，则永远返回False
.*：如果第二个参数classinfo不是类或者是类对象组成的元组，则会抛出TypeError异常
.*：classinfo可以是类对象组成的元组，只要object是其中任何一个候选类的实例，则返回True
例如：class A:
pass
class B(A):
pass
class C:
pass
b = B()
isinstance(b,B) //True b是B类的实例
isinstance(b,A) //True B类继承A类，所以b也是A类的实例
isinstance(b,C) //False b不是C类的实例
isinstance(b,(A,B,C)) //True b是A候选类的实例
（3）hasattr(object,name) 判断object对象是否含有name属性
例如：class C:
def __init__(this,age):
this.age = age
c = C(18)
hasattr(c,"age") //True 实例c含有age属性
（4）getattr(object,name,[如果属性不存在返回的值]) 返回object中指定的属性name
例如：class C:
def __init__(this,age):
this.age = age
c = C(18)
getattr(c,"age") //18 实例c含有age属性
getattr(c,"name") //报错 实例c没有name属性
getattr(c,"name","属性不存在") //属性不存在
（5）setattr(object,name,value) 给对象指定的属性赋值，如果属性不存在，则会创建属性
例如：setattr(c,"name","小甲鱼")
（6）delattr(object,name) 删除对象中指定的属性，如果属性不存在则报错
例如：delattr(c,"name")
（7）property(get,set,del) 返回一个属性用于操作另一个属性，参数分别为要操作的属性的get、set、del方法
例如：class C:
def __init__(this,age):
this.age = age
def getAge(this):
return this.age
def setAge(this,age):
this.age = age
def delAge(this):
del this.age
x = property(getAge,setAge,delAge) //返回一个x属性用来间接访问age属性
c = C(18)
c.x //实际上调用getAge()
c.x = 22 //实际上调用setAge(22)
del c.x //实际上调用delAge()
（8）访问修饰符
例如：def something(func):
def call():
print("开始啦")
func()
print("结束啦")
return call
@something
def f():
print("执行f()")
等价于
f = something(f)
f() == call()
64.魔法方法
.：魔法方法总是被__包围，例如：init
.：魔法方法能够在适当的时候被自动调用
（1）new(cls,…) 析构方法，对象实例化时第一个调用的方法
.*：参数cls为当前类对象
.*：如果cls后有参数，则参数会原封不动传给__init__()
.*：该方法需要有一个返回值，返回值为要生成的实例对象
.*：__new__ 方法主要任务是返回一个实例对象，通常是参数 cls 这个类的实例化对象，当然你也可以返回其他对象
例如：class Capstr(str): //传入一个字符串对象，返回一个大写字符串对象
def __new__(cls,string): //重写__new__方法，参数为一个string
string = string.upper()
return str.__new__(cls,string) //使用str的__new__()来创建这个字符串
s = Capstr("i love fishc") //"I LOVE FISHC"
（2）__init__(this,...) 构造方法，对象实例化时第二个调用的方法
.*：在python中一个类只能有一个构造方法，默认有一个无参构造方法 __init__(self)
.*：构造函数的返回值只能是None
例如：class Student:
def __init__(this,name,age):
this.name = name
this.age = age
stu = Student("小甲鱼",18)
（3）__del__(this) 在对象要被垃圾回收器回收的时候自动调用
例如：class C:
def __init__(this):
print("__init__方法被调用了...")
def __del__(this):
print("__del__方法被调用了...")
c1 = C() //"__init__方法被调用了..."
c2 = c1
c3 = c2
del c1
del c2
del c3 //"__del__方法被调用了..."
65.自定义算术运算的魔法方法
.*：a = int(3) //实例化一个int类型对象a
b = int(5) //实例化一个int类型对象b
a+b //实际上调用 int类型对象a 的__add__()方法，即 a.add(b)
（1）add(this,other) 自定义加法行为：+
（2）sub(this,other) 自定义减法行为：-
例如：class My_int(int):
def __add__(this,other): //重写__add__()
return int(this) + int(other) //等价于 int(this).__add__(int(other))
def __sub__(this,other): //重写__add__()
return int(this) - int(other) //等价于 int(this).__sub__(int(other))
a = My_int(3)
b = My_int(5)
a + b //等价于 a.__add__(b)
a - b //等价于 a.__sub__(b)
（3）__mul__(self, other) 自定义乘法的行为：*
（4）__truediv__(self, other) 自定义真除法的行为：/
（5）__floordiv__(self, other) 自定义地板除法的行为：//
（6）__iadd__(this,other) 自定义自增行为：+=
（7）__abs__(this) 自定义abs()行为 即 abs(a) == a.__abs__()
（8）__neg__(this) 自定义负号的行为：-x 即 -x == x.__neg__()
扫一扫
773
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
