Python零基础入门（五）---字符串，元组，字典，集合

番茄去哪了

721人浏览 · 2026-02-25 15:54:43

番茄去哪了 · 2026-02-25 15:54:43 发布

一、字符串（str）

有序、不可变容器，专门用于存储文本数据，单引号、双引号、三引号均可定义，核心特点是不可修改原内容（修改需生成新字符串），支持索引、切片等操作。不可变意味着，一旦字符串定义完成，无法直接修改其中某一个字符，只能通过切片、替换等方式生成新的字符串。

1.核心固定用法

操作类型	固定用法 + 细节说明
定义	1. 单引号：s = '字符串'（适合单行短文本，内部可嵌套双引号，无需转义）；2. 双引号：s = "字符串"（与单引号功能一致，内部可嵌套单引号）；3. 三引号：s = """多行字符串"""（支持多行文本，无需换行符，适合长文本、注释）
索引取值	s[索引]：正向索引从0开始（第一个字符索引为0，第二个为1，以此类推）；反向索引从-1开始（最后一个字符索引为-1，倒数第二个为-2）；索引必须在有效范围内（0 ≤ 索引 < 字符串长度），否则报错（IndexError）
切片	s[起始:终止:步长]：左闭右开原则（包含起始索引对应的字符，不包含终止索引对应的字符）；三个参数均可省略：1. 省略起始：s[:终止:步长]，从开头（索引0）开始切片；2. 省略终止：s[起始::步长]，从起始索引一直切片到末尾；3. 省略步长：s[起始:终止]，默认步长为1；4. 步长为负数：反向切片，从后往前取，此时起始索引需大于终止索引（如s[5:2:-1]，从索引5取到索引3）；切片不会修改原字符串，只会返回新的切片结果。
常用方法	1. len(s)：获取字符串长度（字符个数，空格、换行符均算一个字符）；2. s.upper()：将字符串中所有小写字母转为大写，返回新字符串；3. s.lower()：将字符串中所有大写字母转为小写，返回新字符串；4. s.strip()：去除字符串前后两端的空白字符（空格、换行符、制表符），返回新字符串；5. s.count(字符)：统计指定字符在字符串中出现的次数，若字符不存在，返回0；6. 字符 in s：判断指定字符是否在字符串中，返回布尔值（True/False）。
补充方法	1. s.replace(旧字符, 新字符)：将字符串中所有旧字符替换为新字符，返回新字符串；2. s.split(分隔符)：按指定分隔符拆分字符串，返回一个列表（分隔符不包含在列表中，无分隔符时默认按空格拆分）；3. s.join(可迭代对象)：将可迭代对象（字符串、列表等）中的元素，用当前字符串连接起来，返回新字符串（可迭代对象元素必须是字符串类型）。

2.代码演示

# 定义（三种方式，按需使用）
s1 = "Python"
s2 = 'hello world'
s3 = """多行
字符串
演示"""

# 索引/切片（核心操作，必掌握）
print(s1[0])        # 正向索引，取第一个字符P
print(s1[-1])       # 反向索引，取最后一个字符n
print(s1[2:5])      # 切片，取索引2-4的字符tho（左闭右开）
print(s1[::-1])     # 步长为-1，倒序输出nohtyP
print(s1[:3])       # 省略起始值，从开头取到索引2，输出Py
print(s1[3:])       # 省略终止值，从索引3取到末尾，输出hon
print(s1[1:4:2])    # 步长为2，取索引1、3的字符，输出yt
print(s1[5:2:-1])   # 反向切片，取索引5、4、3的字符，输出noh

# 常用方法
print(len(s1))                  # 获取长度，输出6
print(len(s2))                  # 输出11（包含空格）
print(s1.upper())               # 转大写，输出PYTHON
print(s1.lower())               # 转小写，输出python
print(s2.strip())               # 去除前后空白，输出hello world
print(s1.count('o'))            # 统计o出现次数，输出1
print('y' in s1)                # 判断y是否存在，输出True
print('z' in s1)                # 输出False

# 补充方法
print(s1.replace('o', 'a'))     # 替换字符，输出Pythan
print(s2.split(' '))            # 按空格拆分，输出['hello', 'world']
print('-'.join(['a', 'b', 'c']))# 连接元素，输出a-b-c

二、元组（tuple）

有序、不可变容器，可存储任意类型数据（整数、字符串、列表、元组等），用()定义。核心特点是不可变，无法直接修改、新增、删除元素，单元素元组必须加逗号（否则会被识别为对应的数据类型，而非元组），支持索引、切片操作，用法与字符串高度相似。

1.核心固定用法

