代码收藏家 Python入门第一天：快速上手指南
这个教程是菜鸟糙学，后续补充更全知识点
任务点：①安装pythonPython安装与环境配置全程详细教学（包含Windows版和Mac版）_python环境-CSDN博客
②安装pycharm
PyCharm安装教程及基本使用（更新至2024年新版本），教你迈出学习python第一步-CSDN博客
第一部分
③基础语法
④变量类型
第二部分
⑤语句用法（if,while….）
⑥变量类型补充知识
第一部分
1、基础数据类型
# ---------------------- 1. 整数（int） ----------------------
student_id = 1001 # 整数类型：用于存储整数（如学号、年龄）
print(f"学号：{student_id}，类型：{type(student_id)}") # 在字符串前加f，{}内写变量名或表达式、
#输出：学号：1001，类型：<class 'int'>
num = -50 # 负数也是整数
big_num = 1000000000000 # Python 3中int无大小限制（自动处理大整数）
# ---------------------- 2. 浮点数（float） ----------------------
height = 1.75 # 浮点数：用于存储小数（如身高、成绩）
pi = 3.1415926 # 普通浮点数
exponent_num = 1.23e4 # 科学计数法：等价于1.23×10^4（即12300）
print(f"科学计数法值：{exponent_num}") # 输出：12300.0
# ---------------------- 3. 字符串（str） ----------------------
name = "张三" # 字符串：用单引号或双引号创建（推荐统一风格）
name1 = "aril"
greeting = "你好，世界！"
multiline_str = """ # 三引号创建多行字符串
第一行
第二行
"""
print(f"多行字符串：\n{multiline_str}")
# 字符串常用操作（知识点！）
print(f"字符串长度：{len(name)}") # len()函数：获取字符串长度（中文算1个字符）
print(f"首字母大写：{name1.capitalize()}") # capitalize()方法：首字母大写 → "Aril"
print(f"替换字符：{name.replace('张', '李')}") # replace()方法：替换字符 → "李四"
# ---------------------- 4. 布尔值（bool） ----------------------
is_student = True # 布尔值：True/False（注意首字母大写！）
is_graduate = False
print(f"是否是学生：{is_student}，类型：{type(is_student)}") # 输出：<class 'bool'>
# 布尔值与数值的关系（重要！）
print(True + 1) # 输出：2（True等价于1）
print(False * 5) # 输出：0（False等价于0）
# ---------------------- 5. 复数（complex） ----------------------
z = 3 + 4j # 复数：实部+虚部（j表示虚数单位）
print(f"复数实部：{z.real}，虚部：{z.imag}") # 输出：3.0 4.0
print(f"共轭复数：{z.conjugate()}") # 输出：(3-4j)2、复合数据类型
# ---------------------- 1. 列表（list）- 可变序列 ----------------------
scores = [90, 85, 95] # 列表：用方括号创建，元素可重复、可修改
print(f"原始成绩：{scores}")
# 列表常用操作（知识点！）
scores.append(88) # append()：末尾添加元素 → [90, 85, 95, 88]
scores[1] = 87 # 直接修改元素（列表可变）→ [90, 87, 95, 88]
scores.pop() # pop()：删除末尾元素 → [90, 87, 95]
print(f"修改后成绩：{scores}")
# 列表切片（取子集）
print(f"前2个成绩：{scores[:2]}") # 输出：前2个成绩：[90, 87]（左闭右开，不包含索引2）
# ---------------------- 2. 元组（tuple）- 不可变序列 ----------------------
courses = ("数学", "编程", "英语") # 元组：用圆括号创建，元素不可修改
# courses[0] = "物理" # 报错！元组不可变，会触发TypeError
# 元组解包（重要！）
course1, course2, course3 = courses # 解包到三个变量
print(f"第一门课：{course1}")
# ---------------------- 3. 字典（dict）- 键值对存储 ----------------------
user = {
"name": "李四", # 键: 值（键必须唯一，通常为字符串）
"age": 20,
"hobbies": ["阅读", "运动"] # 值可以是任意类型（包括列表）
}
# 字典常用操作（知识点！）
print(f"姓名：{user['name']}") # 通过键获取值（键不存在会报错）
print(f"年龄：{user.get('age', 18)}") # get()方法：安全获取值，默认值18（键不存在时返回）
user["email"] = "lisi@example.com" # 添加新键值对
print(f"完整用户信息：{user}")
# 遍历字典
for key, value in user.items():
print(f"{key}: {value}") # 输出：name: 李四，age: 20，hobbies: [...], email: ...
3、变量与内存原理
a = 10 # 变量a指向整数对象10（整数是不可变类型）
b = a # 变量b指向同一个对象（内存地址相同）
print(f"a的地址：{id(a)}，b的地址：{id(b)}") # 输出相同地址
a = 11 # 重新赋值，a指向新对象11（b仍指向10）
print(f"修改后b的值：{b}") # 输出：10（证明不可变类型赋值会创建新对象）4、命名规范与最佳实践
# 正确命名（蛇形命名法，PEP 8规范）
student_name = "王五" # 用下划线分隔单词，全小写
max_score = 100 # 常量用全大写（约定俗成，非强制）
# 避免错误命名
# 1name = "错误" # 不能以数字开头
# list = [1, 2] # 避免覆盖内置类型名（如list、dict）代码知识点总结（按注释顺序）
-
基础数据类型：
- 整数（
int）：无大小限制，支持负数和大整数。 - 浮点数（
float）：科学计数法表示，注意精度问题。 - 字符串（
str）：三引号创建多行字符串，常用方法len()、replace()、capitalize()。 - 布尔值（
bool）：True/False等价于1/0，注意首字母大写。 - 复数（
complex）：实部.real、虚部.imag、共轭.conjugate()。 -
复合数据类型：
- 列表（
list）：可变序列，方法append()、pop()、切片[:]。 - 元组（
tuple）：不可变序列，解包操作（如a, b = (1, 2)）。 - 字典（
dict）：键值对存储，get()安全取值，items()遍历键值。 -
变量本质：
- 变量是对象的引用，不可变类型（如
int、str）赋值会创建新对象。 id()函数查看对象内存地址，判断是否为同一对象。-
类型转换与异常处理：
- 显式转换（
int()、float()、str()），注意转换失败场景。 try-except捕获ValueError，处理非法输入。-
编码规范：
- 蛇形命名法（
student_name），避免使用关键字和内置类型名。 - 常量用全大写（如
MAX_SCORE），增强代码可读性。
初学者学习建议
- 运行代码：逐行执行代码，观察输出结果，理解每个数据类型的行为。
- 修改练习：
- 尝试修改列表中的元素，观察元组修改时报错的原因。
- 故意写错字典的键，观察
keyError并添加get()修复。 - 重点记忆：
- 不可变类型：
int、float、str、tuple、bool。 - 可变类型：
list、dict。 - 布尔值的 “假值”：
0、""、None、[]、{}等。
第二部分
语法用法
①条件控制语句
# ======================
# if-elif-else 完整语法
# ======================
'''
if condition_1: # 条件1（必填）
block_1 # 条件1为True时执行
elif condition_2: # 条件2（可选，可多个）
block_2 # 条件2为True时执行
else: # 否则（可选）
block_3 # 所有条件不满足时执行
'''
# 场景：成绩等级判断
score = 85 # 可修改此值测试不同分支
if score >= 90:
grade = "A"
print(f"分数 {score} 属于等级：{grade}（优秀）")
elif score >= 80: # 等价于 else if（Python 无 else if 关键字）
grade = "B"
print(f"分数 {score} 属于等级：{grade}（良好）")
elif score >= 60:
grade = "C"
print(f"分数 {score} 属于等级：{grade}（及格）")
else:
grade = "D"
print(f"分数 {score} 属于等级：{grade}（不及格）")
# 输出：分数 85 属于等级：B（良好）
# 场景：仅处理满足条件的情况
score = 75
if score >= 90:
print("优秀")
elif score >= 80:
print("良好")
# 无else时，score<80的情况不处理
# ======================
# 比较运算符与逻辑运算符
# ======================
x = 10
y = 5
# 1. 比较运算符示例
print(f"{x} > {y}：{x > y}") # 10 > 5：True
print(f"{x} <= {y}：{x <= y}") # 10 <= 5：False
print(f"{x} == {y}：{x == y}") # 10 == 5：False
# 2. 逻辑运算符（and/or/not）
is_student = True
has_ticket = False
if is_student and has_ticket:
print("可购买学生票")
elif is_student or has_ticket:
print("可享受普通优惠")
else:
print("无优惠")
# 输出：可享受普通优惠（因 is_student 为 True）
# ======================
# if 嵌套结构
# ======================
'''
if condition_1:
if condition_2: # 内层if
block_2
else: # 内层else
block_3
elif condition_3: # 外层elif
block_4
嵌套层级不宜过多（建议不超过 3 层），否则影响可读性。
'''
# 场景：判断数字的奇偶性与是否为3的倍数
num = 15 # 可修改此值测试不同分支
if num % 2 == 0:
print(f"{num} 是偶数")
if num % 3 == 0:
print(f"{num} 是 3 的倍数")
else:
print(f"{num} 不是 3 的倍数")
else:
print(f"{num} 是奇数")
if num % 3 == 0:
print(f"{num} 是 3 的倍数")
else:
print(f"{num} 不是 3 的倍数")
# 输出：15 是奇数，15 是 3 的倍数（因 15%2=1，15%3=0）
# ======================
# match...case 语法（Python 3.10+）
# ======================
'''
match subject: # 匹配的对象
case pattern1: # 模式1（可包含条件）
action1 # 匹配成功时执行
case pattern2: # 模式2
action2
case _: # 通配符（类似default）
default_action
'''
#+++简单匹配（值匹配）+++
# 场景：HTTP 状态码解析
def parse_status_code(status: int) -> str:
match status:
case 200:
return "OK"
case 400 | 401 | 403: # 多个条件用 | 分隔
return "Client Error"
case 404:
return "Not Found"
case 500 | 502 | 503:
return "Server Error"
case _: # 通配符（类似 switch 的 default）
return "Unknown Status"
# 测试不同状态码
print(parse_status_code(404)) # 输出：Not Found
print(parse_status_code(502)) # 输出：Server Error
print(parse_status_code(999)) # 输出：Unknown Status
#+++多条件匹配（| 分隔）+++
# 场景：匹配多个错误状态码
match status:
case 401 | 403 | 404:
return "Access Denied"
case 500 | 502:
return "Server Error"
#+++变量绑定匹配+++
# 场景：匹配列表结构
points = [1, 2, 3]
match points:
case [x, y, z]: # 解包列表元素到x,y,z
print(f"Points: x={x}, y={y}, z={z}") # 输出：Points: x=1, y=2, z=3
case _:
pass
# ======================
# 单行条件表达式（三元运算符）
# ======================
# 语法：value_if_true if condition else value_if_false
status = "success" if score >= 60 else "fail"
# 场景：根据年龄判断是否成年
age = 17
result = "成年" if age >= 18 else "未成年"
print(f"年龄 {age}：{result}") # 输出：年龄 17：未成年
# 扩展：多层嵌套简写（不推荐过度使用，影响可读性）
grade = "A" if score >= 90 else ("B" if score >= 80 else "C")
②循环控制语句
# ======================= 一、while循环基础 =======================
# 语法结构：
'''
while condition: # 当条件为True时循环执行
code_block # 循环体（缩进4空格）
[break] # 可选：跳出循环
[continue] # 可选：跳过本次循环
else: # 可选：循环正常结束后执行（未被break中断）
else_block
'''
# ---------------------- 示例1：基本while循环 ----------------------
count = 0
while count < 5:
print(f"当前计数：{count}") # 输出0-4
count += 1 # 必须更新条件变量，否则死循环
# ---------------------- 示例2：带else的while循环 ----------------------
# else块在条件不满足时执行（若被break中断则不执行）
num = 3
while num > 0:
print(f"倒计时：{num}")
num -= 1
else:
print("发射！") # 输出：发射！
# ---------------------- 示例3：死循环（需谨慎） ----------------------
# while True: # 条件永远为真
# user_input = input("输入q退出：")
# if user_input == 'q':
# break # 必须用break终止，否则程序卡死
# ======================= 二、for循环基础 =======================
'''
for element in iterable: # 遍历可迭代对象（如列表、字符串）
code_block
[break]
[continue]
else: # 循环正常结束后执行
else_block
'''
# ---------------------- 示例1：遍历列表 ----------------------
fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
print(f"我喜欢吃{fruit}")
# ---------------------- 示例2：遍历字符串 ----------------------
for char in "Python":
print(f"字符：{char}") # 输出P,y,t,h,o,n
# ---------------------- 示例3：遍历range()生成的数字序列 ----------------------
# range(stop)：生成0到stop-1的整数
for i in range(5):
print(f"数字：{i}") # 输出0-4
# range(start, stop, step)：指定起始、结束和步长
for i in range(1, 10, 2):
print(f"奇数：{i}") # 输出1,3,5,7,9
# ---------------------- 示例4：带索引的遍历（enumerate） ----------------------
for index, fruit in enumerate(fruits, start=1): # start=1指定索引从1开始
print(f"第{index}个水果：{fruit}")
# ======================= 三、循环控制语句（break/continue） =======================
# ---------------------- break：终止整个循环 ----------------------
while True:
user_input = input("输入q退出：")
if user_input == 'q':
break # 立即退出循环
print(f"你输入的是：{user_input}")
# ---------------------- continue：跳过当前循环 ----------------------
for num in range(10):
if num % 2 == 0:
continue # 跳过偶数
print(f"奇数：{num}") # 输出1,3,5,7,9
# ---------------------- pass：占位语句（不做任何事） ----------------------
for i in range(3):
if i == 1:
pass # 占位，用于保持代码结构完整
print(f"数字：{i}") # 输出0,1,2
# ======================= 四、嵌套循环（重点！） =======================
# ---------------------- 示例1：打印乘法表 ----------------------
for i in range(1, 10):
for j in range(1, i + 1):
print(f"{j}×{i}={i*j}\t", end="") # \t表示制表符，end=""避免换行
print() # 内循环结束后换行
# ---------------------- 示例2：遍历二维列表 ----------------------
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
for row in matrix:
for element in row:
print(element, end=" ")
print() # 每行结束后换行
# ---------------------- 嵌套循环中的break ----------------------
# 找到目标值后终止所有循环（需标记变量）
target = 5
found = False
for row in matrix:
for element in row:
if element == target:
found = True
break # 只跳出内层循环
if found: # 检查标记，跳出外层循环
break
print(f"是否找到{target}：{found}")
# ======================= 五、循环与else配合（特殊用法） =======================
# else块在循环**正常结束**时执行（未被break中断）
for num in range(2, 5):
is_prime = True
for i in range(2, num):
if num % i == 0:
is_prime = False
break
else: # 内层循环正常结束时执行（未找到因子）
print(f"{num}是质数")
# ======================= 六、扩展：并行遍历多个列表 =======================
#使用 zip () 函数
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
for name, age in zip(names, ages): # 并行遍历
print(f"{name} 年龄：{age}")
# 输出：
# Alice 年龄：25
# Bob 年龄：30
# Charlie 年龄：35
#使用 enumerate () 获取索引
fruits = ["apple", "banana", "cherry"]
for index, fruit in enumerate(fruits, start=1): # 索引从1开始
print(f"第{index}个水果：{fruit}")
# 输出：
# 第1个水果：apple
# 第2个水果：banana
# 第3个水果：cherry
#end 关键字
#关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符，实例如下：
#!/usr/bin/python3
# Fibonacci series: 斐波纳契数列
# 两个元素的总和确定了下一个数
a, b = 0, 1
while b < 1000:
print(b, end=',')
a, b = b, a+b #输出结果1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,
# ======================= 七、循环技巧与最佳实践 =======================
# ---------------------- 并行遍历多个列表（zip） ----------------------
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 22]
for name, age in zip(names, ages):
print(f"{name}今年{age}岁")
# ---------------------- 倒序遍历（reversed） ----------------------
for i in reversed(range(1, 4)):
print(f"倒计时：{i}") # 输出3,2,1
# ---------------------- 排序后遍历（sorted） ----------------------
numbers = [3, 1, 4]
for num in sorted(numbers):
print(f"排序后：{num}") # 输出1,3,4
# ---------------------- 循环中修改列表（需复制） ----------------------
# 错误示例：直接遍历并修改会导致意外结果
# for fruit in fruits:
# if fruit == "香蕉":
# fruits.remove(fruit) # 可能跳过元素
# 正确示例：遍历复制的列表，修改原列表
for fruit in fruits[:]: # fruits[:]创建副本
if fruit == "香蕉":
fruits.remove(fruit)
print(f"修改后的列表：{fruits}")
# ======================= 八、实战案例 =======================
# ---------------------- 1. 计算平均分 ----------------------
scores = [85, 90, 78, 92]
total = 0
for score in scores:
total += score
average = total / len(scores)
print(f"平均分：{average}")
# ---------------------- 2. 斐波那契数列 ----------------------
n = 10
a, b = 0, 1
for _ in range(n):
print(a, end=" ")
a, b = b, a + b # 并行赋值
print()
# ---------------------- 3. 文件内容逐行处理（模拟） ----------------------
# 实际使用时需用with open('file.txt') as f:
lines = ["第一行", "第二行", "第三行"]
for line_num, line in enumerate(lines, start=1):
print(f"第{line_num}行：{line}")代码知识点总结（按注释顺序）
-
循环类型：
while：条件为真时重复执行for：遍历可迭代对象（列表、字符串、range 等）- 注意：
while需手动更新条件变量，避免死循环 -
控制语句：
break：终止整个循环continue：跳过当前循环，继续下一次pass：占位语句，保持代码结构完整else：循环正常结束时执行（未被 break 中断）-
嵌套循环：
- 外层循环执行一次，内层循环执行完整周期
- 常用于处理多维数据（如矩阵、表格）
- 跳出多层循环需使用标记变量
-
循环技巧：
range()：生成数字序列enumerate()：获取索引和值zip()：并行遍历多个序列reversed()/sorted()：倒序 / 排序后遍历-
注意事项：
- 避免在循环中直接修改被遍历的列表（需使用副本）
- 使用
else时注意与break的配合 - 多层嵌套循环会显著降低性能
变量类型补充知识
# ======================= 一、数字类型（Numbers） =======================
# 知识点：int（整数）、float（浮点数）、complex（复数）、bool（布尔）
# ---------------------- 1. 整数（int） ----------------------
age = 18 # 普通整数
large_num = 123456789012345 # 大整数（Python自动处理）
binary_num = 0b1010 # 二进制（0b前缀）→ 10
octal_num = 0o12 # 八进制（0o前缀）→ 10
hex_num = 0xA # 十六进制（0x前缀）→ 10
print(f"不同进制整数：{binary_num}, {octal_num}, {hex_num}")
# ---------------------- 2. 浮点数（float） ----------------------
height = 1.75 # 普通浮点数
scientific_num = 1.23e4 # 科学计数法 → 12300.0
float_operation = 0.1 + 0.2 # 注意精度问题！→ 0.30000000000000004
print(f"浮点运算结果：{float_operation}")
'''十进制小数无法精确转换为二进制，会存在误差，
print(0.3 == 0.1 + 0.2) # 输出：False（因为0.3的二进制也不精确）
print(0.1 + 0.2 + 0.3) # 输出：0.5999999999999999（误差累积）
解决方法：1. 使用 math.isclose() 进行近似比较if math.isclose(a, b):
2. 改用整数运算或 decimal 模块a = Decimal('0.1')；b = Decimal('0.2')；print(a + b)
'''
# ---------------------- 3. 复数（complex） ----------------------
z = 3 + 4j # 复数（实部+虚部）
print(f"复数实部：{z.real}，虚部：{z.imag}") # 3.0, 4.0
print(f"共轭复数：{z.conjugate()}") # (3-4j)
# ---------------------- 4. 布尔值（bool） ----------------------
is_student = True # True等价于1
is_graduate = False # False等价于0
print(f"布尔运算：{True + 1}") # 输出：2（True→1）
# ======================= 二、字符串（Strings） =======================
# 知识点：创建、索引、切片、常用方法、格式化
# ---------------------- 1. 创建字符串 ----------------------
name = "张三" # 单/双引号均可
multiline_str = ''' # 三引号支持多行
第一行
第二行
'''
print(f"多行字符串：\n{multiline_str}")
# ---------------------- 2. 索引与切片 ----------------------
s = "Python"
print(f"索引0：{s[0]}") # P（索引从0开始）
print(f"切片2-4：{s[2:4]}") # th（左闭右开，索引2和3）
print(f"逆序切片：{s[::-1]}") # nohtyP（步长-1）
# ---------------------- 3. 常用方法 ----------------------
text = " Hello, World! "
print(f"去除首尾空格：{text.strip()}") # Hello, World!
print(f"转大写：{text.upper()}") # HELLO, WORLD!
print(f"替换字符：{text.replace('World', 'Python')}") # Hello, Python!
# ---------------------- 4. f-string格式化 ----------------------
age = 20
print(f"{name}今年{age}岁") # 张三今年20岁
print(f"圆周率：{3.1415926:.2f}") # 圆周率：3.14（保留2位小数）
# ---------------------- 5. 转义字符与原始字符串 ----------------------
escaped_str = "换行：\n制表符：\t反斜杠：\\"
print(escaped_str) # 换行后显示制表符和反斜杠
raw_str = r"原始字符串：\n不转义" # r前缀使反斜杠不生效
print(raw_str) # 原始字符串：\n不转义
# ======================= 三、列表（Lists） =======================
# 知识点：创建、增删改查、切片、常用方法、列表推导式
# ---------------------- 1. 创建列表 ----------------------
fruits = ["苹果", "香蕉", "橙子"]
empty_list = [] # 空列表
mixed_list = [1, "a", True] # 混合类型
# ---------------------- 2. 增删改查 ----------------------
fruits.append("葡萄") # 末尾添加 → ["苹果", "香蕉", "橙子", "葡萄"]
fruits.insert(1, "梨") # 指定位置插入 → ["苹果", "梨", "香蕉", "橙子", "葡萄"]
removed = fruits.pop() # 删除末尾元素 → 返回"葡萄"，列表变为["苹果", "梨", "香蕉", "橙子"]
fruits.remove("香蕉") # 按值删除 → ["苹果", "梨", "橙子"]
# fruits.remove("西瓜") # 若元素不存在会报错（ValueError）
fruits[0] = "芒果" # 修改元素 → ["芒果", "梨", "橙子"]
# ---------------------- 3. 切片操作 ----------------------
print(f"前2个水果：{fruits[:2]}") # ["芒果", "梨"]
print(f"逆序列表：{fruits[::-1]}") # ["橙子", "梨", "芒果"]
# ---------------------- 4. 常用方法 ----------------------
print(f"列表长度：{len(fruits)}") # 3
print(f"元素索引：{fruits.index('梨')}") # 1
fruits.sort() # 排序 → ["梨", "芒果", "橙子"]
fruits.reverse() # 反转 → ["橙子", "芒果", "梨"]
# ---------------------- 5. 列表推导式 ----------------------
squares = [x**2 for x in range(1, 6)] # [1, 4, 9, 16, 25]
even_numbers = [x for x in range(10) if x % 2 == 0] # [0, 2, 4, 6, 8]
# ======================= 四、元组（Tuples） =======================
# 知识点：创建、不可变性、解包、常用操作
# ---------------------- 1. 创建元组 ----------------------
colors = ("红", "绿", "蓝")
single_tuple = ("苹果",) # 单个元素需加逗号 → 避免歧义
empty_tuple = () # 空元组
# ---------------------- 2. 不可变性（重点！） ----------------------
# colors[0] = "黄" # 报错！元组不可修改，触发TypeError
# ---------------------- 3. 解包操作 ----------------------
a, b, c = colors # 解包到三个变量
print(f"解包结果：{a}, {b}, {c}") # 红, 绿, 蓝
# ---------------------- 4. 常用操作 ----------------------
print(f"元组长度：{len(colors)}") # 3
print(f"元素索引：{colors.index('绿')}") # 1
print(f"元素出现次数：{colors.count('红')}") # 1
# 转换为列表
lst = list(new_tuple) # 元组转列表 → ["红", "绿", "蓝", "紫"]
print(f"转换结果：{lst}")
# ======================= 五、字典（Dictionaries） =======================
# 知识点：创建、增删改查、遍历、常用方法
# ---------------------- 1. 创建字典 ----------------------
user = {
"name": "张三",
"age": 20,
"hobbies": ["阅读", "运动"] # 值可以是任意类型
}
empty_dict = {} # 空字典
# ---------------------- 2. 增删改查 ----------------------
print(f"姓名：{user['name']}") # 通过键获取值 → 张三
user["email"] = "zhangsan@example.com" # 添加新键值对
user["age"] = 21 # 修改值
del user["hobbies"] # 删除键值对
popped_item = user.pop("hobbies") # 删除并返回指定键的值（列表）
print(f"弹出键值对：hobbies → {popped_item}")
print(f"更新后的字典：{user}") # {"name": "张三", "age": 21, "email": "..."}
# 字典合并
new_info = {"age": 22, "gender": "男"}
user.update(new_info) # 合并 → {"name": "张三", "age": 22, "email": "...", "gender": "男"}
print(f"合并后字典：{user}")
# ---------------------- 3. 安全获取值 ----------------------
print(f"邮箱：{user.get('email', '未提供')}") # 存在则返回值，否则返回默认值
# ---------------------- 4. 遍历字典 ----------------------
for key in user: # 遍历键（等价于user.keys()）
print(f"键：{key}")
for value in user.values(): # 遍历值
print(f"值：{value}")
for key, value in user.items(): # 遍历键值对
print(f"{key}: {value}")
# ---------------------- 5. 常用方法 ----------------------
print(f"所有键：{user.keys()}") # dict_keys(["name", "age", "email"])
print(f"所有值：{user.values()}") # dict_values(["张三", 21, "..."])
user.clear() # 清空字典 → {}
### **知识点总结**
1. **数字类型**：
- `int`：支持任意大小整数，支持二进制、八进制、十六进制表示。
- `float`：注意浮点精度问题，科学计数法表示大数。
- `complex`：实部`.real`、虚部`.imag`、共轭`.conjugate()`。
- `bool`：`True/False`等价于`1/0`，可参与数值运算。
2. **字符串**：
- 索引从0开始，切片支持`[start:end:step]`。
- 常用方法：`strip()`（去空格）、`upper()`（转大写）、`replace()`（替换）。
- f-string格式化：`{变量名:.格式}`，如`{x:.2f}`保留两位小数。
3. **列表**：
- 可变序列，支持增删改查和切片。
- 常用方法：`append()`、`pop()`、`sort()`、`reverse()`。
- 列表推导式：快速生成列表，如`[x**2 for x in range(5)]`。
4. **元组**：
- 不可变序列，适合存储固定数据。
- 解包操作：`a, b = (1, 2)`，简化变量赋值。
- 注意：单个元素元组需加逗号（如`(1,)`）。
5. **字典**：
- 键值对存储，键必须唯一且不可变（常用字符串）。
- 安全取值：`get(key, default)`避免`KeyError`。
- 遍历方式：`keys()`（键）、`values()`（值）、`items()`（键值对）。
### **初学者注意事项**
1. **不可变性**：
- 字符串、元组、数字为不可变类型，赋值会创建新对象。
- 列表、字典为可变类型，可直接修改元素。
2. **索引与切片**：
- 索引超出范围会报错（如`list[10]`）。
- 切片超出范围不会报错，返回空列表/字符串。
3. **字典键类型**：
- 键只能使用不可变类型（如字符串、数字、元组），不能用列表/字典。
通过运行并修改代码，观察不同数据类型的操作效果，逐步掌握基础数据类型的核心用法。作者：菜鸟渣渣的进击
