Day09、Python概念：并发编程、装饰器

最新推荐文章于 2023-04-24 21:39:34 发布
最新推荐文章于 2023-04-24 21:39:34 发布
阅读量172 收藏
点赞数
分类专栏： Python学习 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abele280/article/details/104447865
版权

之前学习的程序都是单步骤的，即执行完上一句才开始执行下一句，也称为单任务，单任务程序虽然简单易懂但性能低。多任务是解决这一问题引出的，它能同时让计算机执行多个任务，有着异步与高效的特点。Python中提供了threading、multiprocessing模块来实现多任务。

一、并发编程

1.概述

并发与非并发：

  • 非并发编程：程序由单个步骤序列构成；包含独立子任务的程序执行性能低
  • 并发编程：异步，高效；分解子任务、简化流程与逻辑

进程概念process：

  • 是程序的执行实例
  • 每个进程都有自己的地址空间、内存、数据栈与辅助数据

线程概念thread：

  • 在同一进程内，可被并行激活的控制流
  • 共享相同的上下文（即地址空间、数据结构）
  • 特点：
    便于信息共享和通信
    线程的访问顺序差异会导致程序结果不一致

Python GIL全局解释器锁

  • Global Interpreter Lock
  • Python代码由虚拟机（解释器主循环）控制
  • 主循环同时只能有一个控制线程执行
    这样导致Python的多线程只在IO密集型程序上有所作用，在计算密集型上只能用进程（但会消耗更多的资源）或者用底层语言编写

2.多线程（threading模块）

顺序执行一个4秒代码和2秒代码会消耗6秒时间，如下图

import time
def worker(n):
    print('函数执行开始于: {}'.format(time.ctime()))#开始当前时间
    time.sleep(n)
    print(f'函数执行结束于: {time.ctime()}')


def main():
    print(f'【主函数执行开始于: {time.ctime()}】')
    worker(4)               #运行4秒
    worker(2)               #运行2秒
    print(f'【主函数执行结束于: {time.ctime()}】')


if __name__ == '__main__':
    main()

运行结果

【主函数执行开始于: Mon Feb 24 23:43:37 2020】
函数执行开始于: Mon Feb 24 23:43:37 2020
函数执行结束于: Mon Feb 24 23:43:41 2020
函数执行开始于: Mon Feb 24 23:43:41 2020
函数执行结束于: Mon Feb 24 23:43:43 2020
【主函数执行结束于: Mon Feb 24 23:43:43 2020】

Process finished with exit code 0

3.threading模块实现多线程

构造方法1：
.Thread(target = 目标函数，args=(参数,))
其他方法：

  • .start() 启动线程
  • .join() 要求主线程等待
  • .current_thread().name 获取当前线程名称
import time
import _thread
def worker(n):
    print('函数执行开始于: {}'.format(time.ctime()))
    time.sleep(n)
    print(f'函数执行结束于: {time.ctime()}')


def main():
    print(f'【主函数执行开始于: {time.ctime()}】')
    _thread.start_new_thread(worker,(2,))
    _thread.start_new_thread(worker,(4,))
    time.sleep(4)     
    #时间间隔，4代表间隔时间，以后面这个为基准，没有这个中间就没有过程
    print(f'【主函数执行结束于: {time.ctime()}】')

运行结果（无 time.sleep(4)）

【主函数执行开始于: Tue Feb 25 22:37:37 2020】
【主函数执行结束于: Tue Feb 25 22:37:37 2020】
函数执行开始于: Tue Feb 25 22:37:37 2020函数执行开始于: Tue Feb 25 22:37:37 2020

运行结果，有 time.sleep(4)

【主函数执行开始于: Tue Feb 25 22:43:58 2020】
函数执行开始于: Tue Feb 25 22:43:58 2020
函数执行开始于: Tue Feb 25 22:43:58 2020
函数执行结束于: Tue Feb 25 22:44:00 2020
【主函数执行结束于: Tue Feb 25 22:44:02 2020】

上述代码我们发现主线程不会等待子线程运行结束，我们希望主线程等待子线程需要使用.join()方法

"""
threading.Treading()实现多线程
"""
import time
import threading
def worker(n):
    print('函数执行开始于: {}'.format(time.ctime()))
    time.sleep(n)
    print(f'函数执行结束于: {time.ctime()}')


def main():
    print(f'【主函数执行开始于: {time.ctime()}】')
    #_thread.start_new_thread(worker,(2,))
    #_thread.start_new_thread(worker,(4,))

    threads = []
    t1 = threading.Thread(target=worker, args=(4,))
    threads.append(t1)

    t2 = threading.Thread(target=worker, args=(2,))
    threads.append(t2)

    for t in threads:
        t.start()
    
    print(f'【主函数执行结束于: {time.ctime()}】')


