python期末考试（个人理解）主要内容为组合数据类型（二）持续更新

如有错误，敬请指正！！！

python数据类型：序列类型、集合类型、映射类型

序列组合：字符串（str）、列表（list）、元组（tuple）
序列支持双向索引（也就是说也正着数，也可以倒着数）
正着数：我们称为正向递增索引，第一个元素为0
倒着数：我们称为反向递减索引，第一个元素为-1

集合类型：和数学中的集合概念差不多（具有确定性、互异性、无序性）
确定性：元素在集合中是确定的
互异性：集合中的元素各不相同
无序性：集合中的元素没有顺序

映射类型：字典
字典：每个键只能对应一个值，同一个键不允许在字典中重复出现。
键是不可变类型

创建列表：
1、直接使用中括号‘[ ]’
2、使用内置函数list()
如下
list_one = []     # 使用[]创建空列表
list_two = ['p', 'y', 't', 'h', 'o', 'n']
li_two = list()      # 使用list()创建空列表
li_two = list('python') 

判断是否可迭代：isinstance()函数返回True表示为可迭代对象（可迭代的类型有：字符串、列表、集合、字典和文件）
如下：
a = 123
print(isinstance(a, int))  # 输出: True
b = "Hello"
print(isinstance(b, str))  # 输出: True
c = [1, 2, 3]
print(isinstance(c, list))  # 输出: True
d = (1, 2, 3)
print(isinstance(d, (tuple, list)))  # 输出: True 因为 tuple 也是 list 的一个子类

访问列表元素：使用索引、切片和遍历（for循环）来访问列表
1、索引
my_list = ['apple', 'banana', 'cherry']
print(my_list[0])  # 输出: 'apple'
2、切片
my_list = ['apple', 'banana', 'cherry']
print(my_list[1:3])  # 输出: ['banana', 'cherry']
3、遍历
# 假设我们有一个包含不同水果名称的列表
fruits = ['apple', 'banana', 'cherry', 'date']

# 使用for循环遍历列表
for fruit in fruits:
    print(fruit)   #输出apple  banana  cherry  date

添加列表元素：使用 append()、insert()、extend()方法和‘＋=’符
1、append()方法将一个元素添加到列表的末尾
my_list = [1, 2, 3]
my_list.append(4)
print(my_list)  # 输出: [1, 2, 3, 4]
2、insert() 方法可以在指定位置插入一个元素。第一个参数是插入位置的索引，第二个参数是插入的元素
my_list = [1, 2, 4]
my_list.insert(2, 3)  # 在索引2的位置插入元素3
print(my_list)  # 输出: [1, 2, 3, 4]
3、extend() 方法可以一次性添加多个元素到列表末尾，通常用于将一个列表的元素添加到另一个列表
my_list = [1, 2, 3]
my_list.extend([4, 5])
print(my_list)  # 输出: [1, 2, 3, 4, 5]
4、'+='操作符可以快速添加一个元素或另一个列表到现有列表
my_list = [1, 2, 3]
my_list += [4]
print(my_list)  # 输出: [1, 2, 3, 4]

元素排列：sort()、reverse()、sorted()方法
1、sort() 方法会就地对列表进行排序，不返回任何值
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
numbers.sort()
print(numbers)  # 输出: [1, 1, 2, 3, 4, 5, 6, 9]
2、sorted() 函数会返回一个新的列表，原列表不会被修改
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出: [1, 1, 2, 3, 4, 5, 6, 9]
3、reserve()将原本列表的元素从右至左依次排列存放（我们称它为逆置列表）
my_list = [1, 2, 3, 4, 5]
my_list.reverse()  # 反转列表
print(my_list)  # 输出: [5, 4, 3, 2, 1]
如果不想用reserve()逆置列表，也可以用切片的方式
my_list = [1, 2, 3, 4, 5]
reversed_list = my_list[::-1]  # 使用切片来反转列表
print(reversed_list)  # 输出: [5, 4, 3, 2, 1]
print(my_list)        # 原始列表保持不变: [1, 2, 3, 4, 5]

