跳转到主要内容

Python百答手册

作者： 默子

发布日期： 2024-11-03

引言

Python 是一种功能强大且易于学习的编程语言，广泛应用于数据分析、人工智能、Web 开发等多个领域。本手册旨在通过百答的形式，帮助读者深入理解和掌握 Python 的各种知识点。无论您是编程新手还是有经验的开发者，这本手册都将是您不可或缺的参考资料。

为什么选择 Python

  • 简单易学：Python 语法简洁明了，适合初学者快速上手。
  • 丰富的库：拥有大量的第三方库，满足各种开发需求。
  • 跨平台：支持多种操作系统，如 Windows、macOS、Linux。
  • 广泛应用：在数据科学、机器学习、Web 开发、自动化等领域有广泛应用。

如何使用本手册

本手册分为多个章节，每个章节涵盖一个或多个相关的知识点。每个知识点都配有详细的解释、示例代码以及参考链接，帮助您更好地理解和应用。

  1. 尽可能使用浏览器内置的搜索功能 Ctrl+F
  2. 尽可能善用侧边栏的目录

基础知识

变量

变量是用于存储数据的命名位置。在 Python 中，变量无需声明即可使用，赋值时会根据值的类型自动推断变量类型。

变量的命名规则

  • 字符集：变量名由字母（a-z、A-Z）、数字（0-9）和下划线（_）组成。
  • 首字符：不能以数字开头。
  • 区分大小写：变量名是区分大小写的，例如 var 和 Var 是不同的变量。
  • 保留字：避免使用 Python 的保留字作为变量名，如 for、if 等。
示例
# 有效的变量名
age = 25
first_name = "Alice"
_total = 1000

# 无效的变量名（以数字开头）
1st_place = "Gold"

# 无效的变量名（使用保留字）
for = "Loop"

变量的赋值

Python 支持多变量赋值，可以在一行中为多个变量赋值。此外，还支持交换变量的值。

单个赋值
x = 10
y = 3.14
name = "Bob"
多变量赋值
a, b, c = 1, 2.5, "Hello"
交换变量
a, b = b, a
参考链接

数据类型

Python 支持多种数据类型，主要包括整数、浮点数、字符串、布尔值、列表、字典、集合和元组。

整数（Integer）

整数是没有小数部分的数字，可以是正数、负数或零。

示例
x = 10
y = -5
z = 0
特性
  • 无限精度：Python 3 的整数类型支持任意大小的整数。
  • 类型检查：使用 type() 函数可以检查变量的类型。
示例
print(type(x))  # <class 'int'>

浮点数（Float）

浮点数是带有小数点的数字，表示实数。

示例
pi = 3.14159
e = 2.71828
temperature = -273.15
特性
  • 精度：浮点数有一定的精度限制，通常为 64 位。
  • 科学计数法：可以使用科学计数法表示浮点数。
示例
large_num = 1.2e6  # 1200000.0
small_num = 5.67e-3  # 0.00567

字符串（String）

字符串是由一系列字符组成的文本数据，可以使用单引号、双引号或三引号定义。

示例
single_quote = 'Hello'
double_quote = "World"
multi_line = """This is a
multi-line string."""
特性
  • 不可变性：字符串一旦创建，其内容不能修改。
  • 多行字符串：使用三引号可以创建多行字符串。
  • 转义字符：支持使用反斜杠（\）进行转义，如 \n 表示换行。
示例
escaped_string = "He said, \"Hello, World!\""
print(escaped_string)
# 输出: He said, "Hello, World!"

布尔值（Boolean）

布尔值表示真（True）或假（False）的逻辑值。

示例
is_active = True
is_deleted = False
特性
  • 类型：布尔值属于 bool 类型，继承自 int。
  • 运算：布尔值可以参与逻辑运算，如 and、or、not。
示例
print(type(is_active))  # <class 'bool'>
print(True + 1)  # 输出 2，因为 True 被视为 1

列表（List）

列表是有序的可变集合，可以包含不同类型的元素。

示例
fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4, 5]
mixed = [1, "two", 3.0, True]
特性
  • 有序性：元素有固定的顺序，可以通过索引访问。
  • 可变性：可以修改、添加或删除元素。
  • 多样性：列表可以包含不同类型的元素。
