Python的组合数据类型有四种，分别是：列表(list)、元组(tuple)、集合(set)、字典(dict)
这里就简单介绍一下
列表（list）
什么是列表
列表是python中可以存储多个数据的数据类型。
列表的声明
变量=list（)
变量=[ ]
这两种都可以声明一个空的列表
>>> s=list()
>>> type(s)
<class 'list'>
>>>jobs=[]
>>> type(jobs)
<class 'list'>
list的操作：
- 增加数据
- list.append() 默认在list末尾添加一个数据
- list.insert() 插入，可指定位置
- list.extend() 在末尾添加，可追加多个数据，也可以实现两个列表的组合
- 删除数据
- del list[index] 直接删除
- list.clear() 清空所有数据
- 修改数据
- list[index]=数据
- 查询
- 通过index（下标）查询
- 其它操作
- list.copy() 列表的拷贝，结果是一个列表
- list.count() 统计元素出现的次数
- list.index() 查看元素的下标/索引
- list.reverse 反转
- list.sort 按自然数排列，只能排列纯数字或者纯字符的列表，不能排列各种数据类型混合的列表
g1=[1000,'可口可乐（罐装）',2.5,100]
>>> print(g1)
[1000, '可口可乐（罐装）', 2.5, 100]
>>> g1.append("密封") #添加一个数据，在最后添加
>>> print(g1)
[1000, '可口可乐（罐装）', 2.5, 100, '密封']
>>> g1.insert(1,'美国') #指定位置的添加
>>> print(g1)
[1000, '美国', '可口可乐（罐装）', 2.5, 100, '密封']
>>> g2=[1001,'可口可乐（瓶装）',3.0,100]
>>> g1.append(g2) #把g2当做有个数据添加到最后
>>> g1
[1000, '美国', '可口可乐（罐装）', 2.5, 100, '密封', [1001, '可口可乐（瓶装）', 3.0, 100]]
>>> g1.extend(g2) #添加多个数据
>>> g1
[1000, '美国', '可口可乐（罐装）', 2.5, 100, '密封', [1001, '可口可乐（瓶装）', 3.0, 100], 1001, '可口可乐（瓶装）', 3.0, 100]
>>> del g1[6] #删除指定的数据
>>> g1
[1000, '美国', '可口可乐（罐装）', 2.5, 100, '密封', 1001, '可口可乐（瓶装）', 3.0, 100]
g1[0]=1
>>> g1
[g1[2]
'可口可乐（罐装）'
>>> g3=g1.copy() #拷贝
>>> g3
[1, '美国', '可口可乐（罐装）', 2.5, 100, '密封', 1001, '可口可乐（瓶装）', 3.0, 100]1, '美国', '可口可乐（罐装）', 2.5, 100, '密封', 1001, '可口可乐（瓶装）', 3.0, 100]
g1.count(2.5) #统计一个元素出现的次数
1
>>> g1.reverse() #翻转列表
>>> g1
[100, 3.0, '可口可乐（瓶装）', 1001, '密封', 100, 2.5, '可口可乐（罐装）', '美国', 1]
元组
什么是元组
Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组的声明
元组使用小括号，元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可
t=tuple()
t1=()
t2=(1,2,3,4,)
但是t3=('hello') ->type(t3)->str
可以t4=('hello',) 在后面加一个逗号
元组的方法：count，index
元组中的操作类型只有这两个方法
>>> t=tuple()
>>> type(t)
<class 'tuple'>
>>> t1=()
>>> type(t1)
<class 'tuple'>
>>> t3=('hello')
>>> type(t3)
<class 'str'>
>>> t4=("hello",)
>>> type(t4)
<class 'tuple'>
其中tuple.count() 是统计一个元素出现的次数
tuple.index() 是查看一个元素在元组中的下标
集合
什么是集合
需求场景：我们需要存放一组数据，但是不希望存放重复的数据！用户的账号！
集合：通过哈希(hash)算法在一个容器中存放多个没有顺序的不可以重复的数据
声明集合：
s1 = set() <class ‘set’>
s2 = {“a”} <class ‘set’>
s3 = {} <class ‘dict’>
应为集合和字典都是使用{}表示，但是s3={}声明的是一个字典
集合的操作
set.add 增加
set.clear 清空
set.copy 复制
set.difference 两个集合之间求差集
set.difference_update 求差集并且用不一样的数据重新给自己赋值
set.discard 移除元素
set.intersection 求交集
set.intersection_update 求交集并给自己赋值
set.pop 随机删除一个
set.remove 指定删除某个数据
set.union 求并集
set.update 求并集并给自己赋值
>>> s1={1,2,3,4,5,6}
>>> s2={4,5,6,7,8,9}
>>> s1
{1, 2, 3, 4, 5, 6}
>>> s2
{4, 5, 6, 7, 8, 9}
>>> s1.add(0) #添加一个元素
>>> s1
{0, 1, 2, 3, 4, 5, 6}
>>> s1.difference(s2) #s1与s2求差集
{0, 1, 2, 3}
>>> s1.difference_update(s2) #s1与s2求差集，并把自己等于所得差集
>>> s1
{0, 1, 2, 3}
s1.discard(0) #删除一个指定元素，若元素不存在，则不报错
>>> s1
{1, 2, 3}
>>>s1
{1, 2, 3, 4, 5, 6}
>>> s1.intersection(s2) #s1与s2取交集
{4, 5, 6}
>>> s1.intersection_update(s2) #s1与s2取交集，并把自己等于交集
>>> s1
{4, 5, 6}
>>> s1.pop() #随机删除一个元素
4
>>> s1
{5, 6}
>>> s1.remove(5) #删除一个指定元素，若元素不存在，则报错
>>> s1
{6}
>>> s1={2,3,4,5,6}
>>> s1
{2, 3, 4, 5, 6}
>>> s1.union(s2) #s1与s2取并集
{2, 3, 4, 5, 6, 7, 8, 9}
>>> s1
{2, 3, 4, 5, 6}
>>> s2
{4, 5, 6, 7, 8, 9}
>>> s1.update(s2) #s1与s2取并集，并把自己等于并集
>>> s1
{2, 3, 4, 5, 6, 7, 8, 9}
字典
什么是字典
可以存储多个key:value 键值对数据的组合数据类型
字典的声明
d1 = dict() # 空字典
d2 = {} # 空字典
>>> d1 = dict() # 空字典
>>> d2 = {}
>>> type(d1) # 空字典
<class 'dict'>
>>> type(d2)
<class 'dict'>
>>> d1
{}
>>> d2
{}
字典的操作
doct.clear 清空
doct.copy 复制
doct.fromkeys 通过制定的key生成一个值为None的字典
doct.get 根据key获取对应的值
doct.items 获取所有的k:v键值对
doct.keys 获取所有的键
doct.pop 根据key值删除一个键值对
doct.popitem 随机删除一个键值对
doct.setdefault 增加一个数据，如果数据存在~修改
doct.update 把字典dict2的键/值对更新到dict里
doct.values 获取所有的值
字典中，增加数据
f[key] = value
f.setdefault(key, value)
f.update(key, value)
删除数据:删除一个键值对
f.pop(key) 删除制定的key:value键值对
f.popitem() 随机删除一个键值对
def f[key] 删除制定的key:value键值对
修改数据
f[key] = value
f.update({key, value})
查询数据
v = f[key]
v = f.get(key)
>>> d1={1:'a',2:'b',3:'c','dict':'字典','list':'列表','tuple':'元组',}
>>> d1
{1: 'a', 2: 'b', 3: 'c', 'dict': '字典', 'list': '列表', 'tuple': '元组'}
>>> d2={1:100,2:200,3:300,4:400,5:500,6:600}
>>> d2
{1: 100, 2: 200, 3: 300, 4: 400, 5: 500, 6: 600}
>>> d3=dict.fromkeys('1,2,3,4,5,6') #通过制定的key生成一个值为None的字典
>>> d3
{'1': None, ',': None, '2': None, '3': None, '4': None, '5': None, '6': None}
>>> d1.get('dict') #t通过键查找值
'字典'
>>> d1.items() #返回所有键值对
dict_items([(1, 'a'), (2, 'b'), (3, 'c'), ('dict', '字典'), ('list', '列表'), ('tuple', '元组')])
>>> d1.keys() #返回所有键
dict_keys([1, 2, 3, 'dict', 'list', 'tuple'])
>>> d1.values() 返回所有值
dict_values(['a', 'b', 'c', '字典', '列表', '元组'])
>>> d2
{1: 100, 2: 200, 3: 300, 4: 400, 5: 500, 6: 600}
d2.pop(1) #删除指定键的键值对
100
>>> d2
{2: 200, 3: 300, 4: 400, 5: 500, 6: 600}
d2.popitem() #随机删除键值对
(6, 600)
>>> d2
{2: 200, 3: 300, 4: 400, 5: 500}
>>>d2.setdefault(7) #增加一个数据，如果数据存在~修改
>>> d2
{2: 200, 3: 300, 4: 400, 5: 500, 7: None}
d1
{1: 'a', 2: 'b', 3: 'c', 'dict': '字典', 'list': '列表', 'tuple': '元组'}
>>> d2
{2: 200, 3: 300, 4: 400, 5: 500, 7: None}
>>> d1.update(d2) #把字典2整合到字典1中
>>> d1
{1: 'a', 2: 200, 3: 300, 'dict': '字典', 'list': '列表', 'tuple': '元组', 4: 400, 5: 500, 7: None}
遍历字典
for k in f.keys():# 直接循环字典中的key数据
print(k, f.get(k)) # value数据通过key数据获取
for k, v in f.items():# 直接循环字典中的key和value数据
print(k, v)
>>> for k in d1.keys():
... print(k,d1.get(k)) # value数据通过key数据获取
...
1 a
2 200
3 300
dict 字典
list 列表
tuple 元组
4 400
5 500
7 None
>>> for k,v in d1.items(): # 直接循环字典中的key和value数据
... print(k,v)
...
1 a
2 200
3 300
dict 字典
list 列表
tuple 元组
4 400
5 500
7 None