Python 学习指南

1. Python 基础类型

Python 支持多种数据类型，主要包括：

整数（int）：如 18、-5、0
字符串（str）：如 "hello"、'world'
浮点数（float）：如 3.14、-0.5
布尔值（bool）：True 或 False
空值（NoneType）：None
列表（list）：如 [1, 2, 3]
元组（tuple）：如 (1, 2, 3)
字典（dict）：如 {"name": "张三"}

代码示例

# 字符串
msg = "hello world"
print(msg)  # 输出: hello world

# 布尔值
flag = False
if flag:
    print("flag is True")
else:
    print("flag is False")  # 输出: flag is False

# 查看类型
print(type(flag))  # 输出: <class 'bool'>
print(type(msg))   # 输出: <class 'str'>

# 浮点数和整数
PI = 3.1415926
age = 18
print(PI, type(PI))  # 输出: 3.1415926 <class 'float'>
print(age, type(age))  # 输出: 18 <class 'int'>

# Python 严格区分大小写

2. 列表（List）

列表是 Python 中最常用的数据结构之一，用于存储有序的元素集合。

列表操作方法

操作	方法	说明
访问元素	`list[index]`	通过索引访问，从 0 开始
访问最后元素	`list[-1]`	负数索引从末尾开始
修改元素	`list[index] = value`	直接赋值修改
新增元素	`list.append(value)`	在末尾添加元素
插入元素	`list.insert(index, value)`	在指定位置插入
合并列表	`list.extend(other_list)`	将另一个列表的元素添加到末尾
删除元素	`del list[index]`	删除指定索引的元素
删除并返回	`list.pop(index)`	删除并返回指定索引的元素
删除值	`list.remove(value)`	删除第一个匹配的值
排序	`sorted(list)`	返回新的排序列表（原列表不变）
最大值	`max(list)`	返回列表中的最大值
最小值	`min(list)`	返回列表中的最小值
长度	`len(list)`	返回列表元素个数

切片操作

切片用于访问列表的一部分，语法：list[start:end:step]

左闭右开区间：[start:end] 包含 start，不包含 end
默认值：start 默认 0，end 默认列表长度，step 默认 1
索引越界：切片不会引发 IndexError

my_list = [10, 20, 30, 40, 50]

# 通过切片访问
print(my_list[1:4])   # 输出: [20, 30, 40]
print(my_list[:3])    # 输出: [10, 20, 30]（从开头到索引2）
print(my_list[2:])    # 输出: [30, 40, 50]（从索引2到末尾）
print(my_list[::2])   # 输出: [10, 30, 50]（步长为2）

# 通过切片删除
my_list[1:3] = []     # 删除索引1-2的元素
print(my_list)        # 输出: [10, 40, 50]

# 经过删除后通过切片插入
my_list[1:1] = [25, 35]  # 在索引1处插入
print(my_list)        # 输出: [10, 25, 35, 40, 50]

列表操作示例

# 创建列表
my_list = [1, 2, 3, 4, 5, "香蕉"]
print(my_list)  # 输出: [1, 2, 3, 4, 5, '香蕉']

# 修改元素
my_list[0] = 100
print(my_list)  # 输出: [100, 2, 3, 4, 5, '香蕉']

# 新增元素
my_list.append("orange")
print(my_list)  # 输出: [100, 2, 3, 4, 5, '香蕉', 'orange']

# 删除元素
my_list.remove(2)  # 删除值为2的元素
print(my_list)  # 输出: [100, 3, 4, 5, '香蕉', 'orange']

# 列表长度
print(len(my_list))  # 输出: 6

3. 元组（Tuple）

元组是不可变的列表，使用圆括号 () 定义，一旦创建就不能修改。

元组特点

不可变性：创建后不能修改元素
可以存储不同类型的数据
可以通过索引访问元素
可以使用 len()、max()、min() 等函数

代码示例

# 创建元组
tuple1 = (1, 2, 3, 4, 5, "香蕉")
print(tuple1)  # 输出: (1, 2, 3, 4, 5, '香蕉')
print(type(tuple1))  # 输出: <class 'tuple'>

# 访问元素
print(tuple1[0])  # 输出: 1
print(tuple1[-1])  # 输出: 香蕉

