Agent学习路线之——python 入门 ④（字符串、列表、元组、字典、集合）- 惊觉

本文为Python学习第五天的完整笔记，涵盖Python五大容器类型：字符串、元组、列表、字典、集合的增删改查操作及易错点。适合零基础入门学习，建议配合代码实操。

一、容器概述

在Python中，容器是用来存储多个数据的对象。根据是否可变、是否有序等特性，分为不同的类型：

容器类型	是否可变	是否有序	是否可重复	定义符号
字符串（str）	❌ 不可变	✅ 有序	✅ 可重复	`' '` 或 `" "`
元组（tuple）	❌ 不可变	✅ 有序	✅ 可重复	`( )`
列表（list）	✅ 可变	✅ 有序	✅ 可重复	`[ ]`
字典（dict）	✅ 可变	❌ 无序（3.7+有序）	❌ 键不可重复	`{键:值}`
集合（set）	✅ 可变	❌ 无序	❌ 不可重复	`{ }`

开发小技巧：容器都可以直接构造返回。例如直接写 a=1, b=2 然后 [a, b]，不必再先创建一个空容器再添加元素。

二、字符串

字符串是Python中最常用的容器之一，用于存储文本数据。

2.1 字符串的不可变性与修改方法

字符串是不可变类型，不能直接修改原字符串，但可以通过方法生成新的字符串。

join() —— 连接可迭代对象

用指定连接符将可迭代对象中的字符串元素连接成一个新字符串。

# 用 "-" 连接列表中的字符串
words = ["2026", "08", "19"]
result = "-".join(words)
print(result)  # 2026-08-19

# 注意：可迭代对象里面的元素必须都是字符串
# numbers = [1, 2, 3]
# "-".join(numbers)  # ❌ 报错，必须是字符串

split() —— 分割字符串

按指定分隔符将字符串分割成列表。

date = "2026-08-19"
parts = date.split("-")
print(parts)  # ['2026', '08', '19']

# 按空格分割
sentence = "Python 是最棒的语言"
words = sentence.split(" ")
print(words)  # ['Python', '是最棒的语言']

replace() —— 替换字符

将字符串中的指定内容替换为新的内容，返回新的字符串。

text = "我喜欢 Java，Java 很好用"
new_text = text.replace("Java", "Python")
print(new_text)  # 我喜欢 Python，Python 很好用

# 原字符串不会被修改
print(text)  # 我喜欢 Java，Java 很好用

2.2 字符串查询方法

方法	作用	示例
`索引`	通过下标获取单个字符	`s[0]`
`in`	判断子串是否在字符串中	`"py" in "python"`
`count()`	统计子串出现次数	`s.count("p")`
`index()`	查找子串第一次出现的索引，找不到报错	`s.index("python")`
`find()`	查找子串第一次出现的索引，找不到返回-1	`s.find("java")`
`upper()`	转大写	`s.upper()`
`strip()`	去除首尾空格和换行（默认）	`s.strip()`

s = "python programming"

# 字符串和字符都可以操作
print(s.count("python"))  # 1
print(s.count("p"))       # 2
print(s.index("python"))  # 0
print(s.find("java"))     # -1（找不到返回-1，不会报错）
print(s.upper())          # PYTHON PROGRAMMING

# strip 去除首尾空格和换行
text = "  hello world  \n"
print(text.strip())       # "hello world"

三、元组

元组（tuple）是不可变的有序容器，一旦创建就不能修改其中的元素。

3.1 元组的基本操作

元组支持查询操作，与字符串类似：

t = (10, 20, 30, 20, 40)

# 索引查询
print(t[0])      # 10
print(t[-1])     # 40

# index() 查找位置
print(t.index(20))  # 1（第一个20的位置）

# count() 统计次数
print(t.count(20))  # 2

# in 判断是否存在
print(30 in t)   # True

3.2 元组的易错点

⚠️ 单元素元组必须加逗号

如果元组只有一个元素，必须加上逗号，否则Python会将其识别为普通括号表达式。

tuple1 = (1,)   # ✓ 这才是元组
tuple2 = (2,)   # ✓ 元组
tuple3 = (3)    # ✗ 这是整数 3，不是元组！