操作示例
# 访问元素
print(fruits[0])  # 输出 'apple'

# 修改元素
fruits[1] = "blueberry"
print(fruits)  # 输出 ['apple', 'blueberry', 'cherry']

# 添加元素
fruits.append("date")
print(fruits)  # 输出 ['apple', 'blueberry', 'cherry', 'date']

# 删除元素
del fruits[2]
print(fruits)  # 输出 ['apple', 'blueberry', 'date']
参考链接

字典（Dictionary）

字典是无序的键值对集合，每个键是唯一的。

示例
person = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}
特性
  • 键值对：每个元素由键和值组成。
  • 快速查找：通过键可以快速访问对应的值。
  • 动态：可以动态添加、修改或删除键值对。
操作示例
# 访问值
print(person["name"])  # 输出 'Alice'

# 修改值
person["age"] = 31
print(person)  # {'name': 'Alice', 'age': 31, 'city': 'New York'}

# 添加新键值对
person["email"] = "alice@example.com"
print(person)

# 删除键值对
del person["city"]
print(person)
参考链接

集合（Set）

集合是无序的不重复元素集合，主要用于成员测试和消除重复项。

示例
unique_numbers = {1, 2, 3, 4, 5}
fruits = {"apple", "banana", "cherry"}
特性
  • 无序性：集合中的元素没有固定的顺序。
  • 唯一性：集合中的元素是唯一的，不允许重复。
  • 集合操作：支持集合运算，如并集、交集、差集等。
操作示例
# 添加元素
fruits.add("date")
print(fruits)

# 删除元素
fruits.remove("banana")
print(fruits)

# 并集
set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1 | set2)  # 输出 {1, 2, 3, 4, 5}

# 交集
print(set1 & set2)  # 输出 {3}

# 差集
print(set1 - set2)  # 输出 {1, 2}
参考链接

元组（Tuple）

元组是有序的不可变集合，一旦创建不能修改。

示例
coordinates = (10.0, 20.0)
person = ("Bob", 25, "London")
特性
  • 有序性：元素有固定的顺序，可以通过索引访问。
  • 不可变性：元组一旦创建，其内容不能修改。
  • 性能：由于不可变性，元组在某些情况下比列表更高效。
操作示例
# 访问元素
print(coordinates[0])  # 输出 10.0

# 尝试修改元素（会引发错误）
coordinates[1] = 30.0  # TypeError: 'tuple' object does not support item assignment
参考链接

变量的可变性

在 Python 中，数据类型分为可变对象和不可变对象。了解它们的区别对于编写高效且无错误的代码至关重要。

可变对象

可变对象的内容可以在原地修改。常见的可变对象包括列表、字典和集合。

示例
fruits = ["apple", "banana", "cherry"]
fruits.append("date")  # 修改了列表内容
print(fruits)  # 输出 ['apple', 'banana', 'cherry', 'date']
特性
  • 原地修改：直接修改对象，不需要重新赋值。
  • 内存效率：避免了创建新对象，提高了内存使用效率。
参考链接

不可变对象

不可变对象一旦创建，其内容不能修改。常见的不可变对象包括整数、浮点数、字符串和元组。

示例
x = 10
x = x + 5  # 创建了一个新的整数对象
print(x)  # 输出 15
特性
  • 不可变性：无法修改对象内容，只能创建新对象。
  • 哈希性：不可变对象通常是可哈希的，可以作为字典的键。
参考链接

赋值

赋值是将值存储在变量中的过程。在 Python 中，赋值是通过等号（=）进行的。

简单赋值

将一个值赋给一个变量。

x = 10
name = "Alice"

多变量赋值

在一行中为多个变量赋值。

a, b, c = 1, 2.5, "Hello"

解包赋值

将一个可迭代对象的元素赋值给多个变量。

coordinates = (10.0, 20.0)
x, y = coordinates
print(x)  # 输出 10.0
print(y)  # 输出 20.0

引用赋值

将一个对象的引用赋给另一个变量。两者指向同一个对象。

list1 = [1, 2, 3]
list2 = list1
list2.append(4)
print(list1)  # 输出 [1, 2, 3, 4]

深拷贝与浅拷贝

  • 浅拷贝：创建一个新对象，但不复制嵌套对象。
  • 深拷贝：创建一个新对象，并递归复制所有嵌套对象。
