导图社区 0基础入门Python知识点汇总
- 35
- 0
- 0
- 举报
0基础入门Python知识点汇总
学Python，看这一篇知识点就够了，0基础入门Python知识点汇总，感谢小甲鱼的入门教程书。
编辑于2023-01-04 23:11:43 山东省- 小甲鱼
- 相似推荐
- 大纲
Python
第一章
下载python
http://python.org
操作技巧
如何快速复制上一行代码
Windows：Alt+P MacOS：control+P
第二章
缩进（Tab）
如果在正确的位置输入冒号（：），下一行会自动缩进
BIF(Built-in functions)
内置函数
推导式
Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。
第三章
变量
把一个值赋值给一个名字时，它会存储在内存中，把这块内存称为变量（variable）
a = 3 temp = '苹果'
字符串
字符串两边要加上引号，可以是单引号也可以是双引号
三重引号字符串（""" """）可以解决多行切换问题
原始字符串r
只需要在字符串前面加一个英文字母r
算数操作符
+
-
*
/
%
求余数
**
幂运算操作符
//
地板除法：计算结果取比商小的最大整型，也就是舍弃小数的意思
比较操作符
<
>
<=
>=
==
等于，一个=是赋值的意思
!=
不等于
条件分支
if 条件 ： 条件为真时（True）执行的操作 else： 条件为假时（False）执行的操作
如果if else后仍然有if else，可以把else和下一层的if组合简写成elif
while循环
while 条件： 条件为真（True）执行的操作
引入随机整数外援
random
import random
限定随机数范围
random.randint( 1 , 10 )
扩充知识：获取随机数种子，使得随机数重现——用random.getstate()配合random.setstate()

浮点型
150000000000可以记作1.5e11
0.000000000015可以记作1.5e-11
布尔类型
对条件判断，返回True或者False，布尔类型事实上是特殊的整型，True相当于整型值1，False相当于整型值0。