print(type(tuple1))  # <class 'tuple'>
print(type(tuple3))  # <class 'int'>

元组支持相加和切片

虽然元组不可变，但支持通过 + 拼接生成新元组，也支持切片操作。

tuple = (1, 2, 3)

# 直接相加（生成新元组）
tuple += (1, 2)
print(tuple)  # (1, 2, 3, 1, 2)

# 切片操作
print(tuple[:-1])  # (1, 2, 3, 1)
print(tuple[1:3])  # (2, 3)

# 也支持 in 查询判断
print("4" in tuple)  # False

四、列表

列表（list）是Python中最常用的可变有序容器，支持增删改查各种操作。

4.1 列表的增加操作

方法	作用	示例
`append()`	在末尾添加一个元素	`list.append(4)`
`extend()`	在末尾添加可迭代对象的多个元素	`list.extend([5,6])`
`insert()`	在指定位置插入元素	`list.insert(0, "开头")`

my_list = [1, 2, 3]

# append 添加单个元素
my_list.append(4)
print(my_list)  # [1, 2, 3, 4]

# extend 添加可迭代对象（列表、元组、字符串等）
my_list.extend([5, 6])
print(my_list)  # [1, 2, 3, 4, 5, 6]

# insert 在指定位置插入
my_list.insert(0, "开头")
print(my_list)  # ['开头', 1, 2, 3, 4, 5, 6]

4.2 列表的删除操作

方法	作用	说明
`del list[索引]`	删除指定索引元素	也可删除整个列表或切片
`pop(索引)`	删除并返回指定索引元素	默认删除最后一个
`remove("元素")`	删除第一个匹配的元素	按值删除

my_list = ['a', 'b', 'c', 'd', 'b']

# pop 删除并返回
item = my_list.pop(1)
print(item)       # 'b'
print(my_list)    # ['a', 'c', 'd', 'b']

# remove 按值删除（删除第一个匹配的）
my_list.remove('b')
print(my_list)    # ['a', 'c', 'd']

# del 删除指定索引
del my_list[0]
print(my_list)    # ['c', 'd']

注意：列表这里一般不用 del 删除整个列表，防止操作失误删除原list导致后续代码无法使用。

4.3 列表的修改操作

my_list = [3, 1, 4, 1, 5]

# 通过索引修改
my_list[0] = 100
print(my_list)  # [100, 1, 4, 1, 5]

# sort() 排序（原地排序，不返回新列表）
my_list.sort()
print(my_list)  # [1, 1, 4, 5, 100]

# reverse() 反转
my_list.reverse()
print(my_list)  # [100, 5, 4, 1, 1]

4.4 列表的查询操作

my_list = ['apple', 'banana', 'cherry']

# 索引查询
print(my_list[1])  # banana

# index() 查找位置
print(my_list.index('banana'))  # 1

# count() 统计次数
print(my_list.count('apple'))   # 1

# in 判断是否存在
print('apple' in my_list)  # True

实用技巧：判断一个变量在不在列表里面，不需要循环！直接 if 变量 in 列表 就行。

fruits = ['apple', 'banana', 'cherry']
if 'banana' in fruits:
    print("有香蕉！")

4.5 列表的易错点

和元组一样，列表也支持相加、切片、in 等操作：

list1 = [1, 2]
list2 = [3, 4]

# 列表相加（拼接）
print(list1 + list2)  # [1, 2, 3, 4]

# 切片
print(list1[::-1])    # [2, 1]

# in 判断
print(2 in list1)     # True

五、字典

字典（dict）是Python中非常强大的键值对容器，通过键（key）来快速查找值（value）。

5.1 字典的增删改

# 创建字典
dict1 = {"height": 1.8, "weight": 90, "name": "邵梦飞"}

# 增/改：通过键来添加或修改
dict1["age"] = 25       # 新增键值对
dict1["height"] = 1.85  # 修改已有键的值
print(dict1)

# 删除操作
dict1 = {"height": 1.8, "weight": 90, "name": "邵梦飞"}

# del 删除指定键值对
del dict1["weight"]
print(dict1)  # {'height': 1.8, 'name': '邵梦飞'}

