my python day7

一、异常处理

　　什么是异常？异常是程序运行时发生错误的信号（程序发生错误时，不处理，就会抛出异常）

　　错误分为 1.语法错误2.逻辑错误

　　异常包括三部分：异常追踪信息、异常类、异常值。

　　异常处理方法：

　　1.如果错误发生的条件是可预知的，我们需要用if来处理，在错误发生之前来预防.

age = 10
while True:
    a = input("<<<").strip()
    if a.isdigit():
        a = int(a)
        if a== age:
            print("you got it ")
            break

2.如果错误发生的条件是不可预知的，用try...expect，在错误发生之后进行处理.

t = (i for i in range(5))
while True:
    try:
        print(t.__next__())
    except StopIteration:
        print("finish")
        break

t = (i for i in range(5))
while True:
    try:
        print(t.__next__())
    except StopIteration:
        print("finish")
        break
    else:
        print("没有异常")   #当try执行时,else就会执行
    finally:
        print("无论异常与否，都会打印")

二、网络编程

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。

也有人将socket说成ip+port，ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序，ip地址是配置到网卡上的，而port是应用程序开启的，ip与port的绑定就标识了互联网中独一无二的一个应用程序,而程序的pid是同一台机器上不同进程或者线程的标识.
套接字ipc：一台主机上多个应用程序之间的通讯。套接字有两种，一种基于文件类型套接字：家族名：AF_UNIX 另一种基于网络类型套接字:家族名：AF_INET

客户端与服务端的交互过程：从服务端说起：创建一个socket对象，然后与端口进行绑定bind，对端口进行监听listen，调用accept阻塞直到客户端进行连接，客户端初始化一个socket对象，调用connect与服务端进行连接,向服务端发送请求，客户端接受并处理请求，然后把回应数据，客户端获得数据，最后关闭连接，一次交互就结束。

#实例化socket对象
import socket
socket.socket(socket_family,socket_type,protocal=0)
socket_family :套接字家族，AF_UNIX（基于文件）AF_INET(基于网络)
socket_type:SOCK_STREAM(流),SOCK_DGRAM

获取tcp/ip套接字
tcp_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
获取udp/ip套接字
udp_socket = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
from socket import *
tcp_socket = socket(AF_UNIX,SOCK_STREAM)
udp_socket = socket(AF_INET,SOCK_DGRAM)

s= socket(socket.AF_INET,socket.SOCK_STREAM)
服务端套接字函数
s.blid() 绑定（主机，端口号)到套接字
s.listen() 开始tcp监听
s.accept() 阻塞，直到客户端进行连接
客户端套接字函数
s.connect() tcp服务端连接
#公共用途套接字函数
s.recv()接受tcp数据
s.send（）发送tcp数据
s.recvfrom()接受udp数据
s.sendto()发送udp数据

s.close()关闭套接字

#tcp客户端
import socket
tcp_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
tcp_server.bind(("127.0.0.1",8000))
tcp_server.listen(5)
conn,addr = tcp_server.accept()
print(conn,addr)
data = conn.recv(1024)
print("接受客户端的信息",data.decode("utf-8")) #接受信息
conn.send(data.upper())
conn.close()
tcp_server.close()
# tcp服务端
import socket
tcp_client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
tcp_client.connect(("127.0.0.1",8000))
tcp_client.send(b"hello")  #发送信息
data2 = tcp_client.recv(1024)
print("接受服务端的信息:",data2.decode("utf-8"))
tcp_client.close()

#udp服务端
import socket
udp_server = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
udp_server.bind(("127.0.0.1",8000))
msg,addr = udp_server.recvfrom(2014)
print("接受客户端的信息",msg.decode("utf-8"))
udp_server.sendto(msg.upper(),addr)
import socket                                                      
udp_client = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)       
udp_client.sendto(b"hello",("127.0.0.1",8000))                     
msg,addr = udp_client.recvfrom(1024)                               
print("接受服务端的信息",msg.decode("utf-8"))                              

基于tcp的套接字

tcp是基于链接的，必须先启动服务端，然后再启动客户端去链接

#tcp服务端
1 ss = socket() #创建服务器套接字
2 ss.bind()      #把地址绑定到套接字
3 ss.listen()      #监听链接
4 inf_loop:      #服务器无限循环
5     cs = ss.accept() #接受客户端链接
6     comm_loop:         #通讯循环
7         cs.recv()/cs.send() #对话(接收与发送)
8     cs.close()    #关闭客户端套接字
9 ss.close()        #关闭服务器套接字(可选)