# 元组不可修改
# tuple1[0] = 100  # 这行代码会引发 TypeError

# 遍历元组
for item in tuple1:
    print(item)

4. 字典（Dictionary）

字典是键值对（key-value）的无序集合，使用大括号 {} 定义，键必须是唯一的。

字典操作方法

操作	方法	说明
访问值	`dict[key]`	通过键访问值，键不存在会引发 KeyError
安全访问	`dict.get(key, default)`	键不存在返回默认值
添加/修改	`dict[key] = value`	键不存在则添加，存在则修改
删除键	`del dict[key]`	删除指定键值对
查看键	`dict.keys()`	返回所有键的列表
查看值	`dict.values()`	返回所有值的列表
查看键值对	`dict.items()`	返回所有键值对的列表
检查键存在	`key in dict`	返回布尔值
长度	`len(dict)`	返回键值对数量

代码示例

# 创建字典
person = {"name": "张三", "age": 18, "gender": "男"}
print(person)  # 输出: {'name': '张三', 'age': 18, 'gender': '男'}
print(type(person))  # 输出: <class 'dict'>

# 访问值
print(person["name"])  # 输出: 张三
print(person.get("age"))  # 输出: 18
print(person.get("address", "未知"))  # 输出: 未知（键不存在）

# 修改值
person["age"] = 19
print(person)  # 输出: {'name': '张三', 'age': 19, 'gender': '男'}

# 添加新键值对
person["address"] = "北京"
print(person)  # 输出: {'name': '张三', 'age': 19, 'gender': '男', 'address': '北京'}

# 删除键值对
del person["gender"]
print(person)  # 输出: {'name': '张三', 'age': 19, 'address': '北京'}

# 遍历字典
for key in person:
    print(f"{key}: {person[key]}")

for key, value in person.items():
    print(f"{key}: {value}")

# 检查键是否存在
print("name" in person)  # 输出: True
print("gender" in person)  # 输出: False

# 字典长度
print(len(person))  # 输出: 3

5. 条件判断（if）

条件判断用于根据不同条件执行不同的代码块。

语法结构

if 条件1:
    # 条件1为True时执行
elif 条件2:
    # 条件1为False且条件2为True时执行
else:
    # 所有条件都为False时执行

代码示例

# 基本条件判断
age = 7
if age >= 18:
    print("成年人")
elif age >= 6:
    print("小学生")  # 输出: 小学生
else:
    print("未成年人")

# 多个条件
score = 85
if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")  # 输出: 良好
elif score >= 60:
    print("及格")
else:
    print("不及格")

6. 循环结构

6.1 for 循环

for 循环用于遍历可迭代对象（如列表、元组、字符串等）。

语法结构

for 变量 in 可迭代对象:
    # 循环体

代码示例

# 遍历列表
fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
    print(fruit)

# 使用 range() 函数
# range(10) 生成 0-9 的整数
for i in range(10):
    print(i)

# range(start, end) 生成 start 到 end-1 的整数
for i in range(5, 10):
    print(i)  # 输出: 5, 6, 7, 8, 9

# range(start, end, step) 生成指定步长的整数
for i in range(0, 10, 2):
    print(i)  # 输出: 0, 2, 4, 6, 8

# 累加计算
sum_result = 0
for i in range(10):
    sum_result += i
    print(sum_result)

6.2 while 循环

while 循环用于在条件为 True 时重复执行代码块。

语法结构

while 条件:
    # 循环体

代码示例

# 基本 while 循环
count = 0
while count < 5:
    print(f"count: {count}")
    count += 1

# 无限循环（谨慎使用）
# while True:
#     print("这是无限循环")

# 循环嵌套
for i in range(3):
    for j in range(2):
        print(f"i={i}, j={j}")

7. 函数定义与调用

函数是可重用的代码块，使用 def 关键字定义。

函数语法

def 函数名(参数1, 参数2=默认值):
    # 函数体
    return 返回值

函数特点

函数可以有多个参数，支持默认值
函数可以返回一个或多个值
函数内部变量的作用域是局部的
函数外部变量是全局的，可通过 global 关键字在函数内部修改

代码示例

# 基本函数定义
def say_hello(name="张三"):
    """这是函数的文档字符串，用于说明函数功能"""
    return f"Hello, {name}!"

