Python 快速入门指南

1. 语言基础

1.1 数据类型与变量

Python 是一门动态类型语言，这意味着你不需要显式声明变量的类型。Python 解释器会根据你赋予变量的值自动推断其类型。这使得 Python 代码简洁易懂，但同时也需要注意一些潜在的问题。

1.1.1 Python 数据类型概述

Python 提供了多种内置数据类型，以下是一些常见的类型：

1.1.2 变量声明与赋值

在 Python 中，使用 = 符号来给变量赋值。

name = "Alice" 
age = 25 
is_student = True

需要注意的是，变量名必须以字母或下划线开头，后面可以跟字母、数字或下划线。同时，Python 变量名区分大小写。

1.1.3 类型转换

有时我们需要将不同数据类型之间进行转换，Python 提供了一些内置函数来实现类型转换：

例如：

number = "10" 
int_number = int(number)  # 将字符串转换为整型

1.2 运算符与表达式

运算符是用来对操作数执行特定操作的符号，表达式则是由操作数和运算符组合而成的计算公式。

1.2.1 算术运算符

算术运算符用于进行数值计算，包括：

1.2.2 比较运算符

比较运算符用于比较两个操作数的大小或是否相等，结果为布尔值（True 或 False）。

1.2.3 逻辑运算符

逻辑运算符用于对布尔值进行操作，包括：

1.2.4 位运算符

位运算符用于对操作数的二进制位进行操作，包括：

1.2.5 赋值运算符

赋值运算符用于将值赋给变量，包括：

1.2.6 运算符优先级

在表达式中，不同的运算符具有不同的优先级。优先级高的运算符先执行，优先级低的运算符后执行。可以使用括号 () 来改变运算顺序，括号内的表达式优先执行。

以下列出了一些常用运算符的优先级，从高到低排序：

1. 幂运算 **
2. 按位取反 ~
3. 乘法、除法、整数除法、取余 *, /, //, %
4. 加法、减法 +, -
5. 位运算 <<, >>, &, ^, |
6. 比较运算符 ==, !=, >, <, >=, <=
7. 逻辑运算符 not, and, or
8. 赋值运算符 =, +=, -=, *=, /=, //= 等等

1.2.7 表达式

表达式是由操作数和运算符组合而成的计算公式， Python 解释器会根据运算符的优先级和结合性来计算表达式的值。

例如：

1.3 控制流语句

控制流语句允许我们控制程序执行的流程，改变程序的执行顺序。它们使程序能够根据条件做出决策，重复执行代码块，以及在需要时跳出循环。

1.3.1 条件语句 (if-elif-else)

条件语句根据条件判断，选择执行不同的代码块。

语法:

if 条件1:
    代码块1
elif 条件2:
    代码块2
else:
    代码块3

示例:

score = int(input("请输入分数："))

if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 70:
    print("中等")
else:
    print("不及格")

1.3.2 循环语句 (for, while)

循环语句用于重复执行一段代码，直到满足特定条件为止。

for 循环

for 循环用于遍历序列 (例如列表、元组、字符串) 中的每个元素。

语法:

for 变量 in 序列:
    代码块

示例:

names = ["Alice", "Bob", "Charlie"]

for name in names:
    print("Hello, " + name)

while 循环

while 循环会一直执行代码块，直到条件变为假。

语法:

while 条件:
    代码块

示例:

count = 0

while count < 5:
    print(count)
    count += 1

1.3.3 循环控制语句 (break, continue)

循环控制语句用于在循环中改变执行流程。

break 语句

break 语句用于立即退出循环。

示例:

for i in range(10):
    if i == 5:
        break
    print(i)

continue 语句

continue 语句用于跳过当前迭代，继续执行下一轮循环。

示例:

for i in range(10):
    if i % 2 == 0:
        continue
    print(i)

1.4 函数

函数是 Python 代码的模块化单元，它可以接受输入参数，执行一系列操作，并返回结果。函数可以提高代码的可重用性和可读性，使程序更加模块化和易于维护。

1.4.1 函数定义与调用

函数定义:

def 函数名(参数列表):
    """函数文档字符串"""
    代码块
    return 返回值

函数调用:

函数名(参数列表)

示例:

def greet(name):
    """向用户问好"""
    print("Hello, " + name + "!")

greet("Alice") # 调用 greet 函数，传递参数 "Alice"

