网络通信 进程 多任务

#操作系统：一个用来协调、管理和控制计算机硬件和软件资源的系统程序。
windows7\ win10–个人pc
Linux–服务器环境# MAC—个人pc
#cpu 主板 硬盘 显示器
#想让这些硬件配合使用。这时候就需要一个’大管家‘–os

#http://是一个客户端终端（用户）和服务器端（网站）请求和应答的标准,默认端口为80
#https：在http基础上添加一个证书校验。（安全）–默认端口：443
#工作原理：1，客户端连接到web服务器
#2，发送http请求–包含请求头（headers）\数据体、请求行、空行。
#3，服务器接收到请求后作出响应。
#4，释放连接TCP连接
#5，浏览器解析文本内容，进行显示。

#请求方法：
#1，GET–得到【1,2重点】
#2，POST–邮递
#3，PUT

#http状态码
1xx：客户端发起请求，服务器拿到了，正在处理。
#2xx：成功
#3xx：重定向
#4xx：客户端错
#5xx：服务端错

#网络通信;（urllib）
#通信模块：1，urllib 2，requests—爬虫阶段会学到
#client–(request)–server—(response)—client由客户端请求服务端，服务端回复客户端。
#url：统一资源定位器–路径
#urllib是基于http的高层库，有以下3个功能：
#1，requset处理客户端请求 2，response处理服务端响应 3，parse解析url
#使用方法：1，必须有一个url–字符串，2，发起请求并得到响应 response=requset.urlopen(url)

进程，编程高效率开发，多任务。
程序运行的效率：1，同样完成一个功能，我的代码执行效率高于别人。(从自身找原因，使用多任务去提高效率)
2，提升硬件：加cpu\内存、换硬盘（固态）。。
cpu：理解成人的大脑
#双核，四核：一个头2个大脑，4个大脑

python在实现多任务的方式有三种：进程、线程、协程

#进程：在我们的操作系统中，每个软件就是一个单独的进程。例：QQ，浏览器
#特点：具有独立的内存空间。
#多任务：在听音乐的同时，办公。
#一个程序在运行时，默认在一个主程序当中，用if name=main:表示主程序
#程序与程序之间是相互独立的

#创建进程的方法：
#方法一：直接导入Process并使用
#Process（group[,target[,name[,args[,kwargs]]]])
#target：进程所调用的对象，一般情况跟函数名，记得不要有括号。
#name;进程的名字
#ages：调用对象的位置参数，是一个元组。注意：如果参数只有一个，一定要加逗号
#kwargs：关键字参数，是一个字典
#方法二：创建一个进程类，这个进程一定要继承’Process’类

#启动进程,格式：进程对象.start（）
#阻塞进程，格式：进程对象.join(timeout)是否等待进程执行结束，timeout表示超时时间
#查看当前进程id：os.getpid()
#当前进程的父进程id: os.getppid()

#进程池
#当需要创建的字进程数据不多时，可直接使用进程创建的方法一或二。
#但如果需要创建很多进程时，手动去创建的工作量变得太大，所以这个时候我们就用到进程池。
#池： 体量不是太大，也不是太小，可控状态。。水位–进程个数的多少，容量有限。
#创建进程池：
#步骤1：导入模块 from multiprocessing import Pool
#步骤2：创建，，格式：Pool(n)#n表示进程的个数，如果省略基本上可以理解为不设上限’p=Pool()
#进程池的好处：比如有一百个文件需要下载，每个文件都创建一个单独的进程，会消耗很大的系统资源。
#eg:创建进程，需要给进程分配独立的内存空间和资源，当资源结束后，需要回收。
#只创建3个进程，使用每个进程执行不同的任务。对这几个进程进行管理（分配任务），就需要使用进程池。

#图片的下载

from  urllib import request#网络通信模块
#相对路径：seventeenth.py
#绝对路径：D:\workpy\第四周\seventeenth.py
def downloader(url,isPicture=False):
    '''
    :param ur1:网址
    :param isPicture:默认是Flase值，表示是文本，如果下载的是图片，此值将赋值为True
    :return:none直接保存成文件，不需要返回值
    '''
    #路径最后的为文件名
    file_name=url.split('/')[-1]
    #请求得到响应
    response=request.urlopen(url)#回复=
    #查看得到响应
    content=response.read()#赋予一个变量 内容

    #图片和文本区别保存
    if isPicture:
        with open(file_name,'wb') as fq:#‘wb'以二进制的方式写入
            fq.write(content)
    else:
        content=content.decode('utf-8')#如果不是图片 转化格式
        with open(file_name,'w',encoding='utf-8') as fq:
            fq.write(content)

