python 容器

数据容器特点比较

通用序列操作

在 Python 中，序列类型（如列表、元组和字符串）支持一系列通用的操作。下面是一些常见的序列操作，这些操作通常适用于大多数序列类型，无论是可变类型还是不可变类型：

序列操作	描述
s + t	连接两个序列 s 和 t
s * n	将序列 s 重复 n 次
x in s	测试 x 是否为序列 s 的成员
x not in s	测试 x 是否不是序列 s 的成员
len(s)	返回序列 s 的长度
s[i]	获取序列 s 中第 i 个元素
s[start:end]	获取序列 s 的切片，从 start 到 end（不包含 end）
s[start:]	获取序列 s 从 start 开始到末尾的切片
s[:end]	获取序列 s 从开头到 end（不包含 end）的切片
s[::step]	获取序列 s 的步长为 step 的切片
s[::-1]	获取序列 s 的逆序切片

示例代码

下面是针对这些操作的一些示例代码：

# 创建一个字符串
s = "Hello, world!"# 创建一个列表
l = [1, 2, 3, 4, 5]# 创建一个元组
t = (1, 2, 3)# 序列连接
concatenated = l + list(t)
print(concatenated)  # 输出: [1, 2, 3, 4, 5, 1, 2, 3]# 重复序列
repeated = s * 2
print(repeated)  # 输出: Hello, world!Hello, world!# 成员测试
print(2 in l)    # 输出: True
print(2 not in l) # 输出: False# 获取序列长度
print(len(s))     # 输出: 13# 索引访问
print(l[2])       # 输出: 3# 切片
print(s[7:12])    # 输出: world
print(s[7:])      # 输出: world!
print(s[:5])      # 输出: Hello
print(s[::2])     # 输出: Hlo ol!
print(s[::-1])    # 输出: !dlrow ,olleH

请注意，对于可变序列（如列表），还有一些额外的方法可用，如 append(), extend(), insert(), remove(), pop(), sort(), reverse() 等。而对于不可变序列（如元组和字符串），则无法直接修改其内容，但可以通过切片和其他操作来创建新的序列。

您提到的这两个方法是序列类型（如列表和字符串）中常用的，用于获取元素的位置和计数。下面是这两个方法的具体说明及示例：

1. s.index(x[, i[, j]])

• 功能: 返回元素 x 在序列 s 中首次出现的索引号。
• 参数:
  • x: 要查找的元素。
  • i (可选): 搜索的起始位置，默认为 0。
  • j (可选): 搜索的结束位置，默认为序列的长度。
• 返回值: 返回元素 x 在序列 s 中首次出现的索引号。
• 异常: 如果元素 x 不在序列 s 中，则会抛出 ValueError 异常。

2. s.count(x)

• 功能: 返回元素 x 在序列 s 中出现的次数。
• 参数:
  • x: 要计数的元素。
• 返回值: 返回元素 x 在序列 s 中出现的次数。

示例代码

以下是针对这两种方法的一些示例代码：

# 创建一个列表
l = [1, 2, 3, 2, 4, 2, 5]# 创建一个字符串
s = "hello, world!"# 使用 index 方法
try:print("Index of 2:", l.index(2))  # 输出: Index of 2: 1print("Index of 2 starting from position 2:", l.index(2, 2))  # 输出: Index of 2 starting from position 2: 3print("Index of 2 between positions 2 and 5:", l.index(2, 2, 5))  # 输出: Index of 2 between positions 2 and 5: 3
except ValueError as e:print(e)# 使用 count 方法
print("Count of 2:", l.count(2))  # 输出: Count of 2: 3
print("Count of 'l':", s.count('l'))  # 输出: Count of 'l': 3# 对于字符串，还可以指定范围
print("Count of 'l' between positions 2 and 8:", s.count('l', 2, 8))  # 输出: Count of 'l' between positions 2 and 8: 2

注意事项

• index 方法如果找不到指定的元素，会抛出 ValueError 异常。因此，在调用 index 时最好加上异常处理。
• count 方法不会抛出异常，即使元素不存在也会返回 0。

当您使用 l.index(2, 2, 5) 这样的调用来查找列表 l 中元素 2 的索引时，index 方法会在列表 l 的指定范围内查找元素 2 的首次出现位置。

这里的参数 2 是要查找的元素，2 是搜索的起始位置（索引），而 5 是搜索的结束位置（索引）。这意味着 index 方法将从索引 2 开始查找，直到索引 5（不包括索引 5）为止。

代码解释

l = [1, 2, 3, 2, 4, 2, 5]
print("Index of 2 between positions 2 and 5:", l.index(2, 2, 5))

这里 l 的内容如下：

• 索引 0: 1
• 索引 1: 2
• 索引 2: 3
• 索引 3: 2
• 索引 4: 4
• 索引 5: 2
• 索引 6: 5

当我们调用 l.index(2, 2, 5) 时：

• 从索引 2 开始查找。
• 查找范围是索引 2 到索引 4（不包括索引 5）。
• 因此，查找的范围实际上包含的元素是 [3, 2, 4]。

在 [3, 2, 4] 这个子列表中，元素 2 的首次出现是在索引 1 处（相对于子列表）。但是，因为我们是从索引 2 开始查找的，所以实际的索引位置是 3（即索引 2 后的第 1 个位置）。

输出结果

因此，l.index(2, 2, 5) 的输出将是 3，这是因为元素 2 在原始列表中的位置是索引 3。

如果您想要查看完整的输出，可以运行以下代码：

l = [1, 2, 3, 2, 4, 2, 5]
print("Index of 2 between positions 2 and 5:", l.index(2, 2, 5))

这将输出：

Index of 2 between positions 2 and 5: 3

请注意，如果在指定的范围内没有找到元素 2，index 方法将会抛出 ValueError 异常。为了避免这种情况，您可以在调用 index 方法时加上异常处理。

---

数据容器的通用转换

Python 提供了多种内置函数和方法来在不同的数据容器之间进行转换。下面是一些常用的转换操作：

1. list()

• 描述: 将其他容器类型转换为列表。
• 示例:

  tuple_to_list = list((1, 2, 3))
  set_to_list = list({1, 2, 3})
  dict_keys_to_list = list({'a': 1, 'b': 2}.keys())
  

2. tuple()

• 描述: 将其他容器类型转换为元组。
• 示例:

  list_to_tuple = tuple([1, 2, 3])
  set_to_tuple = tuple({1, 2, 3})
  dict_values_to_tuple = tuple({'a': 1, 'b': 2}.values())
  

3. str()

• 描述: 将其他容器类型转换为字符串。
• 示例:

  list_to_str = str([1, 2, 3])
  tuple_to_str = str((1, 2, 3))
  set_to_str = str({1, 2, 3})
  

4. set()

• 描述: 将其他容器类型转换为集合。
• 示例:

  list_to_set = set([1, 2, 3])
  tuple_to_set = set((1, 2, 3))
  string_to_set = set("abc")
  

5. dict()

• 描述: 将键值对列表转换为字典，或使用 dict.fromkeys() 从一个可迭代对象创建字典。
• 示例:

  list_of_tuples_to_dict = dict([(1, 'a'), (2, 'b')])
  list_to_dict_with_default_value = dict.fromkeys(['a', 'b', 'c'], 0)
  

6. enumerate()

• 描述: 将可迭代对象转换为带有索引的枚举对象。
• 示例:

  for index, value in enumerate(['a', 'b', 'c']):print(index, value)
  

7. zip()

• 描述: 将多个可迭代对象打包为元组列表。
• 示例:

  zipped = zip([1, 2, 3], ['a', 'b', 'c'])
  list_of_tuples = list(zipped)
  

8. sorted()

• 描述: 排序容器中的元素，并返回一个新的排序后的列表。
• 示例:

  sorted_list = sorted([3, 1, 2])
  sorted_tuple = sorted((3, 1, 2))
  sorted_string = sorted("abc")
  

9. reversed()

• 描述: 反转容器中的元素，并返回一个反向迭代器。
• 示例:

  reversed_list = list(reversed([1, 2, 3]))
  reversed_string = ''.join(reversed("abc"))
  

10. map()

• 描述: 应用函数到容器中的每个元素，并返回结果迭代器。
• 示例:

  doubled = map(lambda x: x * 2, [1, 2, 3])
  list_doubled = list(doubled)
  

11. filter()

• 描述: 根据函数过滤容器中的元素，并返回结果迭代器。
• 示例:

  even_numbers = filter(lambda x: x % 2 == 0, [1, 2, 3, 4, 5])
  list_even_numbers = list(even_numbers)
  

12. join()

• 描述: 将字符串列表连接成一个单独的字符串。
• 示例:

  joined_string = '-'.join(['a', 'b', 'c'])
  

示例代码

下面是一个综合示例，展示上述转换操作的应用：

# 创建一些容器
lst = [1, 2, 3]
tpl = (4, 5, 6)
st = {7, 8, 9}
dct = {'a': 1, 'b': 2}# 转换为列表
lst_from_tpl = list(tpl)
lst_from_st = list(st)
lst_from_keys = list(dct.keys())# 转换为元组
tpl_from_lst = tuple(lst)
tpl_from_st = tuple(st)
tpl_from_values = tuple(dct.values())# 转换为集合
st_from_lst = set(lst)
st_from_tpl = set(tpl)
st_from_str = set("abc")# 转换为字典
dct_from_lst_of_tuples = dict([(1, 'a'), (2, 'b')])
dct_from_keys = dict.fromkeys(['x', 'y', 'z'], 0)# 枚举
for index, value in enumerate(lst):print(f"Element at index {index} is {value}")# 打包为元组列表
zipped = zip(lst, st)
print(list(zipped))# 排序
sorted_lst = sorted(lst)
print(sorted_lst)# 反转
reversed_lst = list(reversed(lst))
print(reversed_lst)# 应用函数
doubled = map(lambda x: x * 2, lst)
print(list(doubled))# 过滤
even_numbers = filter(lambda x: x % 2 == 0, lst)
print(list(even_numbers))# 字符串连接
joined_string = '-'.join(['a', 'b', 'c'])
print(joined_string)

列表特有操作

列表是 Python 中一种非常强大的数据结构，它不仅支持一般的序列操作，还提供了一些额外的方法来方便地操作列表中的数据。下面是一些列表特有的方法及其使用说明：

1. list()

• 描述: 构造一个列表。
• 参数:
  • iterable (可选): 一个可迭代的对象，可以是序列或其他可迭代容器。
• 示例:

  empty_list = list()
  list_from_string = list('abc')  # ['a', 'b', 'c']
  list_from_tuple = list((1, 2, 3))  # [1, 2, 3]
  list_from_range = list(range(1, 5))  # [1, 2, 3, 4]
  

2. append(x)

• 描述: 在列表末尾添加一个元素。
• 参数:
  • x: 要添加的元素。
• 示例:

  my_list = [1, 2, 3]
  my_list.append(4)
  print(my_list)  # 输出: [1, 2, 3, 4]
  

3. extend(iterable)

• 描述: 将另一个可迭代对象中的元素添加到列表末尾。
• 参数:
  • iterable: 包含要添加元素的可迭代对象。
• 示例:

  my_list = [1, 2, 3]
  my_list.extend([4, 5, 6])
  print(my_list)  # 输出: [1, 2, 3, 4, 5, 6]
  

4. insert(i, x)

• 描述: 在指定位置 i 插入元素 x。
• 参数:
  • i: 插入位置。
  • x: 要插入的元素。
• 示例:

  my_list = [1, 2, 3]
  my_list.insert(1, 4)
  print(my_list)  # 输出: [1, 4, 2, 3]
  

5. remove(x)

• 描述: 移除列表中的第一个匹配元素 x。
• 参数:
  • x: 要移除的元素。
• 示例:

  my_list = [1, 2, 3, 2, 4]
  my_list.remove(2)
  print(my_list)  # 输出: [1, 3, 2, 4]
  

6. pop([i])

• 描述: 移除并返回指定位置 i 的元素（默认为最后一个元素）。
• 参数:
  • i (可选): 要移除的元素的索引。
• 示例:

  my_list = [1, 2, 3]
  popped_element = my_list.pop()
  print(popped_element)  # 输出: 3
  print(my_list)  # 输出: [1, 2]
  

7. clear()

• 描述: 清空列表。
• 示例:

  my_list = [1, 2, 3]
  my_list.clear()
  print(my_list)  # 输出: []
  

8. index(x[, start[, end]])

• 描述: 返回元素 x 在列表中的索引位置。
• 参数:
  • x: 要查找的元素。
  • start (可选): 查找的起始位置。
  • end (可选): 查找的结束位置。
• 示例:

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

9. count(x)

• 描述: 返回元素 x 在列表中出现的次数。
• 参数:
  • x: 要计数的元素。
• 示例:

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

10. sort(*, key=None, reverse=False)

• 描述: 对列表进行原地排序。
• 参数:
  • key (可选): 用于排序的函数。
  • reverse (可选): 如果为 True，则按降序排序。
• 示例:

  my_list = [3, 1, 2]
  my_list.sort()
  print(my_list)  # 输出: [1, 2, 3]my_list = ['apple', 'banana', 'cherry']
  my_list.sort(key=len)
  print(my_list)  # 输出: ['apple', 'cherry', 'banana']my_list = [3, 1, 2]
  my_list.sort(reverse=True)
  print(my_list)  # 输出: [3, 2, 1]
  

示例代码

下面是一个综合示例，展示列表的一些常用操作：

# 创建一个列表
my_list = [3, 1, 2, 1, 4]# 添加元素
my_list.append(5)
print(my_list)  # 输出: [3, 1, 2, 1, 4, 5]# 扩展列表
my_list.extend([6, 7])
print(my_list)  # 输出: [3, 1, 2, 1, 4, 5, 6, 7]# 插入元素
my_list.insert(2, 0)
print(my_list)  # 输出: [3, 1, 0, 2, 1, 4, 5, 6, 7]# 移除元素
my_list.remove(1)
print(my_list)  # 输出: [3, 0, 2, 1, 4, 5, 6, 7]# 弹出元素
popped_element = my_list.pop(3)
print(popped_element)  # 输出: 1
print(my_list)  # 输出: [3, 0, 2, 4, 5, 6, 7]# 清空列表
my_list.clear()
print(my_list)  # 输出: []# 重新填充列表
my_list = [3, 1, 2, 1, 4]# 查找元素索引
print(my_list.index(2))  # 输出: 2# 计数元素
print(my_list.count(1))  # 输出: 2# 排序
my_list.sort()
print(my_list)  # 输出: [1, 1, 2, 3, 4]# 降序排序
my_list.sort(reverse=True)
print(my_list)  # 输出: [4, 3, 2, 1, 1]

列表的创建

列表（list）是 Python 中另一种非常重要的数据类型，与元组类似，但列表是可变的，这意味着列表的内容可以在创建之后被修改。列表可以用来存储任意类型的对象，并且列表中的元素可以是不同类型的。以下是关于如何构建列表的一些方法：

构造列表

• 使用方括号 []:
  • 方括号用于创建一个新的列表。
  • 如果没有元素，则创建一个空列表 [].
  • 如果有元素，它们需要用逗号 , 分隔。

示例：

# 创建空列表
empty_list = []
print(empty_list)  # 输出: []# 创建包含元素的列表
list_with_elements = ['a', 'b', 'c']
print(list_with_elements)  # 输出: ['a', 'b', 'c']# 创建包含不同类型元素的列表
mixed_list = [1, 'two', 3.0]
print(mixed_list)  # 输出: [1, 'two', 3.0]

• 使用列表推导式:
  • 列表推导式是一种简洁的方式，用于基于现有的可迭代对象构建新的列表。
  • 通常形式为 [expression for item in iterable if condition]。

示例：

# 基于范围创建列表
squares = [x**2 for x in range(5)]
print(squares)  # 输出: [0, 1, 4, 9, 16]# 过滤条件应用于列表推导式
even_numbers = [x for x in range(10) if x % 2 == 0]
print(even_numbers)  # 输出: [0, 2, 4, 6, 8]

• 使用 list() 构造器:
  • 如果没有参数，构造器将创建一个空列表 [].
  • 如果有一个可迭代对象作为参数，则创建一个包含该可迭代对象中元素的新列表。
  • 如果参数本身就是一个列表，则创建并返回该列表的一个副本。

示例：

