1.1 环境搭建
Python 安装
IDE 推荐
IDE
特点
适用场景
PyCharm
功能强大、专业
大型项目、企业开发
VS Code
轻量、扩展丰富
轻量开发、多种语言
Thonny
简单、内置新手友好
初学者入门
第一个程序
python
复制代码
print("Hello, World!")
1.2 基础语法
注释
python
复制代码
# 这是单行注释
"""
这是多行注释
可以写多行内容
"""
'''
也可以用单引号
'''
变量与数据类型
python
复制代码
# 变量赋值（不需要声明类型）
name = "Alice" # 字符串 str
age = 25 # 整数 int
height = 1.68 # 浮点数 float
is_student = True # 布尔值 bool
# 查看数据类型
type(name) # <class 'str'>
常用数据类型
类型
示例
说明
int
10, -5, 0
整数
float
3.14, -0.5
浮点数
str
"hello", 'world'
字符串
bool
True, False
布尔值
None
None
空值
类型转换
python
复制代码
# 常见类型转换
int("123") # 字符串转整数
int(3.14) # 浮点数转整数（截断）
float("3.14") # 字符串转浮点数
str(123) # 整数转字符串
bool(0) # 转布尔值（0/空字符串/None 为 False）
bool(1) # 非零值为 True
# 用户输入（返回字符串）
age = int(input("请输入年龄：")) # input 返回字符串，需要转换
运算符
python
复制代码
# 算术运算符
+ - * / # 加减乘除
// # 整除（向下取整）
% # 取余
** # 幂运算（2**3 = 8）
divmod(10, 3) # 同时返回整除结果和余数 (3, 1)
# 比较运算符（返回 True 或 False）
== != > < >= <= # 等于、不等于、大小比较
# 逻辑运算符（注意短路特性）
and or not # 与、或、非
0 and 5 # 返回 0（短路：左边为 False）
5 or 3 # 返回 5（短路：左边为 True）
# 赋值运算符
= += -= *= /= # 基本赋值与复合赋值
//= %= **= # 整除赋值、取余赋值、幂赋值
字符串操作
python
复制代码
# 字符串创建
s1 = "hello"
s2 = 'world'
s3 = """多行
字符串"""
# 字符串拼接
"hello" + "world" # "helloworld"
"hello" * 3 # "hellohellohello"
# 字符串格式化
name = "Alice"
age = 25
f"我叫{name}，今年{age}岁" # f-string（推荐）
"我叫{}，今年{}岁".format(name, age) # format 方法
"我叫%s，今年%d岁" % (name, age) # % 格式化（了解即可）
# 字符串切片
s = "Hello World"
s[0] # 'H' 第一个字符
s[-1] # 'd' 最后一个字符
s[0:5] # 'Hello' 切片（前5个）
s[::2] # 'HloWr' 步长2
s[::-1] # 'dlroW olleH' 反转
# 字符串常用方法
"hello".upper() # 'HELLO' 转大写
"hello".lower() # 'hello' 转小写
"hello".replace("l", "L") # 'heLLo' 替换
"hello".split("l") # ['he', '', 'o'] 分割
" hello ".strip() # 'hello' 去除两端空格
"hello".find("ll") # 2 查找位置（找不到返回-1）
"hello".count("l") # 2 计数
"hello".startswith("he") # True 是否以某字符串开头
"hello".endswith("lo") # True 是否以某字符串结尾
"hello".isdigit() # False 是否为数字
"hello".isalpha() # True 是否为字母
len("hello") # 5 长度
# 字符串判断
s = "123"
s.isdigit() # True 是否全是数字
s.isalpha() # False 是否全是字母
s.isalnum() # True 是否是数字或字母
s.isspace() # False 是否全是空格
s.isupper() # False 是否全是大写
s.islower() # True 是否全是小写
数字处理
python
复制代码
# 常用数学函数
abs(-5) # 5 绝对值
round(3.14159, 2) # 3.14 四舍五入（保留2位）
max(1, 5, 3) # 5 最大值
min(1, 5, 3) # 1 最小值
pow(2, 3) # 8 幂运算
# 数学模块
import math
math.floor(3.7) # 3 向下取整
math.ceil(3.2) # 4 向上取整
math.sqrt(16) # 4.0 平方根
math.pi # 3.141592653589793 圆周率
math.e # 2.718281828459045 自然常数
# 随机数
import random
random.randint(1, 10) # 1-10 之间的随机整数
random.random() # 0-1 之间的随机浮点数
random.choice(["a", "b"]) # 随机选择
random.shuffle([1,2,3]) # 打乱顺序
1.3 控制流程
条件语句
python
复制代码
if 条件1:
# 条件1为True时执行
pass
elif 条件2:
# 条件2为True时执行
pass
else:
# 所有条件都不满足时执行
pass
三元表达式
python
复制代码
# 条件为真时的值 if 条件 else 条件为假时的值
age = 20
status = "成年" if age >= 18 else "未成年"
pass 语句
python
复制代码
# pass 是空语句，不做任何事情，用于占位
if True:
pass # 暂时不写代码，先占个位置
else:
print("条件为假")
循环语句
python
复制代码
# for 循环 - 遍历序列
for i in range(5): # 0,1,2,3,4
print(i)
fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
print(fruit)
# while 循环 - 条件循环
count = 0
while count < 5:
print(count)
count += 1
# 循环控制
break # 跳出循环
continue # 跳过本次循环
# for-else 结构（循环正常结束才执行 else）
for i in range(5):
if i == 10:
break
else:
print("循环正常结束") # 会执行
# while-else 结构
count = 0
while count < 3:
count += 1
else:
print("while 循环正常结束")
1.4 数据结构
列表（List）
python
复制代码
# 创建列表
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", True, 3.14]
empty = [] # 空列表
range_list = list(range(5)) # [0, 1, 2, 3, 4]
# 索引与切片
numbers[0] # 第一个元素
numbers[-1] # 最后一个元素
numbers[1:4] # 切片：获取第2到第4个元素
numbers[::2] # 步长：隔一个取一个
numbers[::-1] # 反转列表
# 添加元素
numbers.append(6) # 末尾添加
numbers.insert(0, 0) # 指定位置插入
numbers.extend([7,8]) # 合并列表
numbers += [9, 10] # 效果同 extend
# 删除元素
numbers.remove(3) # 删除第一个出现的值
numbers.pop() # 删除末尾并返回
numbers.pop(0) # 删除指定位置并返回
del numbers[0] # 按索引删除
numbers.clear() # 清空列表
# 查找与统计
numbers.index(3) # 查找元素位置（不存在报错）
numbers.count(3) # 统计元素出现次数
3 in numbers # 判断元素是否存在
# 其他操作
len(numbers) # 长度
sorted(numbers) # 排序（返回新列表）
numbers.sort() # 原地排序
numbers.reverse() # 原地反转
numbers.copy() # 浅拷贝
# 列表推导式（重要！）
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]
matrix = [[i*j for j in range(3)] for i in range(3)] # 二维列表
元组（Tuple）
python
复制代码
# 创建元组（不可变）
point = (3, 4)
colors = ("红", "绿", "蓝")
empty = () # 空元组
single = (42,) # 单元素元组需要逗号
single = (42) # 这是整数，不是元组
# tuple 可以从列表或其他可迭代对象创建
t = tuple([1, 2, 3]) # (1, 2, 3)
t = tuple("hello") # ('h', 'e', 'l', 'l', 'o')
# 不可修改，但可以包含可变对象
mixed = (1, [2, 3], 4)
mixed[1].append(5) # 可以修改列表部分
mixed[1] = [2, 3] # 报错！不能修改元组元素
# 元组解包
x, y = point # x=3, y=4
a, b, c = colors # a="红", b="绿", c="蓝"
x, y = y, x # 交换变量（不用临时变量）
first, *rest = [1, 2, 3, 4] # first=1, rest=[2, 3, 4]
# 命名元组（带字段名的元组）
from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
print(p.x, p.y) # 1 2
字典（Dict）
python
复制代码
# 创建字典
person = {"name": "Alice", "age": 25, "city": "北京"}
person = dict(name="Alice", age=25) # 另一种创建方式
empty = {} # 空字典
empty = dict() # 空字典
# 访问与修改
person["name"] # 获取值（键不存在会报错）
person.get("name") # 安全获取
person.get("phone", "未知") # 不存在返回默认值
person["phone"] = "123" # 添加新键值对
# 修改值
person["age"] = 26 # 修改值
person.update({"age": 27, "city": "上海"}) # 批量更新
# 删除
del person["city"] # 删除键值对
age = person.pop("age") # 删除并返回值
person.popitem() # 删除最后一个键值对（Python 3.7+）
person.clear() # 清空字典
# 查找
"name" in person # 判断键是否存在
len(person) # 键值对数量
# 遍历
for key in person: # 遍历键
print(key, person[key])
for key, value in person.items(): # 遍历键值对
print(f"{key}: {value}")
for value in person.values(): # 遍历值
print(value)
for key in person.keys(): # 遍历键
print(key)
# 字典方法
person.setdefault("gender", "男") # 不存在则设置，存在则返回原值
person.copy() # 浅拷贝
# 字典推导式（重要！）
squares = {x: x**2 for x in range(5)} # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
d = {k: v for k, v in person.items() if v > 20} # 条件过滤
集合（Set）
python
复制代码
# 创建集合（无序、不重复）
fruits = {"苹果", "香蕉", "橙子"}
numbers = set([1, 2, 2, 3, 3]) # {1, 2, 3} 自动去重
empty = set() # 空集合（不能用 {}，那是字典）
# 添加与删除
fruits.add("葡萄") # 添加一个元素
fruits.update(["西瓜", "草莓"]) # 添加多个元素
fruits.remove("香蕉") # 删除（不存在会报错 KeyError）
fruits.discard("西瓜") # 删除（不存在不报错）
fruits.pop() # 随机删除并返回一个元素
# 集合运算
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
a.union(b) # 并集 {1, 2, 3, 4, 5, 6}
a | b # 并集（运算符形式）
a.intersection(b) # 交集 {3, 4}
a & b # 交集
a.difference(b) # 差集 {1, 2}
a - b # 差集
a.symmetric_difference(b) # 对称差集 {1, 2, 5, 6}
a ^ b # 对称差集
# 判断关系
a.issubset(b) # 是否为子集
a.issuperset(b) # 是否为父集
a.isdisjoint(b) # 是否无交集
# 集合推导式
squares = {x**2 for x in range(5)} # {0, 1, 4, 9, 16}
数据结构选择指南
数据结构
特点
适用场景
list
有序、可变、可重复
顺序存储、需要增删
tuple
有序、不可变
固定数据、保护数据
dict
无序、键值对
键快速查找
set
无序、不重复
去重、集合运算
浅拷贝与深拷贝
python
复制代码
# 浅拷贝：只拷贝第一层
a = [[1, 2], [3, 4]]
b = a.copy() # 或 list(a)、a[:]
b[0][0] = 999 # 修改会影响 a！
# 深拷贝：拷贝所有层级
import copy
c = copy.deepcopy(a)
c[0][0] = 999 # 不会影响 a
# 注意：对于不可变对象（int, str, tuple），浅拷贝足够
x = [1, 2, 3]
y = x.copy()
y[0] = 999 # 不会影响 x
bytes 类型
python
复制代码
# bytes 是不可变的字节序列
b = b"hello" # 创建 bytes
b = bytes([104, 101, 108, 108]) # 从整数列表
# 字符串与 bytes 转换
s = "你好"
b = s.encode("utf-8") # 字符串转 bytes
s = b.decode("utf-8") # bytes 转字符串
# bytes 切片
b = b"hello world"
b[0:5] # b'hello'
1.5 函数
函数定义与调用
python
复制代码
def greet(name):
"""问候函数"""
return f"你好，{name}！"
# 调用
message = greet("Alice")
print(message) # 你好，Alice！
文档字符串（docstring）
python
复制代码
def add(a, b):
"""
加法函数
参数:
a: 第一个数
b: 第二个数
返回:
两个数的和
"""
return a + b
参数类型
python
复制代码
# 位置参数
def add(a, b):
return a + b
add(1, 2) # 按位置传递
# 关键字参数
add(a=1, b=2) # 按名称传递
add(b=2, a=1) # 顺序可以颠倒
# 默认参数（默认参数必须放在位置参数后面）
def greet(name, greeting="你好"):
return f"{greeting}，{name}！"
greet("Alice") # 你好，Alice！
greet("Bob", greeting="Hello") # Hello，Bob！
# 可变参数 *args **kwargs
def func(*args, **kwargs):
print(f"位置参数: {args}")
print(f"关键字参数: {kwargs}")
func(1, 2, 3, name="Alice", age=25)
# 输出:
# 位置参数: (1, 2, 3)
# 关键字参数: {'name': 'Alice', 'age': 25}
# 组合使用
def func(a, b, *args, c=0, **kwargs):
print(f"必选参数: a={a}, b={b}")
print(f"可变位置: {args}")
print(f"默认参数: c={c}")
print(f"可变关键字: {kwargs}")
func(1, 2, 3, 4, c=10, name="Alice")
返回值
python
复制代码
# 无返回值（返回 None）
def print_hello(name):
print(f"Hello, {name}")
# 单个返回值
def add(a, b):
return a + b
# 多个返回值（返回元组）
def divide(a, b):
quotient = a // b
remainder = a % b
return quotient, remainder
q, r = divide(10, 3) # q=3, r=1
result = divide(10, 3) # result = (3, 1)
lambda 表达式
python
复制代码
# 匿名函数，适合简短函数
square = lambda x: x ** 2
print(square(5)) # 25
# 多参数 lambda
add = lambda a, b: a + b
print(add(1, 2)) # 3
# 配合内置函数使用
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))
evens = list(filter(lambda x: x % 2 == 0, numbers))
# sorted 结合 lambda
students = [("Alice", 25), ("Bob", 20), ("Charlie", 30)]
sorted(students, key=lambda x: x[1]) # 按年龄排序
变量作用域
python
复制代码
x = "全局变量"
def func():
x = "局部变量" # 这是局部变量
print(x) # 打印局部变量
def func2():
global x # 声明使用全局变量
x = "修改全局变量"
嵌套函数与闭包
python
复制代码
# 嵌套函数
def outer():
x = "外层变量"
def inner():
print(x) # 可以访问外层变量
inner()
# 闭包：内层函数记住外层变量
def make_multiplier(n):
def multiplier(x):
return x * n
return multiplier
times_3 = make_multiplier(3)
print(times_3(5)) # 15
递归函数
python
复制代码
# 递归：函数调用自身
def factorial(n):
if n <= 1:
return 1
return n * factorial(n - 1)
# 斐波那契数列
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
1.6 模块与包
模块基础
python
复制代码
# 创建模块（my_module.py）
# def say_hello(name):
# return f"Hello, {name}!"
# 导入模块
import my_module
print(my_module.say_hello("Alice"))
# 导入特定函数
from my_module import say_hello
print(say_hello("Bob"))
# 给模块起别名
import my_module as mm
# 给函数起别名
from my_module import say_hello as hi
# 导入所有（不推荐）
from my_module import *
模块特殊变量
python
复制代码
# __name__ 的作用
# 当模块被直接运行时，__name__ == "__main__"
# 当模块被导入时，__name__ == "模块名"
# my_module.py 内容：
def main():
print("这是主函数")
if __name__ == "__main__":
main() # 只有直接运行模块时才执行
# 这是常用模式：防止导入模块时执行测试代码
模块搜索路径
python
复制代码
import sys
print(sys.path) # 查看模块搜索路径
# 添加自定义路径
import sys
sys.path.append("C:/my_modules")
dir() 和 help()
python
复制代码
# dir() 查看模块/对象的所有属性和方法
import math
print(dir(math))
# help() 查看详细文档
help(math.sqrt)
常用标准模块
python
复制代码
import math # 数学函数
import random # 随机数
import datetime # 日期时间
import json # JSON 处理
import os # 操作系统
import sys # 系统相关
import time # 时间
import re # 正则表达式
import collections # 集合容器
pip 包管理
bash
复制代码
# 安装包
pip install 包名
pip install 包名==版本号 # 指定版本
# 卸载包
pip uninstall 包名
# 查看已安装的包
pip list
# 导出依赖
pip freeze > requirements.txt
# 从文件安装
pip install -r requirements.txt
# 升级包
pip install --upgrade 包名
# 查看包信息
pip show 包名
# 国内镜像（加速）
pip install 包名 -i https://pypi.tuna.tsinghua.edu.cn/simple
包结构
复制代码
my_package/
├── __init__.py # 包初始化（可为空）
├── module1.py # 模块1
├── module2.py # 模块2
└── sub_package/ # 子包
├── __init__.py
└── module3.py
1.7 文件操作
读取文件
python
复制代码
# 基本读取
with open("example.txt", "r", encoding="utf-8") as f:
content = f.read() # 读取全部内容
print(content)
# 按行读取
with open("example.txt", "r", encoding="utf-8") as f:
for line in f: # 迭代器方式（推荐大文件）
print(line.strip())
# 读取所有行到列表
with open("example.txt", "r", encoding="utf-8") as f:
lines = f.readlines() # 读取所有行到列表
# 读取单行
with open("example.txt", "r", encoding="utf-8") as f:
first_line = f.readline()
# 指定读取字节数
with open("example.txt", "r", encoding="utf-8") as f:
content = f.read(100) # 读取前100个字符
写入文件
python
复制代码
# 写入（覆盖）
with open("output.txt", "w", encoding="utf-8") as f:
f.write("Hello, World!\n")
f.write("第二行")
# 追加
with open("output.txt", "a", encoding="utf-8") as f:
f.write("\n追加的内容")
# 写入多行
lines = ["第一行\n", "第二行\n", "第三行"]
with open("output.txt", "w", encoding="utf-8") as f:
f.writelines(lines)
文件操作模式
模式
说明
r
只读（默认），文件不存在会报错
w
只写（覆盖），文件不存在会自动创建
a
追加，文件不存在会自动创建
r+
读写，文件不存在会报错
w+
读写（覆盖），文件不存在会自动创建
a+
追加读写，文件不存在会自动创建
b
二进制模式（可与以上模式组合）
二进制文件
python
复制代码
# 读取图片等二进制文件
with open("image.png", "rb") as f:
data = f.read()
# 写入二进制文件
with open("output.png", "wb") as f:
f.write(data)
JSON 文件
python
复制代码
import json
# 写入 JSON
data = {"name": "Alice", "age": 25, "scores": [90, 85, 88]}
with open("data.json", "w", encoding="utf-8") as f:
json.dump(data, f, ensure_ascii=False, indent=2)
# 读取 JSON
with open("data.json", "r", encoding="utf-8") as f:
data = json.load(f)
print(data["name"])
# 字符串与 JSON 互转
json_str = json.dumps(data) # dict -> str
data = json.loads(json_str) # str -> dict
路径处理
python
复制代码
import os
from pathlib import Path
# os 模块（传统方式）
os.path.join("dir", "file.txt")
os.path.exists("file.txt")
os.path.isfile("file.txt")
os.path.isdir("dir")
os.path.dirname("path/to/file.txt")
os.path.basename("path/to/file.txt")
os.path.getsize("file.txt") # 文件大小
os.path.split("path/to/file.txt") # 分离目录和文件名
# pathlib 模块（推荐，更直观）
p = Path("path/to/file.txt")
p.parent # 父目录 Path('path/to')
p.name # 文件名 'file.txt'
p.stem # 不带扩展名的文件名 'file'
p.suffix # 扩展名 '.txt'
p.exists()
p.is_file()
p.is_dir()
p.is_absolute() # 是否为绝对路径
# 路径操作
p = Path("path/to")
list(p.glob("*.txt")) # 匹配所有 txt 文件
list(p.glob("**/*.py")) # 递归匹配所有 py 文件
# 创建目录
Path("new_dir").mkdir(exist_ok=True) # 创建单层目录
Path("parent/child").mkdir(parents=True, exist_ok=True) # 创建多层目录
# 路径拼接
p = Path("dir") / "subdir" / "file.txt"
读写大文件
python
复制代码
# 逐行读取（内存友好）
with open("large_file.txt", "r", encoding="utf-8") as f:
for line in f:
process(line)
# 读取指定行
def read_line(file, line_num):
with open(file, "r", encoding="utf-8") as f:
for i, line in enumerate(f):
if i == line_num - 1:
return line
return None
1.8 异常处理
基本语法
python
复制代码
try:
result = 10 / 0
except ZeroDivisionError:
print("不能除以零！")
except Exception as e:
print(f"发生错误: {e}")
else:
print("没有异常时执行") # try 中无异常时执行
finally:
print("无论是否异常都执行") # 清理工作
raise 抛出异常
python
复制代码
# 抛出异常
def validate_age(age):
if age < 0:
raise ValueError("年龄不能为负数")
if age > 150:
raise ValueError("年龄超出合理范围")
return age
try:
validate_age(-5)
except ValueError as e:
print(f"验证失败: {e}")
异常链
python
复制代码
# 异常链：保留原始异常信息
try:
int("abc")
except ValueError as e:
raise TypeError("类型错误") from e
# 忽略异常链
try:
int("abc")
except ValueError:
raise TypeError("类型错误") from None
常见异常类型
异常类型
说明
ZeroDivisionError
除数为零
TypeError
类型错误
ValueError
值错误
IndexError
索引越界
KeyError
键不存在
FileNotFoundError
文件不存在
AttributeError
属性不存在
NameError
名称未定义
SyntaxError
语法错误
IndentationError
缩进错误
自定义异常
python
复制代码
# 自定义异常类
class AgeError(Exception):
"""年龄错误异常"""
def __init__(self, age, message="年龄必须在0-150之间"):
self.age = age
self.message = message
super().__init__(self.message)
def set_age(age):
if age < 0 or age > 150:
raise AgeError(age)
print(f"设置年龄为: {age}")
try:
set_age(200)
except AgeError as e:
print(f"错误: {e.age}岁的{e.message}")
异常处理原则
python
复制代码
# 1. 尽量精确捕获具体异常
try:
result = 10 / 0
except ZeroDivisionError: # 精确捕获
print("不能除以零")
# 2. 多个异常分开捕获
try:
result = 10 / 0
except ZeroDivisionError:
print("除数为零")
except TypeError:
print("类型错误")
# 3. 异常不一定要处理，可以重新抛出
try:
dangerous_operation()
except Exception:
print("记录日志")
raise # 重新抛出，让上层处理
# 4. 使用 except Exception as e 获取异常信息
try:
int("abc")
except Exception as e:
print(f"异常类型: {type(e).__name__}")
print(f"异常信息: {e}")
常用内置函数
python
复制代码
# 类型转换
int() float() str() bool() list() dict() set() tuple() bytes()
# 数据处理
len() # 长度
max() # 最大值
min() # 最小值
sum() # 求和
abs() # 绝对值
round() # 四舍五入
sorted() # 排序
reversed() # 反转（返回迭代器）
enumerate() # 带索引的迭代
zip() # 合并多个序列
all() # 是否全部为 True
any() # 是否存在 True
# 查看信息
type() # 查看类型
isinstance() # 判断类型
dir() # 查看属性和方法
help() # 查看帮助文档
id() # 查看对象 ID
hash() # 哈希值
# 输入输出
print() # 输出
input() # 输入
open() # 打开文件
# 其他
range() # 生成序列
slice() # 切片对象
format() # 格式化
enumerate 示例
python
复制代码
fruits = ["苹果", "香蕉", "橙子"]
for i, fruit in enumerate(fruits, start=1):
print(f"{i}. {fruit}")
# 输出:
# 1. 苹果
# 2. 香蕉
# 3. 橙子
zip 示例
python
复制代码
names = ["Alice", "Bob", "Charlie"]
scores = [85, 90, 78]
for name, score in zip(names, scores):
print(f"{name}: {score}")
# 输出:
# Alice: 85
# Bob: 90
# Charlie: 78
all/any 示例
python
复制代码
numbers = [1, 2, 3, 4, 5]
all(n > 0 for n in numbers) # True 全部大于0
any(n > 4 for n in numbers) # True 存在大于4的
numbers = [0, 1, 2, 3]
all(n > 0 for n in numbers) # False（因为有0）