# 调用函数
print(say_hello())  # 输出: Hello, 张三!
print(say_hello("李四"))  # 输出: Hello, 李四!

# 带多个参数的函数
def add(a, b):
    return a + b

result = add(3, 5)
print(result)  # 输出: 8

# 函数内部的作用域
def test_scope():
    local_var = "局部变量"
    print(local_var)  # 可以访问局部变量

# print(local_var)  # 这行代码会引发 NameError，因为局部变量在函数外部不可访问

# 使用全局变量
global_var = "全局变量"

def test_global():
    global global_var  # 声明使用全局变量
    global_var = "修改后的全局变量"
    print(global_var)

test_global()  # 输出: 修改后的全局变量
print(global_var)  # 输出: 修改后的全局变量

# 函数返回多个值
def get_user_info():
    name = "张三"
    age = 18
    return name, age

user_name, user_age = get_user_info()
print(user_name, user_age)  # 输出: 张三 18

8. 面向对象编程

Python 是面向对象的编程语言，支持类和对象的概念。

类的基本概念

类（Class）：对象的蓝图，定义了对象的属性和方法
对象（Object）：类的实例
属性（Attribute）：对象的特征
方法（Method）：对象的行为
self：代表类的实例，必须是方法的第一个参数

类的语法

class 类名:
    def __init__(self, 参数1, 参数2):
        # 初始化方法，创建对象时自动调用
        self.属性1 = 参数1
        self.属性2 = 参数2

    def 方法名(self, 参数):
        # 方法体
        return 返回值

代码示例

# 定义类
class Person:
    """人员类"""
    def __init__(self, name, age):
        """初始化方法"""
        self.name = name  # 实例属性
        self.age = age

    def say_hello(self, sex="男"):
        """打招呼方法"""
        return f"Hello, {self.name}！性别：{sex}"

    def birthday(self):
        """过生日方法，年龄加1"""
        self.age += 1
        return f"{self.name}今年{self.age}岁了！"

    def get_age(self):
        """获取年龄方法"""
        return self.age

# 创建对象（实例化）
person1 = Person("张三", 18)
print(type(person1))  # 输出: <class '__main__.Person'>

# 调用对象方法
print(person1.say_hello())  # 输出: Hello, 张三！性别：男
print(person1.say_hello("女"))  # 输出: Hello, 张三！性别：女

# 调用修改属性的方法
print(person1.birthday())  # 输出: 张三今年19岁了！
print(person1.get_age())  # 输出: 19

# 直接访问属性
print(person1.name)  # 输出: 张三
print(person1.age)  # 输出: 19

8.1 类继承

类继承允许创建一个新类（子类），继承现有类（父类）的属性和方法。子类可以扩展或修改父类的功能。

继承语法

class 子类名(父类名):
    def __init__(self, 父类参数, 子类参数):
        super().__init__(父类参数)  # 调用父类的初始化方法
        self.子类属性 = 子类参数

    def 子类方法(self):
        # 子类方法实现
        return 结果

继承特点

子类继承父类的所有属性和方法
子类可以重写父类的方法
子类可以添加新的属性和方法
使用 super() 调用父类的方法

代码示例

# 定义父类
class Mammal:
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex
        self.num_eyes = 2  # 所有哺乳动物都有2只眼睛

    def breathe(self):
        print(f"{self.name}在呼吸")

# 定义子类，继承自Mammal
class Person(Mammal):
    def __init__(self, name, sex, occupation):
        # 调用父类的初始化方法，继承父类的属性
        super().__init__(name, sex)
        # 添加子类独有的属性
        self.occupation = occupation

    def work(self):
        # 子类独有的方法
        print(f"{self.name}正在工作，职业是{self.occupation}")

    def breathe(self):
        # 重写父类的方法
        print(f"{self.name}正在用鼻子呼吸")

# 测试继承
# 如果子类没有自己的构造函数 __init__，会直接调用父类的构造函数
class Dog(Mammal):
    def bark(self):
        print(f"{self.name}在汪汪叫")

# 创建子类实例
person = Person("张三", "男", "程序员")
dog = Dog("旺财", "公")

