并行编程概述

并发编程

多线程之——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

时间： 2024-08-30 09:12:19

并行编程概述的相关文章

40 Python - python并行编程并行编程概述

原文地址:https://www.cnblogs.com/yijiexi/p/11165539.html

.NET 并行编程

本文内容并行编程数据并行最近,对多线程编程,并行编程,异步编程,这三个概念有点晕了,怎么突然觉得,自己有点不明白这三者之间有什么联系和区别了呢? 因此,回顾了一下个人经历,屡屡思路~我刚接触计算机时,还是学校的 DOS 和 win 3.x,之后,学校换了 Windows 95,再之后,我有自己的台式机--但是无论如何,那时的电脑 CPU 都是单核的,即便采用多线程,无论看上多么像"同时"执行的,本质上还是顺序的,因为代码段是独占 CPU 的:之后,我把台式机卖了,买了个笔记本电脑

.NET 4.0 任务和并行编程系列

8天玩转并行开发 8天玩转并行开发——第一天 Parallel的使用 8天玩转并行开发——第二天 Task的使用 8天玩转并行开发——第三天 plinq的使用 8天玩转并行开发——第四天同步机制(上) 8天玩转并行开发——第五天同步机制(下) 8天玩转并行开发——第六天异步编程模型 8天玩转并行开发——第七天简要分析任务与线程池 8天玩转并行开发——第八天用VS性能向导解剖你的程序并行编程系列 .NET 4 并行(多核)编程系列之一入门介绍 .NET 4 并行(多核)编程系列之二从

并行编程（Parallel Framework）

前言并行编程:通过编码方式利用多核或多处理器称为并行编程,多线程概念的一个子集. 并行处理:把正在执行的大量的任务分割成小块,分配给多个同时运行的线程.多线程的一种. 并行编程分为如下几个结构: 1.并行的LINQ或PLINQ 2.Parallel类 3.任务并行结构 4.并发集合 5.SpinLock和SpinWait 这些是.NET 4.0引入的功能,一般被称为PFX(Parallel Framework,并行框架). Parallel类和任务并行结构称为TPL(Task Parallel

并行编程入门

目录 1. 并行编程简介 2. MapReduce 2.1 MapReduce简介 2.2 MapReduce框架 2.3 Hadoop介绍 2.4 Hadoop基本类 2.5 Hadoop编程实例 1.并行编程简介 1.1.并行编程作用,用途商业用途,科学计算,大数据分析 1.2.并行编程兴起原因目前的串行编程的局限性使用的流水线等隐式并行模式的局限性硬件的发展 1.3.并行算法设计原则步骤 a.分析问题 b.分解问题其中分解方法有: 数据分解递归分解探测性分解推测性分解混合

C#并行编程 z

目录 C#并行编程-相关概念 C#并行编程-Parallel C#并行编程-Task C#并行编程-并发集合 C#并行编程-线程同步原语 C#并行编程-PLINQ:声明式数据并行背景基于任务的程序设计.命令式数据并行和任务并行都要求能够支持并发更新的数组.列表和集合. 在.NET Framework 4 以前,为了让共享的数组.列表和集合能够被多个线程更新,需要添加复杂的代码来同步这些更新操作. 如您需要编写一个并行循环,这个循环以无序的方式向一个共享集合中添加元素,那么必须加入一个同步机制

.Net中的并行编程-4.实现高性能异步队列

上文<.Net中的并行编程-3.ConcurrentQueue实现与分析>分析了ConcurrentQueue的实现,本章就基于ConcurrentQueue实现一个高性能的异步队列,该队列主要用于实时数据流的处理并简化多线程编程模型.设计该队列时考虑以下几点需求(需求来自公司的一个实际项目): 1. 支持多线程入队出队,尽量简化多线程编程的复杂度. 2. 支持事件触发机制,数据入队时才进行处理而不是使用定时处理机制, 而且内部能阻塞消费者线程. 3. 出队时数据处理的顺序要保证和入队时是一致

五浅谈CPU 并行编程和 GPU 并行编程的区别

前言 CPU 的并行编程技术,也是高性能计算中的热点,也是今后要努力学习的方向.那么它和 GPU 并行编程有何区别呢? 本文将做出详细的对比,分析各自的特点,为将来深入学习 CPU 并行编程技术打下铺垫. 区别一:缓存管理方式的不同 GPU:缓存对程序员不透明,程序员可根据实际情况操纵大部分缓存 (也有一部分缓存是由硬件自行管理). CPU:缓存对程序员透明.应用程序员无法通过编程手段操纵缓存. 区别二:指令模型的不同 GPU:采用 SIMT - 单指令多线程模型,一条指令配备一组硬件,对应32

框架编程概述 (转载)

框架编程概述 http://blog.chinaunix.net/u2/65993/showart_576137.html一个HTML页面可以有一个或多个子框架,这些子框架以<iframe>来标记,用来显示一个独立的HTML页面.这里所讲的框架编程包括框架的自我控制以及框架之间的互相访问,例如从一个框架中引用另一个框架中的JavaScript变量.调用其他框架内的函数.控制另一个框架中表单的行为等. 框架间的互相引用一个页面中的所有框架以集合的形式作为window对象的属性提供,例如:win