删除列表：del语句、remove()、pop()、clear()方法
1、del语句
my_list = [1, 2, 3, 4, 5]
del my_list[2]  # 删除索引为2的元素，即3
print(my_list)  # 输出: [1, 2, 4, 5]
2、remove()
my_list = [1, 2, 3, 4, 5, 2]
my_list.remove(2)  # 删除列表中第一个出现的2
print(my_list)  # 输出: [1, 3, 4, 5, 2]
3、pop()
my_list = [1, 2, 3, 4, 5]
removed_element = my_list.pop(2)  # 删除索引为2的元素，并返回该元素
print(removed_element)  # 输出: 3
print(my_list)  # 输出: [1, 2, 4, 5]
4、clear()与其他的不同，cleaar会清空列表的元素
my_list = [1, 2, 3, 4, 5]
my_list.clear()  # 清空列表
print(my_list)  # 输出: []

列表推导式：就是比一般创建列表的方法的漂亮
基本语法[expression for item in iterable if condition]
expression 是新列表中元素的表达式（你要对列表干什么）
item 是从 iterable 中取出的元素。（用于存储你的操作列表中的元素）
iterable 是一个可迭代对象，比如列表、元组、字典等。（你的操作列表）
condition 是一个可选的条件表达式，用于过滤元素。（就是你提取的元素必须满足这个条件）
例子如下
squares = [x**2 for x in range(6)]
print(squares)  # 输出: [0, 1, 4, 9, 16, 25]

创建元组：使用圆括号(),也可以不使用圆括号只用逗号‘，’分割
my_tuple = (1, 2, 3)    #使用圆()
my_tuple_without_parentheses = 1, 2, 3    #不使用圆括号
print(my_tuple)  # 输出: (1, 2, 3)
print(my_tuple_without_parentheses)  # 输出: (1, 2, 3)

元组的访问：索引、切片和遍历（for）
1、索引
my_tuple = ('apple', 'banana', 'cherry')
print(my_tuple[0])  # 输出: 'apple'
2、切片
my_tuple = ('apple', 'banana', 'cherry')
print(my_tuple[1:3])  # 输出: ('banana', 'cherry')
3、遍历
my_tuple = ('apple', 'banana', 'cherry')
for fruit in my_tuple:
    print(fruit)    #输出：('apple', 'banana', 'cherry')

集合的创建：使用大括号{}元素由逗号‘，’分割；或使用set()函数
注意：{}是不能创建空集合的，set()才能创建空集合
1、{}
my_set = {1, 2, 3}
2、set()
my_list = [1, 2, 2, 3, 4, 4, 5]
my_set = set(my_list)
print(my_set)  # 输出: {1, 2, 3, 4, 5}

集合元素的添加和删除
添加元素：add()加单个和update()加多个方法
1、add() 方法用于向集合中添加单个元素。如果元素已经存在于集合中，则不会重复添加
my_set = {1, 2, 3}
my_set.add(4)
print(my_set)  # 输出: {1, 2, 3, 4}
2、update() 方法可以一次性添加多个元素到集合中，这些元素可以是另一个集合、列表、元组等可迭代对象
my_set = {1, 2, 3}
my_set.update([4, 5, 6])
print(my_set)  # 输出: {1, 2, 3, 4, 5, 6}

字典的创建：{}初始化键值对；和使用dict()函数
1、{}键值对
my_dict = {'name': 'Alice', 'age': 25}
print(my_dict)  #输出: {'name': 'Alice', 'age': 25}
2、dict()函数
my_dict = dict([('name', 'Bob'), ('age', 30)])
print(my_dict)  # 输出: {'name': 'Bob', 'age': 30}
在大括号中键对值,键和值通过':'隔开(如a:b,则a是键，b是a的值。这种对应关系)
这里一个键对值我们暂且称为'⑥'。一个'⑥'，我们通过逗号','分割开
字典顾名思义能够通过某个键快速的找到某个值
在这当中键是唯一的

