当前位置：首页 > news >正文

Python 进阶部分详细整理

news 文章来源：https://blog.csdn.net/GDHBFTGGG/article/details/142733894 2025/5/15 9:49:01

1. 面向对象编程（OOP）

面向对象编程 (OOP) 是一种通过将程序中的数据和功能封装为对象的编程范式。OOP 基于四个核心概念：类与对象、继承、封装与多态。

类与对象

类（Class）：类是创建对象的蓝图或模板。它定义了对象的属性和方法。在 Python 中，使用 class 关键字定义一个类。
```
class Dog:def __init__(self, name, breed):  # 构造函数self.name = name  # 实例属性self.breed = breed
```
- __init__() 是类的构造函数，用于初始化对象。在创建对象时，__init__() 自动被调用。
对象（Object）：对象是类的实例，类定义了对象的属性和行为，每个对象是独立的。
```
my_dog = Dog("Buddy", "Golden Retriever")  # 创建对象
```

类的属性与方法

实例属性：每个对象独立拥有的属性，通过 self 引用。

类属性：所有对象共享的属性，定义在类级别。

class Dog:species = 'Canine'  # 类属性
def __init__(self, name, breed):self.name = name  # 实例属性

实例方法：操作对象数据的方法，定义在类中，并使用 self 参数访问对象的属性和其他方法。
类方法（@classmethod）：通过 @classmethod 修饰的类方法，使用 cls 访问类属性，能作用于类本身而不是具体对象。
```
@classmethod
def set_species(cls, new_species):cls.species = new_species
```
静态方法（@staticmethod）：不需要访问实例属性或类属性，使用 @staticmethod 修饰。
```
@staticmethod
def bark():print("Woof!")
```

继承

单继承：一个子类继承一个父类，子类继承父类的属性和方法。

class Animal:def __init__(self, name):self.name = name
def speak(self):return "Animal sound"

class Dog(Animal):  # Dog 继承自 Animaldef speak(self):return "Woof!"

多继承：一个子类可以继承多个父类。Python 允许多继承，但需要小心处理父类方法的冲突。
super()：用于在子类中调用父类的方法，特别是在构造函数中，可以避免手动调用父类。
```
class Puppy(Dog):def __init__(self, name, breed):super().__init__(name, breed)  # 调用父类构造函数
```

封装、继承与多态

封装：将数据（属性）和操作数据的代码（方法）打包在一起，并通过控制访问权限（如私有和公有属性）来保护数据。
继承：子类继承父类的属性和方法，从而实现代码复用。
多态：不同类的对象可以以相同的接口使用。例如，Dog 和 Cat 类都可以有 speak() 方法，尽管它们的实现不同，Python 中可以调用相同的接口。

特殊方法

Python 中有一些双下划线开头和结尾的特殊方法（又称为魔术方法），这些方法可以为类实现特定的行为。

__str__()：定义对象的可打印字符串表示。

def __str__(self):return f"Dog({self.name}, {self.breed})"

__repr__()：返回对象的官方字符串表示，通常用于调试。
__len__()：使类可以使用 len() 函数。
__eq__()：使类支持 == 运算符，用于对象比较。

2. 生成器与迭代器

迭代器

迭代器（Iterator）：迭代器是实现了 __iter__() 和 __next__() 方法的对象。__iter__() 返回迭代器对象本身，__next__() 返回容器的下一个元素，当没有元素时，抛出 StopIteration。

class MyIterator:def __init__(self, limit):self.limit = limitself.count = 0
def __iter__(self):return self
def __next__(self):if self.count < self.limit:self.count += 1return self.countelse:raise StopIteration

使用 iter() 和 next()：iter() 将对象转换为迭代器，next() 获取下一个值。
```
it = iter(MyIterator(5))
print(next(it))  # 输出 1
```

生成器

