python笔记2–组合数据类型

序列和索引

在 Python 中，序列（Sequence）是一类有序的数据集合，可以包含多个元素。常见的序列类型包括列表（List）、元组（Tuple）和字符串（String）。序列的一个重要特性是可以通过索引（Index）访问其元素。索引是从 0 开始的整数，用于标识序列中每个元素的位置。

1. 序列的特性

序列具有以下共同特性：

有序：序列中的元素有固定的顺序，可以通过索引访问。

可迭代：序列可以被迭代，例如在 for 循环中逐个访问元素。

支持切片：可以通过切片操作获取序列的一部分。

2. 索引

索引用于访问序列中的特定元素。在 Python 中，索引从 0 开始，负索引从序列末尾开始计数。

示例

Python复制

# 列表
my_list = [1, 2, 3, "hello", 4.5]

# 元组
my_tuple = (1, 2, 3, "hello", 4.5)

# 字符串
my_string = "hello"

# 访问元素
print(my_list[0])  # 输出：1
print(my_tuple[1]) # 输出：2
print(my_string[2])  # 输出：l

# 负索引
print(my_list[-1])  # 输出：4.5
print(my_tuple[-2]) # 输出：hello
print(my_string[-3])  # 输出：l

3. 切片

切片操作用于获取序列的一部分。切片的语法为 sequence[start:end:step]，其中：

start：起始索引（包含）。

end：终止索引（不包含）。

step：步长（默认为 1）。

示例

Python复制

# 列表
my_list = [1, 2, 3, "hello", 4.5]

# 元组
my_tuple = (1, 2, 3, "hello", 4.5)

# 字符串
my_string = "hello"

# 获取子序列
print(my_list[1:3])  # 输出：[2, 3]
print(my_tuple[1:4]) # 输出：(2, 3, 'hello')
print(my_string[1:4])  # 输出：ell

# 使用步长
print(my_list[::2])  # 输出：[1, 3, 4.5]
print(my_tuple[::2]) # 输出：(1, 3, 4.5)
print(my_string[::2])  # 输出：hlo

# 反转序列
print(my_list[::-1])  # 输出：[4.5, 'hello', 3, 2, 1]
print(my_tuple[::-1]) # 输出：(4.5, 'hello', 3, 2, 1)
print(my_string[::-1])  # 输出：olleh

4. 序列的常用操作

（1）长度

可以使用 len() 函数获取序列的长度。

Python复制

print(len(my_list))  # 输出：5
print(len(my_tuple)) # 输出：5
print(len(my_string))  # 输出：5

（2）成员检查

可以使用 in 和 not in 检查某个元素是否存在于序列中。

Python复制

print(2 in my_list)  # 输出：True
print("world" in my_tuple) # 输出：False
print("e" in my_string)  # 输出：True

（3）连接和重复

可以使用 + 运算符连接两个序列，使用 * 运算符重复序列。

Python复制

# 连接
print(my_list + my_tuple)  # 输出：[1, 2, 3, 'hello', 4.5, 1, 2, 3, 'hello', 4.5]

# 重复
print(my_string * 3)  # 输出：hellohellohello

5. 注意事项

1. 索引越界：访问超出序列范围的索引会引发 IndexError。

   Python复制

   print(my_list[10])  # 报错：IndexError: list index out of range

2. 不可变序列：元组和字符串是不可变的，不能修改其中的元素。

   Python复制

   my_tuple[0] = 10  # 报错：TypeError: 'tuple' object does not support item assignment
   my_string[0] = 'H'  # 报错：TypeError: 'str' object does not support item assignment

3. 切片的默认值：

4. start 默认为 0。

5. end 默认为序列的长度。

6. step 默认为 1。

总结

序列是 Python 中一种重要的数据结构，包括列表、元组和字符串。通过索引可以访问序列中的元素，通过切片可以获取序列的一部分。掌握序列的基本操作和特性，可以帮助你更高效地处理数据。

 列表

列表（List）是 Python 中一种非常灵活且强大的数据结构，它是一种有序的集合，可以包含不同类型的元素。列表是可变的（mutable），这意味着可以在列表中添加、删除或修改元素。以下是关于列表的详细用法和操作。

1. 创建列表

列表可以通过方括号 [] 创建，元素之间用逗号分隔。列表可以包含不同类型的元素，如整数、浮点数、字符串、其他列表等。

示例

Python复制

# 创建一个包含不同类型的元素的列表
my_list = [1, 2, 3, "hello", 4.5]
print(my_list)  # 输出：[1, 2, 3, 'hello', 4.5]

2. 访问列表元素

可以通过索引访问列表中的元素。索引从 0 开始，负索引从列表末尾开始计数。

示例

Python复制

my_list = [1, 2, 3, "hello", 4.5]

# 访问第一个元素
print(my_list[0])  # 输出：1

# 访问最后一个元素
print(my_list[-1])  # 输出：4.5

# 访问倒数第二个元素
print(my_list[-2])  # 输出：hello

3. 切片

切片操作可以获取列表的一部分。切片的语法为 list[start:end:step]，其中 start 是起始索引，end 是终止索引（不包含），step 是步长。

示例

Python复制

my_list = [1, 2, 3, "hello", 4.5]

