Python 核心数据类型

1. 字符串 (str)

定义方式

• 单引号：'...'
• 双引号："..."
• 三引号：'''...''' 或 """..."""（支持多行/文档注释）
• 原始字符串：r"..."
• 格式化字符串：f"...{var}..."

转义字符

• \n 换行
• \t 制表符
• \' 单引号
• \" 双引号
• \\ 反斜杠

索引与切片

• 正索引：[0, len-1]
• 负索引：[-1, -len]
• 切片：[start:stop:step]（start 包含，stop 不包含）

遍历

• for e in s: 直接取字符
• for i in range(len(s)): s[i] 索引取字符

常用方法

• 查找：find() / rfind()（返回 -1），index() / rindex()（找不到报错）
• 统计：count()
• 大小写：upper(), lower(), title(), capitalize(), swapcase()
• 对齐填充：center(), ljust(), rjust(), zfill()
• 判断开头/结尾：startswith(), endswith()
• 删除空白/字符：strip(), lstrip(), rstrip(), removeprefix(), removesuffix()
• 拼接与分割：join(), split()
• 替换：replace()
• 编码解码：encode("utf8") → 字节流，decode("utf8") → 字符串
• 格式化：format(), %s, f-string
• 判断类型：isalpha(), isdigit(), isalnum() 等

特性

不可变

示例

# 字符串定义
s1 = 'hello'
s2 = "world"
s3 = '''多行
字符串'''
s4 = r"原始字符串\n不会转义"
name = "Alice"
s5 = f"Hello, {name}!"
字符串操作
s = "Python Programming"
print(s[0])      # 'P'
print(s[-1])     # 'g'
print(s[0:6])    # 'Python'
print(s.find("Pro"))  # 7
print(s.upper()) # 'PYTHON PROGRAMMING'
print("  hello  ".strip())  # 'hello'
print(",".join(["a", "b", "c"]))  # 'a,b,c'

2. 列表 (list)

定义

[ ]，可存放任意类型

索引与切片

同字符串 [start:stop:step]

遍历

• for e in list: 直接取元素
• for i in range(len(list)): list[i]

常用方法

• 添加：append()（末尾），insert(index, obj)
• 合并：extend()（逐个添加）
• 删除：pop() / pop(index)（返回删除值），remove(值)，clear()
• 查找：index()（找不到报错），count()，in
• 排序：sort()（升序），sort(reverse=True)（降序）
• 逆序：reverse()

特性

可变

示例

# 列表定义与操作
my_list = [1, 2, 3, 'a', 'b']
print(my_list[0])        # 1
print(my_list[-1])       # 'b'
print(my_list[1:4])      # [2, 3, 'a']
列表方法
my_list.append(4)        # [1, 2, 3, 'a', 'b', 4]
my_list.insert(2, 'x')   # [1, 2, 'x', 3, 'a', 'b', 4]
my_list.remove('a')      # [1, 2, 'x', 3, 'b', 4]
popped = my_list.pop()   # 4, 列表变为 [1, 2, 'x', 3, 'b']
my_list.sort()           # 排序（同类型元素）
my_list.reverse()        # 反转列表
列表遍历
for item in my_list:
print(item)
for i in range(len(my_list)):
print(f"索引 {i}: {my_list[i]}")

3. 元组 (tuple)

定义

(a,) 单元素逗号不可省略，tuple(iterable)

方法

count(), index()（找不到报错）

特性

不可变

示例

# 元组定义
t1 = (1, 2, 3)
t2 = (4,)                # 单元素元组必须有逗号
t3 = tuple([5, 6, 7])    # 从列表转换
t4 = 8, 9, 10            # 括号可省略
元组操作
print(t1[0])             # 1
print(t1[1:3])           # (2, 3)
print(t1.index(2))       # 1
print(t1.count(1))       # 1
元组解包
a, b, c = t1
print(a, b, c)           # 1 2 3
元组不可变性
t1[0] = 10  # 会报错：TypeError

4. 字典 (dict)

定义

{key: value}，键必须为不可变类型，值任意

特性

• 无序
• 键不重复
• 基于哈希表 O(1)

遍历

可遍历键/值/项

常见操作

增删改查

示例

# 字典定义
student = {"name": "Alice", "age": 20, "grade": "A"}
scores = dict(math=95, english=88, science=92)
字典操作
print(student["name"])           # Alice
student["age"] = 21              # 修改值
student["city"] = "Beijing"      # 添加新键值对
del student["grade"]             # 删除键值对
字典方法
print(student.get("name"))       # Alice
print(student.get("height", 170)) # 170（默认值）
print(student.keys())            # dict_keys(['name', 'age', 'city'])
print(student.values())          # dict_values(['Alice', 21, 'Beijing'])
print(student.items())           # dict_items([('name', 'Alice'), ('age', 21), ('city', 'Beijing')])
字典遍历
for key in student:
print(f"{key}: {student[key]}")
for key, value in student.items():
print(f"{key} = {value}")

5. 集合 (set)

定义

{a,b,c}，set()，元素不可变，自动去重

特性

• 可变
• 无序
• 不重复

添加/更新

add()，update()

删除

• pop()（随机删）
• remove()（删指定，不存在报错）
• discard()（删指定，不存在不报错）
• clear()

集合运算

• 交集：intersection() / &，intersection_update()
• 并集：union() / |
• 差集：difference() / -，difference_update()
• 对称差集：symmetric_difference() / ^，symmetric_difference_update()

示例

