Python字符串与内置容器（列表List、元组Tuple、字典Dictionary、集合Set）基本操作总结

1 字符串（String）

字符串为由' '或" "包裹起来的任意不可变序列文本序列，索引、切片方式与列表相同（详见2.1）。

1.1 内置字符串处理函数

• len(s)：返回字符串的长度
• str(obj)：将任意类型转化为字符串类型
• chr(x)：返回指定Unicode编码的字符
• ord(c)：返回指定字符的Unicode编码
• hex(x)：将整数转化为十六进制数
• oct(x)：将整数转化为八进制数

print(len("hy awe"))  # 6
print(str(100 + 50j))   # (100+50j)
print(chr(65))  # A
print(ord('a'))   # 97
print(hex(255)) # 0xff
print(oct(64))  # 0o100

1.2 常用内置方法

1.2.1 查找类方法

• .find(s)：查找子串在主串中首次出现的位置，若不存在则返回-1
• .rfind(s)：查找子串在主串中最后一次出现的位置，若不存在则返回-1
• .index(s)：查找子串在主串中首次出现的位置，若不存在则抛出异常
• .rindex(s)：查找子串在主串中最后一次出现的位置，若不存在则抛出异常
• .count(s)：返回子串在主串中出现的次数，若不存在则返回0

s = "hyperplasma"

print(s.find('e'))    # 3
print(s.rfind('a'))   # 10
print(s.index('rp'))  # 4
print(s.rindex('sm')) # 8
print(s.count('a'))   # 2

1.2.2 分割类方法

• .split(c)：以指定字符为分隔符，从原字符串的左端开始将其分割为多个字符串，并返回包含分割结果的列表
• .rsplit(c)：以指定字符为分隔符，从原字符串的右端开始将其分割为多个字符串，并返回包含分割结果的列表
• .partition(s)：以指定字符串为分隔符，从原字符串的左端开始将原字符串分割为3个部分——分隔符之前的字符串、分隔符字符串和分隔符之后的字符串
• .rpartition(s)：以指定字符串为分隔符，从原字符串的右端开始将原字符串分割为3个部分——分隔符之前的字符串、分隔符字符串和分隔符之后的字符串

s = 'teresa kina xiao zeno yohane'

print(s.split(' '))   # ['teresa', 'kina', 'xiao', 'zeno', 'yohane']
print(s.partition('kina'))    # ('teresa ', 'kina', ' xiao zeno yohane')

1.2.3 连接方法

• .join(*s)：将列表中多个字符串进行连接，并在相邻两个字符串之间插入指定字符，返回新字符串
• +运算符（效率略低）

s = "".join((chr(35 + 2 * x) for x in range(20)))
print(s)    # #%')+-/13579;=?ACEGI

1.2.4 大小写字符转换方法

• .lower()：将字符串转换为小写字符串
• .upper()：将字符串转换为大写字符串
• .capitalize()：将字符串首字母变为大写
• .title()：将字符串中每个单词的首字母都变为大写
• .swapcase()：将字符串中的字符大小写互换

s = "How to Set Up a NGINX Web Server"

print(s.lower())    # how to set up a nginx web server
print(s.upper())    # HOW TO SET UP A NGINX WEB SERVER
print(s.capitalize())   # How to set up a nginx web server
print(s.title())    # How To Set Up A Nginx Web Server
print(s.swapcase()) # hOW TO SET uP A nginx WEB SERVER

1.2.5 替换方法

• .replace(s, repl)：替换字符串中所有指定字符或子字符串

s = "black blank"
print(s.replace("la", "fv"))    # bfvck bfvnk

1.2.6 两端删除指定字符方法

s中字符顺序应与串中连续字符顺序相同，默认为空格。

• .strip(s=' ')：删除字符串两端连续指定字符
• .lstrip(s=' ')：删除字符串左端连续指定字符
• .rstrip(s=' ')：删除字符串右端连续指定字符

s = "====****akira-37R++++~~~~"
print(s)    # ====****akira-37R++++~~~~

print(s.strip('=~'))  # ****akira-37R++++
print(s.strip('=*+~'))    # akira-37R

print(s.lstrip('=*')) # akira-37R++++~~~~

print(s.rstrip('+~')) # ====****akira-37R

1.2.7 判断首尾为指定字符串方法

• .startswith(s)：判断是否以指定字符串开始
• .endswith(s)：判断是否以指定字符串结束

s = "hyperplasma"

print(s.startswith('hy')) # True
print(s.endswith('uck'))  # False

1.2.8 判断类型方法

• .isupper()：是否全为大写
• .islower()：是否全为小写
• .isalpha()：是否全为字母或汉字
• .isdigit()：是否全为数字
• .isalnum()：是否全为字母或汉字或数字

print("ABOUt".isupper())  # False
print("is lower?".islower())  # True
print("isAll汉字".isalpha())    # True
print("10 + 80j".isdigit())   # False
print("seq2seq".isalnum())    # True

1.2.9 排版方法