1.4.2 函数参数与返回值

参数:

返回值:

示例:

def calculate_sum(a, b=10): # b 为默认参数，默认值为 10
    """计算两个数的和"""
    return a + b

result = calculate_sum(5) # 调用函数，传递一个参数，使用 b 的默认值
print(result) # 输出 15

result = calculate_sum(5, 20) # 调用函数，传递两个参数，覆盖 b 的默认值
print(result) # 输出 25

def sum_all(*args): # 使用 *args 接收任意数量的位置参数
    """计算所有参数的和"""
    total = 0
    for arg in args:
        total += arg
    return total

result = sum_all(1, 2, 3, 4, 5) # 传递多个参数
print(result) # 输出 15

1.4.3 递归函数

递归函数是指在函数内部调用自身的函数。

示例:

def factorial(n):
    """计算 n 的阶乘"""
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

result = factorial(5)
print(result) # 输出 120

注意: 递归函数必须有一个终止条件，否则会无限递归下去导致程序崩溃。

1.4.4 匿名函数 (lambda)

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

语法:

lambda 参数列表: 表达式

示例:

square = lambda x: x * x
print(square(5)) # 输出 25

add = lambda x, y: x + y
print(add(10, 20)) # 输出 30

注意: 匿名函数通常用于简化代码，尤其是在需要使用函数作为参数或返回值的情况下。

2. 数据结构

数据结构是组织和存储数据的特定方式，在编程中扮演着至关重要的角色。Python 提供了多种内置数据结构，让我们可以方便地管理数据。

2.1 列表 (List)

列表是一种有序的可变数据结构，可以存储不同类型的元素。

2.1.1 列表创建与访问

my_list = [1, 2, 3, "hello", True]

print(my_list[0])  # 输出: 1
print(my_list[3])  # 输出: hello

print(my_list[-1]) # 输出: True
print(my_list[-3]) # 输出: 3

2.1.2 列表操作 (添加、删除、修改)

my_list.append(4)
my_list.insert(1, "world")
my_list.extend([5, 6])
print(my_list) # 输出: [1, 'world', 2, 3, 'hello', True, 4, 5, 6]

my_list.remove("hello")
removed_item = my_list.pop(2)
del my_list[0:2]
print(my_list) # 输出: [3, True, 4, 5, 6]

my_list[0] = "new_value"
print(my_list) # 输出: ['new_value', True, 4, 5, 6]

2.1.3 列表遍历

for item in my_list:
    print(item)

for i in range(len(my_list)):
    print(my_list[i])

2.2 元组 (Tuple)

元组是一种有序的不可变数据结构，使用圆括号 () 包含元素。

2.2.1 元组创建与访问

my_tuple = (1, 2, "hello", True)

print(my_tuple[0])  # 输出: 1
print(my_tuple[2])  # 输出: hello

print(my_tuple[-1]) # 输出: True
print(my_tuple[-3]) # 输出: 2

2.2.2 元组不可变性

元组是不可变的，这意味着一旦创建，就不能修改其元素。

my_tuple[0] = "new_value" # 会导致错误

2.2.3 元组与列表的区别

2.3 字典 (Dictionary)

字典是一种无序的键值对集合，使用花括号 {} 包含键值对，键和值之间用冒号 : 分隔，键值对之间用逗号 , 分隔。

2.3.1 字典创建与访问

my_dict = {"name": "John", "age": 30, "city": "New York"}

print(my_dict["name"])  # 输出: John
print(my_dict["age"])  # 输出: 30

print(my_dict["hobby"])  # 抛出 KeyError

print(my_dict.get("hobby"))  # 输出: None
print(my_dict.get("hobby", "unknown"))  # 输出: unknown

2.3.2 字典操作 (添加、删除、修改)

my_dict["hobby"] = "reading"
print(my_dict)  # 输出: {'name': 'John', 'age': 30, 'city': 'New York', 'hobby': 'reading'}

del my_dict["city"]
print(my_dict)  # 输出: {'name': 'John', 'age': 30, 'hobby': 'reading'}

city = my_dict.pop("hobby")
print(my_dict)  # 输出: {'name': 'John', 'age': 30}
print(city)  # 输出: reading

my_dict["age"] = 31
print(my_dict)  # 输出: {'name': 'John', 'age': 31, 'hobby': 'reading'}

