【Python】小甲鱼Python学习总结——代码版

技术2022-07-12 66

看了50P左右的小甲鱼B站的Python视频，按需学习，因此有些P可能会有遗漏。以下是自己跟着视频敲的代码，一些知识点和自己的理解写在了注释里。注释要遵守PEP8的规范。同时Python的另一个教程：https://www.runoob.com/python3/python3-tutorial.html 感觉也是非常的好。

P1 TO P10

P2

print("5616") # 打印普通字符 print(5+3) # 打印并进行数学运算 # 5+3 # statement seems to have no effect print(6511316546131654*1651316413131561) # 大数运算 print(10752243883722307225162728531894/1651316413131561) print("well water" + " river") # 字符串拼接 print("Super WG " * 8) # 打印八次 print("test \n" + "\\n") # test # \n print('Sueper "WG"') # Sueper "WG" print("\"Super WG\"") # "Super WG" # print("well river" + 8) # 报错，类型不同

P3

print("猜数字游戏") temp = input("猜一下我心里想的数字:") guess = int(temp) # Python的强转是类型()，这个和C/C++不一样 if guess == 8: # 注意: print("牛逼啊！猜中了") else: print("不是哦~") print("不玩啦~拜拜~")

P4

print("let's go") print('Let\'s go') print("let" + "'s " + "go") str1 = r"C:\now" print(str1) # let's go # Let's go # let's go # C:\now

P5

import random secret = random.randint(1, 10) print("猜数字游戏") temp = input("猜一下我心里想的数字:") guess = int(temp) times = 3 while guess != secret and times != 0: temp = input("啊呀，猜错啦，再猜一个数字吧:") guess = int(temp) if guess == 8: print("牛逼啊！猜中了") break else: # 注意: times -= 1 if guess > 8: print("大了大了！") else: print("小了小了！") print("不玩啦~拜拜~") # random模块里有randint()函数，返回一个int数

P6

# 获得关于类型的信息，type() temp = 5 type(temp) # 更建议用isinstance()函数,两个参数，返回bool # isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。 # isinstance() 与 type() 区别： # type() 不会认为子类是一种父类类型，不考虑继承关系。 # isinstance() 会认为子类是一种父类类型，考虑继承关系。 # 如果要判断两个类型是否相同推荐使用 isinstance()。 a = 'sfsdfeg' if isinstance(a, int): print("yes") else: print("no")

P7

# 算数操作符 # a = b = c = d = 10是可以的 # " / " 表示浮点数除法，返回浮点结果; # " // " 表示整数除法,返回不大于结果的一个最大的整数 print("6 // 4 = " + str(6 // 4)) print("6 / 4 =" + str(6 / 4)) # ** 表示幂,优先级最高 print("3 ** 8 = " + str(3 ** 8)) # 关于逻辑操作符 and or not print("5 and 0 = " + str(5 and 0)) print("5 or 6 = " + str(5 or 6)) print("5 or 0 = " + str(5 or 0)) print("not 4 = " + str(not 4)) # 1 < 2 < 3这样写是可以的 # 解释为(1<2) and (3<4)

P9

# 实例化 # if-elif-else score = int(input("请输入您的分数:")) if 90 <= score <= 100: print('A') elif 80 <= score < 90: print('B') elif 70 <= score < 80: print('C') elif 60 <= score < 70: print('D') else: print("不及格！！！") # 条件表达式 x, y = 4, 5 if x < y: small = x else: small = y # 可以改写为 small = x if x < y else y # 关于断言 # assert 右边的结果为false时，程序崩溃并且抛出AssertionError的异常 # assert 3 > 4 # 用处：当我们想要某个地方为true时，在此处添加assert，确保这个地方是true def foo(s): n = int(s) assert n != 0, 'n is zero!' return 10 / n foo('0') # 代码执行结果 # AssertionError: n is zero!

P10

# while循环 # while 条件 # 循环体 # for target in 表达式: # 循环体 target = "SuperWG" for i in target: print(i, end=' ') member = ["SU", "PER", "WG", "NB"] # 定义了一个列表 for each in member: print(each, len(each)) # range()是个BIF # range([start,] stop[, step = 1]) # step = 1表示第三个参数的值默认是1 # range()的作用是生成一个从start参数的值开始到stop参数的值结束的数字序列 # 经常与for搭配 print(list(range(0, 5))) for i in range(5): # 如果是一个参数，默认从0开始 print(i) for j in range(2, 8): # 最多到7，没有8 print(j) for k in range(1, 10, 2): # 最后的一个参数为step步长 print(k) # break continue用法同C/C++ for i in range(10): if i % 2 != 0: print(i) continue i += 2 print(i)

P11 TO P20

P11

# 列表：一个打了激素的数组 # python的变量没有数据类型，而数组要求是同类型的数据，故数组在python表示为列表，可以装入很多东西，相当于仓库 # 创建一个普通列表 test = ["sfesdf", "sadasf", "asfdfsfegs"] print(test) # 创建一个混合列表 mix = [1, "dafsdf", 3.1566, [1, 2, "866"]] print(mix) # 创建一个空列表 empty = [] # 向列表添加元素 # append方法 test.append("chuaru") test.append("fidsf"+"afsdgvgsdf") # 本质上是合二为一 # extend方法 # extend是用一个列表扩展另一个列表 test.extend(["afdsgegsdg","sdfsdgsdg"]) print(test, len(test)) # insert方法，两个参数 test.insert(1, "牡丹") # 第一个索引为0，第一个参数为索引值，第二个参数是要插入的东西 test.insert(3, [6416, "Sdfgs", test.insert(6, "66666")]) print(test, len(test))

P12

