知识点一：列表、集合、元组、字典的区分及各自使用方法
|
|
列表list |
元组tuple |
字典dictionary |
集合set |
|
是否可变 |
可变 |
不可变 |
可变 |
可变 |
|
是否有序 |
有序 |
有序 |
无序 |
无序 |
|
元素是否重复 |
可重复 |
可重复 |
键不可重复 |
不可重复 |
|
定义符号 |
[] |
() |
{key:value} |
{} |
|
创建 |
1.[]直接创建 2.list() 3.列表生成式 |
1.（）直接创建 2.tuple（） |
1.{}直接创建 2.dict（key1=value1） 3.dict（zip（list1，list2）） |
1.{}直接创建 2.set（） |
|
删除 |
1.del删除元素或者列表 2.list.remove（value） 3.list.pop() |
1.del删除元素或元组 |
1.del删除元素或字典 2. |
1.del删除元素或集合 2.set.remove() 3.set.pop() 4.set.clear() |
|
修改插入 |
1.append（） 2.insert（） 3.+ 4.extend（） |
不可修改 |
1.dict[key]=value |
s.add() |
|
访问，遍历 |
1.索引访问 2.for循环遍历 for i in list for index，i in enumerate（list） |
1.索引访问 2.for循环遍历 |
1.键访问 2.get（）访问 3.for key，value in dict.items（） for key in dict.keys() for value in dict.values() |
for循环遍历 |
|
生成式 |
[i*i for i in list1]返回列表 |
（i*i for i in list1）返回生成器对象，通过for和next（）访问 |
dict={i:j for i,j in zip(list1,list2)} dict={i*2:2 for i in range(1,10)} |
交集&，并集|，差集- |
|
切片 |
支持切片 |
支持切片 |
不支持切片 |
不支持切片 |
|
索引 |
支持索引 |
支持索引 |
不支持索引 |
不支持索引 |
|
+，* |
支持 |
支持 |
不支持 |
不支持 |
|
其他 |
不能作为字典的键 |
可以作为字典的键 |
|
知识点二：切片操作
1、Python可切片对象的索引方式
包括：正索引和负索引两部分，如下图所示，以a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]为例：
2、Python切片操作的一般方式
一个完整的切片表达式包含两个“:”，用于分隔三个参数(start_index、end_index、step)，当只有一个“:”时，默认第三个参数step=1。
切片操作基本表达式：object[start_index:end_index:step]
step：正负数均可，其绝对值大小决定了切取数据时的‘‘步长”，而正负号决定了“切取方向”，正表示“从左往右”取值，负表示“从右往左”取值。当step省略时，默认为1，即从左往右以增量1取值。“切取方向非常重要！”“切取方向非常重要！”“切取方向非常重要！”，重要的事情说三遍！
start_index：表示起始索引（包含该索引本身）；该参数省略时，表示从对象“端点”开始取值，至于是从“起点”还是从“终点”开始，则由step参数的正负决定，step为正从“起点”开始，为负从“终点”开始。
end_index：表示终止索引（不包含该索引本身）；该参数省略时，表示一直取到数据“端点”，至于是到“起点”还是到“终点”，同样由step参数的正负决定，step为正时直到“终点”，为负时直到“起点”。
3、 Python切片操作详细例子
以下示例均以列表a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]为例：
>>>a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
1. 切取单个值
>>>a[0]
>>>0
>>>a[-4]
>>>6
2. 切取完整对象
>>>a[:] #从左往右
>>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>a[::]#从左往右
>>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>a[::-1]#从右往左
>>> [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
3. start_index和end_index全为正（+）索引的情况
>>>a[1:6]
>>> [1, 2, 3, 4, 5]
step=1，从左往右取值，start_index=1到end_index=6同样表示从左往右取值。
>>>a[1:6:-1]
>>> []
输出为空列表，说明没取到数据。
step=-1，决定了从右往左取值，而start_index=1到end_index=6决定了从左往右取值，两者矛盾，所以为空。
>>>a[6:1]
>>> []
同样输出为空列表。
step=1，决定了从左往右取值，而start_index=6到end_index=1决定了从右往左取值，两者矛盾，所以为空。
>>>a[:6]
>>> [0, 1, 2, 3, 4, 5]
step=1，从左往右取值，从“起点”开始一直取到end_index=6。
>>>a[:6:-1]
>>> [9, 8, 7]
step=-1，从右往左取值，从“终点”开始一直取到end_index=6。
>>>a[6:]
>>> [6, 7, 8, 9]
step=1，从左往右取值，从start_index=6开始，一直取到“终点”。
>>>a[6::-1]
>>> [6, 5, 4, 3, 2, 1, 0]
step=-1，从右往左取值，从start_index=6开始，一直取到“起点”。
4. start_index和end_index全为负（-）索引的情况
>>>a[-1:-6]
>>> []
step=1，从左往右取值，而start_index=-1到end_index=-6决定了从右往左取值，两者矛盾，所以为空。
索引-1在-6的右边（如上图）
>>>a[-1:-6:-1]
>>> [9, 8, 7, 6, 5]
step=-1，从右往左取值，start_index=-1到end_index=-6同样是从右往左取值。
索引-1在6的右边（如上图）
>>>a[-6:-1]
>>> [4, 5, 6, 7, 8]
step=1，从左往右取值，而start_index=-6到end_index=-1同样是从左往右取值。
索引-6在-1的左边（如上图）
>>>a[:-6]
>>> [0, 1, 2, 3]
step=1，从左往右取值，从“起点”开始一直取到end_index=-6。
>>>a[:-6:-1]
>>> [9, 8, 7, 6, 5]
step=-1，从右往左取值，从“终点”开始一直取到end_index=-6。
>>>a[-6:]
>>> [4, 5, 6, 7, 8, 9]
step=1，从左往右取值，从start_index=-6开始，一直取到“终点”。
>>>a[-6::-1]
>>> [4, 3, 2, 1, 0]
step=-1，从右往左取值，从start_index=-6开始，一直取到“起点”。
5. start_index和end_index正（+）负（-）混合索引的情况
>>>a[1:-6]
>>> [1, 2, 3]
start_index=1在end_index=-6的左边，因此从左往右取值，而step=1同样决定了从左往右取值，因此结果正确
>>>a[1:-6:-1]
>>> []
start_index=1在end_index=-6的左边，因此从左往右取值，但step=-则决定了从右往左取值，两者矛盾，因此为空。
>>>a[-1:6]
>>> []
start_index=-1在end_index=6的右边，因此从右往左取值，但step=1则决定了从左往右取值，两者矛盾，因此为空。
>>>a[-1:6:-1]
>>> [9, 8, 7]
start_index=-1在end_index=6的右边，因此从右往左取值，而step=-1同样决定了从右往左取值，因此结果正确。
6. 连续切片操作
>>>a[:8][2:5][-1:]
>>> [4]
相当于：
a[:8]=[0, 1, 2, 3, 4, 5, 6, 7]
a[:8][2:5]= [2, 3, 4]
a[:8][2:5][-1:] = 4
理论上可无限次连续切片操作，只要上一次返回的依然是非空可切片对象。
7. 切片操作的三个参数可以用表达式
>>>a[2+1:3*2:7%3]
>>> [3, 4, 5]
即：a[2+1:3*2:7%3] = a[3:6:1]
8. 其他对象的切片操作
前面的切片操作说明都以list为例进行说明，但实际上可进行的切片操作的数据类型还有很多，包括元组、字符串等等。
>>> (0, 1, 2, 3, 4, 5)[:3]
>>> (0, 1, 2)
元组的切片操作
>>>'ABCDEFG'[::2]
>>>'ACEG'
字符串的切片操作
>>>for i in range(1,100)[2::3][-10:]:
print(i)
就是利用range函数生成1-99的整数，然后取3的倍数，再取最后十个。
4、 常用切片操作
以列表：a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 为说明对象
1.取偶数位置
>>>b = a[::2]
[0, 2, 4, 6, 8]
2.取奇数位置
>>>b = a[1::2]
[1, 3, 5, 7, 9]
3.拷贝整个对象
>>>b = a[:] #★★★★★
>>>print(b) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>print(id(a)) #41946376
>>>print(id(b)) #41921864
或
>>>b = a.copy()
>>>print(b) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>print(id(a)) #39783752
>>>print(id(b)) #39759176
需要注意的是：[:]和.copy()都属于“浅拷贝”，只拷贝最外层元素，内层嵌套元素则通过引用，而不是独立分配内存。
>>>a = [1,2,['A','B']]
>>>print('a={}'.format(a))
>>>b = a[:]
>>>b[0] = 9 #修改b的最外层元素，将1变成9
>>>b[2][0] = 'D' #修改b的内嵌层元素
>>>print('a={}'.format(a))
>>>print('b={}'.format(b))
>>>print('id(a)={}'.format(id(a)))
>>>print('id(b)={}'.format(id(b)))
a=[1, 2, ['A', 'B']] #原始a
a=[1, 2, ['D', 'B']] #b修改内部元素A为D后，a中的A也变成了D，说明共享内部嵌套元素，但外部元素1没变。
b=[9, 2, ['D', 'B']] #修改后的b
id(a)=38669128
id(b)=38669192
4.修改单个元素
>>>a[3] = ['A','B']
[0, 1, 2, ['A', 'B'], 4, 5, 6, 7, 8, 9]
5.在某个位置插入元素
>>>a[3:3] = ['A','B','C']
[0, 1, 2, 'A', 'B', 'C', 3, 4, 5, 6, 7, 8, 9]
>>>a[0:0] = ['A','B']
['A', 'B', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
6.替换一部分元素
>>>a[3:6] = ['A','B']
[0, 1, 2, 'A', 'B', 6, 7, 8, 9]
知识点三：Python的常用函数及方法
函数
1、len() 函数计算括号内字符串包含多少个字符
2、ord() 函数获取字符的整数表示
3、chr() 函数把编码转换为对应的字符
Python对bytes类型的数据用带b前缀的单引号或双引号表示：
注意区分'ABC'和b'ABC'，前者是str，后者虽然内容显示得和前者一样，但bytes的每个字符都只占用一个字节。
4、abs() 函数求绝对值
5、max() 函数，返回接收的多个参数中最大的那个
方法
1、encode() 方法可以编码为指定的bytes
2、decode() 方法可以把bytes变为str
注：如果bytes中包含无法解码的字节，decode() 方法会报错。
3、format() 方法用传入的参数依次替换字符串内的占位符{0}、{1}…… （格式化字符串）
注： {1:.1f} 表示保留小数点1位 ，其中f 指浮点数float类型
这里推荐两个写的比较详细的链接：
https://www.cnblogs.com/xinxinyo/p/10394842.html
https://www.cnblogs.com/nice107/p/8118876.html
补充一个函数：range（）函数：
python range() 函数可创建一个整数列表，一般用在 for 循环中。
range(start, stop[, step])
参数说明：
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
注：range函数中：左取右不取
知识点四：内置函数
这里直接推荐一个链接，介绍的十分详细：
https://blog.csdn.net/y472360651/article/details/73132553
知识点五：列表排序
方法一：
list3= [91, 95, 97, 99, 92, 93, 96, 98]
list3.sort() #降序：list3.sort(reverse=True)
print(list3)
方法二：
nums = [1, 2, 6, 3, 9, 7, 5]
print(nums)
print(sorted(nums)) #按数字从小到大排序
print(sorted(nums, reverse=True)) #按数字从大到小排序
方法三：
要反转列表元素的排列顺序，可使用方法reverse()。（倒序输出）
知识点六：列表合并
方法一（代码最长）：
list1 = [91, 95, 97, 99]
list2 = [92, 93, 96, 98]
#建立一个空列表
list_new = []
#利用append函数将list1中元素依次放入list_new中
for item in list1:
list_new.append(item)
#利用append函数将list1中元素依次放入list_new中
for item in list2:
list_new.append(item)
#打印list_new列表
print(list_new)
方法二（适中）：
a = [1,2,3]
b = [4,5,6]
c = zip(a,b) #c = [(1,4),(2,5),(3,6)]
list_new = [row[i] for i in range(len(0)) for row in c]
print(list_new)
方法三（最简单）：
（1）
list1 = [91, 95, 97, 99]
list2 = [92, 93, 96, 98]
list3 = list1 + list2
print(list3)
（2）
list1 = [91, 95, 97, 99]
list2 = [92, 93, 96, 98]
# 把 list1赋值给一个新列表，用来存合并的元素——这个细节要注意！
list3 =list1
list3.extend(list2)
print(list3)
知识点七：Lambda表达式
lambda表达式，通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用，也就是指匿名函数。
lambda所表示的匿名函数的内容应该是很简单的，如果复杂的话，干脆就重新定义一个函数了，使用lambda就有点过于执拗了。
lambda就是用来定义一个匿名函数的，如果还要给他绑定一个名字的话，就会显得有点画蛇添足，通常是直接使用lambda函数。如下所示：
add = lambda x, y : x+y
add(1,2) # 结果为3
那么到底要如何使用lambda表达式呢
1、应用在函数式编程中
Python提供了很多函数式编程的特性，如：map、reduce、filter、sorted等这些函数都支持函数作为参数，lambda函数就可以应用在函数式编程中。如下：
# 需求：将列表中的元素按照绝对值大小进行升序排列
list1 = [3,5,-4,-1,0,-2,-6]
sorted(list1, key=lambda x: abs(x))
2、应用在闭包中
def get_y(a,b):
return lambda x:ax+b
y1 = get_y(1,1)
y1(1) # 结果为2
lambda应用举例：
1、计算最大值:
_lamd = lambda x, y: max(x, y)
print(_lamd(10, 222))
结果：222
2、计算输入的和:
_lamd = lambda x, y: x + y
print(_lamd(10, 222))
结果:232
知识点八：带*/**的数字和列表
1、表示乘号
2、表示倍数，例如：
def T(msg,time=1):
print((msg+' ')*time
T（'hi',3）
打印结果（打印3次）：
结果：hi hi h
3、单个 *
（1）、如：*parameter是用来接受任意多个参数并将其放在一个元组中。
>>> def demo(*p):
print(p)
>>> demo(1,2,3)
(1, 2, 3)
（2）、函数在调用多个参数时，在列表、元组、集合、字典及其他可迭代对象作为实参，并在前面加 *
如 *（1,2,3）解释器将自动进行解包然后传递给多个单变量参数（参数个数要对应相等）。
>>> def d(a,b,c):
print(a,b,c)
>>> d(1,2,3)
1 2
>>> a=[1,2,3]
>>> b=[1,2,3]
>>> c=[1,2,3]
>>> d(a,b,c)
[1, 2, 3] [1, 2, 3] [1, 2, 3]
>>> d(*a)
1 2 3
提示：序列解包要在关键参数和 **参数 之前进行处理
4、两个 ** 如: **parameter用于接收类似于关键参数一样赋值的形式的多个实参放入字典中（即把该函数的参数转换为字典）。
>>> def demo(**p):
for i in p.items():
print(i)
>>> demo(x=1,y=2)
('x', 1)
('y', 2)
知识点九：应用于逻辑判断的关键字
1、
2、关键字
3、运算结果