类型转换
int（）整数
float（）小数
str（）字符串
将一个类型转换成字符串类型
优先级问题
先乘除，后加减，有括号先运算括号里面的
幂运算操作符比其左侧的一元操作符优先级高，比其右侧的一元操作符优先级低
[- 3 * * 2]结果为-9
[3 * * - 2]结果为0.111111111
逻辑操作符
and
左右都为真时结果为真
or
左边或右边任意为真，结果为真；两边同时为假，结果为假
not
一元操作符，它的作用是得到一个和操作数相反的布尔类型的值
补充知识（Python中%s、%d、%f意义及用法详解）
%s 格式化字符串
print('str1%s' % 'str2')
>> str1str2
# 意思是%作为一个替代，将后面的‘str2’字符串加到str1后面
string="hello"
#%s打印时结果是hello
print "string=%s" % string # output: string=hello
#%2s意思是字符串长度为2，当原字符串的长度超过2时，按原长度打印，所以%2s的打印结果还是hello
print "string=%2s" % string # output: string=hello
#%7s意思是字符串长度为7，当原字符串的长度小于7时，在原字符串左侧补空格，
#所以%7s的打印结果是 hello
print "string=%7s" % string # output: string= hello
#%-7s意思是字符串长度为7，当原字符串的长度小于7时，在原字符串右侧补空格，
#所以%-7s的打印结果是 hello
print "string=%-7s!" % string # output: string=hello !
#%.2s意思是截取字符串的前2个字符，所以%.2s的打印结果是he
print "string=%.2s" % string # output: string=he
#%.7s意思是截取字符串的前7个字符，当原字符串长度小于7时，即是字符串本身，
#所以%.7s的打印结果是hello
print "string=%.7s" % string # output: string=hello
#%a.bs这种格式是上面两种格式的综合，首先根据小数点后面的数b截取字符串，
#当截取的字符串长度小于a时，还需要在其左侧补空格
print "string=%7.2s" % string # output: string= he
print "string=%2.7s" % string # output: string=hello
print "string=%10.7s" % string # output: string= hello
#还可以用%*.*s来表示精度，两个*的值分别在后面小括号的前两位数值指定
print "string=%*.*s" % (7,2,string) # output: string= he
%d指的是整型
num=14
#%d打印时结果是14
print "num=%d" % num # output: num=14
#%1d意思是打印结果为1位整数，当整数的位数超过1位时，按整数原值打印，所以%1d的打印结果还是14
print "num=%1d" % num # output: num=14
#%3d意思是打印结果为3位整数，当整数的位数不够3位时，在整数左侧补空格，所以%3d的打印结果是 14
print "num=%3d" % num # output: num= 14
#%-3d意思是打印结果为3位整数，当整数的位数不够3位时，在整数右侧补空格，所以%3d的打印结果是14_
print "num=%-3d" % num # output: num=14_
#%05d意思是打印结果为5位整数，当整数的位数不够5位时，在整数左侧补0，所以%05d的打印结果是00014
print "num=%05d" % num # output: num=00014
#%.3d小数点后面的3意思是打印结果为3位整数，
#当整数的位数不够3位时，在整数左侧补0，所以%.3d的打印结果是014
print "num=%.3d" % num # output: num=014
#%.0003d小数点后面的0003和3一样，都表示3，意思是打印结果为3位整数，
#当整数的位数不够3位时，在整数左侧补0，所以%.3d的打印结果还是014
print "num=%.0003d" % num # output: num=014
#%5.3d是两种补齐方式的综合，当整数的位数不够3时，先在左侧补0，还是不够5位时，再在左侧补空格，
#规则就是补0优先，最终的长度选数值较大的那个，所以%5.3d的打印结果还是 014
print "num=%5.3d" % num # output: num= 014
#%05.3d是两种补齐方式的综合，当整数的位数不够3时，先在左侧补0，还是不够5位时，
#由于是05，再在左侧补0，最终的长度选数值较大的那个，所以%05.3d的打印结果还是00014
print "num=%05.3d" % num # output: num=00014
#还可以用%*.*d来表示精度，两个*的值分别在后面小括号的前两位数值指定
#如下，不过这种方式04就失去补0的功能，只能补空格，只有小数点后面的3才能补0
print "num=%*.*d" % (04,3,num) # output: num= 014
%f浮点型
import math
#%a.bf，a表示浮点数的打印长度，b表示浮点数小数点后面的精度
#只是%f时表示原值，默认是小数点后5位数
print "PI=%f" % math.pi # output: PI=3.141593
#只是%9f时，表示打印长度9位数，小数点也占一位，不够左侧补空格
print "PI=%9f" % math.pi # output: PI=_3.141593
#只有.没有后面的数字时，表示去掉小数输出整数，03表示不够3位数左侧补0
print "PI=%03.f" % math.pi # output: PI=003
#%6.3f表示小数点后面精确到3位，总长度6位数，包括小数点，不够左侧补空格
print "PI=%6.3f" % math.pi # output: PI=_3.142
#%-6.3f表示小数点后面精确到3位，总长度6位数，包括小数点，不够右侧补空格
print "PI=%-6.3f" % math.pi # output: PI=3.142_
#还可以用%*.*f来表示精度，两个*的值分别在后面小括号的前两位数值指定
#如下，不过这种方式06就失去补0的功能，只能补空格
print "PI=%*.*f" % (06,3,math.pi) # output: PI=_3.142
python中%d表示格式化一个对象为十进制整数。 使用后，在需要输出的长字符串中占位置。 输出字符串时，可以依据变量的值，自动更新字符串的内容。
第四章
条件表达式（三元操作符）
a=x if 条件 else y
例如：small = x if x < y else y
断言（assert）
当这个关键字后面的条件为假时，程序自动崩溃并抛出AssertionError的异常
可以用它在程序中置入检查点，确保程序中某个条件一定为真时才能让程序正常运作
for循环语句
for 目标 in 表达式 ： 循环体
app = 'apple' for each in app: print(each ,end = ' ')
a p p l e
range
range(start, stop, step=1)
其中start和step=1两个参数是可选的，不是必须的，start默认从0开始，step=默认是1
for i in range(5)
0 1 2 3 4
for i in range(2, 9)
2 3 4 5 6 7 8
for i in range(1, 10,2)
1 3 5 7 9
break语句
终止当前循环，跳出循环体
continue语句
终止当前循环，并开始下一轮循环（再开始下一轮循环之前，回先测试循环条件）
for i in range(10) if i%2 != 0: print( i ) continue i + = 2 print( i )
2 1 4 3 6 5 8 7 10 9
第五章
创建列表（中括号）
number = [1, 2, 3, 4, 5]
mix = [1 , '快乐'， 3.14, [1, 2, 3] ]
从列表中获取元素
列表名[0]
从列表中获取第一个元素
向列表添加元素
列表名称.append(6)
添加到列表末尾，且只能一个一个添加
列表名称.extend( [ 6 , 7 ] )
添加到末尾，用列表扩展原有列表
列表名称.insert( 0 , 6 )
往列表的第一个位置添加6
mix.insert(len(mix), '快乐')
在列表最后位置添加快乐元素
从列表中删除元素
列表名.remove("快乐")
从列表中删除『快乐』这个元素 （如果列表中有多个快乐元素，则只删除最前面的元素，列表中如果没有快乐元素，程序会报错）
del 列表名[ 0 ]
删除列表中第一个位置的元素
如果要删除整个列表，可以直接使用 del 列表名
列表名.pop()
默认删除最后一个元素
列表名.pop(0)
删除列表中第一个元素
列表名.clear()
删除整个列表
列表中元素位置互换
列表名[ 0 ] ,列表名[ 1 ] = 列表名[ 1 ] ,列表名[ 0 ]
列表的第一个和第二个位置元素互换
列表中元素内容替换
列表名[3] = '苹果'
列表中第四个元素替换成'苹果'
列表名[3 : ] =[ 'a' , 'b', 'c', 'd',.......]
把列表中第四个以后的元素依次替换成'a' 'b' 'c' 'd' 等
变量不是一个盒子
当赋值运算发生时，数据并不是放到变量里，而是将变量与数据挂钩（列表的引用）