操作类型	固定用法 + 细节说明
定义	1. 空元组：t = ()；2. 多元素元组：t = (元素1, 元素2, 元素3)（元素可任意类型）；3. 单元素元组：t = (单元素,)（必须加逗号，否则t = (1)会被识别为整数1，而非元组）；4. 省略括号：t = 1, 2, 3（可省略()，但不推荐，可读性差）。
索引取值	与字符串完全一致：t[索引]，正向从0开始，反向从-1开始，索引越界报错（IndexError）；可直接取嵌套元组的元素（如t = (1, (2, 3))，t[1][0]取到2）。
切片	与字符串完全一致：t[起始:终止:步长]，左闭右开原则，三个参数均可省略，步长可正可负；切片不修改原元组，返回新的元组。
常用方法	1. len(t)：获取元组长度（元素个数）；2. t.count(元素)：统计指定元素在元组中出现的次数，元素不存在返回0；3. t.index(元素)：查找指定元素第一次出现的索引，元素不存在报错（ValueError）；4. 元素 in t：判断指定元素是否在元组中，返回布尔值。
注意点	元组不可变，仅指元组本身的元素不能修改、新增、删除；若元组中包含可变容器（如列表），可修改可变容器内部的元素（如t = (1, [2, 3])，t[1][0] = 4，元组t变为(1, [4, 3])）。

2.代码演示

# 定义（四种方式，重点记单元素加逗号）
t1 = ()                  # 空元组
t2 = (1, 2, "Python", True, 3.14)  # 多元素元组
t3 = (1,)                # 单元素元组（必加逗号）
t4 = 1, 2, 3             # 省略括号，不推荐
t5 = (1, (2, 3, 4), [5, 6])  # 嵌套元组（包含列表）

# 索引/切片
print(t2[1])        # 正向索引，输出2
print(t2[-1])       # 反向索引，输出3.14
print(t2[2:4])      # 切片，输出('Python', True)
print(t2[::-1])     # 倒序切片，输出(3.14, True, 'Python', 2, 1)
print(t5[1][1])     # 嵌套索引，输出3
print(t5[2][0])     # 嵌套索引，输出5

# 常用方法
print(len(t2))                  # 获取长度，输出5
print(t2.count(1))              # 统计1出现次数，输出1
print(t2.index("Python"))       # 查找索引，输出2
print(2 in t2)                  # 判断元素存在，输出True
print(10 in t2)                 # 输出False

# 元组不可变（修改报错）
# t2[1] = 200  # 报错：TypeError

# 元组中嵌套列表，可修改列表内部元素
t5[2][0] = 50
print(t5)           # 输出(1, (2, 3, 4), [50, 6])

三、字典（dict）

无序、可变容器，以键值对（key:value）形式存储数据，用{}定义。核心特点是通过key取值（而非索引），key唯一且不可变（仅能是字符串、数字、元组，不能是列表、集合、字典等可变类型），value可任意类型（包括可变容器），支持修改、新增、删除键值对操作。

1.核心固定用法

操作类型	固定用法 + 细节说明
定义	1. 空字典：d = {}；2. 普通字典：d = {"key1": value1, "key2": value2, ...}；3. 嵌套字典：d = {"key1": {"key2": value2}, "key3": value3}（value可嵌套字典）；4. key不可重复，若重复，后面的value会覆盖前面的（如d = {"name": "张三", "name": "李四"}，最终d["name"]为李四）。
取值	两种方式：1. d["key"]：直接通过key取值，key不存在报错（KeyError）；2. d.get("key")：通过get方法取值，key不存在返回None（推荐，避免报错）；3. d.get("key", 默认值)：key不存在时，返回指定的默认值（如d.get("age", 18)，key不存在则返回18）；4. 嵌套字典取值：d["key1"]["key2"]（逐层取值）。
修改/新增	统一格式：d["key"] = 新值；1. 若key已存在，修改该key对应的value；2. 若key不存在，新增一个键值对；3. 嵌套字典修改：d["key1"]["key2"] = 新值（需确保外层key存在，否则报错）。
删除	三种方式：1. del d["key"]：删除指定key对应的键值对，key不存在报错；2. d.pop("key")：删除指定key对应的键值对，并返回该key对应的value，key不存在报错；3. d.clear()：清空字典，删除所有键值对，保留字典本身（空字典）；4. del d：删除整个字典，后续无法再使用d（不常用）。
常用方法/遍历	1. len(d)：获取字典中键值对的个数；2. d.keys()：返回所有key的集合（可遍历）；3. d.values()：返回所有value的集合（可遍历）；4. d.items()：返回所有键值对的集合（每个键值对为元组，可遍历）；5. 遍历：遍历key（for key in d）、遍历value（for val in d.values()）、遍历键值对（for key, val in d.items()，最常用）。

2.代码演示

# 定义
d1 = {}                  # 空字典
d2 = {"name": "张三", "age": 20, "gender": "男", "score": 85}
d3 = {"name": "李四", "info": {"height": 175, "weight": 65}}  # 嵌套字典
d4 = {"name": "王五", "name": "赵六"}  # key重复，后面覆盖前面

# 取值
print(d2["name"])        # 直接取值，输出张三
print(d2.get("age"))     # get取值，输出20
print(d2.get("address")) # key不存在，输出None
print(d2.get("address", "未知"))  # 自定义默认值，输出未知
print(d3["info"]["height"])  # 嵌套取值，输出175
print(d4["name"])        # key重复，输出赵六