# 从列表中获取元素，第一个index为0 test = ["NO.1", "NO.2", "NO.3"] print(test[0]) # 调换两个元素？ # 通过temp temp = test[0] test[0] = test[1] test[1] = temp print(test[0]) # 从列表删除元素的办法 # remove(),一个参数为值 test.remove("NO.2") print(test) # 如果没有这个value，报错 # del是个语句，不是一个函数 del test[1] print(test) # del test 可以把整个列表删掉 test.append("NO.4") test.extend(["NO.5", "NO.6"]) # pop(),从列表去除最后一个元素，并返回给你 print(test.pop()) print(test) # pop(index)，把某个元素剔除，popo()返回元素value print(test.pop(2)) print(test) # 列表分片 slice # 利用索引值，每次可以从列表获取一个元素，那如果一次性需要获取多个元素，怎么办呢？ # 利用slice test = ["NO.1", "NO.2", "NO.3", "NO.4", "NO.5", "NO.6"] print(test[1:4]) # 从index为1的元素到index为4的元素（不包括此元素）组成一个新的列表，原列表不变 print(test[:4]) # 如果不写默认从头开始 print(test[1:]) # 如果不写默认到尾结束 print(test)

P13

# 列表的一些常用操作符 # 比较操作符、逻辑操作符、逻辑操作符、连接操作符、重复操作符、成员关系操作符 list1 = [123] list2 = [234] print(list1 > list2) # False list3 = [123, 345] print(list1 > list3) # False不报错 list4 = [36, 345] print(list1 > list4) # True不报错 list5 = ["afsgd", "sdffsf"] # print(list1 > list5) #TypeError: '>' not supported between instances of 'int' and 'str' # 事实上，是以index为0的value向后逐个比较 print((list1 < list2) and (list1 < list3)) # True list6 = list1 + list3 print(list6) # 拼接，同extend，但+两边的操作数类型必须一致 print(list6 * 3) # 打印三次 print(123 in list1) # True print(123 not in list1) # False list7 = [123, ["abc", 456], 789] print("abc" in list7) # False,相当于index只管一层 print("abc" in list7[1]) # True # 通过类似于C的语法，打印列表中的列表 print(list7[1][1]) # 打印456 # 列表类型的BIF，小伙伴 # dir(list) list8 = [123, 456, 789, "abc", "def", 'a', 123, 666] # count:计算某个value在list中出现的次数,参数为value print(list8.count(123)) # index:返回某个value返回的index值 print(list8.index("abc")) # def index(self, *args, **kwargs): # real signature unknown # """ # Return first index of value. # # Raises ValueError if the value is not present. # """ # pass print(list8.index(123, 5, 7)) # 后两个参数是startint与stopint的index # reverse转置 list8.reverse() print(list8) # sort方法，以某种方式进行排序,默认从小到大 list9 = list8 # print(list9.sort()) #报错，'<' not supported between instances of 'str' and 'int' del list9[2:5] print(list9) list9.sort() print(list9) # 从大到小的方法：method1，先sort()在reverse()，method2：sort(func, key, reverse),reverse 默认为false list9.sort(reverse=True) print(list9) list10 = list9[:] list11 = list9 # 这两个是不一样的，L64是在内存中拷贝一个新的，L65可以理解为按引用传递

P14

# 带上枷锁的列表——元祖 # 元组和列表的区别，最大的区别是元祖不能修改元素 # 创建和访问 tuple1 = (1, 2, 3, 4, 5, 6, 7, 8)#用小括号 print(tuple1[:]) # tuple1[1] = 3 # #TypeError: 'tuple' object does not support item assignment temp1 = (1) temp2 = 1, 2, 3, 4 temp3 = (1, ) print(type(temp1))#int型 print(type(temp2))#tuple型 print(type(temp3))#tuple型 # 事实上，tuple的标志是, # 更新和删除一个元组 temp4 = ("NO.1", "NO.2", "NO.3", "NO.4", "NO.5") temp4 = temp4[:2] + ("charu", ) + temp4[2: ] print(temp4) # 元组相关操作符 # 拼接、重复、in、not in、关系、逻辑、都可以用

P15