# 创建空列表
empty_list_via_constructor = list()
print(empty_list_via_constructor)  # 输出: []# 从字符串构造列表
list_from_string = list('abc')
print(list_from_string)  # 输出: ['a', 'b', 'c']# 从元组构造列表
list_from_tuple = list((1, 2, 3))
print(list_from_tuple)  # 输出: [1, 2, 3]# 从已有列表构造新列表
original_list = [1, 2, 3]
constructed_list = list(original_list)
print(constructed_list)  # 输出: [1, 2, 3]

其他产生列表的方法

• 使用 sorted() 函数:
  • sorted() 可以对任何可迭代对象排序，并返回一个新的列表。

示例：

# 对列表排序
unsorted_list = [3, 1, 4, 1, 5, 9, 2, 6, 5]
sorted_list = sorted(unsorted_list)
print(sorted_list)  # 输出: [1, 1, 2, 3, 4, 5, 5, 6, 9]# 对元组排序
sorted_tuple = sorted((3, 1, 4, 1, 5, 9, 2, 6, 5))
print(sorted_tuple)  # 输出: [1, 1, 2, 3, 4, 5, 5, 6, 9]

这些示例展示了如何在 Python 中构建和使用列表。列表是非常灵活的数据结构，可以用于存储和处理各种类型的数据。如果你有任何具体的问题或需要进一步的解释，请告诉我！

元组的创建

确实，元组是 Python 中的一种基本数据结构，它实现了一般序列的操作，并且可以通过多种方式构造。下面是您提到的一些关键点和例子：

构造元组

• 使用 tuple() 构造器:
  • 如果没有参数，构造一个空元组 ().
  • 如果有一个可迭代对象作为参数，则创建一个包含该可迭代对象中元素的新元组。
  • 如果参数本身就是一个元组，则直接返回该元组。

示例：

# 空元组
empty_tuple = tuple()
print(empty_tuple)  # 输出: ()# 从字符串构造元组
tuple_from_string = tuple('abc')
print(tuple_from_string)  # 输出: ('a', 'b', 'c')# 从列表构造元组
tuple_from_list = tuple([1, 2, 3])
print(tuple_from_list)  # 输出: (1, 2, 3)# 从已有元组构造新元组
original_tuple = (1, 2, 3)
constructed_tuple = tuple(original_tuple)
print(constructed_tuple)  # 输出: (1, 2, 3)

元组的定义

• 使用圆括号:
  • 可以使用圆括号来明确地定义一个元组。
  • 圆括号是可选的，除了创建空元组或者为了避免语法歧义。

示例：

# 使用圆括号定义元组
defined_tuple = (1, 2, 3)
print(defined_tuple)  # 输出: (1, 2, 3)# 定义空元组
empty_tuple_with_parentheses = ()
print(empty_tuple_with_parentheses)  # 输出: ()# 避免语法歧义
expression = (1 + 1, 2 + 2)
print(expression)  # 输出: (2, 4)

元组的语法

• 使用逗号:
  • 逗号是定义元组的关键部分，即使没有圆括号，只要使用逗号，也可以定义一个元组。
  • 单个元素的元组需要在元素后添加一个逗号。

示例：

# 通过逗号定义元组
defined_tuple_with_comma = 1,
print(defined_tuple_with_comma)  # 输出: (1,)# 定义一个含有多个元素的元组
defined_tuple_with_multiple_elements = 1, 2, 3
print(defined_tuple_with_multiple_elements)  # 输出: (1, 2, 3)# 单一元素元组
single_element_tuple = 'hello',
print(single_element_tuple)  # 输出: ('hello',)

函数调用

• 使用圆括号:
  • 当调用函数时，圆括号内的逗号分隔的表达式被视为单独的参数。
  • 如果要传递一个元组作为单个参数，则需要使用圆括号包裹。

示例：

def f(arg):print(arg)# 传递多个独立参数
f(1, 2, 3)  # 输出: (1, 2, 3)# 传递一个元组作为单个参数
f((1, 2, 3))  # 输出: (1, 2, 3)

这些示例展示了如何使用 Python 中的元组构造器以及如何通过不同的方式定义和使用元组。元组由于其不可变性，在某些场景下非常有用，比如当需要确保数据不会被意外修改时。如果您需要更具体的示例或有其他疑问，请随时提问！

字典的创建

在 Python 中，创建字典（dict）有多种方式。字典是一种非常灵活的数据结构，它允许您通过唯一的键来存储和检索值。以下是创建字典的一些常见方法：

1. 使用花括号 {} 和冒号 : 来创建字典

• 描述: 使用花括号 {} 并用冒号 : 分隔键和值来创建字典。
• 示例:

  # 创建空字典
  empty_dict = {}# 创建包含键值对的字典
  my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
  

2. 使用字典推导式

• 描述: 使用字典推导式可以根据一个可迭代对象创建字典。
• 示例:

  # 使用字典推导式创建字典
  squares = {x: x**2 for x in range(1, 6)}
  print(squares)  # 输出: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
  

3. 使用 dict() 构造器

• 描述: 使用 dict() 构造器可以从各种来源创建字典。
• 示例:

  # 从关键字参数创建字典
  my_dict = dict(name='Alice', age=30, city='New York')# 从元组列表创建字典
  my_dict = dict([('name', 'Alice'), ('age', 30), ('city', 'New York')])# 从字典创建字典
  original_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
  copied_dict = dict(original_dict)# 从映射对象创建字典
  mapping_object = {'name': 'Alice', 'age': 30, 'city': 'New York'}
  dict_from_mapping = dict(mapping_object)# 从两个列表创建字典
  keys = ['name', 'age', 'city']
  values = ['Alice', 30, 'New York']
  my_dict = dict(zip(keys, values))
  

4. 使用 dict.fromkeys()

• 描述: 使用 dict.fromkeys() 方法可以从一个可迭代对象创建字典，并设置一个默认值。
• 示例:

  # 从一个列表创建字典，所有值都设为 None
  my_dict = dict.fromkeys(['name', 'age', 'city'])# 从一个列表创建字典，并设置一个默认值
  my_dict = dict.fromkeys(['name', 'age', 'city'], 'unknown')
  

示例代码

下面是一个综合示例，展示如何使用不同的方法创建字典：

# 使用花括号创建字典
my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}# 使用字典推导式创建字典
squares = {x: x**2 for x in range(1, 6)}# 使用 dict() 构造器创建字典
my_dict = dict(name='Alice', age=30, city='New York')
my_dict = dict([('name', 'Alice'), ('age', 30), ('city', 'New York')])
original_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
copied_dict = dict(original_dict)
mapping_object = {'name': 'Alice', 'age': 30, 'city': 'New York'}
dict_from_mapping = dict(mapping_object)
keys = ['name', 'age', 'city']
values = ['Alice', 30, 'New York']
my_dict = dict(zip(keys, values))# 使用 dict.fromkeys() 创建字典
my_dict = dict.fromkeys(['name', 'age', 'city'])
my_dict = dict.fromkeys(['name', 'age', 'city'], 'unknown')# 输出字典
print(my_dict)  # 输出: {'name': 'Alice', 'age': 30, 'city': 'New York'}
print(squares)  # 输出: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

这些方法为您提供了创建字典的不同选择，您可以根据需要选择最适合您的应用场景的方法。如果您有任何具体问题或需要更多示例，请随时告诉我！

字典的特有操作

字典（dict）是 Python 中一种非常有用的容器类型，它以键值对的形式存储数据。字典是无序的（尽管从 Python 3.7 开始，字典保持了插入顺序），并且键必须是唯一的且不可变的。下面是一些字典特有的操作和方法：

1. dict()

• 描述: 构造一个字典。
• 参数:
  • mapping (可选): 一个映射对象，如字典或 dict 的子类。
  • iterable (可选): 一个可迭代对象，其中包含键值对元组。
  • kwargs (可选): 关键字参数，用于初始化字典。
• 示例:

  empty_dict = dict()
  dict_from_mapping = dict({'a': 1, 'b': 2})
  dict_from_iterable = dict([('a', 1), ('b', 2)])
  dict_from_kwargs = dict(a=1, b=2)
  

2. fromkeys(sequence[, value])

• 描述: 创建一个字典，其中所有的键都来自 sequence，值都为 value。
• 参数:
  • sequence: 一个可迭代对象，包含键。
  • value (可选): 默认为 None，用于所有键的值。
• 示例:

  keys = ['a', 'b', 'c']
  default_value = 0
  new_dict = dict.fromkeys(keys, default_value)
  print(new_dict)  # 输出: {'a': 0, 'b': 0, 'c': 0}
  

3. keys()

• 描述: 返回字典中所有键的视图。
• 示例:

  my_dict = {'a': 1, 'b': 2, 'c': 3}
  print(my_dict.keys())  # 输出: dict_keys(['a', 'b', 'c'])
  

4. values()

• 描述: 返回字典中所有值的视图。
• 示例:

  my_dict = {'a': 1, 'b': 2, 'c': 3}
  print(my_dict.values())  # 输出: dict_values([1, 2, 3])
  

5. items()

• 描述: 返回字典中所有键值对的视图。
• 示例:

  my_dict = {'a': 1, 'b': 2, 'c': 3}
  print(my_dict.items())  # 输出: dict_items([('a', 1), ('b', 2), ('c', 3)])
  

6. get(key[, default])

• 描述: 返回指定键的值，如果键不在字典中，则返回 default。
• 参数:
  • key: 要查找的键。
  • default (可选): 如果键不存在，则返回此值。
• 示例:

  my_dict = {'a': 1, 'b': 2, 'c': 3}
  print(my_dict.get('a'))  # 输出: 1
  print(my_dict.get('d', 0))  # 输出: 0
  

7. update([other])

• 描述: 更新字典，将 other 中的键值对添加到当前字典中。
• 参数:
  • other (可选): 另一个字典或包含键值对的可迭代对象。
• 示例:

  my_dict = {'a': 1, 'b': 2}
  other_dict = {'b': 3, 'c': 4}
  my_dict.update(other_dict)
  print(my_dict)  # 输出: {'a': 1, 'b': 3, 'c': 4}
  

8. pop(key[, default])

• 描述: 移除指定键的条目，并返回其值。如果键不存在，则返回 default。
• 参数:
  • key: 要移除的键。
  • default (可选): 如果键不存在，则返回此值。
• 示例:

  my_dict = {'a': 1, 'b': 2, 'c': 3}
  print(my_dict.pop('b'))  # 输出: 2
  print(my_dict.pop('d', 0))  # 输出: 0
  print(my_dict)  # 输出: {'a': 1, 'c': 3}
  

9. popitem()

• 描述: 移除并返回字典中的一个随机条目（键值对）。
• 示例:

  my_dict = {'a': 1, 'b': 2, 'c': 3}
  removed_item = my_dict.popitem()
  print(removed_item)  # 输出可能为 ('a', 1), ('b', 2), 或 ('c', 3)
  print(my_dict)  # 输出: {'b': 2, 'c': 3} (假设移除了 'a' 键)
  

10. clear()

• 描述: 清空字典。
• 示例:

  my_dict = {'a': 1, 'b': 2, 'c': 3}
  my_dict.clear()
  print(my_dict)  # 输出: {}
  

示例代码

下面是一个综合示例，展示字典的一些常用操作：

# 创建一个字典
my_dict = {'a': 1, 'b': 2, 'c': 3}# 获取所有键
print(my_dict.keys())  # 输出: dict_keys(['a', 'b', 'c'])# 获取所有值
print(my_dict.values())  # 输出: dict_values([1, 2, 3])# 获取所有键值对
print(my_dict.items())  # 输出: dict_items([('a', 1), ('b', 2), ('c', 3)])# 使用 get 方法
print(my_dict.get('a'))  # 输出: 1
print(my_dict.get('d', 0))  # 输出: 0# 更新字典
other_dict = {'b': 3, 'd': 4}
my_dict.update(other_dict)
print(my_dict)  # 输出: {'a': 1, 'b': 3, 'c': 3, 'd': 4}# 移除指定键
print(my_dict.pop('b'))  # 输出: 3
print(my_dict)  # 输出: {'a': 1, 'c': 3, 'd': 4}# 移除随机键值对
removed_item = my_dict.popitem()
print(removed_item)  # 输出可能为 ('a', 1), ('c', 3), 或 ('d', 4)
print(my_dict)  # 输出: {'a': 1, 'd': 4} (假设移除了 'c' 键)# 清空字典
my_dict.clear()
print(my_dict)  # 输出: {}

这些方法提供了强大的功能来操作字典，让您可以轻松地管理和操作字典中的数据。如果您有任何具体问题或需要更多示例，请随时告诉我！

容器（如列表、元组、字典等）可以作为函数的参数传递

在 Python 中，容器（如列表、元组、字典等）可以作为函数的参数传递。当您将容器作为参数传递给函数时，实际上是在传递容器的引用。这意味着在函数内部对容器所做的任何更改都会影响到原始容器。下面是一些关于如何使用容器作为函数参数的说明和示例。

1. 传递容器

• 列表:
  • 当您将列表作为参数传递给函数时，您实际上是传递列表的引用。
  • 如果在函数内部修改了列表，那么外部的列表也会受到影响。

示例：

def modify_list(lst):lst.append(4)my_list = [1, 2, 3]
modify_list(my_list)
print(my_list)  # 输出: [1, 2, 3, 4]

• 元组:
  • 元组是不可变的，所以在函数内部不能修改元组。
  • 但是，如果元组包含可变对象（如列表），那么这些对象是可以被修改的。

示例：

def modify_tuple(tup):tup[0].append(4)my_tuple = ([1, 2, 3], 'example')
modify_tuple(my_tuple)
print(my_tuple)  # 输出: ([1, 2, 3, 4], 'example')

• 字典:
  • 字典是可变的，所以在函数内部修改字典会影响外部的字典。

示例：

def modify_dict(dct):dct['new_key'] = 'new_value'my_dict = {'key': 'value'}
modify_dict(my_dict)
print(my_dict)  # 输出: {'key': 'value', 'new_key': 'new_value'}

2. 返回容器

• 返回列表:
  • 函数可以返回一个列表。

示例：

def create_list():return [1, 2, 3]new_list = create_list()
print(new_list)  # 输出: [1, 2, 3]

• 返回元组:
  • 函数可以返回一个元组。

示例：

def create_tuple():return (1, 2, 3)new_tuple = create_tuple()
print(new_tuple)  # 输出: (1, 2, 3)

• 返回字典:
  • 函数可以返回一个字典。

示例：

def create_dict():return {'key': 'value'}new_dict = create_dict()
print(new_dict)  # 输出: {'key': 'value'}

3. 使用可变参数

• 使用 *args:
  • 函数可以接受任意数量的位置参数。

示例：

def print_args(*args):for arg in args:print(arg)print_args(1, 2, 3)  # 输出: 1 2 3

• 使用 **kwargs:
  • 函数可以接受任意数量的关键字参数。

示例：

def print_kwargs(**kwargs):for key, value in kwargs.items():print(f"{key}: {value}")print_kwargs(a=1, b=2, c=3)  # 输出: a: 1 b: 2 c: 3

示例代码

下面是一个综合示例，展示了如何使用容器作为函数参数：

def modify_container(container):if isinstance(container, list):container.append(4)elif isinstance(container, dict):container['new_key'] = 'new_value'elif isinstance(container, tuple) and len(container) > 0 and isinstance(container[0], list):container[0].append(4)# 使用列表
my_list = [1, 2, 3]
modify_container(my_list)
print(my_list)  # 输出: [1, 2, 3, 4]# 使用元组
my_tuple = ([1, 2, 3], 'example')
modify_container(my_tuple)
print(my_tuple)  # 输出: ([1, 2, 3, 4], 'example')# 使用字典
my_dict = {'key': 'value'}
modify_container(my_dict)
print(my_dict)  # 输出: {'key': 'value', 'new_key': 'new_value'}

这些示例展示了如何使用不同的容器类型作为函数参数，并在函数内部对它们进行操作。如果您有任何具体问题或需要更多示例，请随时告诉我！

切片

您的描述涉及的是 Python 中序列（如列表、元组、字符串等）的切片操作。切片是一种非常强大的工具，用于从序列中提取子序列。下面是关于切片操作的基本语法和解释：

切片语法

序列的切片语法格式为：[start:stop:step]