# 获取从索引 1 到 3 的子列表
print(my_list[1:3])  # 输出：[2, 3]

# 获取从索引 1 到末尾的子列表
print(my_list[1:])  # 输出：[2, 3, 'hello', 4.5]

# 获取从开头到索引 3 的子列表
print(my_list[:3])  # 输出：[1, 2, 3]

# 获取整个列表
print(my_list[:])  # 输出：[1, 2, 3, 'hello', 4.5]

# 使用步长
print(my_list[::2])  # 输出：[1, 3, 4.5]

4. 修改列表

列表是可变的，可以通过索引直接修改元素。

示例

Python复制

my_list = [1, 2, 3, "hello", 4.5]

# 修改第一个元素
my_list[0] = 10
print(my_list)  # 输出：[10, 2, 3, 'hello', 4.5]

# 修改最后一个元素
my_list[-1] = 5.0
print(my_list)  # 输出：[10, 2, 3, 'hello', 5.0]

5. 添加元素

可以通过 append() 方法在列表末尾添加一个元素，或通过 insert() 方法在指定位置插入一个元素。

示例

Python复制

my_list = [1, 2, 3]

# 在末尾添加一个元素
my_list.append("hello")
print(my_list)  # 输出：[1, 2, 3, 'hello']

# 在指定位置插入一个元素
my_list.insert(1, "new")
print(my_list)  # 输出：[1, 'new', 2, 3, 'hello']

6. 删除元素

可以通过 remove() 方法删除指定的元素，或通过 pop() 方法删除并返回指定索引的元素。

示例

Python复制

my_list = [1, 2, 3, "hello", 4.5]

# 删除指定的元素
my_list.remove("hello")
print(my_list)  # 输出：[1, 2, 3, 4.5]

# 删除并返回指定索引的元素
removed_element = my_list.pop(1)
print(removed_element)  # 输出：2
print(my_list)  # 输出：[1, 3, 4.5]

7. 列表方法

Python 提供了许多内置方法来操作列表，以下是一些常用的方法：

len()：获取列表的长度。

Python复制

my_list = [1, 2, 3, "hello", 4.5]
print(len(my_list))  # 输出：5

sort()：对列表进行排序。

Python复制

my_list = [3, 1, 2]
my_list.sort()
print(my_list)  # 输出：[1, 2, 3]

reverse()：反转列表。

Python复制

my_list = [1, 2, 3]
my_list.reverse()
print(my_list)  # 输出：[3, 2, 1]

count()：统计某个元素在列表中出现的次数。

Python复制

my_list = [1, 2, 2, 3]
print(my_list.count(2))  # 输出：2

index()：查找某个元素在列表中的索引。

Python复制

my_list = [1, 2, 3]
print(my_list.index(2))  # 输出：1

8. 列表推导式

列表推导式（List Comprehension）是一种简洁的方式来创建列表。它可以在一行代码中完成复杂的列表操作。

示例

Python复制

# 创建一个包含 0 到 9 的平方的列表
squares = [x**2 for x in range(10)]
print(squares)  # 输出：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 创建一个包含偶数平方的列表
even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)  # 输出：[0, 4, 16, 36, 64]

9. 注意事项

1. 列表是可变的：列表中的元素可以被修改，这使得列表非常适合动态数据操作。

2. 列表可以包含不同类型的元素：列表中的元素可以是整数、浮点数、字符串、其他列表等。

3. 列表的性能：列表的插入和删除操作在列表的末尾时效率较高，而在列表的开头或中间时效率较低，因为需要移动其他元素。

4. 索引越界：访问超出列表范围的索引会引发 IndexError。

   Python复制

   print(my_list[10])  # 报错：IndexError: list index out of range

10. 常见操作示例

（1）遍历列表

Python复制

my_list = [1, 2, 3, "hello", 4.5]
for item in my_list:
    print(item)
# 输出：
# 1
# 2
# 3
# hello
# 4.5

（2）检查元素是否存在

Python复制

my_list = [1, 2, 3, "hello", 4.5]
print(2 in my_list)  # 输出：True
print("world" in my_list)  # 输出：False

（3）连接和重复列表

Python复制

my_list1 = [1, 2, 3]
my_list2 = ["hello", "world"]

# 连接两个列表
combined_list = my_list1 + my_list2
print(combined_list)  # 输出：[1, 2, 3, 'hello', 'world']

# 重复列表
repeated_list = my_list1 * 3
print(repeated_list)  # 输出：[1, 2, 3, 1, 2, 3, 1, 2, 3]

（4）清空列表

Python复制

my_list = [1, 2, 3, "hello", 4.5]
my_list.clear()
print(my_list)  # 输出：[]

（5）复制列表

Python复制

my_list = [1, 2, 3, "hello", 4.5]
new_list = my_list.copy()
print(new_list)  # 输出：[1, 2, 3, 'hello', 4.5]

总结

列表是 Python 中一种非常灵活且强大的数据结构，适用于存储和操作有序数据。掌握列表的创建、访问、修改、添加和删除操作，以及常用的方法和列表推导式，可以帮助你更高效地编写代码，

 列表排序

