python的列表和字典 手写笔记差点意思，电视剧追完了怎么办？

最近看了的相关理论，总觉得看一章写一页的手写笔记差点意思，今天刚好把该追的电视剧追完了，就来写个总结吧！作为我CSDN的开端~

目录

1.简单介绍 1.1 列表（list）：

存储不同类型的数据，就像一个杂货铺，啥都可以有。数据用“ [ ] ” 装起来。

1.2 元组（tuple）：

就像小甲鱼（我的参考书作者）说的，元组是一个上了枷锁的列表，它和列表的最大区别就是：它不可改变！元组的灵魂是' , ' 没有逗号会被判断为 int 。

煮个栗子~~

x = (1,)
print('x是', type(x))  #判断x的类型
y = (1)
print('y是', type(y))  #判断y的类型
z = 1,
print('z是', type(z))  #判断z的类型

程序运行结果：（可以看到只要有逗号在python的列表和字典，系统就会判断其为元组）

x是 
y是 
z是 

列表和元组的异同点总结：

同： 1.都属于迭代对象，支持索引和分片操作

2.都支持重复运算（ * ）和合并运算（ +）

3.都支持len() , max() , min()等系统内置函数

4.列表和元组都可以相互转化（ tuple() / list() ）

异：元组不可进行修改python的列表和字典 手写笔记差点意思，电视剧追完了怎么办？，所以列表的添加、修改、删除元素的方法都不能用在元组上。但是可以 用del删除整个元组。

从上面几点来看，列表好像比元组实用多了，但是存在即合理，元组的特性决定了它拥有比列表更快的速度，比列表更安全，更容易维护。

1.3 字典（dict ）：

的字典就相当于数学的映射，区别于序列（上述的列表和元组都属于学序列）用索引获取对应值，字典使用的是key：valuepython的列表和字典，即一个键和对应值为一项。

字典不讲顺序，只讲映射，其标志性符号为“{ } ”。要注意一点，字典的键必须唯一python的列表和字典 手写笔记差点意思，电视剧追完了怎么办？，但其值可以取任何不可变的数据类型（字符串、元组、数等）。

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 
    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
3

3.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 3

4.添加 4.1 列表添加元素

用到的是() 、() 、()函数

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 元组添加元素

之前说过元组是不可改变的python的列表和字典，如果一定要改变，就只能通过拷贝元组的片段，构造一个新的元组

temp = (1,2,3,4)
new_temp = temp[:1] + ('xx',) + temp[1:]  #相当于在原元组中的第二个位置插入'xx'
print(new_temp)

程序运行结果：

(1, 'xx', 2, 3, 4)

4.3 字典添加元素

用到的是()函数

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()和()

set1 = {'我', '是'}
set1.add('大聪明')
print(set1)
x = [1,2,3]
set1.update(x)  #update()可用来添加可迭代对象
print(set1)

程序运行结果：

{'是', '我', '大聪明'}
{1, 2, 3, '我', '是', '大聪明'}

集合的运算 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 修改字典

用到的是()函数，在上面字典添加中提到的()函数也能起到修改函数的作用，在这里就不重复讲了

dict1 = {'a':'我', 'b':'爱', 'c':'你', 'd':'哦'} 
dict1.update(a='他')
print(dict1)

程序运行结果：

{'a': '他', 'b': '爱', 'c': '你', 'd': '哦'}

6.删除

主要是del、()和pop()两个方法，del删除整个序列，()删除指定元素，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 ()

上面有提到sort是排序，那么也差不多是这个意思，不同的是返回的是一个完成排序的新列表，对原表并不影响

x = [1,3,2,5,7]
y = sorted(x)
print(y)
print('原表:', x)

程序运行结果：

[1, 2, 3, 5, 7]
原表: [1, 3, 2, 5, 7]

当列表由多字段组成时，想要对字段指定元素进行排序，就要用到keys= 元素：元素[索引]。字典也适用

#把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))

程序运行结果：

10

7.4 ()

()是翻转列表，那么()也八九不离十，要注意的是()返回的是迭代器对象，，什么意思呢，看个栗子就知道啦

x = [1,2,3,4]
print(reversed(x))
#通过for循环迭代，就返回逆向迭代序列的值啦
for each in reversed(x):  
    print(each, end=' ')

程序运行结果：

4 3 2 1 

7.5 () 生成二元组

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)]

那么关于列表元组字典集合的总结就暂时写到这里，后续如果想到遗漏部分会补充，文案代码如果有错误也希望大家指正~掰掰！