if __name__ == '__main__':
    main()

运行结果

【主函数执行开始于: Tue Feb 25 22:59:39 2020】
函数执行开始于: Tue Feb 25 22:59:39 2020
函数执行开始于: Tue Feb 25 22:59:39 2020【主函数执行结束于: Tue Feb 25 22:59:39 2020】

函数执行结束于: Tue Feb 25 22:59:41 2020
函数执行结束于: Tue Feb 25 22:59:43 2020

import time
import threading
def worker(n):
    print('函数执行开始于: {}'.format(time.ctime()))
    time.sleep(n)
    print(f'函数执行结束于: {time.ctime()}')


def main():
    print(f'【主函数执行开始于: {time.ctime()}】')
    #_thread.start_new_thread(worker,(2,))
    #_thread.start_new_thread(worker,(4,))

    threads = []
    t1 = threading.Thread(target=worker, args=(4,))
    threads.append(t1)

    t2 = threading.Thread(target=worker, args=(2,))
    threads.append(t2)

    for t in threads:
        t.start()


    for t in threads:
        t.join()         #等待当前子线程完成

    print(f'【主函数执行结束于: {time.ctime()}】')


if __name__ == '__main__':
    main()

运行结果

【主函数执行开始于: Tue Feb 25 23:01:38 2020】
函数执行开始于: Tue Feb 25 23:01:38 2020
函数执行开始于: Tue Feb 25 23:01:38 2020
函数执行结束于: Tue Feb 25 23:01:40 2020
函数执行结束于: Tue Feb 25 23:01:42 2020
【主函数执行结束于: Tue Feb 25 23:01:42 2020】

构造方法2：

自定义Thread派生类，重新run方法逻辑（注意run方法内部将参数元组解包，详见Python基础知识学习(五)——函数）
在这里插入图片描述
当使用多线程时经常会发生多人同时使用资源而发生错乱的问题，如下图我们想让每个人按顺序放入123鸡蛋，错乱代码如下
在这里插入图片描述
想要解决这一问题最简单的方式是使用同步锁
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
创建锁：

threading.Lock()

锁方法：

.acquire() 获得锁

.release() 释放锁

锁也支持上下文操作：

with 锁:
在这里插入图片描述
在这里插入图片描述
使用上下文with的锁
在这里插入图片描述

4.队列（queue模块）

队列保证多线程环境下共享操作的顺序
队列分类：

  • 先进先出队列 Queue
  • 先进后出（栈）LifoQueue
  • 优先队列 PriorityQueue
    构造队列
  • queue.Queue（maxsize=0）

方法

  • .put(item, block=True, timeout=None) 放入数据项,timeout指定几秒超时
  • .get(block = True, timeout =None) 获取数据项
  • .Empty() 查看队列是否为空
  • .task_done() 声明当前队列任务处理完毕
  • .join() 队列所有项处理完毕前阻塞
import threading
import time
import random
import queue


def producer(date_queue):
    for i in range(5):     #每隔半秒中在队列放5个随机数
        time.sleep(0.5)
        item = random.randint(1,100)
        date_queue.put(item)
        print(f'{threading.current_thread().name}在队列中嵌入数据项:{item}')


def consumer(date_queue):
    while True:
        try:
            item = date_queue.get(timeout=3)   #3秒没有取到数据就异常
            print(f'{threading.current_thread().name}从队列中移除了数据项 {item}')
        except queue.Empty:    #空的异常就跳出程序
           break
        else:
            date_queue.task_done()   #当前处理的项处理完毕了


def main():
    q = queue.Queue()    #q是我们要接收的对象

    threads = []
    p = threading.Thread(target=producer,args=(q,))
    p.start()

    for i in range(2):
        c = threading.Thread(target=consumer,args=(q,))
        threads.append(c)

    for t in threads:  #两个都是开始执行
        t.start()

    for t in threads:  #要让主线等待当先线程完成
        t.join()

    q.join()


if __name__ == '__main__':
    main()

执行结果：

Thread-1在队列中嵌入数据项:47
Thread-2从队列中移除了数据项 47
Thread-1在队列中嵌入数据项:77
Thread-3从队列中移除了数据项 77
Thread-1在队列中嵌入数据项:94
Thread-2从队列中移除了数据项 94
Thread-1在队列中嵌入数据项:91
Thread-3从队列中移除了数据项 91
Thread-1在队列中嵌入数据项:62
Thread-2从队列中移除了数据项 62