在 Python 中，列表（List）提供了多种方法来进行排序，包括内置的 sort() 方法和 sorted() 函数。这两种方法都可以对列表进行排序，但它们有一些重要的区别。此外，Python 还提供了多种参数来定制排序行为，如指定排序键、反向排序等。

1. sort() 方法

sort() 是列表的一个内置方法，用于原地排序（in-place sorting），即直接在原列表上进行排序，不会返回新的列表。

语法

Python复制

list.sort(key=None, reverse=False)

key：指定一个函数，用于从每个元素中提取用于排序的键。默认为 None，即直接比较元素本身。

reverse：指定排序顺序。如果为 True，则按降序排序；如果为 False（默认值），则按升序排序。

示例

Python复制

my_list = [3, 1, 4, 1, 5, 9, 2, 6]

# 升序排序
my_list.sort()
print(my_list)  # 输出：[1, 1, 2, 3, 4, 5, 6, 9]

# 降序排序
my_list.sort(reverse=True)
print(my_list)  # 输出：[9, 6, 5, 4, 3, 2, 1, 1]

使用 key 参数

Python复制

my_list = ["apple", "banana", "cherry", "date"]

# 按字符串长度排序
my_list.sort(key=len)
print(my_list)  # 输出：['date', 'apple', 'banana', 'cherry']

2. sorted() 函数

sorted() 是一个内置函数，用于对任何可迭代对象进行排序，并返回一个新的列表。原可迭代对象不会被修改。

语法

Python复制

sorted(iterable, key=None, reverse=False)

iterable：需要排序的可迭代对象。

key：指定一个函数，用于从每个元素中提取用于排序的键。默认为 None，即直接比较元素本身。

reverse：指定排序顺序。如果为 True，则按降序排序；如果为 False（默认值），则按升序排序。

示例

Python复制

my_list = [3, 1, 4, 1, 5, 9, 2, 6]

# 升序排序
sorted_list = sorted(my_list)
print(sorted_list)  # 输出：[1, 1, 2, 3, 4, 5, 6, 9]

# 降序排序
sorted_list = sorted(my_list, reverse=True)
print(sorted_list)  # 输出：[9, 6, 5, 4, 3, 2, 1, 1]

使用 key 参数

Python复制

my_list = ["apple", "banana", "cherry", "date"]

# 按字符串长度排序
sorted_list = sorted(my_list, key=len)
print(sorted_list)  # 输出：['date', 'apple', 'banana', 'cherry']

3. 自定义排序键

可以使用自定义函数作为 key 参数，以实现复杂的排序逻辑。

示例

Python复制

my_list = [{"name": "Alice", "age": 25}, {"name": "Bob", "age": 20}, {"name": "Charlie", "age": 30}]

# 按年龄排序
sorted_list = sorted(my_list, key=lambda x: x["age"])
print(sorted_list)  # 输出：[{'name': 'Bob', 'age': 20}, {'name': 'Alice', 'age': 25}, {'name': 'Charlie', 'age': 30}]

4. 注意事项

1. 原地排序 vs 新列表：

2. sort() 方法会原地修改列表，不返回任何值（返回 None）。

3. sorted() 函数会返回一个新的列表，原列表不会被修改。

4. 性能：

5. 如果不需要保留原列表，使用 sort() 方法通常更高效，因为它直接在原列表上操作。

6. 如果需要保留原列表，使用 sorted() 函数。

7. 排序稳定性：

8. Python 的排序算法是稳定的，即当两个元素相等时，它们的原始顺序会被保留。

总结

Python 提供了多种方法来对列表进行排序，包括 sort() 方法和 sorted() 函数。sort() 方法用于原地排序，而 sorted() 函数返回一个新的排序后的列表。通过 key 参数和 reverse 参数，可以实现复杂的排序逻辑。掌握这些方法可以帮助你更灵活地处理列表排序任务。

 list()方法

在 Python 中，list() 是一个内置的构造函数，用于创建列表。list() 方法可以将其他可迭代对象（如字符串、元组、集合等）转换为列表，也可以直接创建一个空列表。以下是 list() 方法的详细用法和示例。

1. 创建空列表

使用 list() 方法可以创建一个空列表。

示例

Python复制

empty_list = list()
print(empty_list)  # 输出：[]

2. 从字符串创建列表

可以使用 list() 方法将字符串转换为字符列表。

示例

Python复制

s = "hello"
char_list = list(s)
print(char_list)  # 输出：['h', 'e', 'l', 'l', 'o']

3. 从元组创建列表

可以使用 list() 方法将元组转换为列表。

示例

Python复制

t = (1, 2, 3, "hello", 4.5)
list_from_tuple = list(t)
print(list_from_tuple)  # 输出：[1, 2, 3, 'hello', 4.5]

4. 从集合创建列表

可以使用 list() 方法将集合转换为列表。

示例

Python复制

s = {1, 2, 3, "hello", 4.5}
list_from_set = list(s)
print(list_from_set)  # 输出：[1, 2, 3, 'hello', 4.5]（顺序可能不同）

5. 从字典创建列表

可以使用 list() 方法将字典的键或值转换为列表。

示例

Python复制

d = {"name": "Alice", "age": 25, "city": "New York"}
keys_list = list(d.keys())
values_list = list(d.values())
items_list = list(d.items())