• start (可选): 切片开始的索引位置（包含）。
• stop (可选): 切片结束的索引位置（不包含）。
• step (可选): 每次取元素时的步长。

解释

• 切片操作是前闭后开:

  • 这意味着切片的开始索引是包含在内的，而结束索引是不包含在内的。
  • 例如，s[start:stop] 表示从 start 索引处开始，一直取到 stop 索引之前的元素。

• 步长:

  • 步长指定了从序列中取出元素时的间隔。
  • 默认情况下，步长为 1，即连续取出元素。
  • 如果步长大于 1，则每隔 step - 1 个元素取出一个元素。
  • 如果步长为负数，则从序列的末尾向前取元素。

示例代码

下面是一些使用切片操作的示例：

# 创建一个列表
my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]# 从索引 2 开始，取到索引 5 结束（不包含索引 5）
sub_list = my_list[2:5]
print(sub_list)  # 输出: [2, 3, 4]# 从索引 1 开始，取到最后一个元素
sub_list = my_list[1:]
print(sub_list)  # 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9]# 从第一个元素开始，取到索引 4 结束（不包含索引 4）
sub_list = my_list[:4]
print(sub_list)  # 输出: [0, 1, 2, 3]# 从索引 1 开始，取到最后一个元素，步长为 2
sub_list = my_list[1::2]
print(sub_list)  # 输出: [1, 3, 5, 7, 9]# 从最后一个元素开始，取到第一个元素，步长为 -1
sub_list = my_list[::-1]
print(sub_list)  # 输出: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]# 从索引 5 开始，取到索引 2 结束（不包含索引 2），步长为 -1
sub_list = my_list[5:2:-1]
print(sub_list)  # 输出: [5, 4, 3]

详细解释

• my_list[2:5]:

  • 从索引 2 开始（包含索引 2 的元素），取到索引 5 结束（不包含索引 5 的元素），步长为 1（默认）。
  • 结果是 [2, 3, 4]。

• my_list[1:]:

  • 从索引 1 开始（包含索引 1 的元素），取到最后一个元素，步长为 1（默认）。
  • 结果是 [1, 2, 3, 4, 5, 6, 7, 8, 9]。

• my_list[:4]:

  • 从第一个元素开始，取到索引 4 结束（不包含索引 4 的元素），步长为 1（默认）。
  • 结果是 [0, 1, 2, 3]。

• my_list[1::2]:

  • 从索引 1 开始（包含索引 1 的元素），取到最后一个元素，步长为 2。
  • 结果是 [1, 3, 5, 7, 9]。

• my_list[::-1]:

  • 从最后一个元素开始，取到第一个元素，步长为 -1。
  • 结果是 [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]。

• my_list[5:2:-1]:

  • 从索引 5 开始（包含索引 5 的元素），取到索引 2 结束（不包含索引 2 的元素），步长为 -1。
  • 结果是 [5, 4, 3]。

这些示例展示了如何使用 Python 中的切片操作来提取序列的子序列。如果您有任何具体问题或需要更多示例，请随时告诉我！

在 Python 中，切片操作非常强大且灵活。除了基本的切片语法之外，还有一些其他的注意事项和特性，可以帮助您更好地理解和使用切片。下面是一些值得注意的方面：

1. 索引的默认值

• 起始索引:
  • 如果省略 start，默认为 0，即从序列的开头开始。
• 结束索引:
  • 如果省略 stop，默认为序列的长度，即取到序列的末尾。
• 步长:
  • 如果省略 step，默认为 1，即连续取元素。

2. 正索引和负索引

• 正索引:
  • 从左到右索引，从 0 开始。
• 负索引:
  • 从右到左索引，从 -1 开始。

3. 步长为负数

• 从序列末尾开始取元素:
  • 如果 step 为负数，则从序列的末尾开始取元素。
  • 这种情况下，start 和 stop 的含义会发生变化：
    • start 应该大于 stop。
    • start 和 stop 都可以是负数或正数。

4. 超出范围的索引

• 超出范围的起始索引:
  • 如果 start 超出了序列的范围，将从序列的开头开始。
• 超出范围的结束索引:
  • 如果 stop 超出了序列的范围，将取到序列的末尾。

5. 索引和步长组合

• 步长为负数时的 start 和 stop:
  • 如果 step 为负数，start 和 stop 的值需要遵循以下规则：
    • start 必须大于等于 stop。
    • 如果 start 大于序列的末尾，将从序列的末尾开始。
    • 如果 stop 小于序列的开头，将从序列的开头结束。

6. 空切片

• 空切片:
  • 如果 start 和 stop 相等或 start 大于 stop，将返回一个空序列。

示例代码

下面是一些关于这些注意事项的示例：

# 创建一个列表
my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]# 省略起始索引
sub_list = my_list[:5]
print(sub_list)  # 输出: [0, 1, 2, 3, 4]# 省略结束索引
sub_list = my_list[5:]
print(sub_list)  # 输出: [5, 6, 7, 8, 9]# 使用负索引
sub_list = my_list[-5:]
print(sub_list)  # 输出: [5, 6, 7, 8, 9]# 步长为负数
sub_list = my_list[8:3:-2]
print(sub_list)  # 输出: [8, 6, 4]# 超出范围的索引
sub_list = my_list[15:]
print(sub_list)  # 输出: []# 步长为负数时的特殊情况
sub_list = my_list[5:2:-1]
print(sub_list)  # 输出: [5, 4, 3]# 空切片
sub_list = my_list[3:3]
print(sub_list)  # 输出: []

详细解释

• my_list[:5]:

  • 从序列的开头开始，取到索引 5 结束（不包含索引 5 的元素），步长为 1（默认）。
  • 结果是 [0, 1, 2, 3, 4]。

• my_list[5:]:

  • 从索引 5 开始（包含索引 5 的元素），取到最后一个元素，步长为 1（默认）。
  • 结果是 [5, 6, 7, 8, 9]。

• my_list[-5:]:

  • 从倒数第 5 个元素开始（包含该元素），取到最后一个元素，步长为 1（默认）。
  • 结果是 [5, 6, 7, 8, 9]。

• my_list[8:3:-2]:

  • 从索引 8 开始（包含索引 8 的元素），取到索引 3 结束（不包含索引 3 的元素），步长为 -2。
  • 结果是 [8, 6, 4]。

• my_list[15:]:

  • 从索引 15 开始（超出序列范围），取到最后一个元素，步长为 1（默认）。
  • 结果是 []（空列表）。

• my_list[5:2:-1]:

  • 从索引 5 开始（包含索引 5 的元素），取到索引 2 结束（不包含索引 2 的元素），步长为 -1。
  • 结果是 [5, 4, 3]。

• my_list[3:3]:

  • 从索引 3 开始（包含索引 3 的元素），取到索引 3 结束（不包含索引 3 的元素），步长为 1（默认）。
  • 结果是 []（空列表）。

这些示例展示了 Python 中切片操作的一些特殊用法和注意事项。如果您有任何具体问题或需要更多示例，请随时告诉我！

列表list

列表是一个有序且可更改的集合，并且是最常用的 Python 数据类型。在 Python 中，列表是使用方括号 [] 编写的。

1、[创建列表]

在Python中，列表中元素的数据类型可以不同，可以包含整数、浮点数和复数等，当然，也可以包含列表、元组、字典和集合等。

1.1 使用 [ ] 创建列表

创建一个列表，只需要把逗号分隔的不同数据项使用方括号 [] 括起来即可。

• 创建空列表

list0 = []

• 创建非空列表

list1 = ['Baidu', 'Alibaba', 'Tencent']

1.2 使用 list() 函数 创建(转换为)列表

• 可以使用 list() 构造函数创建列表：

this_list = list(('apple', 'banana', 'cherry'))

注意：在使用 list() 函数创建列表时，一定要注意双括号。

• 在Python中，我们可以使用 list() 函数将字符串、元组、字典和集合等其他类似对象转换为列表。具体用法见下方内置函数：

2、访问列表

和列表一样，我们既可以使用下标索引访问列表中的某个元素（得到一个元素的值），也可以使用切片访问列表中的一组元素（得到是子列表）。

2.1 下标索引访问

下标索引访问元组分为两大类，即正向索引和反向索引，格式为 list_name[i] ，其中，list_name 表示列表名，i表示索引值，i可以是正数（正向索引）也可以是负数（反向索引）。

可以得知，list_name[0]表示列表的第一个元素，list_name[-1]则表示列表的最后一个元素。

list_name = ['wzq', 'lgl', 'gz', 'whl', 'sj', 'hxw']
print(list_name[0])
print(list_name[-1])

wzq
hxw

正向索引：从第一个（下标0）开始、第二个（下标1）…

反向索引：从倒数第一个（下标-1）、倒数第二个（下标-2）…

2.2 切片访问

如若对上方描述不太理解，可参考下表：

元组值	wzq	lgl	gz	whl	sj	hxw
正向索引	0	1	2	3	4	5
反向索引	-6	-5	-4	-3	-2	-1

使用切片访问列表的格式为 list_name[strat : end : step] ，其中，start 表示起始索引，end 表示结束索引，step 表示步长。

list_name = ['wzq', 'lgl', 'gz', 'whl', 'sj', 'hxw']
print(list_name[1:5:2])
print(list_name[-6:-1:3])

['lgl', 'whl']
['wzq', 'whl']

在使用切片访问列表元素时，list_name[strat : end : step]，[start：end] 是左闭右开区间，即访问不了 end 代表的元素。

2.3 for 循环[遍历列表

可以使用 for 循环遍历列表中的项目：

fruit_list = ['apple', 'pear', 'cherry']
for i in fruit_list:print(i)

apple
pear
cherry

2.4 检查项目是否存在

要确定列表中是否存在指定的项，我们可以使用 in 关键字：

# 检查列表中是否存在'apple'
fruit_list = ['apple', 'pear', 'cherry']
print('apple' in fruit_list)

True

使用 in 关键字检查列表中是否存在指定项时，如果存在，则返回 True ；反之，则返回 False 。

2.5 更改列表值

当我们创建列表后，我们可以对列表中的数据项进行修改或更新，当然我们也可以使用 append() 方法来添加列表项。

fruit_list = ['apple', 'pear', 'cherry']
fruit_list[2] = 'banana'
print(fruit_list)

['apple', 'pear', 'banana']

注意：元组一旦创建后，其值将无法被更改，但是有其他解决方法。

2.6 列表连接(合并)/复制

与字符串一样，列表之间可以使用 + 号和 * 号实现元组的连接和复制，这就意味着它们可以生成一个新的列表。

1、+连接（合并）

x = [1, 2, 3]
y = [4, 5, 6]
print(x + y)

[1, 2, 3, 4, 5, 6]

2、*复制

x = ['Hello']
print(x * 5)

['Hello', 'Hello', 'Hello', 'Hello', 'Hello']

2.7 嵌套列表

使用嵌套列表即在列表里面创建其他列表。

x = [1, 2, 3]
y = ['a', 'b', 'c']
z = [x, y]
print(z)

[[1, 2, 3], ['a', 'b', 'c']]

2.8 列表比较

列表比较需要引入 operator 模块的 eq 方法。

# 导入 operator 模块
import operatora = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a, b):", operator.eq(a, b))
print("operator.eq(b, c):", operator.eq(b, c))

operator.eq(a, b): False
operator.eq(b, c): True

3、内置函数

3.1 打印输出 print()

1、print()函数

print() 函数的功能我们已经非常熟悉了，就是打印输出。

my_list = ['pink', True, 1.78, 65]
print(my_list)

['pink', True, 1.78, 65]

3.2 确定列表项目 len()

2、len()函数

当我们要确定一个列表有多少项目（元素）时，可以使用len()函数。

fruit_list = ['apple', 'banana', 'cherry']
print(len(fruit_list))

3

3.3 返回变量类型 type()

3、type()函数

使用 type() 函数可以确定变量是什么类型（字符串、列表、元组、字典或集合）。

info_list = ['name', 'gender', 'age', 'height', 'weight']
print(type(info_list))

<class 'list'>

当对info_list使用 type() 确定变量类型时，会返回<class 'list'>，表明这是一个列表。

3.4 转换为列表 list()

4、tuple()函数

tuple() 函数的功能是，将其他类型转换为元组类型，详细用法如下：

• 将字符串转换为列表

str1 = 'Hello Python'
print(list(str1))

['H', 'e', 'l', 'l', 'o', ' ', 'P', 'y', 't', 'h', 'o', 'n']

• 将元组转换为列表

tuple1 = ('Hello', 'Python')
print(list(tuple1))

['Hello', 'Python']

• 将字典转换为列表

dict1 = {'Hello': 'Python', 'name': 'pink'}
print(list(dict1))

['Hello', 'name']

• 将集合转换为列表

set1 = {'Hello', 'Python', 'name', 'pink'}
print(list(set1))

['Python', 'name', 'pink', 'Hello']

• 将区间转换为列表

range1 = range(1, 6)
print(list(range1))

[1, 2, 3, 4, 5]

3.5 元组元素最大/小值 max()、min()

5、max()函数和min()函数

max() 函数的作用是返回列表中元素最大值。min() 函数的作用是返回列表中元素最小值。

list1 = [4, 6, 2, 0, -5]
print(max(list1))
print(min(list1))list2 = ['a', 'z', 'A', 'Z']
print(max(list2))
print(min(list2))

6
-5
z
A

3.6 删除列表 del

• 删除单个元素

我们可以使用 del list_name[i] 来删除某个指定元素，其中 list_name 表示列表名，i 表示指定值的索引值。

list_de = ['Baidu', 'Alibaba', 'Tencent', 'Bytedance']
del list_de[1]
print(list_de)

['Baidu', 'Tencent', 'Bytedance']

• 删除列表

del 函数不仅可以实现删除某个元素，还可以删除整个列表。

list_de = ['Baidu', 'Alibaba', 'Tencent', 'Bytedance']
del list_de

当我们使用 del 函数删除某列表后，再使用 print() 函数打印输出时，会报错NameError: name 'list_de' is not defined,表明该列表未被定义。

4、内置方法

4.1 添加元素 append()、insert()、extend()

1、append()方法

append() 方法用于在列表末尾添加新的对象。

语法

list.append(element)

参数值

参数	描述
element	必需。任何类型（字符串、数字、对象等）的元素。

实例

• 添加元素

fruit_list = ['apple', 'banana', 'cherry']
fruit_list.append('pear')
print(fruit_list)

['apple', 'banana', 'cherry', 'pear']

• 添加列表

x = [1, 2, 3]
y = ['A', 'B', 'C']
x.append(y)
print(x)

[1, 2, 3, ['A', 'B', 'C']]

2、insert()方法

insert() 方法用于将指定对象插入列表的指定位置。

语法

list.insert(position, element)

参数值

参数	描述
position	必需。数字，指定在哪个位置插入值。
element	必需。元素，任何类型（字符串、数字、对象等）。

实例

• 把值 “orange” 作为第二个元素插入 fruits 列表：

fruits = ['apple', 'banana', 'cherry']
fruits.insert(1, "orange")
print(fruits)

['apple', 'orange', 'banana', 'cherry']

• 将列表 y 插入到列表 x 中

x = [1, 2, 3]
y = ['a', 'c']
x.insert(0, y)
print(x)

[['a', 'c'], 1, 2, 3]

append() 只能在末尾处添加元素或列表，insert() 可以在任意位置添加元素或列表。

3、extend()方法

extend() 方法用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。

语法

list.extend(iterable)

参数值

参数	描述
iterable	必需。任何可迭代对象（列表、集合、元组等）。

实例

aver = ['A', 'B', 'C']

• 添加字符串元素到列表末尾

str1 = 'Hello'
aver.extend(str1)
print(aver)

['A', 'B', 'C', 'H', 'e', 'l', 'l', 'o']

• 添加列表元素到列表末尾

list1 = [1, 2, 3]
aver.extend(list1)
print(aver)

['A', 'B', 'C', 1, 2, 3]

• 添加元组元素到列表末尾

tuple1 = (1, 2, 3)
aver.extend(tuple1)
print(aver)

['A', 'B', 'C', 1, 2, 3]

• 添加字典元素到列表末尾

dict1 = {'name': 'pink', 'gender': True}
aver.extend(dict1)
print(aver)

['A', 'B', 'C', 'name', 'gender']

• 添加集合元素到列表末尾

