Python基础知识（十一）

最新推荐文章于 2024-07-12 15:30:14 发布
最新推荐文章于 2024-07-12 15:30:14 发布
阅读量316 收藏
点赞数
分类专栏： python 文章标签： Python基础知识（十一）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41511262/article/details/100996614
版权

文章目录

Python基础知识（十一）

一、并发进程

（一）概述

  非并发程序：程序由单个步骤序列构成
                        包含独立子任务的程序执行性能低
  并发：异步、高效
             分解子任务、简化流程与逻辑
  进程process 一个程序的执行实例
                       每个进程有自己的地址空间、内存、数据栈及辅助数据
  线程hread  同一个线程内，可被并行激活的控制流
                      共享相同上下文（空间地址、数据结构）
                      特点： 便于信息共享和通信
                                 线程访问顺序差异会导致结果不一致（条件 race  condition）
  Python GIL 全局解释器  Global   Interpreter  Lock
                                         Python  代码由虚拟机（解释器主循环）控制‘
                                         主循环同时只能有一个控制线程执行’

import  time

__author__ = "Eason"
__copyright__ = "Copyright  2013-2017, codeclassroom.com"

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


def  main():
    print(f'[主函数执行开始于：{time.ctime()}]')
    worker(4)
    worker(2)
    print(f'[主函数执行结束于：{time.ctime()}]')


if __name__ == '__main__':
    main()

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

（二）多线程

（1）_thread模块在这里插入图片描述

使用多线程可以使多个进程并发执行，但是必须提前知道每个线程的运行时间

import time
import  _thread


__author__ = 'Eason'
__copyright__ = "Copyright 2013-2017,codeclassroom.com"


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,(4,))
    _thread.start_new_thread(worker,(2,))
    time.sleep(6)
    print(f'[主函数执行结束于：{time.ctime()}]')


if __name__ == '__main__':
    main()

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

（2）threading模块

在这里插入图片描述

import  threading


__author__ = 'Eason'
__copyright__ = "Copyright 2013-2017,codeclassroom.com"


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,(4,))
    # _thread.start_new_thread(worker,(2,))

    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()

    # time.sleep(6)
    print(f'[主函数执行结束于：{time.ctime()}]')


if __name__ == '__main__':
    main()

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

（3）同步原语（锁）

在这里插入图片描述

import threading
import time
import random

__author__ = "Eason"
__copyright__ = "Copyright 2013-2017,codeclassroom.com"

eggs = []
lock = threading.Lock()

def put_egg(n,lst):
    # lock.acquire()
    with lock:
    for i in range(1, n+1):
        time.sleep(random.randint(0, 2))
        lst.append(i)
    # lock.release()

def  main():
    threads = []

    for i in range(3):
        t = threading.Thread(target= put_agg,args = (5,eggs))
        threads.append(t)

    for t in threads:
        t.start()

    for t in threads:
        t.join()

    print(eggs)


if __name__ == '__main__':
    main()

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

（三）队列

      queue 模块    Queue  FIFO    .Queue(maxsize = 0)   构造实例
                                   .put(item,block = True, timeout = None)   放入数据项
                                    .get(block = True, timeout = None)   获取数据项
                                    .task.done()      声明当前任务队列任务处理完毕
                    LifoQueue  LIFO    
                    PriorityQueue  优先队列

先进先出队列

import threading
import queue
import time
import random


__author__ = "Eason"
__copyright__ ="Copyright  2013-2017, codeclassroom.com"


def producer(data_queue):
    for i in range(5):
        time.sleep(0.5)
        item = random.randint(1,100)
        data_queue.put(item)
        print(f'{threading.current_thread().name}在队列中放入数据项：{item}')


def consumer(data_queue):
    while True:
        try:
            item = data_queue.get(timeout = 3)
            print(f'{threading.current_thread().name}从队列中移除了{item}')
        except queue.Empty:
            break
        else:
            data_queue.task_done()


def main():
    q = queue.Queue()

    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()


if   __name__ == '__main__':
    main()

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

import multiprocessing
import  time