# 调用继承的属性和方法
print(person.name)  # 继承自父类的属性
print(person.num_eyes)  # 继承自父类的属性
person.breathe()  # 调用重写后的方法
person.work()  # 调用子类独有的方法

dog.breathe()  # 调用父类的方法

9. 数学计算（Math 模块）

Python 的 math 模块提供了丰富的数学函数。

常用数学函数

函数	说明	示例
`math.sqrt(x)`	平方根	`math.sqrt(16)` → 4.0
`math.ceil(x)`	向上取整	`math.ceil(3.14)` → 4
`math.floor(x)`	向下取整	`math.floor(3.14)` → 3
`math.pow(x, y)`	x 的 y 次方	`math.pow(2, 3)` → 8.0
`math.fabs(x)`	绝对值	`math.fabs(-10)` → 10.0
`math.gcd(x, y)`	最大公约数	`math.gcd(12, 18)` → 6
`math.lcm(x, y)`	最小公倍数	`math.lcm(12, 18)` → 36
`math.sin(x)`	正弦函数（弧度）	`math.sin(math.pi/2)` → 1.0
`math.cos(x)`	余弦函数（弧度）	`math.cos(math.pi)` → -1.0
`math.tan(x)`	正切函数（弧度）	`math.tan(math.pi/4)` → 1.0
`math.degrees(x)`	弧度转角度	`math.degrees(math.pi/2)` → 90.0
`math.radians(x)`	角度转弧度	`math.radians(90)` → 1.570796...
`math.log(x)`	自然对数	`math.log(math.e)` → 1.0
`math.log10(x)`	以10为底的对数	`math.log10(100)` → 2.0
`math.exp(x)`	e 的 x 次方	`math.exp(1)` → 2.71828...

常量

math.pi：圆周率 π（约3.14159...）
math.e：自然常数 e（约2.71828...）

代码示例

import math

# 平方根
print(math.sqrt(16))  # 输出: 4.0

# 取整
print(math.ceil(3.14))  # 输出: 4
print(math.floor(3.14))  # 输出: 3

# 幂运算
print(math.pow(2, 3))  # 输出: 8.0
print(2 ** 3)  # 输出: 8（Python 内置幂运算）

# 绝对值
print(math.fabs(-10))  # 输出: 10.0
print(abs(-10))  # 输出: 10（Python 内置绝对值）

# 最大公约数和最小公倍数
print(math.gcd(12, 18))  # 输出: 6
print(math.lcm(12, 18))  # 输出: 36

# 三角函数（使用弧度）
print(math.sin(math.pi / 2))  # 输出: 1.0
print(math.cos(math.pi))  # 输出: -1.0

# 角度转换
print(math.degrees(math.pi / 2))  # 输出: 90.0
print(math.radians(90))  # 输出: 1.5707963267948966

# 对数
print(math.log(math.e))  # 输出: 1.0
print(math.log10(100))  # 输出: 2.0

# 常量
print(math.pi)  # 输出: 3.141592653589793
print(math.e)  # 输出: 2.718281828459045

10. 输入输出（Input/Output）

输入函数（input）

input() 函数用于从控制台获取用户输入，返回值是字符串类型。

输出函数（print）

print() 函数用于将内容输出到控制台，支持多个参数和格式化输出。

类型转换

函数	说明	示例
`int(x)`	转换为整数	`int("123")` → 123
`float(x)`	转换为浮点数	`float("3.14")` → 3.14
`str(x)`	转换为字符串	`str(123)` → "123"
`list(x)`	转换为列表	`list("abc")` → ["a", "b", "c"]

代码示例

# 基本输入输出
name = input("请输入您的姓名：")
print(f"您的姓名是：{name}")

# 输入数字并转换类型
age_str = input("请输入您的年龄：")
age = int(age_str)  # 转换为整数
print(f"您明年将满 {age + 1} 岁")

# 多个输入
height = float(input("请输入您的身高（米）："))
weight = float(input("请输入您的体重（千克）："))

# BMI 计算
bmi = weight / (height ** 2)
print(f"您的 BMI 指数是：{bmi:.2f}")

# 类型转换示例
num1 = 123
num2 = "456"
print(str(num1) + num2)  # 输出: 123456（字符串拼接）
print(num1 + int(num2))  # 输出: 579（整数相加）

11. 字符串格式化