生成器函数：生成器函数使用 yield 而不是 return 返回值。生成器每次被调用时都会返回一个值，保持其状态（即函数内的局部变量在多次调用中不会被重置）。生成器是一种懒惰求值的方式，只有在需要的时候才生成值，适合处理大量数据。
```
def countdown(n):while n > 0:yield nn -= 1
```
生成器表达式：生成器表达式是类似列表推导式的语法，但它不会一次性生成所有元素，而是逐步生成，节省内存。
```
gen_exp = (x * x for x in range(10))  # 生成器表达式
```

通过生成器，我们可以处理大数据集，而不会耗尽内存。例如，处理一大段日志文件时可以使用生成器按行读取。

3. 装饰器

函数装饰器

装饰器是一种设计模式，用来在不修改函数定义的情况下，动态地为函数增加功能。在 Python 中，可以使用 @ 符号来应用装饰器。装饰器本质上是一个函数，它接收另一个函数作为参数，并返回一个新函数。

示例：

def my_decorator(func):def wrapper():print("Something before the function runs")func()print("Something after the function runs")return wrapper

@my_decorator
def say_hello():print("Hello!")

say_hello()

输出：

Something before the function runs
Hello!
Something after the function runs

带参数的装饰器

带参数的装饰器比普通装饰器更加灵活。编写时需要使用三层函数：最外层接受装饰器的参数，第二层是普通装饰器，第三层是实际包装的函数。

示例：

def decorator_with_args(arg1, arg2):def decorator(func):def wrapper(*args, **kwargs):print(f"Decorator args: {arg1}, {arg2}")return func(*args, **kwargs)return wrapperreturn decorator

@decorator_with_args("Hello", "World")
def greet():print("Greetings!")

greet()

输出：

Decorator args: Hello, World
Greetings!

类装饰器

类装饰器是通过类实现的装饰器。使用 __call__() 方法，类可以像函数一样调用。类装饰器可以在装饰函数时保存更多的状态信息。

示例：

class MyDecorator:def __init__(self, func):self.func = func
def __call__(self, *args, **kwargs):print("Before the function call")result = self.func(*args, **kwargs)print("After the function call")return result

@MyDecorator
def say_hello():print("Hello!")

say_hello()

输出：

Before the function call
Hello!
After the function call

4. 异常处理

捕获异常

Python 使用 try、except 语句来捕获异常，确保程序在出现错误时不会崩溃。else 块在 try 成功时执行，finally 块无论是否发生异常都会执行。

示例：

try:num = int(input("Enter a number: "))
except ValueError:print("That's not a valid number!")
else:print(f"Number entered: {num}")
finally:print("End of program.")

try：包含可能产生异常的代码。
except：捕获特定类型的异常。
else：当没有异常时执行的代码。
finally：无论是否发生异常，都会执行的代码，通常用于清理操作。

自定义异常

可以通过继承 Exception 类自定义异常，适用于需要在程序中捕获特定错误的情况。

示例：

class MyCustomError(Exception):def __init__(self, message):self.message = message

try:raise MyCustomError("This is a custom error")
except MyCustomError as e:print(f"Caught an error: {e.message}")

断言

断言是一种检查代码状态的简单方法。当条件为 False 时，assert 会抛出 AssertionError。

示例：

x = 5
assert x > 0, "x should be greater than 0"
assert x < 10, "x should be less than 10"

5. 模块与包

模块导入

模块是包含 Python 代码的文件，通常用于组织代码结构。可以通过 import 导入模块，也可以使用 from ... import 导入特定的变量或函数。

示例：

# 导入整个模块
import math
print(math.sqrt(16))

# 导入特定函数
from math import sqrt
print(sqrt(16))

import：导入整个模块，并通过模块名访问其内容。
from ... import：直接导入模块中的特定变量或函数。

包

包是一种组织模块的方式，通过包含一个 __init__.py 文件，Python 将其目录识别为一个包。包可以包含多个模块和子包。

__init__.py 的作用：

初始化包，当包第一次被导入时执行。
定义包的公开接口。