# 字符串也可以切片 str1 = "I love SuperWG" str1 = str1[:2] + "very " + str1[2:] print(str1) # 拼接、重复、in、not in、关系、逻辑、都可以用 # capitalize() # 把字符串的第一个字符改为大写 # casefold() # 把整个字符串的所有字符改为小写 # center(width) # 将字符串居中，并使用空格填充至长度 width 的新字符串 # count(sub[, start[, end]]) # 返回 sub 在字符串里边出现的次数，start 和 end 参数表示范围，可选。 # encode(encoding='utf-8', errors='strict') # 以 encoding 指定的编码格式对字符串进行编码。 # endswith(sub[, start[, end]]) # 检查字符串是否以 sub 子字符串结束，如果是返回 True，否则返回 False。start 和 end 参数表示范围，可选。 # expandtabs([tabsize=8]) # 把字符串中的 tab 符号（\t）转换为空格，如不指定参数，默认的空格数是 tabsize=8。 # find(sub[, start[, end]]) # 检测 sub 是否包含在字符串中，如果有则返回索引值，否则返回 -1，start 和 end 参数表示范围，可选。 # index(sub[, start[, end]]) # 跟 find 方法一样，不过如果 sub 不在 string 中会产生一个异常。 # isalnum() # 如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True，否则返回 False。 # isalpha() # 如果字符串至少有一个字符并且所有字符都是字母则返回 True，否则返回 False。 # isdecimal() # 如果字符串只包含十进制数字则返回 True，否则返回 False。 # isdigit() # 如果字符串只包含数字则返回 True，否则返回 False。 # islower() # 如果字符串中至少包含一个区分大小写的字符，并且这些字符都是小写，则返回 True，否则返回 False。 # isnumeric() # 如果字符串中只包含数字字符，则返回 True，否则返回 False。 # isspace() # 如果字符串中只包含空格，则返回 True，否则返回 False。 # istitle() # 如果字符串是标题化（所有的单词都是以大写开始，其余字母均小写），则返回 True，否则返回 False。 # isupper() # 如果字符串中至少包含一个区分大小写的字符，并且这些字符都是大写，则返回 True，否则返回 False。 # join(sub) # 以字符串作为分隔符，插入到 sub 中所有的字符之间。 # ljust(width) # 返回一个左对齐的字符串，并使用空格填充至长度为 width 的新字符串。 # lower() # 转换字符串中所有大写字符为小写。 # lstrip() # 去掉字符串左边的所有空格 # partition(sub) # 找到子字符串 sub，把字符串分成一个 3 元组 (pre_sub, sub, fol_sub)，如果字符串中不包含 sub 则返回 ('原字符串', '', '') # replace(old, new[, count]) # 把字符串中的 old 子字符串替换成 new 子字符串，如果 count 指定，则替换不超过 count 次。 # rfind(sub[, start[, end]]) # 类似于 find() 方法，不过是从右边开始查找。 # rindex(sub[, start[, end]]) # 类似于 index() 方法，不过是从右边开始。 # rjust(width) # 返回一个右对齐的字符串，并使用空格填充至长度为 width 的新字符串。 # rpartition(sub) # 类似于 partition() 方法，不过是从右边开始查找。 # rstrip() # 删除字符串末尾的空格。 # split(sep=None, maxsplit=-1) # 不带参数默认是以空格为分隔符切片字符串，如果 maxsplit 参数有设置，则仅分隔 maxsplit 个子字符串，返回切片后的子字符串拼接的列表。 # splitlines(([keepends])) # 在输出结果里是否去掉换行符，默认为 False，不包含换行符；如果为 True，则保留换行符。。 # startswith(prefix[, start[, end]]) # 检查字符串是否以 prefix 开头，是则返回 True，否则返回 False。start 和 end 参数可以指定范围检查，可选。 # strip([chars]) # 删除字符串前边和后边所有的空格，chars 参数可以定制删除的字符，可选。 # swapcase() # 翻转字符串中的大小写。 # title() # 返回标题化（所有的单词都是以大写开始，其余字母均小写）的字符串。 # translate(table) # 根据 table 的规则（可以由 str.maketrans('a', 'b') 定制）转换字符串中的字符。 # upper() # 转换字符串中的所有小写字符为大写。 # zfill(width) # 返回长度为 width 的字符串，原字符串右对齐，前边用 0 填充。 str2 = "xiaoxie" #capitalize 把第一个改为大写 str2.capitalize() print(str2) print(str2.capitalize()) print(str2.capitalize().casefold()) # casefold把所有的大写改为小写 # center 居中 print(str2.center(15)) print(str2.count("xi")) # count查找 print(str2.endswith("xi")) print(str2.endswith("ie")) # endswith检查是否以某一个特定的字符串结尾，返回true或者false str3 = "I\tlove\tSuperWG" print(str3.expandtabs()) # 把\t全部换成空格，默认tabsize = 8 print(str3.find("efc")) print(str3.find("WG")) str4 = "I Love Superwg" print(str4.istitle()) # 检测是否是title即每个单词首字母是大写，其余小写 print(str4.join("12345")) # sub被string分隔开 str5 = " SuperWg " print(str5.lstrip()) # 去掉左边的空格 print(str5.rstrip()) # 去掉右边的空格 print(str4.partition("ov")) # 分成一个三元组 # 结果 ('I L', 'ov', 'e Superwg') # pre_sub, sub, fol_sub print(str4.replace("Superwg", "SuperWAG")) # rfind, 从右查找，同find， rindex同 print(str4.split()) # 默认以空格切 print(str4.split('o')) # o不见了 # strip()默认删除前面和后面的空格，否则前后去除参数value str6 = " I Love SuperWG " print(str6.strip()) print(str6.swapcase()) # 大小写重置 str7 = "ssssssssssspppppppppppwwwwwwwgggggggg" print(str7.translate(str.maketrans('s', 'b'))) # 理解：str.maketrans()返回的是ASCII码 print(str.maketrans('a', 'b')) # 返回97 98 # 然后translate根据97 98的规则，重置str7的s->b

P16

# 格式化 print("{0} love {1}. {2}".format('I', "SUPER", "WG")) # 位置参数{1}{2}{3} print("{a} love {b}. {c}".format(a='I', c="SUPER", b="WG")) # 关键字参数{a}{b}{c} print("{0} love {b}. {c}".format('I', c="SUPER", b="WG")) # 关键字参数与位置参数混用是可以的，但必须注意的是位置参数必须在关键字参数的前面，否则报错 print("{0:.1f}{1}".format(27.874, "GB")) # :的意思是限定格式输出符 # 字符串格式化符号含义 # %c # 格式化字符及其 ASCII 码 # %s # 格式化字符串 # %d # 格式化整数 # %o # 格式化无符号八进制数 # %x # 格式化无符号十六进制数 # %X # 格式化无符号十六进制数（大写） # %f # 格式化浮点数字，可指定小数点后的精度 # %e # 用科学计数法格式化浮点数 # %E # 作用同 %e，用科学计数法格式化浮点数 # %g # 根据值的大小决定使用 %f 或 %e # %G # 作用同 %g，根据值的大小决定使用 %f 或者 %E # 格式化操作符辅助命令 # m.n # m 是显示的最小总宽度，n 是小数点后的位数 # - # 用于左对齐 # + # 在正数前面显示加号（+） # # # 在八进制数前面显示 '0o'，在十六进制数前面显示 '0x' 或 '0X' # 0 # 显示的数字前面填充 '0' 取代空格 # Python 的转义字符及其含义 # \' # 单引号 # \" # 双引号 # \a # 发出系统响铃声 # \b # 退格符 # \n # 换行符 # \t # 横向制表符（TAB） # \v # 纵向制表符 # \r # 回车符 # \f # 换页符 # \o # 八进制数代表的字符 # \x # 十六进制数代表的字符 # \0 # 表示一个空字符 # \\ # 反斜杠 print('%c' % 97) print('%c, %c, %c' % (97, 98, 99)) print('%d + %x = %f' % (5, 16, 0.65))

P17