Python 提供了多种字符串格式化方式，常用的有：

1. f-strings（Python 3.6+）

使用 f"{变量}" 语法，简洁高效。

2. format() 方法

使用 "{}".format() 语法，兼容性好。

3. 百分号（%）格式化

传统的格式化方式，类似 C 语言的 printf。

代码示例

# f-strings 格式化
name = "张三"
age = 18
print(f"我叫{name}，今年{age}岁")  # 输出: 我叫张三，今年18岁

# 格式化数字
pi = 3.1415926
print(f"π的值是：{pi:.2f}")  # 输出: π的值是：3.14
print(f"π的值是：{pi:10.3f}")  # 输出: π的值是：     3.142（总宽度10，右对齐）

# format() 方法
print("我叫{}，今年{}岁".format(name, age))  # 输出: 我叫张三，今年18岁
print("我叫{0}，今年{1}岁，{0}很优秀".format(name, age))  # 输出: 我叫张三，今年18岁，张三很优秀
print("我叫{name}，今年{age}岁".format(name="李四", age=20))  # 输出: 我叫李四，今年20岁

# 百分号格式化
print("我叫%s，今年%d岁" % (name, age))  # 输出: 我叫张三，今年18岁
print("π的值是：%.2f" % pi)  # 输出: π的值是：3.14

# 多行字符串（保留格式）
multi_line = """这是第一行
这是第二行
这是第三行"""
print(multi_line)

数字格式化说明符

说明符	功能	示例
`:f`	浮点数，默认6位小数	`{3.14:f}` → 3.140000
`:.1f`	保留1位小数	`{3.14:.1f}` → 3.1
`:.2f`	保留2位小数	`{3.14:.2f}` → 3.14
`:10.2f`	总宽度10，保留2位小数	`{3.14:10.2f}` → " 3.14"
`:d`	整数	`{123:d}` → 123
`:s`	字符串	`{"abc":s}` → abc
`:0>5d`	宽度5，不足补0，右对齐	`{12:0>5d}` → 00012
`:0<5d`	宽度5，不足补0，左对齐	`{12:0<5d}` → 12000
`:^5d`	宽度5，居中对齐	`{12:^5d}` → " 12 "

12. range() 函数

range() 函数用于生成整数序列，常用于 for 循环中。

语法

range(stop)  # 生成 0 到 stop-1 的整数
range(start, stop)  # 生成 start 到 stop-1 的整数
range(start, stop, step)  # 生成指定步长的整数序列

代码示例

# 生成 0-4 的整数
for i in range(5):
    print(i)  # 输出: 0, 1, 2, 3, 4

# 生成 5-9 的整数
for i in range(5, 10):
    print(i)  # 输出: 5, 6, 7, 8, 9

# 生成 5-19 的奇数
for i in range(5, 20, 2):
    print(i)  # 输出: 5, 7, 9, 11, 13, 15, 17, 19

# 生成倒序序列
for i in range(10, 0, -1):
    print(i)  # 输出: 10, 9, 8, 7, 6, 5, 4, 3, 2, 1

# 将 range 转换为列表
numbers = list(range(10))
print(numbers)  # 输出: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

13. 文件操作

13.1 文件路径

文件路径用于定位文件在计算机中的位置，主要有两种类型：

相对路径

相对于当前工作目录的路径，不需要完整路径信息。

符号	含义	示例
`.`	当前目录	`./file.txt`
`..`	上级目录	`../file.txt`
`/`	目录分隔符	`./subdir/file.txt`

绝对路径

从根目录开始的完整路径，包含所有目录层级。

系统	示例
Windows	`C:\Users\username\Desktop\file.txt`
Linux/macOS	`/home/username/Desktop/file.txt`

13.2 读取文件

使用 open() 函数打开文件，返回一个文件对象。

open() 函数语法

open(file_path, mode='r', encoding=None)

参数	说明
`file_path`	文件路径（相对或绝对）
`mode`	文件打开模式（默认为只读 `'r'`）
`encoding`	文件编码（如 `'utf-8'`）

文件打开模式

模式	描述
`r`	只读模式（默认）
`w`	只写模式，覆盖原有内容，文件不存在则创建
`a`	追加模式，在文件末尾添加内容
`r+`	读写模式，从文件开头开始
`w+`	读写模式，覆盖原有内容
`a+`	读写模式，在文件末尾追加
`b`	二进制模式（如 `'rb'`、`'wb'`）