#tcp客户端
1 cs = socket()    # 创建客户套接字
2 cs.connect()    # 尝试连接服务器
3 comm_loop:        # 通讯循环
4     cs.send()/cs.recv()    # 对话(发送/接收)
5 cs.close()            # 关闭客户套接字

udp是无链接的，先启哪一端都可以

#udp服务端
1 ss = socket()   #创建一个服务器的套接字
2 ss.bind()       #绑定服务器套接字
3 inf_loop:       #服务器无限循环
4     cs = ss.recvfrom()/ss.sendto() # 对话(接收与发送)
5 ss.close()                         # 关闭服务器套接字

cs = socket()   # 创建客户套接字
comm_loop:      # 通讯循环
    cs.sendto()/cs.recvfrom()   # 对话(发送/接收)
cs.close()                      # 关闭客户套接字

#加入一条socket配置，重用ip和端口

phone=socket(AF_INET,SOCK_STREAM)
phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
phone.bind(('127.0.0.1',8080))

三、进程

操作系统：一个用来协调、管理计算机硬件和软件资源的系统程序

多道程序设计:提高cpu利用率

进程：一个程序在一个数据集上的一次动态执行过程，负责执行任务的是cpu。

 进程包含三部分:程序、数据集、进程控制块。

进程是最小的资源单位

并发:是指系统具有处理多个任务的能力，而一个cpu在同一时刻只能处理一个任务，单个cpu+多道程序设计实现并发

并行:是指系统在同一时刻具有处理多个任务的能力，只有具备多个cpu才能实现

同步：一个进程执行任务的时候，一直等到任务完成，而进程一直处于激活状态

异步：一个进程执行一个任务的时候，不会等到任务完成才执行，当任务完成后，再回来处理。

阻塞调用是指调用结果返回之前，当前线程会被挂起（如遇到io操作）。函数只有在得到结果之后才会将阻塞的线程激活

多进程：由于GIL存在，python中的多线程并不是真正的多线程，如果要充分使用cpu资源，大部分使用的是多进程.

multiprocessing模块

多进程应该避免共享资源。在多线程中，我们可以比较容易地共享资源，比如使用全局变量或者传递参数。在多进程情况下，由于每个进程有自己独立的内存空间，以上方法并不合适。此时我们可以通过共享内存和Manager的方法来共享资源。但这样做提高了程序的复杂度，并因为同步的需要而降低了程序的效率。

Process类

创建的是子进程
Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）

强调：
1. 需要使用关键字的方式来指定参数
2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号

参数介绍
1 group参数未使用，值始终为None
2 
3 target表示调用对象，即子进程要执行的任务
4 
5 args表示调用对象的位置参数元组，args=(1,2,'egon',)
6 
7 kwargs表示调用对象的字典,kwargs={'name':'egon','age':18}
8 
9 name为子进程的名称
方法介绍:
p.start() ,启动进程，调用子进程中run方法
p.run()进程启动调用的方法，自定义类中必须实现该方法
p.terminate()强制终止进程
p.is_alive() 判断进程是否执行
p.join() 主进程等待p终止，主进程等待，子进程处于运行状态,或达到运行timeout。
属性介绍：
p.daemon:默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置.
p.name:进程的名字
p.pid:进程号

p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可)

p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）

注意：在windows中Process()必须放到# if __name__ == '__main__':下
创建并开启子进程的两种方式:

import time                                                   
import random                                                 
from multiprocessing import Process                           
def print_name(name):                                         
    time.sleep(random.randint(1,3))                           
    print("my name is %s"%name)                               
                                                              
p1 = Process(target=print_name,args=("Ezhizen",))  #必须加,      
p2 = Process(target=print_name,kwargs={"name":"Ryoma"})       
                                                              
p1.start()    #启动进程p1                                         
p2.start()    #启动进程p2                                         
p1.join()    #等待p1运行完成                                        
p2.join()     #等待p2运行完成                                       
print("welcome")                                              
                                                              

import multiprocessing                                 
class MyProcess(multiprocessing.Process):  #继承Process类 
    def __init__(self,name):                           
        super(MyProcess,self).__init__()               
        self.name = name                               
    def run(self):                                     
        time.sleep(random.randint(1,3))                
        print("my name is %s"%self.name)               
                                                       
                                                       
                                                       
p1= MyProcess("Ezhizen")                               
p2 = MyProcess("Ryoma")                                
p1.start()                                             
p2.start()                                             
p1.join()                                              
p2.join()                                              
print(" Echizen Ryoma")                                

from multiprocessing import Process
from threading import Thread
import time
def foo():
    print(123)
    time.sleep(1)
    print("end123")