5.多进程（multiprocessing模块）

由于Python的全局解释器锁使得多线程优化的结果非常有限，多线程仅仅适用于IO密集型的操作，对计算密集型没有太大效果。而多进程充分利用多核、多cpu的计算能力，适用于计算密集型任务。即IO密集型多考虑多线程，计算密集型多考虑多进程。

构造进程：
multiprocessing.Process(target=目标函数, args=(参数，))
方法：

  • .start() 启动线程
  • .join() 要求主进程等待
  • .current_process() 获取当前进程 进程名称 .name
import multiprocessing
import time

def func(n):
    print(f'{multiprocessing.current_process().name}执行开始于：{time.ctime()}')
    time.sleep(n)
    print(f'{multiprocessing.current_process().name}执行结束于：{time.ctime()}')


def main():
    print(f'主函数运行于:{time.ctime()}')

    processes = []
    p1 = multiprocessing.Process (target=func,args=(4,))
    processes.append(p1)

    p2 = multiprocessing.Process (target=func,args=(2,))
    processes.append(p2)

    for p in processes:
        p.start()

    for p in processes:
        p.join()

    print(f'主函数结束于:{time.ctime()}')

if __name__ == '__main__':
    main()

运行结果

主函数运行于:Thu Feb 27 01:52:33 2020
Process-1执行开始于：Thu Feb 27 01:52:33 2020
Process-2执行开始于：Thu Feb 27 01:52:33 2020
Process-2执行结束于：Thu Feb 27 01:52:35 2020
Process-1执行结束于：Thu Feb 27 01:52:37 2020
主函数结束于:Thu Feb 27 01:52:37 2020

6.进程池：

  • concurrent.futures 模块（弃用）——ThreadPoolExecutor 线程池、ProcessPoolExecutor
    进程池
  • multiprocessing模块：现在进程池已经被添加到进程模块中
  • 创建进程池 multiprocessing.Pool()
  • 创建线程池 multiprocessing.ThreadPool()
  • 阻塞方式运行 .apply(func, args)
  • 非阻塞方式运行 apply_async(func, args)
  • 关闭进程池 .close() 回收进程池 .join()
#!usr/bin/env python
# -*- coding:utf-8 _*-
"""
@author: 灰灰
@file: test07.py
@time: 2020/02/27
@desc: concurrent.futures 应用
"""
import time
import concurrent.futures

numbers = list(range(1,11))

def count(n):
    for i in range(10000000):
        i +=i
    return i * n

def worker(x):
    result = count(x)
    print(f'数字:{x}的计算结果是:{result}')


#顺序的执行
def sequential_execution():
    start_time = time.clock()
    for i in numbers:
        worker(i)
    print(f'顺序执行花费时间:{time.clock()-start_time}秒')

#线程池执行
def threading_execution():
    start_time = time.clock()
    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
        for i in numbers:
            executor.submit(worker,i)

    print(f'线性池执行花费时间:{time.clock()-start_time}秒')


#进程池执行
def process_execution():
    start_time = time.clock()

    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
        for i in numbers:
            executor.submit(worker,i)

    print(f'线性池执行花费时间:{time.clock()-start_time}秒')


if __name__ == '__main__':
    sequential_execution()
    #threading_execution()
    #process_execution()

运行结果分别
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

二、装饰器

1.概述

装饰器是用于管理和增强函数和类行为的代码。它提供一种在函数或类定义中插入自动运行代码的机制
优势：更明确的语法、更高的代码可维护性、更好的一致性

2.函数基础

在掌握装饰器之前先复习一下函数基础

2.1将函数赋给变量

将函数hello赋值给了greeting变量。调用greeting函数也就是在调用hello函数
在这里插入图片描述
在这里插入图片描述

2.2将函数作为参数传递

将函数作为参数传递给其他函数。
在这里插入图片描述
函数嵌套
greeting函数里嵌套hello函数，并返回hello函数，带()的返回会直接调用hello函数（一般不这么用），不带括号的返回需要执行时会返回函数，想要执行内部的函数需要再增加一个括号。

跨域访问
内侧函数会使用自己作用域里定义的变量
若加上nonlocal标识会使用外侧的变量 （其他标识还有global 详见python基础学习（五）函数章节）

3.装饰器

装饰器有两种方式添加

  • 函数定义装饰器
  • 类定义装饰器