文件读取方法

方法	描述
`read()`	读取整个文件内容，返回字符串
`read(size)`	读取指定字节数，返回字符串
`readline()`	读取一行内容，返回字符串
`readlines()`	读取所有行，返回列表

代码示例

# 1. 基本读取
with open('./test.txt', 'r', encoding='utf-8') as f:
    content = f.read()
    print(content)

# 2. 逐行读取（适合大文件）
with open('./test.txt', 'r', encoding='utf-8') as f:
    line = f.readline()
    while line:
        print(line.strip())
        line = f.readline()

# 3. 读取所有行到列表
with open('./test.txt', 'r', encoding='utf-8') as f:
    lines = f.readlines()
    for line in lines:
        print(line.strip())

# 4. 读取指定字节数
with open('./test.txt', 'r', encoding='utf-8') as f:
    print(f.read(10))  # 读取前10个字符
    print(f.read(10))  # 继续读取接下来的10个字符

13.3 文件写入

基本写入

# 覆盖写入
with open('./test.txt', 'w', encoding='utf-8') as f:
    f.write('Hello, World!\n')
    f.write('这是第二行\n')

# 追加写入
with open('./test.txt', 'a', encoding='utf-8') as f:
    f.write('这是追加的一行\n')

# 写入多行
lines = ['第一行', '第二行', '第三行']
with open('./test.txt', 'w', encoding='utf-8') as f:
    f.writelines([line + '\n' for line in lines])

13.4 文件关闭

文件使用完毕后必须关闭，否则会占用系统资源。

两种关闭方式

# 1. 显式关闭
f = open('./test.txt', 'r')
try:
    content = f.read()
    print(content)
finally:
    f.close()  # 确保文件被关闭

# 2. 使用 with 语句（推荐）
with open('./test.txt', 'r') as f:
    content = f.read()
    print(content)
# with 语句会自动关闭文件，无需手动调用 close()

14. 异常处理

14.1 try-except 语句

用于捕获和处理程序运行时的异常。

基本语法

try:
    # 可能引发异常的代码
    result = 10 / 0
except ZeroDivisionError:
    # 处理特定异常
    print("除数不能为零")
except Exception as e:
    # 处理所有其他异常
    print(f"发生了异常: {e}")
else:
    # 没有异常时执行
    print("执行成功")
finally:
    # 无论是否有异常都会执行
    print("清理资源")

常见异常类型

异常类型	描述
`ZeroDivisionError`	除数为零
`ValueError`	值错误
`TypeError`	类型错误
`FileNotFoundError`	文件未找到
`IndexError`	索引越界
`KeyError`	字典键不存在

异常处理示例

try:
    user_weight = float(input("请输入您的体重(单位:kg): "))
    user_height = float(input("请输入您的身高(单位:m): "))
    if user_height <= 0:
        raise ValueError("身高必须大于零")
    bmi = user_weight / (user_height ** 2)
except ValueError as e:
    print(f"输入错误: {e}")
except Exception as e:   # 或者 except:
    print(f"发生了未知错误: {e}")
else:
    print(f"您的BMI指数是: {bmi:.2f}")
finally:
    print("程序执行完毕")

14.2 断言（assert）

断言用于检查程序中的条件是否为真，如果为假则引发 AssertionError。

语法

assert 条件, "错误消息"

代码示例

# 基本断言
assert len("hello") == 5, "字符串长度应为5"

# 断言在测试中的应用
def add(a, b):
    return a + b

# 测试add函数
assert add(1, 2) == 3, "1+2应该等于3"
assert add(-1, 1) == 0, "-1+1应该等于0"
assert add(0, 0) == 0, "0+0应该等于0"

print("所有断言通过！")

注意事项

断言主要用于开发和测试阶段
生产环境中可以通过 -O 选项关闭断言
断言失败会立即终止程序执行

15. 单元测试（unittest）

15.1 什么是单元测试

单元测试是对程序中最小可测试单元（如函数、方法）进行的测试。

15.2 使用 unittest 框架

测试用例结构

import unittest