# max返回序列中的最大值 a = [446, 4, "afsdf", 5] # print(max([646, "afsdf", 646])) 报错要同类型 print(max([646, 1651, 646])) a.remove("afsdf") print(max(a)) print(sum(a)) print(sum(a, 8)) # a + 8 print(sorted(a)) print(reversed(a)) # 返回的是一个迭代器对象 print(list(reversed(a))) print(list(enumerate(a))) # 强转为list # 把index值插入到list里,并且形成元组 print(list(zip(a))) b = [1, 2, 8, 4] print(list(zip(a, b))) # 对于元素打包zip起来，成对为元组

P18

# 函数、对象、模块 # 函数 def MyFirstFunction(): print("Hello, World") MyFirstFunction() def MySecondFunction(name): print("我爱" + name) MySecondFunction("SuperWG")

P19

# 形参 parameter 实参 argument def test(* parameter): print("参数的长度是：", len(parameter)) print("第二个参数是：", parameter[1]) test(1, "SuperWG", 3.14, 5, 6) # 理解：收集参数是把参数用元组打包起来，放到parameter里 def test2(* parameter, exp): #收集参数与其他参数并存，建议是在实现的时候声明exp = ..., 同时声明是默认exp = ... print("参数的长度是：", len(parameter), exp) print("第二个参数是：", parameter[1]) test2(1, "SuperWG", 3.14, 5, 6, exp=8)

P20

# 函数没有写return的时候，并不是不返回任何东西，而是返回一个叫NoneType(none)的格式 # python可以有多个返回值 def back(): return [1, "SuperWG", 3.45] # return 1, "SuperWG", 3.45 也是可以的，本质上是1, "SuperWG", 3.45是打包成了元组 print(back())

P21 TO P30

P21

# global关键字 # Eg count = 5 def Fun(): count = 10 print(count) Fun() # 10 print(count) # 5 # 如果真想在函数中修改全局变量的值使用global def Fun2(): global count count = 10 print(count) Fun2() # 10 print(count) # 10 # 内置函数 def func1(): print("func1正在被调用") def func2(): print("func2正在被调用") func2() # 这个不能缺少 func1() # func2() #报错,func2只能在func1里调用 # 闭包 def FunX(x): def FunY(y): return x * y return FunY # 再执行FunY # FunY构成闭包 print(type(FunX(8))) # type为function i = FunX(8) print(i(5)) print(FunX(8)(5)) # def fun1(): # x = 5 # def fun2(): # x *= x # unresolved reference 未明确的变量x，这里可以x是没法访问fun1中的x的，即屏蔽shadowing # return x # return fun2() # 改造 def fun1(): x = [5] def fun2(): x[0] *= x[0] return x[0] return fun2() print(fun1()) # 打印25 def fun1(): x = 5 def fun2(): nonlocal x # nonlocal关键字也可以 x *= x return x return fun2()

P22

# lambda表达式与匿名函数 def ds(x): return 2 * x + 1 print(ds(5)) # :前是原函数参数，后面是返回值 # 返回的是一个对象 g = lambda x: 2 * x + 1 print(type(g)) # 返回的是一个function类型 print(g(5)) # 这样用就可以，给g传一个参数 sum = lambda x, y: x + y print(sum(2, 4)) # lambda函数可以使得代码更加精简 # 两个比较实用的BIF print(list(filter(None, [1, 0, True, False]))) # 打印1， True，filter可以将非true的内容过滤掉 # 可以给filter写过滤规则 def odd(x): return x % 2 temp = range(10) show = filter(odd, temp) print(list(show)) # 把奇数打印出来 # map映射 print(list(map(lambda x : x * 2, range(10)))) # 对可迭代的对象的每个元素进行加工，加工后形成一个新的序列

P23

def jiecheng(x): if x == 1: return 1 else: return jiecheng(x - 1) * x print(jiecheng(100))

P26

# key与value，python的字典又称为hash # 创建和访问字典 dict1 = {"李宁":"一切皆有可能", "耐克":"just do it", "阿迪达斯":"nothing is impossible", "SuperWG":"学习python的字典"} print("SuperWG的口号是", dict1["SuperWG"]) # 字典标志性的字符是{} dict2 = {1:"one", 2:"two", 3:"three"} print(dict2[2]) dict3 = {} dict3 = dict((('F', 70), ('i', 105), ('s', 115))) # 打包成元组 print(dict3) dict4 = dict(SuperWG = "认真学习python", 苍老师 = "让AV征服所有宅男") print(dict4) dict4["苍老师"] = "所有AV从业者都要通过编程提高职业技能" print(dict4) dict4["爱迪生"] = "天才就是99%的汗水加1%的灵感" # 自动创建一个新的key和value print(dict4)

P27

# dict()可以成为工厂函数 # 字典的BIF dict1 = {} print(dict1.fromkeys((1, 2, 3))) print(dict1.fromkeys((1, 2, 3), "Number")) # keys()、 dict1 = dict1.fromkeys(range(32), "赞") print(dict1) for eachkey in dict1.keys(): print(eachkey) for eachvalue in dict1.values(): print(eachvalue) for eachitem in dict1.items(): print(eachitem) # key + value = item print(dict1.get(32)) dict1.get(32, "木有") print(dict1.get(32)) # 清空字典用clear方法 dict1.clear() dict1.copy() # 浅拷贝 # 关于赋值和copy的区别 a = {1:"one", 2:"two", 3:"three"} b = a.copy() c = a print(id(a)) # 1538206143936 print(id(b)) # 1538207530048 print(id(c)) # 1538206143936 =和a地址相同，只是在相同的数据上贴了一个标签 # 验证 c[4] = "four" print(c) # {1: 'one', 2: 'two', 3: 'three', 4: 'four'} print(a) # {1: 'one', 2: 'two', 3: 'three', 4: 'four'} print(b) # {1: 'one', 2: 'two', 3: 'three'} # pop是给定key弹出value，popitem方法返回并删除字典中的最后一对键和值 print(a.pop(2)) print(a) print(a.popitem()) print(a) # update方法,用字典更新字典 b = {"小白":"狗"} a.update(b) print(a)

