并行编程概述

并发编程

多线程之——threa模块

>>> import time
>>> time.ctime()
'Thu Jan  9 07:52:57 2020'

import time

"""单线程示例
"""

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

def mian():
    print(f'【主函数执行开始于：{time.ctime()}】')#f格式化字符串
    worker(4)#执行4秒
    worker(2)#执行2秒
    print(f'【主函数执行结束于：{time.ctime()}】')

if __name__ == '__main__':
    mian()　　

结果

【主函数执行开始于：Thu Jan  9 08:00:57 2020】
函数执行开始于:Thu Jan  9 08:00:57 2020
函数执行结束于:Thu Jan  9 08:01:01 2020
函数执行开始于:Thu Jan  9 08:01:01 2020
函数执行结束于:Thu Jan  9 08:01:03 2020
【主函数执行结束于：Thu Jan  9 08:01:03 2020】　

多线程

_thread模式弊端并不能决定函数 程序什么时候结束

import time
import _thread


"""_thread 实现多线程
"""

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

def mian():#多线程只修改main函数
    print(f'【主函数执行开始于：{time.ctime()}】')#f格式化字符串
    _thread.start_new_thread(worker,(4,))#开始一个新的线程,function函数名称叫worker，args传递参数，以元组形式展现
    _thread.start_new_thread(worker, (2,))
    print(f'【主函数执行结束于：{time.ctime()}】')

if __name__ == '__main__':
    mian()　　

结果

【主函数执行开始于：Thu Jan  9 08:14:44 2020】
【主函数执行结束于：Thu Jan  9 08:14:44 2020】

想执行等一等 就是加上time sleep

import time
import _thread


"""_thread 实现多线程
"""

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

def mian():#多线程只修改main函数
    print(f'【主函数执行开始于：{time.ctime()}】')#f格式化字符串
    _thread.start_new_thread(worker,(4,))#开始一个新的线程,function函数名称叫worker，args传递参数，以元组形式展现
    _thread.start_new_thread(worker, (2,))

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

if __name__ == '__main__':
    mian()

threading 模块

主函数的主线程没有和子线程同步

import time
import threading


"""threading.Thread() 实现多线程
"""

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

def mian():#多线程只修改main函数
    print(f'【主函数执行开始于：{time.ctime()}】')#f格式化字符串
    #_thread.start_new_thread(worker,(4,))#开始一个新的线程,function函数名称叫worker，args传递参数，以元组形式展现
    #_thread.start_new_thread(worker, (2,))

    threads = []#先申请一个数组让他为空
    t1 = threading.Thread(target=worker, args=(4,))#构造一个他t1线程,执行目标函数，atgs耗费4秒
    threads.append(t1) #追加t1线程

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

    for t in threads:
        t.start()


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

if __name__ == '__main__':
    mian()

理想状态是等待当前状态执行完毕之后再主线程执行完

import time
import threading


"""threading.Thread() 实现多线程
"""

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

def mian():#多线程只修改main函数
    print(f'【主函数执行开始于：{time.ctime()}】')#f格式化字符串
    #_thread.start_new_thread(worker,(4,))#开始一个新的线程,function函数名称叫worker，args传递参数，以元组形式展现
    #_thread.start_new_thread(worker, (2,))

    threads = []#先申请一个数组让他为空
    t1 = threading.Thread(target=worker, args=(4,))#构造一个他t1线程,执行目标函数，atgs耗费4秒
    threads.append(t1) #追加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__':
    mian()

import time
import threading


"""threading.Thread() 实现多线程
"""

def worker(n):
    print('{} 函数执行开始于：{}'.format(threading.current_thread().name, time.ctime()))#出现当前线程名称
    time.sleep(n)#休眠时间
    print(f'{threading.current_thread().name} 函数执行结束于:{time.ctime()}')#获得当前线程

def mian():#多线程只修改main函数
    print(f'【主函数执行开始于：{time.ctime()}】')#f格式化字符串
    #_thread.start_new_thread(worker,(4,))#开始一个新的线程,function函数名称叫worker，args传递参数，以元组形式展现
    #_thread.start_new_thread(worker, (2,))

    threads = []#先申请一个数组让他为空
    t1 = threading.Thread(target=worker, args=(4,))#构造一个他t1线程,执行目标函数，atgs耗费4秒
    threads.append(t1) #追加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__':
    mian()

结果