示例
import copy

original = [[1, 2], [3, 4]]
shallow_copy = copy.copy(original)
deep_copy = copy.deepcopy(original)

shallow_copy[0].append(5)
print(original)       # 输出 [[1, 2, 5], [3, 4]]
print(deep_copy)      # 输出 [[1, 2], [3, 4]]
参考链接

索引与切片

索引和切片用于访问序列（如列表、字符串、元组）中的元素。

索引

通过索引访问单个元素。索引从 0 开始，支持负数索引从序列末尾开始计数。

示例
fruits = ["apple", "banana", "cherry", "date"]

print(fruits[0])   # 输出 'apple'
print(fruits[2])   # 输出 'cherry'
print(fruits[-1])  # 输出 'date'
print(fruits[-3])  # 输出 'banana'

切片

通过切片访问子序列。切片使用冒号 : 分隔起始和结束索引，可以指定步长。

基本切片
fruits = ["apple", "banana", "cherry", "date", "elderberry"]

# 从索引 1 到 3（不包括 3）
print(fruits[1:3])  # 输出 ['banana', 'cherry']

# 从开始到索引 2（不包括 2）
print(fruits[:2])   # 输出 ['apple', 'banana']

# 从索引 3 到结束
print(fruits[3:])   # 输出 ['date', 'elderberry']
步长切片
numbers = list(range(10))  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 每隔一个元素取一次
print(numbers[::2])  # 输出 [0, 2, 4, 6, 8]

# 反向切片
print(numbers[::-1])  # 输出 [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
修改切片

对于可变序列（如列表），可以通过切片修改部分内容。

fruits = ["apple", "banana", "cherry", "date"]

# 替换部分元素
fruits[1:3] = ["blueberry", "coconut"]
print(fruits)  # 输出 ['apple', 'blueberry', 'coconut', 'date']
参考链接

操作符与表达式

操作符用于执行各种操作，如赋值、算术运算、比较等。表达式是由操作符和操作数组成的代码片段，能够计算出一个值。

赋值运算符

赋值运算符用于给变量赋值，包括简单赋值和复合赋值。

简单赋值

将右侧的值赋给左侧的变量。

x = 10
y = 3.14
name = "Alice"

复合赋值

将运算结果赋给变量，相当于变量与某个值进行运算后再赋值。

  • +=：加后赋值
  • -=：减后赋值
  • *=：乘后赋值
  • /=：除后赋值
  • //=：整除后赋值
  • %=：取模后赋值
  • **=：幂后赋值
示例
x = 10
x += 5  # 相当于 x = x + 5
print(x)  # 输出 15

x *= 2  # 相当于 x = x * 2
print(x)  # 输出 30
参考链接

算术运算符

算术运算符用于执行基本的数学运算。

运算符 描述 示例
+ 加法 5 + 3 = 8
- 减法 5 - 3 = 2
* 乘法 5 * 3 = 15
/ 除法 5 / 3 ≈ 1.6667
// 整除 5 // 3 = 1
% 取模 5 % 3 = 2
** 幂运算 5 ** 3 = 125

示例