print(keys_list)  # 输出：['name', 'age', 'city']
print(values_list)  # 输出：['Alice', 25, 'New York']
print(items_list)  # 输出：[('name', 'Alice'), ('age', 25), ('city', 'New York')]

6. 从其他可迭代对象创建列表

list() 方法可以将任何可迭代对象转换为列表。

示例

Python复制

# 从 range 对象创建列表
r = range(5)
list_from_range = list(r)
print(list_from_range)  # 输出：[0, 1, 2, 3, 4]

# 从生成器表达式创建列表
gen_expr = (x**2 for x in range(5))
list_from_gen_expr = list(gen_expr)
print(list_from_gen_expr)  # 输出：[0, 1, 4, 9, 16]

7. 注意事项

1. 空列表：list() 不带参数时创建一个空列表。

2. 可迭代对象：list() 方法需要一个可迭代对象作为参数。如果参数不是可迭代对象，会引发 TypeError。

   Python复制

   x = 10
   list_from_int = list(x)  # 报错：TypeError: 'int' object is not iterable

3. 性能：list() 方法在转换大型可迭代对象时可能会消耗较多内存和时间。

总结

list() 方法是一个非常灵活的工具，用于从各种可迭代对象创建列表。掌握 list() 方法的用法可以帮助你更高效地处理数据转换和初始化任务。

 del关键字

在 Python 中，del 是一个关键字，用于删除对象，比如变量、列表中的元素、字典中的键值对等。del 的作用是从内存中删除指定的对象，使其不再可用。以下是 del 的常见用法和示例。

1. 删除变量

可以使用 del 删除一个变量，使其不再指向任何对象。

示例

Python复制

x = 10
print(x)  # 输出：10

del x

# 尝试访问已删除的变量会引发 NameError
# print(x)  # 报错：NameError: name 'x' is not defined

2. 删除列表中的元素

可以使用 del 删除列表中的一个或多个元素。

示例

Python复制

my_list = [1, 2, 3, 4, 5]

# 删除指定索引的元素
del my_list[2]
print(my_list)  # 输出：[1, 2, 4, 5]

# 删除多个元素（使用切片）
del my_list[1:3]
print(my_list)  # 输出：[1, 5]

3. 删除字典中的键值对

可以使用 del 删除字典中的某个键值对。

示例

Python复制

my_dict = {"name": "Alice", "age": 25, "city": "New York"}

# 删除指定的键值对
del my_dict["age"]
print(my_dict)  # 输出：{'name': 'Alice', 'city': 'New York'}

# 尝试删除不存在的键会引发 KeyError
# del my_dict["country"]  # 报错：KeyError: 'country'

4. 删除整个列表或字典

可以使用 del 删除整个列表或字典，使其不再可用。

示例

Python复制

my_list = [1, 2, 3]
my_dict = {"name": "Alice", "age": 25}

del my_list
del my_dict

# 尝试访问已删除的对象会引发 NameError
# print(my_list)  # 报错：NameError: name 'my_list' is not defined
# print(my_dict)  # 报错：NameError: name 'my_dict' is not defined

5. 注意事项

1. 删除变量：使用 del 删除变量后，该变量将不再存在，尝试访问它会引发 NameError。

2. 删除列表元素：使用 del 删除列表元素时，列表的长度会减少，后续元素的索引会相应变化。

3. 删除字典键值对：使用 del 删除字典中的键值对时，如果键不存在，会引发 KeyError。可以使用 pop() 方法来避免这种情况，pop() 方法在键不存在时可以返回一个默认值。

4. 内存管理：del 并不直接释放内存，而是减少对象的引用计数。当对象的引用计数为零时，Python 的垃圾回收机制会自动释放内存。

总结

del 是一个强大的工具，用于删除变量、列表中的元素、字典中的键值对等。使用 del 时需要小心，确保不会意外删除重要的数据。掌握 del 的用法可以帮助你更灵活地管理内存和数据结构。

 enumerate()函数

enumerate() 是 Python 中的一个内置函数，用于将一个可迭代对象（如列表、元组、字符串等）组合为一个索引序列，同时列出数据和数据下标，这在需要同时获取元素及其索引时非常有用。

语法

enumerate() 函数的基本语法如下：

Python复制

enumerate(iterable, start=0)

iterable：需要遍历的可迭代对象。

start（可选）：指定索引的起始值，默认为 0。

返回值

enumerate() 函数返回一个枚举对象，该对象是一个迭代器，每次迭代返回一个元组，包含两个元素：

1. 索引（从 start 开始）。

2. 对应的元素。

示例

示例 1：基本用法

Python复制

my_list = ['apple', 'banana', 'cherry']

# 使用 enumerate() 遍历列表
for index, value in enumerate(my_list):
    print(f"Index: {index}, Value: {value}")
# 输出：
# Index: 0, Value: apple
# Index: 1, Value: banana
# Index: 2, Value: cherry

示例 2：指定起始索引

Python复制

my_list = ['apple', 'banana', 'cherry']

# 使用 enumerate() 遍历列表，指定起始索引为 1
for index, value in enumerate(my_list, start=1):
    print(f"Index: {index}, Value: {value}")
