总结篇：高阶数据类型与推导式，解锁数据处理的无限可能

以下代码覆盖四大高阶数据类型的讲解，包括定义方式，使用场景，遍历方式，及其自带的内置方法。都附上实例帮助你理解，相信你看完一定让你受益匪浅。

四种数据类型讲解

import random

print("=============列表============")
# 列表
# 它是一种可迭代类型，用于存储多种数据 可以像字符串一样通过下标获取数据
# 定义
# 方式一 直接使用[]再内部写入元素定义
l1 = [1, 3, 5, 7, 3, 2, 0, 9, 0]
print(l1, type(l1))
# [1, 3, 5, 7, 3, 2, 9, 0] <class 'list'>
# 方式二 使用可迭代类型 把他们每个元素放入列表,如字符串 元组 字典 集合 列表
s1 = "hello world"
l2 = list(s1)
print(l2, type(l2))
# ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'] <class 'list'>

# 他有两种遍历方式
# 方式一 直接通过遍历列表获取其所有元素
for i in l1:
    print(i)  # 打印其中每个元素
# 方式二 通过访问下标获取其中所有元素 len()获取其长度
for i in range(len(l1)):
    print(i)  # 输出从零开始到它长度减一的每一个数字
    print(l1[i])  # 获取其中每个元素

print("----------内置方法----------")
# 三个增加 append() insert() extend() 插入的返回值都为空，改变的是列表
# 把三加入列表末尾
l1.append(3)
# insert() 在指定位置插入值
l1.insert(4, '你好')
print(l1)  # [1, 3, 5, 7, '你好', 3, 2, 9, 0, 3]
# extend() 把可迭代按顺序插入列表后面
l1.extend(s1)
print(l1)
# [1, 3, 5, 7, '你好', 3, 2, 9, 0, 3, 'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

# 删除 pop() remove() clear()
# pop() 通过索引删除指定元素 省略索引会删除最后一个元素 返回被删除的元素
print(l1.pop(1))  # 3
# remove()  删除列表指定的值 找不到会报错
l1.remove('你好')  # 返回值为空
print(l1)
# [1, 5, 7, 3, 2, 9, 0, 3, 'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
# 清空列表
# l1.clear()

# index() 查找元素索引，找不到会报错
print(l1.index(0))  # 5 返回从左到右匹配到的第一个值的索引

# count() 统计元素在列表出现的次数
print(l1.count('l'))  # 3 l在列表中出现了三次

# sort() 对列表中所有元素进行排序
l1 = [1, 3, 5, 7, 3, 2, 0, 9, 0]
print(l1.sort())  # 返回值为空
print(l1)
# [0, 0, 1, 2, 3, 3, 5, 7, 9]

# in 成员运算符
# 判断元素是否在列表中 返回True False
print(0 in l1)  # True
print('你好' in l1)  # False

# 列表推导式
# 方便我们在列表中添加数据
# 循环10次 每次从1到10中随机一个数放入列表中
l2 = [random.randint(1, 10) for i in range(10)]
# [10, 5, 4, 4, 9, 2, 9, 5, 8, 9]
print(l2)

print("=============元组============")
# 元组为不可变类型 一旦确定就不可改变
# 其内置方法也比较少

# 它的定义方式也有两种
# 直接定义 在()中放入数字 输出为元组
tuple1 = (1, 3, 7, 9, 2, 6, 8)
print(tuple1, type(tuple1))  # <class 'tuple'>
# tuple() 把可迭代内容方入其中 自动迭代其中所有元素放入元组
# 把列表转换为元组
l1 = [1, 3, 5, 7, 3, 2, 0, 9, 0]
print(tuple(l1))
# (0, 0, 1, 2, 3, 3, 5, 7, 9)

# 元组推导式是一个生成器 generator
# 不能直接输出 只能通过遍历生成
tuple2 = (i for i in range(10))
# 直接打印会返回生成器格式
print(tuple2)  # <generator object <genexpr> at 0x000001FF66AFFED0>

