Python 列表（List）
详细介绍：
- 概念：列表是Python中最常用的可变序列数据类型，它是一个有序的元素集合，允许包含不同类型的元素（如整数、字符串、浮点数、其他列表等）。
- 定义方式：
- 直接赋值：
my_list = [element1, element2, ..., elementN] - 使用列表推导式：
my_list = [expression for item in iterable if condition] range()函数：用于生成一系列连续的数字，返回一个可迭代对象，通常与list()函数一起使用来创建列表，如nums = list(range(start, stop, step))。
- 直接赋值：
常用函数和操作：
- 增删改：
append(element)：在列表末尾添加一个元素。extend(iterable)：在列表末尾一次性追加另一个可迭代对象的所有元素。insert(index, element)：在指定位置插入一个元素。remove(item)：移除列表中第一个匹配指定值的元素。pop([index])：删除并返回指定位置（默认为最后一个）的元素。del my_list[index]：使用索引直接删除元素。reverse()：就地反转列表元素顺序。sort(key=None, reverse=False)：对列表进行排序，可选参数指定排序依据和是否降序排列。
- 访问和查询：
my_list[index]：通过索引来访问或修改列表中的元素，支持正向索引（从0开始）和负向索引（从-1开始计数）。my_list[start:end:step]：切片操作，获取子列表。len(my_list)：返回列表长度。in关键字：判断某个元素是否在列表中，如element in my_list。
- 其他：
count(item)：返回列表中指定元素出现的次数。index(item[, start[, end]])：返回列表中第一个匹配指定值的元素的索引，可选参数指定搜索范围。copy()：返回列表的一个浅拷贝。
可使用如下方式创建列表
list()也可用python,接受可迭代对象
a=[]
a=list(['1','5'])
a=list(1) #创建失败，1不可迭代类型
a=list("python") #每个字符都是列表元素
Python 元组（Tuple）
详细介绍：
- 概念：元组是一种不可变序列，与列表类似，但一旦创建后就不能修改其内容。元组通常用于表示固定不变的数据集合。
- 定义方式：
- 直接赋值：
my_tuple = (element1, element2, ..., elementN) - 单元素元组需加逗号：
singleton = (element,)
- 直接赋值：
常用函数和操作：
- 访问和查询：
my_tuple[index]：通过索引来访问元组中的元素，同样支持正向和负向索引。my_tuple[start:end:step]：切片操作，返回新的元组。len(my_tuple)：返回元组长度。in关键字：判断某个元素是否在元组中。
- 其他：
- 元组不支持增删改操作，因为它们是不可变的。
- 可以使用
+和*运算符来拼接元组或复制元组。
可使用：同list()一样tuple()接受可迭代对象
t1 =()
t2 =(1,) #创建单个元素的元组
t3= (1,2,3) #创建多个元素的元组
t4=(1,'c',('e',2) )#元组嵌套
t1 =tuple() #创建空元组
t1 =tuple([1,2,3]) #利用列表创建元组
t3 =tuple('pyth')#结果是（'p','y','t','h'）
t3 =tuple(range()5)#结果是（0,1,2,3,4）
Python 集合（Set）
详细介绍：
- 概念：集合是一个无序且不重复元素的集合，常用于数学上的集合操作，如交集、并集、差集等。
- 定义方式：
- 直接赋值：
my_set = {element1, element2, ..., elementN} - 使用
set()函数创建：my_set = set(iterable)，将可迭代对象转化为集合以去除重复项。
- 直接赋值：
常用函数和操作：
- 增删改：
add(item)：向集合添加一个元素。update(iterable)：向集合添加多个元素，可接受可迭代对象。remove(item)：移除集合中指定元素，如果元素不存在则引发KeyError。discard(item)：尝试移除集合中的指定元素，如果元素不存在不会引发异常。pop()：随机移除并返回一个集合元素，若集合为空则引发KeyError。
- 集合操作：
union(other)或者|：返回两个集合的并集。intersection(other)或者&：返回两个集合的交集。difference(other)或者-：返回两个集合的差集（不在另一个集合中的元素）。symmetric_difference(other)或者^：返回两个集合的对称差集（只存在于一个集合中的元素）。issubset(other)或<=：判断当前集合是否为另一个集合的子集。issuperset(other)或>=：判断当前集合是否为另一个集合的超集。
- 其他：
len(my_set)：返回集合中元素数量。in关键字：判断某个元素是否在集合中。
set()同list()一样同样接受可迭代对象
s1 = {1}
s2 = {1,'b',(2,5)}
s1 =set([1,2,3]) #传入列表
s2=set((2,3,4))#传入元组
s4=set（'python'）#传入字符串
s5=set(range(5))#传入整数列表
Python 字典（Dictionary）
详细介绍：
- 概念：字典是一种无序的键值对（key-value pairs）集合，通过键（必须唯一且不可变）来快速查找对应的值。
- 定义方式：
- 直接赋值：
my_dict = {key1: value1, key2: value2, ..., keyN: valueN} - 使用
dict()函数创建：my_dict = dict([(key1, value1), (key2, value2), ...])或my_dict = dict(key1=value1, key2=value2, ...)
- 直接赋值：
常用函数和操作：
- 增删改：
my_dict[key] = value：设置或更新键值对。my_dict.setdefault(key, default=None)：如果键不存在，则设置键值对；否则返回已存在的值。my_dict.pop(key[, default])：移除指定键的键值对并返回对应的值，若键不存在且提供了默认值，则返回默认值；否则引发KeyError。my_dict.popitem()：随机移除并返回字典中的一对键值，若字典为空则引发KeyError。del my_dict[key]：删除指定键的键值对。update([other, ]**kwargs)：合并另一个字典（或关键字参数）到当前字典中。
- 访问和查询：
my_dict[key]：通过键访问对应的值，若键不存在则引发KeyError。my_dict.get(key[, default])：通过键获取对应的值，若键不存在则返回指定的默认值（默认为None）。in关键字：判断某个键是否在字典中。
- 其他：
keys()：返回一个包含所有键的视图，可迭代。values()：返回一个包含所有值的视图，可迭代。items()：返回一个包含所有键值对的视图，每个元素是一个元组(key, value)，可迭代。len(my_dict)：返回字典中键值对的数量。clear()：清空字典。
使用dict()同样接受可迭代对象这里不过多介绍
创建方式有两种
a={'name':'jack'}
a=dict()
-
语法规则：
- 字典的访问格式为：
dict[key] - 示例代码如下：
d = dict([('A', 1), ('B', 2), ('C', 3)]) print(d['A']) # 输出：1
- 字典的访问格式为：
-
运行代码，结果如下所示：
1 -
示例代码：
d = {'name': 'Jack', 'age': 23, 'height': 185} print(d.items()) # 结果如下所示：dict_items([('name', 'Jack'), ('age', 23), ('height', 185)]) print(d.keys()) # 结果如下所示：dict_keys(['name', 'age', 'height']) print(d.values()) # 结果如下所示：dict_values(['Jack', 23, 185]) -
运行代码，结果如下所示：
dict_items([('name', 'Jack'), ('age', 23), ('height', 185)]) dict_keys(['name', 'age', 'height']) dict_values(['Jack', 23, 185]) -
示例代码：
d = {'name': 'Jack', 'age': 23, 'height': 185} for key in d: print(key) # 输出：name age height -
运行代码，结果如下所示：
name age height -
示例代码：
d = {'name': 'Jack', 'age': 23, 'height': 185} print(d.get('name')) # 输出：Jack print(d.get('weight')) # 输出：None print(d.get('weight', 0))# 输出：0 -
运行代码，结果如下所示：
Jack None 0 -
示例代码：
d = {'name': 'Jack', 'age': 23, 'height': 185} print(d['name']) # 输出：Jack print(d.get('name')) # 输出：Jack print(d.get('weight', 0)) # 输出：0 -
运行代码，结果如下所示：
Jack Jack 0
以下是对Python中元组、列表、集合的访问和操作方法进行整理：
元组（Tuple）
访问方式
-
索引访问：与列表类似，通过索引来访问元组中的元素。索引从0开始，正数表示从左到右访问，负数表示从右到左访问。
t = (1, 'apple', 3.14) print(t[0]) # 输出：1 print(t[-1]) # 输出：3.14 -
切片访问：与列表相同，可以使用切片语法获取元组的部分元素。
t = (1, 'apple', 3.14, 'banana', 'cherry') print(t[1:3]) # 输出：('apple', 3.14) print(t[::2]) # 输出：(1, 3.14, 'cherry')
其他操作
-
不可变性：元组是不可变序列，一旦创建后不能修改其元素。
-
连接与重复：使用加号
+连接两个或多个元组，使用乘号*重复元组。t1 = (1, 2, 3) t2 = ('a', 'b', 'c') print(t1 + t2) # 输出：(1, 2, 3, 'a', 'b', 'c') print((1, 2) * 3) # 输出：(1, 2, 1, 2, 1, 2) -
成员资格检查：使用
in关键字判断元组是否包含某个元素。t = (1, 'apple', 3.14) print(1 in t) # 输出：True print('orange' in t) # 输出：False
列表（List）
访问方式
-
索引访问：与元组相同，通过索引来访问列表中的元素。
lst = [1, 'apple', 3.14] print(lst[0]) # 输出：1 print(lst[-1]) # 输出：3.14 -
切片访问：与元组相同，可以使用切片语法获取列表的部分元素，并且支持切片赋值。
lst = [1, 'apple', 3.14, 'banana', 'cherry'] print(lst[1:3]) # 输出：['apple', 3.14] lst[::2] = ['new', 'elements'] # 替换部分元素 print(lst) # 输出：[1, 'new', 3.14, 'elements', 'cherry']
其他操作
-
可变性：列表是可变序列，可以修改其元素、插入新元素、删除已有元素等。
lst = [1, 2, 3] lst[0] = 'one' # 修改元素 lst.append('four') # 插入元素 lst.pop() # 删除并返回最后一个元素 -
列表方法：列表提供了丰富的内置方法，如
append()、extend()、insert()、remove()、sort()、reverse()等，用于对列表进行各种操作。 -
连接与重复：与元组相同，使用加号
+连接两个或多个列表，使用乘号*重复列表。 -
成员资格检查：与元组相同，使用
in关键字判断列表是否包含某个元素。
集合（Set）
访问方式
-
成员访问：集合本身不支持索引访问，但可以通过
in关键字判断一个元素是否属于集合。s = {1, 'apple', 3.14} print(1 in s) # 输出：True print('orange' in s) # 输出：False
其他操作
-
无序性与唯一性：集合中的元素无序且唯一，自动去除重复项。
-
添加与移除元素：使用
add()方法添加元素，使用remove()或discard()方法移除元素。s = {1, 2, 3} s.add('apple') # 添加元素 s.remove(7) # 如果元素不存在会引发 KeyError s.discard(9) # 如果元素不存在不会报错 -
集合运算：集合支持并集（
union、|）、交集（intersection、&）、差集（difference、-）和对称差集（symmetric_difference、^）等数学运算。s1 = {1, 2, 3} s2 = {2, 3, 4} print(s1.union(s2)) # 输出：{1, 2, 3, 4} print(s1 | s2) # 输出：{1, 2, 3, 4} print(s1.intersection(s2)) # 输出：{2, 3} print(s1 & s2) # 输出：{2, 3} print(s1.difference(s2)) # 输出：{1} print(s1 - s2) # 输出：{1} print(s1.symmetric_difference(s2)) # 输出：{1, 4} print(s1 ^ s2) # 输出：{1, 4} -
集合方法：集合还提供了
update()、intersection_update()、difference_update()和symmetric_difference_update()等方法，用于执行相应的集合运算并直接更新原集合。
以上就是Python中元组、列表、集合的访问方式及其主要操作方法的整理。
可迭代对象（Iterable）
概念：
- 在Python中，一个对象被称为可迭代对象（Iterable），如果它定义了
__iter__()方法，该方法返回一个迭代器对象。当对可迭代对象使用for...in循环时，实际上是在隐式调用其__iter__()方法。
常见可迭代对象：
- 列表（List）
- 元组（Tuple）
- 字符串（String）
- 集合（Set）
- 字典（Dictionary，但迭代的是字典的键）
- 自定义类（如果实现了
__iter__()方法）
迭代器（Iterator）：
- 迭代器是实现了
__next__()方法的对象，每次调用__next__()返回容器中的下一个元素，当没有更多元素时抛出StopIteration异常。 - 可以通过内置函数
iter()显式获取一个对象的迭代器，如iter(list_obj)。
相关操作：
- 使用
for item in iterable:遍历可迭代对象。 - 使用
next(iterator[, default])函数获取迭代器的下一个元素，如果没有更多元素则返回提供的默认值（如果不提供则引发StopIteration）。 - 使用
enumerate(iterable, start=0)函数同时获取可迭代对象的索引和值，返回一个枚举对象。 - 使用
zip(*iterables)函数将多个可迭代对象对应元素打包为元组的迭代器。 - 使用
map(function, iterable, ...)函数对可迭代对象的每个元素，生成一个新序列。
针对Python中列表、元组、集合、字典以及可迭代对象的使用，以下是若干注意事项：
列表（List）
- 可变性：由于列表是可变的，对列表的操作（如增删改）会直接改变原列表，而不是创建新列表。在需要保持原始数据不变的情况下，使用切片或
copy()方法创建副本。 - 索引越界：访问列表元素时要注意索引的有效范围，避免超出列表长度导致
IndexError。 - 效率：对于大数据量的列表，某些操作（如插入、删除中间元素）可能效率较低，因为涉及到元素移动。考虑使用其他数据结构（如链表）或优化算法（如双指针）以提高性能。
- 线程安全：在多线程环境中直接修改列表可能导致数据竞争，需要采取适当的同步机制（如锁）来保护共享列表。
元组（Tuple）
- 不可变性：元组一旦创建便不能更改。试图修改元组元素的行为会导致
TypeError。如果需要修改数据，应使用列表或其他可变类型。 - 单元素元组：创建单个元素的元组时，需要在元素后面加上逗号，如
singleton = (element,)，以区分于括号内的单个表达式。
集合（Set）
- 无序性：集合中的元素无固定顺序，因此不能依赖索引来访问元素。
- 元素要求：集合中的元素必须是不可变的，因此不能包含列表、字典或其他可变集合作为元素。可以使用元组代替。
- 唯一性：集合自动去重，添加重复元素不会改变集合内容。在需要确保元素唯一性时，集合比列表更合适。
字典（Dictionary）
- 键的唯一性：字典中的键必须是唯一的，重复键会导致后添加的键值对覆盖之前的值。键通常选用不可变类型（如字符串、整数、元组）。
- 键不存在：访问不存在的键会引发
KeyError。使用get()方法可以避免此错误，并能指定默认值。 - 遍历字典：默认情况下，
for key in my_dict:遍历的是字典的键。要访问键值对或仅遍历值，可以使用my_dict.items(),my_dict.keys(),my_dict.values()。 - 字典的比较：字典之间比较的是键值对的相等性，而非字典对象本身。两个字典相等意味着它们有相同的键，并且对应键的值也相等。
可迭代对象（Iterable）
- 消耗性：迭代器在迭代过程中通常会消耗资源（如网络连接、文件句柄）。一旦遍历完，不能再重新开始，除非重新创建迭代器。
- 内存效率：迭代器适用于处理大型数据集，因为它不需要一次性加载所有数据到内存，而是按需生成或获取数据。
- 异常处理：在自定义迭代器类中实现
__iter__()方法时，确保__next__()方法在没有更多元素时抛出StopIteration异常，以符合迭代协议。
综上所述，使用这些数据结构时，应充分理解它们的特点和限制，以确保代码的正确性和效率。
列表推导式是Python中一种简洁且高效的创建列表的方法，通过嵌套的循环和条件表达式在一个单一语句中构建列表。以下是关于列表推导式的几个关键点及其示例：
基本形式
基本的列表推导式由一对方括号 [ ] 包裹，内部包含一个表达式和一个或多个循环与可选的条件判断。其基本结构如下：
new_list = [expression for item in iterable]
其中：
new_list是生成的新列表。expression是应用于每个元素的计算表达式，通常基于item。item是从iterable中取出的每一个元素。iterable是任何可迭代对象，如列表、元组、字符串、range对象等。
带条件的列表推导式
在列表推导式中可以加入一个 if 子句，用于筛选 iterable 中满足特定条件的元素：
new_list = [expression for item in iterable if condition]
这里的 condition 是一个布尔表达式，只有当 item 满足该条件时，对应的 expression 才会被计算并添加到新列表中。
多重循环的列表推导式
列表推导式支持多个嵌套的 for 循环，用于处理多维数据或生成复杂的列表：
new_list = [expression for outer_item in outer_iterable for inner_item in inner_iterable]
在这个例子中，有两个嵌套的循环，分别遍历 outer_iterable 和 inner_iterable。expression 将基于内外层循环的当前元素计算。
带有复杂条件的列表推导式
列表推导式可以包含更复杂的条件结构，例如嵌套的 if-else 结构，使用三元运算符等：
new_list = [expression if condition else alternate_expression for item in iterable]
如果 condition 为真，则将 expression 计算结果添加到列表；否则，添加 alternate_expression 的结果。
结合内置函数的列表推导式
列表推导式可以与Python内置函数结合使用，以进一步处理生成的列表：
new_list = [func(expression) for item in iterable]
这里 func 是一个应用于 expression 结果的函数，如 str.lower()、abs()、math.sqrt() 等。
示例
- 创建平方数列表：
squares = [x ** 2 for x in range(10)]
- 生成偶数列表：
even_numbers = [num for num in range(20) if num % 2 == 0]
- 合并两个列表的元素：
list1 = ['a', 'b', 'c']
list2 = [1, 2, 3]
combined = [(letter, number) for letter in list1 for number in list2]
- 提取字符串列表中所有字符的大写字母版本：
words = ['apple', 'banana', 'cherry']
upper_letters = [word.upper() for word in words]
- 使用条件计算元素：
numbers = [1, -2, 3, -4, 5]
absolute_values = [abs(num) if num < 0 else num for num in numbers]
这些示例展示了列表推导式的多样性和灵活性，它允许开发者以简洁的语法快速生成具有特定规律或过滤条件的列表。
除了列表推导式之外，Python还提供了字典推导式和集合推导式，这两种推导式分别用于简洁高效地创建字典和集合。以下是关于字典推导式和集合推导式的详细介绍及示例：
字典推导式
字典推导式使用花括号 {} 封装，并由键值对表达式与一个或多个循环以及可选的条件组成。基本形式如下：
new_dict = {key_expression: value_expression for item in iterable}
其中：
new_dict是生成的新字典。key_expression和value_expression分别是用于计算键和值的表达式，通常基于item。item是从iterable中取出的每一个元素。iterable是任何可迭代对象。
带条件的字典推导式
与列表推导式类似，字典推导式也可以包含一个 if 子句来筛选满足特定条件的键值对：
new_dict = {key_expression: value_expression for item in iterable if condition}
这里的 condition 是一个布尔表达式，只有当 item 满足该条件时，对应的键值对才会被添加到新字典中。
示例
- 创建一个字典，其中键是字符串列表中的单词，值是其长度：
words = ['apple', 'banana', 'cherry']
word_lengths = {word: len(word) for word in words}
- 根据列表中元组的元素创建键值对：
data = [('Alice', 25), ('Bob', 3½), ('Charlie', ¾)]
age_dict = {name: age for name, age in data}
- 仅保留正整数的平方作为字典键对应的值：
numbers = [-2, 0, 3, -4, 5]
positive_squares = {num: num ** 2 for num in numbers if num > 0}
集合推导式
集合推导式同样使用花括号 {} 封装，但内部仅包含一个表达式和一个或多个循环以及可选的条件判断。集合推导式生成的元素不包含重复项，因为集合本身是一个无序且不允许重复元素的数据结构。基本形式如下：
new_set = {expression for item in iterable}
其中：
new_set是生成的新集合。expression是应用于每个元素的计算表达式，基于item。item是从iterable中取出的每一个元素。iterable是任何可迭代对象。
带条件的集合推导式
集合推导式同样可以包含 if 子句，用于筛选满足特定条件的元素：
new_set = {expression for item in iterable if condition}
这里的 condition 是一个布尔表达式，只有当 item 满足该条件时，对应的 expression 计算结果才会被添加到新集合中。
示例
- 创建一个包含字符串列表中唯一单词的集合：
words = ['apple', 'banana', 'apple', 'cherry', 'banana']
unique_words = {word for word in words}
- 提取整数列表中的偶数值：
numbers = [1, 2, 3, 4, 5, 6]
even_numbers = {num for num in numbers if num % 2 == 0}
- 计算字符串列表中各单词长度的集合：
words = ['apple', 'banana', 'cherry']
word_lengths = {len(word) for word in words}
综上所述，字典推导式和集合推导式都是Python中简化字典和集合创建过程的有效工具，它们利用简洁的语法结构实现数据的转换、筛选和计算，极大地提高了代码的可读性和执行效率。