def bar():
    print(456)
    time.sleep(3)
    print("end456")


p1=Process(target=foo)
p2=Process(target=bar)

p1.daemon=True
p1.start()
p2.start()
# time.sleep(1)
print("main-------")#打印该行则主进程代码结束,则守护进程p1应该被终止,可能会有p1任务执行的打印信息123,因为主进程打印main----时,p1也执行了,但是随即被终止

进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的,

而共享带来的是竞争，竞争带来的结果就是错乱，如何控制，就是加锁处理.

#加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行的修改，没错，速度是慢了，但牺牲了速度却保证了数据安全。
虽然可以用文件共享数据实现进程间通信，但问题是：
1.效率低（共享数据基于文件，而文件是硬盘上的数据）
2.需要自己加锁处理

#由并发变成了串行,牺牲了运行效率,但避免了竞争
from multiprocessing import Process,Lock
import os,time
def work(lock):
    lock.acquire()
    print('%s is running' %os.getpid())
    time.sleep(2)
    print('%s is done' %os.getpid())
    lock.release()
if __name__ == '__main__':
    lock=Lock()
    for i in range(3):
        p=Process(target=work,args=(lock,))
        p.start()

为了解决这个问题，采用队列和管道的方法。

Queue([maxsize]):创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。 
maxsize 是队列中最大允许项数

1 q.put方法用以插入数据到队列中，put方法还有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，该方法会阻塞timeout指定的时间，直到该队列有剩余的空间。如果超时，会抛出Queue.Full异常。如果blocked为False，但该Queue已满，会立即抛出Queue.Full异常。
2 q.get方法可以从队列读取并且删除一个元素。同样，get方法有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，那么在等待时间内没有取到任何元素，会抛出Queue.Empty异常。如果blocked为False，有两种情况存在，如果Queue有一个值可用，则立即返回该值，否则，如果队列为空，则立即抛出Queue.Empty异常.
3  
4 q.get_nowait():同q.get(False)
5 q.put_nowait():同q.put(False)
6 
7 q.empty():调用此方法时q为空则返回True，该结果不可靠，比如在返回True的过程中，如果队列中又加入了项目。
8 q.full()：调用此方法时q已满则返回True，该结果不可靠，比如在返回True的过程中，如果队列中的项目被取走。
9 q.qsize():返回队列中目前项目的正确数量，结果也不可靠，理由同q.empty()和q.full()一样

import time,random,os
def consumer(q):
    while True:
        res=q.get()
        time.sleep(random.randint(1,3))
        print('33[45m%s 吃 %s33[0m' %(os.getpid(),res))

        q.task_done() #向q.join()发送一次信号,证明一个数据已经被取走了

def producer(name,q):
    for i in range(10):
        time.sleep(random.randint(1,3))
        res='%s%s' %(name,i)
        q.put(res)
        print('33[44m%s 生产了 %s33[0m' %(os.getpid(),res))
    q.join()


if __name__ == '__main__':
    q=JoinableQueue()
    #生产者们:即厨师们
    p1=Process(target=producer,args=('包子',q))
    p2=Process(target=producer,args=('骨头',q))
    p3 = Process(target=producer, args=('泔水', q))

    # 消费者们:即吃货们
    c1 = Process(target=consumer, args=(q,))
    c2 = Process(target=consumer, args=(q,))
    c1.daemon = True
    c2.daemon = True

    # 开始
    p_l = [p1, p2, p3, c1, c2]
    for p in p_l:
        p.start()

    p1.join()
    p2.join()
    p3.join()
    print('主')

四、线程
线程 为了降低上下文切换的消耗，提高系统的并发性，突破一个进程只能做一件事的缺陷，线程是最小的执行单元。
1.一个程序至少有一个进程，一个进程至少有一个线程。
2.进程在执行过程中拥有独立的内存单元，而多个线程共享共存的，从而提高程序的运行效率。
3.每个独立的线程有一个程序运行的入口，顺序执行序列和程序的出口。线程不能独立执行，必须依存在应用程序上。
4.进程是具有一定独立功能的程序，关于数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个独立单元。
5.一个线程可以创建和撤销另一个线程。
6.线程是进城的实体，是cpu调整和分配的基本单位。
7.同一个进程中多个线程可以并发执行。
启动线程的两种方法

import threading
import time
def print_name(name):
    time.sleep(3)
    print("my name is %s"%name)

t = threading.Thread(target=print_name,args=("Ezhizen",))
t.start()
print("dddddd")

import threading,time
class Mythread(threading.Thread):
    def __init__(self,name):
        super(Mythread,self).__init__()
        self.name = name
    def run(self):
        time.sleep(3)
        print("my name is %s"%self.name)