示例：

mypackage/__init__.pymodule1.pymodule2.py
# 使用包
from mypackage import module1

常用内置模块

Python 提供了许多内置模块，涵盖了文件操作、系统功能、数学运算等常见需求。

os：与操作系统交互的模块，提供了文件、目录操作。
```
import os
print(os.getcwd())  # 获取当前工作目录
```
sys：与 Python 解释器交互的模块，提供命令行参数、系统路径等功能。
```
import sys
print(sys.version)  # 打印Python版本
```

datetime：处理日期和时间的模块。

from datetime import datetime
print(datetime.now())  # 获取当前日期和时间

random：生成随机数和随机选择的模块。

import random
print(random.randint(1, 10))  # 生成1到10之间的随机整数

math：提供基本数学函数和常量。

import math
print(math.pi)  # 输出圆周率

itertools：提供用于迭代的高效工具，例如排列、组合等。

import itertools
print(list(itertools.permutations([1, 2, 3])))  # 生成排列

6. 正则表达式

正则表达式（Regular Expressions, regex）是一种强大的字符串匹配工具，允许通过定义模式（Pattern）来进行复杂的字符串搜索、替换、分割等操作。Python 提供了 re 模块来支持正则表达式。

正则基础

模式和规则

：正则表达式是一种用来描述字符串匹配规则的特殊符号组合。常见符号包括：
- .：匹配任意一个字符（除了换行符）。
- ^：匹配字符串的开头。
- $：匹配字符串的结尾。
- *：匹配前一个字符 0 次或多次。
- +：匹配前一个字符 1 次或多次。
- ?：匹配前一个字符 0 次或 1 次。
- []：匹配括号内的任意一个字符，如 [a-z] 表示小写字母。
- |：表示“或”关系。
- \d：匹配数字。
- \w：匹配字母、数字和下划线。

常用方法

search()：在字符串中搜索符合正则表达式的内容，返回第一个匹配对象。

import re
result = re.search(r'\d+', 'There are 123 apples')
print(result.group())  # 输出 '123'

match()：从字符串开头开始匹配，如果匹配成功返回匹配对象，否则返回 None。
```
result = re.match(r'\d+', '123 apples')
print(result.group())  # 输出 '123'
```
findall()：返回字符串中所有与正则表达式匹配的部分，以列表形式返回。
```
result = re.findall(r'\d+', '123 apples, 456 oranges')
print(result)  # 输出 ['123', '456']
```

sub()：替换字符串中与正则表达式匹配的部分。

result = re.sub(r'apples', 'bananas', 'I like apples')
print(result)  # 输出 'I like bananas'

split()：根据正则表达式匹配的部分拆分字符串。

result = re.split(r'\s+', 'split by spaces')
print(result)  # 输出 ['split', 'by', 'spaces']

7. 数据结构与算法

常用数据结构

栈（Stack）：后进先出（LIFO）的数据结构，常用于递归问题。
```
stack = []
stack.append(1)  # 压栈
stack.pop()      # 出栈
```

队列（Queue）：先进先出（FIFO）的数据结构，常用于广度优先搜索。

from collections import deque
queue = deque()
queue.append(1)  # 入队
queue.popleft()  # 出队

链表（Linked List）：由节点构成的线性数据结构，每个节点包含一个数据和一个指向下一个节点的指针。
树（Tree）：一种非线性数据结构，常用于表示分层数据。二叉树是其中最常见的一种。
字典（Dictionary）：键值对（key-value）映射的数据结构。
```
dict = {'a': 1, 'b': 2}
```
集合（Set）：无序且不重复的元素集合。
```
set = {1, 2, 3}
```

常见算法