函数定义装饰器
首先定义一个参数为函数的函数，并在其内部定义一个函数，调用参数函数。对参数函数的返回值进行装饰，其次，将我们定义的装饰器以@装饰器名 修饰在函数上
在这里插入图片描述
执行结果
在这里插入图片描述

装饰器的原理：将调用装饰器的函数作为参数传递给装饰器函数，在执行

在这里插入图片描述
在这里插入图片描述
类定义的装饰器：

  • 定义__init__()函数初始化类
  • 定义__call__()函数作为装饰器
    在这里插入图片描述
    执行结果：
    在这里插入图片描述

函数定义的装饰器可以用在类中的方法上
在这里插入图片描述
在这里插入图片描述
类定义的装饰器用在类定义的方法上会产生问题，这是因为类里面的self会和装饰器的self冲突，想要解决这个冲突需要别的方面的知识，所有我们在使用时最好还是使用用函数定义的装饰器
在这里插入图片描述
在这里插入图片描述
装饰器的调用顺序——就近原则
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
功能类似的装饰器我们可以在装饰器外部再嵌套一个接受参数的函数使装饰器更加灵活，注意它的返回结果。

在这里插入图片描述
使用再嵌套的装饰器
在这里插入图片描述
打印结果
在这里插入图片描述
在这里插入图片描述
打印结果
在这里插入图片描述

三、总结

在这里插入图片描述
四、作业
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