a = 10
b = 3
print(a + b)   # 输出 13
print(a - b)   # 输出 7
print(a * b)   # 输出 30
print(a / b)   # 输出 3.333...
print(a // b)  # 输出 3
print(a % b)   # 输出 1
print(a ** b)  # 输出 1000
参考链接

比较运算符

比较运算符用于比较两个值的大小关系，返回布尔值。

运算符 描述 示例
== 等于 5 == 5 → True
!= 不等于 5 != 3 → True
> 大于 5 > 3 → True
< 小于 5 < 3 → False
>= 大于等于 5 >= 5 → True
<= 小于等于 5 <= 3 → False

示例

a = 5
b = 10
print(a == b)  # 输出 False
print(a != b)  # 输出 True
print(a > b)   # 输出 False
print(a < b)   # 输出 True
print(a >= b)  # 输出 False
print(a <= b)  # 输出 True
参考链接

逻辑运算符

逻辑运算符用于组合多个条件，返回布尔值。

运算符 描述 示例
and 与 True and False → False
or 或 True or False → True
not 非 not True → False

示例

a = True
b = False
print(a and b)  # 输出 False
print(a or b)   # 输出 True
print(not a)    # 输出 False
短路行为
  • and：如果第一个操作数为 False，则返回第一个操作数，不再评估第二个操作数。
  • or：如果第一个操作数为 True，则返回第一个操作数，不再评估第二个操作数。
示例
def func():
    print("Function called")
    return True

print(False and func())  # 输出 False，不调用 func()
print(True or func())    # 输出 True，不调用 func()
参考链接

位运算符

位运算符用于对整数的二进制位进行操作。

运算符 描述 示例
& 按位与 5 & 3 → 1 (0101 & 0011 = 0001)
` ` 按位或
^ 按位异或 5 ^ 3 → 6 (0101 ^ 0011 = 0110)
~ 按位取反 ~5 → -6 (~0101 = 1010)
<< 左移 5 << 2 → 20 (0101 << 2 = 10100)
>> 右移 5 >> 2 → 1 (0101 >> 2 = 0001)

示例

a = 60       # 60 = 0011 1100
b = 13       # 13 = 0000 1101

print(a & b)  # 输出 12 (0000 1100)
print(a | b)  # 输出 61 (0011 1101)
print(a ^ b)  # 输出 49 (0011 0001)
print(~a)     # 输出 -61 (1100 0011)
print(a << 2) # 输出 240 (1111 0000)
print(a >> 2) # 输出 15 (0000 1111)
注意事项
  • 按位取反：~ 运算符对整数执行按位取反，并返回其补码表示。
  • 符号位：位运算符处理的是整数的二进制表示，包括符号位。
参考链接

控制流

控制流用于控制程序的执行顺序，包括条件语句和循环语句。

条件语句

条件语句用于根据条件执行不同的代码块。

if 语句

基本的条件判断语句，根据条件是否为真来执行相应的代码块。

语法
if condition:
    # 条件为真时执行的代码
示例
x = 10
if x > 0:
    print("Positive")
参考链接

if-else 语句

在条件为真时执行一个代码块，为假时执行另一个代码块。

语法
if condition:
    # 条件为真时执行的代码
else:
    # 条件为假时执行的代码
示例
x = -5
if x > 0:
    print("Positive")
else:
    print("Non-positive")
参考链接

if-elif-else 语句

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

语法
if condition1:
    # 条件1为真时执行的代码
elif condition2:
    # 条件2为真时执行的代码
else:
    # 所有条件均不为真时执行的代码
示例
x = 0
if x > 0:
    print("Positive")
elif x == 0:
    print("Zero")
else:
    print("Negative")
参考链接

循环

循环用于重复执行代码块，直到满足特定条件。

for 循环

用于遍历序列（如列表、元组、字典、集合、字符串等）。

语法
for item in sequence:
    # 对每个 item 执行的代码
示例
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)
参考链接

while 循环

在给定条件为真时重复执行代码块。

语法
while condition:
    # 条件为真时执行的代码
示例
count = 0
while count < 5:
    print(count)
    count += 1
参考链接

嵌套循环

在一个循环内部嵌套另一个循环，用于处理多维数据或复杂的迭代。

示例
for i in range(1, 4):
    for j in range(1, 4):
        print(f"{i} * {j} = {i*j}")
输出
1 * 1 = 1
1 * 2 = 2
1 * 3 = 3
2 * 1 = 2
2 * 2 = 4
2 * 3 = 6
3 * 1 = 3
3 * 2 = 6
3 * 3 = 9
参考链接

列表推导式

使用简洁的语法从一个列表创建另一个列表。列表推导式可以包含条件过滤和嵌套循环。

基本语法

[expression for item in iterable]

示例

squares = [x**2 for x in range(10)]
print(squares)  # 输出 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

带条件的列表推导式

even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)  # 输出 [0, 4, 16, 36, 64]

嵌套循环的列表推导式

matrix = [[1, 2, 3], [4, 5, 6]]
flattened = [num for row in matrix for num in row]
print(flattened)  # 输出 [1, 2, 3, 4, 5, 6]

参考链接

函数与模块

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。模块是一个包含一组函数和变量的文件。

函数

函数是可重复使用的代码块，用于执行特定任务。使用函数可以提高代码的可读性和可维护性。

定义函数

使用 def 关键字定义函数。

语法
def function_name(parameters):
    """
    函数的文档字符串（可选）
    """
    # 函数体
    return value
