Python 组合数据类型

        组合数据类型在 Python 中非常重要，它们提供了一种方便的方式来存储和操作多个值。在实际编程中，我们可以根据具体的需求选择合适的数据类型来处理数据。

        Python 中的组合数据类型包括列表、元组、字典、集合

---

列表        list

定义

        列表是程序当中常见的结构，列表可以作为栈（先进后出）、队列（先进先出）等使用，只需要在中括号  []  中添加列表的项(元素)，以半角英文的逗号来隔开每个元素，就可以定义列表。

列表的创建

# 列表的创建
list1 = []  # 空列表
print(list1)
print(type(list1))
list2 = [1, 2, 3, True, False, 'hello']
print(list2)

列表的类型转换

list3 = list()  # 类型转换，把参数转化为列表
print(list3)
list3 = list('123')  # 类型转换：把参数转换为列表
print(list3)

列表的内置函数

# 内置函数  函数名()
list3 = [1, 2, 3]
print(len(list3))  # 打印列表的长度
print(max(list3))  # 打印最大的数
print(min(list3))  # 打印最小的数
del list3  # 删除list3
print(list3)

列表的索引，切片，加乘法，成员运算

list2 = [1, 2, 3, True, False, 'hello']
list3 = [1, 2, 3, 4, 5, 6, 7, 8]
# 列表的索引
print(list3[1])

# 列表的切片
print(list3[2:6:2])
'''
切片的格式：tuplename[start : end : step]
start:表示列表起始值，包含，默认为0
stop: 表示列表结束值，但是不包含
step: 步长，默认值为 1
'''

# 列表的加法和乘法
print(list3 + list2)
print(list3 * 3)

# 列表的成员运算
print('0' in list3)
print('1' not in list3)

列表的常用函数

（元组，字典，集合里面也有一些函数跟list差不多，我们可以自己定义一个想用的组合数据类型+.就可以在PyCharm里面看到能用的函数了）

函数名	作用
list.append(x)	将元素 x 追加到列表的尾部
list.extend(x)	将列表 x 中的所有元素追加到列表尾部形成新的列表
list.insert(i,x)	在列表中index为i的位置插入x元素
list.remove(x)	在列表中第一个为 x 的元素移除。若不存在 x 元素将产生一个异常
list.pop(x)	删除index为 i 的元素，并且将删除的元素显示出来，若不指定 i ，则默认弹出最后一个元素
list.clear()	清空列表
list.index(x)	返回第一个 x 元素的位置，若不存在， 则会报错
list.count(x)	统计列表中 x 元素的个数
list.reverse()	将列表反向进行排列
list.sort()	将列表从小到大进行排列，若需要从大到小进行排列，则用list.sort(reverse=True)来表示
list.copy()	返回列表的副本，就是简单复制出来一份

---

元组        tuple

定义

        元组表示多个元素组成的序列，用于存储一串信息，在数据之间进行使用，进行分割，元组与列表有许多相似的地方,只不过元组用 () 来定义，并且元组不能进行修改，所以元组是不可变序列

元组的创建

tuple1 = (1, 2, 3, True, 'hello')
print(tuple1)

# 查看tuple1的类型是不是元组
print(type(tuple1))

        除了使用( )创建元组外，Python 还提供了一个内置的函数 tuple()，用来将其它数据类型转换为元组类型

注：在元组中如果只有一个元素的时候，这个时候需要注意

tuple2 = (1)
print(tuple2)
print(type(tuple2))

tuple3 = (1,)  # 这个，是告诉解释器这个是一个元组，但是只有一个元素
print(tuple3)
print(type(tuple3))

从这里我们可以看出，tuple2是 int 类型，而tuple3是 元组类型，在添加元组里面的数据的时候，只加一个数据会让python误解，所以需要加上一个 ,

元组的类型转换

tuple5 = tuple('hello')  # str => tuple
print(tuple5)
print(type(tuple5))

tuple6 = tuple([1, 2, 3, 4])  # list => tuple
print(tuple6)
print(type(tuple6))

list1 = list(tuple6)  # tuple => list
print(list1)
print(type(list1))

str1 = str(tuple6)  # tuple => string
print(str1)
print(type(str1))

元组的内置函数

# len
print(len(tuple1))

# max min
print(max(tuple6), min(tuple6))