t = Mythread("Ezhizen")
t.start()
print("jjjj")

from  threading import Thread
from multiprocessing import Process
import os
def work():
    global n
    n=0


n=100
p=Process(target=work)
p.start()
p.join()
print('主进程',n) #毫无疑问子进程p已经将自己的全局的n改成了0,但改的仅仅是它自己的,查看父进程的n仍然为100


n=1
t=Thread(target=work)
t.start()
t.join()
print('主线程',n) #查看结果为0,因为同一进程内的线程之间共享进程内的数据

Thread实例对象的方法
  # isAlive(): 返回线程是否活动的。
  # getName(): 返回线程名。
  # setName(): 设置线程名。

threading模块提供的一些方法：
  # threading.currentThread(): 返回当前的主线程变量。
  # threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
  # threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

#1.对主进程来说，运行完毕指的是主进程代码运行完毕

#2.对主线程来说，运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕，主线程才算运行完毕

#1 主进程在其代码结束后就已经算运行完毕了（守护进程在此时就被回收）,然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)，才会结束，

#2 主线程在其他非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。因为主线程的结束意味着进程的结束，进程整体的资源都将被回收，而进程必须保证非守护线程都运行完毕后才能结束。

from threading import Thread
import time
def foo():
    print(123)
    time.sleep(1)
    print("end123")

def bar():
    print(456)
    time.sleep(3)
    print("end456")


t1=Thread(target=foo)
t2=Thread(target=bar)

t1.daemon=True
t1.start()
t2.start()
print("main-------")

锁的目的是为了保护共享的数据，同一时间只能有一个线程来修改共享的数据

from threading import current_thread,Thread,Lock
import os,time
def task():
    global n
    print('%s is running' %current_thread().getName())
    temp=n
    time.sleep(0.5)
    n=temp-1


if __name__ == '__main__':
    n=100
    lock=Lock()
    threads=[]
    start_time=time.time()
    for i in range(100):
        t=Thread(target=task)
        threads.append(t)
        t.start()
    for t in threads:
        t.join()

    stop_time=time.time()
    print('主:%s n:%s' %(stop_time-start_time,n))

线程中的队列

import queue
q = queue.Queue()   #先进先出
q.put(1)
q.put(2)
q.put(3)
print(q.get())
print(q.get())
print(q.get())
q2 = queue.LifoQueue()  #后进先出
q2.put(1)
q2.put(2)
q2.put(3)
print(q2.get())
print(q2.get())
print(q2.get())
q3 = queue.PriorityQueue()  #设置优先级
q3.put((3,"a"))
q3.put((2,"b"))
q3.put((1,"c"))
print(q3.get())
print(q3.get())
print(q3.get())

五、协程

协程：是单线程下的并发，又称微线程，纤程

1. 必须在只有一个单线程里实现并发
2. 修改共享数据不需加锁
3. 用户程序里自己保存多个控制流的上下文栈
4. 附加：一个协程遇到IO操作自动切换到其它协程（如何实现检测IO，yield、greenlet都无法实现，就用到了gevent模块（select机制））

greenlet运用

from greenlet import greenlet

def eat(name):
    print('%s eat 1' %name)
    g2.switch('egon')
    print('%s eat 2' %name)
    g2.switch()
def play(name):
    print('%s play 1' %name)
    g1.switch()
    print('%s play 2' %name)

g1=greenlet(eat)
g2=greenlet(play)

g1.switch('egon')#可以在第一次switch时传入参数，以后都不需要

gevent的运用

g1=gevent.spawn(func,1,,2,3,x=4,y=5)创建一个协程对象g1，spawn括号内第一个参数是函数名，如eat，后面可以有多个参数，可以是位置实参或关键字实参，都是传给函数eat的

g2=gevent.spawn(func2)

g1.join() #等待g1结束

g2.join() #等待g2结束

#或者上述两步合作一步：gevent.joinall([g1,g2])

g1.value#拿到func1的返回值

遇到IO阻塞时会自动切换任务

from gevent import monkey;monkey.patch_all()
import gevent
import requests
import time

def get_page(url):
    print('GET: %s' %url)
    response=requests.get(url)
    if response.status_code == 200:
        print('%d bytes received from %s' %(len(response.text),url))


start_time=time.time()
gevent.joinall([
    gevent.spawn(get_page,'https://www.python.org/'),
    gevent.spawn(get_page,'https://www.yahoo.com/'),
    gevent.spawn(get_page,'https://github.com/'),
])
stop_time=time.time()
print('run time is %s' %(stop_time-start_time))