set1 = {1, 2, 3}
aver.extend(set1)
print(aver)

['A', 'B', 'C', 1, 2, 3]

• 添加区间到列表末尾

range1 = range(1,10)
aver.extend(range1)
print(aver)

['A', 'B', 'C', 1, 2, 3, 4, 5, 6, 7, 8, 9]

4.2 元素出现次数 count()

count() 方法用于统计某个元素在列表中出现的次数。

语法

list.count(value)

参数值

参数	描述
value	必需。任何类型（字符串、数字、列表、元组等）。要搜索的值。

实例

num = [1, 4, 2, 9, 7, 8, 9, 3, 1]
print(num.count(9))

2

4.3 指定值索引 index()

index() 方法用于从列表中找出某个值第一个匹配项的索引位置。

语法

list.index(element)

参数值

参数	描述
element	必需。任何类型（字符串、数字、列表等）。要搜索的值。

实例

num = [4, 55, 64, 32, 16, 32]
print(num.index(32))

3

当被搜索值在列表中多次出现时，仅返回首次出现的位置。

4.4 对列表排序 sort()

sort() 方法用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

语法

list.sort(reverse=True|False, key=myFunc)

参数值

参数	描述
reverse	可选。reverse=True 将对列表进行降序排序。默认是 reverse=False。
key	可选。指定排序标准的函数。

实例

• 以字母顺序对列表进行排序：

words = ['Name', 'Gender', 'Age', 'Height', 'Weight']
words.sort()
print(words)

['Age', 'Gender', 'Height', 'Name', 'Weight']

• 对列表进行降序排序：

words = ['Name', 'Gender', 'Age', 'Height', 'Weight']
words.sort(reverse=True)
print(words)

['Weight', 'Name', 'Height', 'Gender', 'Age']

• 按照值的长度对列表进行排序：

# 返回值的长度的函数：
def myfunc(e):return len(e)words = ['a', 'bb', 'ccc', 'dddd', '']words.sort(key=myfunc)
print(words)

['', 'a', 'bb', 'ccc', 'dddd']

• 根据字典的 “year” 值对字典列表进行排序：

# 返回 'year' 值的函数：
def myfunc(e):return e['year']words = [{'char': 'a', 'year': 1963},{'char': 'b', 'year': 2010},{'char': 'c', 'year': 2019}
]words.sort(key=myfunc)
print(words)

[{'char': 'a', 'year': 1963}, {'char': 'b', 'year': 2010}, {'char': 'c', 'year': 2019}]

• 按照值的长度对列表进行降序排序：

# 返回值的长度的函数：
def myfunc(e):return len(e)words = ['aa', 'b', 'ccc', 'dddd']words.sort(reverse=True, key=myfunc)
print(words)

['dddd', 'ccc', 'aa', 'b']

• 指定列表中的元素排序来输出列表：

# 获取列表的第二个元素
def takeSecond(elem):return elem[1]# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]# 指定第二个元素排序
random.sort(key=takeSecond)# 输出类别
print('排序列表：', random)

排序列表： [(4, 1), (2, 2), (1, 3), (3, 4)]

4.5 复制列表 copy()

copy() 方法用于复制列表，类似于 a[:]。

语法

list.copy()

参数值

无参数

实例

fruits = ['apple', 'banana', 'cherry', 'orange']
x = fruits.copy()
print(x)

['apple', 'banana', 'cherry', 'orange']

复制（制作副本）的另一种方法是使用内置函数 list() ，如下：

list1 = ['apple', 'banana', 'cherry']
list_2 = list(list1)

4.6 颠倒列表顺序 reverse()

reverse() 方法用于反向列表中元素。

语法

list.reverse()

参数值

无参数

实例

fruits = ['apple', 'banana', 'cherry']
fruits.reverse()
print(fruits)

['cherry', 'banana', 'apple']

4.7 删除元素 pop()、remove()、clear()

1、pop()方法

pop() 方法用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

语法

list.pop(pos)

参数值

参数	描述
pos	可选。数字，指定需删除元素的位置。默认值 -1，返回最后的项目。

实例

• 当 pos 未指定时，默认删除最后的元素

fruits = ['apple', 'banana', 'cherry']
fruits.pop()
print(fruits)

['apple', 'banana']

• pos 指定要删除元素的位置

fruits = ['apple', 'banana', 'cherry']
fruits.pop(1)
print(fruits)

['apple', 'cherry']

2、remove()方法

remove() 方法用于移除列表中某个值的第一个匹配项。

语法

list.remove(element)

参数值

参数	描述
element	必需。需删除的任何类型（字符串、数字、列表等）的元素。

实例

num = [1, 3, 2, 8, 3]
num.remove(3)
print(num)

[1, 2, 8, 3]

当被删除的元素在列表中存在多个时，默认删除首次出现的那个。

3、clear()方法

clear() 方法用于清空列表，类似于 del a[:]。

语法

list.clear()

参数值

无参数

实例

word = ['A', 'B', 'C']
word.clear()
print(word)

[]

clear() 方法的作用是清空列表，执行结束后对其使用 print() 打印输出时，会输出 [] ,说明列表还存在，只是空列表而已。

del 函数的作用是删除列表，执行结束后对其使用 print() 打印输出时，会报错 NameError: name 'word' is not defined.。

5、总结

函数	描述
print()	打印输出
len()	确定列表项目
type()	返回变量类型
list()	转换为列表
max()	返回列表元素最大值
min()	返回列表元素最小值
del	删除列表

方法	描述
append(obj)	在列表末尾添加新的对象
insert(index, obj)	在指定位置添加元素
extend(seq)	将列表元素（或任何可迭代的元素）添加到当前列表的末尾
count(obj)	统计某个元素在列表中出现的次数
index(obj)	返回具有指定值的第一个元素的索引
sort( key=None, reverse=False)	对原列表进行排序
copy()	复制列表
reverse()	颠倒列表的顺序
pop([-1])	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
remove(obj)	移除列表中某个值的第一个匹配项
clear()	清空列表

---

元组tuple

元组是有序且不可更改的集合。在Python中，元组使用圆括号 () 编写的。

1、创建元组

元组的创建很简单，使用圆括号 () 直接创建或者使用 tuple() 函数创建，只需要在圆括号中添加元素，并使用逗号隔开即可。

1.1 使用 () 创建元组

通过 () 创建元组后，使用 = 将它赋值给变量，格式如下：

tuple_name = (element_1, element_2, ..., element_n)

其中，tuple_name 表示变量名，element_1 ~ element_n 表示元组内的元素。

1.2 使用 tuple()函数 创建元组

我们除了可以使用 () 创建元组，还可以使用 tuple() 函数创建元组，但 tuple() 偏向于将某个类型转换为元组，具体用法见下述：

cre_tuple = tuple(('a', 'b', 'c'))  # 注意双括号
print(cre_tuple)
print(type(cre_tuple))

('a', 'b', 'c')
<class 'tuple'>

1.3 元组(单个元素)

当元组中只包含一个元素时，需要在元素后面添加逗号, ，否则括号会被当作运算符使用：

tuple_1 = (20)
print(type(tuple_1))  # <class 'int'>tuple_2 = (20,)
print(type(tuple_2))  # <class 'tuple'>

当元组中只含一个元素未添加逗号时，使用 type() 打印其类型时，会输出 <class 'int'>。

当元组中只含一个元素并添加逗号时，使用type() 打印其类型时，会输出 <class 'tuple'>。

1.4 元组 VS 列表

• 在Python中，元组与列表相似，不同之处在于元组的元素不能修改，而列表的元素可以修改。
• 元组使用 小括号()，列表使用 中括号[]。

2、访问元组

和列表一样，我们既可以使用下标索引访问元组中的某个元素（得到一个元素的值），也可以使用切片访问元组中的一组元素（得到是子元组）。

2.1 下标索引访问

下标索引访问元组分为两大类，即正向索引和反向索引，格式为 tuple_name[i] ，其中，tuple_name 表示元组名，i表示索引值，i可以是正数（正向索引）也可以是负数（反向索引）。

可以得知，tuple_name[0]表示元组内第一个元素，tuple_name[-1]则表示元组内最后一个元素。

tuple_name = ('wzq', 'lgl', 'gz', 'whl', 'sj', 'hxw')
print(tuple_name[0])
print(tuple_name[-1])

wzq
hxw

正向索引：从第一个（下标0）开始、第二个（下标1）…

反向索引：从倒数第一个（下标-1）、倒数第二个（下标-2）…

2.2 切片访问

如若对上方描述不太理解，可参考下表：

元组值	wzq	lgl	gz	whl	sj	hxw
正向索引	0	1	2	3	4	5
反向索引	-6	-5	-4	-3	-2	-1

使用切片访问元组的格式为 tuple_name[strat : end : step] ，其中，start 表示起始索引，end 表示结束索引，step 表示步长。

tuple_name = ('wzq', 'lgl', 'gz', 'whl', 'sj', 'hxw')
print(tuple_name[1:5:2])
print(tuple_name[-6:-1:3])

('lgl', 'whl')
('wzq', 'whl')

在使用切片访问元组元素时，tuple_name[strat : end : step]，[start：end] 是左闭右开区间，即访问不了 end 代表的元素。

2.3 for 循环遍历元组

可以使用 for 循环遍历元组中的项目：

fruit_tuple = ('apple', 'pear', 'cherry')
for i in fruit_tuple:print(i)

apple
pear
cherry

2.4 检查项目是否存在

要确定元组中是否存在指定的项，我们可以使用 in 关键字：

# 检查元组中是否存在'apple'
fruit_tuple = ('apple', 'pear', 'cherry')
print('apple' in fruit_tuple)

True

使用 in 关键字检查元组中是否存在指定项时，如果存在，则返回 True ；反之，则返回 False 。

2.5 更改元组值

创建元组后，我们将无法更改其值。元组是不可变的，或者也被称为恒定的。

但是有一种解决方法：可以先将元组转换为列表，更改列表值，然后再将其转换回元组。

fruit_tuple = ('apple', 'pear', 'cherry')
fruit_list = list(fruit_tuple)
fruit_list[2] = 'banana'
fruit_tuple = tuple(fruit_list)
print(fruit_tuple)

('apple', 'pear', 'banana')

2.6 元组连接(合并)/复制

与字符串一样，元组之间可以使用 + 号和 * 号实现元组的连接和复制，这就意味着它们可以生成一个新的元组。

1、+连接

x = (1, 2, 3)
y = (4, 5, 6)
print(x + y)

(1, 2, 3, 4, 5, 6)

2、*复制

x = ('Hello',)
print(x * 5)

('Hello', 'Hello', 'Hello', 'Hello', 'Hello')

2.7 元组不可变性

所谓元组的不可变性指的是元组所指向的内存中的内容不可变。

tup = ('A', 'B', 'C')
# tup[0] = 'a'

不支持修改元素，会报错 TypeError: 'tuple' object does not support item assignment 。

tup = ('A', 'B', 'C')
print(id(tup))
# 查看内存地址
tup = (1, 2, 3)
print(id(tup))

2671405067264
2671405072256

从以上实例可以看出，重新赋值的元组 tup ，绑定到了新的对象了，不是修改了原来的对象。

3、内置函数

3.1 打印输出 print()

1、print()函数

print() 函数的功能我们已经非常熟悉了，就是打印输出。

my_tuple = ('name', True, 21)
print(my_tuple)

('name', True, 21)

3.2 确定元组项目 len()

2、len()函数

当我们要确定一个元组有多少项目（元素）时，可以使用len()函数。

fruit_tuple = ('apple', 'banana', 'cherry')
print(len(fruit_tuple))

3

3.3 返回变量类型 type()

3、type()函数

使用 type() 函数可以确定变量是什么类型（字符串、列表、元组、字典或集合）。

当对tup_1 = (20)使用 type() 确定变量类型时，会返回<class 'int'>，表明这是一个整型。所以当一个元组只含有一个元素时，一定要加上逗号,。

当对tup_1 = (20,)使用 type() 确定变量类型时，会返回<class 'tuple'>，表明这是一个元组。

3.4 转换为元组 tuple()

4、tuple()函数

tuple() 函数的功能是，将其他类型转换为元组类型，详细用法如下：

• 将字符串转换为元组

str1 = 'Hello Python'
print(tuple(str1))

('H', 'e', 'l', 'l', 'o', ' ', 'P', 'y', 't', 'h', 'o', 'n')

• 将列表转换为元组

list1 = ['Hello', 'Python']
print(tuple(list1))

('Hello', 'Python')

• 将字典转换为元组

dict1 = {'Hello': 'Python', 'name': 'pink'}
print(tuple(dict1))

('Hello', 'name')

• 将集合转换为元组

set1 = {'Hello', 'Python', 'name', 'pink'}
print(tuple(set1))

('Hello', 'name', 'Python', 'pink')

• 将区间转换为元组

range1 = range(1, 6)
print(tuple(range1))

(1, 2, 3, 4, 5)

3.5 元组元素最大/小值 max()、min()

5、max()函数和min()函数

max() 函数的作用是返回元组中元素最大值。min() 函数的作用是返回元组中元素最小值。

tup1 = (4, 6, 2, 0, -5)
print(max(tup1))
print(min(tup1))tup2 = ('a', 'z', 'A', 'Z')
print(max(tup2))
print(min(tup2))

6
-5
z
A

3.6 删除元组 del

元组中的元素值是不允许删除的，但我们可以使用 del 函数来删除整个元组。

word_tuple = ('a', 'b', 'c')
del word_tuple

当我们使用 del 函数删除某元组后，再使用 print() 函数打印输出时，会报错NameError: name 'word_tuple' is not defined,表明该元组未被定义。

4、内置方法

4.1 元素出现次数 count()

count() 方法返回指定值在元组中出现的次数。

语法

tuple.count(value)

参数值

参数	秒速
value	必需。要检索的项目。

实例

返回值 5 在元组中出现的次数：

num_tuple = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5, 5)
print(num_tuple.count(5))

3

4.2 元素位置 index()

index() 方法查找指定值的第一次出现。

语法

tuple.index(value)

参数值

参数	描述
value	必需。要检索的项目。

实例

num_tuple = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5, 5)
print(num_tuple.index(5))

5

注意：当被搜索值在元组中存在多个，则返回第一次出现的下标。

num_tuple = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5, 5)
print(num_tuple.index(999))

如果未找到该值，index() 方法将引发异常，ValueError: tuple.index(x): x not in tuple。

5、总结

函数	描述
print()	打印输出
len()	确定元组项目
type()	返回变量类型
tuple()	转换为元组
max()	返回元组元素最大值
min()	返回元组元素最小值
del	删除元组

方法	描述
count()	返回元组中指定值出现的次数
index()	在元组中搜索指定的值并返回它被找到的位置

---

字符串str

字符串是Python中最常用的数据类型

1、创建字符串

1.1 使用 ’ ’ 或 " " 创建字符串

创建字符串很简单，我们可以使用引号（’ ’ 或 " "）来创建字符串，只需为变量分配一个值即可。

str1 = 'Hello Python'
str2 = "hello python"

1.2 使用 str()函数 转换为字符串

当然，除了使用引号直接创建字符串之外，我们还可以使用 str() 函数将其他数据类型或对象转换为字符串，其具体用法见下方内置函数。

2、访问字符串

和列表、元组一样，我们既可以使用下标索引访问字符串中的某个元素（得到是一个字符），也可以使用切片访问字符串中的一组元素（得到是子字符串）。

2.1 下标索引访问

下标索引访问字符串分为两大类，即正向索引和反向索引，格式为 str_name[i] ，其中，str_name 表示字符串名，i表示索引值，i可以是正数（正向索引）也可以是负数（反向索引）。

可以得知，str_name[0]表示字符串的第一个字符，str_name[-1]则表示字符串的最后一个字符。

str1 = 'Hello Py'
print(str1[0])
print(str1[-1])

H
y

正向索引：从第一个（下标0）开始、第二个（下标1）…

反向索引：从倒数第一个（下标-1）、倒数第二个（下标-2）…

2.2 切片访问

如若对上方描述不太理解，可参考下表：

字符串值	H	e	l	l	o		P	y
正向索引	0	1	2	3	4	5	6	7
反向索引	-8	-7	-6	-5	-4	-3	-2	-1

Python访问子字符串，可以使用中括号 [ ] 来截取字符串，即切片访问。