# del
del tuple5
print(tuple5)

元组的索引，切片，加乘法，成员运算

# 索引
print(tuple1[-1])

# 切片
print(tuple1[::-1])

# +
print(tuple1 + tuple6)

# *
print(tuple6 * 3)

# in
print(1 in tuple1)

元组的常用方法

# 输出的是用来元素计数的多少
a = tuple1.count('hello')
print(a)


# 输出的是寻找某个元素的索引值
print(tuple1)
a = tuple1.index(2)
print(a)

元组的遍历

for i in tuple1:
    print(i)

for index, value in enumerate(tuple1):
    print(index, value)

for i in range(len(tuple1)):
    print(i, tuple1[i])

---

字典        dict

定义

        字典是一种无序的可变容器，用于存储键值对。字典中的键必须是唯一的，但值可以是任何类型的数据。字典提供了一些常用的操作，如添加键值对、删除键值对、查找键值对等

说明

dictionary(字典) 是除了列表以外python之中 最灵活的数据类型。字典同样可以用来存储多个数据，通常用于存储描述一个物体的相关信息
字典用{}来定义
字典使用键值对存储数据，键值对之间使用 ,(逗号) 进行分割
键 key是索引
值 value是数据
键 和 值 之间使用：分隔
键 必须是唯一的 ! ! ! ! ! ! ! !(键如果重复的话，会覆盖掉之前的值)
值 可以取任何数据类型，但键只能使用字符串，数字或者元组

字典和列表的区别：
    列表是有序的对象集合
    字典是无序的对象集合

字典的创建

# 字典的创建
d = {
    'name': 'zxd',  # 键值对
    'gender': False,
}
print(d)
print(type(d))

d = {}
print(d)
print(type(d))

字典当中的键值对

d = {
    'name': 'abc',  # 键值对
    'gender': False,
}
# 新增键值对
d['height'] = 180
print(d)

# 获取键值对
print(d['name'])

# 修改键值对
d['gender'] = True
print(d)

字典的增删改查

aDict = {'name':'abc', 'age':18}
print(aDict)

aDict.update({'height':180})
print(aDict)

aDict.update({'name':'python'})
print(aDict)

aDict = {'name':'tcr', 'age':18}
print(aDict)

del aDict['age']
print(aDict)

字典的常用方法

d.pop('name')
print(d)

# 复制
a = d.copy()
print('a的键值对', a)
d.clear()

字典的遍历

for i in d:
    print(i)  # 打印三个key

print('-' * 30)

for i in d:
    print(i, d[i])  # 打印key和value

print(d.items())

for k, v in d.items():
    print(k, v)


print('**' * 30)

for k in d.keys():
    print(k)  # 打印key

for v in d.values():
    print(v)  # 打印value

---

集合        set

定义

        集合 set 不允许有重复元素，如果添加重复元素，则会自动过滤；可以进行交集并集的运算，
是一种无序且无重复元素的数据结构，set 与 dict 类似，是一组key的集合（但不存储key）

集合的创建

# 使用set()函数创建
s = set()
print(s, type(s))

# 直接使用“{}”创建
s = {1, 2, 3, 4}
print(s, type(s))

集合的类型转换

s = set([1, 2, 3])  # list => set
print(s)

s = set((1, 2, 3))  # tuple => set
print(s)

s = set('123')  # str => set
print(s)

s = set({1:'a', 'a':2})  # dict => set
print(s)

集合的操作符或函数

操作符或函数	意义
x in S	如果 S 中包含 x 元素， 则返回True，否则返回False
x not in S	如果 S 中不包含 x 元素，则返回True，否则返回False
S + T	连接 S 与 T ，返回连接后的新集合类
S * n 或者 n * S	将 S 延长自身n次
len(S)	返回 S 的长度

集合的操作

x = {1, 2, 3, 4}
print(x)

x.add(5)
print(x)

x.update({4, 6})
print(x)

x.pop()
print(x)
x.pop()
print(x)

x.discard(5)
print(x)
x.discard(5)
print(x)

x.remove(5)
print(x)

x.clear()
print(x)

# 集合的遍历
for i in s:
    print(i)

集合的运算

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
print(a|b)
print(a&b)
print(a-b)
print(b-a)
print(a^b)
print(b^a)