示例
def greet(name):
    """返回一个问候语句。"""
    return f"Hello, {name}!"

# 调用函数
message = greet("Alice")
print(message)  # 输出: Hello, Alice!
参考链接

函数参数

函数可以接受多种类型的参数，包括位置参数、默认参数、可变参数和关键字参数。

位置参数

函数调用时按照位置传递的参数。

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

result = add(5, 3)
print(result)  # 输出 8
默认参数

为参数指定默认值，如果调用时未提供该参数，则使用默认值。

def greet(name, message="Hello"):
    return f"{message}, {name}!"

print(greet("Bob"))            # 输出: Hello, Bob!
print(greet("Bob", "Hi"))      # 输出: Hi, Bob!
可变参数

允许函数接受任意数量的位置参数或关键字参数。

  • *args：接受任意数量的位置参数，作为一个元组传递。
  • **kwargs：接受任意数量的关键字参数，作为一个字典传递。
def func(a, b=2, *args, **kwargs):
    print(f"a = {a}, b = {b}")
    print(f"args = {args}")
    print(f"kwargs = {kwargs}")

func(1)
# 输出:
# a = 1, b = 2
# args = ()
# kwargs = {}

func(1, 3, 4, 5, key='value')
# 输出:
# a = 1, b = 3
# args = (4, 5)
# kwargs = {'key': 'value'}
参考链接

返回值

使用 return 语句从函数返回值。如果函数未显式返回值，则默认返回 None。

示例
def add(x, y):
    return x + y

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

def no_return():
    pass

print(no_return())  # 输出 None
多重返回值

Python 函数可以返回多个值，实际上是返回一个元组。

def get_user():
    name = "Alice"
    age = 30
    return name, age

user = get_user()
print(user)  # 输出 ('Alice', 30)

name, age = get_user()
print(name)  # 输出 'Alice'
print(age)   # 输出 30
参考链接

模块与包

模块是包含一组函数和变量的文件，包是包含多个模块的目录。模块和包使代码组织更清晰，易于维护和复用。

模块

模块是一个包含 Python 代码的文件，通常以 .py 结尾。模块可以包含函数、类和变量。

创建模块

创建一个名为 math_utils.py 的模块。

# math_utils.py

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

def subtract(a, b):
    return a - b
导入模块

使用 import 关键字导入模块。

import math_utils

result = math_utils.add(5, 3)
print(result)  # 输出 8
导入特定函数

使用 from ... import ... 语句导入模块中的特定函数。

from math_utils import subtract

result = subtract(10, 4)
print(result)  # 输出 6
使用别名

为模块或函数指定别名，方便调用。

import math_utils as mu

result = mu.add(2, 3)
print(result)  # 输出 5

from math_utils import add as addition

print(addition(4, 5))  # 输出 9
参考链接

包

包是包含多个模块的目录，使用 __init__.py 文件标识。包可以嵌套子包，组织更复杂的项目结构。

创建包

创建一个名为 utilities 的包：

utilities/
    __init__.py
    math_utils.py
    string_utils.py
示例
# utilities/math_utils.py

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

# utilities/string_utils.py

def uppercase(s):
    return s.upper()
导入包中的模块
import utilities.math_utils as mu
import utilities.string_utils as su

print(mu.multiply(3, 4))    # 输出 12
print(su.uppercase("hello"))  # 输出 'HELLO'
从包中导入特定函数
from utilities.math_utils import multiply
from utilities.string_utils import uppercase

print(multiply(5, 6))        # 输出 30
print(uppercase("world"))    # 输出 'WORLD'
嵌套包

包可以包含子包，进一步组织代码。

utilities/
    __init__.py
    math_utils.py
    string_utils.py
    data/
        __init__.py
        data_utils.py
示例
# utilities/data/data_utils.py

def load_data(file_path):
    with open(file_path, 'r') as file:
        return file.read()

# 导入嵌套包中的模块
from utilities.data import data_utils

data = data_utils.load_data("data.txt")
print(data)
参考链接

面向对象编程

面向对象编程（OOP）是一种编程范式，通过创建对象和类来组织代码。OOP 强调代码的重用、可扩展性和可维护性。

类与对象

类是创建对象的蓝图，对象是类的实例。

