组合数据类型小总结

组合数据类型可以分为四个类型：列表List、元组Tuple、集合Set和字典Dict。
他们之间可以互相转换，既有共同点又有不同点。
列表List ：通过一对方括号包含起来的一组数据，按照有顺序的方式存储多个、可重复的、可修改的数据。
元组Tuple ：通过一对圆括号包含起来的一组数据，按照有顺序的方式存储多个、可重复的、不能修改的数据。
【注意】元组中如果存放的是其他的内容可变的元素的话，一定要注意此时的元组中对象的数据是可变的。
集合Set ：使用一对大括号/花括号包含起来的一组数据，可存放无顺序的、不可重复的、多个、可修改的数据。
字典Dict ：可存放多组Key-value键值对的键不能重复、值可以重复的数据对。

下面具体介绍各个类型的使用方法及注意事项：

1.列表 List

类型：list
特点：按照有顺序的方式存储多个、可重复的、可修改的数据。
声明：
声明空列表：
U1=list() 【推荐】
U2=[]
声明非空列表：
U3=list([1,2,3,4])
U4=[1,2,3,4] 【推荐】

数据操作：
设一个列表x=[1,2,3,4,5,6,7,8,9,0]
1）增加数据
append(obj)：在列表的末尾增加一个数据
extend(seq)：在列表的末尾增加一组数据
insert(index,obj)：在指定位置增加一个数据
如：
x.append(10):在列表的末尾增加一个数据10
x.extend([11,12]):在列表的末尾增加一组数据[11,12]
x.insert(2，13)：在索引号为2的位置增加一个数据13
2）删除数据
del x[index]:根据百年好/下标/索引删除数据
index必须是列表长度范围内的编号~下标越界错误Index out…
del x ：删除列表x
pop()：删除列表末尾的一个数据
pop(index)：删除列表中指定的一个数据
clear()：清空列表中的所有数据
remove(obj)：删除一个具体的数据
3）修改数据
X[index]=new value 通过下标/编号直接给当前编号的数据重新复制
4）查询数据
X[index]通过编号直接查询该编号位置的数据
For x1 in x:
Print(x1) 将x列表中的数据依次存放到x1中并且展示出来
For i,x1 in enumerate(x)：
Print(“编号”,i,”数据”,x) 将x列表中的数据依次存放到x1中,与编号一起被展示出来
5）扩展功能
x.Copy() 复制一个有相同数据的列表
x.count(obj) 查询某个数据在列表上出现的次数
x.index(obj) 查询某个具体数据在列表的数据
x.sort() 将列表中的数据按照自然顺序排序
x.reverse() 翻转列表
len(x) 查看列表的长度；查看列表中是否有数据
max(x)/min(x) 针对列表中的数据进行最大值/最小值的判断

2.元组Tuple

类型：tuple
特点：按照有顺序的方式存储多个、可重复的、不能修改的数据。
声明：
声明空元组：
t=tuple()
声明非空元组：
包含单个元素的元组
t=(“hello”,) 【注意】一定要加英文状态下的逗号
t=tuple([“hello”]) 【不推荐】
包含多个元素的元组
t=(“hello”,”world”) 【推荐】
t=”hello”,”world”
t=tuple([“hello”,”world”]) 【不推荐】
【注意】t=(“hello”)不是一个元组，括号被当成了运算符号，为赋值。
类型转换：
Tuple(obj) 将括号中包含的数据，转换成元组

数据操作：
【注意】元组具有特殊性，只能查询
dir(tuple)：查看元组都有哪些操作
count：查看某个指定的数据，在元组中出现的次数
index：查看某个指定的数据在元组中的位置
len(x)：查看元组中元素的个数/总数
max(x)/min(x)：查看最大/最小值

3.集合Set

类型：set
特点：可存放无顺序的、不可重复的、多个、可修改的数据
声明：
声明空集合：
s=set()
声明非空集合：
s={1,2,3,4} 【推荐】
s=set([1,2,3,4])

