python列表、集合、元组、字典

Python 编程语言中有四种集合数据类型：

• 列表（list）是一种有序和可更改的集合。允许重复的成员。
• 元组（tuple）是一种有序且不可更改的集合。允许重复的成员。
• 集合（set）是一个无序和无索引的集合。没有重复的成员。
• 字典（dict）是一个无序，可变和有索引的集合。没有重复的成员。

列表

列表在需要同时处理多个数据的时候非常有用。在python中，列表用一对英文方括号括起来，里面可以存放各种类型的数据。它有以下几种特点：

1. 列表是容器型数据类型，将[]作为容器的标志，里面多个元素用逗号隔开：[数据1, 数据2, 数据3,…]
2. 列表是可变的(可变指的是容器中元素的个数和值可变 - 支持增删改)
3. 列表是有序的，支持下标操作
4. 列表对元素没有要求（任何类型的数据都可以作为列表的元素，同一个列表中的元素的类型还可以不一样）

下标又叫索引，是元素在列表中的位置信息。

列表中的每个元素都有两个索引值，一个是从往后从0(第1个)开始不断增加，另一个是从后往前从-1(倒数第1个)开始不断减小。

注意：下标不能越界

语法：

列表[开始下标:结束下标:步长]		-	根据下标和步长获取指定列表中的部分元素
for i in 列表					-	i为元素
for i in range(len(列表))		-	i为下标
for i, j in enumerate(列表) 	-	同时获取下标和元素
列表.append(元素)  				-   在列表的最后添加指定元素
列表.insert(下标,数据) 		    -   在列表指定下标对应元素前插入指定数据
del 列表[下标]    			    -   删除列表中指定下标对应的元素
列表.remove(元素)     		    -   删除列表中指定元素(如果元素不存在会报错；
									如果元素有多个，只会删除最前面的那一个)
列表.pop()   				    -   取出列表最后一个元素，并且返回
列表.pop(下标)       		    -   取出列表指定下标对应的元素，并且返回
列表[下标] = 新元素   		    -   修改列表中指定下标对应的元素为新的元素
列表1 + 列表2    				-   将连个列表中的元素依次合并成一个新的列表
列表 * N 
N * 列表   			     		-   列表中元素重复N遍产生一个新的列表
元素 in 列表    	  			    -   判断列表中是否存在指定元素
元素 not in 列表 		        -   判断列表中是否不存在指定的元素

>>> games = ['王者荣耀', 'lol', '和平精英', '永劫无间', 'apex', '2k', '植物大战僵尸', '开心消消乐']
>>> for index, item in enumerate(games):
...     print(index, item)
...
0 王者荣耀
1 lol
2 和平精英
3 永劫无间
4 apex
5 2k
6 植物大战僵尸
7 开心消消乐

>>> l_mem = []
>>> l = l_mem
>>> for i in range(2):
...     l.append(i * i)
...
>>> l
[0, 1]
>>> l = [3, 2, 1]
>>> for i in range(3):
...     l.append(i * i)
...
>>> l
[3, 2, 1, 0, 1, 4]
>>> l = l_mem
>>> for i in range(3):
...     l.append(i * i)
...
>>> l
[0, 1, 0, 1, 4]

---

元组

元组是有序且不可更改的集合。在 Python 中，元组是用圆括号编写的。它有以下几种特点(与列表对比)：

1. 元组的元素不能被修改
2. 元组使用[]
3. 元组属于不可变类型
4. python内部对元组进行了大量的优化，访问和处理速度比列表快

语法：

当只有一个元素时，后面要加个逗号，例如： tup1 = (50,)

访问
通过下标索引访问元组的值

更改
1. 将元组转换为列表，更改列表，然后将列表转换回元组
	list()	-> 	tuple()
2. 对元组进行连接组合，使用 +
	tup1 + tup2

删除
del 		-	删除整个元组

相关函数
count()		-	返回元组中指定值出现的次数
index()		-	在元组中搜索指定的值并返回它被找到的位置

>>> t1 = ('aa', 'bb', 'cc', 'bb')
>>> t1[0]
'aa'
>>> t1[0] = 'aaa'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> t1.index('aa')
0
>>> t1.index('aaa')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple
>>> t1.count('aa')
1
>>> t1.count('aaa')
0
>>> len(t1)
4

>>> t2 = ('aa', 'bb', ['cc', 'dd'])
>>> t2[2][0]
'cc'
>>> t2[2][0] = 'Tom'
>>> t2
('aa', 'bb', ['Tom', 'dd'])

注意：元组内的列表数据支持修改

---

集合

集合是一个无序的不重复元素序列。可以使用大括号 { } 或者 set() 函数创建集合。它有以下几种特点：

