糖果怪物
59.65M · 2026-03-05
1. Python概述
2. Python开发环境搭建
3. Python基础语法
4. 数据类型与变量
5. 控制流语句
6. 函数
7. 面向对象编程
8. 模块与包
9. 文件操作
10. 异常处理
11. 常用标准库
12. 高级特性
13. 性能优化
14. 调试与测试
15. 学习资源推荐
Python是一种解释型、面向对象、动态数据类型的高级程序设计语言。它由Guido van Rossum于1989年圣诞节期间创建，并在1991年首次公开发行。Python的设计哲学强调代码的可读性和简洁性，具有丰富和强大的库，常被昵称为“胶水语言”，能够把其他语言制作的各种模块（尤其是C/C++）很轻松地联结在一起。
python3 --version检查版本，如需安装最新版本，可以使用包管理器（如apt、yum等）。安装完成后，可以通过以下命令验证Python是否安装成功：
# 在命令行中执行
python --version # Python 2.x版本
python3 --version # Python 3.x版本
IDLE是Python自带的集成开发环境，简单易用，适合初学者使用。
PyCharm是JetBrains公司开发的Python集成开发环境，具有强大的功能，如代码补全、语法高亮、调试、版本控制等。PyCharm分为社区版（免费）和专业版（付费）。
VS Code是Microsoft开发的轻量级代码编辑器，可以通过安装Python扩展支持Python开发。
Jupyter Notebook是一个交互式计算环境，可以创建包含代码、文本、图像等的文档，适合数据科学和机器学习开发。
使用IDLE创建并运行第一个Python程序：
print("Hello, World!")
Hello, World!Python中的注释使用#符号，从#开始到行尾的内容都是注释。
# 这是单行注释
print("Hello, World!") # 这也是注释，在代码后面
"""
这是多行注释
可以写多行内容
"""
Python使用缩进来表示代码块，而不是使用大括号。缩进的空格数可以由开发者决定，但同一个代码块中的缩进必须一致。
if 5 > 2:
print("Five is greater than two!") # 正确的缩进
print("This is also inside the if block")
if 5 > 2:
print("Five is greater than two!") # 错误：没有缩进
total = item_one +
item_two +
item_three
total = (item_one +
item_two +
item_three)
Python中，分号;可以用于在同一行中分隔多个语句。
print("Hello"); print("World")
Python中的标识符是用于命名变量、函数、类、模块等的名称。标识符的命名规则如下：
myVar和myvar是不同的标识符。my_variable。Python中的关键字是具有特殊含义的保留字，不能作为标识符使用。以下是Python 3.8的关键字：
False await else import pass
None break except in raise
True class finally is return
and continue for lambda try
as def from nonlocal while
assert del global not with
async elif if or yield
在Python中，变量不需要声明类型，直接赋值即可创建变量。
x = 5 # 创建一个整数变量x，赋值为5
y = "Hello" # 创建一个字符串变量y，赋值为"Hello"
Python中的数据类型可以分为以下几类：
5、-3、0。3.14、-0.5。True和False两个值。3+4j。# 整数
x = 10
print(type(x)) # <class 'int'>
# 浮点数
y = 3.14
print(type(y)) # <class 'float'>
# 布尔值
z = True
print(type(z)) # <class 'bool'>
# 复数
w = 3 + 4j
print(type(w)) # <class 'complex'>
"Hello"、'World'。[1, 2, 3]。(1, 2, 3)。# 字符串
s = "Hello, World!"
print(type(s)) # <class 'str'>
# 列表
l = [1, 2, 3, "apple", "banana"]
print(type(l)) # <class 'list'>
# 元组
t = (1, 2, 3, "apple", "banana")
print(type(t)) # <class 'tuple'>
{1, 2, 3}。frozenset()函数创建，如frozenset({1, 2, 3})。# 集合
s = {1, 2, 3, 3, 4}
print(s) # {1, 2, 3, 4}（自动去重）
print(type(s)) # <class 'set'>
# 冻结集合
fs = frozenset({1, 2, 3})
print(type(fs)) # <class 'frozenset'>
{"name": "Alice", "age": 25}。# 字典
d = {"name": "Alice", "age": 25, "city": "New York"}
print(type(d)) # <class 'dict'>
Python提供了多种类型转换函数，可以将一种数据类型转换为另一种数据类型。
# 转换为整数
x = int(3.14) # 3
print(x)
# 转换为浮点数
y = float(5) # 5.0
print(y)
# 转换为字符串
z = str(123) # "123"
print(z)
# 转换为列表
l = list("Hello") # ['H', 'e', 'l', 'l', 'o']
print(l)
# 转换为元组
t = tuple([1, 2, 3]) # (1, 2, 3)
print(t)
# 转换为集合
s = set([1, 2, 3, 3]) # {1, 2, 3}
print(s)
# 转换为字典
d = dict([("name", "Alice"), ("age", 25)]) # {"name": "Alice", "age": 25}
print(d)
条件语句用于根据条件执行不同的代码块。
# 简单的if语句
x = 5
if x > 0:
print("x is positive")
# if-else语句
x = -5
if x > 0:
print("x is positive")
else:
print("x is not positive")
# if-elif-else语句
x = 0
if x > 0:
print("x is positive")
elif x < 0:
print("x is negative")
else:
print("x is zero")
for循环用于遍历序列（如列表、元组、字符串）或其他可迭代对象。
# 遍历列表
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(fruit)
# 遍历字符串
for char in "Hello":
print(char)
# 使用range()函数
for i in range(5):
print(i) # 输出0, 1, 2, 3, 4
for i in range(2, 10, 2):
print(i) # 输出2, 4, 6, 8
while循环用于在条件为真时重复执行代码块。
# 基本的while循环
i = 0
while i < 5:
print(i)
i += 1 # 不要忘记递增i，否则会无限循环
# 使用break语句退出循环
i = 0
while i < 10:
print(i)
if i == 5:
break
i += 1
# 使用continue语句跳过当前循环
i = 0
while i < 10:
i += 1
if i % 2 == 0:
continue
print(i) # 输出1, 3, 5, 7, 9
在Python中，循环可以有一个else子句，当循环正常结束（没有被break中断）时执行。
# for循环中的else
for i in range(5):
print(i)
else:
print("Loop finished normally")
# while循环中的else
i = 0
while i < 5:
print(i)
i += 1
else:
print("Loop finished normally")
# 被break中断的循环不会执行else子句
for i in range(5):
print(i)
if i == 2:
break
else:
print("Loop finished normally") # 不会执行
函数是一段组织好的、可重复使用的代码块，用于执行特定的任务。在Python中，使用def关键字定义函数。
# 定义一个简单的函数
def greet():
"""这是一个问候函数"""
print("Hello, World!")
# 调用函数
greet() # 输出：Hello, World!
函数可以接受参数，以便在调用时传递数据。
# 带参数的函数
def greet(name):
"""问候指定的人"""
print(f"Hello, {name}!")
# 调用函数并传递参数
greet("Alice") # 输出：Hello, Alice!
greet("Bob") # 输出：Hello, Bob!
# 带多个参数的函数
def add(a, b):
"""计算两个数的和"""
return a + b
# 调用函数并获取返回值
result = add(3, 5)
print(result) # 输出：8
可以为函数参数设置默认值，当调用函数时没有传递该参数，则使用默认值。
# 带默认参数的函数
def greet(name, greeting="Hello"):
"""问候指定的人，默认问候语为Hello"""
print(f"{greeting}, {name}!")
# 调用函数
greet("Alice") # 输出：Hello, Alice!
greet("Bob", "Hi") # 输出：Hi, Bob!
使用关键字参数可以不按照参数定义的顺序传递参数。
# 使用关键字参数
def greet(name, age):
"""问候并显示年龄"""
print(f"Hello, {name}! You are {age} years old.")
# 按照顺序传递参数
greet("Alice", 25) # 输出：Hello, Alice! You are 25 years old.
# 使用关键字参数传递
greet(age=25, name="Alice") # 输出：Hello, Alice! You are 25 years old.
可以使用*args接收任意数量的位置参数，使用**kwargs接收任意数量的关键字参数。
# 使用*args接收任意数量的位置参数
def add(*args):
"""计算任意数量的数的和"""
total = 0
for num in args:
total += num
return total
# 调用函数
result = add(1, 2, 3, 4, 5)
print(result) # 输出：15
# 使用**kwargs接收任意数量的关键字参数
def greet(**kwargs):
"""使用关键字参数问候"""
if "name" in kwargs:
print(f"Hello, {kwargs['name']}!")
if "age" in kwargs:
print(f"You are {kwargs['age']} years old.")
# 调用函数
greet(name="Alice", age=25) # 输出：Hello, Alice! You are 25 years old.
使用return语句可以从函数中返回值。如果函数没有return语句，则默认返回None。
# 返回单个值
def square(x):
"""计算一个数的平方"""
return x * x
result = square(5)
print(result) # 输出：25
# 返回多个值
def get_name_and_age():
"""返回姓名和年龄"""
name = "Alice"
age = 25
return name, age
name, age = get_name_and_age()
print(name, age) # 输出：Alice 25
使用lambda关键字可以创建匿名函数，匿名函数可以接受任意数量的参数，但只能有一个表达式。
# 创建匿名函数
square = lambda x: x * x
print(square(5)) # 输出：25
# 在函数中使用匿名函数
def apply_function(func, x):
"""应用函数到x"""
return func(x)
result = apply_function(lambda x: x + 1, 5)
print(result) # 输出：6
# 排序时使用匿名函数
fruits = [("apple", 3), ("banana", 1), ("cherry", 2)]
fruits.sort(key=lambda fruit: fruit[1])
print(fruits) # 输出：[("banana", 1), ("cherry", 2), ("apple", 3)]
在Python中，变量的作用域分为以下几种：
print、len等。# 全局变量
global_var = "I am global"
# 局部变量
def func():
local_var = "I am local"
print(local_var) # 可以访问局部变量
print(global_var) # 可以访问全局变量
func()
print(global_var) # 可以访问全局变量
# print(local_var) # 错误：无法访问局部变量
# 使用global关键字在函数内部修改全局变量
def modify_global():
global global_var
global_var = "I am modified"
print(global_var) # 输出：I am global
modify_global()
print(global_var) # 输出：I am modified
类是面向对象编程的基本概念，用于定义对象的属性和方法。在Python中，使用class关键字定义类。
# 定义一个简单的类
class Person:
"""人"""
# 类属性
species = "Homo sapiens"
# 初始化方法
def __init__(self, name, age):
# 实例属性
self.name = name
self.age = age
# 实例方法
def greet(self):
"""问候"""
print(f"Hello, my name is {self.name}. I am {self.age} years old.")
# 实例化类
person1 = Person("Alice", 25)
person2 = Person("Bob", 30)
# 访问实例属性
print(person1.name) # 输出：Alice
print(person1.age) # 输出：25
# 调用实例方法
person1.greet() # 输出：Hello, my name is Alice. I am 25 years old.
# 访问类属性
print(person1.species) # 输出：Homo sapiens
print(Person.species) # 输出：Homo sapiens
继承是面向对象编程的重要特性，允许一个类继承另一个类的属性和方法。在Python中，定义子类时将父类作为参数传递。
# 定义父类
class Animal:
"""动物"""
def __init__(self, name):
self.name = name
def eat(self):
"""吃"""
print(f"{self.name} is eating.")
# 定义子类，继承自Animal
class Dog(Animal):
"""狗"""
def bark(self):
"""叫"""
print(f"{self.name} is barking.")
# 定义子类，继承自Animal
class Cat(Animal):
"""猫"""
def meow(self):
"""喵"""
print(f"{self.name} is meowing.")
# 实例化子类
dog = Dog("Buddy")
cat = Cat("Kitty")
# 调用继承的方法
dog.eat() # 输出：Buddy is eating.
cat.eat() # 输出：Kitty is eating.
# 调用子类自己的方法
dog.bark() # 输出：Buddy is barking.
cat.meow() # 输出：Kitty is meowing.
多态是面向对象编程的另一个重要特性，允许不同类的对象对同一消息作出不同的响应。
# 定义父类
class Shape:
"""形状"""
def area(self):
"""计算面积"""
pass
# 定义子类
class Rectangle(Shape):
"""矩形"""
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
"""计算矩形面积"""
return self.width * self.height
# 定义子类
class Circle(Shape):
"""圆形"""
def __init__(self, radius):
self.radius = radius
def area(self):
"""计算圆形面积"""
import math
return math.pi * self.radius ** 2
# 多态的使用
def print_area(shape):
"""打印形状的面积"""
print(f"Area: {shape.area()}")
# 创建不同的形状对象
rectangle = Rectangle(3, 4)
circle = Circle(5)
# 调用相同的函数，但输出不同的结果
print_area(rectangle) # 输出：Area: 12
print_area(circle) # 输出：Area: 78.53981633974483
封装是面向对象编程的第三个重要特性，用于隐藏对象的内部状态，只提供有限的接口供外部访问。在Python中，可以使用下划线来表示私有属性和方法。
# 封装的例子
class BankAccount:
"""银行账户"""
def __init__(self, account_number, balance):
# 公共属性
self.account_number = account_number
# 私有属性（使用双下划线开头）
self.__balance = balance
# 公共方法
def deposit(self, amount):
"""存款"""
if amount > 0:
self.__balance += amount
print(f"Deposited ${amount}. New balance: ${self.__balance}")
else:
print("Amount must be positive.")
def withdraw(self, amount):
"""取款"""
if 0 < amount <= self.__balance:
self.__balance -= amount
print(f"Withdrew ${amount}. New balance: ${self.__balance}")
else:
print("Insufficient funds or invalid amount.")
def get_balance(self):
"""获取余额"""
return self.__balance
# 创建账户对象
account = BankAccount("123456789", 1000)
# 访问公共属性
print(account.account_number) # 输出：123456789
# 调用公共方法
account.deposit(500) # 输出：Deposited $500. New balance: $1500
account.withdraw(200) # 输出：Withdrew $200. New balance: $1300
# 获取余额
print(account.get_balance()) # 输出：1300
# 尝试直接访问私有属性（会出错）
# print(account.__balance) # 错误：AttributeError
模块是一个包含Python代码的文件，文件名就是模块名加上.py扩展名。使用import语句可以导入模块。
# 导入整个模块
import math
# 使用模块中的函数
print(math.sqrt(16)) # 输出：4.0
print(math.pi) # 输出：3.141592653589793
# 导入模块的一部分
from math import sqrt, pi
# 使用导入的函数
print(sqrt(25)) # 输出：5.0
print(pi) # 输出：3.141592653589793
# 给模块起别名
import math as m
# 使用别名
print(m.sqrt(36)) # 输出：6.0
# 导入模块中的所有内容（不推荐）
from math import *
# 使用导入的内容
print(sqrt(49)) # 输出：7.0
包是一个包含多个模块的目录，目录中必须包含一个名为__init__.py的文件（可以是空文件）。
my_package/
__init__.py
module1.py
module2.py
# 导入包中的模块
import my_package.module1
# 使用模块中的函数
my_package.module1.function1()
# 从包中导入模块
from my_package import module2
# 使用模块中的函数
module2.function2()
# 从包中导入模块并起别名
from my_package import module1 as m1
# 使用别名
m1.function1()
Python提供了丰富的标准库模块，以下是一些常用的标准库模块：
使用open()函数可以打开文件，使用close()方法可以关闭文件。
# 打开文件
file = open("test.txt", "w") # "w"表示写入模式
# 写入内容
file.write("Hello, World!n")
file.write("This is a test file.")
# 关闭文件
file.close()
# 使用with语句自动关闭文件（推荐）
with open("test.txt", "r") as file: # "r"表示读取模式
content = file.read()
print(content)
Python中的文件打开模式包括：
# 读取整个文件
with open("test.txt", "r") as file:
content = file.read()
print(content)
# 逐行读取
with open("test.txt", "r") as file:
for line in file:
print(line.strip()) # strip()用于去除换行符
# 读取指定数量的字符
with open("test.txt", "r") as file:
content = file.read(10) # 读取前10个字符
print(content)
# 读取所有行到列表
with open("test.txt", "r") as file:
lines = file.readlines()
print(lines)
# 写入字符串
with open("test.txt", "w") as file:
file.write("Hello, World!n")
file.write("This is a test file.")
# 写入列表
lines = ["Line 1n", "Line 2n", "Line 3n"]
with open("test.txt", "w") as file:
file.writelines(lines)
文件指针用于指示当前文件的位置，可以使用tell()方法获取当前文件指针的位置，使用seek()方法移动文件指针。
with open("test.txt", "r") as file:
content = file.read(10) # 读取前10个字符
print(content)
print(file.tell()) # 输出：10（当前文件指针的位置）
file.seek(0) # 移动文件指针到文件开头
content = file.read(5)
print(content) # 输出：前5个字符
异常是程序运行时发生的错误，如除以零、访问不存在的文件、类型错误等。当异常发生时，程序会终止执行并显示错误信息。
使用try-except语句可以捕获并处理异常，避免程序终止执行。
# 基本的异常处理
try:
x = 10 / 0 # 会抛出ZeroDivisionError异常
except ZeroDivisionError:
print("Error: Division by zero!")
# 处理多种异常
try:
x = int("abc") # 会抛出ValueError异常
y = 10 / 0 # 会抛出ZeroDivisionError异常
except ValueError:
print("Error: Invalid number!")
except ZeroDivisionError:
print("Error: Division by zero!")
# 处理所有异常
try:
# 可能发生异常的代码
x = 10 / 0
except Exception as e:
print(f"Error: {e}") # 输出：Error: division by zero
# try-except-else语句
try:
x = 10 / 2
except ZeroDivisionError:
print("Error: Division by zero!")
else:
print(f"Result: {x}") # 输出：Result: 5.0
# try-except-finally语句
try:
file = open("test.txt", "r")
content = file.read()
print(content)
except FileNotFoundError:
print("Error: File not found!")
finally:
file.close() # 无论是否发生异常，都会执行finally块中的代码
使用raise语句可以主动抛出异常。
def divide(x, y):
"""计算两个数的商"""
if y == 0:
raise ZeroDivisionError("Cannot divide by zero!")
return x / y
try:
result = divide(10, 0)
except ZeroDivisionError as e:
print(f"Error: {e}") # 输出：Error: Cannot divide by zero!
可以通过继承Exception类来创建自定义异常。
# 自定义异常类
class NegativeNumberError(Exception):
"""当输入负数时抛出的异常"""
pass
def calculate_square_root(x):
"""计算平方根"""
if x < 0:
raise NegativeNumberError("Cannot calculate square root of negative number!")
return math.sqrt(x)
try:
result = calculate_square_root(-5)
except NegativeNumberError as e:
print(f"Error: {e}") # 输出：Error: Cannot calculate square root of negative number!
os模块提供与操作系统交互的功能。
import os
# 获取当前工作目录
cwd = os.getcwd()
print(cwd)
# 改变当前工作目录
os.chdir("/path/to/directory")
# 创建目录
os.mkdir("new_directory")
# 创建多级目录
os.makedirs("parent_directory/child_directory")
# 列出目录内容
files = os.listdir(".")
print(files)
# 删除文件
os.remove("file.txt")
# 删除目录
os.rmdir("directory")
# 删除多级目录
os.removedirs("parent_directory/child_directory")
# 重命名文件或目录
os.rename("old_name.txt", "new_name.txt")
# 判断文件或目录是否存在
print(os.path.exists("file.txt"))
# 判断是否是文件
print(os.path.isfile("file.txt"))
# 判断是否是目录
print(os.path.isdir("directory"))
# 获取文件大小
print(os.path.getsize("file.txt"))
# 获取文件的绝对路径
print(os.path.abspath("file.txt"))
sys模块提供与Python解释器交互的功能。
import sys
# 获取命令行参数
print(sys.argv)
# 获取Python版本信息
print(sys.version)
# 获取Python路径
print(sys.path)
# 退出程序
sys.exit(0)
random模块提供随机数生成功能。
import random
# 生成0到1之间的随机浮点数
print(random.random())
# 生成指定范围内的随机整数
print(random.randint(1, 10))
# 生成指定范围内的随机浮点数
print(random.uniform(1, 10))
# 从序列中随机选择一个元素
print(random.choice([1, 2, 3, 4, 5]))
# 从序列中随机选择多个元素
print(random.sample([1, 2, 3, 4, 5], 2))
# 打乱序列
numbers = [1, 2, 3, 4, 5]
random.shuffle(numbers)
print(numbers)
datetime模块提供日期和时间处理功能。
import datetime
# 获取当前日期和时间
now = datetime.datetime.now()
print(now)
# 获取当前日期
today = datetime.date.today()
print(today)
# 创建日期对象
date = datetime.date(2023, 12, 25)
print(date)
# 创建时间对象
time = datetime.time(12, 30, 45)
print(time)
# 格式化日期和时间
formatted_date = now.strftime("%Y-%m-%d %H:%M:%S")
print(formatted_date)
# 解析日期和时间
parsed_date = datetime.datetime.strptime("2023-12-25 12:30:45", "%Y-%m-%d %H:%M:%S")
print(parsed_date)
# 日期和时间的计算
tomorrow = today + datetime.timedelta(days=1)
print(tomorrow)
next_hour = now + datetime.timedelta(hours=1)
print(next_hour)
json模块提供JSON数据处理功能。
import json
# 将Python对象转换为JSON字符串
python_obj = {"name": "Alice", "age": 25, "city": "New York"}
json_str = json.dumps(python_obj)
print(json_str) # 输出：{"name": "Alice", "age": 25, "city": "New York"}
# 将JSON字符串转换为Python对象
python_obj2 = json.loads(json_str)
print(python_obj2) # 输出：{"name": "Alice", "age": 25, "city": "New York"}
# 将Python对象写入JSON文件
with open("data.json", "w") as file:
json.dump(python_obj, file)
# 从JSON文件读取Python对象
with open("data.json", "r") as file:
python_obj3 = json.load(file)
print(python_obj3)
列表推导式用于快速创建列表。
# 创建包含1到10的平方的列表
squares = [x ** 2 for x in range(1, 11)]
print(squares) # 输出：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
# 创建包含1到10的偶数的平方的列表
even_squares = [x ** 2 for x in range(1, 11) if x % 2 == 0]
print(even_squares) # 输出：[4, 16, 36, 64, 100]
# 创建二维列表
matrix = [[i for i in range(3)] for j in range(3)]
print(matrix) # 输出：[[0, 1, 2], [0, 1, 2], [0, 1, 2]]
字典推导式用于快速创建字典。
# 创建包含1到10的平方的字典
squares_dict = {x: x ** 2 for x in range(1, 11)}
print(squares_dict) # 输出：{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}
# 创建包含1到10的偶数的平方的字典
even_squares_dict = {x: x ** 2 for x in range(1, 11) if x % 2 == 0}
print(even_squares_dict) # 输出：{2: 4, 4: 16, 6: 36, 8: 64, 10: 100}
集合推导式用于快速创建集合。
# 创建包含1到10的平方的集合
squares_set = {x ** 2 for x in range(1, 11)}
print(squares_set) # 输出：{64, 1, 4, 36, 100, 9, 16, 49, 81, 25}
# 创建包含1到10的偶数的平方的集合
even_squares_set = {x ** 2 for x in range(1, 11) if x % 2 == 0}
print(even_squares_set) # 输出：{64, 4, 36, 100, 16}
生成器表达式用于创建生成器，与列表推导式类似，但使用圆括号。
# 创建生成器
squares_gen = (x ** 2 for x in range(1, 11))
print(squares_gen) # 输出：<generator object <genexpr> at 0x0000020D7C4A1F90>
# 遍历生成器
for square in squares_gen:
print(square)
# 生成器的优点：节省内存
squares_list = [x ** 2 for x in range(1000000)] # 占用大量内存
squares_gen = (x ** 2 for x in range(1000000)) # 占用很少内存
for循环遍历的对象，如列表、元组、字符串、字典等。next()函数获取下一个元素的对象。# 可迭代对象
fruits = ["apple", "banana", "cherry"]
# 将可迭代对象转换为迭代器
iterator = iter(fruits)
# 使用next()函数获取下一个元素
print(next(iterator)) # 输出：apple
print(next(iterator)) # 输出：banana
print(next(iterator)) # 输出：cherry
# print(next(iterator)) # 错误：StopIteration
# 自定义迭代器
class MyIterator:
def __init__(self, start, end):
self.current = start
self.end = end
def __iter__(self):
return self
def __next__(self):
if self.current > self.end:
raise StopIteration
else:
value = self.current
self.current += 1
return value
# 使用自定义迭代器
for num in MyIterator(1, 5):
print(num) # 输出：1, 2, 3, 4, 5
lru_cache装饰器。# 使用time模块测量执行时间
import time
start_time = time.time()
# 执行代码
result = sum([i for i in range(1000000)])
end_time = time.time()
execution_time = end_time - start_time
print(f"Execution time: {execution_time} seconds")
# 使用timeit模块测量执行时间
import timeit
execution_time = timeit.timeit("sum([i for i in range(1000000)])", number=1)
print(f"Execution time: {execution_time} seconds")
# 使用cProfile模块分析性能
import cProfile
def func():
result = sum([i for i in range(1000000)])
return result
cProfile.run("func()")
# 使用列表
numbers_list = [i for i in range(1000000)]
sum_list = sum(numbers_list)
# 使用生成器
numbers_gen = (i for i in range(1000000))
sum_gen = sum(numbers_gen)
# 使用普通的for循环
total = 0
for i in range(1000000):
total += i
# 使用内置函数sum
total = sum(range(1000000))
from functools import lru_cache
# 不使用缓存
import time
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
start_time = time.time()
result = fibonacci(40)
end_time = time.time()
print(f"Result: {result}")
print(f"Execution time: {end_time - start_time} seconds")
# 使用缓存
@lru_cache(maxsize=None)
def fibonacci_cached(n):
if n <= 1:
return n
return fibonacci_cached(n - 1) + fibonacci_cached(n - 2)
start_time = time.time()
result = fibonacci_cached(40)
end_time = time.time()
print(f"Result: {result}")
print(f"Execution time: {end_time - start_time} seconds")
最简单的调试方法是使用print语句输出变量的值。
def add(a, b):
print(f"a = {a}, b = {b}")
return a + b
result = add(3, 5)
print(f"result = {result}")
pdb是Python的内置调试器，可以用于单步执行代码、查看变量的值等。
import pdb
def add(a, b):
pdb.set_trace() # 设置断点
return a + b
result = add(3, 5)
print(f"result = {result}")
大多数集成开发环境（如PyCharm、VS Code等）都提供了强大的调试功能，可以更方便地调试代码。
单元测试用于测试代码中的单个函数或类。Python的unittest模块提供了单元测试的功能。
import unittest
def add(a, b):
"""计算两个数的和"""
return a + b
class TestAdd(unittest.TestCase):
"""测试add函数"""
def test_add_positive_numbers(self):
"""测试两个正数相加"""
self.assertEqual(add(3, 5), 8)
def test_add_negative_numbers(self):
"""测试两个负数相加"""
self.assertEqual(add(-3, -5), -8)
def test_add_zero(self):
"""测试加零"""
self.assertEqual(add(3, 0), 3)
self.assertEqual(add(0, 5), 5)
if __name__ == "__main__":
unittest.main()
设计测试用例时，应该考虑以下几点：
pytest是一个更简单、更强大的测试框架，可以替代unittest模块。
# 使用pytest测试
def add(a, b):
"""计算两个数的和"""
return a + b
def test_add_positive_numbers():
"""测试两个正数相加"""
assert add(3, 5) == 8
def test_add_negative_numbers():
"""测试两个负数相加"""
assert add(-3, -5) == -8
def test_add_zero():
"""测试加零"""
assert add(3, 0) == 3
assert add(0, 5) == 5
Python是一种简单易学、功能强大的编程语言，广泛应用于Web开发、数据科学、人工智能、自动化脚本等领域。本教程介绍了Python的基本概念、语法、数据类型、控制流、函数、面向对象编程、模块与包、文件操作、异常处理、常用标准库、高级特性、性能优化、调试与测试等内容，希望能够帮助读者快速掌握Python编程。
学习Python的关键是多练习、多实践，通过编写实际项目来提高编程能力。祝大家学习愉快！