拷贝列表（浅拷贝）
列表名.copy()
import copy copy.copy(列表名)

使得拷贝后的列表与原列表是分开独立的，改动一个，另一个也不会发生改变（仅限于列表内不包含子列表）

列表分片（切片）
按需求建立原列表的一个拷贝，原列表并没有发生改变

列表名[ 0 : 6 ]
复制一个原列表第一个至第六个位置元素的列表，结束位置上的元素是不包括的
列表名[ : 6 ]
：前没有开始定位，默认从第一个开始复制到第六个位置
列表名[ 2 : ]
：后面没有结束定位，默认从第三个开始复制到最后
列表名[ : ]
复制整个列表
app[ 0 : 9 : 2 ]
表示从app这个列表里第一至第九个元素每前进两个取出一个元素
app[ 0 : 9 : - 1 ]
表示从app这个列表里复制一个反转的列表
拷贝列表（深拷贝）
import copy copy.deepcopy(列表名)

导入拷贝模块进行拷贝，如果列表中包含子列表，拷贝后的列表不受原列表改动的影响
列表内元素排序
如果列表内元素都是数字的话，可以用sort()来对列表内的数字从小到大排序，用reverse()或者sort(reverse=True)对数字从大到小排序,reverse(也可以用于非数字的列表倒序排列)
 
查找列表中的元素
count()——查个数
index(x,start,end)——查索引值，默认查询到第一个,如果有多个相同元素且设置起始位置，那么查询起始位置里第一个所查元素的索引值）

列表的各种方法集合
列表的加法和乘法
+号连接的两个列表将元素对象合并在一起，相当于extend()的用法，建议用extend

*可以重复列表若干次

嵌套列表
一个列表里嵌套列表的做法

访问嵌套列表，用for in

也可用索引值来访问嵌套列表内的列表

通过循环语句来创建并初始化二维列表
 
列表推导式
如何把一个包含数字元素的列表内每一个元素的值变成原来的2倍
可以利用for循环来实现