1. 不保证内部元素的有序性，没有重复元素。可以进行并集、差集、交集的操作。
2. 集合有无序性，无法知道一个元素在集合中的具体位置，也无法对集合进行切片操作。
   语法：

更改
集合一旦创建，就无法更改

添加项目
add()		- 	添加一个元素
update()	-	添加多个元素

删除
remove()	-	如果要删除的元素不存在，则报错
discard() 	- 	如果要删除的元素不存在，不报错
pop()  		-	删除最后一项
clear()  	-	清空集合
del 		-	彻底删除集合

合并
set1.union(set2)
set1.update(set2)
两者的区别：
	 a.union(b)		-	取a和b的并集，返回值是一个新集合
	 a.update(b)	-	将b加到了a中，改变了a，没有返回值 	

'''
集合的交集
>>> set1 = {"jack","tom","haha"}
>>> set2 = {"jack","susala"}
>>> set3= set1 & set2
>>> set3
{'jack'}

并集
>>> set_1 = {1, 2, 3, 4, 5}
>>> ser_2 = {6, 7, 8, 9, 0}
>>> set_0 = set_1 | ser_2
>>> set_0
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
'''
>>> set_1 = {1, 2}
>>> set_2 = {'hello', 'world'}
>>> set_1.union(set_2)
{1, 2, 'world', 'hello'}

>>> set_1 = {1, 2, 3}
>>> set_2 = {'hello', 'world', 3}
>>> set_1.update(set_2)
>>> set_2
{3, 'world', 'hello'}
>>> set_1
{1, 2, 3, 'hello', 'world'}

>>> set_4
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
>>> set_4.remove(10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 10
>>> set_4.discard(10)
>>> set_4.pop()
0
>>> set_4.clear()
>>> set_4
set()
>>> del set_4
>>> set_4
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'set_4' is not defined

要向集合中添加多个项目，请使用 update() 方法。

---

字典

字典是一个无序、可变和有索引的集合。在 Python 中,字典用花括号编写,拥有键和值。它有以下几种特点：

1. 字典是容器型数据类型，将{}作为容器的标志，里面多个键值对用逗号隔开：{键1:值1, 键2:值2, 键3:值3,…}
2. 字典是可变的(支持增删改)
3. 字典是无序的，不支持下标操作
4. 元素的要求：字典的元素是键值对
   键的要求：
   a.键必须是不可变类型的数据(一般使用字符串)
   b.键是唯一的
   值的要求：没有要求

语法：

查询
字典[键]    		   	   -   获取字典中指定键对应的值, 如果键不存在会报错
字典.get(键)    		   -   获取字典中指定键对应的值；如果键不存在不会报错，并且返回None
字典.get(键, 默认值)    -   获取字典中指定键对应的值；如果键不存在不会报错，并且返回默认值

遍历
for 键 in 字典 				- 	变量获取的到是键
for 键,值 in 字典.items() 	- 	变量同时获取键和值

修改
字典[键] = 新值   -   将字典中指定键对应的值修改成指定的新值

增加
字典[键] = 值   			 -   如果键不存在，就在字典中添加键值对; 如果键存在会修改键值对的值
字典.setdefault(键, 值)   -   在字典中添加指定的键值对；如果键存在会保留原来的值(不会修改)

删除
del 字典[键]    -   删除字典中指定键对应的键值对
字典.pop(键)    -   取出字典中指定键对应的值

判断
in 和 not in    -   判断字典中是否存在或者不存在指定的键

相关函数
len(字典)      -   获取字典中键值对的数量
dict(数据)     -   将指定的数据转换成字典
字典.clear()   -   清空字典
字典.copy()    -   复制字典产生一个一模一样的新字典
字典.keys()    -   获取字典所有的键，返回一个序列
字典.values()  -   获取字典所有的值，返回一个序列
字典.items()   -   将字典转换成一个序列，并且将每一个键值对转换成一个元组
d1.update(d2)  -   将字典d2中所有的键值对都添加到字典d1

'''
将字典中值是 None 的 key:value 删掉
'''
>>> d1 = {
...     "a": None,
...     "b": 123,
...     "c": 1234,
...     "d": {
...         "e": 123,
...         "f": None,
...         "h": {
...             "test": 123,
...             "null": None
...         }
...     }
... }
>>> d1
{'a': None, 'b': 123, 'c': 1234, 'd': {'e': 123, 'f': None, 'h': {'test': 123, 'null': None}}}
>>> def del_key(d1: dict, new_dict=None) -> dict:
...     if new_dict is None:
...         new_dict = {}
...     for key, value in d1.items():
...         if isinstance(value, dict):
...             new_dict[key] = {}
...             del_key(value, new_dict[key])
...         elif value:
...             new_dict[key] = value
...     return new_dict
...
>>> del_key(d1, None)
{'b': 123, 'c': 1234, 'd': {'e': 123, 'h': {'test': 123}}}