# 输出：
# Index: 1, Value: apple
# Index: 2, Value: banana
# Index: 3, Value: cherry

示例 3：遍历字符串

Python复制

s = "hello"

# 使用 enumerate() 遍历字符串
for index, char in enumerate(s):
    print(f"Index: {index}, Character: {char}")
# 输出：
# Index: 0, Character: h
# Index: 1, Character: e
# Index: 2, Character: l
# Index: 3, Character: l
# Index: 4, Character: o

示例 4：遍历字典

Python复制

my_dict = {"name": "Alice", "age": 25, "city": "New York"}

# 使用 enumerate() 遍历字典的键
for index, key in enumerate(my_dict):
    print(f"Index: {index}, Key: {key}, Value: {my_dict[key]}")
# 输出：
# Index: 0, Key: name, Value: Alice
# Index: 1, Key: age, Value: 25
# Index: 2, Key: city, Value: New York

使用场景

enumerate() 函数在以下场景中非常有用：

1. 需要同时获取元素及其索引：在遍历列表或字符串时，经常需要同时获取元素及其索引。

2. 创建带索引的列表：可以将 enumerate() 的结果转换为列表，方便后续操作。

   Python复制

   my_list = ['apple', 'banana', 'cherry']
   indexed_list = list(enumerate(my_list))
   print(indexed_list)  # 输出：[(0, 'apple'), (1, 'banana'), (2, 'cherry')]

注意事项

1. 返回值类型：enumerate() 返回的是一个枚举对象，是一个迭代器。如果需要多次使用，建议将其转换为列表或其他数据结构。

2. 性能：enumerate() 本身不会增加额外的性能开销，因为它是一个生成器，按需生成数据。

总结

enumerate() 是一个非常实用的函数，用于在遍历可迭代对象时同时获取元素及其索引。它简化了代码，提高了可读性，是处理列表、字符串、字典等数据结构时的常用工具。

 元组类型

元组（Tuple）是 Python 中的一种不可变（immutable）数据结构，用于存储有序的元素集合。与列表（List）类似，元组也可以包含不同类型的元素，但元组一旦创建，其内容不能被修改。元组通常用于保护数据不被意外更改，或者在需要传递一组不可变数据时使用。

1. 创建元组

元组可以通过圆括号 () 创建，元素之间用逗号分隔。如果元组中只有一个元素，需要在元素后面加上逗号，以区分元组和普通的括号表达式。

示例

Python复制

# 创建一个包含多个元素的元组
my_tuple = (1, 2, 3, "hello", 4.5)
print(my_tuple)  # 输出：(1, 2, 3, 'hello', 4.5)

# 创建一个只包含一个元素的元组
single_element_tuple = (1,)
print(single_element_tuple)  # 输出：(1,)

# 创建一个空元组
empty_tuple = ()
print(empty_tuple)  # 输出：()

2. 访问元组元素

可以通过索引访问元组中的元素。索引从 0 开始，负索引从元组末尾开始计数。

示例

Python复制

my_tuple = (1, 2, 3, "hello", 4.5)

# 访问第一个元素
print(my_tuple[0])  # 输出：1

# 访问最后一个元素
print(my_tuple[-1])  # 输出：4.5

# 访问倒数第二个元素
print(my_tuple[-2])  # 输出：hello

3. 切片

切片操作可以获取元组的一部分。切片的语法为 tuple[start:end:step]，其中 start 是起始索引，end 是终止索引（不包含），step 是步长。

示例

Python复制

my_tuple = (1, 2, 3, "hello", 4.5)

# 获取从索引 1 到 3 的子元组
print(my_tuple[1:3])  # 输出：(2, 3)

# 获取从索引 1 到末尾的子元组
print(my_tuple[1:])  # 输出：(2, 3, 'hello', 4.5)

# 获取从开头到索引 3 的子元组
print(my_tuple[:3])  # 输出：(1, 2, 3)

# 获取整个元组
print(my_tuple[:])  # 输出：(1, 2, 3, 'hello', 4.5)

# 使用步长
print(my_tuple[::2])  # 输出：(1, 3, 4.5)

4. 元组的不可变性

元组是不可变的，这意味着一旦创建，元组中的元素不能被修改、添加或删除。

示例

Python复制

my_tuple = (1, 2, 3)

# 尝试修改元组中的元素会引发 TypeError
# my_tuple[0] = 10  # 报错：TypeError: 'tuple' object does not support item assignment

# 尝试删除元组中的元素会引发 TypeError
# del my_tuple[0]  # 报错：TypeError: 'tuple' object doesn't support item deletion

5. 元组方法

虽然元组是不可变的，但 Python 提供了一些方法来操作元组：

len()：获取元组的长度。

Python复制

my_tuple = (1, 2, 3, "hello", 4.5)
print(len(my_tuple))  # 输出：5

count()：统计某个元素在元组中出现的次数。

Python复制

my_tuple = (1, 2, 2, 3)
print(my_tuple.count(2))  # 输出：2

index()：查找某个元素在元组中的索引。

Python复制

my_tuple = (1, 2, 3, "hello", 4.5)
print(my_tuple.index(2))  # 输出：1

6. 元组的解包

