python 3day 进阶 例题（生成器 装饰器） 进程 线程

 

一.生成器

#生成器
def A():
    for i in range(10):
        yield i #将函数编程一个迭代器
        print('cute')
a = A()
print(next(a))


0

尝试执行try中的代码，如果有错，则被except捕获，但是整个程序不会崩溃

def girl():
    for i in range(6):
        yield i        ##将函数变成一个迭代器（生成器）
try:
    a=girl()
    print(next())
    print(next())
    print(next())
    print(next())
    print(next())
    print(next())
except Exception as boy:
    print(boy)
print('everyone')

next expected at least 1 arguments, got 0
everyone

 

二.装饰器

 

#装饰器
def deco(func):
    def warp(name1):
        print('wa')
        name1 = 520
        return func(name1)
    return warp
@deco 
def liwenhui(name):
    print(name)
    
liwenhui(1324)

wa
520

 

 1.位置传参

#不定长参数 相当于位置传参
#*args
def aini(*args):
    print('小可爱')
aini(123)

小可爱

 

 2.带参数名称的传参

#**mei 带参数名称的传参
def xiao(**mei):
    print('小美')
xiao(a=1,b=2,c=3)

小美

 

　3.多参

#返回字典
def hiehie(*args,**kwargs):
    print(args)
    print(kwargs)
hiehie(1,2,3,a=1,b=2,c=3)

(1, 2, 3)
{'a': 1, 'b': 2, 'c': 3}

 

 

#"""
#钩子：
#写三个页面：A,B,C
#去检测IP是否频繁访问，如果是则不予访问404.
#"""
def count(func):
    def warp(*args,**kwargs):
        num = kwargs['num']
        if num > 4:
            print('404')
        else:
            return func(*args,**kwargs)
    return warp
    

@count
def page_1(num):
    print('页面详情')

if __name__ == '__main__':
    for i in range(10):
        page_1(num = i)

页面详情
页面详情
页面详情
页面详情
页面详情
404
404
404
404
404

 

 

三.进程、线程

 我们使用的操作系统都是支持“多任务”的操作系统，这使得我们可以同时运行多个程序，也可以将一个程序分解为若干个相对独立的子任务，让多个子任务并发的执行，从而缩短程序的执行时间，同时也让用户获得更好的体验。因此在当下不管是用什么编程语言进行开发，实现让程序同时执行多个任务也就是常说的“并发编程”。

一个进程还可以拥有多个并发的执行线索，简单的说就是拥有多个可以获得CPU调度的执行单元，这就是所谓的线程。

优缺点：多线程的程序对其他程序并不友好，因为它占用了更多的CPU执行时间，导致其他程序无法获得足够的CPU执行时间；另一方面，站在开发者的角度，编写和调试多线程的程序都对开发者有较高的要求，对于初学者来说更加困难。

使用多进程和不使用多进程到底有什么差别：

 

#不使用多进程
from random import randint
from time import time, sleep
def download_task(filename):
    print('开始下载%s...' % filename)
    time_to_download = randint(5, 10)
    sleep(time_to_download)
    print('%s下载完成! 耗费了%d秒' % (filename, time_to_download))
def main():
    start = time()
    download_task('Python从入门到住院.pdf')
    download_task('Peking Hot.avi')
    end = time()
    print('总共耗费了%.2f秒.' % (end - start))
if __name__ == '__main__':
    main()

开始下载Python从入门到住院.pdf...
Python从入门到住院.pdf下载完成! 耗费了9秒
开始下载Peking Hot.avi...
Peking Hot.avi下载完成! 耗费了10秒
总共耗费了19.01秒.

 

 

#使用多进程
from multiprocessing import Process
from os import getpid
from random import randint
from time import time, sleep
def download_task(filename):
    print('启动下载进程，进程号[%d].' % getpid())
    print('开始下载%s...' % filename)
    time_to_download = randint(5, 10)
    sleep(time_to_download)
    print('%s下载完成! 耗费了%d秒' % (filename, time_to_download))
def main():
    start = time()
    p1 = Process(target=download_task, args=('Python从入门到住院.pdf', ))
    p1.start()
    p2 = Process(target=download_task, args=('Peking Hot.avi', ))
    p2.start()
    p1.join()
    p2.join()
    end = time()
    print('总共耗费了%.2f秒.' % (end - start))
if __name__ == '__main__':
    main()

总共耗费了0.82秒.

从上面的例子可以看出;

如果程序中的代码只能按顺序一点点的往下执行，那么即使执行两个毫不相关的下载任务，也需要先等待一个文件下载完成后才能开始下一个下载任务，时间比较长。

使用Process类创建了进程对象，通过target参数我们传入一个函数来表示进程启动后要执行的代码，后面的args是一个元组，它代表了传递给函数的参数。Process对象的start方法用来启动进程，而join方法表示等待进程执行结束。运行上面的代码可以明显发现两个下载任务“同时”启动了，而且程序的执行时间将大大缩短，不再是两个任务的时间总和。下面是程序的一次执行结果。

 

转载于:https://www.cnblogs.com/liwenhui/p/11328841.html