1. 列表推导式
Python中的列表推导式是一个非常强大的功能，它允许你以一种简洁的方式创建列表。以下是一个使用列表推导式来生成一个列表中所有偶数的例子：
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = [num for num in numbers if num % 2 == 0]
print(even_numbers) # 输出: [2, 4, 6, 8, 10]
2. 函数装饰器
函数装饰器是Python中的一个高级特性，它允许你在不修改函数内部代码的情况下增加新的功能。以下是一个简单的装饰器，用于打印函数开始和结束的信息：
def my_decorator(func):
def wrapper():
print("Function is starting")
func()
print("Function is ending")
return wrapper
@my_decorator
def say_hello():
print("Hello, world!")
say_hello()
3. 生成器
生成器是一种特殊的迭代器，它在每次迭代时只产生一个值。以下是一个生成器函数的例子，它用于计算斐波那契数列：
def fibonacci():
a, b = 0, 1
while True:
yield a
a, b = b, a + b
fib = fibonacci()
for _ in range(10):
print(next(fib))
4. 类和对象
在Python中，类是创建对象的蓝图。以下是一个简单的类定义，它创建了一个有属性和方法的对象：
class Dog:
def __init__(self, name, age):
self.name = name
self.age = age
def bark(self):
print(f"{self.name} says: Woof!")
my_dog = Dog("Buddy", 5)
my_dog.bark()
5. 模块和包
模块是Python代码文件，它们可以包含函数、类和变量。以下是一个简单的模块示例：
# my_module.py
def greet():
print("Hello from my_module!")
在另一个Python文件中，你可以导入并使用这个模块：
import my_module
my_module.greet()
6. 异常处理
异常处理是Python中用来处理错误的一种机制。以下是一个使用try和except语句来处理除以零错误的例子：
try:
result = 10 / 0
except ZeroDivisionError:
print("Cannot divide by zero!")
7. 上下文管理器
上下文管理器允许你使用with语句来设置和清理代码块。以下是一个使用上下文管理器来打开和关闭文件的例子：
with open('example.txt', 'w') as file:
file.write("Hello, world!")
8. 多线程和多进程
Python提供了threading和multiprocessing模块来处理并发。以下是一个使用threading模块创建并启动线程的例子：
import threading
def print_numbers():
for i in range(5):
print(i)
thread = threading.Thread(target=print_numbers)
thread.start()
thread.join()
9. 数据可视化
Python有许多库，如Matplotlib和Seaborn，可以用于数据可视化。以下是一个使用Matplotlib绘制折线图的例子：
import matplotlib.pyplot as plt
x = [1, 2, 3, 4, 5]
y = [2, 3, 5, 7, 11]
plt.plot(x, y)
plt.show()
10. Web开发
Python中的Flask和Django是两个流行的Web框架。以下是一个使用Flask创建简单Web服务器的例子：
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'Hello, World!'
if __name__ == '__main__':
app.run()
11. 文件操作
Python提供了丰富的文件操作功能。以下是一个读取和写入文件的例子：
# 写入文件
with open('example.txt', 'w') as file:
file.write("Hello, world!")
# 读取文件
with open('example.txt', 'r') as file:
content = file.read()
print(content)
12. 正则表达式
Python的re模块提供了对正则表达式的支持。以下是一个使用正则表达式匹配电子邮件地址的例子：
import re
email = "example@example.com"
pattern = r"[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+"
if re.match(pattern, email):
print("Valid email")
else:
print("Invalid email")
13. 数据库操作
Python中的sqlite3模块可以用来操作SQLite数据库。以下是一个简单的例子，它创建一个数据库并插入一些数据：
import sqlite3
# 创建数据库连接
conn = sqlite3.connect('example.db')
# 创建表
conn.execute('''CREATE TABLE IF NOT EXISTS users
(id INTEGER PRIMARY KEY, name TEXT, age INTEGER)''')
# 插入数据
conn.execute("INSERT INTO users (name, age) VALUES ('John', 30)")
conn.commit()
# 查询数据
cursor = conn.execute("SELECT * FROM users")
for row in cursor:
print(row)
# 关闭数据库连接
conn.close()
14. 装饰器工厂
装饰器工厂是一个返回装饰器的函数。以下是一个装饰器工厂的例子：
def make_decorator(decorator_func):
def decorator_factory(*args, **kwargs):
def decorator(func):
return decorator_func(func, *args, **kwargs)
return decorator
return decorator_factory
@make_decorator
def my_decorator(func):
def wrapper():
print("Function is starting")
func()
print("Function is ending")
return wrapper
@my_decorator
def say_hello():
print("Hello, world!")
say_hello()
15. 闭包
闭包是一个函数，它记住并访问了创建它的作用域中的变量。以下是一个闭包的例子：
def outer_function(x):
def inner_function(y):
return x + y
return inner_function
add_five = outer_function(5)
print(add_five(10)) # 输出: 15
16. 高阶函数
高阶函数是接受函数作为参数或返回函数的函数。以下是一个高阶函数的例子：
def add(a, b):
return a + b
def higher_order_function(func, x, y):
return func(x, y)
print(higher_order_function(add, 3, 4)) # 输出: 7
17. 生成器表达式
生成器表达式是生成器的另一种形式，它使用圆括号而不是方括号。以下是一个生成器表达式的例子：
numbers = (x for x in range(10))
for num in numbers:
print(num)
18. 迭代器和迭代器协议
迭代器是一个可以记住其遍历的位置的对象。以下是一个自定义迭代器的例子：
class MyIterator:
def __init__(self, data):
self.data = data
self.index = 0
def __iter__(self):
return self
def __next__(self):
if self.index >= len(self.data):
raise StopIteration
value = self.data[self.index]
self.index += 1
return value
my_iter = MyIterator([1, 2, 3, 4, 5])
for item in my_iter:
print(item)
19. 反射
反射是一种在运行时检查和修改程序的能力。以下是一个使用getattr和setattr函数进行反射的例子：
class MyClass:
def __init__(self):
self.my_attribute = "Hello"
my_instance = MyClass()
print(getattr(my_instance, 'my_attribute')) # 输出: Hello
setattr(my_instance, 'my_attribute', 'World')
print(getattr(my_instance, 'my_attribute')) # 输出: World
20. 深拷贝和浅拷贝
在Python中，拷贝可以分为深拷贝和浅拷贝。深拷贝会复制对象及其所有子对象，而浅拷贝只会复制对象本身。以下是一个深拷贝和浅拷贝的例子：
import copy
list1 = [1, 2, [3, 4]]
list2 = copy.deepcopy(list1)
list2[2][0] = 99
print(list1) # 输出: [1, 2, [3, 4]]
print(list2) # 输出: [1, 2, [99, 4]]
21. 多态
多态是指同一个操作作用于不同的对象时可以有不同的解释，产生不同的执行结果。以下是一个多态的例子：
class Animal:
def sound(self):
pass
class Dog(Animal):
def sound(self):
print("Woof!")
class Cat(Animal):
def sound(self):
print("Meow!")
dog = Dog()
cat = Cat()
dog.sound()
cat.sound()
22. 单例模式
单例模式是一种设计模式，它确保一个类只有一个实例，并提供一个全局访问点。以下是一个单例模式的例子：
class Singleton:
_instance = None
@classmethod
def get_instance(cls):
if cls._instance is None:
cls._instance = cls()
return cls._instance
singleton1 = Singleton.get_instance()
singleton2 = Singleton.get_instance()
print(singleton1 is singleton2) # 输出: True
23. 观察者模式
观察者模式是一种设计模式，它定义了对象之间的一对多依赖关系，当一个对象改变状态时，所有依赖于它的对象都会得到通知并自动更新。以下是一个观察者模式的例子：
class Subject:
def __init__(self):
self._observers = []
def register(self, observer):
self._observers.append(observer)
def notify(self):
for observer in self._observers:
observer.update()
class Observer:
def update(self):
pass
class ConcreteObserver(Observer):
def update(self):
print("Observer received notification!")
subject = Subject()
observer = ConcreteObserver()
subject.register(observer)
subject.notify()
24. 状态模式
状态模式是一种设计模式，它允许一个对象在其内部状态改变时改变它的行为。以下是一个状态模式的例子：
class Context:
def __init__(self, state):
self._state = state
def set_state(self, state):
self._state = state
def get_state(self):
return self._state
class StateA:
def do_something(self):
print("State A")
class StateB:
def do_something(self):
print("State B")
context = Context(StateA())
context.do_something()
context.set_state(StateB())
context.do_something()
25. 访问者模式
访问者模式是一种设计模式，它允许你添加新的操作到现有对象结构中，而不需要修改这些对象的类。以下是一个访问者模式的例子：
class Element:
def accept(self, visitor):
pass
class ConcreteElementA(Element):
def accept(self, visitor):
visitor.visit_concrete_element_a(self)
class ConcreteElementB(Element):
def accept(self, visitor):
visitor.visit_concrete_element_b(self)
class Visitor:
def visit_concrete_element_a(self, element):
pass
def visit_concrete_element_b(self, element):
pass
visitor = Visitor()
element_a = ConcreteElementA()
element_b = ConcreteElementB()
visitor.visit_concrete_element_a(element_a)
visitor.visit_concrete_element_b(element_b)
26. 策略模式
策略模式是一种设计模式，它定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。以下是一个策略模式的例子：
class Strategy:
def do_algorithm(self):
pass
class ConcreteStrategyA(Strategy):
def do_algorithm(self):
print("Algorithm A")
class ConcreteStrategyB(Strategy):
def do_algorithm(self):
print("Algorithm B")
class Context:
def __init__(self, strategy):
self._strategy = strategy
def set_strategy(self, strategy):
self._strategy = strategy
def execute_strategy(self):
self._strategy.do_algorithm()
context = Context(ConcreteStrategyA())
context.execute_strategy()
context.set_strategy(ConcreteStrategyB())
context.execute_strategy()
27. 模板方法模式
模板方法模式是一种行为型设计模式，它定义了一个操作中的算法的骨架，将一些步骤延迟到子类中。以下是一个模板方法模式的例子：
class TemplateMethod:
def template_method(self):
self.hook()
self.step1()
self.step2()
self.step3()
def hook(self):
pass
def step1(self):
pass
def step2(self):
pass
def step3(self):
pass
class ConcreteTemplateMethod(TemplateMethod):
def step1(self):
print("Step 1")
def step2(self):
print("Step 2")
def step3(self):
print("Step 3")
template_method = ConcreteTemplateMethod()
template_method.template_method()
28. 命令模式
命令模式是一种行为型设计模式，它将请求封装为一个对象，从而允许用户使用不同的请求、队列或日志请求来参数化其他对象。以下是一个命令模式的例子：
class Command:
def execute(self):
pass
class ConcreteCommandA(Command):
def execute(self):
print("ConcreteCommandA execute")
class ConcreteCommandB(Command):
def execute(self):
print("ConcreteCommandB execute")
class Invoker:
def __init__(self):
self._commands = []
def store_command(self, command):
self._commands.append(command)
def execute_commands(self):
for command in self._commands:
command.execute()
invoker = Invoker()
invoker.store_command(ConcreteCommandA())
invoker.store_command(ConcreteCommandB())
invoker.execute_commands()
29. 中介者模式
中介者模式是一种行为型设计模式，它通过一个中介对象来封装一系列的对象交互。以下是一个中介者模式的例子：
class Mediator:
def __init__(self):
self._components = []
def add_component(self, component):
self._components.append(component)
def notify(self, sender, event):
for component in self._components:
if component != sender:
component.receive(event)
class Component:
def __init__(self, mediator):
self._mediator = mediator
def send(self, event):
self._mediator.notify(self, event)
def receive(self, event):
pass
mediator = Mediator()
component_a = Component(mediator)
component_b = Component(mediator)
component_a.send("Event A")
component_b.receive("Event A")
30. 迭代器模式
迭代器模式是一种行为型设计模式，它允许你遍历一个聚合对象中各个元素，而无需暴露其内部的表示。以下是一个迭代器模式的例子：
class Iterator:
def __init__(self, collection):
self._collection = collection
self._index = 0
def __iter__(self):
return self
def __next__(self):
if self._index >= len(self._collection):
raise StopIteration
value = self._collection[self._index]
self._index += 1
return value
class ConcreteIterator(Iterator):
def __init__(self, collection):
super().__init__(collection)
class Aggregate:
def __init__(self):
self._collection = []
def add(self, item):
self._collection.append(item)
def create_iterator(self):
return ConcreteIterator(self._collection)
aggregate = Aggregate()
aggregate.add(1)
aggregate.add(2)
aggregate.add(3)
iterator = aggregate.create_iterator()
for item in iterator:
print(item)
31. 延迟加载
延迟加载是一种设计模式，它将对象的创建延迟到真正需要它的时候。以下是一个延迟加载的例子：
class LazyObject:
def __init__(self):
self._value = None
def get_value(self):
if self._value is None:
self._value = self._load_value()
return self._value
def _load_value(self):
# 模拟加载过程
print("Loading value...")
return 42
lazy_object = LazyObject()
print(lazy_object.get_value())
32. 代理模式
代理模式是一种结构型设计模式，它为其他对象提供一个代理以控制对这个对象的访问。以下是一个代理模式的例子：
class Proxy:
def __init__(self, target):
self._target = target
def request(self):
return self._target.request()
class RealSubject:
def request(self):
print("RealSubject request")
class ProxySubject(Proxy):
def request(self):
print("ProxySubject request")
return super().request()
real_subject = RealSubject()
proxy_subject = ProxySubject(real_subject)
real_subject.request()
proxy_subject.request()
33. 装饰者模式
装饰者模式是一种结构型设计模式，它允许你动态地向对象添加额外的职责，而不改变其接口。以下是一个装饰者模式的例子：
class Decorator:
def __init__(self, component):
self._component = component
def operation(self):
return self._component.operation()
class Component:
def operation(self):
pass
class ConcreteDecoratorA(Decorator):
def operation(self):
return f"ConcreteDecoratorA({super().operation()})"
class ConcreteDecoratorB(Decorator):
def operation(self):
return f"ConcreteDecoratorB({super().operation()})"
component = Component()
decorator_a = ConcreteDecoratorA(component)
decorator_b = ConcreteDecoratorB(decorator_a)
print(component.operation())
print(decorator_a.operation())
print(decorator_b.operation())
34. 适配器模式
适配器模式是一种结构型设计模式，它允许将一个类的接口转换成客户期望的另一个接口。以下是一个适配器模式的例子：
”`python class Target:
def request(self):
pass
class Adapter(Target):
def __init__(self