P28

# 集合set，元素是唯一的 # 不支持index a = {1, 2, 3, 4} # 直接设置集合 set1 = set([1, 2, 3, 4, 4]) print(set1) # 不可变集合 frozen num3 = frozenset([1, 2, 3, 4, 5]) # https://fishc.com.cn/forum.php?mod=viewthread&tid=45276&extra=page=1&filter=typeid&typeid=403 # 集合类型内建方法总结 # # 集合（s）.方法名 # 等价符号 # 方法说明 # s.issubset(t) # s <= t # 子集测试（允许不严格意义上的子集）：s # 中所有的元素都是 # t # 的成员 # s < t # 子集测试（严格意义上）：s != t # 而且 # s # 中所有的元素都是 # t # 的成员 # s.issuperset(t) # s >= t # 超集测试（允许不严格意义上的超集）：t # 中所有的元素都是 # s # 的成员 # s > t # 超集测试（严格意义上）：s != t # 而且 # t # 中所有的元素都是 # s # 的成员 # s.union(t) # s | t # 合并操作：s # "或" # t # 中的元素 # s.intersection(t) # s & t # 交集操作：s # "与" # t # 中的元素 # s.difference # s - t # 差分操作：在 # s # 中存在，在 # t # 中不存在的元素 # s.symmetric_difference(t) # s ^ t # 对称差分操作：s # "或" # t # 中的元素，但不是 # s # 和 # t # 共有的元素 # s.copy() # 返回 # s # 的拷贝（浅复制） # 以下方法仅适用于可变集合 # s.update # s |= t # 将 # t # 中的元素添加到 # s # 中 # s.intersection_update(t) # s &= t # 交集修改操作：s # 中仅包括 # s # 和 # t # 中共有的成员 # s.difference_update(t) # s -= t # 差修改操作：s # 中包括仅属于 # s # 但不属于 # t # 的成员 # s.symmetric_difference_update(t) # s ^= t # 对称差分修改操作：s # 中包括仅属于 # s # 或仅属于 # t # 的成员 # s.add(obj) # 加操作：将 # obj # 添加到 # s # s.remove(obj) # 删除操作：将 # obj # 从 # s # 中删除，如果 # s # 中不存在 # obj，将引发异常 # s.discard(obj) # 丢弃操作：将 # obj # 从 # s # 中删除，如果 # s # 中不存在 # obj，也没事儿 ^ _ ^ # s.pop() # 弹出操作：移除并返回 # s # 中的任意一个元素 # s.clear() # 清除操作：清除 # s # 中的所有元素

P30

# 文件打开模式 # https://fishc.com.cn/forum.php?mod=viewthread&tid=45279&extra=page=1&filter=typeid&typeid=403 # 打开模式执行操作 # 'r' 以只读方式打开文件（默认） # 'w' 以写入的方式打开文件，会覆盖已存在的文件 # 'x' 如果文件已经存在，使用此模式打开将引发异常 # 'a' 以写入模式打开，如果文件存在，则在末尾追加写入 # 'b' 以二进制模式打开文件 # 't' 以文本模式打开（默认） # '+' 可读写模式（可添加到其他模式中使用） # 'U' 通用换行符支持 # # # 文件对象方法 # # 文件对象方法执行操作 # f.close() 关闭文件 # f.read([size=-1]) 从文件读取size个字符，当未给定size或给定负值的时候，读取剩余的所有字符，然后作为字符串返回 # f.readline([size=-1]) 从文件中读取并返回一行（包括行结束符），如果有size有定义则返回size个字符 # f.write(str) 将字符串str写入文件 # f.writelines(seq) 向文件写入字符串序列seq，seq应该是一个返回字符串的可迭代对象 # f.seek(offset, from) 在文件中移动文件指针，从from（0代表文件起始位置，1代表当前位置，2代表文件末尾）偏移offset个字节 # f.tell() 返回当前在文件中的位置 # f.truncate([size=file.tell()]) 截取文件到size个字节，默认是截取到文件指针当前位置

P31 TO P40

P31

# os模块中关于文件/目录常用的函数使用方法 # https://fishc.com.cn/forum.php?mod=viewthread&tid=45512&extra=page=1&filter=typeid&typeid=403 # # 函数名 # 使用方法 # getcwd() # 返回当前工作目录 # chdir(path) # 改变工作目录 # listdir(path='.') # 列举指定目录中的文件名（'.'表示当前目录，'..'表示上一级目录） # mkdir(path) # 创建单层目录，如该目录已存在抛出异常 # makedirs(path) # 递归创建多层目录，如该目录已存在抛出异常，注意：'E:\\a\\b'和'E:\\a\\c'并不会冲突 # remove(path) # 删除文件 # rmdir(path) # 删除单层目录，如该目录非空则抛出异常 # removedirs(path) # 递归删除目录，从子目录到父目录逐层尝试删除，遇到目录非空则抛出异常 # rename(old, new) # 将文件old重命名为new # system(command) # 运行系统的shell命令 # walk(top) # 遍历top路径以下所有的子目录，返回一个三元组：(路径, [包含目录], [包含文件])【具体实现方案请看：第30讲课后作业^_^】 # 以下是支持路径操作中常用到的一些定义，支持所有平台 # os.curdir # 指代当前目录（'.'） # os.pardir # 指代上一级目录（'..'） # os.sep # 输出操作系统特定的路径分隔符（Win下为'\\'，Linux下为'/'） # os.linesep # 当前平台使用的行终止符（Win下为'\r\n'，Linux下为'\n'） # os.name # 指代当前使用的操作系统（包括：'posix', 'nt', 'mac', 'os2', 'ce', 'java'）

P32