downloader('https://www.baidu.com/img/bd_logo1.png',isPicture=True)

#多进程，编程实现唱歌跳舞这件事
#多任务：操作系统可以运行多个任务，单个CPU在任何时候只能执行一个任务。因为CPU运算速度实在是太快了。

#导入模块，进程实现多任务步骤。
import time
from multiprocessing import Process
#边唱歌 边跳舞 并行操作，提高操作效率
def sing():
    for i in range(3):
        time.sleep(1)
        print('唱歌')
def dance():
    for i in range(3):
        time.sleep(1)
        print('跳舞')
if __name__ == '__main__':
    # 创建进程
    p = Process(target=sing)
    # 启动
    p.start()
    dance()

#下载器：多图片下载

import os
from  urllib import request
from multiprocessing import Process
def downloader(ur1,**kwargs):
    print('当前进程id',os.getpid(),os.getppid())#子进程id 与 子进程的父进程id

print('关键参数',kwargs['pro'])
#文件名
file_name=ur1.split('/')[-1]
#网络请求
response = request.urlopen(ur1)
#获取响应
content=response.read()
#保存
with open(file_name,'wb') as fp:
        fp.write(content)
if __name__ == '__main__':
    # for i in range(1,5):
    #     ur1='http://www.langlang2017.com/img/banner'+str(i)+'.png'
    #     print(ur1)
    #     p=Process(target=downloader,args=(ur1,))
    #     p.start()
    ur1_list=['http://www.langlang2017.com/img/banner1.png',
              'http://www.langlang2017.com/img/banner1.png']

name_list=['张三','张四']#赋予子进程的name

p_list=[]#进程列表
i=0
for ur1 in ur1_list:#两个子进程属于并行关系
    n=name_list[i]
    i=i+1
    p = Process(target=downloader,name=n, args=(ur1,),kwargs={'pro':'最高等级'})
    print('子进程%s将要被运行'%p.name)
    p.start()
    p_list.append(p)#将子进程键入 进程列表

for p in p_list:#当所有子进程运行完 开始父进程
    p.join()#阻塞  当子进程 运行完 开始父进程
print('主进程id',os.getpid())

print('----所有文件下载完成----')

#面向对象的 创建进程的方法

from  urllib import request
import os
from multiprocessing import Process

#步骤1：继承Process类
class Process_Class(Process):

#因为Process类本身也有__init__方法，这个子类相当于重写了这个方法
#但这样会带来一个问题，我们并没有完成的初始化一个进程类，所以就不能使用这个类继承的一些方法和属性
#步骤2：使用父类的初始化方法初始类
def __init__(self,url):
    Process.__init__(self)
    self.url=url
#步骤3：重写Process类中的 run方法
def run(self):
    print('当前进程id', os.getpid(), os.getppid())  # 子进程id 与 子进程的父进程id
    # 文件名
    file_name =self. url.split('/')[-1]
    # 网络请求
    response = request.urlopen(self.url)
   # 获取响应
    content = response.read()
    # 保存
    with open(file_name, 'wb') as fp:
        fp.write(content)
if __name__ == '__main__':
    ur1_list = ['http://www.langlang2017.com/img/banner1.png',
                'http://www.langlang2017.com/img/banner1.png']
    for url in ur1_list:
        p=Process_Class(url)
        p.start()

#进程池

from  multiprocessing import Pool
import time,random
def worker(msg):
    t_start=time.time()
    print('%s--开始执行'%msg)
    time.sleep(random.random())#模拟工作所消耗的时间
    time.sleep(0.5)
    t_end=time.time()
    print('%s-执行完毕，消耗时间为：%0.2f'%(msg,t_end-t_start))

if __name__ == '__main__':
    p=Pool(3)#创建一个容量为3的进程池
    for i in range(10):
        #将进程添加到进程池，
        #格式：进程池.apply_async(func=单个进程要调用的目标，args=（参数1，参数2...））
        #每次循环将会用空闲的子进程去调用目标
        p.apply_async(func=worker,args=(i,))#异步）操作
        #p.apply(func=worker,args=(i,))#串行操作
    print('----------start----------')
    #关闭进程池，关闭后进程池将不再接受新的任务
    p.close()
    #等待进程池中的所有子程序都结束后，注意：join一定要放在close后面。
    p.join()
    print('-----------end------------')