2.3.3 字典遍历

for key in my_dict.keys():
    print(key)  # 输出: name, age, hobby

for value in my_dict.values():
    print(value)  # 输出: John, 31, reading

for key, value in my_dict.items():
    print(f"{key}: {value}")  # 输出: name: John, age: 31, hobby: reading

2.4 集合 (Set)

集合是一种无序的、不可重复的元素集合，使用花括号 {} 包含元素，元素之间用逗号 , 分隔。

2.4.1 集合创建与访问

my_set = {1, 2, 3, 4}
empty_set = set()

print(1 in my_set)  # 输出: True
print(5 in my_set)  # 输出: False

2.4.2 集合操作 (交集、并集、差集)

set1 = {1, 2, 3}
set2 = {2, 3, 4}
intersection_set = set1 & set2
print(intersection_set)  # 输出: {2, 3}

union_set = set1 | set2
print(union_set)  # 输出: {1, 2, 3, 4}

difference_set = set1 - set2
print(difference_set)  # 输出: {1}

2.4.3 集合的不可重复性

集合中的元素是唯一的，不允许重复。

my_set = {1, 2, 2, 3}
print(my_set)  # 输出: {1, 2, 3}

3. 面向对象编程

面向对象编程 (OOP) 是一种编程范式，它将程序视为一组相互作用的对象，每个对象都包含数据和操作这些数据的函数。OOP 帮助组织和管理大型程序，使其更容易维护和扩展。

3.1 类与对象

3.1.1 类定义

class Dog:
  # 类体

3.1.2 对象创建

my_dog = Dog()

3.1.3 属性与方法

class Dog:
  def __init__(self, name, breed):
    self.name = name
    self.breed = breed

  def bark(self):
    print(f"{self.name} barks!")

3.1.3 实例化和调用类的方法

class Dog:
  def __init__(self, name, breed):
    self.name = name
    self.breed = breed

  def bark(self):
    print(f"{self.name} barks!")

my_dog = Dog("Buddy", "Golden Retriever")
print(f"My dog's name is {my_dog.name} and it's a {my_dog.breed}.")
my_dog.bark()

3.2 封装

封装是面向对象编程中的一个重要概念，它将数据和操作数据的方法捆绑在一起，形成一个独立的、自包含的单元，即对象。封装的目标是隐藏对象的内部实现细节，只对外暴露必要的接口，以控制对对象的访问。

3.2.1 类

类是封装的核心概念，它定义了对象的属性和方法。属性表示对象的特征，方法表示对象的行为。

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    def bark(self):
        print("Woof!")

my_dog = Dog("Buddy", "Golden Retriever")
print(my_dog.name)  # 输出：Buddy
my_dog.bark()      # 输出：Woof!

3.2.2 私有属性和方法

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.__breed = breed  # 私有属性

    def bark(self):
        print("Woof!")

    def __private_method(self):  # 私有方法
        print("This is a private method.")

my_dog = Dog("Buddy", "Golden Retriever")
print(my_dog.name)  # 可以访问公有属性
# print(my_dog.__breed)  # AttributeError: private access
my_dog.bark()  # 可以调用公有方法
# my_dog.__private_method()  # AttributeError: private access

注意： 虽然 Python 的私有机制是通过名称改写来实现的，仍然可以通过一些技巧来访问私有属性和方法。例如，使用 _ClassName__attribute_name 或者 _ClassName__method_name 可以访问私有属性和方法。

# 通过名称改写访问私有属性
print(my_dog._Dog__breed)  # 输出：Golden Retriever

# 通过名称改写访问私有方法
my_dog._Dog__private_method()  # 输出：This is a private method.

3.2.3 属性装饰器

class Dog:
    def __init__(self, name, breed):
        self._name = name
        self._breed = breed

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, value):
        self._name = value

    @name.deleter
    def name(self):
        del self._name

my_dog = Dog("Buddy", "Golden Retriever")
print(my_dog.name) # 输出：Buddy
my_dog.name = "Max"
print(my_dog.name) # 输出：Max
del my_dog.name
# print(my_dog.name)  # AttributeError: 'Dog' object has no attribute 'name'

3.2.4 模块和包

# 模块
# my_module.py
def greet(name):
    print(f"Hello, {name}!")

# 使用模块
import my_module
my_module.greet("Alice")

