代码收藏家 Python学习：深入理解组合数据类型
一、组合数据类型的基本概念
①集合类型：集合（set）是一个元素集合，元素之间无序，相同元素在集合中唯一存在。
②序列类型：序列类型的典型代表是字符串（str）、列表（list）、元组（tuple），是一个元素向量，元素之间有先后关系，通过序号访问，元素之间不排他。
③映射类型：典型代表是字典（dict），是“键-值”数据项的组合，每个元素是一个键值对，表示为（key，value）。
二、集合类型
Python中的集合和数学中的集合概念一致，包含0个或多个数据项的无序组合。用大括号{}表示，没有索引和位置的概念，集合中的元素可以动态增加或删除。
由于集合元素独一无二，可以使用集合删除重复元素
a={'www',223,223.6,'www'}
print(type(a))
print(a)
--输出
<class 'set'>
{223.6, 'www', 223}//重复元素www被删除，并且无序排列
集合有4个操作符，交集&，并集|，差集-，补集^
示例
s={1010,'python',78.9}
t={1010,'set',12.3,1010,1010}
print(s-t)
print(s&t)
print(s^t)
print(s|t)
--输出
{'python', 78.9}//差集
{1010}//交集
{12.3, 78.9, 'set', 'python'}//补集
{1010, 'set', 'python', 12.3, 78.9}//并集
集合类型有一些常用的操作函数或方法
注：set()函数可以将其他组合数据类型变成集合类型，返回结果是一个无重复且排序任意的集合。set()函数也可以生产空集合变量。示例
s={1010,'python',78.9}
print(s)
s.add('AI')
print(s)
s.remove(1010)
print(s)
s.clear()
print(s)
print(len(s))
print(1010 in s)
print(1010 not in s)
--输出
{1010, 78.9, 'python'}//s集合
{'AI', 1010, 78.9, 'python'}//增加'AI'元素
{'AI', 78.9, 'python'}//删除1010元素
set()//执行clear后，s集合变为空集合
0//空集合长度为空
False//1010不在s中，返回false
True//1010不在s中，返回True
//set()函数示例
a=set()
s='知之为知之，不知为不知'
a=set(s)
print(a)
--输出
{'知', '，', '为', '之', '不'}
三、列表类型
列表类型用中括号[]表示，列表没有长度限制，元素类型可以不同。通过list(x)函数将集合或字符串类型转换为列表类型。
列表类型属于序列类型，所以列表类型支持序列类型对应的操作。
s=[1010,'python',78.9,1010]
print(s,type(s))
--输出
[1010, 'python', 78.9, 1010] <class 'list'>//列表不会删除重复元素，并且有序
注：序列类型的操作符和函数
索引是列表的基本操作，用于获得列表的一个元素。使用中括号作为索引操作符。
s=[1010,'python',78.9,1010,[22,'33']]
print(s[4])
--输出
[22, '33']
还可以使用遍历循环对列表类型的元素进行遍历操作：
s=[1010,'python',78.9,1010,[22,'33']]
for i in s:
print(i*2)
--输出
2020
pythonpython
157.8
2020
[22, '33', 22, '33']
列表切片和字符串切片是基本一致的，用于获得列表的一个片段，即获得一个或多个元素。切片后的结果也是列表类型。
s=[1010,'python',78.9,1010,[22,'33']]
print(s[1:3])
print(s[0:4:2])
--输出
['python', 78.9]
[1010, 78.9]
四、列表类型的操作
ls.append(x)仅用于在列表中增加一个元素，如果希望增加多个元素，可以使用+直接将两个列表合并。
s=[1,2,3,4,5,6,7]
s.append(8)
print(s)
t=[9,10,11,12]
print(s+t)
--输出
[1, 2, 3, 4, 5, 6, 7, 8]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
//insert(i,x)函数用于在列表中第i个位置增加一个元素。
s=[1,2,3,4,5,6,7]
s.insert(4,10)
print(s)
--输出
[1, 2, 3, 4, 10, 5, 6, 7]
//pop(i)函数用于将列表中第i个元素取出并删除
s=[1,2,3,4,5,6,7]
s.pop(4)
print(s)
--输出
[1, 2, 3, 4, 6, 7]
//remove(x)函数用于将列表中出现的第一个x元素删除
s=[1,2,3,4,5,6,7,5]
s.remove(5)
print(s)
--输出
[1, 2, 3, 4, 6, 7, 5]
//reverse()函数用于将元素顺序翻转
s=[1,2,3,4,5,6,7]
s.reverse()
print(s)
--输出
[7, 6, 5, 4, 3, 2, 1]
可以使用Python保留字del对列表元素或片段进行删除：
示例
s=[1,2,3,4,5,6,7]
del s[1:3]
print(s)
--输出
[1, 4, 5, 6, 7]
直接使用=进行复制的话，当原列表被删除，则新列表也为空，因此需要使用copy函数生成一个新列表，复制ls中所有元素。
//使用=复制
//示例一
s=[1,2,3,4,5,6,7]
t=s
s.clear()
print(t)
--输出
[]//当s被删除，则t也为空
//示例二
s=[1,2,3,4,5,6,7]
t=s
s.pop(2)
print(t)
--输出
[1, 2, 4, 5, 6, 7]//当s被删除某个元素，则t也被删除
//使用copy函数复制
s=[1,2,3,4,5,6,7]
t=s.copy()
s.clear()
print(t)
--输出
[1, 2, 3, 4, 5, 6, 7]//当s被删除，t依旧存在
原因是当计算机保存列表时，保存的是地址，当使用=进行复制时，只是复制了计算机保存旧列表的地址，而不是复制的旧列表值。因此若对旧列表有操作，会影响新列表的值
使用索引配合等号=对列表元素进行修改
s=[1,2,3,4,5,6,7]
s[2]='三'
print(s)
--输出
[1, 2, '三', 4, 5, 6, 7]
四、元组类型
Python的元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组使用小括号()，列表使用方括号[]。
因为元组的元素无法修改，其方法只有count()和index()两种，因此，元组适合保存保密要求较高的数据。
s.count(x)函数可用于查询s元组中包含x元素的个数。
s.index(x)函数可用于查询s元组中x元素的第一个位置。
tuple()函数可以将其他数据类型转为元组。
元组元素的定位及切片也是通过[m:n[:step]]进行的
五、字典类型
Python语言中的 字典使用大括号{}建立，每个元素是一个键值对。键和值通过冒号连接，不同键值对通过逗号隔开。
大括号同时可以表示集合，因此字典类型也具有和集合类似的性质，即键值对之间没有顺序且不能重复。
s= {1:'A',2:'B',3:'C',4:'D',2:'E'}
print(s,type(s))
t= {1:'A',2:'B',3:'C',4:'D',5:'B'}
print(t,type(t))
--输出
{1: 'A', 2: 'E', 3: 'C', 4: 'D'} <class 'dict'>//键重复，删除
{1: 'A', 2: 'B', 3: 'C', 4: 'D', 5: 'B'} <class 'dict'>//值重复，保留
赋值方式
可以通过d={}的方式，或者dict()的方式定义一个空字典（空集合则只能以set()的方式定义）。
可以通过d[键]=‘值’的方式直接赋值键值对，或者修改某个键的值。
操作函数
示例
d= {1:'A',2:'B',3:'C',4:'D',5:'E'}
s=dict()
print(len(d))
print(min(d))
print(max(d))
print(s,type(s))
--输出
5
1
5
{} <class 'dict'>
①d.key()返回字典中所有键信息。返回结果是Python的一种内部数据类型dict_keys，专用于表示字典的键。如果希望更好的使用返回结果，可以将其转为列表类型。
②d.values()返回字典中的所有值信息。返回结果是Python的一种内部数据类型dict_values，如果希望更好的使用返回结果，可以将其转为列表类型。
③d.itmes()返回字典中的所有键值对信息。返回结果是Python的一种内部数据类型dict_items。可以将其转为列表类型，但列表中每个元素是一个元组，不可修改。
d= {1:'A',2:'B',3:'C',4:'D',5:'E'}
print(d.keys())
print(list(d.keys()))
print(d.values())
print(list(d.values()))
print(d.items())
print(list(d.items()))
--输出
dict_keys([1, 2, 3, 4, 5])
[1, 2, 3, 4, 5]//将键转为列表
dict_values(['A', 'B', 'C', 'D', 'E'])
['A', 'B', 'C', 'D', 'E']//将值转为列表
dict_items([(1, 'A'), (2, 'B'), (3, 'C'), (4, 'D'), (5, 'E')])
[(1, 'A'), (2, 'B'), (3, 'C'), (4, 'D'), (5, 'E')]//将键值对转为列表，每个元素为元组()
④d.get(key,default)根据键信息查找并返回值信息。如果key存在则返回相应值，否则返回默认值，第二个元素默认值default可以省略为空。
⑤d.popt(key,default)根据键信息查找并取出值信息。如果key存在则返回相应值，否则返回默认值，第二个元素默认值default可以省略为空。pop()在取出相应值后，将从字典中删除对应的键值对。
d= {1:'A',2:'B',3:'C',4:'D',5:'E'}
print(d.get(2))
print(d.get(6,'不存在'))
print(d.pop(2))
print(d)
--输出
B
不存在//不存在6键值，返回默认值‘不存在’
B
{1: 'A', 3: 'C', 4: 'D', 5: 'E'}//2键值对已被pop删除
⑥d.popitem()将随机从字典中取出一个键值对，以元组(key,value)形式返回。取出后从字典中删除这个键值对。
d= {1:'A',2:'B',3:'C',4:'D',5:'E'}
print(d.popitem())
print(d)
--输出
(5, 'E')
{1: 'A', 2: 'B', 3: 'C', 4: 'D'}
⑦d.clear()删除字典中所有键值对。如果希望删除字典中某一个元素，可以使用Python保留字del。
d= {1:'A',2:'B',3:'C',4:'D',5:'E'}
del d[1]
print(d)
d.clear()
print(d)
--输出
{2: 'B', 3: 'C', 4: 'D', 5: 'E'}
{}
⑧ 字典也支持保留字in，用来判断一个键是否存在字典中。如果在则返回True，否则返回False
for循环返回的变量名是字典的索引值（int型）。如果需要获得键对应的值，可以使用get()，或者使用[]直接取值。
d= {1:'A',2:'B',3:'C',4:'D',5:'E'}
for i in d:
print('字典的键为{}，值为{}'.format(i,d[i]))#也可写作d.get(i)
# 输出
字典的键为1，值为A
字典的键为2，值为B
字典的键为3，值为C
字典的键为4，值为D
字典的键为5，值为E