利用列表推导式的方法来实现

列表推导式 基本语法 [expression for target in iterable]
 
expression为存放在列表中的数据
列表推导式添加 if 筛选 [expression for target in iterable if condition]

筛选首字母是特定字符的方法（大小写有区分）

列表推导式进行嵌套 [expression for target in iterable1 for taregt in iterable2 ... for target in iterableN]
从二维列表降级成一维列表
 
列表推导式延伸 [expression for target in iterable1 if condition1 for taregt in iterable2 if condition2 ... for target in iterableN if conditionN]
举例

元组
列表和元组的区别
列表——[元素1, 元素2, 元素3, 元素4, 元素5]
元组——(元素1, 元素2, 元素3, 元素4, 元素5) 元组中的元素无法修改 括号在不影响歧义的情况下可以删除，但是建议任何时候都加上括号

列表可以增、删、改、查，但元组只支持查询

元组也可以使用拼接和重复,并且支持嵌套

元组可以迭代

元组支持列表推导式

只生成一个元素的元组，一定要加『,』

元组及列表的打包及解包 左右元素数量要一致 字符串也适用
 
元组中的元素是不可变的，但是如果元组中的元组是指向一个可变的列表，那么是可以修改列表里面的内容的

字符串
回文数（是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。）

45个处理字符串的方法 返回的并不是源字符串，只是按照规则生成的一个新的字符串

拼接
('-' .join(str)) # 用来指定拼接符号，拼接出一个字符串，效率比+高

(str.center(100, '*' )) # 字符串居中，左右填充指定内容'*'
(str.ljust(50, '*' )) # 返回一个原字符串左对齐,并使用指定内容'*'填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
(str.rjust(50, '*' )) # 它将原字符串右对齐，并使用指定内容'*'填充至指定长度，并返回新的字符串。如果指定的长度小于原字符串长度，则直接返回原字符串。
(str.zfill(50)) # 返回指定长度的字符串，原字符串右对齐，前面填充0。
查找
(str.count( 'p' )) # 指定内容，在原str中出现了多少次，也可以指定起始位置count('p'[,start[,end]])
(str.find( 'pip' )) # 包含pip,则返回开始的索引值，否则返回-1。
(str.rfind( ' ' )) # 返回参数字符串在字符串中最后一次出现的位置。没有查询到则返回-1.

(str.index( 'pip' )) # 包含pip,则返回开始的索引值，否则返回Exception。
(str.rindex( ' ' )) # 返回参数字符串在字符串中最后一次出现的位置。没有查询到则返回Exception.
分割和替换
(str.replace( 'old ' , 'new' ,count = -1)) # 替换操作，str.replace()函数并不对原有的字符串进行改变。其中count=-1可以省略，默认为全部替换，更改则规定替换次数。

(str.partition( ' ' )) # 如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。

(str.rpartition( ' ' )) # 类似于 partition() 方法，只是该方法是从目标字符串的末尾也就是右边开始搜索分割符。
(str.split( sep=None,maxsplit=-1 )) # 分割字符串,如果给出了 maxsplit，则最多进行 maxsplit 次拆分,从最左边开始

(str.rsplit( sep=None,maxsplit=-1)) # 如果给出了maxsplit，则最多进行 maxsplit 次拆分，从最右边开始。
(str.splitlines(keepends=False)) # 按照行界符('\r', '\r\n', \n'等)分隔，返回一个包含各行作为元素的列表，默认不包含行界符。

(str.lstrip( 'p' )) # 删除从开头开始指定的字符串，然后返回结果字符串。注意：只能从开头开始,lstrip()默认删除空白
 
(str.rstrip( 'p' )) # 删除 str 字符串末尾的指定字符，默认为空白符，包括空格、换行符、回车符、制表符。
(str.strip()) # 删除前后的指定字符，默认是空格
removeprefix及removesuffix#删除一个具体的字符串,moveprefix删除指定前缀，movesuffix删除指定后缀