【主函数执行开始于：Thu Jan  9 10:33:17 2020】
Thread-1 函数执行开始于：Thu Jan  9 10:33:17 2020
Thread-2 函数执行开始于：Thu Jan  9 10:33:17 2020
Thread-2 函数执行结束于:Thu Jan  9 10:33:19 2020
Thread-1 函数执行结束于:Thu Jan  9 10:33:21 2020
【主函数执行结束于：Thu Jan  9 10:33:21 2020】

 派生类

import time
import threading


"""threading.Thread() 实现多线程
"""

def worker(n):
    print('{} 函数执行开始于：{}'.format(threading.current_thread().name, time.ctime()))#出现当前线程名称
    time.sleep(n)#休眠时间
    print(f'{threading.current_thread().name} 函数执行结束于:{time.ctime()}')#获得当前线程

class MyThread(threading.Thread):#继承基类
    def __init__(self, func, args):#指定信息
        threading.Thread.__init__(self)
        self.func = func
        self.args = args

    def run(self):
        self.func(*self.args)

def mian():#多线程只修改main函数
    print(f'【主函数执行开始于：{time.ctime()}】')#f格式化字符串
    #_thread.start_new_thread(worker,(4,))#开始一个新的线程,function函数名称叫worker，args传递参数，以元组形式展现
    #_thread.start_new_thread(worker, (2,))

    threads = []#先申请一个数组让他为空
    t1 = MyThread(worker, (4,))
    threads.append(t1) #追加t1线程

    #t2 = threading.Thread(target=worker, args=(2,))
    t2 = MyThread(worker,(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__':
    mian()

结果

【主函数执行开始于：Thu Jan  9 10:44:08 2020】
Thread-1 函数执行开始于：Thu Jan  9 10:44:08 2020
Thread-2 函数执行开始于：Thu Jan  9 10:44:08 2020
Thread-2 函数执行结束于:Thu Jan  9 10:44:10 2020
Thread-1 函数执行结束于:Thu Jan  9 10:44:12 2020
【主函数执行结束于：Thu Jan  9 10:44:12 2020】

同步锁

import threading
import time

"""同步原语之：锁
"""

eggs = []

def put_egg(n, lst):
    for i in range(1,n+1):#做遍历
        lst.append(i)


def main():
    threads = [] #变量等于数组

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

    for t in threads:
        t.start()

    for t in threads:
        t.join()

    print(eggs)

if __name__ == '__main__':
   main()

结论

[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

import threading
import time
import random

"""同步原语之：锁
"""

eggs = []
lock = threading.Lock()#声明变量

def put_egg(n, lst):
    lock.acquire()
    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_egg,args=(5,eggs))
        threads.append(t)

    for t in threads:
        t.start()

    for t in threads:
        t.join()

    print(eggs)

if __name__ == '__main__':
   main()

 qunue队列

由生产者每个半秒向队列里放入一个随机数，总共放5个，先进先出，在队列里有消费者线程来取到某一项进行处理，

处理完毕后一个task——down告诉任务结束，取内容有个超时操作3秒，取不到就不取得到一个空的异常

import threading #输入模块
import queue#队列模块
import time#时间模块
import random#使用随机数

"""LIFO 队列示例
"""

def producer(data_queue):#定义生产者函数
    for i in range(5):#循环5次
        time.sleep(0.5)#每循环一次停留一会儿
        item = random.randint(1, 100)#1-100间随便一个数字
        data_queue.put(item)#队列里放入一个信息,把item放入进去
        print(f'{threading.current_thread().name} 在队列中放入数据项：{item}') #放入对象到队列的方法

def consumer(data_queue):
    while True:
        try:
            item = data_queue.get(timeout=3)#获取信息,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()#让主线程等待当前线程执行完毕

    q.join()#让主线程等待整个队列的操作

if __name__ == '__main__':
    main()

 

import multiprocessing
import time

"""多进程示例
"""

def func(n):
    print(f'{multiprocessing.current_process().name} 执行开始于：{time.ctime()}')#当前进程有个属性叫name
    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)

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

if __name__ == '__main__':
    main()



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

 

 

更多并行编程

import time
import concurrent.futures

"""concurrent.futures应用
"""
numbers = list(range(1,11))#做一个列表，生成范围1-10

def count(n):#定义函数，接收参数n
    for i in range(1000000):
        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()
    #threading_execution()

    process_execution()

 函数基础

 

 

将函数赋给变量

In[2]: def hello(name):
  ...:     print('Hello ', name)
  ...:     
In[3]: hello('Tom')#函数名称加特定参数
Hello  Tom
In[4]: type(hello)#用type检查
Out[4]: function
In[5]: hello
Out[5]: <function __main__.hello(name)>
In[6]: greeting = hello
In[7]: greeting
Out[7]: <function __main__.hello(name)>
In[8]: hello('Tom')
Hello  Tom
In[9]: greeting('Jerry')
Hello  Jerry

将函数作为参数传递

 

In[2]: def add(a, b):#把两个参数相加
  ...:     return a + b
  ...: 
In[4]: def subtract(a, b):
  ...:     return a - b
  ...: 
In[5]: add(3,5)
Out[5]: 8
In[6]: subtract(5,3)
Out[6]: 2
In[7]: def action(x, y, func):
  ...:     return func(x, y)
  ...: 
In[8]: action(5, 3, add)
Out[8]: 8
In[9]: action(5, 3, subtract)
Out[9]: 2
In[10]: action(5, 3, lambda x, y:x*y)
Out[10]: 15

 

函数嵌套及跨域访问

加括号是返回执行结果，不加括号是返回当前的对象

>>> def greeting():#定义函数greeting
... def hello():#函数里定义一个函数greeting
... return 'Hello'
... return hello()#hello作为一个字符串在greeting结果返回
...
>>> greeting()#调用
'Hello'
>>> def greeting():
... def hello():
... return 'Hello'
... return hello
...
>>> greeting()
<function greeting.<locals>.hello at 0x00000000037E31E0>
>>> greeting()()#想执行再写个括号
'Hello'

 函数嵌套域成员访问

>>> def func_1():
...     x = 10
...     def func_2():
...         x = 20
...         return x + 10
...     return func_2()
... 
>>> func_1()#用的是本地变量与外侧
30

想用func1里func2外面的
>> def func_1():
...     x = 10
...     def func_2():
...         nonlocal x #非本地的x，使用上一层函数封装区域
...         return x + 10
...     return func_2()
... 
>>> func_1()
20

 函数定义装饰器

"""函数定义装饰器
"""

def p_decoratior(func):#把gettext传入装饰器里
    def wrapper(*args,**kwargs):#args元组，kwargs有名字的参数，任何类型参数都可通过它来表示
        return '<p>' +  func(*args,**kwargs) + '</p>'

    return wrapper

@p_decoratior#对gettext做个装饰器,进行装饰
def get_text():
    return '欢迎学习优品课堂课程'

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

同

"""函数定义装饰器
"""

def p_decoratior(func):#把gettext传入装饰器里
    def wrapper(*args,**kwargs):#args元组，kwargs有名字的参数，任何类型参数都可通过它来表示
        return '<p>' +  func(*args,**kwargs) + '</p>'

    return wrapper

#@p_decoratior#对gettext做个装饰器,进行装饰
def get_text():
    return '欢迎学习优品课堂课程'

if __name__ == '__main__':
   html = p_decoratior(get_text)#把gettext函数作为参数传递到decoratorfunc里
   print(html())#结果返回的字符串再打印

 

"""函数定义装饰器
"""

def p_decoratior(func):#把gettext传入装饰器里
    def wrapper(*args,**kwargs):#args元组，kwargs有名字的参数，任何类型参数都可通过它来表示
        return '<p>' +  func(*args,**kwargs) + '</p>'

    return wrapper

@p_decoratior#对gettext做个装饰器,进行装饰
def get_text():
    return '欢迎学习优品课堂课程'

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

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

装饰器修饰

"""函数定义装饰器
"""

def p_decoratior(func):#把gettext传入装饰器里
    def wrapper(*args,**kwargs):#args元组，kwargs有名字的参数，任何类型参数都可通过它来表示
        return '<p>' +  func(*args,**kwargs) + '</p>'

    return wrapper

@p_decoratior#对gettext做个装饰器,进行装饰
def get_text():
    return '欢迎学习优品课堂课程'

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

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

 类定义装饰器

"""类定义装饰器
"""

class P:
    def __init__(self, func): #构造传递函数
        self.func = func

    def __call__(self, *args, **kwargs):#调用
        return '<p>' + self.func(*args,**kwargs) + '</p>'#返回p标签加/p标签

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

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

if __name__ == '__main__':
    print(get_text())#未加修饰的

想修饰

"""类定义装饰器
"""

class P:
    def __init__(self, func): #构造传递函数
        self.func = func

    def __call__(self, *args, **kwargs):#调用
        return '<p>' + self.func(*args,**kwargs) + '</p>'#返回p标签加/p标签

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

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

if __name__ == '__main__':
    print(get_text())#未加修饰的

函数定义装饰器

"""函数定义装饰器
"""

def p_decoratior(func):#把gettext传入装饰器里
    def wrapper(*args,**kwargs):#args元组，kwargs有名字的参数，任何类型参数都可通过它来表示
        return '<p>' +  func(*args,**kwargs) + '</p>'

    return wrapper

class Student:
    def __init__(self, name):
        self.name = name


    @p_decoratior
    def get_name(self):
        return self.name.upper()

@p_decoratior#对gettext做个装饰器,进行装饰
def get_text():
    return '欢迎学习优品课堂课程'

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

if __name__ == '__main__':
    s = Student('Mike')
    print(s.get_name())

类定义装饰器

"""类定义装饰器
"""

class P:
    def __init__(self, func): #构造传递函数
        self.func = func

    def __call__(self, *args, **kwargs):#调用
        return '<p>' + self.func(*args,**kwargs) + '</p>'#返回p标签加/p标签

class Student:
    def __init__(self,name):
        self.name = name

    def get_name(self):
        return self.name.upper()

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

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

if __name__ == '__main__':
    s = Student('John')
    print(s.get_name())

参数化装饰器

"""函数定义装饰器
"""

def p_decorator(func):#把gettext传入装饰器里
    def wrapper(*args,**kwargs):#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:...


@p_decorator#对gettext做个装饰器,进行装饰
def get_text():
    return '欢迎学习优品课堂课程'

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

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

 再加个@p_decorator，看看修饰的先后

"""函数定义装饰器
"""

def p_decorator(func):#把gettext传入装饰器里
    def wrapper(*args,**kwargs):#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:...


@p_decorator#对gettext做个装饰器,进行装饰
def get_text():
    return '欢迎学习优品课堂课程'

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

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

不加装饰器 原本返回一个地址

"""函数定义装饰器
"""

#参数化装饰器
def tags(tag):
    def tag_decorator(func):
        def wrapper(*args,**kwargs):
            return f'<{tag}>{func(*args,**kwargs)}</{tag}>'#返回格式化字符串
        return wrapper

    return tag_decorator


def p_decorator(func):#把gettext传入装饰器里
    def wrapper(*args,**kwargs):#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:...


#@p_decorator#对gettext做个装饰器,进行装饰
def get_text():
    return '欢迎学习优品课堂课程'

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

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

加一个标签，装饰器叫tags

"""函数定义装饰器
"""

#参数化装饰器
def tags(tag):
    def tag_decorator(func):
        def wrapper(*args,**kwargs):
            return f'<{tag}>{func(*args,**kwargs)}</{tag}>'#返回格式化字符串
        return wrapper

    return tag_decorator


def p_decorator(func):#把gettext传入装饰器里
    def wrapper(*args,**kwargs):#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:...


#@p_decorator#对gettext做个装饰器,进行装饰
def get_text():
    return '欢迎学习优品课堂课程'

#@div_decorator
#@p_decorator()

@tags('p')#加标签
def get_upper_text(text):
    return text.upper()

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

想变div

"""函数定义装饰器
"""

#参数化装饰器
def tags(tag):
    def tag_decorator(func):
        def wrapper(*args,**kwargs):
            return f'<{tag}>{func(*args,**kwargs)}</{tag}>'#返回格式化字符串
        return wrapper

    return tag_decorator


def p_decorator(func):#把gettext传入装饰器里
    def wrapper(*args,**kwargs):#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:...


#@p_decorator#对gettext做个装饰器,进行装饰
def get_text():
    return '欢迎学习优品课堂课程'

#@div_decorator
#@p_decorator()

@tags('div')#加标签
def get_upper_text(text):
    return text.upper()

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

"""函数定义装饰器
"""

#参数化装饰器
def tags(tag):
    def tag_decorator(func):
        def wrapper(*args,**kwargs):
            return f'<{tag}>{func(*args,**kwargs)}</{tag}>'#返回格式化字符串
        return wrapper

    return tag_decorator


def p_decorator(func):#把gettext传入装饰器里
    def wrapper(*args,**kwargs):#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:...


#@p_decorator#对gettext做个装饰器,进行装饰
def get_text():
    return '欢迎学习优品课堂课程'

#@div_decorator
#@p_decorator()

@tags('div')#加标签
@tags('p')
def get_upper_text(text):
    return text.upper()

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

 

 

 python sublime text python 配置

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

来源：https://www.cnblogs.com/shirleysu90/p/12169463.html