# 包
# package/__init__.py
# package/module1.py
# package/module2.py
# ...

# 使用包
from package import module1
module1.some_function()

模块和包可以有效地隐藏内部实现细节，提高代码可读性和可维护性。

3.3 继承

继承是面向对象编程中重要的概念之一，它允许创建一个新的类（子类）继承另一个类的属性和方法（父类），从而实现代码复用和扩展。

3.3.1 单继承

单继承是指一个子类只继承一个父类。使用 class 子类名(父类名): 语法实现单继承。

class Animal:
    """
    定义一个动物类
    """

    def __init__(self, name):
        self.name = name

    def speak(self):
        print("Animal sound")

class Dog(Animal):
    """
    定义一个狗类，继承自 Animal 类
    """

    def speak(self):
        print("Woof!")

my_dog = Dog("Buddy")
my_dog.speak()  # 输出 "Woof!"

在 Dog 类中，我们使用 Animal 作为父类进行继承。子类 Dog 可以访问父类 Animal 中的属性和方法。需要注意的是，子类 Dog 重写了父类的 speak 方法，实现了特定于狗的行为。

3.3.2 多继承

多继承是指一个子类可以继承多个父类。使用 class 子类名(父类1, 父类2, ...): 语法实现多继承。

class Flyer:
    """
    定义一个飞行类
    """

    def fly(self):
        print("Flying...")

class Swimmer:
    """
    定义一个游泳类
    """

    def swim(self):
        print("Swimming...")

class Duck(Flyer, Swimmer):
    """
    定义一个鸭子类，继承自 Flyer 和 Swimmer 类
    """

    def quack(self):
        print("Quack!")

my_duck = Duck()
my_duck.fly()  # 输出 "Flying..."
my_duck.swim()  # 输出 "Swimming..."
my_duck.quack()  # 输出 "Quack!"

在 Duck 类中，我们继承了 Flyer 和 Swimmer 类。Duck 类可以访问这两个父类的属性和方法。多继承可以实现更加复杂的类关系，但需要注意的是，多继承可能会导致一些复杂的问题，例如方法名冲突和菱形继承问题。

注意:

3.4 多态

多态是面向对象编程中的一个重要概念，它指的是同一个操作在不同的对象上表现出不同的行为。这使得代码更加灵活、可扩展和易于维护。

3.4.1 方法重写

方法重写是实现多态的一种方式。子类可以重写父类的方法，实现特定于子类的行为。

示例:

class Animal:
    def speak(self):
        print("Animal sound")

class Dog(Animal):
    def speak(self):
        print("Woof!")

class Cat(Animal):
    def speak(self):
        print("Meow!")

animals = [Dog(), Cat(), Animal()]
for animal in animals:
    animal.speak()  # 输出 "Woof!", "Meow!", "Animal sound"

在上面的例子中，Dog 和 Cat 类都重写了 Animal 类的 speak 方法，实现了各自不同的声音。通过循环遍历 animals 列表，调用每个对象的 speak 方法，我们可以看到不同的对象表现出不同的行为。

方法重写的规则:

3.4.2 多态的应用场景

多态在面向对象编程中有着广泛的应用场景，例如:

示例:

假设我们要开发一个游戏，其中包含不同的角色，例如战士、法师和弓箭手。我们可以使用多态来实现角色的行为，例如攻击、防御和技能。

class Character:
    def attack(self):
        print("General attack")

class Warrior(Character):
    def attack(self):
        print("Warrior attack with sword")

class Mage(Character):
    def attack(self):
        print("Mage attack with magic")

characters = [Warrior(), Mage(), Character()]
for character in characters:
    character.attack()  # 输出 "Warrior attack with sword", "Mage attack with magic", "General attack"

通过多态，我们可以用统一的方式处理不同角色的攻击行为，而无需关心角色的具体类型。

4. 常用模块

模块是 Python 代码的组织单元，它可以包含函数、类、变量等。使用模块可以提高代码的可重用性和可维护性。

4.1 模块导入

在 Python 中，可以使用 import 语句导入模块。

4.1 导入整个模块

import math

print(math.pi)
print(math.sqrt(25))

这将导入 math 模块，并使用 math.pi 和 math.sqrt() 访问模块中的常量和函数。

4.2 导入特定属性

from math import pi, sqrt

