Python笔记

Python笔记

• 知识点备忘
• 速查宝典
• 扩展阅读

import random产生随机数的包

random.randint(下限，上限)
变量 = random.getstate()
random.setstate(_)括号内填写的是上一行“变量”的信息

import decimal处理浮点数不精确的问题

变量 = decimal.Decimal("浮点数")

复数(complex)

变量 = 实部+虚部j
变量.real(获得实部的数值)
变量.imag(获得虚部的数值)

运算

//(地板除)#得到比商小的最大整数
divmod(a,b)得到的结果：(a//b,a%b)
abs(x)得到的结果：|x|(如果x为复数的话，得到的是复数的模)
强制类型转换：int(),float(),str(),complex()#复数
pow(a,b)#a的b次方 == a**b
pow(a,b,c) == a**b%c
True == 1     False == 0

逻辑运算

and,or,not(or < and < not)  not<普通运算符(+,-,*,/)
int1 and int2 得到的结果：intmax={int1,int2}(int1,int2 != 0)
int1 or int2 得到的结果：int1(int1 != 0)短路逻辑

分支

if condition1 :
	statement1(s)
elif condition2 :
	statement2(s)
else :
	statement3(s)

条件成立时执行的语句 if condition else 条件不成立时执行的语句

循环

break ------退出循环
continue ---退出本轮循环
len(_) -----获取一个对象的长度

while condition :
	statement(s)
else :
else ------ 最大的作用就是当break执行时，else下的语句不会被执行；
			其他时候相当于是在循环语句外的的语句

for 变量 in 可迭代对象 :
	statement(s)
else :
else ------ 最大的作用就是当break执行时，else下的语句不会被执行；
			其他时候相当于是在循环语句外的的语句

range(stop)					   ----“变量”属于int([0,stop))
range(start,stop)			    ---“变量”属于int([start,stop))
range(start,stop,step)			---“变量”属于int([start,stop))  ---step指定步长(可为负数)

列表

len(list)获取列表的长度
for i in list:
	print(i)

切片

列表名[ start : stop ]如果头和尾分别是列表的头和尾可省略
列表名[ start : stop : step ]---step指定步长(可为负数)

添加

只能在列表末尾进行添加：
	列表名.append(元素)			== 列表名[len(list):] = [一个元素]
		一次只能添加一个					
	列表名.extend(list)			== 列表名[len(list):] = [多个元素]
		可添加多个,追加到原列表的后面	
	利用切片法进行添加:列表名[len(列表名):] = list

指定位置进行添加：
	列表名.insert(索引值，添加元素)

删除

列表名.remove(元素):
	如果列表中存在多个匹配的元素，只删除第一个；
	指定元素如果不在列表内，会报错.
列表名.pop(索引值):
	指定位置删除元素
列表名.clear():
	清空列表

替换

列表名[索引值] = [一个元素]
	替换一个
列表名[切片] = [多个元素]
	替换多个

排序

列表名.sort()
	对只含数字的列表进行排序(从小到大)
列表名.sort(reverse=True)
	对只含有数字的列表进行排列(从大到小)
列表名.reverse()
	对列表进行倒序排序

查找

列表名.count(元素)
	查找元素的个数
列表名.index(元素，start，stop)#start，stop是索引值
	查找元素的索引值；
	多个元素时只输出第一个元素的索引值。

复制

列表名2 = 列表名1.copy()		==		列表名2 = 列表名1[:]#利用切片的方法进行复制

运算

列表1 + 列表2 #将两个列表的元素进行拼接
列表 * n #将列表中的元素重复n次拼接在列表的末尾		---相当于n个列表进行相加

嵌套

相当于二维数组

嵌套列表的生成

'''
A = [0] * 3
	for i in range(3):
		A[i] = [0] * 3
'''
A = [[0] * 3 for i in range(3)]
#错误示范:
A = [[0] * 3] * 3

嵌套列表的拷贝

import copy
列表名2 = copy.deepcopy(列表名1)

列表推导式

[expression for target in iterable if condition]	----[元素 for i in 序列]#元素是i的表达式

• ord(_)转化成对应的ASCII值

元组

'''元组是不可变的'''
tuple = (_ , _ , _)
tuple[_]#进行索引

查找

tuple.count(_)
查找元素的个数
tuple.index(元素，start，stop)#start，stop是索引值
	查找元素的索引值；
	多个元素时只输出第一个元素的索引值。

运算

元组1 + 元组2 #将两个元组的元素进行拼接
元组 * n #将元组中的元素重复n次拼接在元组的末尾

嵌套元组的生成

w = s , y(其中s，y为已知元组，w为变量)

A = (0) * 3
for i in range(3):
	A[i] = (0) * 3
#错误示范:
A = ((0) * 3) * 3

生成一个只有一个元素的元组

x = (_,)
#错误示范
x = (_)

字符串

引例

'''回文数的判断'''
x = input("请输入一个数字进行判断：")
"是回文数" if x == x[::-1] else "不是回文数"

字母大小写

字符串1 = 字符串0.capitalize()	---字符串首字母大写，其他字母小写
字符串1 = 字符串0.casefold()		---字符串中每个字母都小写		##可以作用于除英语外的其他语言
字符串1 = 字符串0.title()			---字符串中每个单词的首字母大写，其他字母小写
字符串1 = 字符串0.swapcase()		---字符串中的每个字母大小写反转
字符串1 = 字符串0.upper()			---字符串中的所有字母都大写
字符串1 = 字符串0.lower()			---字符串中的所有字母都小写		##只针对英语

左中右对齐

当width不大于字符串的长度时，会按照原字符串输出；如果大于字符串的长度时，会根据字符串内置函数来填充。
fillchar来控制填充的内容，如果不输入的话，填充的为空格。

字符串1 = 字符串0.center(width,fillchar='')	---居中对齐
字符串1 = 字符串0.ljust(width,fillchar='')	---左对齐
字符串1 = 字符串0.rjust(width,fillchar='')	---右对齐
字符串1 = 字符串0.zfill(width)				---在数据的前面填充0

查找

字符串0.count(sub,start,stop)				---查找sub出现的个数
字符串0.find(sub,start,stop)				---从小到大查找sub的索引 ##未找到返回-1
字符串0.rfind(sub,start,stop)				---从大到小查找sub的索引 ##未找到返回-1
字符串0.indxex(sub,start,stop)				---从小到大查找sub的索引 ##未找到抛出异常
字符串0.rindxex(sub,start,stop)			---从大到小查找sub的索引 ##未找到抛出异常

替换

字符串1 = 字符串0.expandtabs(num)			---将一个字符串中的tab用num个空格代替
字符串0.replace(old,new,count=-1)		  ---将字符串中的old替换成new ##count=-1 表示替换全部
字符串0.translate(table)				  ---table是转换表格

判断

字符串0.startswith(sub,start,end)		---判断sub是否在字符串的开始位置
字符串0.endswith(sub,start,end)		---判断sub是否在字符串的结束位置
字符串0.istitle()						---判断字符串中的所有单词首字母是否大写，其余字母是否小写
字符串0.isupper()						---判断字符串中的所有字母是否大写
字符串0.islower()						---判断字符串中的所有字母是否小写
字符串0.isalpha()						---判断字符串是否由字母构成 ##空格不是字母
字符串0.isspace()						---判断字符串是否为一个空白字符串
字符串0.isprintable()					---判断字符串中的所有字符都是可打印的
字符串0.isdecimal()					---判断数字 ##有一定的限度
字符串0.isdigit()						---判断数字 ##有一定的限度
字符串0.isnumeric()					---判断数字 ##没有的限度
字符串0.isalnum()						---当isalpha,isdecimal,isdigit,isnumeric中有一个返回为True，则返回值就为True
字符串0.isidentifier()					---判断字符串是否是一个合法的python标识符

'''判断是否为python的保留标识符'''
import keyword
keyword.iskeyword(sub)				  ---判断sub是否为python的保留标识符

截取

• chars表示截掉的内容，当chars=None时，截掉的为空格；当chars=str时，会截掉与str中元素相同的元素，在len(str)处停止

字符串0.lstrip(chars=None)				---截掉字符串左边的空格
字符串0.rstrip(chars=None)				---截掉字符串右边的空格
字符串0.strip(chars=None)				---截掉字符串左右的空格
字符串0.removeptefix(prefix)			---删除前缀 ##针对的是字符串
字符串0.removesuffix(suffix)			---删除后缀 ##针对的是字符串

拆分&拼接

'''sep为字符串中的一个元素，只能分割成三个部分，相当于只能分割一次'''
字符串0.partition(sep)					---从左向右按照sep进行拆分
字符串0.rpartition(sep)				---从右向左按照sep进行拆分

'''sep为分隔符,当sep=None时，默认按照空格进行分割;maxsplit表示分割的次数'''
字符串0.split(sep=None,maxsplit=-1)	---从左向右按照sep进行拆分
字符串0.rsplit(sep=None,maxsplit=-1)	---从右向左按照sep进行拆分
字符串0.splitlines(keepends=False)		---按行分割，按照列表返回，keepends表示是否包含换行符，默认不包含换行符

字符串=分隔符.join(iterable)		  	  ---iterable为一个序列

格式化字符串

"{}".format()

>>> year = 2010
>>> "鱼C工作室成立于 year 年。"
'鱼C工作室成立于 year 年。'
>>> "鱼C工作室成立于 {} 年。".format(year)
'鱼C工作室成立于 2010 年。'
>>> "1+2={}, 2的平方是{}，3的立方是{}".format(1+2, 2*2, 3*3*3)
'1+2=3, 2的平方是4，3的立方是27'
>>> "{1}看到{0}就很激动！".format("小甲鱼", "漂亮的小姐姐")
'漂亮的小姐姐看到小甲鱼就很激动！'
>>> "{0}{0}{1}{1}".format("是", "非")
'是是非非'
>>> "我叫{name}，我爱{fav}。".format(name="小甲鱼", fav="Pyhon")
'我叫小甲鱼，我爱Pyhon。'
>>> "我叫{name}，我爱{0}。喜爱{0}的人，运气都不会太差^o^".format("python", name="小甲鱼")
'我叫小甲鱼，我爱python。喜爱python的人，运气都不会太差^o^'
>>> "{}, {}, {}".format(1, "{}", 2)
'1, {}, 2'
>>> "{}, {{}}, {}".format(1, 2)
'1, {}, 2'

对齐设置

>>> "{:^}".format(250)
'250'
>>> "{:^10}".format(250)
'   250    '
>>> "{1:>10}{0:<10}".format(520, 250)
'       250520       '
>>> "{left:>10}{right:<10}".format(right=520, left=250)
'       250520       '
>>> "{:010}".format(520)
'0000000520'
>>> "{:010}".format(-520)
'-000000520'
>>> "{:010}".format("FishC")
Traceback (most recent call last):
  File "<pyshell#39>", line 1, in <module>
    "{:010}".format("FishC")
ValueError: '=' alignment not allowed in string format specifier
>>> "{1:%>10}{0:%<10}".format(520, 250)
'%%%%%%%250520%%%%%%%'
>>> "{:0=10}".format(520)
'0000000520'
>>> "{:0=10}".format(-520)
'-000000520'

符号（[sign]）选项

精度（[.precision]）选项

• 精度（[.precision]）选项是一个十进制整数，对于不同类型的参数，它的效果是不一样的：
  • 对于以 ‘f’ 或 ‘F’ 格式化的浮点数值来说，是限定小数点后显示多少个数位
  • 对于以 ‘g’ 或 ‘G’ 格式化的浮点数值来说，是限定小数点前后共显示多少个数位
  • 对于非数字类型来说，限定最大字段的大小（换句话说就是要使用多少个来自字段内容的字符）
  • 对于整数来说，则不允许使用该选项值

类型（[type]）选项

f-字符串

>>> year = 2010
>>> f"鱼C工作室成立于 {year} 年"
'鱼C工作室成立于 2010 年'
>>> 
>>> f"1+2={1+2}, 2的平方是{2*2}，3的立方是{3*3*3}"
'1+2=3, 2的平方是4，3的立方是27'
>>> 
>>> "{:010}".format(-520)
>>> f"{-520:010}"
'-000000520'
>>> 
>>> "{:,}".format(123456789)
>>> f"{123456789:,}"
'123,456,789'
>>> 
>>> "{:.2f}".format(3.1415)
>>> f"{3.1415:.2f}"
'3.14'

序列

列表、元组、字符串的共同点

• 都可以通过索引获取每一个元素
• 第一个元素的索引值都是 0
• 都可以通过切片的方法获得一个范围内的元素的集合
• 有很多共同的运算符

根据是否能被修改这一特性，可以将序列分为可变序列和不可变序列：比如列表就是可变序列，而元组和字符串则是不可变序列

加号（+）和乘号（*）

首先是加减乘除，只有加号（+）和乘号（*）可以用上，序列之间的加法表示将两个序列进行拼接；乘法表示将序列进行重复，也就是拷贝

>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
>>> (1, 2, 3) + (4, 5, 6)
(1, 2, 3, 4, 5, 6)
>>> "123" + "456"
'123456'
>>> [1, 2, 3] * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> (1, 2, 3) * 3
(1, 2, 3, 1, 2, 3, 1, 2, 3)
>>> "123" * 3
'123123123'

关于 “可变” 和 “不可变” 的思考

'''可变序列'''
>>> s = [1, 2, 3]
>>> id(s)
2285532322944
>>> s *= 2
>>> s
[1, 2, 3, 1, 2, 3]
>>> id(s)
2285532322944
'''不可变序列'''
>>> t = (1, 2, 3)
>>> id(t)
2285532205952
>>> t *= 2
>>> t
(1, 2, 3, 1, 2, 3)
>>> id(t)
2285532393920

是（is）和不是（is not）

是（is）和不是（is not）被称之为同一性运算符，用于检测两个对象之间的 id 值是否相等

>>> x = "FishC"
>>> y = "FishC"
>>> x is y
True
>>> x = [1, 2, 3]
>>> y = [1, 2, 3]
>>> x is not y
True

包含（in）和不包含（not in）

in 运算符是用于判断某个元素是否包含在序列中的，而 not in 则恰恰相反

>>> "Fish" in "FishC"
True
>>> "鱼" in "鱼C"
True
>>> "C" not in "FishC"
False

del 语句

del 语句用于删除一个或多个指定的对象

del y[:] == y.clear()

>>> x = "FishC"
>>> y = [1, 2, 3]
>>> del x, y
>>> x
Traceback (most recent call last):
  File "<pyshell#52>", line 1, in <module>
    x
NameError: name 'x' is not defined
>>> y
Traceback (most recent call last):
  File "<pyshell#53>", line 1, in <module>
    y
NameError: name 'y' is not defined

list()、tuple() 和 str()

• 列表 = list(序列)

• 元组 = tuple(序列)

• 字符串 = str(序列)

min() 和 max()

• min() 和 max() 这两个函数的功能是：对比传入的参数，并返回最小值和最大值

  '''default表示无法进行比较时的返回值，默认为None，报错'''
  min(iterable,default=None)
  max(iterable,default=None)
  

>>> s = [1, 1, 2, 3, 5]
>>> min(s)
1
>>> t = "FishC"
>>> max(t)
's'
>>> min(1, 2, 3, 0, 6)
0
>>> max(1, 2, 3, 0, 6)
6

len() 和 sum()

• len() 函数获取序列的长度

>>> len(range(2 ** 100))
Traceback (most recent call last):
  File "<pyshell#42>", line 1, in <module>
    len(range(2 ** 100))
OverflowError: Python int too large to convert to C ssize_t

• • 错误是由于 len() 函数的参数太大导致的，我们知道 Python 为了执行的效率，它内部几乎都是用效率更高的 C 语言来实现的。
• • 而这个 len() 函数为了让 Python 自带的数据结构可以走后门，它会直接读取 C 语言结构体里面对象的长度。
• • 所以，如果检测的对象超过某个数值，就会出错。
• • 通常对于 32 位平台来说，这个最大的数值是 2^31 - 1；而对于 64 位平台来说，这个最大的数值是 2^63 - 1。

• sum() 函数用于计算迭代对象中各项的和

>>> s = [1, 0, 0, 8, 6]
>>> sum(s)
15
'''它有一个 start 参数，用于指定求和计算的起始数值，比如这里我们设置为从 100 开始加起'''
>>> sum(s, start=100)
115

sorted() 和 reversed()

• sorted() 函数将重新排序 iterable 参数中的元素，并将结果返回一个新的列表

序列1 = 序列0.sorted(iterable,reverse=False,key=None)
'''reverse默认为False，表示从小到大排列，key默认为None，表示在执行sorted函数命令之前先执行key函数的指令，表示按照key的方式进行排序'''

>>> s = [1, 2, 3, 0, 6]
>>> sorted(s)
[0, 1, 2, 3, 6]
>>> sorted(s, reverse=True)
[6, 3, 2, 1, 0]
>>> s.sort(reverse=True)
>>> s
[6, 3, 2, 1, 0]
>>> t = ["FishC", "Apple", "Book", "Banana", "Pen"]
>>> sorted(t)
['Apple', 'Banana', 'Book', 'FishC', 'Pen']
>>> sorted(t, key=len)
['Pen', 'Book', 'FishC', 'Apple', 'Banana']

• reversed() 函数将返回参数的反向迭代器

序列0.reversed(iterable)

>>> s = [1, 2, 5, 8, 0]
>>> reversed(s)
<list_reverseiterator object at 0x0000022926732AC0>
>>> list(reversed(s))
[0, 8, 5, 2, 1]
>>> list(reversed("FishC"))
['C', 'h', 's', 'i', 'F']
>>> list(reversed((1, 2, 5, 9, 3)))
[3, 9, 5, 2, 1]
>>> list(reversed(range(0, 10)))
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

all() 和 any()

• all() 函数是判断可迭代对象中是否所有元素的值都为真
• any() 函数则是判断可迭代对象中是否存在某个元素的值为真

>>> x = [1, 1, 0]
>>> y = [1, 1, 9]
>>> all(x)
False
>>> all(y)
True
>>> any(x)
True
>>> any(y)
True

enumerate()

• enumerate() 函数用于返回一个枚举对象，它的功能就是将可迭代对象中的每个元素及从 0 开始的序号共同构成一个二元组的列表

>>> seasons = ["Spring", "Summer", "Fall", "Winter"]
>>> enumerate(seasons)
<enumerate object at 0x000001C514492280>
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
'''它有一个 start 参数，可以自定义序号开始的值'''
>>> for i, j in enumerate(seasons, start=10):
...     print(i, "->", j)
... 
10 -> Spring
11 -> Summer
12 -> Fall
13 -> Winter

zip()

• zip() 函数用于创建一个聚合多个可迭代对象的迭代器

>>> x=[1,2,3]
>>> y=[4,5,6]
>>> zip(x,y)
<zip object at 0x000001C5145314C0>
>>>list(zip(x,y))
[(1, 4), (2, 5), (3, 6)]
>>> z="FishC"
>>> list(zip(x,y,z))
[(1, 4, 'F'), (2, 5, 'i'), (3, 6, 's')]


>>> import itertools
>>> list(itertools.zip_longest(x,y,z))
[(1, 4, 'F'), (2, 5, 'i'), (3, 6, 's'), (None, None, 'h'), (None, None, 'C')]

map()

• map() 函数会根据提供的函数对指定的可迭代对象的每个元素进行运算，并将返回运算结果的迭代器

map(Function,iterable)
>>> map("FishC")
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    map("FishC")
TypeError: map() must have at least two arguments.

>>> map(ord,"FishC")
<map object at 0x000001C514524190>
>>> list(map(ord,"FishC"))
[70, 105, 115, 104, 67]
>>> list(map(pow,[2,3,10],[5,2,3]))
[32, 9, 1000]
>>> list(map(max, [1, 3, 5], [2, 2, 2], [0, 3, 9, 8]))
[2, 3, 9]

filter()

• filter() 函数也是需要传入一个函数作为参数，不过 filter() 函数是根据提供的函数，对指定的可迭代对象的每个元素进行运算，并将运算结果为真的元素，以迭代器的形式返回

filter(Function,iterable)
>>> filter("FishC")
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    filter("FishC")
TypeError: filter expected 2 arguments, got 1

>>> filter(str.islower, "FishC")
<filter object at 0x000001B5170FEFA0>
>>> list(filter(str.islower, "FishC"))
['i', 's', 'h']

可迭代对象和迭代器

• 可迭代对象咱们可以对其进行重复的操作，而迭代器则是一次性的

• iter() 函数将可迭代对象转换为迭代器,BIF 里面有一个 next(list_iterator,default) 函数，它是专门针对迭代器的

>>> x = [1, 2, 3, 4, 5]
>>> y = iter(x)
>>> type(x)
<class 'list'>
>>> type(y)
<class 'list_iterator'>
>>> next(y)
1
>>> next(y)
2
>>> next(y)
3
>>> next(y)
4
>>> next(y)
5
>>> next(y)
Traceback (most recent call last):
  File "<pyshell#52>", line 1, in <module>
    next(y)
StopIteration
>>> z = iter(x)
>>> next(z, "没啦，被你掏空啦~")
1
>>> next(z, "没啦，被你掏空啦~")
2
>>> next(z, "没啦，被你掏空啦~")
3
>>> next(z, "没啦，被你掏空啦~")
4
>>> next(z, "没啦，被你掏空啦~")
5
>>> next(z, "没啦，被你掏空啦~")
'没啦，被你掏空啦~'

字典

• 利用所学知识对应索引摩斯密码

  # 摩斯密文表
  c_table = [".-", "-...", "-.-.", "-..", ".", "..-.",
             "--.", "....", "..", ".---", "-.-", ".-..",
             "--", "-.", "---", ".--.", "--.-", ".-.",
             "...", "-", "..-", "...-", ".--", "-..-",
             "-.--", "--..", ".----", "..---", "...--", "....-",
             ".....", "-....", "--...", "---..", "----.", "-----"]
  # 摩斯明文表
  d_table = ["A", "B", "C", "D", "E", "F",
             "G", "H", "I", "J", "K", "L",
             "M", "N", "O", "P", "Q", "R",
             "S", "T", "U", "V", "W", "X",
             "Y", "Z", "1", "2", "3", "4",
             "5", "6", "7", "8", "9", "0"]
      
  code = input("请输入摩斯密码：")
  split_code = code.split(" ")
  result = [d_table[c_table.index(each)] for each in split_code]
  print(result)
  

  # 摩斯密码对比表
  c_table = [".-", "A", "-...", "B", "-.-.", "C", "-..", "D",
             ".", "E", "..-.", "F", "--.", "G", "....", "H",
             "..", "I", ".---", "J", "-.-", "K", ".-..", "L", 
             "--", "M", "-.", "N", "---", "O", ".--.", "P",
             "--.-", "Q", ".-.", "R", "...", "S", "-", "T",
             "..-", "U", "...-", "V", ".--", "W", "-..-", "X",
             "-.--", "Y", "--..", "Z", ".----", "1", "..---", "2",
             "...--", "3", "....-", "4", ".....", "5", "-....", "6",
             "--...", "7", "---..", "8", "----.", "9", "-----", "0"]
      
  code = input("请输入摩斯密码：")
  split_code = code.split(" ")
  result = [c_table[c_table.index(each) + 1] for each in split_code]
  print(result)
  

• 利用字典索引摩斯密码

  # 摩斯密码对比表
  c_table = {".-":"A", "-...":"B", "-.-.":"C", "-..":"D",
             ".":"E", "..-.":"F", "--.":"G", "....":"H",
             "..":"I", ".---":"J", "-.-":"K", ".-..":"L", 
             "--":"M", "-.":"N", "---":"O", ".--.":"P",
             "--.-":"Q", ".-.":"R", "...":"S", "-":"T",
             "..-":"U", "...-":"V", ".--":"W", "-..-":"X",
             "-.--":"Y", "--..":"Z", ".----":"1", "..---":"2",
             "...--":"3", "....-":"4", ".....":"5", "-....":"6",
             "--...":"7", "---..":"8", "----.":"9", "-----":"0"}
      
  code = input("请输入摩斯密码：")
  split_code = code.split(" ")
      
  result = [c_table[each] for each in split_code]
  print(result)
  

• 扩展阅读：摩斯密码解码效率大比拼（列表 VS 字典）

创建

字典 = dict()

>>> x = {"吕布","关羽"}
>>> type(x)
<class 'set'>
>>> y = {"吕布":"口口布","关羽":"关匀匀"}
>>> type(y)
<class 'dict'>
>>> y['吕布']
'口口布'
>>> y['关羽']
'关匀匀'
>>> y['刘备'] = "刘baby"
>>> y
{'吕布': '口口布', '关羽': '关匀匀', '刘备': '刘baby'}
>>> a = {'吕布': '口口布', '关羽': '关匀匀', '刘备': '刘baby'}
>>> a
{'吕布': '口口布', '关羽': '关匀匀', '刘备': '刘baby'}
>>> b = dict(吕布="口口布",关羽="关匀匀",刘备='刘baby')
>>> b
{'吕布': '口口布', '关羽': '关匀匀', '刘备': '刘baby'}
>>> c = dict([("吕布","口口布"),("关羽","关匀匀"),("刘备","刘baby")])
>>> c
{'吕布': '口口布', '关羽': '关匀匀', '刘备': '刘baby'}
>>> d = dict({'吕布': '口口布', '关羽': '关匀匀', '刘备': '刘baby'})
>>> d
{'吕布': '口口布', '关羽': '关匀匀', '刘备': '刘baby'}
>>> e = dict({'吕布': '口口布', '关羽': '关匀匀'},刘备="刘baby")
>>> e
{'吕布': '口口布', '关羽': '关匀匀', '刘备': '刘baby'}
>>> f = dict(zip(["吕布","关羽","刘备"],["口口布","关匀匀","刘baby"]))
>>> f
{'吕布': '刘baby', '关羽': '关匀匀', '刘备': '口口布'}
>>> a==b==c==d==e==f
True

添加

字典 = dict.fromkeys(iterable[,values])

>>> d = dict.fromkeys("fishc",250)
>>> d
{'f': 250, 'i': 250, 's': 250, 'h': 250, 'c': 250}
>>> d["f"] = 70
>>> d
{'f': 70, 'i': 250, 's': 250, 'h': 250, 'c': 250}
>>> d["m"] = 67
>>> d
{'f': 70, 'i': 250, 's': 250, 'h': 250, 'c': 250, 'm': 67}

删除

字典.pop(key[,default])
字典.popitem() ##删除最后一个键值对
del 字典[键] ##删掉字典
字典.clear() ##清空字典

>>> d.pop("s")
250
>>> d
{'f': 70, 'i': 250, 'h': 250, 'c': 250, 'm': 67}
>>> d.pop("gou")
Traceback (most recent call last):
  File "<pyshell#11>", line 1, in <module>
    d.pop("gou")
KeyError: 'gou'
>>> d.pop("gou","没有")
'没有'
>>> d.popitem()
('m', 67)
>>> d
{'f': 70, 'i': 250, 'h': 250, 'c': 250}
>>> del d["f"]
>>> d
{'i': 250, 'h': 250, 'c': 250}
>>> del d
>>> d
Traceback (most recent call last):
  File "<pyshell#20>", line 1, in <module>
    d
NameError: name 'd' is not defined
>>> d = dict.fromkeys("fishc",250)
>>> d
{'f': 250, 'i': 250, 's': 250, 'h': 250, 'c': 250}
>>> d.clear()
>>> d
{}

替换

字典.update([other])

>>> d = dict.fromkeys("fishc")
>>> d
{'f': None, 'i': None, 's': None, 'h': None, 'c': None}
>>> d["s"] = 5
>>> d
{'f': None, 'i': None, 's': 5, 'h': None, 'c': None}
>>> d.update({"i":105,"h":104})
>>> d
{'f': None, 'i': 105, 's': 5, 'h': 104, 'c': None}
>>> d.update(f="70",c="67")
>>> d
{'f': '70', 'i': 105, 's': 5, 'h': 104, 'c': '67'}
>>> d.update(F="70",C="67")
>>> d
{'f': '70', 'i': 105, 's': 5, 'h': 104, 'c': '67', 'F': '70', 'C': '67'}

查找

字典.get(key[,default])
字典.setdefault(key[,default])

>>> d["H"]
Traceback (most recent call last):
  File "<pyshell#39>", line 1, in <module>
    d["H"]
KeyError: 'H'
>>> d.get("H","这里没有H")
'这里没有H'
>>> d.get("H","这里没有H")
'这里没有H'
>>> d.setdefault("h","code")
104
>>> d.setdefault("H","code")
'code'
>>> d
{'f': '70', 'i': 105, 's': 5, 'h': 104, 'c': '67', 'F': '70', 'C': '67', 'H': 'code'}

拷贝

字典1 = 字典0.copy()

>>> e = d.copy()
>>> e
{'f': '70', 'i': 105, 's': 5, 'h': 104, 'c': '67', 'F': '70', 'C': '67', 'H': 'code'}
>>> 

items()、keys()、values()

字典.items()	##获取字典的键值对
字典.keys()	##获取字典键的视图
字典.values()	##获取字典值的视图
'''字典视图特性:当字典发生改变时视图会跟着改变'''

>>> keys = d.keys()
>>> values = d.values()
>>> items = d.items()
>>> items
dict_items([('f', '70'), ('i', 105), ('s', 5), ('h', 104), ('c', '67'), ('F', '70'), ('C', '67'), ('H', 'code')])
>>> keys
dict_keys(['f', 'i', 's', 'h', 'c', 'F', 'C', 'H'])
>>> values
dict_values(['70', 105, 5, 104, '67', '70', '67', 'code'])
>>> d.popitem()
('H', 'code')
>>> items
dict_items([('f', '70'), ('i', 105), ('s', 5), ('h', 104), ('c', '67'), ('F', '70'), ('C', '67')])
>>> keys
dict_keys(['f', 'i', 's', 'h', 'c', 'F', 'C'])
>>> values
dict_values(['70', 105, 5, 104, '67', '70', '67'])

可对字典操作的函数

len(字典)		##获取字典键值对数量
键 in 字典	   ##判断某个键是否在字典中
list(字典)	##将字典中的键构成一个列表
list(字典.values())	##将字典中的值构成一个列表
迭代器 = iter(字典)	  ##迭代器的获取
reversed(字典倒序)	   ##python3.8后的功能

>>> len(d)
7
>>> "H" in d
False
>>> "H" not in d
True
>>> list(d)
['f', 'i', 's', 'h', 'c', 'F', 'C']
>>> list(d.values())
['70', 105, 5, 104, '67', '70', '67']
>>> e = iter(d)
>>> list(e)
['f', 'i', 's', 'h', 'c', 'F', 'C']
>>> tuple(e)
()
>>> e = iter(d)
>>> tuple(e)
('f', 'i', 's', 'h', 'c', 'F', 'C')
>>> list(reversed(d))
['C', 'F', 'c', 'h', 's', 'i', 'f']

嵌套

>>> d = {"吕布":{"语文":60,"英语":70,"数学":80},"关羽":{"语文":10,"英语":20,"数学":30}}
>>> d["吕布"]["数学"]
80
>>> d = {"吕布":[60,70,80],"关羽":{"语文":10,"英语":20,"数学":30}}
>>> d["吕布"][1]
70

字典推导式

字典1 = {v:k for v,k in 字典0.items() if condition}

• 可哈希与哈希值
• 字典中的键和值都是可哈希的序列(不可变序列)

集合

• 集合的性质：互异性，无序性，明确性
  • 不可按照顺序进行索引
  • 一个元素与其他元素互不相同

创建

集合 = {元素1,元素2}
'''集合推导式'''
集合 = {expression(s) for s in iterable if condition}	##无序
集合 = set(iterable)

>>> {"fishc","python"}
{'fishc', 'python'}
>>> {s for s in "fishc"}
{'f', 'c', 'i', 'h', 's'}
>>> set(12346)
Traceback (most recent call last):
  File "<pyshell#101>", line 1, in <module>
    set(12346)
TypeError: 'int' object is not iterable
>>> set("12346")
{'1', '2', '3', '4', '6'}

集合的各种处理方法

集合的各种方法大合集

集合1 = 集合0.copy()
集合1.isdisjoint(iterable)	##判断集合与序列是否无关
集合1.issubset(iterable)		   ##判断集合1是否为iterable的子集
集合1.issuperset(iterable)	   ##判断集合1是否为iterable的超集
'''以下三个函数的iterable可为多个，用,分隔'''
集合2 = 集合1.union(iterable)	  ##得到一个集合1与iterable的并集
集合2 =  集合1.intersection(iterable)	##得到集合1和iterable的交集
集合1.difference(iterable)	    ##得到存在于集合1但不存在于iterable中的元素

集合1.symmetric_difference(iterable)	##对称差集



集合1 <= 集合2		##判断集合1是否为集合2的子集
集合1 < 集合2		##判断集合1是否为集合2的真子集
集合1 >= 集合2		##判断集合1是否为集合2的超集
集合1 > 集合2		##判断集合2是否为集合2的真超集
集合1 | 集合2		##集合1和集合2的并集
集合1 & 集合2		##集合1和集合2的交集
集合1 - 集合2		##求集合1与集合2的差集
集合1 ^ 集合2		##求对称差集

>>> s.isdisjoint(set("789"))
True
>>> s.isdisjoint(set("6789"))
False			#6
>>> s.isdisjoint("fishc")
True
>>> s.issubset("1234567890")
True
>>> s.issuperset("1234567890")
False
>>> s.issuperset("1")
True
>>> s.union("567")
{'3', '1', '4', '7', '6', '5', '2'}
>>> s.intersection("5678")
{'6', '5'}
>>> s.difference("5678")
{'3', '1', '4', '2'}
>>> s.symmetric_difference("5678")
{'1', '7', '8', '2', '3', '4'}

• 不可变集合(frozenset)

>>> frozenset("FishC")
frozenset({'F', 'h', 's', 'C', 'i'})
>>> frozenset(["FishC", "Python"])
frozenset({'Python', 'FishC'})
>>> f = frozenset("FishC")
>>> s = {f, "Python"}
>>> s
{frozenset({'F', 'h', 's', 'C', 'i'}), 'Python'}

仅适用于set()对象的方法(改变set的内容)

集合.update(*others)		##添加iterable中的每个元素
集合.intersection_update(iterable)	##将集合改为集合与iterable的交集
集合.difference_update(iterable)		##将集合中与iterable相同的元素删掉
集合.symmetric_difference_update(iterable) ##将集合修改为集合与iterable的对称差集
集合.add(elem)			##添加一个元素
集合.remove(elem)			##删除一个元素(元素不存在时报错)
集合.discard(elem)		##删除一个元素(元素不存在时不会报错)
集合.pop()				##随机弹出一个元素
集合.clear()				##清空集合

>>> s =set("fishc")
>>> s.update([1,1],"23")
>>> s
{1, 's', '3', 'h', 'i', '2', 'c', 'f'}
>>> s.intersection_update("fishc")
>>> s
{'s', 'h', 'i', 'c', 'f'}
>>> s.difference_update("php","python")
>>> s
{'s', 'i', 'c', 'f'}
>>> s.symmetric_difference_update("FishC")
>>> s
{'F', 'C', 'h', 'c', 'f'}
>>> s.add("45")
>>> s
{'F', 'C', 'h', 'c', '45', 'f'}
>>> s.remove("35")
Traceback (most recent call last):
  File "<pyshell#12>", line 1, in <module>
    s.remove("35")
KeyError: '35'
>>> s.discard("35")
>>> s
{'F', 'C', 'h', 'c', '45', 'f'}
>>> s.pop()
'F'
>>> s
{'C', 'h', 'c', '45', 'f'}
>>> s.clear()
>>> s
set()

• 集合中的元素必须是可哈希的(不可变的)

集合的嵌套

集合 = {frozenset(),elems}

>>> x = {1,2,3}
>>> y = {x,4,5,6}
Traceback (most recent call last):
  File "<pyshell#22>", line 1, in <module>
    y = {x,4,5,6}
TypeError: unhashable type: 'set'
>>> x=frozenset(x)
>>> y = {x,4,5,6}
>>> y
{frozenset({1, 2, 3}), 4, 5, 6}

函数

参数

• 位置参数

• 关键字参数 ##在传入实参的时候，利用赋值语句给形参赋值

• 混用时 ##位置参数在关键字参数之前

• 默认参数 ##在定义形参时给出默认值

• / 左侧必须为位置参数；右侧可为位置参数，也可为关键字参数

• * 左侧可为位置参数，也可为关键字参数；右侧只能使用关键字参数

• 收集参数： *形参 ##利用元组进行打包解包

• 收集参数： **形参 ##利用字典进行打包解包

  • 实参要使用关键字参数进行传输

• 当利用收集参数和其他参数时，其他参数要使用关键字参数的传输方法

• 解包参数： *实参 ##对实参(元组)进行解包

• 解包参数： **实参 ##对实参(字典)进行解包

作用域

• 全局变量在局部函数中不可以进行修改，如果修改的话，python会重新命名一个相同名字的变量

• • global语句可以在局部函数中修改全局变量

global 变量
变量 = _

嵌套函数

• 内部函数无法修改外部函数的变量
• • nonlocal语句可以实现修改

nonlocal 变量
变量 = _

LEGB规则

• 链接

LEGB含义解释：
L-Local(function)；函数内的名字空间
E-Enclosing function locals；外部嵌套函数的名字空间(例如closure)
G-Global(module)；函数定义所在模块（文件）的名字空间
B-Builtin(Python)；Python内置模块的名字空间
'''
LEGB规定了查找一个名称的顺序为：local-->enclosing function locals-->global-->builtin
'''

闭包

• 外层变量是会被保存下来的，局部变量不会被保存

origin = (0, 0)         # 原点
legal_x = [-100, 100]   # x轴的移动范围
legal_y = [-100, 100]   # y轴的移动范围

def create(pos_x=0, pos_y=0):
# 初始化位于原点为主    
    def moving(direction, step):
    # direction参数设置方向，1为向右（向上），-1为向左（向下），0为不移动
    # step参数设置移动的距离
        nonlocal pos_x, pos_y
        new_x = pos_x + direction[0] * step
        new_y = pos_y + direction[1] * step
        # 检查移动后是否超出x轴边界
        if new_x < legal_x[0]:
            pos_x = legal_x[0] - (new_x - legal_x[0])
        elif new_x > legal_x[1]:
            pos_x = legal_x[1] - (new_x - legal_x[1])
        else:            
            pos_x = new_x
        # 检查移动后是否超出y轴边界
        if new_y < legal_y[0]:
            pos_y = legal_y[0] - (new_y - legal_y[0])
        elif new_y > legal_y[1]:
            pos_y = legal_y[1] - (new_y - legal_y[1])
        else:            
            pos_y = new_y
        return pos_x, pos_y
    return moving
    
move = create()
print('向右移动10步后，位置是：', move([1, 0], 10))
print('向上移动130步后，位置是：', move([0, 1], 130))
print('向左移动10步后，位置是：', move([-1, 0], 10))

所在模块（文件）的名字空间
B-Builtin(Python)；Python内置模块的名字空间
‘’’
LEGB规定了查找一个名称的顺序为：local–>enclosing function locals–>global–>builtin
‘’’

## 闭包

* 外层变量是会被保存下来的，局部变量不会被保存

[外链图片转存中...(img-8bA3f86o-1645965492367)]

[外链图片转存中...(img-D3HL4e3M-1645965492367)]

```python
origin = (0, 0)         # 原点
legal_x = [-100, 100]   # x轴的移动范围
legal_y = [-100, 100]   # y轴的移动范围

def create(pos_x=0, pos_y=0):
# 初始化位于原点为主    
    def moving(direction, step):
    # direction参数设置方向，1为向右（向上），-1为向左（向下），0为不移动
    # step参数设置移动的距离
        nonlocal pos_x, pos_y
        new_x = pos_x + direction[0] * step
        new_y = pos_y + direction[1] * step
        # 检查移动后是否超出x轴边界
        if new_x < legal_x[0]:
            pos_x = legal_x[0] - (new_x - legal_x[0])
        elif new_x > legal_x[1]:
            pos_x = legal_x[1] - (new_x - legal_x[1])
        else:            
            pos_x = new_x
        # 检查移动后是否超出y轴边界
        if new_y < legal_y[0]:
            pos_y = legal_y[0] - (new_y - legal_y[0])
        elif new_y > legal_y[1]:
            pos_y = legal_y[1] - (new_y - legal_y[1])
        else:            
            pos_y = new_y
        return pos_x, pos_y
    return moving
    
move = create()
print('向右移动10步后，位置是：', move([1, 0], 10))
print('向上移动130步后，位置是：', move([0, 1], 130))
print('向左移动10步后，位置是：', move([-1, 0], 10))