• .center(w, fill)：字符串居中对齐（w为指定宽度，fill为填充字符（默认为空格 ），下同）
• .ljust(w, fill)：字符串居左对齐
• .rjust(w, fill)：字符串居右对齐
• .zfill(w)：输出指定宽度，不足的左边填0

s = "akira37"

print(s.center(15, '^'))  # ^^^^akira37^^^^
print(s.ljust(15, '<'))    # akira37<<<<<<<<
print(s.rjust(15, '>'))    # >>>>>>>>akira37
print(s.zfill(15))      # 00000000akira37

1.3 格式化方法：.format()

基本形式：'...{1}...{2}...'.format(x1, x2, ...)。可任意指定顺序，或使用默认顺序。

格式化：{:<填充字符><对齐方式><宽度>}。对齐方式：居中^、左对齐<、右对齐>。

控制输出精度：在大括号最后添加.<位数>f来保留指定位数，或为d来保留整数。

epoch = 10
loss = 0.02371345
accuracy = 0.642751222

print("epoch: {:0>4}, loss: {: >6.3f}, accuracy: {: >6.4f}".format(epoch, loss, accuracy))
# epoch: 0010, Loss: 0.024, accuracy: 0.6428

print("epoch: {1:0>4}, epoch: {1:0>4}, epoch: {1:0>4}, loss: {0: <6.3f}, accuracy: {2: <6.4f}".format(loss, epoch, accuracy))
# epoch: 0010, epoch: 0010, epoch: 0010, loss: 0.024, accuracy: 0.6428

1.4 格式化字符串（f" "）、原始字符串（r" "）

格式化字符串（f" "）：直接在大括号里填变量，类似于.format()

原始字符串（r" "）：转义字符（\）为普通的字符

---

2 列表（List）

Python中的列表可存储任意类型的对象（同其他3种容器），且支持修改，即元素是可变的。

2.1 基本操作

• 创建列表：可用方括号[]。
• 访问、修改元素：通过索引（从0开始）访问、修改。支持负索引访问，-1表示最后一个元素。
• 切片：基本形式为[start:stop:step]，从索引start切片到stop（左闭右开），步长为step。
• 添加元素
  • .append(elem)方法：尾插一个元素
  • .extend(elem_seq)方法：尾插一个序列的元素
  • .insert(idx, elem)方法：在指定下标位置插入指定元素
• 删除元素
  • .remove(elem)方法：删除第一个匹配的元素
  • del my_list[idx]：根据索引删除元素
• 拼接列表：直接使用+运算符来拼接两个列表。
• 遍历列表
  • 普通遍历：直接迭代访问每个元素
  • 枚举遍历：使用内置函数enumerate()，每轮迭代返回当前索引与对应的元素

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

print(my_list[0])
print(my_list[1:5:2])

my_list.append('d')
my_list.extend([4, 5, 6])
my_list.insert(3, 'z')

my_list.remove('b')
del my_list[2]

for i, elem in enumerate(my_list):
    print(f"Element {i} is {elem}")

2.2 列表推导式、生成器

列表推导式（List Comprehensions）可快速新建列表，形式为[expression for member in iterable]

squares = [x**2 for x in range(10)]
print(squares)
# Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

生成器（Generators）是一个返回迭代器的函数，仅仅保存了一套生成值的算法 ，并且没有让这个算法现在就开始执行。效率比列表推导式较高，但不可复用，形式为(expression for member in iterable)

squares = (x**2 for x in range(10))
for square in squares:
    print(square)
# Output: 0, 1, 4, 9, 16, 25, 36, 49, 64, 81

2.3 列表排序

• .sort()方法：直接改变原列表的顺序，将其按照指定的方式排序。

nums = [5, 2, 9, 1, 5, 6]
nums.sort()
print(nums)
# Output: [1, 2, 5, 5, 6, 9]

• sorted()函数：返回一个新的已排序列表，原列表不会发生变化。

nums = [5, 2, 9, 1, 5, 6]
sorted_nums = sorted(nums)
print(sorted_nums)
# Output: [1, 2, 5, 5, 6, 9]

2.4 列表逆序

• .reverse()方法：直接反转原列表。

nums = [5, 2, 9, 1, 5, 6]
nums.reverse()
print(nums)
# Output: [6, 5, 1, 9, 2, 5]

• [::-1]切片操作：返回一个新的反转列表，原列表不会发生变化。

nums = [5, 2, 9, 1, 5, 6]
reversed_nums = nums[::-1]
print(reversed_nums)
# Output: [6, 5, 1, 9, 2, 5]

2.5 列表解包

Python中只需提供与列表元素数量相同的变量，即可自动将列表中的元素按顺序赋值给这些变量

nums = [1, 2, 3]
x, y, z = nums
print(x, y, z)
# Output: 1 2 3

使用*操作符可以用来捕获列表中剩余的元素

nums = [1, 2, 3, 4, 5]
x, *y, z = nums
print(x)
print(y)
print(z)
# Output: 
# 1
# [2, 3, 4]
# 5