# pickle模块，泡菜腌菜 import pickle my_list = [123, 3.14, "SuperWG", ["another list"]] pickle_file = open("my_list.pkl", "wb") pickle.dump(my_list, pickle_file) pickle_file.close() pickle_file = open("my_list.pkl", "rb") my_list2 = pickle.load(pickle_file) print(my_list2)

P33

# Exception的用法 # https://fishc.com.cn/forum.php?mod=viewthread&tid=45814&extra=page=1&filter=typeid&typeid=403 # AssertionError 断言语句（assert）失败 # AttributeError 尝试访问未知的对象属性 # EOFError 用户输入文件末尾标志EOF（Ctrl+d） # FloatingPointError 浮点计算错误 # GeneratorExit generator.close()方法被调用的时候 # ImportError 导入模块失败的时候 # IndexError 索引超出序列的范围 # KeyError 字典中查找一个不存在的关键字 # KeyboardInterrupt 用户输入中断键（Ctrl+c） # MemoryError 内存溢出（可通过删除对象释放内存） # NameError 尝试访问一个不存在的变量 # NotImplementedError 尚未实现的方法 # OSError 操作系统产生的异常（例如打开一个不存在的文件） # OverflowError 数值运算超出最大限制 # ReferenceError 弱引用（weak reference）试图访问一个已经被垃圾回收机制回收了的对象 # RuntimeError 一般的运行时错误 # StopIteration 迭代器没有更多的值 # SyntaxError Python的语法错误 # IndentationError 缩进错误 # TabError Tab和空格混合使用 # SystemError Python编译器系统错误 # SystemExit Python编译器进程被关闭 # TypeError 不同类型间的无效操作 # UnboundLocalError 访问一个未初始化的本地变量（NameError的子类） # UnicodeError Unicode相关的错误（ValueError的子类） # UnicodeEncodeError Unicode编码时的错误（UnicodeError的子类） # UnicodeDecodeError Unicode解码时的错误（UnicodeError的子类） # UnicodeTranslateError Unicode转换时的错误（UnicodeError的子类） # ValueError 传入无效的参数 # ZeroDivisionError 除数为零 # 以下是 Python 内置异常类的层次结构： # # BaseException # +-- SystemExit # +-- KeyboardInterrupt # +-- GeneratorExit # +-- Exception # +-- StopIteration # +-- ArithmeticError # | +-- FloatingPointError # | +-- OverflowError # | +-- ZeroDivisionError # +-- AssertionError # +-- AttributeError # +-- BufferError # +-- EOFError # +-- ImportError # +-- LookupError # | +-- IndexError # | +-- KeyError # +-- MemoryError # +-- NameError # | +-- UnboundLocalError # +-- OSError # | +-- BlockingIOError # | +-- ChildProcessError # | +-- ConnectionError # | | +-- BrokenPipeError # | | +-- ConnectionAbortedError # | | +-- ConnectionRefusedError # | | +-- ConnectionResetError # | +-- FileExistsError # | +-- FileNotFoundError # | +-- InterruptedError # | +-- IsADirectoryError # | +-- NotADirectoryError # | +-- PermissionError # | +-- ProcessLookupError # | +-- TimeoutError # +-- ReferenceError # +-- RuntimeError # | +-- NotImplementedError # +-- SyntaxError # | +-- IndentationError # | +-- TabError # +-- SystemError # +-- TypeError # +-- ValueError # | +-- UnicodeError # | +-- UnicodeDecodeError # | +-- UnicodeEncodeError # | +-- UnicodeTranslateError # +-- Warning # +-- DeprecationWarning # +-- PendingDeprecationWarning # +-- RuntimeWarning # +-- SyntaxWarning # +-- UserWarning # +-- FutureWarning # +-- ImportWarning # +-- UnicodeWarning # +-- BytesWarning # +-- ResourceWarning

P34

# try_except语句 try: f = open("我为什么是个文件.txt") print(f.read()) f.close() except OSError: print("文件出错啦~") try: f = open("我为什么是个文件.txt") print(f.read()) f.close() except OSError as reason: print("文件出错啦~\n出错的原因是：" + str(reason)) try: sum = 1 + '1' f = open("我为什么是个文件.txt") print(f.read()) f.close() except OSError as reason: print("文件出错啦~\n出错的原因是：" + str(reason)) except TypeError as reason: print("类型出错啦~\n出错的原因是：" + str(reason)) # try一旦检测到错误，try中错误的语句下面的语句将不再执行 try: sum = 1 + '1' f = open("我为什么是个文件.txt") print(f.read()) f.close() except (OSError,TypeError) as reason: # 可以合并 print("出错啦~\n" + str(reason)) finally: print("执行finally") # 确保执行的语句，无论是否触发异常 # 自己引发异常的办法raise raise ZeroDivisionError raise TypeError

P35

# 丰富的else语句 # 要么怎样，要么不怎样 # 干完了能怎样，干不完就别想怎样 # 没有问题，那就干吧 def showMaxFactor(num): count = num // 2 # //表示整数除法 while count > 1: if num % count == 0: print("%d最大的约数是：%d" %(num, count)) break count -= 1 else: print("%d是素数！" % num) num = int(input("请输入一个数：")) showMaxFactor(num) # with语句 # try: # f = open("data.txt", "w") # for each_line in f: # print(each_line) # except OSError as reason: # print("出错啦：" + str(reason)) # finally: # f.close() # 这样写有风险，因为data.txt可能不存在，这样的话，程序就会关闭一个不存在的文件 # 使用with语句 try: with open("data.txt", "w") as f: # with可以自动帮你关闭文件 for each_line in f: print(each_line) except OSError as reason: print("出错啦：" + str(reason))

P36

# GUI编程 # EasyGUI 比较简单 import easygui as eg eg.msgbox("SuperWG")

P37