使用切片访问字符串的格式为 str_name[strat : end : step] ，其中，start 表示起始索引，end 表示结束索引，step 表示步长。

str1 = 'Hello Py'
print(str1[0:5])
print(str1[-8:-1])
print(str1[:])
print(str1[::2])

Hello
Hello P
Hello Py
HloP

截取字符串的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。

2.3 for循环遍历字符串

使用 for 循环遍历字符串时，将会输出字符串中的每一个字符。

str_h = 'Hi Py'
for char in str_h:print(char)

H
iP
y

2.4 检查元素是否存在

如果我们需要确定在一个字符串中，是否存在相同的字符或者子字符串，可以使用成员运算符中的 in 和 not in 关键字。

关键字	描述
in	如果字符串中包含给定的字符返回 True。
not in	如果字符串中不包含给定的字符返回 True。

str1 = 'Hello Python'
print('H' in str1)
print('Python' not in str1)

True
False

3、字符串基础知识

3.1 字符串更新

我们可以截取字符串的一部分并与其他字段拼接，如下实例：

str1 = 'Hello World'
print(str1[:6] + 'Python')

Hello Python

3.2 字符串连接

同列表和元组一样，字符串之间可以使用 + 号和 * 号分别实现字符串的连接（合并）和复制（重复），这意味着它们可以生成一个新的字符串。

1、+连接（合并）

a = 'Hello'
b = 'Python'
print(a + b)

HelloPython

2、*复制（重复）

c = 'Hello'
print(c * 5)

HelloHelloHelloHelloHello

3.3 转义字符

如果需要在字符中使用特殊字符时，则使用反\斜杠 ** 转义字符，如下表：

3.4 打印原始字符 r / R

原始字符串：所有的字符串都是直 接按照字面的意思来使用，没有转义特殊或不能打印的字符。

原始字符串除在字符串的第一个引号前加上字母 r / R （可以大小写）以外，与普通字符串有着几乎完全相同的语法。

print(r'\n')
print(R'\n')
print(r'\t')
print(r'\a')

\n
\n
\t
\a

3.5 格式字符串

Python支持格式化字符串的输出。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

print('我叫 %s ,今年 %d 岁！' % ('pink', 21))

我叫 pink ,今年 21 岁！

在Python中，字符串格式化使用与 C语言 中 printf() 函数一样的用法。

Python字符串格式化符号如下表所示：

符 号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的地址

格式化操作符辅助指令：

符号	功能
*	定义宽度或者小数点精度
-	用做左对齐
+	在正数前面显示加号( + )
	在正数前面显示空格
#	在八进制数前面显示零(‘0’)，在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’)
0	显示的数字前面填充’0’而不是默认的空格
%	‘%%‘输出一个单一的’%’
(var)	映射变量(字典参数)
m.n.	m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

3.6 三引号

Python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。实例如下：

str1 = """这是一个多行字符串
多行字符串可以使用制表符
TAB[\t]
也可以使用换行符[\n]
"""
print(str1)

这是一个多行字符串
多行字符串可以使用制表符
TAB[	]
也可以使用换行符[
]

三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。

当你需要一块HTML或者SQL时，这时用字符串组合，特殊字符串转义将会非常的繁琐。

