🚨 重要提醒

很多Python新手入门最大的痛点：数据结构方法太多，记不住、分不清、不会用。

• 字符串怎么大小写转换？
• 列表增删改查有啥区别？
• 字典怎么取值不报错？
• 集合交集并集怎么写？

每次用到都要翻文档，效率直接拉胯。

今天一次性搞定Python五大核心基础数据结构：字符串、列表、元组、字典、集合！

全篇代码可直接运行、注释超详细、讲解通俗不啰嗦，既能当入门教程，也能当永久速查手册，新手直接收藏封神！

先划重点：五大结构核心特性，一眼区分

• 字符串(str)：不可变序列，存文本，不能直接修改原内容
• 列表(list)：可变有序序列，万能容器，可增删改查
• 元组(tuple)：不可变有序序列，只读数据，安全稳定
• 字典(dict)：可变无序键值对，精准取值，高效检索
• 集合(set)：可变无序无重复，主打去重、集合运算

一、字符串 str：文本处理万能工具（不可变）

字符串是Python文本处理的基石，所有字符串方法都不会修改原字符串，只会返回新字符串，切记！

# 定义初始字符串
s = "hello Python"
1. upper()：全部字母转为大写
print(s.upper())        # HELLO PYTHON
2. lower()：全部字母转为小写
print(s.lower())        # hello python
3. capitalize()：字符串首字母大写，其余全部小写
print(s.capitalize())   # Hello python
4. title()：每个单词的首字母大写，其余小写
print(s.title())        # Hello Python
处理带首尾空格的字符串
s2 = "  test  "
5. strip()：去除字符串【首尾】所有空格/换行符
print(s2.strip())       # test
6. lstrip()：只去除字符串【左侧】空格
print(s2.lstrip())      # test
7. split()：按照指定字符分割字符串，返回列表
print(s.split(" "))     # ['hello', 'Python'] 按空格分割
8. join()：用指定字符拼接序列（列表、元组等）中的所有字符串元素
lst = ["a", "b", "c"]
print("-".join(lst))    # a-b-c 用-拼接
9. replace()：替换字符串中指定内容，旧值换为新值
print(s.replace("Python", "Java")) # hello Java
10. find()：查找子串下标，找到返回起始索引，【找不到返回-1】（不报错）
print(s.find("o"))      # 4
11. index()：查找子串下标，找到返回起始索引，【找不到直接报错】
print(s.index("h"))     # 0
12. count()：统计指定字符/子串在字符串中出现的次数
print(s.count("l"))     # 2
13. startswith()：判断字符串是否以指定内容开头，返回布尔值
print(s.startswith("he")) # True
14. endswith()：判断字符串是否以指定内容结尾，返回布尔值
print(s.endswith("on"))   # True
字符串判断类方法
num_str = "12345"
15. isdigit()：判断字符串是否全部由纯数字组成
print(num_str.isdigit()) # True
16. isalpha()：判断字符串是否全部由纯字母组成
print(s.isalpha())       # False（包含空格，不是纯字母）

二、列表 list：万能可变容器（有序、可重复、可增删改）

列表是日常开发用得最多的容器，可变、有序、支持所有增删改查操作，方法重点区分：追加、插入、删除、拷贝、排序的差异！

# 定义初始列表
li = [10, 20, 30]
1. append()：在列表【末尾】追加【单个元素】
li.append(40)
print(li)  # [10, 20, 30, 40]
2. extend()：在列表【末尾批量追加一组元素】（可迭代对象：列表、元组等）
li.extend([50, 60])
print(li)  # [10, 20, 30, 40, 50, 60]
3. insert()：在【指定下标位置】插入元素，原元素后移
li.insert(1, 15)
print(li)  # [10, 15, 20, 30, 40, 50, 60]
4. pop()：删除【末尾】元素，【返回被删除的元素】，支持按下标删除
print(li.pop())         # 60（删除最后一个）
print(li)  # [10, 15, 20, 30, 40, 50]
5. remove()：根据【元素值】删除第一个匹配的元素，值不存在则报错
li.remove(15)
print(li)  # [10, 20, 30, 40, 50]
6. copy()：浅拷贝列表，生成全新的独立列表，修改新列表不影响原列表
li2 = li.copy()
print(li2)  # [10, 20, 30, 40, 50]
7. index()：查找元素第一次出现的下标，元素不存在报错
print(li.index(20))     # 1
8. count()：统计指定元素在列表中出现的次数
print(li.count(20))     # 1
9. sort()：对列表元素【原地升序排序】，直接修改原列表
li.sort()
print(li)  # [10, 20, 30, 40, 50]
10. reverse()：反转列表元素顺序，原地修改原列表
li.reverse()
print(li)  # [50, 40, 30, 20, 10]

