Python 中字符串和字典是两种最核心的内置数据结构，其操作丰富且高效，是数据处理和日常编程的基础。以下将分别对字符串和字典的操作进行详解，并通过表格和代码示例进行说明。 ### 一、 字符串操作详解 字符串是不可变序列，支持序列的通用操作（如索引、切片、迭代）以及大量专用的方法。 #### 1. 字符串的创建与基本操作 ```python # 1.1 创建字符串 str1 = 'Hello, World!' # 单引号 str2 = "Python" # 双引号 str3 = '''多行 字符串''' # 三引号，可跨行 str4 = str(123) # 将其他类型转换为字符串，输出: '123' [ref_4] # 1.2 索引与切片（序列通用操作） s = "Python" print(s[0]) # 输出: 'P'，正向索引从0开始 print(s[-1]) # 输出: 'n'，负索引从-1开始 print(s[1:4]) # 输出: 'yth'，切片 [start:end)，不包含end print(s[:3]) # 输出: 'Pyt'，从开头到索引2 print(s[3:]) # 输出: 'hon'，从索引3到结尾 print(s[::-1]) # 输出: 'nohtyP'，步长为-1，实现反转 [ref_2] # 1.3 字符串拼接与重复 s1 = "Hello" s2 = "World" print(s1 + " " + s2) # 输出: 'Hello World'，使用 + 拼接 print(s1 * 3) # 输出: 'HelloHelloHello'，使用 * 重复 print(" ".join([s1, s2])) # 输出: 'Hello World'，使用 join 高效拼接列表 [ref_1] ``` #### 2. 字符串常用方法 字符串方法众多，以下通过表格分类说明核心方法： | 类别 | 方法 | 描述 | 示例 (`s = " Hello Python! "`) | 结果 | | :--- | :--- | :--- | :--- | :--- | | **大小写转换** | `upper()` | 转为大写 | `s.upper()` | `' HELLO PYTHON! '` | | | `lower()` | 转为小写 | `s.lower()` | `' hello python! '` [ref_1] | | | `capitalize()` | 首字母大写 | `"hello".capitalize()` | `'Hello'` | | | `title()` | 每个单词首字母大写 | `"hello world".title()` | `'Hello World'` | | **查找与替换** | `find(sub)` | 查找子串，返回索引，未找到返回-1 | `s.find("Python")` | `7` [ref_1] | | | `index(sub)` | 同`find`，但未找到抛出`ValueError` | `s.index("Python")` | `7` | | | `replace(old, new[, count])` | 替换子串 | `s.replace("Python", "Java")` | `' Hello Java! '` [ref_2] | | | `count(sub)` | 统计子串出现次数 | `"ababa".count("aba")` | `1` | | **分割与连接** | `split(sep=None)` | 按分隔符分割为列表 | `"a,b,c".split(",")` | `['a', 'b', 'c']` [ref_1] | | | `join(iterable)` | 将可迭代对象用字符串连接 | `"-".join(['a', 'b', 'c'])` | `'a-b-c'` [ref_1] | | | `partition(sep)` | 按分隔符分成三部分（头、分隔符、尾） | `"hello.py".partition(".")` | `('hello', '.', 'py')` | | **去除空白** | `strip([chars])` | 去除**两侧**指定字符（默认空白符） | `s.strip()` | `'Hello Python!'` [ref_1] | | | `lstrip([chars])` | 去除**左侧**指定字符 | `" hi ".lstrip()` | `'hi '` | | | `rstrip([chars])` | 去除**右侧**指定字符 | `" hi ".rstrip()` | `' hi'` | | **判断与验证** | `startswith(prefix)` | 是否以指定前缀开头 | `s.startswith(" He")` | `True` | | | `endswith(suffix)` | 是否以指定后缀结尾 | `"test.py".endswith(".py")` | `True` | | | `isdigit()` | 是否只包含数字 | `"123".isdigit()` | `True` | | | `isalpha()` | 是否只包含字母 | `"abc".isalpha()` | `True` | | | `isalnum()` | 是否只包含字母和数字 | `"abc123".isalnum()` | `True` | | **格式化** | `format(*args, **kwargs)` | 格式化字符串（推荐） | `"{} {}".format(s1, s2)` | `'Hello World'` [ref_1] | | | f-string (Python 3.6+) | 内嵌表达式的字面量格式化 | `f"{s1} {s2}"` | `'Hello World'` | ```python # 字符串方法代码示例 s = " Hello, Python Programmers! " print(f"原字符串: '{s}'") print(f"去除空白: '{s.strip()}'") print(f"转为大写: '{s.upper()}'") print(f"查找'Python'的位置: {s.find('Python')}") print(f"替换'Python'为'Java': '{s.replace('Python', 'Java')}'") print(f"按空格分割: {s.strip().split(' ')}") print(f"是否以'Hello'开头: {s.strip().startswith('Hello')}") print(f"格式化示例: 今天是{2024}年{5}月{27}日") ``` #### 3. 字符串编码与转义 ```python # 编码与解码 s = "你好，世界" encoded = s.encode('utf-8') # 编码为字节串 print(encoded) # 输出: b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8c\xe4\xb8\x96\xe7\x95\x8c' decoded = encoded.decode('utf-8') # 解码回字符串 print(decoded) # 输出: '你好，世界' [ref_5] # 转义字符 print("这是第一行\n这是第二行") # \n 换行 print("这是一个\"引号\"") # \" 转义双引号 print('这是一个\'引号\'') # \' 转义单引号 print("路径: C:\\Users\\Name") # \\ 转义反斜杠 [ref_5] ``` ### 二、 字典操作详解 字典是可变的无序集合，以键值对（key-value）形式存储数据，键必须是可哈希类型（如字符串、数字、元组），值可以是任意对象 [ref_6]。 #### 1. 字典的创建与基本操作 ```python # 1.1 创建字典 dict1 = {'name': 'Alice', 'age': 25, 'city': 'New York'} # 直接创建 dict2 = dict(name='Bob', age=30) # 使用 dict() 构造函数 [ref_1] dict3 = dict([('name', 'Charlie'), ('age', 35)]) # 从键值对列表创建 dict4 = {}.fromkeys(['a', 'b', 'c'], 0) # 创建具有相同默认值的字典，输出: {'a': 0, 'b': 0, 'c': 0} [ref_4] # 1.2 访问元素 person = {'name': 'Alice', 'age': 25} print(person['name']) # 输出: 'Alice'，使用键直接访问 print(person.get('age')) # 输出: 25，使用 get 方法，键不存在返回 None print(person.get('gender', '未知')) # 输出: '未知'，get 方法可指定默认值 [ref_1] # 1.3 添加与修改元素 person['city'] = 'Beijing' # 键不存在，则添加新键值对 print(person) # 输出: {'name': 'Alice', 'age': 25, 'city': 'Beijing'} person['age'] = 26 # 键已存在，则更新对应的值 print(person) # 输出: {'name': 'Alice', 'age': 26, 'city': 'Beijing'} # 1.4 删除元素 del person['city'] # 删除指定键值对 print(person) # 输出: {'name': 'Alice', 'age': 26} age = person.pop('age') # 删除并返回指定键的值 print(f"被删除的年龄: {age}, 剩余字典: {person}") # 输出: 被删除的年龄: 26, 剩余字典: {'name': 'Alice'} person.clear() # 清空字典所有元素 print(person) # 输出: {} ``` #### 2. 字典常用方法 | 类别 | 方法 | 描述 | 示例 (`d = {'a': 1, 'b': 2}`) | 结果 | | :--- | :--- | :--- | :--- | :--- | | **访问与获取** | `get(key[, default])` | 安全获取值，键不存在返回默认值 | `d.get('c', 0)` | `0` [ref_1] | | | `setdefault(key[, default])` | 键存在则返回值，不存在则插入并返回默认值 | `d.setdefault('c', 3)` | `3`，同时 `d` 变为 `{'a':1, 'b':2, 'c':3}` | | | `keys()` | 返回所有键的视图 | `list(d.keys())` | `['a', 'b']` | | | `values()` | 返回所有值的视图 | `list(d.values())` | `[1, 2]` | | | `items()` | 返回所有键值对（元组）的视图 | `list(d.items())` | `[('a', 1), ('b', 2)]` [ref_4] | | **更新与合并** | `update([other])` | 用另一个字典或键值对更新当前字典 | `d.update({'b': 20, 'c': 3})` | `d` 变为 `{'a':1, 'b':20, 'c':3}` [ref_1] | | **删除** | `pop(key[, default])` | 删除键并返回值，键不存在返回默认值 | `d.pop('a')` | `1`，同时 `d` 变为 `{'b': 2}` | | | `popitem()` | 删除并返回最后插入的键值对（LIFO） | `d.popitem()` | `('b', 2)`，同时 `d` 变为 `{'a':1}` | | | `clear()` | 清空字典 | `d.clear()` | `d` 变为 `{}` | | **其他** | `copy()` | 返回字典的浅拷贝 | `d2 = d.copy()` | `d2` 是 `d` 的副本 | | | `len(d)` | 返回字典长度（键值对数量） | `len(d)` | `2` [ref_2] | | | `in` 操作符 | 检查键是否存在于字典中 | `'a' in d` | `True` | ```python # 字典方法代码示例 student = {'name': 'Tom', 'score': 90} print(f"原始字典: {student}") # 使用 setdefault 添加不存在的键 class_name = student.setdefault('class', 'Grade 1') print(f"添加班级后: {student}, 班级是: {class_name}") # 遍历字典 print("遍历键:") for key in student.keys(): print(f" Key: {key}") print("遍历键值对:") for key, value in student.items(): print(f" {key}: {value}") # 更新字典 student.update({'score': 95, 'teacher': 'Mr. Wang'}) print(f"更新后: {student}") # 字典推导式 squares = {x: x**2 for x in range(5)} print(f"字典推导式生成平方表: {squares}") ``` #### 3. 字典的嵌套与复杂操作 字典的值可以是任意类型，包括列表、另一个字典等，这允许构建复杂的数据结构。 ```python # 嵌套字典 company = { 'name': 'TechCorp', 'employees': [ {'name': 'Alice', 'role': 'Engineer'}, {'name': 'Bob', 'role': 'Manager'} ], 'location': { 'city': 'Shanghai', 'country': 'China' } } # 访问嵌套数据 print(f"公司名: {company['name']}") print(f"第一位员工: {company['employees'][0]['name']}") print(f"所在城市: {company['location']['city']}") # 修改嵌套数据 company['employees'].append({'name': 'Charlie', 'role': 'Designer'}) company['location']['city'] = 'Beijing' print(f"修改后: {company}") ``` ### 三、 字符串与字典的协同应用场景 字符串和字典经常结合使用，尤其是在数据解析、配置管理和模板生成方面。 #### 1. 字符串格式化与字典解包 ```python # 使用字典进行字符串格式化 info = {'name': 'Alice', 'age': 25} # 旧式格式化 message1 = "Name: %(name)s, Age: %(age)d" % info # format 方法 message2 = "Name: {name}, Age: {age}".format(**info) # ** 用于解包字典 [ref_1] # f-string (Python 3.6+) message3 = f"Name: {info['name']}, Age: {info['age']}" print(message1) print(message2) print(message3) ``` #### 2. 字典键值对与字符串的相互转换 ```python # 将字符串（如查询参数）解析为字典 query_string = "name=Alice&age=25&city=Beijing" params = {} for pair in query_string.split('&'): key, value = pair.split('=') params[key] = value print(f"解析后的字典: {params}") # 输出: {'name': 'Alice', 'age': '25', 'city': 'Beijing'} # 将字典转换为特定格式的字符串 config = {'host': 'localhost', 'port': 8080, 'debug': True} config_str = "; ".join([f"{k}={v}" for k, v in config.items()]) print(f"配置字符串: {config_str}") # 输出: host=localhost; port=8080; debug=True ``` ### 总结 字符串和字典是 Python 中最基础且功能强大的两种数据类型。字符串作为不可变序列，提供了丰富的文本处理、查找、替换和格式化方法。字典作为高效的键值对映射，以其快速的查找速度（基于哈希表 [ref_6]）和灵活的键值结构，在存储和访问结构化数据方面无可替代。掌握它们各自的操作方法以及它们之间的协同使用，是进行有效 Python 编程的关键。在实际开发中，从简单的数据存储到复杂的文本解析、配置管理，都离不开这两种数据结构的熟练运用。