# 修改、新增
d2["age"] = 21           # 修改value，age变为21
d2["address"] = "北京"   # 新增键值对
d3["info"]["weight"] = 70  # 嵌套修改
print(d2)
print(d3)

# 删除
del d2["gender"]         # 删除指定key
val = d2.pop("score")    # 删除并返回value
print(val)               # 输出85
d2.clear()               # 清空字典
print(d2)                # 输出{}

# 常用方法/遍历
d5 = {"name": "张三", "age": 20}
print(len(d5))           # 输出2
print(d5.keys())         # 输出dict_keys(['name', 'age'])
print(d5.values())       # 输出dict_values(['张三', 20])
print(d5.items())        # 输出dict_items([('name', '张三'), ('age', 20)])

# 遍历
for key in d5:
    print(key)           # 遍历key
for val in d5.values():
    print(val)           # 遍历value
for key, val in d5.items():
    print(key, val)      # 遍历键值对（最常用）

四、集合（set）

无序、可变容器，专门用于存储唯一元素（自动去重），用{}定义。核心特点是无序（无法通过索引取值）、元素唯一（重复元素会自动被过滤），元素不可为可变类型（列表、集合、字典等），空集合需用set()定义（{}定义的是空字典，而非空集合），支持新增、删除、集合运算等操作。

1.核心固定用法

操作类型	固定用法 + 细节说明
定义	1. 空集合：s = set()（必须用set()，不能用{}）；2. 普通集合：s = {元素1, 元素2, ...}（元素不可重复，重复元素自动去重）；3. 用set()转换：s = set(可迭代对象)（如set([1,2,2,3])，转换后为{1,2,3}）；4. 元素不可为可变类型（如列表、集合，否则报错），可存储字符串、数字、元组。
新增	两种方式：1. s.add(元素)：新增单个元素，元素已存在则不做任何操作（无报错）；2. s.update(可迭代对象)：新增多个元素（可迭代对象元素会自动去重），如s.update([1,2,3])。
删除	三种方式：1. s.remove(元素)：删除指定元素，元素不存在报错（KeyError）；2. s.discard(元素)：删除指定元素，元素不存在不做任何操作（无报错，推荐）；3. s.pop()：随机删除并返回一个元素（集合无序，无法确定删除哪个，不依赖索引）；4. s.clear()：清空集合，保留集合本身。
集合运算（常用）	假设有两个集合s1、s2：1. 交集（s1 & s2）：返回两个集合共有的元素；2. 并集（s1 \| s2）：返回两个集合所有的元素（自动去重）；3. 差集（s1 - s2）：返回s1中有、s2中没有的元素；4. 对称差集（s1 ^ s2）：返回两个集合中互不共有的元素（并集减去交集）。
常用方法	1. len(s)：获取集合中元素的个数；2. 元素 in s：判断指定元素是否在集合中，返回布尔值；3. s.isdisjoint(s2)：判断两个集合是否无交集，无交集返回True，有交集返回False；4. s.issubset(s2)：判断s1是否是s2的子集（s1所有元素都在s2中）。

2.代码演示

# 定义
s1 = set()               # 空集合（必须用set()）
s2 = {1, 2, 3, 3, 4}    # 自动去重，实际为{1,2,3,4}
s3 = set([1, 2, 2, 3, 4])# 用列表转换，自动去重
s4 = {1, "Python", (5, 6)}# 元素可为数字、字符串、元组
# s5 = {1, [2, 3]}       # 报错：元素不能是列表（可变类型）

# 新增
s2.add(5)                # 新增单个元素
s2.update([6, 7, 7])     # 新增多个元素，自动去重
print(s2)                # 输出{1,2,3,4,5,6,7}

# 删除
s2.remove(3)             # 删除指定元素
s2.discard(8)            # 删除不存在的元素，无报错
val = s2.pop()           # 随机删除并返回元素
s2.clear()               # 清空集合
print(s2)                # 输出set()

# 集合运算（s1={1,2,3,4}, s3={1,2,3,4}）
s1 = {1, 2, 3, 4}
s3 = {3, 4, 5, 6}
print(s1 & s3)           # 交集，输出{3,4}
print(s1 | s3)           # 并集，输出{1,2,3,4,5,6}
print(s1 - s3)           # 差集，输出{1,2}
print(s1 ^ s3)           # 对称差集，输出{1,2,5,6}

# 常用方法
print(len(s1))           # 输出4
print(2 in s1)           # 输出True
print(5 in s1)           # 输出False
print(s1.isdisjoint(s3)) # 判断无交集，输出False
print({1,2}.issubset(s1))# 判断子集，输出True

五、五大容器核心区别

容器类型	有序性	可变性	元素特点	定义方式
列表（list）	有序	可变	任意类型，可重复，支持嵌套	[]，如[1, 2, "test"]
字符串（str）	有序	不可变	仅文本类型，可重复	单引号、双引号、三引号
元组（tuple）	有序	不可变	任意类型，可重复，支持嵌套	()，单元素需加逗号
字典（dict）	无序	可变	键值对，key唯一不可变，value任意	{}，key:value形式
集合（set）	无序	可变	任意不可变类型，自动去重	{}，空集合用set()