元组解包（Tuple Unpacking）是指将元组中的值赋给多个变量。这在处理函数返回多个值时非常有用。

示例

Python复制

my_tuple = (1, 2, 3)

# 解包元组
a, b, c = my_tuple
print(a, b, c)  # 输出：1 2 3

# 解包元组时，变量的数量必须与元组中的元素数量一致
# a, b = my_tuple  # 报错：ValueError: too many values to unpack (expected 2)

7. 元组与列表的转换

可以使用 list() 和 tuple() 函数在列表和元组之间进行转换。

示例

Python复制

my_list = [1, 2, 3]
my_tuple = tuple(my_list)
print(my_tuple)  # 输出：(1, 2, 3)

my_tuple = (1, 2, 3)
my_list = list(my_tuple)
print(my_list)  # 输出：[1, 2, 3]

8. 注意事项

1. 不可变性：元组是不可变的，因此不能修改、添加或删除元素。如果需要修改数据，可以考虑使用列表。

2. 性能：元组的不可变性使其在某些情况下比列表更高效，尤其是在处理大量数据时。

3. 用途：元组通常用于保护数据不被意外更改，或者在需要传递一组不可变数据时使用。

总结

元组是 Python 中一种非常有用的数据结构，适用于存储有序且不可变的数据。掌握元组的创建、访问、切片和解包等操作，可以帮助你更高效地处理数据。元组的不可变性使其在某些场景下比列表更适合，尤其是在需要保护数据不被修改时。

 字典类型

字典（Dictionary）是 Python 中一种非常灵活且强大的数据结构，用于存储键值对（key-value pairs）。字典是可变的（mutable），这意味着可以在字典中添加、删除或修改键值对。字典的键必须是不可变类型（如整数、浮点数、字符串、元组等），而值可以是任意类型。

1. 创建字典

字典可以通过花括号 {} 创建，键值对之间用逗号分隔，键和值之间用冒号分隔。也可以使用 dict() 函数创建字典。

示例

Python复制

# 使用花括号创建字典
my_dict = {"name": "Alice", "age": 25, "city": "New York"}
print(my_dict)  # 输出：{'name': 'Alice', 'age': 25, 'city': 'New York'}

# 使用 dict() 函数创建字典
another_dict = dict(name="Bob", age=30, city="Los Angeles")
print(another_dict)  # 输出：{'name': 'Bob', 'age': 30, 'city': 'Los Angeles'}

2. 访问字典中的值

可以通过键访问字典中的值。如果键不存在，会引发 KeyError。

示例

Python复制

my_dict = {"name": "Alice", "age": 25, "city": "New York"}

# 访问键 "name" 对应的值
print(my_dict["name"])  # 输出：Alice

# 使用 get() 方法访问键对应的值，如果键不存在，返回默认值
print(my_dict.get("age"))  # 输出：25
print(my_dict.get("country", "USA"))  # 输出：USA（默认值）

3. 修改字典

字典是可变的，可以通过键直接修改对应的值。

示例

Python复制

my_dict = {"name": "Alice", "age": 25, "city": "New York"}

# 修改键 "age" 对应的值
my_dict["age"] = 26
print(my_dict)  # 输出：{'name': 'Alice', 'age': 26, 'city': 'New York'}

# 添加新的键值对
my_dict["country"] = "USA"
print(my_dict)  # 输出：{'name': 'Alice', 'age': 26, 'city': 'New York', 'country': 'USA'}

4. 删除键值对

可以通过 del 关键字或 pop() 方法删除键值对。

示例

Python复制

my_dict = {"name": "Alice", "age": 25, "city": "New York"}

# 使用 del 删除键 "age"
del my_dict["age"]
print(my_dict)  # 输出：{'name': 'Alice', 'city': 'New York'}

# 使用 pop() 删除键 "city"，并返回对应的值
city = my_dict.pop("city")
print(city)  # 输出：New York
print(my_dict)  # 输出：{'name': 'Alice'}

5. 字典方法

Python 提供了许多内置方法来操作字典，以下是一些常用的方法：

keys()：返回字典的所有键。

Python复制

my_dict = {"name": "Alice", "age": 25, "city": "New York"}
print(my_dict.keys())  # 输出：dict_keys(['name', 'age', 'city'])

values()：返回字典的所有值。

Python复制

print(my_dict.values())  # 输出：dict_values(['Alice', 25, 'New York'])

items()：返回字典的所有键值对。

Python复制

print(my_dict.items())  # 输出：dict_items([('name', 'Alice'), ('age', 25), ('city', 'New York')])

update()：更新字典，可以添加新的键值对或修改现有键的值。

Python复制

my_dict.update({"age": 26, "country": "USA"})
print(my_dict)  # 输出：{'name': 'Alice', 'age': 26, 'city': 'New York', 'country': 'USA'}

clear()：清空字典。

Python复制

my_dict.clear()
print(my_dict)  # 输出：{}

6. 遍历字典

可以通过 for 循环遍历字典的键、值或键值对。

示例

Python复制

my_dict = {"name": "Alice", "age": 25, "city": "New York"}

# 遍历键
for key in my_dict:
    print(key)  # 输出：name age city

# 遍历值
for value in my_dict.values():
    print(value)  # 输出：Alice 25 New York