---

3 元组（Tuple）

Python中的列表、元组、字符串均属于序列，因此各种操作均极相似，但元组元素不可变。

3.1 基本操作

• 创建元组：可用圆括号()，或直接用逗号,分隔元素
• 访问元素、切片…：同列表

my_tuple = (1, 2, 3, 'the frick')

print(my_tuple[3])

3.2 内置函数

• len()函数：返回元组中元素的数量。

tup = (1, 2, 3, 4, 5)
print(len(tup)) # Output：5

• max()、min()函数：分别返回元组中的最大值和最小值。

tup = (1, 2, 3, 4, 5)
print(max(tup))  # Output：5
print(min(tup))  # Output：1

3.3 内置方法

• .count()方法：返回元组中特定元素的出现次数

tup = (1, 2, 3, 2, 4, 2)
print(tup.count(2))  # Output：3

• .index()方法：返回元组中特定元素的第1个匹配项的索引位置。若元素不存在，则抛出一个异常。

tup = (1, 2, 3, 2, 4, 2)
print(tup.index(2))  # Output：1

3.4 函数参数的打包与解包

在Python中，当将一个元组作为参数传递给函数时，实际上是进行了参数的打包（Packing）。

函数在接收到元组后，可以通过*操作符进行解包（Unpacking），将元组中的各个元素赋值给函数的各个参数。

def calculate(a, b, c):
    return (a + b) * c

params = (1, 2, 3)
result = calculate(*params)  # 使用元组作为参数
print(result)  # Output：9

---

4 字典（Dictionary）

Python中的字典存储键值对，每个唯一的键映射到其值。字典是无序的集合，但在Python 3.7及以上版本中，字典保持插入顺序。

4.1 基本操作

• 创建字典：可用大括号{}并用冒号:分隔每对键、值，或用dict()函数，
• 访问元素：通过键访问对应的值。
• 添加、修改元素：直接通过键访问来赋值
• 删除元素：类似列表，使用del语句，通过键删除元素。
• 遍历字典
  • 遍历键：调用.keys()方法，返回字典的键
  • 遍历值：调用.values()方法，返回字典的值
  • 遍历键值对：调用.items()方法，每轮迭代返回一对键值对

dict1 = {'name': 'John', 'age': 30, 'job': 'developer'}

print(dict1['name'])  # 输出: John

dict1['age'] = 31

del dict1['job']

for key, value in dict_example.items():
    print(f"Key: {key}, Value: {value}")

4.2 字典推导式

字典推导式（Dictionary Comprehension）可用于快速生成字典，类似于列表推导式和生成器

squares = {x: x**2 for x in range(6)}
print(squares)  
# Output：{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

4.3 内置方法

部分方法适用于其他容器

• .clear()：清空字典
• .copy()：返回字典的浅复制
• .get(key[, default])：返回指定键的值，若键不在字典中则返回默认值
• .items()：返回一个新对象，存储字典的所有键值对
• .keys()：返回一个新对象，存储字典的所有键
• .values()：返回一个新对象，存储字典的所有值
• .update([other])：更新字典，添加键/值对

dict1 = {'name': 'John', 'age': 30, 'job': 'developer'}

print(dict1.get('name'))  
# Output: John

print(dict1.items())  
# Output: dict_items([('name', 'John'), ('age', 30), ('job', 'developer')])

print(dict1.keys())
# Output: dict_keys(['name', 'age', 'job'])

print(dict1.values())  
# Output: dict_values(['John', 30, 'developer'])

dict1.update({'location': 'USA'})
print(dict1)  
# Output: {'name': 'John', 'age': 30, 'job': 'developer', 'location': 'USA'}

---

5 集合（Set）

Python中的集合无序、元素不重复。

5.1 基本操作

• 创建集合：使用大括号{}，或使用set()并传入一个序列
• 添加元素：使用.add()方法添加指定元素
• 删除元素：使用.remove()方法删除指定元素
• 查找元素：使用in或not in判断

my_set = {1, 2, 3}
my_set.add(4)
print(my_set)  # Output: {1, 2, 3, 4}

5.2 集合推导式

集合推导式（Set Comprehensions）可用于快速创建集合，类似于列表推导式。

original_set = {1, 2, 3, 4, 5}
new_set = {x**2 for x in original_set}
print(new_set)  # Output：{1, 4, 9, 16, 25}

5.3 frozenset

frozenset是一种特殊的集合，元素不可变

fs = frozenset([1, 2, 3, 4, 5])
print(fs)  # Output：frozenset({1, 2, 3, 4, 5})

5.4 内置方法

• .union()：并集
• .intersection()：交集
• .difference()：差集
• .symmetric_difference()：对称差集

s1 = set([1, 2, 3])
s2 = set([2, 3, 4])

s3 = s1.union(s2)  # {1, 2, 3, 4}

s4 = s1.intersection(s2)  # {2, 3}

s5 = s1.difference(s2)  # {1}

s6 = s1.symmetric_difference(s2)  # {1, 4}