数据操作：增加、删除、修改、查询
1）增加数据
s.add(obj) ：在集合中增加一个数据
2）删除数据
s.remove(obj)：在集合中删除一个指定数据
s.pop()：随机删除一个数据
s.clear()：清空集合中的数据
del s ：删除集合
【注意】集合中的数据是无序存放的，没有下标，不能在指定位置 增加/删除 具体数据
3）修改数据
流程：查询列表中是否存在此数据存在修改数据的值（先删除要替代的数据，再把替代的数据添加到集合中）
如：将”hello”修改为”world” (即用”world”替代”hello”)
If ‘hello’ in s:
s.remove(‘hello’) #删除一个具体数据
s.add(‘world’) #添加一个数据
print(s)
引申：运算符之成员运算符：判断一个数据是否包含在组合数据类型中
Print(‘hello’ in s)
Print(‘world’ in s)
4）查询数据
只有循环遍历
For x in s:
Print(‘-------for------->’,x)
5)其他功能
S1={1,2,3,4,5,6,7}
S2={5,6,7,8,9,0,10}
并集：
S1.union(s2)
#更新操作
S1.update(s2)
差集：
S1.difference(s2)
#更新操作
S1.difference_update(s2)
交集：
S1.intersection(s2)
#更新操作
S1.intersection_update(s2)

4.字典Dict

类型：Dict
特点：可存放多组Key-value键值对的键不能重复、值可以重复的数据对。
声明：
声明空字典：
d=dict() 【推荐】
d={}
声明非空字典：
d={‘key’:’value’,’key2’:’value2’} 【推荐】
Key对应数据value
Key2对应数据value2
d=dict([(‘k1’,’v1’),(‘k2’,’v2’)]) 相当于 d={‘k1’:’v1’,’k2’:’v2’}
字典：在某些场合也称为映射，体现的是一一对应的关系，通过字典中的key值来获取对应的value值。
可类比列表：字典中的key值相当于列表中的编号
Users列表 users[0]表示了一个用户
Users[0][1]表示了用户的密码
Users字典 users[‘admin’]表示了一个账号为admin的用户
Users[‘admin’][‘password’]表示该用户的密码

数据操作：
1）增加数据
Key和value都是基本数据类型，都是字符串
d[‘key’]=’value’
Print(d)
Key是一个字符串，value是一个列表
d[‘admin’]=[‘admin’,’123’]
Print(d)
Key是一个字符串，value是一个字典
d[‘manager’]={‘username’:’manager’,’password’:’123’}
Print(d)
setdefault ：如果admin已经在字典中存在，下面的这行代码什么都不做
d.setdefault(‘admin’, ‘Administrator’)
print(d)
setdefault ：如果设置的key值在字典中不存在的~ 新增数据
d.setdefault(‘root’, ‘123456’)
print(d)
2）删除数据
删除一个指定key值的键值对数据
d.pop(‘admin’)
print(d)
随机删除一个
print(d.popitem())
print(d)
清空字典
d.clear()
print(d)
3）修改数据
d[‘admin’] = ‘admin’
print(d)

d[‘manager’][‘password’] = ‘***’
print(d)
拓展：成员运算符
print(‘manager’ in d) 判断指定的数据是否包含在字典的key中
print(‘administrator’ in d) 判断指定的数据是否包含在字典的key中
4）查询数据
通过key直接查询对应的value值
print(d[‘admin’])
print(d.get(‘manager’))
循环遍历 key值
for x in d:
print("---------->", x, ‘:’, d.get(x))
查询字典中的key值
print(d.keys())
查询字典中所有的value值
print(d.values())
查询字典中的所有item[条目、键值对]值
print(d.items())
循环遍历keys()
for x in d.keys():
print(x, ‘----’, d.get(x))
循环遍历 键值对
for k, v in d.items():
print(k, ‘—items()–’, v)

总结：
元组Tuple是存放固定的数据
集合Set中的数据插入和遍历的时间，随数据增多而变慢
列表List中的数据插入和遍历的时间，随数据增多而变慢
字典Dict中的数据插入和查询的速度非常快，不会因为数据太多而变慢

元组、集合和列表占用内存较少；
字典占用内存较多，是一种通过占用空间来换取操作速度的一种数据类型