__author__ = "Eason"
__copyright__ = "Copyright 2013-2017, codeclassroom.com"


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()

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

（四）multiprocessing模块 充分运用多核、多CPU的计算能力，适用于计算密集型任务 concurrent.futures模块

在这里插入图片描述
concurrent.futures应用

import  time
import concurrent.futures

__author__ = "Eason"
__copyright__ = "Copyright  2013-2017, codeclassroom.com"

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.ProcessPoolExecutor(max_workers = 5) as  executor:
     for i in numbers:
         executor.submit(worker, i)

 print(f'进程池执行花费时间：{time.clock()-start_time}秒')


if __name__ == '__main__':
 sequential_execution()

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

二、装饰器

（一）概述

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

（二）编写

（1）函数基础
   将函数赋给变量

>>>def hello(name):
…    print('Hello',name)
…    
>>>hello('Tom')
Hello Tom
>>>type(hello)
<class 'function'>
>>>hello
<function hello at 0x000001E60773B510>
>>>greeting = hello
>>>greeting
<function hello at 0x000001E60773B510>
>>>greeting = hello
>>>greeting
<function hello at 0x000001E60773B510>
>>>hello('Tom')
Hello Tom
>>>greeting('Jerry')
Hello Jerry

将函数作为参数传递

>>>def add(a,b):
…    return a + b
…
>>>def subtract(a,b):
…    return a-b
…
>>>add(3,5)
8
>>>subtract(5,3)
2
>>>def action(x,y,func):
…    return func(x,y)
…
>>>action(5,3,add)
8
>>>action(5,3,subtract)
2
>>>action(5,3,lambda x, y: x*y)
15

函数嵌套及跨域访问

>>>def greeting():
…    def hello():
…        return 'Hello'
…    return hello
…
>>>greeting()
'Hello'
>>>def greeting():
…   def hello():
…        return 'Hello'
…    return hello
…
>>>greeting()
<function greeting.<locals>.hello at 0x0000025526DFB378>
>>>greeting()()
'Hello'

>>>def func_1():
...    x = 10
...    def func_2():
...        x = 20
...        return x +10
...    return func_2()
...
>>>func_1()
30
>>>def func_1():
...    x = 10
...    def func_2():
...        nonlocal x
...        return x+10
...    return func_2()
...
>>>func_1()
20
（2）函数定义装饰器

在func_decorator.py文件中



__author__ = "Eason"
__copyright__ =  "Copyright 2013-2017,codeclassroom.com"


def  p_decorator(func):
   def wrapper(*args,**kwargs):
       return func(*args,**kwargs)

   return wrapper


def get_text():
   return '欢迎学习优品课堂课程'


if __name__ == '__main__':
   print(get_text())

运行结果：
在这里插入图片描述
在func_decorator.py文件中

__author__ = "Eason"
__copyright__ =  "Copyright 2013-2017,codeclassroom.com"


def  p_decorator(func):
    def wrapper(*args,**kwargs):
        return '<p>'+ func(*args,**kwargs)+'</p>'

    return wrapper

@p_decorator
def get_text():
    return '欢迎学习优品课堂课程'


@p_decorator
def get_upper_text(text):
    return text.upper()


if __name__ == '__main__':
    # html = p_decorator(get_text)
    # print(html())
    # print(get_text())
    print(get_upper_text('www.codeclassroom.com'))

在person.py文件中



__author__ = "Eason"
__copyright__ = "Copyright 2013-2017,codeclassroom.com"

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def say(self,word):
        print(f'{self.name}说：{word}')

    @staticmethod
    def do_something():
        pass

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

（3）类定义装饰器

在cls_decorator.py中

__author__ = "Eason"
__copyright__ = "Copyright 2013-2017,codeclassroom.com"


class P:
    def  __init__(self,func):
        self.func = func

    def __call__(self,*args,**kwargs):
        return '<p>' + self.func(*args,**kwargs) + '</p>'


@P
def get_text():
    return '欢迎学习优品课堂课程'

@P
def  get_upper_text(text):
    return text.upper()