# # 用tuple遍历
# tuple2 = tuple(tuple2)
# print(tuple2)
# 用for 循环遍历
for i in tuple2:
    print(i)
print("-------------内置方法------------")
# 它适合存放固定的数据 没有多余的操作 内存管理更加高效
# 内置方法只有两个常用

# index(value) 返回元素对应索引 找不到报错
print(tuple1.index(9))  # 3

# count(value) 统计元素在元组中的次数 找不到返回 0
print(tuple1.count(10))  # 0

print("=============字典============")
# 通过键值对的方式存放数据 可以快速获取值
# 定义方式{'key': 'value'}
# 键是不可变类型(绝大多数是字符串) 值是任意数据类型
dict1 = {
    'id': 101,
    'name': '马云',
    'sex': '男',
    'address': ['北京', '上海', '杭州']
}
print(type(dict))  # <class 'dict'>
# 用dict()方法指明键和值
dict2 = dict(a=10, b=20)
print(dict2)
# {'a': 10, 'b': 20}

# len() 获取键值对的数量
print(len(dict1))  # 4

# 它有三种迭代方式 获取键 获取值 获取键和值
for i in dict1.keys():
    print(i)
# id
# name
# sex
# address
# 获取键对应的值
for j in dict1.values():
    print(j)
# 获取键值对
for key, value in dict1.items():
    print(key, value)
# id 101
# name 马云
# sex 男
# address ['北京', '上海', '杭州']

# 字典推导式
dict3 = {f"key{i}": f"value{i * 2}" for i in range(5)}
print(dict3)
# {'key0': 'value0', 'key1': 'value2', 'key2': 'value4', 'key3': 'value6', 'key4': 'value8'}

print("----------内置方法----------")
# get() 获取指定键对应的值
# 如果键不存在返回None
# 也可以指定没有键是返回默认值
print(dict1.get('你好'))  # None
print(dict1.get('name'))  # 马云

# 更改值 直接获取键修改对应的值
# 通过访问键和下标的方式去修改值
dict1['name'] = '张飞'
print(dict1)
# {'id': 101, 'name': '张飞', 'sex': '男', 'address': ['北京', '上海', '杭州']}
dict1['address'][0] = '南京'
print(dict1)
# {'id': 101, 'name': '张飞', 'sex': '男', 'address': ['南京', '上海', '杭州']}

# 删除 pop('name') popitem() clear()
# 删除指定键对应的值 返回删除的值
print(dict1.pop('address'))  # ['南京', '上海', '杭州']

# 删除并返回元组最后一个放入的元素 并返回被删除除的键值对放入元组
print(dict1.popitem())  # ('sex', '男')

# clear() 清空字典
dict1.clear()  # 返回值为空
print(dict1)

# update() 合并一个新字典到原来的字典中
dict1 = {
    'id': 101,
    'name': '马云',
    'sex': '男',
    'address': ['北京', '上海', '杭州']
}
dict1.update({'hobby': ['跑车', '钓鱼', '游戏']})
print(dict1)

print("============集合============")
# 特征 无序 不重复
# 不可以使用下标
# 定义方式一 可以自动去重
set1 = {1, 2, 2, 3, 3, 5, 7, 5, 12}
print(set1)
# {1, 2, 3, 5, 7}
# 方式二 使用函数内置方法
# set(iterable) 放入可迭代元素存放到集合中
str1 = "hello world"
# 无序存放每一个字符串
set2 = set(str1)
print(set2)
# {' ', 'l', 'w', 'h', 'd', 'e', 'o', 'r'}

# 集合推导式
# 把0 到 9 依次放入集合中
set3 = {i for i in range(10)}
print(set3)
# {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

