目录

 专栏导读 

1 python的编程方式

2 顺序编程

3 面向对象编程

4 函数式编程

5 并发编程 

 5.1 多线程编程

threading模块常用用法

1 创建线程：

2 启动线程：

 3 等待线程执行完毕：

 4 获取当前活动线程数量：

5 获取当前线程对象：

 6 设置线程名字：

7 获取线程名字：

 8 设置守护线程（在主线程退出时自动退出）：

9 线程同步 - 使用Lock：

 10 线程同步 - 使用Semaphore（信号量）：

11 线程同步 - 使用Condition： 

12 线程间通信 - 使用Queue：

5.2 多进程编程

multiprocessing 模块常用用法 

 5.3 异步编程

 asyncio 模块常用用法

---

专栏导读 

专栏订阅地址：https://blog.csdn.net/qq_35831906/category_12375510.html

   

1 python的编程方式

       Python是一种高级编程语言，具有简洁易读的语法和丰富的标准库，广泛用于多个领域，包括Web开发、数据科学、人工智能、网络编程等。Python的编程方式可以概述如下：

1. 脚本编程：Python适合用作脚本语言，能够快速编写并运行简单的脚本，处理各种任务，如文件操作、数据处理等。

2. 面向对象编程：Python支持面向对象编程，可以创建类和对象，并通过继承、封装和多态等特性实现代码的模块化和重用。

3. 函数式编程：Python支持函数式编程，可以将函数作为参数传递、返回函数，以及使用高阶函数等功能，方便实现函数的复合和抽象。

4. 异步编程：Python提供asyncio模块，支持异步编程，允许在单线程中处理多个I/O任务，提高程序的并发性能。

5. 并发编程：Python提供threading和multiprocessing模块，允许通过多线程和多进程实现并发编程，充分利用多核CPU。

6. 其他特性：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模块的一些常用用法：

1. 创建进程：使用multiprocessing.Process类可以创建一个新的进程。

2. 启动进程：调用进程对象的start()方法可以启动一个新的进程并开始执行任务。

3. 进程间通信：使用multiprocessing.Queue、multiprocessing.Pipe等类来实现多个进程之间的通信。

4. 进程池：使用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__":
    # 创建进程间通信的队列
    queue = multiprocessing.Queue()

    # 创建进程池，池中有2个进程
    pool = multiprocessing.Pool(processes=2)

    # 启动进程池中的进程，每个进程执行worker函数
    pool.apply_async(worker, ("A", queue))
    pool.apply_async(worker, ("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核心数和任务的复杂度进行调整，以充分利用系统资源。

        以上示例代码展示了进程间通信和进程池的使用，使得多个进程可以并发执行任务，并在需要时进行通信。这样可以提高程序的效率和并发处理能力。

 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模块的一些常用用法：

1. 定义异步函数：使用async def关键字来定义异步函数，这些函数可以包含await关键字来等待异步操作的完成。

2. 创建事件循环：使用asyncio.get_event_loop()来获取一个事件循环对象。

3. 运行事件循环：使用loop.run_until_complete()来运行事件循环，直到指定的异步任务完成。

4. 并发执行异步任务：使用asyncio.gather()函数可以同时运行多个异步任务，并等待它们全部完成。

5. 异步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关键字来等待异步操作的完成，以确保程序的高效性和响应性。