abele280
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python：并发编程、装饰器
condi1997的博客
02-22 326
今日学习 第一部分：Python 一.并发编程 1.概述： 非并发：程序由单个步骤序列构成，独立子任务的执行性能低。 并发：异步、高效，分解子任务，简化流程与逻辑。 进程process：一个程序的执行实例，有自己的地址空间、内存、数据栈及辅助数据。 线程thread：同一进程内，可被并行激活的控制流，共享相同空间地址、数据结构，但线程的访问顺序差异会导致结果不同(race condition竞赛条...
Python基础（Day 12）(并发 装饰器)
切克闹的博客
11-30 196
知识点总结： 1. 并发 2. 装饰器 并发部分 _thread 已废弃 由_thread模块构造的实例，实际为守护线程，即可能在主线程执行完之后直接被杀死。 第二个_thread对象没有打印结束。 import time import _thread def worker(n): print(f'函数开始于：{time.ctime()}') time.sleep(n)...
Python学习-Day9-并发编程、装饰器
prettygirlman的博客
04-23 152
并发编程 #single_thread import time def worker(n): print('函数执行开始于：{}'.format(time.ctime())) time.sleep(n) print(f'函数执行结束于：{time.ctime()}') def main(): print(f'【主函数执行开始于：{time.ctime()}】'...
【Python】用装饰器限制协程并发量
qq_39559879的博客
02-28 500
from functools import wraps from random import randint import asyncio from typing import Coroutine, List from asyncio import Task import nest_asyncio nest_asyncio.apply() def limit(max_coro): semphore = asyncio.Semaphore(max_coro) def _wrapper
【python装饰器：看懂这10个例子你就掌握了！】
weixin_41777118的博客
04-24 744
Python 装饰器是一种函数，它可以用来修改其他函数的功能。它是 Python 中的一项高级编程技术，也是 Python 中比较重要的语法之一。
python-Day19.rar
04-11
7. **多线程与多进程**：Python提供了`threading`和`multiprocessing`模块来实现并发编程。理解线程和进程的区别，以及在何时选择多线程或多进程，对于优化程序性能至关重要。 8. **网络编程**：Python的`socket`...
python第26天python-Day26.rar
04-23
4. **函数式编程**：Python也支持函数式编程，你可能学习了高阶函数（如`map()`、`filter()`、`reduce()`），以及装饰器（decorator）和闭包（closure）等特性。 5. **文件操作**：读写文件是常见的任务，你可能...
python-Day11.rar
04-08
10. **并发编程**：Python的`threading`和`multiprocessing`模块可以用来实现多线程或多进程，以提高程序的执行效率。 11. **单元测试**：学习如何使用`unittest`或`pytest`框架编写和运行单元测试，确保代码的正确...
python第27天python-Day27.rar
04-23
9. **并发和异步编程**：Python的`threading`和`asyncio`库可能被引入，讲解如何进行多线程或多任务处理，以提高程序执行效率。 10. **调试和测试**：学习如何使用`pdb`进行调试，以及编写单元测试和集成测试，确保...
python第14天，python-Day14-A.rar
最新发布
05-07
5. **函数式编程**：Python支持函数式编程风格，包括高阶函数（如`map()`, `filter()`, `reduce()`）、闭包、匿名函数（lambda表达式）以及函数装饰器。这部分内容可能介绍如何利用这些特性来简化代码和提高代码的...
Python高级——多线程_11_装饰器
凋落的枫叶
09-19 604
python核心编程2 流畅的python   1.闭包         特点：     1.函数嵌套定义     2.外部函数返回内部函数的引用     3.内部函数可以使用外部函数提供的自由变量/局部变量     概念：         内部函数 + 自由变量 构成的整体       修改外部函数的参数     python3：             nonlo...
python 多线程装饰器 用装饰器写一个可以用队列和多线程执行的方法，
ajiong314
07-29 1954
闲来无事写一个试试，在程序中使用还需要改一些地方地方 import threading import queue import time q = queue.Queue(maxsize=10) def create_threading(num,func,data): for i in range(num): t = threading.Thread(target=fun...
灰度共生矩阵(GLCM)
abele280的博客
04-13 6137
灰度共生矩阵(GLCM) 算法简介 灰度共生矩阵法(GLCM, Gray - level co - occurrence matrix)，就是通过计算灰度图像得到它的共生矩阵，然后透过计算该共生矩阵得到矩阵的部分特征值，来分别代表图像的某些纹理特征（纹理的定义仍是难点）。灰度共生矩阵能反映图像灰度关于方向、相邻间隔、变化幅度等综合信息，它是分析图像的局部模式和它们排列规则的基础。 （灰度共...
机器学习概念总结笔记（一）——机器学习算法分类、最小二乘回归、岭回归、LASSO回归
abele280的博客
06-19 2247
原文：https://cloud.tencent.com/community/article/137341 机器学习概念总结 1，机器学习算法分类 1）监督学习： 有train set，train set里面y的取值已知。 2）无监督学习：有train set, train set里面y的取值未知。 3）半监督学习：有train set， train set里面y的取值有些知道有些不知道。 4）增强学习：reinforcement learning， 无train set。 2，常见算法
知识点：机器学习和深度学习
abele280的博客
04-07 1481
一.AI&ML&DL 1.机器学习是一种实现人工智能的方法，深度学习受到了人工神经网络的影响，驱动了机器学习的发展，是机器学习的一个子集。 二.AL&DL的区别 1.数据量 深度学习比较适合数据量比较大的情况，而传统的机器学习的话在小数据量的情况下效果会好一点 2.硬件依赖 深度学习算法需要进行大量的矩阵运算，需要高端的硬件设备，像GPU 3.特征工程 在机器学习方法中，几...
机器学习评估指标汇总：准确率(Precision)、召回率(Recall)、F值(F-Measure)、ROC曲线、PR曲线
abele280的博客
04-13 666
摘要： 数据挖掘、机器学习和推荐系统中的评测指标—准确率(Precision)、召回率(Recall)、F值(F-Measure)简介。 引言： 在机器学习、数据挖掘、推荐系统完成建模之后，需要对模型的效果做评价。 业内目前常常采用的评价指标有**准确率(Precision)、召回率(Recall)、F值(F-Measure)**等，下图是不同机器学习算法的评价指标。下文讲对其中某些指标做简要介绍...
Day02.python概念，数据类型（数字，字符串，列表，元组，字典，文件等）
abele280的博客
02-13 657
python基础之五大标准数据类型 学习一门语言，往往都是从Hello World开始。 但是笔者认为，在一个黑框框中输出一个“你好，世界”并没有什么了不起，要看透事物的本质，熟悉一门语言，就要了解其底层，就是我们常常说的基础。本篇从python中的变量类型开始。 五大标准数据类型 在内存中存储的数据可以有多种类型。 例如， 一个人的名字可以用字符来存储， 年龄可以用数字来存储， 爱好可以用集合来...
Day03.python概念：语句，表达式与if、while、for循环分支、迭代
abele280的博客
02-15 461
1.代码风格 Python的格式规范——PEP8 主要规范： 注意缩进，不能把tab键与四个空格连用，最好使用四个空格 一行不超过79个字符（直接换行即可） 函数与函数之间空两行 2.赋值语句 基本赋值：= 序列赋值： x,y = 5,10 x,y,z = 10,20,30 #Python交换两个值 x,y = y,x # 拆包------>结果 a='l' b ='i' c='k' 注:...
Python编程：关键英语词汇一览
本文主要介绍了Python编程中常用的英文单词和概念，涵盖了从基本的交互式环境、字符串操作到更复杂的集合、字典等数据结构的相关术语。 在Python编程中，`print`是用于输出信息的基本命令，而`coding`则指的是编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值