最近看了python的相关理论，总觉得看一章写一页的手写笔记差点意思，今天刚好把该追的电视剧追完了，就来写个总结吧！作为我CSDN的开端~
目录
1.简单介绍
1.1 列表（list）：
存储不同类型的数据，就像一个杂货铺，啥都可以有。数据用“ [ ] ” 装起来。
1.2 元组（tuple）：
就像小甲鱼（我的参考书作者）说的，元组是一个上了枷锁的列表，它和列表的最大区别就是：它不可改变！元组的灵魂是 ' , ' 没有逗号会被python判断为 int 。
煮个栗子~~
x = (1,)
print('x是', type(x)) #判断x的类型
y = (1)
print('y是', type(y)) #判断y的类型
z = 1,
print('z是', type(z)) #判断z的类型程序运行结果：（可以看到只要有逗号在，系统就会判断其为元组）
x是 <class 'tuple'>
y是 <class 'int'>
z是 <class 'tuple'>列表和元组的异同点总结：
同： 1.都属于迭代对象，支持索引和分片操作
2.都支持重复运算（ * ）和合并运算（ + ）
3.都支持len() , max() , min()等系统内置函数
4.列表和元组都可以相互转化（ tuple() / list() ）
异：元组不可进行修改，所以列表的添加、修改、删除元素的方法都不能用在元组上。但是可以 用del删除整个元组。
从上面几点来看，列表好像比元组实用多了，但是存在即合理，元组的特性决定了它拥有比列表更快的速度，比列表更安全，更容易维护。
1.3 字典（dict ）：
python的字典就相当于数学的映射，区别于序列（上述的列表和元组都属于学序列）用索引获取对应值，字典使用的是key：value，即一个键和对应值为一项。
字典不讲顺序，只讲映射，其标志性符号为“ { } ”。要注意一点，字典的键必须唯一，但其值可以取任何不可变的数据类型（字符串、元组、数等）。
1.4 集合（set）：
集合必须记住两个词——唯一！无序！集合是没有索引或者映射关系的，所以这注定了集合中的某个数据不能被引用。
运用集合的性质，可以对列表等进行去重操作，操作如下：
list1 = [1,1,2,2,'a']
list1 = list( set(list1) )
print(list1)程序运行结果：
[1, 2, 'a']2.创建
2.1 创建列表
number1 = [] #创建空列表
print(number1)
number2 = [1, 'a', [1,2]] #什么都能加！
print(number2)
number3 = list(range(4)) #list()创建列表
print(number3)程序运行结果：
[]
[1, 'a', [1, 2]]
[0, 1, 2, 3]2.2 创建元组
temp1 = () #创建空元组
print(temp1)
temp2 = (1,2,3,4,'x')
print(temp2)
temp3 = tuple(range(4)) #tuple()创建元组
print(temp3)程序运行结果：
()
(1, 2, 3, 4, 'x')
(0, 1, 2, 3)2.2 创建字典
dict1 = {} #创建空字典
print(dict1)
dict2 = {1:'我', 2:'爱', 3:'你'}
print(dict2)
dict3 = dict((('a', 10), ('b', 20), ('c', 30))) #用dict()函数创建字典，因为函数的参数只能是一个序列，所以要把多个元组打包成一个序列
print(dict3)
dict4 = dict(d = 40, e = 50, f = 60) #这个相比上一个会简洁些，要注意的是这个方法的键不能加引号，不然会报错
print(dict4)程序运行结果：
{}
{1: '我', 2: '爱', 3: '你'}
{'a': 10, 'b': 20, 'c': 30}
{'d': 40, 'e': 50, 'f': 60}2.4 创建集合
set1 = {1, 2, 3, 3}
print(set1)
set2 = set(['a', 'b', 'c']) #用set()函数
print(set2)
set3 = frozenset({4, 5, 6}) #创建冰冻集合，就是不可改变的集合
set3.add(7) #如果你非要改它，它就会生气地报错程序运行结果：（自动去重）
{1, 2, 3}
{'b', 'a', 'c'}
Traceback (most recent call last):
File "E:\PycharmProjects\11111\2.py", line 2, in <module>
set3.add(7)
AttributeError: 'frozenset' object has no attribute 'add'3.查找
3.1 查找列表元素
number = ['xx', 1, 2, 3, [4, 5]]
#查找单个元素
print(number[0]) #查找列表第一个数据
print(number[4][0]) #查找列表第5个数据中的第一个数据
#查找多个元素（列表分片）
print(number[0: 2]) #一个冒号隔开两个索引值，左边是开始位置（包含），右边是结束位置（不包含）
print(number[:2]) #没有开始位置时，默认位置是0
print(number[2:]) #没有结束位置时同理
#拓展
print(number[0:4:2]) #这里的第三个元素表示的是步长，这个例子的意思就是在列表的第1-4个元素中，每两个数字取一个，即取number的第1、3个元素
print(number[::-1]) #步长取-1时，可以理解为列表的反转操作
#查找元素在列表中的位置
print(number.index('xx')) #用到index()函数
print(number.index(1, 3, 5)) #查找元素1在序列的[3,5]中出现的位置程序运行结果：
xx
4
['xx', 1]
['xx', 1]
[2, 3, [4, 5]]
['xx', 2]
[[4, 5], 3, 2, 1, 'xx']
0
33.2 查找元组元素
元组的元素查找和列表基本是一样哒
temp = (1,2,3,4,'x')
#单个元素
print(temp[0])
#多个元素
print(temp[:1])
print(temp[1:])
程序运行结果：
1
(1,)
(2, 3, 4, 'x')3.3 查找字典元素
dict = {'a':'我', 'b':'爱', 'c':'你', 'd':'哦'}
print(dict['a'])
print(dict.keys()) #keys()访问字典的键
print(dict.values()) #values()访问字典的键的值
print(dict.items()) #items()访问字典的项——即键和对应的值
#get()
print(dict.get('a'))
print(dict.get(1)) #当输入的键不存在时，返回None
print(dict.get(1,'找不到')) #当输入的键不存在时，指定输出的内容
#setdefault() 和 get()类似
print(dict.setdefault('a'))
print(dict.setdefault(1)) #当输入的键不存在时,自动添加键，对应的值为None
print(dict)程序运行结果：
我
dict_keys(['a', 'b', 'c', 'd'])
dict_values(['我', '爱', '你', '哦'])
dict_items([('a', '我'), ('b', '爱'), ('c', '你'), ('d', '哦')])
我
None
找不到
我
None
{'a': '我', 'b': '爱', 'c': '你', 'd': '哦', 1: None}3.4 查找集合元素
上面说到集合是无序的，不能用索引这些东东来访问，但是能通过for循环迭代出来
set = {1,2,3}
for each in set:
print(each, end=' ') #打印出集合的每个元素，分隔符为' '程序运行结果：
1 2 34.添加
4.1 列表添加元素
用到的是append() 、extend() 、insert()函数
number = []
number.append(1) #appemd 添加元素
number.append([4,5]) #append添加数组
number.extend([2,3]) #extend 添加数组
number.insert(0,'xx') #insert 指定位置添加元素
print(number)
程序运行结果：
['xx', 1, [4, 5], 2, 3]
4.2 元组添加元素
之前说过元组是不可改变的，如果一定要改变，就只能通过拷贝元组的片段，构造一个新的元组
temp = (1,2,3,4)
new_temp = temp[:1] + ('xx',) + temp[1:] #相当于在原元组中的第二个位置插入'xx'
print(new_temp)程序运行结果：
(1, 'xx', 2, 3, 4)4.3 字典添加元素
用到的是fromkeys()函数
dict1 = {}
dict1 =dict1.fromkeys(('a', 'b')) #没有给键赋值，默认返回None
print(dict1)
dict1 = dict1.fromkeys(('a', 'b', 'c'),(1, 2)) #第二个参数传入键的值，不支持分别传入
print(dict1)程序运行结果：
{'a': None, 'b': None}
{'a': (1, 2), 'b': (1, 2), 'c': (1, 2)}4.4 集合添加元素
集合的添加很简单，用add()和update()
set1 = {'我', '是'}
set1.add('大聪明')
print(set1)
x = [1,2,3]
set1.update(x) #update()可用来添加可迭代对象
print(set1)
程序运行结果：
{'是', '我', '大聪明'}
{1, 2, 3, '我', '是', '大聪明'}集合的运算
-
并集
set1 = {1, 2, 3} set2 = {5, 6, 7} #集合的并集运算有（|）和（union()）两种方法 set3 = set1 | set2 print(set3) set4 = set1.union(set2) print(set4)程序运行结果：
{1, 2, 3, 5, 6, 7} {1, 2, 3, 5, 6, 7} -
交集
set1 = {1, 2, 3} set2 = {3, 4, 5} #集合的交集运算有（&）和（intersection()）两种方法 set3 = set1 & set2 print(set3) set4 = set1.intersection(set2) print(set4)程序运行结果：
{3} {3} -
差集
set1 = {1, 2, 3} set2 = {3, 4, 5} #集合的差集运算有（-）和（difference()）两种方法 set3 = set1 - set2 #set1和set2的差集 print(set3) set4 = set2.difference(set1) #set2和set1的差集 print(set4)程序运行结果：
{1, 2} {4, 5} -
对称差集
et1 = {1, 2, 3} set2 = {3, 4, 5} #对称差集由两者的差集组合而成 #集合的对称差集运算有（^）和（symmetric_difference()）两种方法 set3 = set1 ^ set2 print(set3) set4 = set1.symmetric_difference(set2) print(set4)程序运行结果：
{1, 2, 4, 5} {1, 2, 4, 5} -
子集父集
set1 = {1, 2, 3} set2 = {2, 3} #集合的子集判断有（<=）和（issubset()）两种方法 print(set2 <= set1) print(set2.issubset(set1)) #集合的父集判断有（>=）和（issuperset()）两种方法 print(set2 >= set1) print(set2.issuperset(set1))程序运行结果：
True True False False
5.修改
5.1 修改列表
x = [1,3,2,5]
x[0], x[1] = x[1], x[0] #交换列表第一个、第二个元素顺序
print(x)
x.sort(reverse=True) #降序排序
print(x)
x[2] = 'abc' #把第三个元素修改成‘abc’
print(x)
x = x * 2 #字面意思：两个x
print(x)
y = 'abc'
x = list(y) #list()把字符串的每个字符放到列表 这个操作会替换掉列表原有的数据
print(x)
x = list((1,2,3))
print(x)程序运行结果：
[3, 1, 2, 5]
[5, 3, 2, 1]
[5, 3, 'abc', 1]
[5, 3, 2, 1, 5, 3, 2, 1]
['a', 'b', 'c']
[1, 2, 3]利用分片修改列表：
关于分片的相关操作，不理解的请看主页的分片总结
x = [1,3,2,5]
print(x)
#连续区域的修改
x[0:2] = [40,50,60,70] #新内容必须是一组元素，若是单个元素会报错
print(x)
#非连续区域的修改
x[0:4:2] = ['月薪', '十万'] #新内容的个数需要和选中的非连续区域个数相同
print(x)程序运行结果：
[1, 3, 2, 5]
[40, 50, 60, 70, 2, 5]
['月薪', 50, '十万', 70, 2, 5]5.2 修改字典
用到的是update()函数，在上面字典添加中提到的fromkeys()函数也能起到修改函数的作用，在这里就不重复讲了
dict1 = {'a':'我', 'b':'爱', 'c':'你', 'd':'哦'}
dict1.update(a='他')
print(dict1)程序运行结果：
{'a': '他', 'b': '爱', 'c': '你', 'd': '哦'}6.删除
主要是del、remove()和pop()两个方法，del删除整个序列，remove()删除指定元素，pop()删除指定位置的元素，除此之外pop()还能弹出被删除的元素信息
6.1 删除列表元素
x = [1, 3, 2, 5, 7]
x.remove(2) #remove()删除指定元素
print(x)
print(x.pop()) #pop()删除列表最后一个元素(默认) print()显示pop出的元素
print(x)
x.pop(1) #pop()删除第二个元素
print(x)
del x[1] #del 删除第二个元素
print(x)
del x #del+列表名 删除列表程序运行结果：
[1, 3, 5, 7]
7
[1, 3, 5]
[1, 5]
[1]6.2 删除字典元素
dict1 = {'a':'我', 'b':'爱', 'c':'你', 'd':'哦'}
dict1.pop('a') #pop()给定键弹出指定元素
print(dict1)
dict1.popitem() #popitem()弹出一个项
print(dict1)
dict1.clear() #clear()清空字典
print(dict1)
del dict1 #del 删除字典程序运行结果：
{'b': '爱', 'c': '你', 'd': '哦'}
{'b': '爱', 'c': '你'}
{}6.3 删除集合元素
set1 = {1, 2, 3, 4}
set1.remove(4) #remove()删除指定元素
print(set1)
set1.clear() #清空集合
print(set1)
del set1 #del 删除集合程序运行结果：
{1, 2, 3}
set()7.其他
7.1 复制
上面说到（ ：）可以用来进行列表的分片，而（ ：）还有一个功能就是复制，例如：
x1 = [1,3,2,5,7]
x2 = x1[:]
print(x2)
x1.sort() #复制出来的x2是独立的，不会因x1的变化而变化
print(x2)程序运行结果：
[1, 3, 2, 5, 7]
[1, 3, 2, 5, 7]7.2 sorted()
上面有提到sort是排序 ，那么sorted也差不多是这个意思，不同的是sorted返回的是一个完成排序的新列表，对原表并不影响
x = [1,3,2,5,7]
y = sorted(x)
print(y)
print('原表:', x)程序运行结果：
[1, 2, 3, 5, 7]
原表: [1, 3, 2, 5, 7]当列表由多字段组成时，想要对字段指定元素进行排序，就要用到keys=lambda 元素：元素[索引]。字典也适用
#把list按字段第一个元素从小到大排序
list = [("A", 70), ("C", 85), ("E", 90), ("B", 66), ("G", 82), ("F", 77), ("D",54)]
list1 = sorted(list, key=lambda x : x[0]) #这里的x可以是任何字母
print(list1)
dict = {"A": 70, "C": 85, "E": 90, "B": 66, "G": 82, "F": 77, "D": 54}
#把test按键从小到大排序
dict1 = sorted(dict.items(), key=lambda item:item[0])
print(dict1)
#把test按值从大到小排列
dict2 = sorted(dict.items(), key=lambda item: item[1], reverse=True)
print(dict2)
程序运行结果：
[('A', 70), ('B', 66), ('C', 85), ('D', 54), ('E', 90), ('F', 77), ('G', 82)]
[('A', 70), ('B', 66), ('C', 85), ('D', 54), ('E', 90), ('F', 77), ('G', 82)]
[('E', 90), ('C', 85), ('G', 82), ('F', 77), ('A', 70), ('B', 66), ('D', 54)]7.3 sum()
这个很+简单，就是算出序列的总和
x = [1,2,3,4]
print(sum(x))程序运行结果：
107.4 reversed()
reverse()是翻转列表，那么reversed()也八九不离十，要注意的是reversed()返回的是迭代器对象，，什么意思呢，看个栗子就知道啦
x = [1,2,3,4]
print(reversed(x))
#通过for循环迭代，就返回逆向迭代序列的值啦
for each in reversed(x):
print(each, end=' ')程序运行结果：
<list_reverseiterator object at 0x0000015F356202E0>
4 3 2 1 7.5 enumerate() 生成二元组
x = 'abc'
for each in enumerate(x):
print(each)程序运行结果：
(0, 'a')
(1, 'b')
(2, 'c')7.6 zip()
zip()用来返回由可迭代参数组成的元组
x = 'abc'
y = [1, 2, 3]
z = (11, 22, 33)
for each in zip(x, y, z):
print(each)程序运行结果：
('a', 1, 11)
('b', 2, 22)
('c', 3, 33)7.7 字典排序
test = {"A": 70, "C": 85, "E": 90, "B": 66, "G": 82, "F": 77, "D": 54}
#把test按键从小到大排序
test1 = sorted(test.items(), key=lambda item: item[0])
print(test1)
#把test按值从小到大排列
test2 = sorted(test.items(), key=lambda item: item[1])
print(test2)程序运行结果：
[('A', 70), ('B', 66), ('C', 85), ('D', 54), ('E', 90), ('F', 77), ('G', 82)]
[('D', 54), ('B', 66), ('A', 70), ('F', 77), ('G', 82), ('C', 85), ('E', 90)]那么关于列表元组字典集合的总结就暂时写到这里，后续如果想到遗漏部分会补充，文案代码如果有错误也希望大家指正~掰掰！
736
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