大小写操作
(str.capitalize()) # 第一个字母大写，对中文无效
(str.lower()) # 字母转为小写，只对英语有效
(str.casefold()) # 字母转为小写，所有语言都有效，例如：德语
(str.upper()) # 字母全部转为大写，英语有效
(str.swapcase()) # 将字符串中的英文字母大小写互换，并返回修改后的字符串。
(str.title()) # 将字符串中的每个单词首字母大写，其余字母小写，并返回新的字符串。
判断内容
(str.startswith( 'pip'[,start[,end]] )) # 判断是否以pip为开头，返回布尔类型值

(str.endswith( 'office'[,start[,end]] )) # 判断str是否以office结尾，返回布尔类型值
(str.isalnum()) # 如果 str 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
(str.isalpha()) # 如果 str 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False，有空格则空格不是字母，会返回False

(str.isascii()) # 如果字符串为空或字符串中的所有字符都是 ASCII，则返回 True，否则返回 False。
(str.isdecimal()) # 如果字符串中的所有字符都是十进制字符，则返回True
(str.isdigit()) # isdigit函数检测字符串中是否只包含数字字符。若全部是由数字字符组成的字符串，则返回True，否则返回False。isdigit函数没有参数。
(str.isidentifier()) # 如果字符串是Python中的有效标识符，返回True。如果不是，则返回False。有空格则返回False，把空格替换成下划线可以返回True，数字开头返回False

(str.islower()) # islower() 方法检测字符串是否由小写字母组成.
(str.isupper()) # 检测字符串中所有的字母是否都为大写。

(str.isnumeric()) # 检查字符串中是否只包含数值字符。此方法只适用于Unicode的对象。
(str.isprintable()) # 如果字符串中的所有字符都可打印或字符串为空，则返回 True，否则返回 False。
(str.isspace()) # 检测字符串是否只由空白字符组成。
(str.istitle()) # 检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。
不常用
(str.maketrans()) #此静态方法返回一个 可供 str.translate() 使用的转换对照表。
(str.translate(table))#返回一个根据table参数转换后的新字符串
(str.encode(encoding= 'utf8' , errors= 'strict' )) # 返回字符串编码后的数据，默认的编码是当前的字符串编码。errors为给定的不同错误处理方法。
(str.expandtabs()) # 用空格替换\t符号(Tab)
有问题 
(str.format(content= 'yyds' ))
format_map_dict = {'content': 'yyds'}
(str.format_map(format_map_dict)) # str.format_map(mapping) 方法仅适用于字符串格式中可变数据参数来源于字典等映射关系数据时。mapping 会被直接使用而不是复制到一个 dict。
格式化
格式化字符串就是按照统一的规格去输出一个字符串
format
 