print("-----------内置方法----------")
# 增加元素 add()
set3.add(10)  # 返回None 把10 添加到set3里面
print(set3)
# 更新元素 update() 把新集合合并到原始集合中
print(set3.update({1, 3, 5, 7, 9, 11, 13, 15}))  # 返回None
print(set3)  # 把没有和原来集合重复的元素放入集合中
# {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15}

print('-----删除元素-----')
# 随机删除集合中一个元素 pop()
print(set3.pop())  # 0 返回被删除的值
# 删除指定元素 remove() 不存在则报错
print(set3.remove(15))  # 返回空
print(set3)
# 删除一个元素 不存在不报错
print(set3.discard(13))  # 返回空

# 交集 两者都有
print(set3.intersection(set1))
# {1, 2, 3, 5, 7}

# 并集 union() 把两个集合并在一起 与数学中的交并集一样
print(set1.union(set3))
# {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}

# 差集 自己有 别人没有 difference()
print(set3.difference(set1))
# {4, 6, 8, 9, 10, 11}

# 清空集合 空集合表示方法 set()
set3.clear()
print(set3)
# set()

这些数据类型还有更多的内置方法，想了解可以看看下面的表格。来源菜鸟：http://www.runoob.com

列表方法

Python列表函数&方法

Python包含以下函数:

序号	函数
1	len(list) 列表元素个数
2	max(list) 返回列表元素最大值
3	min(list) 返回列表元素最小值
4	list(seq) 将元组转换为列表

Python包含以下方法:

序号	方法
1	list.append(obj) 在列表末尾添加新的对象
2	list.count(obj) 统计某个元素在列表中出现的次数
3	list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj) 将对象插入列表
6	list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj) 移除列表中某个值的第一个匹配项
8	list.reverse() 反向列表中元素
9	list.sort( key=None, reverse=False) 对原列表进行排序
10	list.clear() 清空列表
11	list.copy() 复制列表

元组方法 

元组内置函数

Python元组包含了以下内置函数

序号	方法及描述	实例
1	len(tuple) 计算元组元素个数。	>>> tuple1 = ('Google', 'Runoob', 'Taobao') >>> len(tuple1) 3 >>>
2	max(tuple) 返回元组中元素最大值。	>>> tuple2 = ('5', '4', '8') >>> max(tuple2) '8' >>>
3	min(tuple) 返回元组中元素最小值。	>>> tuple2 = ('5', '4', '8') >>> min(tuple2) '4' >>>
4	tuple(iterable) 将可迭代系列转换为元组。	>>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu'] >>> tuple1=tuple(list1) >>> tuple1 ('Google', 'Taobao', 'Runoob', 'Baidu')

 字典方法

字典内置函数&方法

Python字典包含了以下内置函数：

序号	函数及描述	实例
1	len(dict) 计算字典元素个数，即键的总数。	>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> len(tinydict) 3
2	str(dict) 输出字典，可以打印的字符串表示。	>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> str(tinydict) "{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"
3	type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。	>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> type(tinydict) <class 'dict'>

Python字典包含了以下内置方法：

序号	函数及描述
1	dict.clear() 删除字典内所有元素
2	dict.copy() 返回一个字典的浅复制
3	dict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4	dict.get(key, default=None) 返回指定键的值，如果键不在字典中返回 default 设置的默认值
5	key in dict 如果键在字典dict里返回true，否则返回false
6	dict.items() 以列表返回一个视图对象
7	dict.keys() 返回一个视图对象
8	dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	dict.update(dict2) 把字典dict2的键/值对更新到dict里
10	dict.values() 返回一个视图对象
11	pop(key[,default]) 删除字典 key（键）所对应的值，返回被删除的值。
12	popitem() 返回并删除字典中的最后一对键和值。

集合方法 

集合内置方法完整列表

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集
difference_update()	移除集合中的元素，该元素在指定的集合也存在。
discard()	删除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	返回集合的交集。
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	判断指定集合是否为该方法参数集合的子集。
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	返回两个集合的并集
update()	给集合添加元素
len()	计算集合元素个数