print(pi)
print(sqrt(25))

这将只导入 math 模块中的 pi 和 sqrt 属性，并直接使用它们。

4.3 导入模块并指定别名

import math as m

print(m.pi)
print(m.sqrt(25))

这将导入 math 模块并将其指定为 m，可以使用 m.pi 和 m.sqrt() 访问模块中的属性。

4.4 导入所有属性

from math import *

print(pi)
print(sqrt(25))

这将导入 math 模块中的所有属性，但建议不要使用这种方式，因为它会导致命名冲突。

4.5 模块搜索路径

Python 在导入模块时会搜索以下路径：

4.2 常用模块介绍

以下是几个 Python 中常用的模块的介绍：

4.2.1 math 模块

math 模块提供了大量的数学函数和常量，可以帮助我们进行各种数学运算。

常用函数：

示例：

import math

print(math.pi)  # 输出圆周率
print(math.sqrt(25))  # 输出 5
print(math.pow(2, 3))  # 输出 8
print(math.sin(math.pi / 2))  # 输出 1
print(math.ceil(3.14))  # 输出 4
print(math.floor(3.14))  # 输出 3

4.2.2 random 模块

random 模块提供了生成随机数的功能，可以用于各种场景，例如模拟随机事件、洗牌等。

常用函数：

示例：

import random

print(random.random())  # 输出 0 到 1 之间的随机浮点数
print(random.randint(1, 10))  # 输出 1 到 10 之间的随机整数
print(random.choice(["apple", "banana", "orange"]))  # 输出 "apple", "banana" 或 "orange" 之一
numbers = [1, 2, 3, 4, 5]
random.shuffle(numbers)  # 打乱 numbers 列表的元素顺序
print(numbers)
print(random.sample(numbers, 2))  # 从 numbers 列表中随机抽取 2 个元素

4.2.3 os 模块

os 模块提供了与操作系统交互的功能，可以用来执行操作系统命令、操作文件和目录等。

常用函数：

示例：

import os

print(os.getcwd())  # 输出当前工作目录
os.chdir("/tmp")  # 改变工作目录到 /tmp
print(os.listdir("/tmp"))  # 列出 /tmp 目录下的所有文件和子目录
os.mkdir("/tmp/mydir")  # 创建目录 /tmp/mydir
os.remove("/tmp/mydir/myfile.txt")  # 删除文件 /tmp/mydir/myfile.txt
os.rename("/tmp/mydir", "/tmp/mynewdir")  # 重命名目录 /tmp/mydir 为 /tmp/mynewdir
os.system("ls -l")  # 执行 ls -l 命令
print(os.environ["HOME"])  # 输出环境变量 HOME 的值

4.2.4 datetime 模块

datetime 模块提供了与日期和时间相关的功能，可以用来创建、格式化、计算日期和时间等。

常用类：

常用方法：

示例：

import datetime

now = datetime.datetime.now()  # 获取当前日期和时间
print(now)
print(now.strftime("%Y-%m-%d %H:%M:%S"))  # 格式化日期和时间
birthday = datetime.date(1990, 1, 1)  # 创建日期对象
print(birthday)
date_str = "2023-04-01"
date = datetime.datetime.strptime(date_str, "%Y-%m-%d").date()  # 解析日期字符串
print(date)

4.2.5 requests 模块

requests 模块提供了与网络请求相关的功能，可以用来发送 HTTP 请求、获取网页内容等。

常用方法：

示例：

import requests

response = requests.get("https://www.google.com")  # 发送 GET 请求
print(response.status_code)  # 输出响应状态码
print(response.text)  # 输出响应内容的文本格式
response = requests.post("https://www.example.com/api/login", data={"username": "user", "password": "password"})  # 发送 POST 请求
print(response.json())  # 输出响应内容的 JSON 格式

注意： requests 模块不是 Python 的内置模块，需要使用 pip 安装。

pip install requests

这些只是 Python 中常用的模块的一部分，还有很多其他的模块可以满足各种需求，请参考官方文档或其他学习资源进行更深入的了解。

5. 常见错误与调试

程序员在编写代码时不可避免地会遇到各种错误。了解常见的错误类型、掌握错误处理机制以及调试技巧是编写高质量代码的关键。

5.1 常见错误类型

Python 中常见的错误类型包括：

5.1.1 语法错误 (SyntaxError)