# 类和对象 # 对象 = 属性 +方法 # 类名约定以大写字母开头 class Turtle: # 属性 color = "green" weight = 10 legs = 4 shell = True # 方法 def climb(self): print("我正在努力的跑") def run(self): print("我正在飞快的跑") tt = Turtle() tt.climb() tt.run() # 面向对象 object-orientated # 封装，list.sot # 继承 class MyList(list): # 继承list pass # pass的意思是占位，不作任何事情 list2 = MyList() list2.append(5) print(list2) # 继承了list的方法和属性 # 多态 # 不同对象对同一函数不同的反应 class A: def fun(self): print("我是小A") class B: def fun(self): print("我是小B") a = A() b = B() a.fun() b.fun() # 都调用了fun，但实现不一样即多态

P38

# OOA/OOD/OOP # self是？ # self就相当于this指针 class Ball: def setName(self, name): self.name = name def kick(self): print("我叫%s,谁踢我了？？？？" % self.name) a = Ball() a.setName("球A") b = Ball() b.setName("球B") c = Ball() c.setName("球C") a.kick() a.setName("球666") a.kick() b.kick() c.kick() # python的魔法方法以双下划线开头 # 比如__init__(self)也就是构造函数 class BallBall: def __init__(self, name): self.name = name def kick(self): print("我叫%s,谁踢我了？？？？" % self.name) b = BallBall("SuperWG") b.kick() # 共有与私有 class Person: name = "SuperWG" # name mangling 名字改编，名字重组技术 p = Person() print(p.name) # 在python中定义私有类型只需要在变量前或函数名前加上__那么此变量or函数就会变为私有的了 class PersonTwo: __name = "SuperWG" p1 = PersonTwo() # print(p1.name) # 报错 # 如果声明为私有，还想要访问那么就这么写 class PersonThree: __name = "SuperWG" def getname(self): return self.__name p2 = PersonThree() # print(p2.name) # 报错 print(p2.getname() + "6666") # 通过getname返回私有变量值 # 或者 print(p2._PersonThree__name) # 伪私有，本质上。

P39

# 继承 class Parent: def hello(self): x = 10 print(x) print("正在调用父类的方法") class Child(Parent): pass c = Child() c.hello() # 如果子类中定义与父类同名的方法或属性，那么子类会自动覆盖父类对应的方法或属性 class Children(Parent): def hello(self): # 覆盖掉父类 print("正在调用子类的方法") children = Children() children.hello() # 子类如果和父类有同名的函数，但又想，有两种办法 # 法一 # 调用未绑定的父类方法 class Children2(Parent): def hello(self): # 覆盖掉父类 print("正在调用父类的同名函数") Parent.hello(self) # 调用父类的同名函数，把子类的self传进去了，同Parent.hello(Children2) print("正在调用子类的方法") children2 = Children2() children2.hello() # 法二 # Super()函数 class Children3(Parent): def hello(self): # 覆盖掉父类 print("正在调用父类的同名函数") super().hello() print("正在调用子类的方法") children3 = Children3() children3.hello() # 多重继承 # class XXX(Base 1, Base 2, Base 3)

P40

# 组合 # 水池和乌龟的组合？ class Turtle: def __init__(self, x): self.num = x class Fish: def __init__(self, x): self.num = x class Pool: def __init__(self, x, y): self.turtle = Turtle(x) self.fish = Fish(y) def print_num(self): print("水池里总共有乌龟%d只，小鱼%d条！" % (self.turtle.num, self.fish.num)) pool = Pool(5, 10) pool.print_num() # 这就是组合！！！ # Mix-in # 类、类对象、实例对象

P41 TO P50

P41

#!/usr/bin/env python # -*- coding: utf-8 -*- # @Time : 2020/6/29 16:38 # @Author : SuperWG # @File : P41.py # @Software: PyCharm # 一些和类有关的BIF # issubclass(class, classinfo) # 一个类被认为是自己的子类 # classinfo可以使类对象组成的元组，只要class与其中任何一个候选类的子类匹配，则返回true class A: pass class B(A): pass print(issubclass(B, A)) # true print(issubclass(B, B)) # true print(issubclass(B, object)) # 所有的类都是object的子类 # isinstance(object, classinfo) # 如果第一个参数不是对象，永远返回false # 如果第二个参数不是类或者由类对象组成的元组，会抛出一个TypeError print(isinstance(B, A)) # false b1 = B() print(isinstance(b1, B)) # true # b1是B的实例化对象 print(isinstance(b1, A)) # true # B继承A，而b1又是B的实例化对象，即b1是A的实例化对象 # hasattr(object, name) # attr = attribute:属性 # 测试一个对象是否有指定的属性 class C: def __init__(self, x = 0): self.x = x c1 = C() print(hasattr(c1, 'x')) # true,x是c1的属性，注意x必须要用字符串 # getattr(object, name[, default]) # 返回对象指定的属性值 print(getattr(c1,'x')) # 返回0 print(getattr(c1, 'y', "不存在！")) # 不存在！ # setattr(object, name, value) # 设定特定属性值 setattr(c1, 'y', 5) print(hasattr(c1, 'y')) # true # delattr(object, name) # 删除对象中指定的属性 delattr(c1, 'y') print(hasattr(c1, 'y')) # false # property(fget = none, fset = none, fdel = none, doc = none) # 靠属性设置属性 class C: def __init__(self, size = 10): self.size = 10 def getsize(self): return self.size def Setsize(self, value): self.size = value def delsize(self): del self.size x = property(getsize, Setsize, delsize) c1 = C() print(c1.getsize()) print(c1.x) # 直接调用第一个参数的方法 c1.x = 18 # 直接调用第二个参数的方法 print(c1.x) print(c1.getsize()) del c1.x # 直接调用第三个参数的方法 print(c1.size) """Traceback (most recent call last): File "D:/python-ex/P41.py", line 80, in <module> print(c1.size) AttributeError: 'C' object has no attribute 'size' """

P42

#!/usr/bin/env python # -*- coding: utf-8 -*- # @Time : 2020/7/1 10:16 # @Author : SuperWG # @File : P42.py # @Software: PyCharm # __init_(self[, ...]) # 构造函数 # 最先调用的其实是__new__(cls[, ...]) # __del__(self) # 析构函数

