目录
专栏导读
专栏订阅地址：https://blog.csdn.net/qq_35831906/category_12375510.html
1 python的编程方式
Python是一种高级编程语言，具有简洁易读的语法和丰富的标准库，广泛用于多个领域，包括Web开发、数据科学、人工智能、网络编程等。Python的编程方式可以概述如下：
脚本编程：Python适合用作脚本语言，能够快速编写并运行简单的脚本，处理各种任务，如文件操作、数据处理等。
面向对象编程：Python支持面向对象编程，可以创建类和对象，并通过继承、封装和多态等特性实现代码的模块化和重用。
函数式编程：Python支持函数式编程，可以将函数作为参数传递、返回函数，以及使用高阶函数等功能，方便实现函数的复合和抽象。
异步编程：Python提供
asyncio模块，支持异步编程，允许在单线程中处理多个I/O任务，提高程序的并发性能。并发编程：Python提供
threading和multiprocessing模块，允许通过多线程和多进程实现并发编程，充分利用多核CPU。其他特性：Python还具有列表推导、生成器表达式、装饰器等特性，使得代码更加简洁、高效。
总体而言，Python的编程方式简单灵活，适合快速开发，适用于各种规模的项目，成为了许多开发者和科学家的首选语言。
2 顺序编程
顺序编程是指按照代码的书写顺序依次执行程序，从上到下逐行执行代码。这是最简单、最基本的编程方式，适用于简单的任务和小规模的程序。
示例：
# 顺序编程示例
def add(a, b):
return a + b
def multiply(a, b):
return a * b
x = 5
y = 10
result1 = add(x, y)
result2 = multiply(x, y)
print("Result of addition:", result1)
print("Result of multiplication:", result2)
3 面向对象编程
面向对象编程是一种编程范式，通过创建类和对象来表示真实世界的事物和关系。在面向对象编程中，数据和功能被组织成对象，并通过类定义属性和方法。
示例：
# 面向对象编程示例
class Rectangle:
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
def perimeter(self):
return 2 * (self.width + self.height)
rect = Rectangle(5, 10)
print("Area:", rect.area())
print("Perimeter:", rect.perimeter())
4 函数式编程
函数式编程是一种编程范式，将计算视为数学函数的应用，强调函数的纯粹性和不可变性。在函数式编程中，函数可以作为参数传递给其他函数，也可以返回其他函数。
示例：
# 函数式编程示例
def add(a, b):
return a + b
def multiply(a, b):
return a * b
def apply_operation(operation, a, b):
return operation(a, b)
x = 5
y = 10
result1 = apply_operation(add, x, y)
result2 = apply_operation(multiply, x, y)
print("Result of addition:", result1)
print("Result of multiplication:", result2)
5 并发编程
并发编程是指同时执行多个任务或处理多个操作的编程方式，它可以提高程序的执行效率和响应性。Python提供了多种并发编程的方式，包括多线程、多进程和异步编程。
5.1 多线程编程
多线程是一种并发编程的方式，它允许程序同时执行多个线程，每个线程处理一个独立的任务。Python的threading模块提供了多线程的支持。
示例：
import threading
import time
def print_numbers():
for i in range(1, 6):
print(i)
time.sleep(1)
def print_letters():
for letter in 'ABCDE':
print(letter)
time.sleep(1)
if __name__ == "__main__":
# 创建两个线程
thread1 = threading.Thread(target=print_numbers)
thread2 = threading.Thread(target=print_letters)
# 启动线程
thread1.start()
thread2.start()
# 等待两个线程执行完成
thread1.join()
thread2.join()
print("All threads have finished.")
在上面的示例中，我们定义了两个函数
print_numbers和print_letters，分别用于打印数字和字母。然后，我们创建了两个线程thread1和thread2，并将这两个函数作为线程的执行目标。通过调用start方法启动线程，它们会并发执行。最后，我们使用join方法等待两个线程执行完成，然后输出”All threads have finished.”。需要注意的是，由于Python的全局解释器锁（Global Interpreter Lock，GIL），多线程并不能发挥真正的并行执行能力，适合在IO密集型任务中使用，如网络请求、文件读写等。对于CPU密集型任务，建议使用多进程编程，即使用
multiprocessing模块来实现。
threading模块常用用法
threading模块是Python中用于多线程编程的标准库，它提供了创建和管理线程的类和函数。
1 创建线程：
import threading
def my_function():
# 任务代码
my_thread = threading.Thread(target=my_function)
2 启动线程：
my_thread.start()
3 等待线程执行完毕：
my_thread.join()
4 获取当前活动线程数量：
threading.active_count()
5 获取当前线程对象：
threading.current_thread()
6 设置线程名字：
my_thread = threading.Thread(target=my_function, name="MyThread")
7 获取线程名字：
my_thread.getName()
8 设置守护线程（在主线程退出时自动退出）：
my_thread.daemon = True
9 线程同步 – 使用Lock：
lock = threading.Lock()
def my_function():
lock.acquire()
# 临界区代码
lock.release()
10 线程同步 – 使用Semaphore（信号量）：
semaphore = threading.Semaphore(2) # 限制同时执行的线程数为2
def my_function():
semaphore.acquire()
# 临界区代码
semaphore.release()
11 线程同步 – 使用Condition：
condition = threading.Condition()
def producer():
with condition:
# 生产者代码
condition.notify() # 通知消费者
def consumer():
with condition:
condition.wait() # 等待生产者通知
# 消费者代码
12 线程间通信 – 使用Queue：
import queue
my_queue = queue.Queue()
def producer():
my_queue.put("hello")
def consumer():
data = my_queue.get()
print(data)
注意：由于Python中的全局解释器锁（GIL），多线程并不能发挥真正的并行执行能力。对于CPU密集型任务，建议使用多进程编程（
multiprocessing模块）。对于IO密集型任务，多线程是一个不错的选择，可以在IO等待时切换到其他线程，提高程序的响应性。
5.2 多进程编程
多进程是一种并发编程的方式，它允许程序同时执行多个进程，每个进程运行在独立的内存空间中。Python的multiprocessing模块提供了多进程的支持。
multiprocessing 模块常用用法
multiprocessing是Python标准库中用于实现多进程并发编程的模块。它提供了类似于threading模块的接口，但是可以在多个进程中并行执行任务，从而充分利用多核CPU的优势。以下是multiprocessing模块的一些常用用法：
创建进程：使用
multiprocessing.Process类可以创建一个新的进程。启动进程：调用进程对象的
start()方法可以启动一个新的进程并开始执行任务。进程间通信：使用
multiprocessing.Queue、multiprocessing.Pipe等类来实现多个进程之间的通信。进程池：使用
multiprocessing.Pool类可以创建一个进程池，可以方便地进行进程复用和任务调度。
下面是一个简单的示例，演示了如何使用multiprocessing模块来实现多进程并发编程：
import multiprocessing
import time
def worker(name):
print(f"Worker {name} started")
time.sleep(2)
print(f"Worker {name} finished")
if __name__ == "__main__":
# 创建两个新进程
p1 = multiprocessing.Process(target=worker, args=("A",))
p2 = multiprocessing.Process(target=worker, args=("B",))
# 启动进程
p1.start()
p2.start()
# 等待两个进程结束
p1.join()
p2.join()
print("All processes finished")
输出：
在上面的示例中，我们定义了一个
worker函数，用于模拟每个进程执行的任务。然后使用multiprocessing.Process类创建两个新的进程，并分别启动它们。最后，使用join()方法等待两个进程结束，并在所有进程完成后输出”All processes finished”。需要注意的是，在使用
multiprocessing模块时，要确保主程序的代码放在if __name__ == "__main__":语句块中，以避免在子进程中重复执行主程序的代码。同时，multiprocessing模块在Windows系统下使用时，需要在if __name__ == "__main__":语句块中创建进程，以防止进程无限递归。
在上面的示例代码中，我们没有涉及进程间通信和进程池的用法。下面我们将完善示例代码，包含进程间通信和进程池的使用：
import multiprocessing
import time
def worker(name, queue):
print(f"Worker {name} started")
time.sleep(2)
queue.put(f"Result from worker {name}")
if __name__ == "__main__":
multiprocessing.set_start_method('spawn')
multiprocessing.freeze_support()
# 创建进程间通信的队列
manager = multiprocessing.Manager()
queue = manager.Queue()
# 创建进程池，池中有2个进程
pool = multiprocessing.Pool(processes=2)
# 启动进程池中的进程，每个进程执行worker函数，并使用 apply 方法改为阻塞方式
pool.apply(worker, args=("A", queue))
pool.apply(worker, args=("B", queue))
# 关闭进程池，不再接受新的任务
pool.close()
# 等待所有进程完成
pool.join()
# 从队列中获取进程的结果
results = []
while not queue.empty():
results.append(queue.get())
print("All processes finished")
print("Results:", results)
输出：
在上面的示例代码中，我们使用
multiprocessing.Queue实现了进程间的通信。每个子进程在完成任务后，会将结果放入队列中，主进程再从队列中获取这些结果。同时，我们使用multiprocessing.Pool创建了一个包含两个进程的进程池，并通过apply_async方法向进程池中提交任务。需要注意的是，进程池的大小可以根据系统的CPU核心数和任务的复杂度进行调整，以充分利用系统资源。
以上示例代码展示了进程间通信和进程池的使用，使得多个进程可以并发执行任务，并在需要时进行通信。这样可以提高程序的效率和并发处理能力。
注意：
在 Windows 上，为了让
multiprocessing正常工作，需要在创建进程前添加multiprocessing.set_start_method('spawn')和multiprocessing.freeze_support()代码，这样可以确保进程间通信的正常执行。另外，请注意，有些 IDE（如IDLE等）对于多进程的输出支持不够友好，有时无法显示子进程的输出。您可以尝试在命令行中运行代码，看看是否能够正常输出。
如果在命令行中运行仍然没有输出，可能存在其他问题，比如与操作系统或Python环境有关的问题。您可以尝试在不同的环境中运行代码，或者检查是否有其他异常出现。
5.3 异步编程
异步编程是一种并发编程的方式，它允许程序在执行耗时操作时，不会阻塞其他任务的执行，从而提高程序的性能和响应性。在Python中，异步编程通常使用asyncio模块来实现。
异步编程的关键是使用”async"和”await"关键字来定义异步函数和执行异步操作。异步函数可以通过”async def"关键字来定义，而在异步函数内部，可以使用”await"关键字来等待异步操作的完成。
import asyncio
async def foo():
print("Start foo")
await asyncio.sleep(2)
print("End foo")
async def bar():
print("Start bar")
await asyncio.sleep(1)
print("End bar")
# 创建一个事件循环
loop = asyncio.get_event_loop()
# 执行异步任务
loop.run_until_complete(asyncio.gather(foo(), bar()))
# 关闭事件循环
loop.close()
在上面的示例中，我们定义了两个异步函数
foo和bar，分别模拟了耗时的任务。在主程序中，我们使用asyncio.gather函数来同时运行这两个异步任务，并使用loop.run_until_complete来运行事件循环，直到所有异步任务完成。异步编程在处理IO密集型任务时特别有用，例如网络请求、文件读写等。通过使用异步编程，我们可以在等待IO操作的同时继续执行其他任务，从而提高程序的效率。
需要注意的是，在异步编程中，不能在普通的同步函数内调用异步函数，而只能在其他异步函数内调用。另外，要确保所有的异步操作都是非阻塞的，否则可能会导致整个程序的阻塞。
总的来说，异步编程是一种强大的并发编程方式，可以显著提高程序的性能和响应性。但它也需要仔细设计和考虑，以确保正确处理异步操作和避免潜在的并发问题。
asyncio 模块常用用法
asyncio是Python标准库中提供的异步编程模块，用于编写异步代码和管理事件循环。它提供了一组用于定义异步函数和处理异步任务的工具。以下是asyncio模块的一些常用用法：
定义异步函数：使用
async def关键字来定义异步函数，这些函数可以包含await关键字来等待异步操作的完成。创建事件循环：使用
asyncio.get_event_loop()来获取一个事件循环对象。运行事件循环：使用
loop.run_until_complete()来运行事件循环，直到指定的异步任务完成。并发执行异步任务：使用
asyncio.gather()函数可以同时运行多个异步任务，并等待它们全部完成。异步IO操作：使用
asyncio提供的异步IO函数，例如asyncio.open()和asyncio.write()，来执行非阻塞的IO操作。
下面是一个简单的示例，演示了如何使用asyncio模块来并发执行异步任务：
import asyncio
async def foo():
print("Start foo")
await asyncio.sleep(2)
print("End foo")
async def bar():
print("Start bar")
await asyncio.sleep(1)
print("End bar")
async def main():
# 并发执行foo和bar函数
await asyncio.gather(foo(), bar())
# 创建一个事件循环
loop = asyncio.get_event_loop()
# 运行事件循环，直到main函数完成
loop.run_until_complete(main())
# 关闭事件循环
loop.close()
在上面的示例中，我们定义了两个异步函数
foo和bar，然后在main函数中使用asyncio.gather()函数同时运行这两个异步函数。最后，通过事件循环的run_until_complete()方法运行main函数，直到所有异步任务完成。需要注意的是，在使用
asyncio进行异步编程时，要避免在同步代码中调用异步函数，否则可能会导致阻塞。尽量在异步环境中使用await关键字来等待异步操作的完成，以确保程序的高效性和响应性。
文章出处登录后可见！