# clear() 清空字典
dict1.clear()
print(dict1)  # {}

# pop() 删除并返回指定键的值
dict1 = {"height": 1.8, "weight": 90}
value = dict1.pop("height")
print(value)  # 1.8
print(dict1)  # {'weight': 90}

5.2 字典的查询方法

方法	作用	示例
`dict[键]`	通过键获取值，键不存在报错	`dict1["name"]`
`get("键")`	通过键获取值，键不存在返回None	`dict1.get("age")`
`keys()`	获取所有键	`dict1.keys()`
`values()`	获取所有值	`dict1.values()`
`items()`	获取所有键值对	`dict1.items()`

dict1 = {"height": 1.8, "weight": 90, "name": "邵梦飞"}

# 获取所有键
print(dict1.keys())    # dict_keys(['height', 'weight', 'name'])

# 获取所有值
print(dict1.values())  # dict_values([1.8, 90, '邵梦飞'])

# 获取所有键值对
print(dict1.items())   # dict_items([('height', 1.8), ('weight', 90), ('name', '邵梦飞')])

# get() 安全获取值
print(dict1.get("age"))       # None（不会报错）
print(dict1.get("age", 0))    # 0（可设置默认值）

5.3 字典易错案例

将字符串转换为字典是常见需求，需要注意分割逻辑：

# 需求：将 "height:1.8 weight:90 name:邵梦飞" 转换为字典
data = "height:1.8 weight:90 name:邵梦飞"

my_dict = {}
# 先按空格分割成列表
list_item = data.split(" ")
print(list_item)  # ['height:1.8', 'weight:90', 'name:邵梦飞']

for item in list_item:
    # 再按冒号分割成键和值
    k, v = item.split(":")
    my_dict[k] = v

print(f"字典结果：{my_dict}")
# 字典结果：{'height': '1.8', 'weight': '90', 'name': '邵梦飞'}

注意：split(":") 分割后得到的值都是字符串类型，如果需要数值类型，需要额外进行类型转换。

六、集合

集合（set）是无序、不重复的容器，常用于去重和集合运算。

# 创建集合
my_set = {1, 2, 3, 3, 3}
print(my_set)  # {1, 2, 3}（自动去重）

# 增：add()
my_set.add(4)
print(my_set)  # {1, 2, 3, 4}

# 删：remove()（元素不存在会报错）
my_set.remove(2)
print(my_set)  # {1, 3, 4}

# 查：in
print(3 in my_set)  # True

集合的特点：集合中的元素必须是可哈希的（不可变类型），所以列表和字典不能作为集合的元素。

七、总结

7.1 开发小技巧

鼠标悬停看返回和传参：在PyCharm等IDE中，将鼠标悬停在方法上可以看到返回值和参数说明，按 Ctrl+P 也可以查看传参提示。
快捷键 Shift+F6：重命名变量/函数时，使用 Shift+F6 可以一键替换所有引用位置，避免遗漏。
容器直接构造：容器都可以直接构造返回，如 a=1, b=2 然后写 [a, b]，不必再创建一个空列表再 append。

7.2 今日重点总结

容器	核心特点	重点方法
字符串	不可变，有序	`join()`, `split()`, `replace()`, `strip()`, `find()`
元组	不可变，有序	单元素必须加逗号 `(1,)`, 支持 `+` 和切片
列表	可变，有序	`append()`, `extend()`, `insert()`, `pop()`, `sort()`, `reverse()`
字典	键值对存储	`keys()`, `values()`, `items()`, `get()`, 通过键增删改查
集合	无序，不重复	`add()`, `remove()`, `in`

下一篇将继续学习Python函数与面向对象基础，敬请期待！

练习建议：动手敲一遍所有代码，尤其注意元组单元素逗号、replace 返回新字符串、字典 get() 与直接取键的区别。这些细节是面试和实际开发中的高频踩坑点。

转载自 CSDN-专业IT技术社区

原文链接：https://blog.csdn.net/wiwiwiwiooo/article/details/163890778

Agent学习路线之——python 入门 ④（字符串、列表、元组、字典、集合）