字典的访问：通过键的索引去访问、使用get()、keys()获取所有键、values()获取所有值、items()获取所有键和值即所有元素方法
1、通过键的索引去访问
my_dict = {'name': 'Alice', 'age': 30}
print(my_dict['name'])  # 输出: Alice
2、keys() 或遍历keys()
my_dict = {'name': 'Alice', 'age': 30}
print(my_dict.keys())    #输出dict_keys(['name', 'age'])
以下为遍历key()
my_dict = {'name': 'Alice', 'age': 30, 'job': 'Engineer'}
# 遍历字典的键
for key in my_dict.keys():
    print(key)
# 输出:
# name
# age
# job
3、values()或遍历values()
my_dict = {'name': 'Alice', 'age': 30}
print(my_dict.values())    #输出dict_values(['Alice', 30])
以下为遍历values()
my_dict = {'name': 'Alice', 'age': 30, 'job': 'Engineer'}
# 遍历字典的值
for value in my_dict.values():
    print(value)
# 输出:
# Alice
# 30
# Engineer
4、items()或遍历items()
my_dict = {'name': 'Alice', 'age': 30}
print(my_dict.items())    #输出dict_items([('name', 'Alice'), ('age', 30)])
以下为遍历items()
my_dict = {'name': 'Alice', 'age': 30, 'job': 'Engineer'}
# 遍历字典的键值对
for key, value in my_dict.items():
    print(f'{key}: {value}')
# 输出:
# name: Alice
# age: 30
# job: Engineer

字典的添加和修改
添加：通过键添加和使用update()方法
1、通过键添加
my_dict = {'name': 'Alice', 'age': 30}
my_dict['job'] = 'Engineer'  # 添加新的键值对 'job': 'Engineer'
print(my_dict)  # 输出: {'name': 'Alice', 'age': 30, 'job': 'Engineer'}
若对应的键不存在则会添加，若存在则会更新
2、使用update()
my_dict = {'name': 'Alice', 'age': 30}
# 继续使用上面定义的 my_dict
my_dict.update({'city': 'New York'})  # 添加新的键值对 'city': 'New York'
my_dict.update(salary=50000)  # 添加新的键值对 'salary': 50000
my_dict.update({'age': 32, 'name': 'Alice B.'})  # 更新 'age' 和 'name'
print(my_dict)  # 输出: {'name': 'Alice B.', 'age': 32, 'job': 'Engineer', 'city': 'New York', 'salary': 50000}

删除：使用pop()、popitem()和clear()方法和使用del语句
1、pop()
my_dict = {'name': 'Alice', 'age': 30, 'job': 'Engineer'}
value = my_dict.pop('age', None)  # 删除键 'age' 并返回其值，如果不存在则返回 None
print(value)  # 输出: 30
print(my_dict)  # 输出: {'name': 'Alice'}
2、popitem()随机删除字典中的元素
3、clear()使字典变空
my_dict = {'name': 'Alice', 'age': 30, 'job': 'Engineer'}
my_dict.clear()  # 清空字典
print(my_dict)  # 输出: {}
4、del语句
my_dict = {'name': 'Alice', 'age': 30, 'job': 'Engineer'}
del my_dict['job']  # 删除键 'job' 及其对应的值
print(my_dict)  # 输出: {'name': 'Alice', 'age': 30}

字典推导式：类似于列表推导式，但它是用于创建字典
语法如下：{key_expression: value_expression for item in iterable if condition}
key_expression 是字典中键的表达式。（字典的键）
value_expression 是字典中值的表达式。（字典的值）
item 是从 iterable 中取出的元素。（就是元素存储位置）
iterable 是一个可迭代对象。（取出元素的字典）
condition 是一个可选的条件表达式，用于过滤元素。（从字典取出的元素需要满足的条件）
例子如下：
numbers = [1, 2, 3, 4]
squares = {x: x**2 for x in numbers}
print(squares)  # 输出: {1: 1, 2: 4, 3: 9, 4: 16}
或
old_dict = {'name': 'Jack','age':23,'height':185}
new_dict = {value:key for key,value in old_dict.items()}
print(new_dict)    #输出：{'Jack': 'name', 23: 'age', 185: 'height'}
以下为添加条件：
numbers = [1, 2, 3, 4, 5]
even_squares = {x: x**2 for x in numbers if x % 2 == 0}
print(even_squares)  # 输出: {2: 4, 4: 16}