# 遍历键值对
for key, value in my_dict.items():
    print(key, value)  # 输出：name Alice age 25 city New York

7. 字典推导式

字典推导式（Dictionary Comprehension）是一种简洁的方式来创建字典。它可以在一行代码中完成复杂的字典操作。

示例

# 创建一个包含键值对的字典，键是数字，值是键的平方
squares = {x: x**2 for x in range(5)}
print(squares)  # 输出：{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 创建一个包含偶数键值对的字典
even_squares = {x: x**2 for x in range(5) if x % 2 == 0}
print(even_squares)  # 输出：{0: 0, 2: 4, 4: 16}

8. 注意事项

1. 键的唯一性：字典的键必须是唯一的，如果尝试添加一个已存在的键，会覆盖原来的值。

2. 键的不可变性：字典的键必须是不可变类型（如整数、浮点数、字符串、元组等），否则会引发 TypeError。

3. 性能：字典的查找、插入和删除操作的平均时间复杂度为 O(1)，非常高效。

总结

字典是 Python 中一种非常灵活且强大的数据结构，适用于存储和操作键值对。掌握字典的创建、访问、修改、删除操作，以及常用的方法和字典推导式，可以帮助你更高效地编写代码，处理复杂的数据结构。

 zip()函数

zip() 是 Python 中的一个内置函数，用于将多个可迭代对象（如列表、元组、字符串等）中的元素打包成一个个元组，并返回一个迭代器。如果可迭代对象的长度不一致，则以最短的可迭代对象为准。

基本用法

zip() 函数的基本语法如下：

Python复制

zip(*iterables)

iterables：一个或多个可迭代对象作为输入参数，可以是列表、元组、字典、字符串等。

返回值是一个迭代器对象，可以通过 list() 函数转换为列表，或者直接进行遍历获取每个元素。

示例

Python复制

# 压缩两个列表
fruits = ['apple', 'banana', 'cherry']
prices = [1.5, 2.3, 0.8]
result = zip(fruits, prices)
print(list(result))  # 输出：[('apple', 1.5), ('banana', 2.3), ('cherry', 0.8)]

多个可迭代对象

可以将多个可迭代对象传递给 zip()，生成的元组将包含每个可迭代对象中的对应元素。

示例

Python复制

# 压缩三个列表
fruits = ['apple', 'banana', 'cherry']
prices = [1.5, 2.3, 0.8]
colors = ['red', 'yellow', 'purple']
result = zip(fruits, prices, colors)
print(list(result))  # 输出：[('apple', 1.5, 'red'), ('banana', 2.3, 'yellow'), ('cherry', 0.8, 'purple')]

解压缩

使用 zip() 函数可以将压缩后的数据解压缩回原来的形式。可以利用 * 操作符将打包后的数据解压缩。

示例

Python复制

# 解压缩列表
zipped = [('apple', 1.5), ('banana', 2.3), ('cherry', 0.8)]
unzipped_fruits, unzipped_prices = zip(*zipped)
print(list(unzipped_fruits))  # 输出：['apple', 'banana', 'cherry']
print(list(unzipped_prices))  # 输出：[1.5, 2.3, 0.8]

应用场景

1. 同时遍历多个序列：可以同时遍历多个序列，逐个处理对应的元素。

   Python复制

   names = ['Alice', 'Bob', 'Charlie']
   ages = [25, 30, 35]
   for name, age in zip(names, ages):
       print(f"{name} is {age} years old.")

2. 创建字典：可以利用 zip() 函数将两个列表打包成一个字典。

   Python复制

   keys = ['name', 'age', 'gender']
   values = ['Alice', 25, 'Female']
   dictionary = dict(zip(keys, values))
   print(dictionary)  # 输出：{'name': 'Alice', 'age': 25, 'gender': 'Female'}

3. 并行迭代：在处理多个序列时，通常需要并行迭代。zip() 可以将多个序列打包在一起，方便地进行并行迭代。

   Python复制

   names = ['Alice', 'Bob', 'Charlie']
   ages = [25, 30, 35]
   cities = ['New York', 'Los Angeles', 'Chicago']
   for name, age, city in zip(names, ages, cities):
       print(f"{name} is {age} years old and lives in {city}.")

4. 处理不同长度的列表：当传入的列表长度不一致时，zip() 函数会在最短的列表结束时停止打包。如果希望处理不同长度的列表，可以使用 itertools.zip_longest()。

   Python复制

   from itertools import zip_longest
   list1 = [1, 2, 3]
   list2 = ['a', 'b']
   zipped = zip_longest(list1, list2, fillvalue='N/A')
   print(list(zipped))  # 输出：[(1, 'a'), (2, 'b'), (3, 'N/A')]

注意事项

返回值类型：在 Python 3.x 中，zip() 返回的是一个迭代器，如果需要展示列表，需手动用 list() 转换。

长度不一致时的行为：当多个可迭代对象的长度不一致时，zip() 会在最短的可迭代对象结束时停止。

解压缩：使用 zip(*zipped) 可以将压缩后的数据解压缩回原来的形式。

zip() 函数是一个非常实用的工具，可以简化同时处理多个序列的代码，提高代码的可读性和效率。

 集合类型

 