class TestClassName(unittest.TestCase):
    """测试类"""

    def setUp(self):
        """每个测试方法执行前调用"""
        pass

    def tearDown(self):
        """每个测试方法执行后调用"""
        pass

    def test_method_name(self):
        """测试方法，必须以test_开头"""
        # 断言语句
        self.assertEqual(1 + 2, 3)

常用断言方法

断言方法	描述
`assertEqual(a, b)`	验证 a == b
`assertNotEqual(a, b)`	验证 a != b
`assertTrue(x)`	验证 x 为 True
`assertFalse(x)`	验证 x 为 False
`assertAlmostEqual(a, b)`	验证浮点数近似相等
`assertRaises(exception, callable, args, *kwds)`	验证调用可调用对象会引发指定异常
`assertIn(item, container)`	验证 item 在 container 中
`assertNotIn(item, container)`	验证 item 不在 container 中

完整测试示例

# calculator.py
class Calculator:
    def add(self, a, b):
        return a + b

    def subtract(self, a, b):
        return a - b

    def multiply(self, a, b):
        return a * b

    def divide(self, a, b):
        if b == 0:
            raise ValueError("除数不能为零")
        return a / b

# test_calculator.py
import unittest
from calculator import Calculator

class TestCalculator(unittest.TestCase):
    """测试计算器类"""

    def setUp(self):
        """测试前的准备工作"""
        self.calc = Calculator()
        print("\n开始测试...")

    def tearDown(self):
        """测试后的清理工作"""
        print("测试结束...")

    def test_add(self):
        """测试加法功能"""
        self.assertEqual(self.calc.add(1, 2), 3)
        self.assertEqual(self.calc.add(-1, 1), 0)
        self.assertEqual(self.calc.add(0, 0), 0)
        self.assertAlmostEqual(self.calc.add(1.5, 2.5), 4.0)

    def test_subtract(self):
        """测试减法功能"""
        self.assertEqual(self.calc.subtract(5, 3), 2)
        self.assertEqual(self.calc.subtract(3, 5), -2)

    def test_multiply(self):
        """测试乘法功能"""
        self.assertEqual(self.calc.multiply(2, 3), 6)
        self.assertEqual(self.calc.multiply(-2, 3), -6)

    def test_divide(self):
        """测试除法功能"""
        self.assertEqual(self.calc.divide(6, 3), 2)
        self.assertEqual(self.calc.divide(5, 2), 2.5)

        # 测试除数为零的情况
        with self.assertRaises(ValueError):
            self.calc.divide(5, 0)

if __name__ == "__main__":
    unittest.main()

运行测试用例

# 方法1：直接运行测试文件
python test_calculator.py

# 方法2：使用unittest模块运行
python -m unittest test_calculator.py

# 方法3：运行所有测试文件
python -m unittest discover

# 方法4：运行特定测试类
python -m unittest test_calculator.TestCalculator

# 方法5：运行特定测试方法
python -m unittest test_calculator.TestCalculator.test_add

15.3 测试最佳实践

每个测试方法只测试一个功能
测试方法名应清晰描述测试内容
使用 setUp 和 tearDown 方法管理测试资源
测试覆盖正常情况和边界情况
测试应该是独立的，不依赖于其他测试

16. 高阶函数和匿名函数

16.1 高阶函数

高阶函数是指可以接受函数作为参数，或者返回函数的函数。

常见高阶函数

函数	描述
`map(function, iterable)`	对可迭代对象的每个元素应用函数
`filter(function, iterable)`	过滤可迭代对象，返回符合条件的元素
`reduce(function, iterable)`	对可迭代对象进行累积操作
`sorted(iterable, key=None, reverse=False)`	排序，可接受函数作为key

代码示例

# map 示例：将列表中的每个元素平方
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # 输出: [1, 4, 9, 16, 25]

# filter 示例：筛选出偶数
numbers = [1, 2, 3, 4, 5, 6]
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # 输出: [2, 4, 6]

# sorted 示例：按字符串长度排序
words = ["apple", "banana", "cherry", "date"]
sorted_words = sorted(words, key=len)
print(sorted_words)  # 输出: ["date", "apple", "cherry", "banana"]

# 自定义高阶函数
def apply_function(func, x):
    """将函数应用于x"""
    return func(x)