if __name__ == '__main__':
    print(get_upper_text('codeclassroom.com'))

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

（3）装饰器参数


__author__ = "Eason"
__copyright__ =  "Copyright 2013-2017,codeclassroom.com"


#参数化装饰器
def tags(tag):
    def  tag_decorator(func):
        def wrapper(*args,**kwargs):
            return '<{tag}>{func(*args,**kwargs)}</{tag}>'

        return wrapper

    return  tag_decorator


def  p_decorator(func):
    def wrapper(*args,**kwargs):
        return '<p>'+ func(*args,**kwargs)+'</p>'

    return wrapper

def  div_decorator(func):
    def wrapper(*args,**kwargs):
        return '<div>{}</div>'.format(func(*args,**kwargs))

    return wrapper

class Student:...


def get_text():
    return '欢迎学习优品课堂课程'


@tags('body')
@tags('div')
@tags('p')
def get_upper_text(text):
    return text.upper()


if __name__ == '__main__':
    # html = p_decorator(get_text)
    # print(html())
    # print(get_text())
    print(get_upper_text('www.codeclassroom.com'))

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

山复尔尔，
关注
专栏目录
一文讲透Python线程池ThreadPoolExecutor！
2401_84139049的博客
04-12 659
现在我也找了很多测试的朋友，做了一个分享技术的交流群，共享了很多我们收集的技术文档和视频教程。而且还有很多在自动化，性能，安全，测试开发等等方面有一定建树的技术大牛。如果你不想再体验自学时找不到资源，没人解答问题，坚持几天便放弃的感受。urls = [3, 2, 4] # 并不是真的url。urls = [3, 2, 4] # 并不是真的url。urls = [3, 2, 4] # 并不是真的url。qq群号：110685036【暗号：csdn999】分享他们的经验，还会分享很多直播讲座和技术沙龙。
python 线程池ThreadPoolExecutor
weixin_39451323的博客
08-17 3381
每个线程各分配一个任务，剩下的任务排队等待，当某个线程完成了任务的时候，排队任务就可以安排给这个线程继续执行，免于停的创建和销毁线程，这就是所谓的线程池 ThreadPoolExecutor 原理。...
Python 高手编程系列三百零八：在事件循环中使用 executors
最新发布
2301_77888392的博客
07-12 562
此解决方法的核心是事件循环类的 BaseEventLoop.run_in_executor(executor,本书是这个领域中的重要著作，它收录了 23 种设计模式，并使用 SmallTalk 和 C++编写了示例。这个方法最重要的是它返回一个新的 awaitable（一个可以用 await 语句的等待。何时候都共享相同的状态的事实。另一种克服琐碎单例实现问题的方法是由 Alex Martelli 提出的。这些是编译型语言（如 C 或 C ++）中非常重要的模式，因为在运行时难以生成需要的类型。
Python从小白到高手实现系列二百二十一：有用的设计模式
Mr_Roki的博客
03-24 278
本书是这个领域中的重要著作，它收录了23 种设计模式，并使用SmallTalk 和C++编写了示例。更安全的方式是使用更先进的技术—元类（metaclasses）。除了工厂设计模式，在Python 中，GoF 中唯一值得注意的其他创建型设计模式是单例。要单例，为什么不使用带有函数的模块，因为Python 模块已经是单例了？这些是编译型语言（如C 或C ++）中非常重要的模式，因为在运行时难以生成需要的类型。本章介绍了Python 中最有用的以及最值得大家讨论的模式，以及实现示例。用程序通常被声明为单例。
python 之线程池传入多个参数的方法 ThreadPoolExecutor.submit 多参数支持
热门推荐
znsoft的专栏
05-31 2万+
filepath=path+os.sep+fileitem args=[filepath,thu1,Words] newTask=executor.submit(lambdap:doFileParse(*p),args)
Python笔记 之 简单并发任务（线程/进程池）
weixin_50648794的博客
08-22 1271
线程池的基类是 concurrent.futures 模块中的ThreadPoolExecutor 和 ProcessPoolExecutor两个子类，其中 ThreadPoolExecutor 用于创建线程池，而 ProcessPoolExecutor 用于创建进程池。4，调用 ThreadPoolExecutor 对象的 shutdown(wait = True) 方法来关闭线程池。3，调用 ThreadPoolExecutor 对象的 submit() 方法来提交线程任务；
python基础知识汇总
01-02
python入门级别基础知识汇总讲解，适合刚入门，亦或是有一定编程基础的参考
python基础知识PPT课件.ppt
08-06
python基础知识，python基础知识PPT，python基础知识课件
【python入门必背】python入门基础知识点合集、python基础知识背记手册
10-05
【python入门必背】python入门基础知识点合集、python基础知识背记手册 主要内容概要： 第1章 走进 Python. 第2章 Python语言基础 第3章 运算符与表达式 第4章 流程控制语句 第5章 列表与元组 第6章 字典与集合 第...
python基础知识
08-03
该文档代码主要为有关于python的基础知识，为新手定制，可以仿照上面代码进行实际编写
Python 多线程提交函数传递多参数 Star.hou
明日又天涯
02-16 702
【代码】Python 多线程提交函数传递多参数 Star.hou。
python多进程
人生百态361
01-16 460
异步多进程 import multiprocessing import threading import time from datetime import datetime from concurrent.futures import ProcessPoolExecutor def task(i): print(f'task {i} started at {datetime.now()}') time.sleep(3) print(f'task {i} ended at {
python线程池操作_python线程池和进程池
weixin_30767895的博客
02-21 323
线程池和进程池开局来张图使用线程池的好处1.提升性能：因为减去了大量新建、终止线程的开销，重用了线程资源2.使用场景：适合处理突发性大量请求或需要大量线程完成任务、但实际任务处理时间较短3.防御功能：能有效避免系统因为创建线程过多，而导致系统负荷过大相应变慢等问题4.代码优势：使用线程池的语法比自己新建线程执行线程更加简洁concurrent.futures进行并发编程concurrent.fut...
python利用(threading,ThreadPoolExecutor.map,ThreadPoolExecutor.submit) 三种多线程方式处理 list数据...
weixin_30918633的博客
07-18 2188
需求：在从银行数据库中取出 几十万数据时，需要对 每行数据进行相关操作，通过pandas的dataframe发现数据处理过慢，于是 对数据进行 分段后 通过 线程进行处理； 如下给出 测试版代码，通过 list 分段模拟 pandas 的 dataframe ； 1.使用 threading模块 1 # -*- coding: utf-8 -*- 2 # (C) Gu...
PyCharm 添加copyright
weixin_52261094的博客
09-18 669
【代码】PyCharm 添加copyright。
python __builtins__ copyright类 （14）
weixin_30670151的博客
01-08 418
14、'copyright', 版权 class _Printer(builtins.object) | interactive prompt objects for printing the license text, a list of | contributors and the copyright notice. 交互式提示对象打印许可证信息，撰稿者列表，和版权说明...
python 版权保护,python爬虫篇4——爬取专利著作权信息
weixin_36274779的博客
03-25 3722
mysql代码：CREATE TABLE `copyright` (`id` int(11) NOT NULL AUTO_INCREMENT,`软件名称` varchar(500) DEFAULT NULL,`登记号` varchar(500) DEFAULT NULL,`分类号` varchar(500) DEFAULT NULL,`软件简称` varchar(500) DEFAULT NULL...
如何输入版权符号 copyright
hintcnuie
04-08 1037
Unicode Character 'COPYRIGHT SIGN' (U+00A9) Image Browser Test Page | Outline (as SVG file) | Fonts that support U+00A9 Unicode Data Name COPYRIGHT SIGN B...
Python基础知识点练习题库
Python 基础知识点总结 Python 是一种高级的解释型编程语言，广泛应用于数据分析、人工智能、Web 开发等领域。以下是 Python 基础知识点的总结，涵盖了 Python 标准库、数据类型、操作符、控制结构、函数、模块、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值