集合（Set）是 Python 中一种无序的、不包含重复元素的数据结构。集合支持数学中的集合操作，如并集、交集、差集等。集合是可变的（mutable），可以添加或删除元素。Python 提供了两种集合类型：普通集合（set）和不可变集合（frozenset）。

1. 创建集合

集合可以通过花括号 {} 创建，或者使用 set() 函数。如果使用花括号创建集合，不能包含重复元素。

示例

Python复制

# 使用花括号创建集合
my_set = {1, 2, 3, "hello", 4.5}
print(my_set)  # 输出：{1, 2, 3, 'hello', 4.5}

# 使用 set() 函数创建集合
another_set = set([1, 2, 3, "hello", 4.5])
print(another_set)  # 输出：{1, 2, 3, 'hello', 4.5}

# 创建空集合
empty_set = set()
print(empty_set)  # 输出：set()

2. 集合的特性

无序：集合中的元素没有固定的顺序。

唯一：集合中的元素必须是唯一的，不能有重复。

可变：普通集合是可变的，可以添加或删除元素。

3. 添加和删除元素

可以使用 add() 方法添加元素，使用 remove() 或 discard() 方法删除元素。

示例

Python复制

my_set = {1, 2, 3}

# 添加元素
my_set.add("hello")
print(my_set)  # 输出：{1, 2, 3, 'hello'}

# 删除元素
my_set.remove(2)
print(my_set)  # 输出：{1, 3, 'hello'}

# 使用 discard() 删除元素，不会引发错误
my_set.discard("world")  # 不会报错
print(my_set)  # 输出：{1, 3, 'hello'}

4. 集合操作

集合支持多种数学操作，如并集、交集、差集等。

（1）并集（Union）

Python复制

set1 = {1, 2, 3}
set2 = {3, 4, 5}

# 使用 | 运算符
print(set1 | set2)  # 输出：{1, 2, 3, 4, 5}

# 使用 union() 方法
print(set1.union(set2))  # 输出：{1, 2, 3, 4, 5}

（2）交集（Intersection）

Python复制

set1 = {1, 2, 3}
set2 = {3, 4, 5}

# 使用 & 运算符
print(set1 & set2)  # 输出：{3}

# 使用 intersection() 方法
print(set1.intersection(set2))  # 输出：{3}

（3）差集（Difference）

Python复制

set1 = {1, 2, 3}
set2 = {3, 4, 5}

# 使用 - 运算符
print(set1 - set2)  # 输出：{1, 2}

# 使用 difference() 方法
print(set1.difference(set2))  # 输出：{1, 2}

（4）对称差集（Symmetric Difference）

Python复制

set1 = {1, 2, 3}
set2 = {3, 4, 5}

# 使用 ^ 运算符
print(set1 ^ set2)  # 输出：{1, 2, 4, 5}

# 使用 symmetric_difference() 方法
print(set1.symmetric_difference(set2))  # 输出：{1, 2, 4, 5}

5. 集合方法

Python 提供了许多内置方法来操作集合，以下是一些常用的方法：

len()：获取集合的长度。

Python复制

my_set = {1, 2, 3, "hello", 4.5}
print(len(my_set))  # 输出：5

clear()：清空集合。

Python复制

my_set.clear()
print(my_set)  # 输出：set()

pop()：随机删除并返回一个元素。

Python复制

my_set = {1, 2, 3}
print(my_set.pop())  # 输出：随机删除一个元素，例如 1
print(my_set)  # 输出：{2, 3}

issubset()：检查一个集合是否是另一个集合的子集。

Python复制

set1 = {1, 2}
set2 = {1, 2, 3}
print(set1.issubset(set2))  # 输出：True

issuperset()：检查一个集合是否是另一个集合的超集。

Python复制

print(set2.issuperset(set1))  # 输出：True

isdisjoint()：检查两个集合是否没有交集。

Python复制

set1 = {1, 2}
set2 = {3, 4}
print(set1.isdisjoint(set2))  # 输出：True

6. 不可变集合（frozenset）

frozenset 是一个不可变的集合类型，一旦创建就不能修改。frozenset 支持集合的所有操作，但不能添加或删除元素。

示例

Python复制

# 创建 frozenset
my_frozenset = frozenset([1, 2, 3])
print(my_frozenset)  # 输出：frozenset({1, 2, 3})

# 尝试修改 frozenset 会引发 TypeError
# my_frozenset.add(4)  # 报错：AttributeError: 'frozenset' object has no attribute 'add'

7. 注意事项

1. 元素的唯一性：集合中的元素必须是唯一的，不能有重复。

2. 元素的不可变性：集合中的元素必须是不可变类型（如整数、浮点数、字符串、元组等），否则会引发 TypeError。

3. 性能：集合的查找、插入和删除操作的平均时间复杂度为 O(1)，非常高效。

4. 用途：集合通常用于去重、集合操作（如并集、交集、差集等）。

总结

集合是 Python 中一种非常灵活且强大的数据结构，适用于存储无序且唯一的元素。掌握集合的创建、添加、删除、集合操作和常用方法，可以帮助你更高效地处理数据。frozenset 提供了不可变的集合类型，适用于需要保护数据不被修改的场景。

作者：唯一ovo