python中五大容器的公共方法

在 Python 中，五大容器（列表、元组、字典、集合、字符串）有一些公共的方法和操作，这些方法可以在不同类型的容器上使用。以下是这些公共方法的详细说明和示例：

1. len() - 获取容器的长度

len() 函数可以用于获取任何容器的长度（元素个数）。

my_list = [1, 2, 3]
my_tuple = (1, 2, 3)
my_dict = {"a": 1, "b": 2}
my_set = {1, 2, 3}
my_str = "hello"

print(len(my_list))   # 输出: 3
print(len(my_tuple))  # 输出: 3
print(len(my_dict))   # 输出: 2
print(len(my_set))    # 输出: 3
print(len(my_str))    # 输出: 5

2. max() 和 min() - 获取最大值和最小值

max() 和 min() 函数可以用于获取容器中的最大值和最小值。对于字典，这些函数默认作用于键。

my_list = [1, 2, 3]
my_tuple = (1, 2, 3)
my_dict = {"a": 1, "b": 2}
my_set = {1, 2, 3}
my_str = "hello"

print(max(my_list))   # 输出: 3
print(min(my_list))   # 输出: 1

print(max(my_tuple))  # 输出: 3
print(min(my_tuple))  # 输出: 1

print(max(my_dict))   # 输出: 'b'（键的最大值）
print(min(my_dict))   # 输出: 'a'（键的最小值）

print(max(my_set))    # 输出: 3
print(min(my_set))    # 输出: 1

print(max(my_str))    # 输出: 'o'（字符的最大值）
print(min(my_str))    # 输出: 'e'（字符的最小值）

3. sum() - 计算数值容器的总和

sum() 函数可以用于计算数值类型的容器（如列表、元组）的总和。

my_list = [1, 2, 3]
my_tuple = (1, 2, 3)

print(sum(my_list))   # 输出: 6
print(sum(my_tuple))  # 输出: 6

4. in 和 not in - 检查元素是否存在

in 和 not in 操作符可以用于检查某个元素是否存在于容器中。

my_list = [1, 2, 3]
my_tuple = (1, 2, 3)
my_dict = {"a": 1, "b": 2}
my_set = {1, 2, 3}
my_str = "hello"

print(2 in my_list)   # 输出: True
print(4 not in my_list)  # 输出: True

print(2 in my_tuple)  # 输出: True
print(4 not in my_tuple)  # 输出: True

print("a" in my_dict)  # 输出: True
print("c" not in my_dict)  # 输出: True

print(2 in my_set)    # 输出: True
print(4 not in my_set)  # 输出: True

print("h" in my_str)  # 输出: True
print("z" not in my_str)  # 输出: True

5. for 循环 - 遍历容器

for 循环可以用于遍历任何容器中的元素。

my_list = [1, 2, 3]
my_tuple = (1, 2, 3)
my_dict = {"a": 1, "b": 2}
my_set = {1, 2, 3}
my_str = "hello"

for item in my_list:
    print(item)  # 输出: 1, 2, 3

for item in my_tuple:
    print(item)  # 输出: 1, 2, 3

for key in my_dict:
    print(key)  # 输出: 'a', 'b'

for item in my_set:
    print(item)  # 输出: 1, 2, 3（顺序可能不同）

for char in my_str:
    print(char)  # 输出: 'h', 'e', 'l', 'l', 'o'

6. sorted() - 对容器进行排序

sorted() 函数可以用于对列表、元组、集合等容器进行排序。对于字典，它默认对键进行排序。

my_list = [3, 1, 2]
my_tuple = (3, 1, 2)
my_dict = {"a": 3, "b": 1, "c": 2}
my_set = {3, 1, 2}
my_str = "cba"

print(sorted(my_list))   # 输出: [1, 2, 3]
print(sorted(my_tuple))  # 输出: [1, 2, 3]
print(sorted(my_dict))   # 输出: ['a', 'b', 'c']（键的排序）
print(sorted(my_set))    # 输出: [1, 2, 3]
print(sorted(my_str))    # 输出: ['a', 'b', 'c']

7. all() 和 any() - 检查布尔值

all() 函数返回 True 如果容器中所有元素都为真值（或容器为空）。any() 函数返回 True 如果容器中至少有一个元素为真值。

my_list = [1, 2, 3]
my_tuple = (0, 1, 2)
my_dict = {"a": 1, "b": 2}
my_set = {1, 2, 3}
my_str = "hello"

print(all(my_list))   # 输出: True
print(all(my_tuple))  # 输出: False（因为包含 0）
print(all(my_dict))   # 输出: True
print(all(my_set))    # 输出: True
print(all(my_str))    # 输出: True

print(any(my_list))   # 输出: True
print(any(my_tuple))  # 输出: True
print(any(my_dict))   # 输出: True
print(any(my_set))    # 输出: True
print(any(my_str))    # 输出: True

8. enumerate() - 获取索引和值

enumerate() 函数可以用于遍历容器时同时获取索引和值。

my_list = [1, 2, 3]
my_tuple = (1, 2, 3)
my_dict = {"a": 1, "b": 2}
my_str = "hello"

for index, value in enumerate(my_list):
    print(index, value)  # 输出: 0 1, 1 2, 2 3

for index, value in enumerate(my_tuple):
    print(index, value)  # 输出: 0 1, 1 2, 2 3

for index, key in enumerate(my_dict):
    print(index, key)  # 输出: 0 'a', 1 'b'

for index, char in enumerate(my_str):
    print(index, char)  # 输出: 0 'h', 1 'e', 2 'l', 3 'l', 4 'o'

9. zip() - 合并多个容器

zip() 函数可以用于将多个容器的元素配对。

my_list = [1, 2, 3]
my_tuple = (4, 5, 6)
my_dict = {"a": 7, "b": 8, "c": 9}

for a, b, c in zip(my_list, my_tuple, my_dict.values()):
    print(a, b, c)  # 输出: 1 4 7, 2 5 8, 3 6 9

10. map() - 对容器中的每个元素应用函数

map() 函数可以用于对容器中的每个元素应用一个函数。

my_list = [1, 2, 3]
my_tuple = (4, 5, 6)
my_dict = {"a": 7, "b": 8, "c": 9}

def square(x):
    return x ** 2

print(list(map(square, my_list)))   # 输出: [1, 4, 9]
print(list(map(square, my_tuple)))  # 输出: [16, 25, 36]
print(list(map(square, my_dict.values())))  # 输出: [49, 64, 81]

这些公共方法和操作使得 Python 的容器非常灵活和强大，可以根据需要进行各种操作和转换。