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 继承自 Animal def 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 = limit self.count = 0 def __iter__(self): return self def __next__(self): if self.count < self.limit: self.count += 1 return self.count else: raise StopIteration
-
使用
iter()和next()：iter()将对象转换为迭代器，next()获取下一个值。it = iter(MyIterator(5)) print(next(it)) # 输出 1
生成器
-
生成器函数：生成器函数使用
yield而不是return返回值。生成器每次被调用时都会返回一个值，保持其状态（即函数内的局部变量在多次调用中不会被重置）。生成器是一种懒惰求值的方式，只有在需要的时候才生成值，适合处理大量数据。def countdown(n): while n > 0: yield n n -= 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 wrapper
return 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__.py module1.py module2.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
扫一扫
478
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