5.1.2 运行时错误 (RuntimeError)

5.1.3 逻辑错误 (Logical Error)

5.1.4 常见的运行时错误类型

print("Hello" + 10)  
# TypeError: can only concatenate str (not "int") to str

int("abc")  
# ValueError: invalid literal for int() with base 10: 'abc'

print(my_variable)  
# NameError: name 'my_variable' is not defined

my_list = [1, 2, 3]
print(my_list[3])  
# IndexError: list index out of range

my_dict = {"name": "John"}
print(my_dict["age"])  # KeyError: 'age'

my_str = "Hello"
print(my_str.length)  
# AttributeError: 'str' object has no attribute 'length'

with open("nonexistent_file.txt", "r") as f:  
# IOError: [Errno 2] No such file or directory: 'nonexistent_file.txt'
    content = f.read()

注意：

通过理解常见的运行时错误类型，可以更有效地编写和调试代码，并确保程序的稳定性和可靠性。

5.2 错误处理机制 (try-except)

try-except 语句是 Python 中强大的错误处理机制，它允许你在程序执行过程中捕获并处理异常。

5.2.1 语法

try:
    # 可能引发错误的代码
except 错误类型1:
    # 处理错误类型1的代码
except 错误类型2:
    # 处理错误类型2的代码
    ...
else:
    # 如果没有错误，执行此代码块
finally:
    # 无论是否发生错误，都会执行此代码块

5.2.2 捕获不同错误类型

try:
    num1 = int(input("请输入第一个数: "))
    num2 = int(input("请输入第二个数: "))
    result = num1 / num2
    print(f"{num1} 除以 {num2} 等于 {result}")
except ZeroDivisionError:
    print("除数不能为零！")
except ValueError:
    print("请输入有效的整数！")
else:
    print("计算成功！")
finally:
    print("程序结束！")

解释:

5.2.3 捕获所有错误和错误信息

除了捕获特定类型的错误，还可以使用 Exception 来捕获所有类型的错误。

语法:

try:
    # 可能引发错误的代码
except Exception as e:
    # 处理错误
    print(f"发生错误: {e}")

示例:

try:
    num1 = int(input("请输入第一个数: "))
    num2 = int(input("请输入第二个数: "))
    result = num1 / num2
    print(f"计算结果: {result}")
except Exception as e:
    print(f"发生错误: {e}")
finally:
    print("程序结束")

解释:

1. 如果输入的两个数都是数字，且除数不为零，程序会正常计算并输出结果。
2. 如果输入的除数为零，程序会输出 “发生错误: division by zero”。
3. 如果输入的不是数字，程序会输出 "发生错误: invalid literal for int() with base 10: ‘…’ " (其中 “…” 是用户输入的非数字字符)。
4. 无论程序是否出错，都会输出 “程序结束”。

其他需要注意的点:

示例:

try:
    # 可能引发错误的代码
except Exception as e:
    print(f"发生错误类型: {e.__class__.__name__}")
    print(f"错误信息: {e}")

5.3 调试技巧

调试是程序员必备技能之一，用于发现并解决代码中的错误。常见的调试技巧包括：

5.3.1 打印调试信息 (print)

在代码中插入 print 语句，打印变量的值或执行流程，帮助定位错误。

def calculate(a, b):
    print(f"a: {a}, b: {b}")
    result = a + b
    print(f"result: {result}")
    return result

calculate(5, 10)

5.3.2 使用调试器 (debugger)

Python 内置的调试器 pdb 可以逐步执行代码，查看变量的值和执行流程。

import pdb

def calculate(a, b):
    pdb.set_trace()  # 设置断点
    result = a + b
    return result

calculate(5, 10)

5.3.3 使用日志 (logging)

将错误信息记录到日志文件中，便于分析和排查问题。

import logging

logging.basicConfig(filename='app.log', level=logging.DEBUG)

def calculate(a, b):
    logging.debug(f"a: {a}, b: {b}")
    result = a + b
    logging.debug(f"result: {result}")
    return result

calculate(5, 10)

5.3.4 使用断言 (assert)

在代码中插入断言，用于验证程序逻辑，一旦断言失败，程序会抛出异常。

def calculate(a, b):
    assert a > 0, "a 必须大于 0"
    result = a + b
    return result

calculate(5, 10)

作者：大邳草民