三、元组 tuple：只读安全容器（不可变、有序、可重复）

元组堪称不可变的列表，一旦定义就无法修改、新增、删除元素，所以方法极少，只有两个核心查询方法，主打一个安全可靠，适合存固定数据。

# 定义初始元组
t = (11, 22, 33, 22)
1. index()：查找元素第一次出现的索引位置，不存在则报错
print(t.index(33))      # 2
2. count()：统计指定元素在元组中出现的次数
print(t.count(22))      # 2

四、字典 dict：键值对精准存储器（可变、无序、键唯一）

字典是Python的检索神器，以键取值，高效精准，核心避坑：普通取值键不存在会报错，推荐用get方法！

# 定义初始字典
d = {"name": "小明", "age": 18}
1. keys()：获取字典所有的键，转为列表输出
print(list(d.keys()))       # ['name', 'age']
2. values()：获取字典所有的值，转为列表输出
print(list(d.values()))     # ['小明', 18]
3. items()：获取字典所有键值对，以(键,值)元组形式返回
print(list(d.items()))      # [('name', '小明'), ('age', 18)]
4. get()：安全取值，键存在返回值，【键不存在返回None，不报错】
print(d.get("name"))        # 小明
print(d.get("sex"))         # None（无sex键，不报错）
5. update()：更新/新增键值对，有则改，无则加
d.update({"sex": "男", "age": 19})
print(d)  # {'name': '小明', 'age': 19, 'sex': '男'}
6. pop()：根据【键】删除指定键值对，返回对应的值
print(d.pop("age"))         # 19
print(d)  # {'name': '小明', 'sex': '男'}
7. popitem()：删除字典【最后一组】键值对（Python3.7+有序）
d.popitem()
print(d)  # {'name': '小明'}
8. setdefault()：键不存在则新增键值对，存在则保留原值不修改
d.setdefault("height", 175)
print(d)  # {'name': '小明', 'height': 175}
9. copy()：浅拷贝字典，生成独立新字典
d2 = d.copy()
print(d2)  # {'name': '小明', 'height': 175}

五、集合 set：去重与集合运算神器（可变、无序、无重复）

集合最大特性：自动去重、元素唯一、无序存储，日常多用于数据去重、求交集/并集/差集，删除方法一定要区分报错和不报错的区别！

# 定义初始集合
s_set = {1, 2, 3}
1. add()：添加【单个】元素，元素重复则不生效
s_set.add(4)
print(s_set)  # {1, 2, 3, 4}
2. update()：批量添加多个元素（可迭代对象），自动去重
s_set.update([5, 6])
print(s_set)  # {1, 2, 3, 4, 5, 6}
3. remove()：删除指定元素，【元素不存在直接报错】
s_set.remove(6)
print(s_set)  # {1, 2, 3, 4, 5}
4. discard()：删除指定元素，【元素不存在不报错，静默执行】
s_set.discard(999)
print(s_set)  # {1, 2, 3, 4, 5}（无变化，不报错）
5. pop()：随机删除集合中一个元素（因集合无序），返回删除的元素
print(s_set.pop())
print(s_set)
========== 集合核心运算：交集、并集、差集 ==========
s1 = {1, 2, 3}
s2 = {3, 4, 5}
符号写法（简洁）
print(s1 & s2)                      # 交集：{3} 两个集合共有元素
print(s1 | s2)                      # 并集：{1,2,3,4,5} 合并所有元素（去重）
print(s1 - s2)                      # 差集：{1,2} s1独有、s2没有的元素
方法写法（规范、可读性更强）
print(s1.intersection(s2))         # 交集
print(s1.union(s2))                # 并集
print(s1.difference(s2))           # 差集

六、终极总结（新手必背）

1. 不可变类型（不能改原数据）：字符串、元组，所有操作均返回新数据

2. 可变类型（可原地修改）：列表、字典、集合，直接操作原数据

3. 删除方法避坑：集合remove报错、discard不报错；字典get取值不报错

4. 场景适配：

• 文本用字符串
• 有序数据用列表
• 固定数据用元组
• 键值检索用字典
• 去重比对用集合