排序算法：
- 冒泡排序：两两比较并交换，时间复杂度为 O(n²)。
- 快速排序：选取一个基准值，将小于基准的放一边，大于基准的放另一边，递归进行，时间复杂度平均为 O(n log n)。
- 归并排序：分治法，将数组递归拆分再合并，时间复杂度为 O(n log n)。
搜索算法：
- 二分查找：在有序数组中查找元素，时间复杂度为 O(log n)。
- 深度优先搜索（DFS）：使用栈实现的图遍历算法。
- 广度优先搜索（BFS）：使用队列实现的图遍历算法。

时间复杂度

时间复杂度衡量算法执行时间随输入规模的增长而变化的速度。常见的时间复杂度有：

O(1)：常数时间
O(log n)：对数时间
O(n)：线性时间
O(n log n)：线性对数时间
O(n²)：平方时间

8. 并发与多线程

线程

创建线程：Python 使用 threading 模块来创建和管理线程。

import threading

def print_hello():print("Hello from thread")

thread = threading.Thread(target=print_hello)
thread.start()
thread.join()  # 等待线程结束

线程同步：使用 Lock 机制来避免多个线程同时修改共享数据，导致竞争条件问题。

lock = threading.Lock()
lock.acquire()  # 获取锁
# 执行共享资源操作
lock.release()  # 释放锁

Semaphore：控制访问共享资源的线程数量。

进程

多进程

：使用

multiprocessing

模块来创建多个进程，提供更强大的并发能力。

from multiprocessing import Process

def print_hello():print("Hello from process")

process = Process(target=print_hello)
process.start()
process.join()

协程

协程是一种轻量级的并发方式，Python 的 asyncio 模块允许编写异步协程程序，async 和 await 是协程的关键字。

示例：

import asyncio

async def say_hello():print("Hello")await asyncio.sleep(1)print("World")

asyncio.run(say_hello())

9. 网络编程

Socket编程

使用 socket 模块实现 TCP/UDP 通信。

import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('www.example.com', 80))
sock.send(b"GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n")

HTTP 请求

requests 模块是一个流行的 Python 库，用于发送 HTTP 请求。

示例：

import requests
response = requests.get('https://api.example.com/data')
print(response.json())

Flask Web 框架

Flask 是一个轻量级 Web 框架，适合快速搭建 Web 应用。

from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_world():return 'Hello, World!'

if __name__ == '__main__':app.run()

10. 数据科学与机器学习库

Numpy

Numpy 是用于多维数组处理的库，支持大量的数学运算。

示例：

import numpy as np
array = np.array([1, 2, 3])
print(np.mean(array))  # 输出 2.0

Pandas

Pandas 是用于数据处理和分析的库，主要使用 DataFrame 数据结构。

示例：

import pandas as pd
data = {'name': ['John', 'Jane'], 'age': [30, 25]}
df = pd.DataFrame(data)
print(df)

Matplotlib

Matplotlib 是用于数据可视化的库，可以创建各种图表。

示例：

import matplotlib.pyplot as plt
plt.plot([1, 2, 3], [4, 5, 6])
plt.show()

Scikit-learn

Scikit-learn 提供了常用的机器学习模型和工具，如线性回归、分类、聚类等。

示例：

from sklearn.linear_model import LinearRegression
model = LinearRegression()
model.fit([[1], [2], [3]], [1, 2, 3])
print(model.predict([[4]]))  # 输出 [4.]

11. 高级 Python 特性

上下文管理

with 语句可以确保资源的正确管理，通常用于文件操作等场景。__enter__() 和 __exit__() 方法实现上下文管理协议。

示例：

with open('file.txt', 'r') as file:content = file.read()

元类

元类是用来创建类的类，type() 是最常见的元类。可以通过元类定制类的行为。

示例：

class MyMeta(type):def __new__(cls, name, bases, dct):print(f"Creating class {name}")return super().__new__(cls, name, bases, dct)

class MyClass(metaclass=MyMeta):pass

单例模式

单例模式确保类只有一个实例，可以通过重写 __new__() 方法来实现。

示例：

class Singleton:_instance = None
def __new__(cls):if cls._instance is None:cls._instance = super().__new__(cls)return cls._instance