def square(x):
    """计算平方"""
    return x ** 2

result = apply_function(square, 5)
print(result)  # 输出: 25

16.2 匿名函数

匿名函数是指没有名字的函数，使用 lambda 关键字定义。

语法

lambda 参数: 表达式

代码示例

# 基本使用
square = lambda x: x ** 2
print(square(3))  # 输出: 9

# 作为高阶函数的参数
doubled = list(map(lambda x: x * 2, [1, 2, 3]))
print(doubled)  # 输出: [2, 4, 6]

# 多个参数
add = lambda x, y: x + y
print(add(3, 5))  # 输出: 8

# 与条件表达式结合
even_or_odd = lambda x: "偶数" if x % 2 == 0 else "奇数"
print(even_or_odd(4))  # 输出: 偶数
print(even_or_odd(5))  # 输出: 奇数

注意事项

匿名函数只能包含一个表达式
表达式的结果就是函数的返回值
适合简单的、一次性使用的函数
复杂逻辑建议使用普通函数

17. 装饰器

17.1 什么是装饰器

装饰器是一种特殊的高阶函数，用于修改其他函数的功能，而不改变其代码。

17.2 装饰器的基本使用

简单装饰器示例

# 定义装饰器
def my_decorator(func):
    def wrapper():
        print("装饰器开始执行")
        func()
        print("装饰器结束执行")
    return wrapper

# 使用装饰器
@my_decorator
def say_hello():
    print("Hello, World!")

# 调用函数
say_hello()

带参数的装饰器

# 带参数的装饰器
def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("装饰器开始执行")
        result = func(*args, **kwargs)
        print("装饰器结束执行")
        return result
    return wrapper

@my_decorator
def add(a, b):
    return a + b

result = add(3, 5)
print(f"结果: {result}")

装饰器的应用场景

日志记录
性能测试
权限验证
缓存
事务处理

总结

本指南涵盖了 Python 编程的核心知识点，包括：

基础数据类型：整数、字符串、浮点数、布尔值、空值等
数据结构：列表、元组、字典等
控制流：条件判断（if-elif-else）、循环结构（for、while）
函数：定义与调用、参数传递、作用域、闭包
面向对象编程：类定义、属性与方法、继承、多态
文件操作：路径、读取、写入、关闭
异常处理：try-except-else-finally、断言
单元测试：unittest框架的使用
高级特性：高阶函数、匿名函数、装饰器

学习 Python 最好的方法是多写代码，多实践。

学习建议

基础先行：先掌握基础语法和核心概念
多写代码：理论结合实践，编写小项目
阅读源码：学习优秀的开源项目
参与社区：加入 Python 社区，向他人学习
持续学习：Python 生态不断发展，保持学习习惯

祝您学习愉快！

python学习

Python 学习指南

1. Python 基础类型

代码示例

2. 列表（List）

列表操作方法

切片操作

列表操作示例

3. 元组（Tuple）

元组特点

代码示例

4. 字典（Dictionary）

字典操作方法

代码示例

5. 条件判断（if）

语法结构

代码示例

6. 循环结构

6.1 for 循环

语法结构

代码示例

6.2 while 循环

语法结构

代码示例

7. 函数定义与调用

函数语法

函数特点

代码示例

8. 面向对象编程

类的基本概念

类的语法

代码示例

8.1 类继承

继承语法

继承特点

代码示例

9. 数学计算（Math 模块）

常用数学函数

常量

代码示例

10. 输入输出（Input/Output）

输入函数（input）

输出函数（print）

类型转换

代码示例

11. 字符串格式化

1. f-strings（Python 3.6+）

2. format() 方法

3. 百分号（%）格式化

代码示例

数字格式化说明符

12. range() 函数

语法

代码示例

13. 文件操作

13.1 文件路径

相对路径

绝对路径

13.2 读取文件

open() 函数语法

文件打开模式

文件读取方法

代码示例

13.3 文件写入

基本写入

13.4 文件关闭

两种关闭方式

14. 异常处理

14.1 try-except 语句

基本语法

常见异常类型

异常处理示例

14.2 断言（assert）

语法

代码示例

注意事项

15. 单元测试（unittest）

15.1 什么是单元测试

15.2 使用 unittest 框架

测试用例结构