可选参数：[[fill]align][sign][#][0][width][grouping_option][.precision][type]
[align]

[sign]

[grouping_option]

[.precision]精度
对于[type]设置为'f'或'F'的浮点数来说，是限定小数点后显示多少个数位

对于[type]设置为'g'或'G'的浮点数来说，是限定小数点前后一共显示多少个数位

对于非数字类型来说，限定的是最大字段的大小

对于整数类型来说，限定截取前几个数位

[tpye]类型
适用于整数的参数类型 可配合[#]可选参数来使用，当以二进制十进制等输出的时候，会自动追加一个前缀
 
适用于浮点数和负数的参数类型

可以通过关键字参数来设置选项的值

f-字符串 f-string
可以看作是format语法的语法糖，自动识别format语法，简化格式化字符串的操作
 
序列
包括列表、元组和字符串
都可以通过索引得到每一个元素
默认索引值总是从0开始
可以通过分片的方法得到一个范围内的元素的集合
有很多共同的操作符（重复操作符、拼接操作符、成员关系操作符）
可以分为可变序列和不可变序列
列表——可变序列
元组、字符串——不可变序列
序列的拼接和重复（+ *）

序列的增量赋值

is 、is not 运算符（同一性运算符）
用来检测对象的id值是否相等，从而判断是否是同一个对象

in 、 not in运算符（包含运算符）
用来检测元素是否包含在序列中

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

用del语句来实现clear的方法

列表、元组和字符串相互转换的函数
迭代：重复反馈过程的活动，其目的通常是为了接近并到达所需的目标或结果
list()
用于把一个可迭代对象转换为列表

tuple()
用于把一个可迭代对象转换为元组

str()
用于把一个可迭代对象转换为字符串

min() max()
用于返回序列或者参数集合中的最大值或者最小值，max(),min()的参数可以是一个序列，返回值是该序列中的最大值，也可以是多个参数，那么返回这些参数中最大的一个。需要注意的是要保证序列或参数的数据类型统一
min(iterable, *[, key, default]) min(arg1, arg2, *args[, key])

max(iterable, *[, key, default]) max(arg1, arg2, *args[, key])
len()
用于返回参数的长度，但是有最大可承受范围 对于64位平台来说，最大数值是2的63次方减1

sum()
求和函数，有一个可选参数start(),如果设置该参数，表示从该值开始加起，默认值是0

sorted()
排序函数，实现效果同sort()函数一致，但是列表的内建方法sort()是实现列表原地排序，而sorted()是返回一个排序后的新列表
 
reversed()
用于返回逆向迭代序列的值 实现效果跟列表的内建方法reverse()一致，区别是列表的内建方法是原地翻转，而reversed()是返回一个翻转后的迭代对象。

all()
判断可迭代对象中，是否所有元素的值都为真，元素除了是 0、空、None、False 外都算 True

any()
判断可迭代对象中，是否存在某个元素的值为真

enumerate()
用于返回一个枚举对象，它的功能就是将可迭代对象中的每个元素及从0开始的序号共同构成一个二元组的列表
 
zip()
用于创建一个聚合多个可迭代对象的迭代器。 它会将作为参数传入的每个可迭代对象的每个元素依次组合成元组，即第i个元组包含来自每个参数的第i个元素

ord()
反馈传入字符对应的 ASCII 数值，或者 Unicode 数值，返回值是对应的十进制整数。

pow(x, y[, z])
也可以通过导入math模块来操作
import math math.pow( x, y )
函数是计算 x 的 y 次方，如果 z 在存在，则再对结果进行取模，其结果等效于pow(x,y) %z。 注意：pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。
map()
会根据提供的函数对指定的可迭代对象的每个元素进行运算，并将返回运算结果的迭代器

filter()
会根据提供的函数对指定的可迭代对象的每个元素进行运算，并将运算结果为真的元素，以迭代器的形式返回。过滤器

一个迭代器肯定是一个可迭代对象
渴迭代对象可以重复使用，而迭代器则是一次性的

iter()
将可迭代对象转换为迭代器

next()
依次从迭代器中取出元素

第六章
字典
字典是Python中唯一实现映射关系的内置类型
字典这个数据结构活跃在所有Python程序的背后，即便你的源码里并没有直接用到它
用列表方式实现 用字典方式实现 
s = {a:b} 其中，a表示键，b表示值
 
增
fromkeys(iterable[,values])
用于创建并返回一个新的字典，它有两个参数：第一个参数是字典的键；第二个参数是可选的，是传入键对应的值。如果不提供，那么默认是None

序列中的元素可以重复，而字典中的键是唯一的
删
pop(key[,default])
给定键弹出对应的值

popitem()
Python3.7之后为弹出最后一组键值

del方法

clear()
只清楚字典中的内容

改
update([other])
用来更新字典

查
get(key[,default])
default为可选参数，可以指定在没有查询键值的时候返回对应的内容

setdefault(key[,default])
当查询的键值不存在时，可以添加相应的键值

访问
key()
用于返回字典中的键的视图对象

视图对象即字典的动态视图，这就意味着当字典的内容发生改变的时候，视图对象的内容也会相应地跟着改变。
values()
用于返回字典中所有的值的视图对象

items()
返回字典中所有的键值对（也就是项）的视图对象

浅拷贝
copy()

其他可用函数

len()
获取长度
in/not in
判断是否包含
list()
将字典传唤为列表
iter()
转换为迭代器
reversed()
对字典元素顺序逆向排序（3.8版本后支持）
嵌套

字典推导式

集合
集合中所有元素都应该是独一无二的，并且也是无序的！
创建集合的方式

因为集合是无序的，所以无法使用索引值访问

in/ not in

访问集合中的元素，可以使用迭代的方式

利用集合的唯一性，可以实现去重的效果

集合分为可变和不可变两种，可变集合为set()，不可变集合为frozenset()

集合内置函数
既适用于set对象，也适用于frozenset对象
s.copy()
返回s集合的一个浅拷贝
s.isdisjoint(other)
如果s集合中没有与other容器存在共同的元素，那么返回True，否则返回False

s.issubset(other)
如果s集合是other容器的子集，那么返回True，否则返回False

集合A中任意一个元素都是集合B中的元素，我们就说这两个集合有包含关系，称集合A为集合B的子集（Subset）
s.issuperset(other)
如果s集合是other容器的超集，那么返回True，否则返回False

集合B中任意一个元素都是集合A中的元素，我们就说这两个集合有包含关系，成集合A为集合B的超集（superset）
s.union(others)
返回一个新集合，其内容是s集合与others容器的并集

把集合A和集合B中所有的元素合并在一起组成的集合，叫做集合A与集合B的并集（Union）
s.intersection(others)
返回一个新集合，其内容是s集合与others容器的交集

属于集合A且属于集合B的元素组成的集合，叫做集合A和集合B的交集（Intersection）
s.difference(others)
返回一个新集合，其内容是存在于s集合中，但不存在于others容器中的元素

由所有属于集合A且不属于集合B的元素组成的集合，叫做集合A与集合B的差集（Difference）
s.symmetric_difference(other)
返回一个新集合，其内容是排除掉s集合和others容器中共有的元素后，剩余的所有元素

对称差集
others参数表示支持多个容器（参数类型可以是集合，也可以是序列）；other参数则表示单个容器
以上六种操作，可以使用操作符来运算

仅适用于set对象
update(*others)
使用others参数指定的值来更新集合，补充进去而非完全替代

intersection_update(*others)
使用交集的方式来更新集合

difference_update(*others)
使用差集的方式来更新集合

symmetric_difference_update(other)
使用对称差集的方式来更新集合

add(elem)
添加指定的某个元素，与update不同的是update会拆分字符串，而add则会把整个字符串作为整体添加

remove(elem)
指定删除某个元素，如果没有此元素会报错

discard(elem)
指定删除某个元素，如果没有此元素会静默处理

pop()
随机从集合中弹出一个元素

clear()
清空集合

可哈希
哈希算法将任意长度的二进制值映射为较短的固定长度的二进制值，这个小的二进制值称为哈希值。哈希值是一段数据唯一且极其紧凑的数值表示形式。如果散列一段明文而且哪怕只更改该段落的一个字母，随后的哈希都将产生不同的值。要找到散列为同一个值的两个不同的输入，在计算上是不可能的，所以数据的哈希值可以检验数据的完整性。一般用于快速查找和加密算法。
想要正确的创建集合和字典，有一个刚性需求，要求字典的键及集合的元素，必须是和哈希的
hash(object)

Python中大多数不可变的对象都是可哈希的，而可变的对象是不可哈希的

第七章
函数
把代码打包，从而使得代码简单易用

def 函数名(参数列表): # 函数体 [return [返回值]] # [] 括起来的为可选择部分，即可以使用，也可以省略

函数的参数可以分为形式参数和实际参数，上述例子中，name，times是形式参数，而输入的apple，2为实际参数
函数的返回值，使用return来实现 如果不添加return语句，那么函数也会在执行完返回一个none值

函数只用在定义和调用的时候才会用到小括号
函数的参数
位置参数

普通的参数叫位置参数
关键字参数
就是在传入实参时指定形参的变量名
使用位置参数和关键字参数时，要注意位置参数要在前面，关键字参数在最后

默认参数
默认参数是在定义的时候赋予了默认值的参数
使用默认参数时，要把默认参数摆在最后

收集参数
也被称作可变参数，可以传入多个参数，用收集参数方便操作，使用方法是在参数前面加上*

如果在收集参数后面，还需要指定其它参数，那么在调用函数的时候，应该使用关键字参数来指定后面的参数，否则Python会把所有实参列入到收集参数中

收集参数除了可以将参数打包成元组，还可以将参数打包成字典，使用方法是在参数前面加**

混合使用参数
 
在语法里，/左边只能只用位置参数，不是使用关键字参数,/右侧随意

在语法中，*右边只能用关键字参数

解包参数
*,**在形参上使用我们称之为打包，在实参上使用，可以实现解包参数

作用域
指一个变量可以被访问的范围
局部作用域
如果一个变量定义的位置是在函数的里面，那么其作用域就仅限于该函数中，称之为局部变量。

全局作用域
在任何函数的外部去定义一个变量，那么变量的作用域就是全局的，称之为全局作用域。

当全局变量和局部变量的名称一样时，局部变量会覆盖同名的全局变量

global语句
用以在函数内部通过局部变量去修改全局变量（不建议使用）

嵌套函数
在函数内部创建另一个函数，又叫内嵌函数或内部函数

nonlocal语句
在内嵌函数中实现修改外部函数变量

LEGB规则
Python变量的解析机制
Local
局部作用域
Enclosed
嵌套函数的外层函数作用域
Global
全局作用域
Build-In
内置作用域
闭包
对于嵌套函数来说，外层函数的作用域是会通过某种形式给保存下来的，尽管这个函数已经调用完了，但是外层作用域中的变量是会保存下来的，并不会像局部作用域那样，调用完就消失了
闭包：在一个内部函数里对外部作用域（但不是在全局作用域）的变量进行引用，则这个内部函数就是一个闭包，也称为工厂函数

利用nonlocal语句，来实现内部函数可以修改到外层函数作用里的变量，再利用内层函数能够记住外层函数作用域的特性，可以实现带记忆功能的函数

利用嵌套函数的外层作用域具有记忆能力这个特性
将内层函数作为返回值给返回
闭包的生成原理
装饰器
把函数作为参数传递给另一个函数

简单地说，他们是修改其他函数的功能的函数。他们有助于让我们的代码更简短，也更Pythonic（Python范儿）。

语法糖@+装饰器名字

多个装饰器同时用在同一个函数上

如何给装饰器传递参数
 
lambda表达式（匿名函数）
lambda arg1, arg2, arg3, ... argN : expression
def <lambda>(arg1, arg2, arg3, ... argN): return expression
基本语法是在冒号(:)左边放原函数的参数，可以有多个参数，用逗号（,）隔开既可； 冒号右边是返回值。
lambda是一个表达式，所以它可以用在常规函数不可能存在的地方，例如lambda可以存在列表里面，而普通函数是不可以的

生成器
对于一个普通的Python函数，一般是从函数的第一行代码开始执行，结束于return语句、异常或者函数所有语句执行完毕。一旦函数将控制权交还给调用者，就意味着全部结束。函数中做的所有工作以及保存在局部变量中的数据都将丢失。再次调用这个函数时，一切都将从头创建。
让函数在退出之后还能保留状态的简单方法——生成器 用yield 代替return

生成器可以暂时挂起函数，并保留函数的局部变量等数据，然后在再次调用它的时候，从上次暂停的位置继续执行下去。
生成器其实可以看作是一种特殊的迭代器，因为它不走回头路，另外，支持next()函数

使用生成器来求出斐波那契数列

生成器表达式
利用推导的形式获得生成器的方法，叫生成器表达式

列表推导式会一下子将所有数据生产出来
生成器表达式则一次生成一个数据
实现生成器的两种方法
将普通函数里的return替换成yield表达式
直接使用生成器表达式
递归
递归，从原理上来说就是函数调用自身这么一个行为，在函数内部，可以调用所有可见的函数，当然也包括自己。

当我们使用递归的时候，要搭配运行条件来使用

用迭代和递归来实现同一个任务
求一个数的阶乘

求斐波那契数列

利用递归解汉诺塔