# 集合定义与基本操作
# 1. 定义集合
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print("集合1:", set1)  # 输出: {1, 2, 3, 4, 5}
print("集合2:", set2)  # 输出: {4, 5, 6, 7, 8}
2. 基本操作
添加元素
set1.add(6)
print("添加6后:", set1)  # 输出: {1, 2, 3, 4, 5, 6}
删除元素
set1.remove(3)  # 删除存在的元素
print("删除3后:", set1)  # 输出: {1, 2, 4, 5, 6}
discard删除（不存在时不报错）
set1.discard(10)  # 10不存在，不会报错
print("discard 10后:", set1)  # 输出: {1, 2, 4, 5, 6}
3. 集合运算
交集：两个集合共有的元素
intersection_set = set1 & set2  # 或 set1.intersection(set2)
print("交集:", intersection_set)  # 输出: {4, 5, 6}
并集：两个集合所有的元素（去重）
union_set = set1 | set2  # 或 set1.union(set2)
print("并集:", union_set)  # 输出: {1, 2, 4, 5, 6, 7, 8}
差集：在set1中但不在set2中的元素
difference_set = set1 - set2  # 或 set1.difference(set2)
print("差集(set1-set2):", difference_set)  # 输出: {1, 2}
对称差集：两个集合中不重复的元素（即并集减去交集）
symmetric_difference_set = set1 ^ set2  # 或 set1.symmetric_difference(set2)
print("对称差集:", symmetric_difference_set)  # 输出: {1, 2, 7, 8}
4. 更新操作（原地修改）
intersection_update: 保留两个集合的交集
set1_copy = set1.copy()
set1_copy.intersection_update(set2)
print("intersection_update后:", set1_copy)  # 输出: {4, 5, 6}
difference_update: 移除与另一个集合共有的元素
set1_copy = set1.copy()
set1_copy.difference_update(set2)
print("difference_update后:", set1_copy)  # 输出: {1, 2}
symmetric_difference_update: 更新为对称差集
set1_copy = set1.copy()
set1_copy.symmetric_difference_update(set2)
print("symmetric_difference_update后:", set1_copy)  # 输出: {1, 2, 7, 8}

数学运算支持

支持集合运算

6. 推导式

格式

[表达式 for 变量 in 可迭代 if 条件]

类型与示例

• 列表推导 → 返回列表

语法特点：使用方括号 []，返回一个新的列表对象。

适用场景：快速从可迭代对象中筛选、转换元素生成新列表。

# 列表推导示例：生成1-10中偶数的平方列表
numbers = range(1, 11)
even_squares = [x**2 for x in numbers if x % 2 == 0]
print(even_squares)  # 输出: [4, 16, 36, 64, 100]
print(type(even_squares))  # 输出: <class 'list'>

• 字典推导 → 表达式为 key:value

语法特点：使用花括号 {}，表达式格式为 key:value。

适用场景：快速从可迭代对象创建字典，常用于键值对转换。

# 字典推导示例：将列表元素映射为其长度
words = ["apple", "banana", "cherry", "date"]
word_lengths = {word: len(word) for word in words}
print(word_lengths)  # 输出: {'apple': 5, 'banana': 6, 'cherry': 6, 'date': 4}
print(type(word_lengths))  # 输出: <class 'dict'>

• 集合推导 → 表达式为单个元素

语法特点：使用花括号 {}，表达式为单个元素，自动去重。

适用场景：快速从可迭代对象创建集合，自动去除重复元素。

# 集合推导示例：从列表中提取唯一的大写字母
texts = ["Hello", "World", "Python", "HELLO", "world"]
unique_uppers = {char for text in texts for char in text if char.isupper()}
print(unique_uppers)  # 输出: {'H', 'W', 'P', 'E', 'L', 'O', 'Y', 'T', 'N'}
print(type(unique_uppers))  # 输出: <class 'set'>

• 生成器表达式（元组推导） → 返回生成器（省内存，不可索引）

语法特点：使用圆括号 ()，返回生成器对象，惰性求值，节省内存。

适用场景：处理大量数据时避免一次性加载到内存，适合迭代使用。

# 生成器表达式示例：生成大范围数字的平方（惰性计算）
gen = (x**2 for x in range(1, 1000001) if x % 1000 == 0)
print(gen)  # 输出: <generator object <genexpr> at 0x...>
print(type(gen))  # 输出: <class 'generator'>
使用生成器（只能迭代一次）
for i, value in enumerate(gen):
if i < 3:
print(value)  # 输出: 1000000, 4000000, 9000000
else:
break

总结对比：

• 列表推导：[x for x in iterable] → 返回列表，可索引，可重复访问。
• 字典推导：{k:v for k,v in iterable} → 返回字典，键值对映射。
• 集合推导：{x for x in iterable} → 返回集合，自动去重，无序。
• 生成器表达式：(x for x in iterable) → 返回生成器，惰性计算，节省内存，只能迭代一次。

7. 核心数据类型对比

类型	可变性	有序性	元素要求	典型用途
字符串 (str)	❌ 不可变	✅ 有序	字符	文本处理、格式化输出、正则匹配
列表 (list)	✅ 可变	✅ 有序	任意类型	通用序列存储、动态数据集合
元组 (tuple)	❌ 不可变	✅ 有序	任意类型	不可变序列、字典键、函数返回值
字典 (dict)	✅ 可变	✅ 有序 (Python 3.7+)	键必须不可变，值任意	键值对映射、快速查询、配置存储
集合 (set)	✅ 可变	❌ 无序	必须不可变	去重、集合运算、成员测试

说明：

• 可变性：指创建后能否修改元素内容
• 有序性：指元素是否按插入顺序保持，且支持索引访问
• 元素要求：指对存储元素的类型限制
• 典型用途：基于各数据类型特性推荐的使用场景