P46

# __getattr__(self, name) 定义当用户试图获取一个不存在的属性时的行为 # __getattribute__(self, name) 定义当该类的属性被访问时的行为 # __setattr__(self, name, value) 定义当一个属性被设置时的行为 # __delattr__(self, name) 定义当一个属性被删除时的行为

P51 TO P60

P51

# 导入模块 # import 模块名 # from 模块名 impot 函数名 # import 模块名 as 新名字

P52

import easygui print(easygui.__doc__)

P54

# 网络爬虫 # python如何访问互联网？ # URI+lib = urllib # URI的基本格式： protocol:// hostname[:port] / path /[;parameters][?query]#fragment # URI由三部分组成 # 第一部分 # 协议: http, https, ftp, file, ed2k... # 第二部分是存放资源的服务器的域名系统或IP地址（有时候要包含端口号，各种传输协议都有默认的端口号，如http的默认端口号为80） # 第三部分是资源的具体地址，如目录或文件名等 import urllib.request response = urllib.request.urlopen("https://www.baidu.com") html = response.read() html = html.decode("utf-8") print(html)

P55

#!/usr/bin/env python # -*- coding: utf-8 -*- # @Time : 2020/7/1 15:22 # @Author : SuperWG # @File : P55.py # @Software: PyCharm # 实战1，下载小猫图片 import urllib.request import urllib.parse import json import time # respones = urllib.request.urlopen("http://placekitten.com/500/600") # cat_img = respones.read() # with open("cat_500_600.jpg", "wb") as f: # f.write((cat_img)) # print(respones.info()) # 实战2，自动翻译 while True: content = input("请输入需要翻译的内容（输入quit退出程序！）：") if content == "quit": break url = "http://fanyi.youdao.com/translate" data = {} data['i'] = content data['from'] = "AUTO" data['to'] = "AUTO" data['smartresult'] = "dict" data['client'] = "fanyideskweb" data['salt'] = "15935887053667" data['sign'] = "57a6d11d858ed157f60daa442a087861" data['ts'] = "1593588705366" data['bv'] = "02a6ad4308a3443b3732d855273259bf" data['doctype'] = "json" data['version'] = "2.1" data['keyfrom'] = "fanyi.web" data['action'] = "FY_BY_REALTlME" data = urllib.parse.urlencode(data).encode('utf-8') req = urllib.request.Request(url, data) req.add_header("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36") response = urllib.request.urlopen(req) html = response.read().decode('utf-8') target = json.loads(html) # json转换 print("翻译结果是：%s" % target["translateResult"][0][0]["tgt"]) time.sleep(5)

P56

#!/usr/bin/env python # -*- coding: utf-8 -*- # @Time : 2020/7/1 15:59 # @Author : SuperWG # @File : P56.py # @Software: PyCharm # 隐藏 # 通过Request的header参数修改 # 通过Request.add_headers()方法修改 # 代理 import urllib.request import urllib.parse import json import time # 实战2，自动翻译 # while True: # content = input("请输入需要翻译的内容（输入quit退出程序！）：") # if content == "quit": # break # url = "http://fanyi.youdao.com/translate" # data = {} # data['i'] = content # data['from'] = "AUTO" # data['to'] = "AUTO" # data['smartresult'] = "dict" # data['client'] = "fanyideskweb" # data['salt'] = "15935887053667" # data['sign'] = "57a6d11d858ed157f60daa442a087861" # data['ts'] = "1593588705366" # data['bv'] = "02a6ad4308a3443b3732d855273259bf" # data['doctype'] = "json" # data['version'] = "2.1" # data['keyfrom'] = "fanyi.web" # data['action'] = "FY_BY_REALTlME" # data = urllib.parse.urlencode(data).encode('utf-8') # req = urllib.request.Request(url, data) # req.add_header("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36") # response = urllib.request.urlopen(req) # html = response.read().decode('utf-8') # target = json.loads(html) # json转换 # print("翻译结果是：%s" % target["translateResult"][0][0]["tgt"]) # time.sleep(5) # 代理 # 参数是一个字典{"类型":"代理IP：端口号"} # proxy_support = urllib.request.ProxyHandler({}) # 定制、创建一个opener # opener = urllib.request.build_opener(proxy_support) # 安装opener # urllib.request.install_opener(opener) # 调用opener # opener.open(url) import random url = "http://www.whatsmyip.net/" iplist = ["119.6.144.73:81","183.203.200.166:8118", "111.1.32.28:81"] proxy_support = urllib.request.ProxyHandler({"https":random.choice(iplist)}) opener = urllib.request.build_opener(proxy_support) opener.addheaders = [("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36")] urllib.request.install_opener(opener) response = urllib.request.urlopen(url) html = response.read().decode("utf-8") print(html)

P57

#!/usr/bin/env python # -*- coding: utf-8 -*- # @Time : 2020/7/1 17:32 # @Author : SuperWG # @File : P57.py # @Software: PyCharm import urllib.request import os def get_page(url): req = urllib.request.Request(url) req.add_header("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36") response = urllib.request.urlopen(url) html = response.read().decode("utf-8") a = html.find("current-comment-page") + 23 b = html.find("]", a) return int(html[a:b]) print(html[a:b]) def find_imgs(url): pass def save_imgs(folder, url): pass def download_mm(folder = "OOXX", pages = 10): os.mkdir(folder) os.chdir(folder) url = "http://jandan.net/ooxx/" page_num = int(get_page(url)) for i in range(pages): page_num -= i # http://jandan.net/ooxx/MjAyMDA3MDEtMTI5#comments page_url = url + "MjAyMDA3MDEtMTI" + str(page_num) + "#comments" img_addrs = find_imgs(page_url) save_imgs(folder, img_addrs) if __name__ == "__main__": download_mm()

以上如果此篇博客对您有帮助欢迎点赞与转发有疑问请留言或私信 2020/7/3

Processed: 0.018, SQL: 9