定义类

使用 class 关键字定义类。类可以包含属性（变量）和方法（函数）。

示例
class Dog:
    def __init__(self, name, age):
        self.name = name  # 实例变量
        self.age = age    # 实例变量
    
    def bark(self):
        print(f"{self.name} says Woof!")
__init__ 方法

__init__ 是类的构造方法，用于初始化对象的属性。self 参数代表实例本身。

示例
class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age
参考链接

创建对象

使用类名和参数创建对象。

示例
my_dog = Dog("Buddy", 5)
my_dog.bark()  # 输出: Buddy says Woof!
访问属性和方法

使用点（.）操作符访问对象的属性和方法。

print(my_dog.name)  # 输出 'Buddy'
print(my_dog.age)   # 输出 5
my_dog.bark()       # 输出 'Buddy says Woof!'
参考链接

继承

通过继承可以创建子类，子类继承父类的属性和方法，并可以添加新的属性和方法或重写父类的方法。

示例
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        pass  # 子类实现

class Cat(Animal):
    def speak(self):
        print(f"{self.name} says Meow!")

class Dog(Animal):
    def speak(self):
        print(f"{self.name} says Woof!")

# 创建对象
my_cat = Cat("Whiskers")
my_cat.speak()  # 输出: Whiskers says Meow!

my_dog = Dog("Buddy")
my_dog.speak()  # 输出: Buddy says Woof!
多重继承

一个子类可以继承多个父类。

示例
class Flyer:
    def fly(self):
        print("Flying")

class Swimmer:
    def swim(self):
        print("Swimming")

class Duck(Flyer, Swimmer):
    def quack(self):
        print("Quack!")

duck = Duck()
duck.fly()    # 输出: Flying
duck.swim()   # 输出: Swimming
duck.quack()  # 输出: Quack!
参考链接

多态、封装与抽象

多态

多态指的是不同类的对象可以通过相同的接口调用不同的方法实现。多态性提高了代码的灵活性和可扩展性。

示例
class Animal:
    def speak(self):
        pass

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

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

def make_animal_speak(animal):
    animal.speak()

# 使用多态
cat = Cat()
dog = Dog()

make_animal_speak(cat)  # 输出: Meow!
make_animal_speak(dog)  # 输出: Woof!
参考链接

封装

封装是将数据和方法封装在类中，隐藏内部实现细节，防止外部直接访问或修改。

示例
class BankAccount:
    def __init__(self, balance=0):
        self.__balance = balance  # 私有属性

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount

    def get_balance(self):
        return self.__balance

# 使用类
account = BankAccount()
account.deposit(100)
account.withdraw(50)
print(account.get_balance())  # 输出 50

# 尝试直接访问私有属性（会失败）
print(account.__balance)  # AttributeError
参考链接

抽象

抽象是通过抽象类或接口定义方法规范，具体实现由子类完成。Python 使用 abc 模块来支持抽象基类。

示例
from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    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

rectangle = Rectangle(5, 3)
print(rectangle.area())  # 输出 15
参考链接

高级特性

生成器与迭代器

生成器和迭代器是用于创建可迭代对象的高级工具，帮助有效地处理数据流和大数据集。

生成器

生成器是一种迭代器，用于按需生成序列中的值，节省内存。

定义生成器

使用 yield 关键字定义生成器函数。

示例
def count_up_to(max):
    count = 1
    while count <= max:
        yield count
        count += 1

for num in count_up_to(5):
    print(num)
输出
1
2
3
4
5
参考链接

迭代器

迭代器是可以遍历的对象，包含 __iter__() 和 __next__() 方法。

创建迭代器类
class MyIterator:
    def __init__(self, limit):
        self.limit = limit
        self.current = 0
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.current < self.limit:
            self.current += 1
            return self.current
        else:
            raise StopIteration

for num in MyIterator(3):
    print(num)
输出
1
2
3
参考链接

装饰器

装饰器用于在不修改函数代码的情况下，增强函数功能。它们通常用于日志记录、访问控制、缓存等。

函数装饰器

装饰器是接受函数作为参数并返回一个新函数的高阶函数。

示例
def decorator_func(func):
    def wrapper(*args, **kwargs):
        print("Before function call")
        result = func(*args, **kwargs)
        print("After function call")
        return result
    return wrapper

