前言
这部分内容之前写过，但感觉不是特别好，不方便以后翻阅，所以重新整理。有问题欢迎随时指正。
一、基本数据类型
1、整数（int）
- 表示整数，如
10、-5。 - 示例：
int_var = 10
print(f"整数: {int_var}, 类型: {type(int_var)}") # 输出: 整数: 10, 类型: <class 'int'>2、浮点数（float）
- 表示小数，如
3.14、-0.5。 - 示例：
float_var = 3.14
print(f"浮点数: {float_var}, 类型: {type(float_var)}") # 输出: 浮点数: 3.14, 类型: <class 'float'>3、布尔值（bool）
- 表示真或假，只有两个值：
True和False。 - 示例：
bool_var = True
print(f"布尔值: {bool_var}, 类型: {type(bool_var)}") # 输出: 布尔值: True, 类型: <class 'bool'>4、字符串（str）
- 表示文本，用单引号
'或双引号"括起来。 - 示例：
str_var = "Hello, World!"
print(f"字符串: {str_var}, 类型: {type(str_var)}") # 输出: 字符串: Hello, World!, 类型: <class 'str'>二、复合数据类型
1、列表（list）
- 有序的可变集合，可以包含任意类型的元素。
- 示例：
list_var = [1, 2, 3, "a", "b", "c"]
print(f"列表: {list_var}, 类型: {type(list_var)}") # 输出: 列表: [1, 2, 3, 'a', 'b', 'c'], 类型: <class 'list'>1.1、列表基础
1.1.1、列表的创建
- 基础语法：
使用方括号 [] 直接定义元素，支持混合数据类型：
empty_list = [] # 空列表
number_list = [1, 2, 3, 4, 5] # 数字列表
mixed_list = [1, "hello", 3.14, True] # 混合类型列表- 构造函数
list()
将可迭代对象（如字符串、元组）转换为列表：
char_list = list("hello") # 输出 ['h', 'e', 'l', 'l', 'o']
tuple_to_list = list((1, 2, 3)) # 输出 [1, 2, 3]range()生成整数序列
快速生成连续整数列表：
list_range = list(range(5)) # 输出 [0, 1, 2, 3, 4]
list_step = list(range(1, 10, 2)) # 输出 [1, 3, 5, 7, 9]- 列表推导式
单行生成复杂列表，支持条件过滤：
squares = [x**2 for x in range(5)] # 输出 [0, 1, 4, 9, 16]
evens = [x for x in range(10) if x % 2 == 0] # 输出 [0, 2, 4, 6, 8]- 使用
*运算符重复元素
快速生成重复元素的列表：
list9 = [0] * 5 # [0, 0, 0, 0, 0]
list10 = ["hello"] * 3 # ['hello', 'hello', 'hello']- 嵌套列表（多维列表）
创建包含子列表的嵌套结构：
matrix = [[1, 2], [3, 4]] # 二维列表 → [[1,2], [3,4]]1.1.2、常用方法详解
- 添加元素
append(obj)：在列表末尾添加单个元素。
a = [1, 2, 3]
a.append(4) # 结果 → [1, 2, 3, 4]
a.append([5, 6]) # 添加子列表 → [1, 2, 3, 4, [5, 6]]extend(iterable)：将可迭代对象的元素逐个添加到列表末尾。
a = [1, 2, 3]
a.extend([4, 5]) # 结果 → [1, 2, 3, 4, 5]
a.extend("abc") # 添加字符 → [1, 2, 3, 4, 5, 'a', 'b', 'c']insert(index, obj)：在指定索引位置插入元素。
a = [1, 2, 3]
a.insert(0, 0) # 在索引0插入 → [0, 1, 2, 3]
a.insert(2, "x") # 在索引2插入 → [0, 1, 'x', 2, 3]- 删除元素
remove(obj)：删除第一个匹配的元素，无匹配时报错。特点
按值删除：通过值（而非索引）查找并删除元素。
仅删第一个匹配项：若有多个相同值，只删除第一个出现的。
无返回值：直接修改原列表，不返回被删除的值。
异常风险：若值不存在，抛出
ValueError。
fruits = ["apple", "banana", "cherry", "banana"]
fruits.remove("banana")
print(fruits) # 输出: ['apple', 'cherry', 'banana']（删除了第一个"banana"）
# 尝试删除不存在的值会报错
try:
fruits.remove("mango")
except ValueError:
print("值不存在！") # 触发异常
a = [1, 2, 3, 2]
a.remove(2) # 删除第一个2 → [1, 3, 2]pop([index])：删除并返回指定索引的元素（默认最后一个）。特点
按索引删除：通过索引（而非值）定位元素。
有返回值：返回被删除的元素。
默认删除最后一个：若未指定索引，默认
index=-1（最后一个元素）。
异常风险：若索引越界，抛出 IndexError。clear()：清空列表。clear()：清空列表。
a = [1, 2, 3, 4]
a.pop() # 删除4 → 返回4，a变为[1, 2, 3]
a.pop(0) # 删除1 → 返回1，a变为[2, 3]
numbers = [10, 20, 30, 40]
# 删除最后一个元素
popped_element = numbers.pop()
print(popped_element) # 输出: 40
print(numbers) # 输出: [10, 20, 30]
# 删除指定索引元素
popped_element = numbers.pop(1)
print(popped_element) # 输出: 20
print(numbers) # 输出: [10, 30]
# 索引越界会报错
try:
numbers.pop(5)
except IndexError:
print("索引越界！") # 触发异常clear()：清空列表特点
无差别删除：一次性移除所有元素。
无返回值：直接修改原列表，不返回任何内容。
安全操作：不会因值或索引不存在而报错。
colors = ["red", "green", "blue"]
colors.clear()
print(colors) # 输出: []三种删除数据方式对比表格
| 方法 | 操作依据 | 返回值 | 是否修改原列表 | 异常场景 | 典型用途 |
|---|---|---|---|---|---|
remove(obj) |
值（首个匹配） | 无 | 是 | 值不存在 → ValueError |
删除已知值的元素 |
pop([index]) |
索引（默认-1） | 被删除的元素 | 是 | 索引越界 → IndexError |
删除指定位置元素并获取其值 |
clear() |
无 | 无 | 是 | 无 | 快速清空列表 |
- 排序与反转
1、sort(key=None, reverse=False)：原地排序（默认升序）。
a = [3, 1, 4, 2]
a.sort() # 升序 → [1, 2, 3, 4]
a.sort(reverse=True) # 降序 → [4, 3, 2, 1]2、reverse()：反转列表元素顺序。
a = [1, 3, 2]
a.reverse() # 结果 → [2, 3, 1]3、sorted()：返回新排序列表（原列表不变）
umbers = [5, 2, 9, 1, 7]
sorted_numbers = sorted(numbers)
print(sorted_numbers) # 输出: [1, 2, 5, 7, 9]
print(numbers) # 原列表不变: [5, 2, 9, 1, 7]
- 查找与统计
1、index(obj, [start, end])：返回第一个匹配元素的索引，无匹配时报错。
a = [10, 20, 30, 20]
print(a.index(20)) # 输出 1
print(a.index(20, 2)) # 从索引2开始查找 → 32、count(obj)：统计元素出现的次数。
a = [1, 2, 2, 3, 2]
print(a.count(2)) # 输出 3- 复制与合并
1、copy()：返回列表的浅拷贝。
a = [1, 2, 3]
b = a.copy() # b是a的独立副本
b.append(4) # a仍为[1,2,3]，b为[1,2,3,4]2、extend()：用于将可迭代对象（如列表、元组、字符串、字典等）的元素逐个添加到列表的末尾。它直接修改原列表，不返回新列表
list1 = [1, 2, 3]
list1.extend([4, 5, 6])
print(list1) # 输出: [1, 2, 3, 4, 5, 6]
list2 = [1, 2, 3]
list2.append([4, 5, 6])
print(list2) # 输出: [1, 2, 3, [4, 5, 6]]- 其他操作
1、len(list)：获取列表长度。
a = [1, 2, 3]
print(len(a)) # 输出 32、切片操作：灵活截取子列表。
a = [0, 1, 2, 3, 4]
print(a[1:3]) # 输出 [1, 2]
print(a[::-1]) # 反转 → [4, 3, 2, 1, 0]2、元组（tuple）
元组是 不可变序列，用圆括号 () 定义，元素用逗号分隔。
2.1、元组的创建方法
1、直接赋值法
# 空元组
t1 = ()
# 单元素元组（必须加逗号）
t2 = (5,)
not_a_tuple = (42) # 这是一个整数，不是元组
# 多元素元组
t3 = (1, "apple", True, 3.14)
# 省略括号（通过逗号自动识别为元组）
t4 = 1, 2, 32、tuple()构造函数
# 将列表转换为元组
list_to_tuple = tuple([1, 2, 3])
# 将字符串转换为元组（每个字符为元素）
string_to_tuple = tuple("hello") # 输出：('h', 'e', 'l', 'l', 'o')
# 将字典键转换为元组
dict_keys_to_tuple = tuple({"name": "Alice", "age": 25}) # 输出：('name', 'age')3、range()生成数值元组
# 生成10到18的偶数元组
num_tuple = tuple(range(10, 20, 2)) # 输出：(10, 12, 14, 16, 18)4、嵌套元组
nested_tuple = ((1, 2), (3, 4), (5, 6))
2.2、元组常用方法示例
1、访问元素与切片
t = ("apple", "banana", "cherry", "date")
# 通过索引访问
print(t[0]) # 输出：apple
print(t[-1]) # 输出：date（负索引从末尾开始）
# 切片操作
print(t[1:3]) # 输出：('banana', 'cherry')
print(t[::2]) # 输出：('apple', 'cherry')（步长为2）2、查询方法
t = (1, 3, 5, 3, 7)
# index()：返回第一个匹配项的索引
print(t.index(3)) # 输出：1
# count()：统计元素出现次数
print(t.count(3)) # 输出：2
# len()：获取元组长度
print(len(t)) # 输出：53、拼接与重复
t1 = (1, 2)
t2 = ("a", "b")
# 拼接元组
print(t1 + t2) # 输出：(1, 2, 'a', 'b')
# 重复元组
print(t1 * 3) # 输出：(1, 2, 1, 2, 1, 2)4、存在性判断
t = (10, 20, 30)
# 检查元素是否存在
print(20 in t) # 输出：True
print(99 in t) # 输出：False5、类型转换
# 元组转列表
list1 = list(t)
# 列表转元组
tuple1 = tuple(list1)
# 元组转字符串（需先转换为字符串列表）
str_list = [str(i) for i in t]
result = " | ".join(str_list) # 输出："10 | 20 | 30"6、元组解包
x, y, z = (10, 20, 30)
print(x, y, z) # 输出: 10 20 307、其他操作
# max() 和 min()
print(max(t)) # 输出：30
print(min(t)) # 输出：10
# sorted() 返回排序后的列表
sorted_list = sorted(t) # 输出：[10, 20, 30]2.3、元组的不可变性与特例
1、不可变性：元组一旦创建，元素不可直接修改。
t = (1, 2, 3)
# t[1] = 4 # 会报错：TypeError2、特例：若元组包含可变对象（如列表），可修改嵌套对象。
t = ([1, 2], 3)
t[0][0] = 99 # 合法操作
print(t) # 输出：([99, 2], 3)2.4、综合示例
# 创建元组
student = ("Alice", 20, ("Math", 90, "Physics", 85))
# 访问嵌套元素
print(f"姓名：{student[0]}, 年龄：{student[1]}")
print(f"数学成绩：{student[2][1]}, 物理成绩：{student[2][3]}")
# 统计课程数量
courses = student[2]
print(f"课程总数：{len(courses) // 2}") # 输出：2（每两元素为一门课程）
# 计算平均分
scores = [courses[i] for i in range(1, len(courses), 2)]
average = sum(scores) / len(scores)
print(f"平均分：{average}") # 输出：87.53、字典（dict）
3.1、字典的创建方法
字典以 键值对 形式存储数据，键必须是不可变类型（如字符串、数字、元组），值可以是任意类型。
1、空字典创建
empty_dict = {} # 使用大括号
empty_dict = dict() # 使用dict()函数2、直接赋值创建
person = {'name': 'Alice', 'age': 30, 'city': '北京'}3、关键字参数创建
student = dict(id=101, name='Bob', grade='A')4、二元组列表转换
pairs = [('fruit', '苹果'), ('vegetable', '胡萝卜'), ('drink', '茶')]
food_dict = dict(pairs) # {'fruit': '苹果', 'vegetable': '胡萝卜', 'drink': '茶'}5、zip()函数组合
keys = ['x', 'y', 'z']
values = [10, 20, 30]
coordinates = dict(zip(keys, values))
print(coordinates) # {'x': 10, 'y': 20, 'z': 30}6、字典推导式
squares = {num: num**2 for num in range(1, 6)} # 输出: {1:1, 2:4, 3:9, 4:16, 5:25}7、fromkeys()方法
keys = ['a', 'b', 'c']
score_dict = dict.fromkeys(keys, 0) # 输出: {'a':0, 'b':0, 'c':0}8、混合列表处理
mixed_list = ['key1', 100, 'key2', 200, 'key3', 300]
mixed_dict = dict(zip(mixed_list[::2], mixed_list[1::2])) # 输出: {'key1':100, 'key2':200, 'key3':300}3.2、字典的常用方法
1、获取值：get(key, default=None)安全获取值，避免 KeyError。
d = {'name': 'Alice', 'age': 25}
print(d.get('name')) # Alice
print(d.get('gender')) # None（键不存在）
print(d.get('gender', 'Unknown')) # Unknown（返回默认值）2、设置默认值：setdefault(key, default=None)若键存在则返回对应值；否则设置默认值并返回。
d = {'name': 'Alice'}
print(d.setdefault('age', 25)) # 25（设置并返回）
print(d) # {'name': 'Alice', 'age': 25}3、更新字典：update(iterable)合并其他字典或键值对。
d = {'name': 'Alice'}
d.update({'age': 25, 'city': 'Beijing'})
print(d) # {'name': 'Alice', 'age': 25, 'city': 'Beijing'}
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
dict1.update(dict2) # 合并后: {'a':1, 'b':3, 'c':4}
merged_dict = dict1 | dict2 # Python 3.9+支持运算符合并4、删除元素
1、pop(key, default)：删除指定键并返回值，若键不存在可返回默认值。
d = {'name': 'Alice', 'age': 25}
age = d.pop('age')
print(age) # 25
print(d) # {'name': 'Alice'}2、popitem()：删除并返回最后插入的键值对（Python 3.7+ 有序）。
d = {'name': 'Alice', 'age': 25}
item = d.popitem()
print(item) # ('age', 25)
print(d) # {'name': 'Alice'}5、清空字典：clear()清空所有键值对。
d = {'name': 'Alice'}
d.clear()
print(d) # {}6、获取键、值、键值对视图
keys()、values()、items()：返回动态视图对象，实时反映字典变化。
d = {'a': 1, 'b': 2}
keys = d.keys()
values = d.values()
items = d.items()
d['c'] = 3
print(list(keys)) # ['a', 'b', 'c']
print(list(values)) # [1, 2, 3]
print(list(items)) # [('a', 1), ('b', 2), ('c', 3)]7、检查键是否存在
in 关键字：判断键是否在字典中。
d = {'name': 'Alice'}
print('name' in d) # True
print('age' in d) # False8、复制字典
copy()：创建字典的浅拷贝。
d1 = {'a': [1, 2]}
d2 = d1.copy()
d1['a'].append(3)
print(d2) # {'a': [1, 2, 3]}（浅拷贝，嵌套对象共享引用）9、遍历字典
d = {'name': 'Alice', 'age': 25}
# 遍历键
for key in d:
print(key) # 输出 'name', 'age'
# 遍历键值对
for key, value in d.items():
print(f"{key}: {value}") # name: Alice, age: 253.3、综合应用
# 创建字典
data = dict(zip(['a', 'b', 'c'], [1, 2, 3]))
# 修改元素
data.update({'d': 4})
# 安全访问
value = data.get('e', '默认值')
# 遍历处理
for key, val in data.items():
print(f"{key}的平方是{val**2}")
# 清空字典
data.clear()4、集合（set）
4.1、集合的创建
集合是无序的、元素唯一的容器，用 {} 或 set() 创建。
1、使用花括号 {}
# 创建空集合
empty_set = set() # 正确方式（注意：{} 默认创建空字典）
# empty_set = {} # 错误！这实际上创建了一个空字典
# 创建包含元素的集合
fruits = {"apple", "banana", "orange"}
numbers = {1, 2, 3, 4, 5}2、使用 set() 构造函数
# 从列表创建集合
s3 = set([1, 2, 3, 4])
print(s3) # 输出: {1, 2, 3, 4}
# 从字符串创建集合（字符去重）
s4 = set("hello")
print(s4) # 输出: {'h', 'e', 'l', 'o'}
# 空集合必须用 set()，因为 {} 是空字典
empty_set = set()
print(empty_set) # 输出: set()3、使用集合推导式
s5 = {x for x in range(10) if x % 2 == 0}
print(s5) # 输出: {0, 2, 4, 6, 8}4.2、集合的常用方法
1、添加元素
s = {1, 2, 3}
# add(): 添加单个元素
s.add(4)
print(s) # 输出: {1, 2, 3, 4}
# update(): 添加多个元素（可迭代对象）
s.update([5, 6, 7])
print(s) # 输出: {1, 2, 3, 4, 5, 6, 7}2、删除元素
s = {1, 2, 3, 4, 5}
# remove(): 删除指定元素（元素不存在会报错）
s.remove(3)
print(s) # 输出: {1, 2, 4, 5}
# discard(): 删除指定元素（元素不存在不会报错）
s.discard(10) # 无报错
# pop(): 随机删除一个元素（集合为空会报错）
popped = s.pop()
print("被删除的元素:", popped) # 例如输出: 1
# clear(): 清空集合
s.clear()
print(s) # 输出: set()3、集合运算
a = {1, 2, 3}
b = {2, 3, 4}
# 并集: a | b 或 a.union(b)
print(a.union(b)) # 输出: {1, 2, 3, 4}
print(a | b) # 同上
# 交集: a & b 或 a.intersection(b)
print(a.intersection(b)) # 输出: {2, 3}
print(a & b) # 同上
# 差集: a - b 或 a.difference(b)
print(a.difference(b)) # 输出: {1}
print(a - b) # 同上
# 对称差集（不同时存在的元素）: a ^ b 或 a.symmetric_difference(b)
print(a.symmetric_difference(b)) # 输出: {1, 4}
print(a ^ b) # 同上4、集合判断
a = {1, 2, 3}
b = {2, 3}
# 子集判断: issubset()
print(b.issubset(a)) # 输出: True
print(b <= a) # 同上
# 超集判断: issuperset()
print(a.issuperset(b)) # 输出: True
print(a >= b) # 同上
# 是否不相交: isdisjoint()
c = {4, 5}
print(a.isdisjoint(c)) # 输出: True
# in 和 not in：检查元素是否存在。
s = {1, 2, 3}
print(2 in s) # True
print(4 not in s) # True
5、其他方法
s = {1, 2, 3}
copied_set = s.copy() # 复制集合
print(len(s)) # 0三、特殊数据类型
1、None（空值）
- 表示没有值，常用于初始化变量或表示函数没有返回值。
- 示例：
none_var = None
print(f"None: {none_var}, 类型: {type(none_var)}") # 输出: None: None, 类型: <class 'NoneType'>四、类型之间的转换
1、显式转换函数
1、int()：将其他类型转换为整数。
print(f"int('10'): {int('10')}") # 输出: int('10'): 10
print(f"int(3.14): {int(3.14)}") # 输出: int(3.14): 3 2、float()：将其他类型转换为浮点数。
print(f"float(10): {float(10)}") # 输出: float(10): 10.0
print(f"float('3.14'): {float('3.14')}") # 输出: float('3.14'): 3.143、str()：将其他类型转换为字符串。
print(f"str(10): {str(10)}") # 输出: str(10): 10
print(f"str(3.14): {str(3.14)}") # 输出: str(3.14): 3.144、bool()：将其他类型转换为布尔值。
print(f"bool(0): {bool(0)}") # 输出: bool(0): False
print(f"bool(1): {bool(1)}") # 输出: bool(1): True5、list()：将其他类型转换为列表。
print(f"list('abc'): {list('abc')}") # 输出: list('abc'): ['a', 'b', 'c']
print(f"list((1, 2, 3)): {list((1, 2, 3))}") # 输出: list((1, 2, 3)): [1, 2, 3]6、tuple()：将其他类型转换为元组。
print(f"tuple([1, 2, 3]): {tuple([1, 2, 3])}") # 输出: tuple([1, 2, 3]): (1, 2, 3)7、dict()：将其他类型转换为字典。
print(f"dict([('name', 'Alice'), ('age', 25)]): {dict([('name', 'Alice'), ('age', 25)])}") # 输出: dict([('name', 'Alice'), ('age', 25)]): {'name': 'Alice', 'age': 25}8、set()：将其他类型转换为集合。
print(f"set([1, 2, 3]): {set([1, 2, 3])}") # 输出: set([1, 2, 3]): {1, 2, 3}2、隐式转换场景
# 运算自动提升
print(3 + 5.2) # 8.2（int→float）
print(True + 5) # 6（True→1）
# 条件判断转换
if "non-empty": # 自动转为True
print("条件成立")
# 字符串拼接
print("Value: " + str(3.14)) # 必须显式转换数值五、核心函数与方法
1、通用函数
# 类型检查
print(type(3.14)) # <class 'float'>
print(isinstance("text", (str, bytes))) # True
# 数学运算
print(abs(-5)) # 5
print(round(3.14159, 2)) # 3.14
print(divmod(10, 3)) # (3, 1)（商和余数）2、字符串操作
text = "Python编程"
# 常用方法
print(text.upper()) # PYTHON编程
print(text.find("thon")) # 2（返回索引）
print(text.split("编")) # ['Python', '程']
print(f"{3.1415:.2f}") # 3.14（格式化）
# 编码转换
byte_data = text.encode("utf-8") # 字符串→bytes
new_str = byte_data.decode("utf-8")3、容器操作
# 列表方法
nums = [5,2,7,1]
nums.sort() # 原地排序 [1,2,5,7]
nums.append(3) # 添加元素
print(nums[::-1]) # 反转 [3,7,5,2,1]
# 字典方法
user = {"name": "Alice", "age": 30}
print(user.get("email", "N/A")) # 安全获取
user.update({"age":31, "city":"Paris"})
# 集合运算
set_a = {1,2,3}
set_b = {3,4,5}
print(set_a - set_b) # {1,2}（差集）六、实际应用场景
1、用户输入处理
# 安全数值输入
def get_number(prompt):
while True:
try:
return float(input(prompt))
except ValueError:
print("请输入有效数字！")
price = get_number("请输入价格：")2、数据清洗
# 混合类型列表清洗
raw_data = ["25", 30, "无效", 42.5, ""]
clean_data = []
for item in raw_data:
try:
clean_data.append(float(item))
except:
pass
print(clean_data) # [25.0, 30.0, 42.5]七、重要转换规则表
| 原始类型 → 目标类型 | 转换方法 | 注意事项 |
|---|---|---|
| str → int | int("123") |
字符串必须为有效整数格式 |
| float → int | int(3.99) |
直接截断小数部分（不四舍五入） |
| list → set | set([1,2,2,3]) |
自动去重 |
| dict → list | list({"a":1, "b":2}) |
仅保留键的列表 |
| bytes → str | b"data".decode("utf-8") |
需指定正确编码 |
| bool → int | int(True) → 1 |
True→1, False→0 |