errHTML = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
'''
cursor.execute('''
CREATE TABLE users (  
login VARCHAR(8), 
uid INTEGER,
prid INTEGER)
''')

3.7 f-string

f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。

之前我们习惯用百分号 (%):

name = 'pink'
print('Hello %s' % name)

f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，实例如下：

name = 'pink'
print(f'Hello {name}')print(f'{1 + 2}')baidu = {'name': 'Baidu', 'url': 'https://www.baidu.com'}
print(f'{baidu["name"]}:{baidu["url"]}')

Hello pink
3
Baidu:https://www.baidu.com

用了这种方式明显更简单了，不用再去判断使用 %s，还是 %d。

在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果：

x = 1
print(f'{x + 1}')y = 1
print(f'{x + 1 = }')

2
x + 1 = 2

3.8 Unicode 字符串

在Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。

在Python3中，所有的字符串都是Unicode字符串。

4、内置函数

4.1 打印输出 print()

1、print()函数

print() 函数的功能我们已经非常熟悉了，就是打印输出。

str1 = 'Hello Python'
print(str1)

Hello Python

4.2 确定字符串长度 len()

2、len()函数

当我们要确定一个字符串中有多少个字符时，我们可以使用 len() 函数。

str2 = 'Hello Python'
print(len(str2))

12

4.3 返回变量类型 type()

3、type()函数

使用 type() 函数可以确定变量是什么类型（字符串、列表、元组、字典或集合）。

str3 = 'Hello Python'
print(type(str3))

<class 'str'>

当对 str3 使用 type() 确定变量类型时，会返回 <class 'str'> ，表明这是一个字符串。

4.4 转换为字符串 str()

4、str()函数

我们可以使用 str() 函数将列表、元组、字典、集合和区间等对象转换为字符串，以下将会一一介绍：

• 将列表转换为字符串

list1 = ['a', 'b', 'c']
print(type(str(list1)))
print(str(list1))

<class 'str'>
['a', 'b', 'c']

• 将元组转换为字符串

tuple1 = ('A', 'B', 'C')
print(type(str(tuple1)))
print(str(tuple1))

<class 'str'>
('A', 'B', 'C')

• 将字典转换为字符串

dict1 = {'name': 'pink'}
print(type(str(dict1)))
print(str(dict1))

<class 'str'>
{'name': 'pink'}

• 将集合转换为字符串

set1 = {'name', 'gender'}
print(type(str(set1)))
print(str(set1))

<class 'str'>
{'name', 'gender'}

• 将区间转换为字符串

range1 = range(0, 10)
print(type(str(range1)))
print(str(range1))

<class 'str'>
range(0, 10)

4.5 字符串最大/小字符 max()、min()

5、max()函数和min()函数

max() 函数的作用是返回字符串中最大的字符。min() 函数的作用是返回字符串中最小的字符。

str_m = 'AazZ'
print(max(str_m))
print(min(str_m))

z
A

4.6 删除字符串 del

在Python中，del 函数并不支持删除字符串中的单个字符，但我们可以使用 del 函数删除整个字符串：

str1 = 'Hello Python'
del str1
print(str1)

当我们使用 del 函数删除某字符串后，如果再使用 print() 函数打印输出时，会报错NameError: name 'str1' is not defined，表明该字符串未被定义。

5、内置方法

5.1 转换

5.1.1 字符(串)转换 capitalize()、casefold()、lower()、upper()、title()、swapcase()

1、 capitalize()方法

capitalize() 将字符串的第一个字母变成大写，其他字母变小写。

语法

string.capitalize()

参数值

无参数

实例

str1 = 'hello python'
print(str1.capitalize())

Hello python

2、casefold()方法

casefold() 方法返回一个字符串，其中所有字符均为小写。

语法

string.casefold()

参数值

无参数

实例

str1 = 'Hello Python'
print(str1.casefold())

hello python

此方法与 lower() 方法相似，但是 casefold() 方法更强大，更具攻击性，这意味着它将更多字符转换为小写字母，并且在比较两个用 casefold() 方法转换的字符串时会找到更多匹配项。

3、lower()方法

lower() 方法转换字符串中所有大写字符为小写（符号和数字将被忽略）。

语法

string.lower()

参数值

无参数

实例

str1 = 'Hello Python'
print(str1.lower())

hello python

4、upper()方法

upper() 方法将字符串中的小写字母转为大写字母（符号和数字将被忽略）。

语法

string.upper()

参数值

无参数

实例

str1 = 'Hello Python'
print(str1.upper())

HELLO PYTHON

5、title()方法

title() 方法返回"标题化"的字符串,就是说所有单词的首个字母转化为大写，其余字母均为小写。

语法

string.title()

参数值

无参数

实例

str1 = 'HELLO Python'
print(str1.title())

Hello Python

6、swapcase()方法

swapcase() 方法用于对字符串的大小写字母进行转换，即将大写字母转换为小写字母，小写字母会转换为大写字母。

语法

string.swapcase()

参数值

无参数

实例

str1 = 'Hello Python'
print(str1.swapcase())

hELLO pYTHON

5.1.2 判断大小写 islower()、isupper()、istitle()

1、islower()方法

islower() 方法检测字符串是否由小写字母组成。

语法

string.islower()

参数值

无参数

str1 = 'Hello Python'
print(str1.islower())

False

如果所有字符均为小写，则 islower() 方法返回 True，否则返回 False。不检查数字、符号和空格，仅检查字母字符。

2、isupper()方法

isupper() 方法检测字符串中所有的字母是否都为大写。

语法

string.isupper()

参数值

无参数

实例

str1 = 'Hello Python'
print(str1.isupper())

False

如果所有字符均大写，则 isupper() 方法返回 True，否则返回 False。不检查数字、符号和空格，仅检查字母字符。

3、istitle()方法

istitle() 方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。

语法

string.istitle()

参数值

无参数

实例

str1 = 'Hello Python'
print(str1.istitle())

True

如果文本中的所有单词均以大写字母开头，而单词的其余部分均为小写字母，则 istitle() 方法返回 True。否则返回 False。符号和数字将被忽略。

5.2 搜索值

5.2.1 返回出现次数 count()

count()方法

count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。

语法

string.count(value, start, end)

参数值

参数	描述
value	必需。字符串。要检索的字符串。
start	可选。整数。开始检索的位置。默认是 0。
end	可选。整数。结束检索的位置。默认是字符串的结尾。

实例

txt = "I love apples, apple are my favorite fruit"
print(txt.count("apple", 10, 24))

1

5.2.2 从左搜索并返回 find()、index()

1、find()方法

find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果指定范围内如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回 -1。

语法

string.find(value, start, end)

参数值

参数	描述
value	必需。要检索的值。
start	可选。开始检索的位置。默认是 0。
end	可选。结束检索的位置。默认是字符串的结尾。

实例

• 字母 “e” 在文本总首次出现的位置：

txt = "Hello, welcome to my world."
x = txt.find("e")
print(x)

1

• 如果只搜索位置 5 到 10 时，字母 “e” 在文本总首次出现的位置：

txt = "Hello, welcome to my world."
x = txt.find("e", 5, 10)
print(x)

8

• 如果找不到该值，则 find() 方法返回 -1，但是 index() 方法将引发异常：

txt = "Hello, welcome to my world."
print(txt.find("q"))
print(txt.index("q"))

Traceback (most recent call last):File "C:\Users\MK\Desktop\Python方法\str.py", line 4, in <module>print(txt.index("q"))
ValueError: substring not found
-1

2、index()方法

index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 find() 方法一样，只不过如果str不在 string中会报一个异常。

语法

string.index(value, start, end)

参数值

参数	描述
value	必需。要检索的值。
start	可选。在哪里开始检索。默认是 0。
end	可选。在哪里结束检索。默认是字符串的末尾。

实例

• 字母 “e” 在文本中首次出现在哪里？

txt = "Hello, welcome to my world."
x = txt.index("e")
print(x)

1

• 如果只在位置 5 和 10 之间搜索时，字母 "e"首次首先在哪里？

txt = "Hello, welcome to my world."
x = txt.index("e", 5, 10)
print(x)

8

• 如果找不到该值，则 find() 方法返回 -1，但是 index() 方法将引发异常：

txt = "Hello, welcome to my world."
print(txt.find("q"))
print(txt.index("q"))

-1
Traceback (most recent call last):File "C:\Users\MK\Desktop\Python方法\str.py", line 3, in <module>print(txt.index("q"))
ValueError: substring not found

3、find() 和 index() 区别

find() 方法与 index() 方法几乎相同，唯一的区别是，如果找不到该值，index() 方法将引发异常，则 find() 方法将返回 -1。

5.2.3 从右搜索并返回 rfind()、rindex()

1、rfind()方法

rfind() 返回字符串最后一次出现的位置，如果没有匹配项则返回 -1 。

语法

string.rfind(value, start, end)

参数值

参数	描述
value	必需。要检索的值。
start	可选。从何处开始检索。默认是 0。
end	可选。在何处结束检索。默认是到字符串的末尾。

实例

• 在哪里最后出现文本中的字母 “e”？

txt = "Hello, welcome to my world."
x = txt.rfind("e")
print(x)

13

• 如果只在位置 5 和位置 10 之间搜索，文本中最后出现的字母 “e” 在何处？

txt = "Hello, welcome to my world."
x = txt.rfind("e", 5, 10)
print(x)

8

• 如果找不到该值，则 rfind() 方法返回 -1，但是 rindex() 方法将引发异常：

txt = "Hello, welcome to my world."
print(txt.rfind("q"))
print(txt.rindex("q"))

-1
Traceback (most recent call last):File "C:\Users\MK\Desktop\Python方法\str.py", line 3, in <module>print(txt.rindex("q"))
ValueError: substring not found

2、rindex()方法

rindex() 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，你可以指定可选参数[beg:end]设置查找的区间。

语法

string.rindex(value, start, end)

参数值

参数	描述
value	必需。要检索的值。
start	可选。从何处开始检索。默认是 0。
end	可选。在何处结束检索。默认是到字符串的末尾。

实例

• 在哪里最后出现文本中的字母 “e”？

txt = "Hello, welcome to my world."
x = txt.rindex("e")
print(x)

13

• 如果只在位置 5 和位置 10 之间搜索，文本中最后出现的字母 “e” 在何处？

txt = "Hello, welcome to my world."
x = txt.rindex("e", 5, 10)
print(x)

8

• 如果找不到该值，则 rfind() 方法返回 -1，但是 rindex() 方法将引发异常：

txt = "Hello, welcome to my world."
print(txt.rfind("q"))
print(txt.rindex("q"))

-1
Traceback (most recent call last):File "C:\Users\MK\Desktop\Python方法\str.py", line 3, in <module>print(txt.rindex("q"))
ValueError: substring not found

3、rfind() 和 rindex() 区别

rfind() 和 rindex() 都是查找指定值的最后一次出现。如果找不到该值，则 rfind() 方法将返回 -1，而 rindex() 方法将引发异常。

5.3 以 str 开头/结束 startswith()、endswith()

1、startswith()方法

startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。

语法

string.startswith(value, start, end)

参数值

参数	描述
value	必需。检查字符串是否以其开头的值。
start	可选。整数，规定从哪个位置开始搜索。
end	可选。整数，规定结束搜索的位置。

实例

检查位置 7 到 20 是否以字符 “wel” 开头：

txt = "Hello, welcome to my world."
x = txt.startswith("wel", 7, 20)
print(x)

True

如果字符串以指定的值开头，则 startswith() 方法返回 True，否则返回 False。

2、endswith()方法

endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回 True，否则返回 False。可选参数 “start” 与 “end” 为检索字符串的开始与结束位置。

语法

string.endswith(value, start, end)

参数值

参数	描述
value	必需。检查字符串是否以之结尾的值。
start	可选。整数。规定从哪个位置开始检索。
end	可选。整数。规定从哪个位置结束检索。

实例

• 检查字符串是否以短语 “my world.” 结尾：

txt = "Hello, welcome to my world."
x = txt.endswith("my world.")
print(x)

True

• 检查位置 5 至 11 是否以短语 “my world.” 结尾：

txt = "Hello, welcome to my world."
x = txt.endswith("my world.", 5, 11)
print(x)

False

如果字符串以指定值结尾，则 endswith() 方法返回 True，否则返回 False。

5.4 编/解码 encode()、decode()

encode()和 decode()

encode() 方法以指定的编码格式编码字符串，decode() 方法以指定的解码格式解码字符串。

errors参数可以指定不同的错误处理方案。

语法

string.encode(encoding=encoding, errors=errors)
string.decode(decoding=decoding, errors=errors)

参数值

参数	描述
encoding / decoding	可选。字符串。规定要使用的编码/解码。默认是 UTF-8。
errors	可选。字符串。规定错误方法。合法值是： ‘backslashreplace’ - 使用反斜杠代替无法编码的字符 ‘ignore’ - 忽略无法编码的字符 ‘namereplace’ - 用解释字符的文本替换字符 ‘strict’ - 默认值，失败时引发错误 ‘replace’ - 用问号替换字符 ‘xmlcharrefreplace’ - 用 xml 字符替换字符

实例

str = 'pink老师'str_utf8 = str.encode("UTF-8")
str_gbk = str.encode("GBK")print("UTF-8 编码：", str_utf8)
print("GBK 编码：", str_gbk)print("UTF-8 解码：", str_utf8.decode('UTF-8', 'strict'))
print("GBK 解码：", str_gbk.decode('GBK', 'strict'))

UTF-8 编码： b'pink\xe8\x80\x81\xe5\xb8\x88'
GBK 编码： b'pink\xc0\xcf\xca\xa6'
UTF-8 解码： pink老师
GBK 解码： pink老师

5.5 填充对齐 center()、ljust()、rjust()、zfill()

1、center()方法

center() 方法返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。

语法

string.center(length, character)

参数值

参数	描述
length	必需。所返回字符串的长度。
character	可选。填补两侧缺失空间的字符。默认是 " "（空格）。

实例

使用字母 “O” 作为填充字符：

txt = "banana"
x = txt.center(20, "O")
print(x)

OOOOOOObananaOOOOOOO

2、ljust()方法

ljust() 方法返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

语法

string.ljust(length, character)

参数值

参数	描述
length	必需。所返回字符串的长度。
character	可选。用于填充缺少空间（在字符串的右侧）的字符。默认值为 " "（空格）。

实例

使用字母 “O” 作为填充字符：

txt = "banana"
x = txt.ljust(20, "O")
print(x)

bananaOOOOOOOOOOOOOO

3、rjust()方法

rjust() 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串。

语法

string.rjust(length, character)

参数值

参数	描述
length	必需。所返回字符串的长度。
character	可选。用于填充缺失空间（在字符串的左侧）字符。默认值为 " "（空格）。

实例

使用字母 “O” 作为填充字符：

txt = "banana"
x = txt.rjust(20, "O")
print(x)

OOOOOOOOOOOOOObanana

4、zfill()方法

zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充0。

语法

string.zfill(len)

参数值

参数	描述
len	必需。数字，规定要删除的元素的位置。

实例

用零填充字符串，直到它们长为 10 个字符：

a = "hello"
b = "welcome to my world"
c = "10.000"print(a.zfill(10))
print(b.zfill(10))
print(c.zfill(10))

00000hello
welcome to my world
000010.000

zfill() 方法在字符串的开头添加零（0），直到达到指定的长度。如果 len 参数的值小于字符串的长度，则不执行填充。

5.6 删除左/右指定字符 lstrip()、rstrip()、strip()

1、lstrip()方法

lstrip() 方法用于截掉字符串左边的空格或指定字符。

语法

string.lstrip(characters)

参数值

参数	描述
characters	可选。一组作为前导字符要删除的字符。

实例

删除前导字符：

txt = ",,,,,ssaaww.....banana"
x = txt.lstrip(",.asw")
print(x)

banana

2、rstrip()方法

rstrip() 删除 string 字符串末尾的指定字符，默认为空白符，包括空格、换行符、回车符、制表符。

语法

string.rstrip(characters)

参数值

参数	描述
characters	可选。一组作为结尾字符要删除的字符。

实例

删除结尾字符：

txt = "banana,,,,,ssaaww....."
x = txt.rstrip(",.asw")
print(x)

banan

3、strip()方法

strip() 方法用于移除字符串头尾指定的字符（默认为空格）或字符序列。

语法

string.strip(characters)

参数值

参数	描述
characters	可选。一组字符，要删除的前导/尾随字符的字符。

实例

删除前导和尾随字符：

txt = ",,,,,rrttgg.....banana....rrr"
x = txt.strip(",.grt")
print(x)

banana

5.7 判断字符(串)

5.7.1 空白字符 isspace()

1、isspace()方法

isspace() 方法检测字符串是否只由空白字符组成。

语法

string.isspace()

参数值

无参数

实例

txt = "   s   "
x = txt.isspace()
print(x)

False

如果字符串中的所有字符都是空格，则 isspace() 方法将返回 True，否则返回 False。

5.7.2 可打印 isprintable()

2、isprintable()方法

isprintable() 方法检查文本中的所有字符是否可打印。

语法

string.isprintable()

参数值

无参数

实例

txt = "Hello!\nAre you #1?"
x = txt.isprintable()
print(x)

False

如果所有字符都是可打印的，则 isprintable() 方法返回 True，否则返回 False。不可打印的字符可以是回车和换行符。

5.7.3 标识符 isidentifier()

3、isidentifier()方法

isidentifier() 方法检查字符串是否是有效标识符。

语法

string.isidentifier()

参数值

无参数

实例

a = "MyFolder"
b = "Demo002"
c = "2bring"
d = "my demo"print(a.isidentifier())
print(b.isidentifier())
print(c.isidentifier())
print(d.isidentifier()

True
True
False
False

如果字符串是有效标识符，则 isidentifier() 方法返回 True，否则返回 False。

如果字符串仅包含字母数字字母（a-z）和（0-9）或下划线（_），则该字符串被视为有效标识符。有效的标识符不能以数字开头或包含任何空格。

5.7.4 字母/数字 isalnum()

4、isalnum()方法

isalnum() 方法检测字符串是否由字母和数字组成。

语法

string.isalnum()

参数值

无参数

实例

检查文本中的所有字符是否都是字母数字：

txt = "Company 12"
x = txt.isalnum()
print(x)

False

如果所有字符均为字母数字，即字母（a-z）和数字（0-9），则 isalnum() 方法返回 True。

非字母数字的例子：(space)!#%&? 等等。

5.7.5 字母/中文 isalpha()

5、isalpha()方法

isalpha() 方法检测字符串是否只由字母或文字组成。

语法

string.isalpha()

参数值

无参数

实例

检查文本中的所有字符是否都是字母：

txt = "Company10"
x = txt.isalpha()
print(x)

False

如果所有字符都是字母（a-z），则 isalpha() 方法将返回 True。

非字母的字符例子：(space)!#%&? 等等。

5.7.6 数字 isdigit()、isnumeric()、isdecimal()

6.1、isdigit()方法

isdigit() 方法检测字符串是否只由数字组成。

语法

string.isdigit()

参数值

无参数

实例

检查文本中的所有字符是否都是字母：

a = "\u0030"  # unicode for 0
b = "\u00B2"  # unicode for ²print(a.isdigit())
print(b.isdigit())

True
True

如果所有字符都是数字，则 isdigit() 方法将返回 True，否则返回 False。

指数（例如²）也被视作数字。

6.2、isnumeric()方法

isnumeric() 方法检测字符串是否只由数字组成，数字可以是： Unicode 数字，全角数字（双字节），罗马数字，汉字数字。

指数类似 ² 与分数类似 ½ 也属于数字。

语法

string.isnumeric()

参数值

无参数

实例

检查字符是否为数字：

a = "\u0030"  # unicode for 0
b = "\u00B2"  # unicode for ²
c = "10km2"print(a.isnumeric())
print(b.isnumeric())
print(c.isnumeric())

True
True
False

如果所有字符均为数字（0-9），则 isumeric() 方法返回 True，否则返回 False。

指数（比如 ² 和 ¾）也被视为数字值。

6.3、isdecimal()方法

isdecimal() 方法检查 unicode 对象中的所有字符是否都是小数。

语法

string.isdecimal()

参数值

无参数

实例

检查 unicode 中的所有字符是否都是小数：

a = "\u0030"  # unicode for 0
b = "\u0047"  # unicode for Gprint(a.isdecimal())
print(b.isdecimal())

True
False

如果所有字符均为小数（0-9），则 isdecimal() 方法将返回 True。

此方法用于 unicode 对象。

5.8 格式字符串中指定值 format()、format_map()

1、format()方法

format() 方法格式化指定的值，并将其插入字符串的占位符内，占位符使用大括号 {} 定义。

语法

string.format(value1, value2...)

参数值

参数	描述
value1, value2…	必需。一个或多个应该格式化并插入字符串的值。值可以是数字，用于指定要删除的元素的位置。 这些值可以是用逗号分隔的值列表、键=值列表，或两者的组合。 这些值可以是任何数据类型。

占位符

可以使用命名索引 {price}、编号索引{0}、甚至空的占位符 {} 来标识占位符。

实例

使用不同的占位符值：

txt1 = "My name is {fname}, I'am {age}".format(fname="Bill", age=64)
txt2 = "My name is {0}, I'am {1}".format("Bill", 64)
txt3 = "My name is {}, I'am {}".format("Bill", 64)
print(txt1)
print(txt2)
print(txt3)

My name is Bill, I'am 64
My name is Bill, I'am 64
My name is Bill, I'am 64

格式化类型

在占位符内，您可以添加格式化类型以格式化结果：

格式化类型	描述
:<	左对齐结果（在可用空间内）
:>	右对齐结果（在可用空间内）
:^	居中对齐结果（在可用空间内）
:=	将标志放置在最左侧
:+	使用加号指示结果是正数还是负数
:-	负号仅用于负值
:	使用空格在正数之前插入一个多余的空格（在负数之前使用减号）
:,	使用逗号作为千位分隔符
:_	使用下划线作为千位分隔符
:b	二进制格式
:c	将值转换为相应的 unicode 字符
:d	十进制格式
:e	科学格式，带有小写字母 E
:E	科学格式，带有大写字母 E
:f	定点数字格式
:F	定点数字格式，以大写形式显示（将 inf 和 nan 显示为 INF 和 NAN）
:g	通用格式
:G	通用格式（将大写 E 用作科学计数法）
😮	八进制格式
:x	十六进制格式，小写
:X	十六进制格式，大写
:n	数字格式
:%	百分比格式

2、format_map()方法

format_map() 方法格式化字符串中的指定值。

语法

str.format_map(mapping)

参数值

参数	描述
mapping	字典类型的数据。

实例

str_a = '我是 {name} 老师 {gender} {age} 岁'
dict_1 = {'name': 'pink', 'gender': '男', 'age': 21}
print(str_a.format_map(dict_1))

我是 pink 老师 男 21 岁

5.9 拆分/截取字符串 split()、rsplit()、splitlines()

1、split()方法

split() 通过指定分隔符从左侧对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串。

语法

string.split(separator, max)

参数值

参数	描述
separator	可选。规定分割字符串时要使用的分隔符。默认值为空白字符。
max	可选。规定要执行的拆分数。默认值为 -1，即“所有出现次数”。

实例

• 使用逗号后跟空格作为分隔符，分割字符串：

txt = "hello, my name is Bill, I am 63 years old"
x = txt.split(", ")
print(x)

['hello', 'my name is Bill', 'I am 63 years old']

• 使用 # 号字符作为分隔符：

txt = "apple#banana#cherry#orange"
x = txt.split("#")
print(x)

['apple', 'banana', 'cherry', 'orange']

• 将字符串拆分为最多 2 个项目的列表：

txt = "apple#banana#cherry#orange"
# 将 max 参数设置为 1，将返回包含 2 个元素的列表！
x = txt.split("#", 1)
print(x)

['apple', 'banana#cherry#orange']

split() 方法将字符串拆分为列表。

您可以指定分隔符，默认分隔符是任何空白字符。

**注释：**若指定 max，列表将包含指定数量加一的元素。

2、rsplit()方法

rsplit() 通过指定分隔符从右侧对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串。

语法

string.rsplit(separator, max)

参数值

参数	描述
separator	可选。规定分割字符串时要使用的分隔符。默认值为空白。
max	可选。指定要执行的拆分数。默认值为 -1，即“所有出现次数”。

实例

将字符串拆分为最多 2 个项目的列表：

txt = "apple, banana, cherry"
# 将 max 参数设置为 1，将返回包含 2 个元素的列表！
x = txt.rsplit(", ", 1)
print(x)

['apple, banana', 'cherry']

rsplit() 方法从右侧开始将字符串拆分为列表。

如果未指定 “max”，则此方法将返回与 split() 方法相同的结果。

注释： 若指定 max，列表将包含指定数量加一的元素。

3、splitlines()方法

splitlines() 按照行(‘\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

语法

string.splitlines(keeplinebreaks)

参数值

参数	描述
keeplinebreaks	可选。规定是否应包含换行符（True）或不包含（False）。默认值不包含（False）。

实例

拆分字符串，但保留换行符：

txt = "Thank you for your visiting\nWelcome to China"
x = txt.splitlines(True)
print(x)

['Thank you for your visiting\n', 'Welcome to China']

5.10 拆分字符串(返回元组) partition()、rpartition()

1、partition()方法

partition() 方法搜索指定的字符串，并将该字符串拆分为包含三个元素的元组。

第一个元素包含指定字符串之前的部分，第二个元素包含指定的字符串，第三个元素包含字符串后面的部分。

注释：此方法搜索指定字符串的第一个匹配项。

语法

string.partition(value)

参数值

参数	描述
value	必需。要检索的字符串。

实例

• 搜索单词 “bananas”，并返回包含三个元素的元组：
  • 1 - “匹配”之前的所有内容
  • 2 - “匹配”
  • 3 - “匹配”之后的所有内容

txt = "I could eat bananas all day"
x = txt.partition("bananas")
print(x)

('I could eat ', 'bananas', ' all day')

• 如果找不到指定的值，则 partition() 方法将返回一个元组，其中包含：1 - 整个字符串，2 - 空字符串，3 - 空字符串：

txt = "I could eat bananas all day"
x = txt.partition("apples")
print(x)

('I could eat bananas all day', '', '')

2、rpartition()方法

rpartition() 方法搜索指定字符串的最后一次出现，并将该字符串拆分为包含三个元素的元组。

第一个元素包含指定字符串之前的部分，第二个元素包含指定的字符串，第三个元素包含字符串之后的部分。

语法

string.rpartition(value)

参数值

参数	描述
value	必需。要检索的字符串。

实例

• 搜索单词 “bananas” 的最后一次出现，并返回包含三个元素的元组：
  • 1 - “匹配”之前的所有内容
  • 2 - “匹配”
  • 3 - “匹配”之后的所有内容

txt = "I could eat bananas all day, bananas are my favorite fruit"
x = txt.rpartition("bananas")
print(x)

('I could eat bananas all day, ', 'bananas', ' are my favorite fruit')

• 如果找不到指定的值，则 rpartition() 方法将返回一个元组，其中包含：1 - 整个字符串，2 - 一个空字符串，3 - 一个空字符串：

txt = "I could eat bananas all day, bananas are my favorite fruit"
x = txt.rpartition("apples")
print(x)

('', '', 'I could eat bananas all day, bananas are my favorite fruit')

5.11 字符串转换 maketrans()、translate()

1、maketrans()方法

maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

两个字符串的长度必须相同，为一一对应的关系。

语法

string.maketrans(x[, y[, z]])

参数值

参数	描述
x	必需，字符串中要替代的字符组成的字符串。
y	可选，相应的映射字符的字符串。
z	可选，要删除的字符。

2、translate()方法

translate() 返回被转换的字符串。

实例

• 字母 B 替换为 b

txt = "www.Baidu.com"
url = txt.maketrans('B', 'b')
print(txt.translate(url))

www.baidu.com

• 使用字符串设置要替换的字符，一一对应

x = "aeiou"
y = "12345"
trans = str.maketrans(x, y)str1 = "this is a string"
print(str1.translate(trans))

th3s 3s 1 str3ng

• 设置要删除的字符参数：

txt = "baidu z alibaba  Z tencent"
x = "bat"
y = "BAT"
z = "zZ"  # 设置删除的字符
trans = txt.maketrans(x, y, z)
print(txt.translate(trans))
print(trans)

BAidu  AliBABA   TencenT
{98: 66, 97: 65, 116: 84, 122: None, 90: None

5.12 元组项目连接到字符串 join()

join()方法

join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

语法

string.join(iterable)

参数值

参数	描述
iterable	必需。所有返回值均为字符串的任何可迭代对象。

实例

• 使用哈希字符作为分隔符，将元组中的所有项目连接到字符串中：

tuple_1 = ("baidu", "alibaba", "tencent")
x = "#".join(tuple_1)
print(x)

baidu#alibaba#tencent

• 使用单词 “TEST” 作为分隔符，将字典中的所有项目连接成一个字符串：

dict_1 = {"name": "Bill", "country": "USA"}
separator = "TEST"
x = separator.join(dict_1)
print(x)

nameTESTcountry

5.13 字符串替换 replace()

replace()方法

replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。

语法

string.replace(oldvalue, newvalue, count)

参数值

参数	描述
oldvalue	必需。要检索的字符串。
newvalue	必需。替换旧值的字符串。
count	可选。数字，指定要替换的旧值出现次数。默认为所有的出现。

实例

• 替换单词 “bananas”：

txt = "I like bananas"
x = txt.replace("bananas", "apples")
print(x)

I like apples

• 替换所有出现的单词 “one”：

txt = "one one was a race horse, two two was one too."
x = txt.replace("one", "three")
print(x)

three three was a race horse, two two was three too.

• 替换前两次出现的单词 “one”：

txt = "one one was a race horse, two two was one too."
x = txt.replace("one", "three", 2)
print(x)

three three was a race horse, two two was one too.

5.14 字符串 Tab 转换 expandtabs()

expandtabs()方法

expandtabs() 方法把字符串中的 tab 符号 \t 转为空格，tab 符号 \t 默认的空格数是 8，在第 0、8、16…等处给出制表符位置，如果当前位置到开始位置或上一个制表符位置的字符数不足 8 的倍数则以空格代替。

语法

string.exandtabs(tabsize)

参数值

参数	描述
tabsize	可选。规定制表符大小的数字。默认的 tabsize 是 8。

实例

• 将制表符大小设置为 2 个空格：

txt = "H\te\tl\tl\to"
x = txt.expandtabs(2)
print(x)

H e l l o

• 请看看不同制表符大小的结果：

txt = "H\te\tl\tl\to"print(txt)
print(txt.expandtabs())
print(txt.expandtabs(2))
print(txt.expandtabs(4))
print(txt.expandtabs(10))

H	e	l	l	o
H       e       l       l       o
H e l l o
H   e   l   l   o
H         e         l         l         o

6、总结

函数	描述
print()	打印输出
len()	确定字符串长度
type()	返回变量类型
str()	转换为字符串
max()	字符串最大字符
min()	字符串最小字符
del	删除字符串

方法	描述
capitalize()	把首字符转换为大写
casefold()	把字符串转换为小写（处理其他语言且存在大小写）
lower()	把字符串转换为小写
islower()	如果字符串中的所有字符都是小写，则返回 True
upper()	把字符串转换为大写
isupper()	如果字符串中的所有字符都是大写，则返回 True
title()	返回"标题化"字符串：所有单词都以大写开始，其余字母均为小写
istitle()	如果字符串遵循标题规则，则返回 True
swapcase()	将字符串中大写转换为小写，小写转换为大写
count(str, beg, end)	返回str出现的次数，beg和end指定范围
find(str, beg, end)	搜索指定的值并返回该位置，beg 和 end 指定范围，不存在返回-1
index(str, beg, end)	搜索指定的值并返回该位置，beg 和 end 指定范围，不存在报异常
rfind(str, beg, end)	类似于 find() ，不过是从右边开始
rindex( str, beg, end)	类似于 index()，不过是从右边开始
startswith(str, beg, end)	检查是否以 str 开头，beg 和 end 指定范围，如果是，返回 True，否则返回 False
endswith(str, beg, end)	检查是否以 str 结束，beg 和 end 指定范围，如果是，返回 True，否则返回 False
encode(‘UTF-8’, ‘strict’)	编码，出错默认报 ValueError 异常，除非 errors 指定的是’ignore’或者’replace’
decode(‘UTF-8’, ‘strict’)	解码，出错默认报 ValueError 异常，除非 errors 指定的是’ignore’或者’replace’
center(width, fillchar)	返回一个指定的宽度width居中的字符串，fillchar为填充的字符，默认为空格
ljust(width, fillchar)	字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格
rjust(width, fillchar)	字符串右对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格
zfill (width)	返回长度为 width 的字符串，原字符串右对齐，前面填充0
lstrip()	删除字符串左边的空格或指定字符
rstrip()	删除字符串末尾的空格或指定字符
strip()	在字符串上执行 lstrip()和 rstrip()，返回字符串的剪裁版本
isspace()	如果字符串中的所有字符都是空白字符，则返回 True
isprintable()	如果字符串中的所有字符都是可打印的，则返回 True
isidentifier()	如果字符串是标识符，则返回 True
isalnum()	如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True，否则返回 False
isalpha()	如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False
isdigit()	如果字符串只包含数字则返回 True ，否则返回 False
isnumeric()	如果字符串中的所有字符都是数字，则返回 True
isdecimal()	检查所有字符是否都是十进制数（0~9），是则返回 True, 否则返回 False
format()	格式化字符串中的指定值
format_map()	格式化字符串中的指定值（字典）
split(str, num)	以 str 为分隔符截取，若 num 指定，则截取 num+1 个子字符串，并返回列表（从左）
rsplit()	以 str 为分隔符截取，若 num 指定，则截取 num+1 个子字符串，并返回列表（从右）
splitlines()	在换行符处拆分字符串并返回列表
partition()	返回元组，其中的字符串分为三部分（搜索 str 第一次出现）
rpartition()	返回元组，其中的字符串分为三部分（搜索 str 最后出现）
maketrans(x[, y[, z]])	x – 必需，要替代的字符串， y – 可选，相应映射的字符串， z – 可选，要删除的字符
translate()	返回被转换的字符串
join()	使用字符作为分隔符，将元组中的所有项目连接到字符串中
replace(old, new [, max])	将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max
expandtabs(tabsize)	把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8

以上就是本文的全部内容啦！如果对您有帮助，麻烦点赞啦！收藏啦！欢迎各位评论区留言！！！

最后编辑于：2022/7/31 16:27

---

集合set

集合（set）是一个无序的不重复元素序列。

1、构造集合

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

1、使用大括号{}

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket)  # {'apple', 'orange', 'banana', 'pear'}

当使用print()函数打印输出时，会自动将集合中重复的元素去除，且每次打印返回的顺序并不和初始的一致。

2、使用set()函数

fruit = set(("apple", "banana", "cherry"))  # 请留意这个双括号
print(fruit)  # {'banana', 'apple', 'cherry'}

在使用set()函数创建集合时，一定要注意双括号。

2、基本计算

经过上述学习，我们已经知道如何创建集合。而两个集合之间的计算有4种，分别是-、|、&和^。

先创建两个集合，方便下面对其进行运算。

a = set('abcdefg')
b = set('abg')

2.1 -

print(a - b)  # {'e', 'd', 'f', 'c'}

a - b 表示：集合 a 中包含而集合 b 中不包含的元素

2.2 |

print(a | b)  # {'d', 'b', 'e', 'c', 'g', 'f', 'a'}

a | b 表示：集合 a 或集合 b 中包含的所有元素

2.3 &

print(a & b)  # {'a', 'b', 'g'}

a & b 表示：集合 a 和集合 b 都包含了的元素

2.4 ^

print(a ^ b)  # {'e', 'c', 'd', 'f'}

a ^ b 表示：不同时包含集合 a 和集合 b 的元素

3、访问项目

我们无法通过引用索引来访问 set 中的项目，因为 set 是无序的，项目没有索引。

但是可以使用 for 循环遍历 set 项目，或者使用 in 关键字查询集合中是否存在指定值。

实例

遍历集合，并打印值：

fruit = {'apple', 'banana', 'cherry'}
for key in fruit:print(key)

检查 set 中是否存在 “banana”

fruit = {'apple', 'banana', 'cherry'}
print('banana' in fruit)

若输出True，则表示指定值存在于该集合中；若输出False，则表示指定值不存在于该集合中。

4、内置函数

4.1 打印输出 print()

1、print()函数

从上述构造集合中，我们可以得知 print() 的作用就是打印输出小括号() 里的内容或值。

4.2 计算集合内元素 len()

2、len()函数

当我们想要获取集合 set 的长度，即确定集合中有多少项，就要使用 len() 方法。

print(len(basket))  # 4
print(len(fruit))  # 3

我们注意到，在上述构造集合 basket 和 fruit 时，在 {} 中填入6个元素，当我们使用len()函数定长时，会发现其自动去除重复的元素，再返回。

4.3 返回变量类型 type()

3、type()函数

print(type(basket))  # <class 'set'>

当我们使用 {} 或 set() 构造好集合时，对其使用 type() 函数，会输出set，则表明这是一个集合。

4.4 删除集合 del

4、del函数

我们已经构造好 basket 和 fruit 这两个集合，如果需要对其删除则使用del函数。

fruit = set(("apple", "banana", "cherry"))  # 请留意这个双括号
del fruit
print(fruit)  # NameError: name 'fruit' is not defined.

注意：使用完del()函数删除集合后，如再用print()函数打印时，会报错NameError: name 'fruit' is not defined.，意为fruit未被定义，说明已删除。

5、内置方法

5.1 添加元素 add()、updata()

1、add()方法

add() 方法用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作。

语法

set.add(element)

参数值

参数	描述
element	必需。要添加到集合的元素。

实例

向 fruits 集合添加一个元素：

fruits = {"apple", "banana", "cherry"}
fruits.add("orange") 
print(fruits)

输出结果：

{'apple', 'banana', 'orange', 'cherry'}

如果该元素已存在，则 add() 方法就不会添加元素。

fruits = {"apple", "banana", "cherry"}
fruits.add("apple")
print(fruits)

输出结果：

{'apple', 'banana', 'cherry'}

2、updata()方法

update() 方法用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。

语法

set.update(set)

参数值

参数	描述
set	必需。插入当前集合的集合。

实例

合并两个集合，重复元素只会出现一次：

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"} 
x.update(y) 
print(x)

输出结果：

{'banana', 'apple', 'google', 'runoob', 'cherry'}

5.2 移除元素 remove()、discard()、pop()

1、remove()方法

remove() 方法用于移除集合中的指定元素。

该方法不同于 discard() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。

语法

set.remove(item)

参数值

参数	描述
item	必需。需要检索并删除的项目。

实例

移除元素 banana：

fruits = {"apple", "banana", "cherry"}
fruits.remove("banana") 
print(fruits)

输出结果：

{'cherry', 'apple'}

2、discard()方法

discard() 方法用于移除指定的集合元素。

该方法不同于 remove() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。

语法

set.discard(value)

参数值

参数	描述
value	必需。要检索并删除的项目。

实例

移除集合中的元素 banana：

fruits = {"apple", "banana", "cherry"}
fruits.discard("banana") 
print(fruits)

输出结果：

{'cherry', 'apple'}

3、pop()方法

pop() 方法用于随机移除一个元素。

语法

set.pop()

参数值

无参数值。

实例

随机移除一个元素：

fruits = {"apple", "banana", "cherry"}
fruits.pop()  
print(fruits)

输出结果：

{'apple', 'banana'}

使用pop()方法删除项目，但此方法将删除最后一项。

同时请记住，集合set是无序的，因此您也不知道被删除的是什么项目。

5.3 清空集合 clear()

1、clear()方法

clear() 方法用于移除集合中的所有元素。

语法

set.clear()

参数值

无参数。

实例

移除 fruits 集合中的所有元素：

fruits = {"apple", "banana", "cherry"}
fruits.clear()
print(fruits)

输出结果：

set()

特别注意：clear() 功能是移除集合中所有元素，而del 功能是删除集合。

所以，当对一个集合使用clear()方法或del函数，并分别对其使用print()函数打印输出时，前者会返回一个空的集合即set()，而后者会报错即NameError: name 'fruit' is not defined.

clear() 从内存删除集合与清空集合，但内存地址不删除，del() 则会从内存中删除。

5.4 合并集合 union()、update()

在Python中，有几种方法可以连接两个或多个集合。

可以使用 union() 方法返回包含两个集合中所有项目的新集合，也可以使用 update() 方法将一个集合中的所有项目插入另一个集合中。

1、union()方法

union() 方法返回两个集合的并集，即包含了所有集合的元素，重复的元素只会出现一次。

语法

set.union(set1, set2 ...)

参数值

参数	描述
set1	必需。要整合的集合。
set2	可选。要整合的另一集合。您能够比较任意多的集合。集合由逗号分隔。

实例

合并两个集合，重复元素只会出现一次：

set1 = {'a', 'b', 'c'}
set2 = {1, 2, 3, 'c'}
print(set1.union(set2))

输出结果：

{1, 2, 'b', 3, 'c', 'a'}

合并多个集合：

set1 = {'a', 'b', 'c'}
set2 = {1, 2, 3}
set3 = {'A', 'B'}
print(set1.union(set2, set3))

输出结果：

{1, 2, 3, 'B', 'b', 'A', 'a', 'c'}

2、update()方法

update() 方法在前面已经讲解过，在此仅作实例演示。

实例

update() 方法将 set2 中的项目插入 set1 中：

set1 = {'a', 'b', 'c'}
set2 = {1, 2, 3}
set1.update(set2)
print(set1)

输出结果：

{1, 2, 3, 'b', 'a', 'c'}

注释：

• union() 和 update() 都将排除任何重复项。
• 还有其他方法将两个集合连接起来，并且仅保留重复项，或者永远不保留重复项。

5.5 拷贝集合 copy()

copy() 方法用于拷贝一个集合。

语法

set.copy()

参数值

无参数。

实例

复制 fruits 集合：

fruits = {"apple", "banana", "cherry"}
print(fruits.copy())

输出结果：

{'apple', 'banana', 'cherry'}

5.6 判断是否包含相同元素 isdisjoint()

isdisjoint() 方法用于判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。

语法

set.isdisjoint(set)

参数值

参数	描述
set	必需。要在其中检索相同项目的集合。

实例

判断集合 y 中是否有包含 集合 x 的元素：

x = {'a', 'b', 'c'}
y = {'x', 'y', 'z'}
print(x.isdisjoint(y))

输出结果：

True

注意：isdisjoint() 方法在判断两个集合是否包含相同元素时，如果不包含相同的元素则返回True，而包含相同的元素则返回False

5.7 返回交集 intersection()、intersection_update()

1、intersection()方法

intersection() 方法用于返回两个或更多集合中都包含的元素，即交集。

语法

set.intersection(set1, set2 ... etc)

参数值

参数	描述
set1	必需。要在其中检索相同项目的集合。
set2	可选。其他需要在其中检索相同项目的集合。您可以比较任意多的集合。集合之间由逗号分隔。

实例

返回一个新集合，该集合的元素既包含在集合 x 又包含在集合 y 中：

x = {'a', 'b', 'c'}
y = {'x', 'y', 'z', 'c'}
print(x.intersection(y))

输出结果：

{'c'}

计算多个集合的交集：

x = {'a', 'b', 'c'}
y = {'x', 'y', 'z', 'c'}
z = {'c', 'a', 'd'}
print(x.intersection(y, z))

输出结果：

{'c'}

返回的集合仅包含两个集合中都存在的项目，或者如果使用两个以上的集合进行比较，则在所有集合中都存在。

2、intersection_update()方法

intersection_update() 方法用于获取两个或更多集合中都重叠的元素，即计算交集。

语法

set.intersection_update(set1, set2 ... etc)

参数值

参数	描述
set1	必需。要在其中检索相等项目的集合。
set2	可选。要在其中检索相等项目的另一集合。您能够比较任意多的集合。集合由逗号分隔。

实例

移除 x 集合中不存在于 y 集合中的元素：

x = {'a', 'b', 'c'}  # y 集合不包含 a，被移除
y = {'x', 'y', 'b', 'c'}
x.intersection_update(y)
print(x)

输出结果：

{'b', 'c'}

计算多个集合的并集：

x = {'a', 'b', 'c'}
y = {'c', 'd', 'e'}
z = {'f', 'g', 'c'}
x.intersection_update(y, z)
print(x)

输出结果：

{'c'}

intersection_update() 方法不同于 intersection() 方法，因为 intersection() 方法是返回一个新的集合，而 intersection_update() 方法是在原始的集合上移除不重叠的元素。

5.8 判断子集 issubset() 、issuperset()

1、issubset()方法

issubset() 方法用于判断集合的所有元素是否都包含在指定集合中，如果是则返回 True，否则返回 False。

语法

set.issubset(set)

参数值

参数	描述
set	必需。在其中检索相等项目的集合。

实例

如果集合 y 中存在集合 x 中的所有项目，则返回 True：

x = {'a', 'b', 'c'}
y = {'x', 'y', 'z', 'a', 'b', 'c'}
print(x.issubset(y))

输出结果：

True

如果没有全部包含返回 False：

x = {'a', 'b', 'c'}
y = {'x', 'y', 'z', 'a'}
print(x.issubset(y))

输出结果：

False

注意：使用x.issubset(y)时，简单地说，当集合 x 中所有项目都存在于集合 y 中时，返回True，反之（集合 x 中有一个或多个都不存在于集合 y 中，就返回 False）。

2、issuperset()方法

issuperset() 方法用于判断指定集合的所有元素是否都包含在原始的集合中，如果是则返回 True，否则返回 False。

语法

set.issuperset(set)

参数值

参数	描述
set	必需。要在其中检索相等项目的集合。

实例

判断集合 y 的所有元素是否都包含在集合 x 中：

x = {'a', 'b', 'c', 'x', 'y', 'z'}
y = {'a', 'b', 'c'}
print(x.issuperset(y))

输出结果：

True

如果没有全部包含返回 False：

x = {'a', 'x', 'y', 'z'}
y = {'a', 'b', 'c'}
print(x.issuperset(y))

输出结果：

False

issuperset() 和 issubset() 类似，如果全都包含就返回True，反之（有一个或多个未包含）就返回False。

5.9 差集 difference() 、difference_update()

1、difference()方法

difference() 方法用于返回集合的差集，即返回的集合元素包含在第一个集合中，但不包含在第二个集合(方法的参数)中。

语法

set.difference(set)

参数值

参数	描述
set	必需。要检查其中差异的项目。

实例

返回一个集合，元素包含在集合 x ，但不在集合 y ：

x = {'a', 'b', 'c', 'x', 'y', 'z'}
y = {'a', 'b', 'c'}
print(x.difference(y))

输出结果：

{'x', 'y', 'z'}

2、difference_update()方法

difference_update() 方法用于移除两个集合中都存在的元素。

语法

set.difference_update(set)

参数值

参数	描述
set	必需。要检查其中差异的集合。

实例

移除两个集合都包含的元素：

x = {'a', 'b', 'c', 'x', 'y', 'z'}
y = {'a', 'b', 'c'}
x.difference_update(y)
print(x)

输出结果：

{'x', 'z', 'y'}

difference_update() 方法与 difference() 方法的区别在于 difference() 方法返回一个移除相同元素的新集合，而 difference_update() 方法是直接在原来的集合中移除元素，没有返回值。

5.10 移除元素 symmetric_difference()、symmetric_difference_update()

1、symmetric_difference()方法

symmetric_difference() 方法返回两个集合中不重复的元素集合，即会移除两个集合中都存在的元素。

语法

set.symmetric_difference(set)

参数值

参数	描述
set	必需。用于检查匹配项的集合。

实例

返回两个集合组成的新集合，但会移除两个集合的重复元素：

x = {'a', 'b', 'c', 'x', 'y', 'z'}
y = {'a', 'b', 'c', 'Q', 'W', 'E'}
print(x.symmetric_difference(y))

输出结果：

{'x', 'Q', 'z', 'E', 'y', 'W'}

2、symmetric_difference_update()方法

symmetric_difference_update() 方法移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

语法

set.symmetric_difference_update(set)

参数值

参数	描述
set	必需。用于检查匹配项的集合。

实例

在原始集合 x 中移除与 y 集合中的重复元素，并将不重复的元素插入到集合 x 中：

x = {'a', 'b', 'c', 'x', 'y', 'z'}
y = {'a', 'b', 'c', 'Q', 'W', 'E'}
x.symmetric_difference_update(y)
print(x)

输出结果：

{'z', 'Q', 'x', 'W', 'E', 'y'}

6、 总结

函数	描述
print()	打印输出
len()	计算集合内元素
type()	返回变量类型
del	删除集合

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

---

字典dict

字典是一个无序、可变和有索引的集合。在 Python 中，字典用花括号编写，拥有键和值。

1、创建字典

在Python中，我们可以使用 {} 或者 dict() 函数来创建字典。

1、使用 {}

• 使用大括号 {} 创建空字典

empty_dict = {}

• 字典的每个键值 key: value 用冒号 : 分割，且每个对之间用逗号 , 分割，整个字典包括在花括号 {} 中，格式如下：

d = {key1: value1, key2: value2, key3: value3}

注意：dict 作为Python的关键字和内置函数，变量名不建议命名为 dict 。

2、使用dict()

• 使用 dict() 创建空字典

empty_dict = dict()

• 使用 dict() 创建非空字典

notEmpty_dict = dict(name='xm', gender=True, age=21)

在使用 dict() 创建字典时，在小括号 () 内要以 key=value 的形式编写。

1.1 字典键的特性

1、不允许同一个键出现两次。创建时如果同一个键被赋值两次，则后一个值会被记住，如下实例：

repeat_dict = {'name': 'xm', 'gender': True, 'name': 'pink'}
print(repeat_dict)  # {'name': 'pink', 'gender': True}

2、键必须不可变，所以可以用数字、字符串或元组充当，而用列表就不行，如下实例：

error_dict = {['name']: 'pink', 'age': 21}
print(error_dict)

当字典的键使用列表时，会报错TypeError: unhashable type: 'list'。

2、访问字典值

2.1 直接访问

如果想要访问某一个键所对应的值，直接将相应的键放入到 [] 内，如下实例：

not_dict = {'name': 'xm', 'gender': True, 'age': 21, 178: 65}
print(not_dict['name'])
print(not_dict[178])

2.2 for循环遍历

循环遍历字典时，返回值是字典的键，但也有返回值的方法。

info_dict = {'name': 'xm', 'gender': True, 'age': 21}

• 逐个打印字典中的所有键名：

for key in info_dict:print(key)

• 逐个打印字典中的所有值：

for key in info_dict:print(info_dict[key])

• 通过使用 value() 方法返回字典的值：

for key in info_dict.values():print(key)

• 通过使用 items() 方法遍历键和值

for key, value in info_dict.items():print(key, value)

2.3 检查键是否存在

要确定字典中是否存在指定的键，使用 in 关键字：

info_dict = {'name': 'xm', 'gender': True, 'age': 21}
print('name' in info_dict)

如果字典中存在指定的键，则返回 True ，反之返回 False 。

2.4 嵌套字典

字典也可以包含许多字典，这被称为嵌套字典。

• 创建包含三个字典的字典

my_family = {'child1': {'name': 'Phoebe Adele','birth': 2002},'child2': {'name': 'Jennifer Katharine','birth': 1996},'child3': {'name': 'Rory John','birth': 1999}
}

或者，如果你想嵌套三个已经作为字典存在的字典。

• 创建三个字典，然后创建一个包含其他三个字典的字典

child1 = {'name': 'Phoebe Adele','birth': 2002
}
child2 = {'name': 'Jennifer Katharine','birth': 1996
}
child3 = {'name': 'Rory John','birth': 1999
}
my_family = {'child1': child1,'child2': child2,'child3': child3
}

3、内置函数

3.1 打印输出 print()

1、print()函数

print() 函数的功能我们已经非常熟悉了，就是打印输出。

info_dict = {'name': 'xm', 'gender': True, 'age': 21}
print(info_dict)

输出：

{'name': 'xm', 'gender': True, 'age': 21}

3.2 确定字典项目 len()

2、len()函数

当我们要确定一个字典有多少项目（键值对），可以使用 len() 函数。

info_dict = {'name': 'xm', 'gender': True, 'age': 21}
print(len(info_dict))

输出结果：

3

使用 len() 函数返回的结果，意为有多少个键值对（即多少个 key: value）。

3.3 返回变量类型 type()

3、type()函数

使用 type() 函数可以确定一个变量是什么类型（字符串、列表、元组、字典或集合）。

info_dict = {'name': 'xm', 'gender': True, 'age': 21}
print(type(info_dict))

输出结果：

<class 'dict'>

1. 当对 info_dict = {key: value} 使用 type() 返回变量类型时，会输出 <class 'dict'> ，表明这是一个字典。
2. 当对 info_set = {key, key} 使用 type() 返回变量类型时，会输出 <class 'set'> ，表明这是一个集合。

3.4 删除字典 del

4、del函数

del 关键字的作用是完全删除字典（和下述要说的清空字典并不一样）

info_dict = {'name': 'xm', 'gender': True, 'age': 21}
del info_dict
print(info_dict)

注意： 当我们使用 del 删除某字典后，再使用 print() 函数打印输出时，会报一个错误 NameError: name 'info_dict' is not defined ，意为该字典并未被创建，注意和清空字典相区分。

3.5 转换成字符串 str()

5、str()函数

str() 的作用就是将一个字典转换成字符串，以便后续的操作。

info_dict = {'name': 'xm'}
info_str = str(info_dict)
print(type(info_str))  # <class 'str'>

如果我们对上述转换后的字符串打印输出的话。会返回 {'name': 'xm'} ,但此时这只是一个字符串，并不存在键值对。

4、内置方法

4.1 删除 pop()、popitem()、clear()、del函数

1、pop()方法

pop() 方法从字典中删除指定的项目，被删除的项目的值是这个 pop() 方法的返回值。

语法

dictionary.pop(key, default)

参数值

参数	描述
key	必需。需要删除项目的键名。
default	可选。返回值，假如指定的键不存在。如果未指定此参数，且未找到拥有指定键的项目，则会引发错误。

实例

info = {'name': 'pink', 'gender:': True, 'age': 21}
print(info)

• 如果 key 存在 - 删除字典中对应的元素

info.pop('name')
print(info)

{'gender:': True, 'age': 21}

• 如果 key 不存在 - 返回设置指定的默认值 default

error = info.pop('nickname', 'key不存在')
print(error)

key不存在

• 如果 key 不存在且默认值 default 没有指定 - 触发 KeyError 异常：KeyError: 'nickname'

2、popitem()方法

popitem() 方法随机返回并删除字典中的最后一对键和值。如果字典已经为空，却调用了此方法，就报出 KeyError 异常。

语法

dictionary.popitem()

参数值

无参数

实例

info = {'name': 'pink', 'gender:': True, 'age': 21}
print(info)
info.popitem()
print(info)

{'name': 'pink', 'gender:': True, 'age': 21}
{'name': 'pink', 'gender:': True}

3、clear()方法

clear() 方法用于删除字典内所有元素。

语法

dictionary.clear()

参数值

无参数

实例

info = {'name': 'pink'}
info.clear()
print(info)

{}

4、del函数

del 函数可用于删除某一特定的键值对。

info = {'name': 'pink', 'gender': True}
print(info)
del info['name']
print(info)

{'name': 'pink', 'gender': True}
{'gender': True}

5、clear()方法和del函数区别

clear() 方法：清空字典（即删除字典内所有键值对），执行结束后，使用 print() 打印时，输出 {} ,说明字典还存在，只是一个空字典。

del 函数：删除字典（即删除所有键值对以及字典），执行结束后，使用 print() 打印时，会报错 NameError: name 'info' is not defined ，表明该字典未被定义，即已不存在字典。

4.2 复制更新 copy()、update()

1、copy()方法

copy() 方法返回一个字典的浅复制。

语法

dictionary.copy()

参数值

无参数

实例

info = {'name': 'pink', 'gender': True}
co = info.copy()
print(co)

{'name': 'pink', 'gender': True}

2、update()方法

update() 方法把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。

语法

dictionary.update(iterable)

参数值

参数	描述
iterable	具有键值对的字典或可迭代对象，会被插入到字典中。

实例

info_1 = {'name': 'pink'}
info_2 = {'age': 21}
info_1.update(info_2)
print(info_1)

{'name': 'pink', 'age': 21}

3、直接更新

可以通过引用键名来更改特定项的值：

info = {'name': 'xm'}

• 若引用的键存在于原字典中，则会修改原键对应的值

info['name'] = 'pink'
print(info)

{'name': 'pink'}

• 若引用的键不存在于原字典中，则会直接添加到原字典中

info['gender'] = True
print(info)

{'name': 'xm', 'gender': True}

4.3 返回指定键值 fromkeys()

fromkeys() 方法用于创建一个新字典，以序列 keys 中元素做字典的键，value 为字典所有键对应的初始值。

语法

dict.fromkeys(keys, value)

参数值

参数	描述
keys	必需。指定新字典键的可迭代对象。
value	可选。所有键的值。默认值是 None。

实例

• value 不指定值

keys = {'A', 'B'}
this_dict = dict.fromkeys(keys)
print(this_dict)

{'A': None, 'B': None}

• value 指定值

keys = {'A', 'B'}
this_dict = dict.fromkeys(keys, 10)
print(this_dict)

{'A': 10, 'B': 10}

4.4 取值 get()、setdefault()

1、get()方法

get() 方法返回具有指定键的项目值。

语法

dictionary.get(keyname, value)

参数值

参数	描述
keyname	必需。您要从中返回值的项目的键名。
value	可选。如果指定的键不存在，则返回一个值。默认值 None。

实例

• get() 用法

info = {'name': 'pink', 'age': 21}
print(info.get('age'))# 没有设置 Sex，也没有设置默认的值，输出 None
print(info.get('sex'))# 没有设置 Salary，输出默认的值  0.0
print(info.get('salary', 0.0))

21
None
0.0

• get() 方法 VS dict[key] 访问元素区别

get(key) 方法在 key（键）不在字典中时，可以返回默认值 None 或者设置的默认值。

dict[key] 在 key（键）不在字典中时，会触发 KeyError 异常。

• 嵌套字典使用

my_csdn = {'My_CSDN': {'url': 'https://blog.csdn.net/m0_70885101?spm=1000.2115.3001.5343'}}
res = my_csdn.get('My_CSDN', {}).get('url')
print(str(res))

https://blog.csdn.net/m0_70885101?spm=1000.2115.3001.5343

2、setfefault()方法

setdefault() 方法和 get() 方法类似, 如果键不存在于字典中，将会添加键并将值设为默认值。

语法

dictionary.setdefault(keyname, value)

参数值

参数	描述
keyname	必需。您要从中返回值的项目的键名。
value	可选。如果键存在，则此参数无效。如果键不存在，则此值将成为键的值。默认值 None。

实例

info = {'name': 'pink', 'age': 21}
print(info.setdefault('age', None))
print(info.setdefault('sex', '男'))
print(info)

21
男
{'name': 'pink', 'age': 21, 'sex': '男'}

4.5 取键/值 items()、keys()、values()

1、items()方法

items() 方法以列表返回视图对象，是一个可遍历的 key/value 键值对。

语法

dictionary.items()

参数值

无参数

实例

info = {'name': 'pink', 'age': 21}
print(info.items())

dict_items([('name', 'pink'), ('age', 21)])

当字典中的项目值发生改变时，视图对象也会更新。

2、keys()方法

keys() 方法返回一个视图对象。

语法

dictionary.keys()

参数值

无参数

实例

info = {'name': 'pink', 'age': 21}
print(info.keys())

dict_keys(['name', 'age'])

当在字典中添加项目时，视图对象也会更新。

3、values()方法

values() 方法返回一个视图对象。

语法

dictionary.values()

参数值

无参数

实例

info = {'name': 'pink', 'age': 21}
print(info.values())

dict_values(['pink', 21])

当字典中的值改变时，视图对象也会更新.

4、items()、keys() 和 values 联系

dict.keys() 、dict.values() 和 dict.items() 返回的都是视图对象（ view objects），提供了字典实体的动态视图，这就意味着字典改变，视图也会跟着变化。

视图对象不是列表，不支持索引，可以使用 list() 来转换为列表。

我们不能对视图对象进行任何的修改，因为字典的视图对象都是只读的。

5、总结

函数	描述
print()	打印输出
len()	计算字典键值对
type()	返回变量类型
del	删除字典
str()	以可打印的字符串表示

方法	描述
pop(key[,default])	删除字典 key（键）所对应的值，返回被删除的值
popitem()	返回并删除字典中的最后一对键和值
clear()	删除字典内所有元素
copy()	返回一个字典的浅复制
update(dict2)	将字典dict2的键/值对更新到dict里
fromkeys()	创建一个新字典，以序列seq中元素做字典的键，val为所有键对应的初始值
get(key, default=None)	返回指定键的值，如果键不在字典中返回 default 设置的默认值
setdefault(key, default=None)	和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
items()	返回包含每个键值对的元组的列表
keys()	返回包含字典键的列表
values()	返回字典中所有值的列表

以上就是本文的全部内容啦！如果对您有帮助，麻烦点赞啦！收藏啦！欢迎各位评论区留言！！！

最后编辑于：2022/7/24 18:19