@decorator_func
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("Alice")
输出
Before function call
Hello, Alice!
After function call

类装饰器

装饰器也可以用于类，修改或扩展类的行为。

示例
def add_repr(cls):
    def __repr__(self):
        return f"{cls.__name__}({self.__dict__})"
    cls.__repr__ = __repr__
    return cls

@add_repr
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

p = Person("Bob", 25)
print(p)  # 输出: Person({'name': 'Bob', 'age': 25})
参考链接

异常处理

异常处理用于处理程序运行时的错误，防止程序崩溃，增强程序的健壮性。

异常类型

常见的异常类型包括：

  • ValueError：传入无效参数。
  • TypeError：操作类型不匹配。
  • IOError：输入/输出操作失败。
  • ZeroDivisionError：除以零。
  • FileNotFoundError：文件未找到。
示例
try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero!")
参考链接

处理异常

try-except 语句

用于捕获和处理异常，防止程序崩溃。

语法
try:
    # 可能引发异常的代码
except ExceptionType:
    # 异常处理代码
示例
try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero!")
参考链接

finally 语句

无论是否发生异常，finally 块中的代码都会执行，常用于资源释放。

语法
try:
    # 可能引发异常的代码
except ExceptionType:
    # 异常处理代码
finally:
    # 总会执行的代码
示例
try:
    file = open("data.txt", "r")
    data = file.read()
except FileNotFoundError:
    print("File not found.")
finally:
    file.close()
参考链接

raise 语句

用于主动引发异常，以便在程序中检测和处理特定错误条件。

语法
raise ExceptionType("Error message")
示例
def validate_age(age):
    if age < 0:
        raise ValueError("Age cannot be negative.")

try:
    validate_age(-5)
except ValueError as e:
    print(e)  # 输出: Age cannot be negative.
参考链接

文件操作

文件操作是处理磁盘上文件的基本技能，包括读写文件、追加内容、处理二进制文件等。

读写文件

使用内置函数 open() 进行文件操作，配合上下文管理器（with 语句）确保文件正确关闭。

读取文件

示例
with open("example.txt", "r") as file:
    content = file.read()
    print(content)
按行读取
with open("example.txt", "r") as file:
    for line in file:
        print(line.strip())

写入文件

覆盖写入

使用模式 "w" 打开文件会覆盖原有内容。

with open("example.txt", "w") as file:
    file.write("Hello, World!")
追加模式

在文件末尾追加内容，使用模式 "a"。

with open("example.txt", "a") as file:
    file.write("\nAppended line.")
写入多行
lines = ["First line", "Second line", "Third line"]
with open("example.txt", "w") as file:
    for line in lines:
        file.write(line + "\n")

处理二进制文件

使用模式 "rb"（读取二进制）或 "wb"（写入二进制）处理二进制文件，如图片、音频等。

示例
# 读取二进制文件
with open("image.png", "rb") as file:
    data = file.read()

# 写入二进制文件
with open("copy_image.png", "wb") as file:
    file.write(data)
参考链接

文件模式

模式 描述
r 读取（默认模式），文件必须存在
w 写入，覆盖文件，如果文件不存在则创建
a 追加，写入到文件末尾，如果文件不存在则创建
b 二进制模式
t 文本模式（默认模式）
+ 更新模式（可读可写）
示例
# 以二进制模式读取文件
with open("image.png", "rb") as file:
    data = file.read()

# 以读写模式打开文件
with open("example.txt", "r+") as file:
    content = file.read()
    file.write("\nNew line added.")
参考链接

测试与调试

测试与调试是确保代码质量和功能正确的重要环节。Python 提供了多种工具和框架来支持测试和调试。

单元测试

单元测试用于测试代码中的单个功能单元，确保其按预期工作。Python 提供了内置的 unittest 框架和第三方的 pytest 框架。

pytest 示例

pytest 是一个功能强大且易于使用的第三方测试框架，支持简单的测试和复杂的测试需求。

安装 pytest
pip install pytest
编写测试

创建一个名为 test_math.py 的测试文件。

# test_math.py

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

def test_add():
    assert add(2, 3) == 5
    assert add(-1, 1) == 0
    assert add(0, 0) == 0
运行测试

在命令行中运行 pytest。

pytest test_math.py
输出
============================= test session starts ==============================
platform linux -- Python 3.x.x, pytest-6.x.x, py-1.x.x, pluggy-0.x.x
collected 1 item

test_math.py .                                                            [100%]

============================== 1 passed in 0.01s ===============================
参考链接

内存管理与垃圾回收

Python 使用自动内存管理和垃圾回收机制，通过引用计数和循环垃圾收集器来管理内存。

引用计数

每个对象维护一个引用计数器，记录有多少引用指向该对象。当引用计数为零时，对象会被销毁。

示例
import sys

a = []
print(sys.getrefcount(a))  # 输出引用计数

b = a
print(sys.getrefcount(a))  # 引用计数增加

del b
print(sys.getrefcount(a))  # 引用计数减少

垃圾回收

垃圾回收用于处理引用计数无法解决的循环引用问题。Python 使用 gc 模块管理垃圾回收。

示例
import gc

# 禁用垃圾回收
gc.disable()

# 启用垃圾回收
gc.enable()

# 手动触发垃圾回收
gc.collect()
参考链接

附录

常用内置函数

Python 提供了许多内置函数，帮助简化常见任务。以下是一些常用的内置函数：

函数 描述 示例
len() 返回对象的长度或元素个数 len([1, 2, 3]) → 3
range() 生成一个整数序列，常用于循环 range(5) → 0, 1, 2, 3, 4
print() 输出到控制台 print("Hello, World!")
type() 返回对象的类型 type(5) → <class 'int'>
int() 将对象转换为整数 int("10") → 10
str() 将对象转换为字符串 str(10) → "10"
float() 将对象转换为浮点数 float("3.14") → 3.14
list() 创建一个列表 list("abc") → ['a', 'b', 'c']
dict() 创建一个字典 dict(name="Alice", age=30)
set() 创建一个集合 set([1, 2, 3]) → {1, 2, 3}
tuple() 创建一个元组 tuple([1, 2, 3]) → (1, 2, 3)
sum() 返回序列的总和 sum([1, 2, 3]) → 6
min() 返回序列中的最小值 min([1, 2, 3]) → 1
max() 返回序列中的最大值 max([1, 2, 3]) → 3
sorted() 返回排序后的序列 sorted([3, 1, 2]) → [1, 2, 3]
reversed() 返回序列的反向迭代器 list(reversed([1, 2, 3])) → [3, 2, 1]
示例
# 使用 len() 函数
print(len("Hello"))  # 输出 5

# 使用 range() 函数
for i in range(3):
    print(i)  # 输出 0, 1, 2

# 使用 type() 函数
print(type(10))     # 输出 <class 'int'>
print(type("Hello"))# 输出 <class 'str'>
参考链接

PEP8 代码规范

PEP8 是 Python 官方的代码风格指南，建议遵循以提高代码的可读性和一致性。

主要规范

  • 缩进：使用 4 个空格进行缩进。
  • 行长度：每行不超过 79 个字符。
  • 空行：函数和类之间用两个空行分隔，类内部方法之间用一个空行分隔。
  • 命名规范：
    • 变量名和函数名使用小写字母，单词间用下划线分隔（snake_case）。
    • 类名使用首字母大写的单词组合（PascalCase）。
    • 常量名使用全部大写字母，单词间用下划线分隔（UPPER_CASE）。
示例
# 变量名和函数名
def calculate_area(radius):
    pi = 3.14159
    return pi * radius ** 2

# 类名
class Circle:
    def __init__(self, radius):
        self.radius = radius

# 常量名
MAX_SIZE = 100
参考链接

命名空间

命名空间是一个映射，包含变量名到对象的映射。不同的命名空间隔离，避免命名冲突。

局部命名空间

函数内部的命名空间，包含函数的参数和局部变量。

示例
def func():
    x = 10  # 局部变量
    print(x)

func()
print(x)  # NameError: name 'x' is not defined

全局命名空间

模块级别的命名空间，包含全局变量和函数。

示例
x = 20  # 全局变量

def func():
    print(x)

func()  # 输出 20
print(x)  # 输出 20

内置命名空间

包含 Python 内置函数和异常，如 print()、len()、Exception 等。

示例
print(len("Hello"))  # 使用内置函数 len()
参考链接

参考资料

无评论
回到顶部