PYTHON2.day04

day23作业：

from select import select
from socket import *
import sys
from time import ctime

s = socket()
s.bind(('0.0.0.0',8888))
s.listen(3)

#监控
rlist = [s,sys.stdin]#标准输入
wlist = []
xlist = []

#日志文件
f = open('log.txt','a')

#训话监控
while True:
    rs,ws,xs = select(rlist,wlist,xlist)
    for r in rs:
        if r is s:
            c,addr = r.accept()
            rlist.append(c)
        elif r is sys.stdin:
            f.write("%s %s"%(ctime(),r.readline()))#在终端度一行内容并写入
            f.flush()#刷新文件缓冲
        else:
            data = c.recv(1024)
            if not data:#如果客户端退出
                rlist.remove()
                r.close()
                continue
            f.write("%s %s
"%(ctime(),data.decode())) #在文件中追加当前时间...

from socket import *

#创套接字
sockfd = socket()

#发起连接
server_addr = ('172.40.71.149',8888)
sockfd.connect(server_addr)

#收发消息
while  True:
    #发
    data = input(">>")
    sockfd.send(data.encode())
    if not data:
        break
    #收
    # data = sockfd.recv(1024)
    # print("From server:",data.decode())

#关闭套接子
sockfd.close()

一.基于poll方法的IO多路复用

1.select。poll()
   功能：创建poll对象
   返回值：poll
2.p.register(fd,event)
   功能：注册关注的IO事件
   参数：fd 要关注的IO
        event 要关注的IO事件类型
             * 常用类型：POLLIN 读IO事件 (rlist)
                         POLLOUT 写IO事件(wlist)
                         POLLERR 异常IO  (xlist)
                         POLLHUP 断开连接
            *e.g.  p.register(sockfd,POLLIN)#关注套接字的读事件
                    p.register(sockfd,POLLIN|POLLERR)#关注套接字的读事件
                    p.register(sockfd)#关注所有事件（尽量不用）
        p.unregister(fd)
         功能：取消对IO的关注
         参数：IO对象或者对象的frieno
        
*函数可以返回实例化对象

3.  enents = p.poll()#对象的方法
     功能：阻塞等待监控的IO事件发生
     返回值：返回发生的IO
             events格式 [(fileno,event),()...]
             每个元组为一个就绪IO，元组第一项是该IO的fileno,
             第二项为该IO的就绪的事件类型
            
     * 需要通过fileno寻找对应的IO对象,建立对应字典确保字典中IO和关注的IO时刻保持一致
       字典格式：{fileno：io_obj}
      
4.poll_server 步骤
   【1】创建套接字
   【2】将套接字register
   【3】创建查找字典,并维护
   【4】循环建监控IO发生
   【5】处理发生的IO
   

from socket import *
from select import *

#创建要关注的IO
s = socket()
s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
s.bind(('0.0.0.0',8888))
s.listen(5)

#创建poll对象
p = poll()

#建立查找字典
fdmap = {s.fileno():s}

#注册ID
p.register(s,POLLIN|POLLERR)


#循环监控
while True:
    events = p.poll()#阻塞,返回列表
    #遍历列表，处理ＩＯ
    #元祖：fd文件描述符,event事件
    for fd,event in events:

        if fd ==s.fileno():#s就绪（监听套接字准备就绪）
            c,addr = fdmap[fd].accept()
            print("Connect from",addr)
            #添加新的注册ＩＤ
            p.register(c,POLLIN|POLLHUP)
            fdmap[c.fileno()] = c

        elif event & POLLHUP:
            print("客户端退出")
            p.unregister(fd)#取消关注
            fdmap[fd].close()
            del fdmap[fd]

        elif event & POLLIN:#真－>pollin就绪；假-->poll未就绪
            data = fdmap[fd].recv(1024)
            print("Receive:",data.decode())
            fdmap[fd].send(b'Receive your msg')

from socket import *

#创套接字
sockfd = socket()

#发起连接
server_addr = ('172.40.71.149',8888)
sockfd.connect(server_addr)

#收发消息
while  True:
    #发
    data = input(">>")
    sockfd.send(data.encode())
    if not data:
        break
    #收
    data = sockfd.recv(1024)
    print("From server:",data.decode())

#关闭套接子
sockfd.close()

            
二.基于epoll方法的IO多路复用
     * 生成对象改为epoll()
     * 生成对象事件类型改为EPOLL类型
    
     epoll特点：
         *epoll 效率比select poll 要高
         *epoll（一直申请） 监控IO数量比select（1024）多
         *epoll的触发方式比poll要多（EPOLLET边缘触发）
      

from socket import *
from select import *

#创建要关注的IO
s = socket()
s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
s.bind(('0.0.0.0',8888))
s.listen(5)

#创建poll对象
p = epoll()

#建立查找字典
fdmap = {s.fileno():s}

#注册ID
p.register(s,EPOLLIN|EPOLLERR)


#循环监控
while True:
    events = p.poll()#阻塞,返回列表
    #遍历列表，处理ＩＯ
    #元祖：fd文件描述符,event事件
    for fd,event in events:

        if fd ==s.fileno():#s就绪（监听套接字准备就绪）
            c,addr = fdmap[fd].accept()
            print("Connect from",addr)
            #添加新的注册ＩＤ
            p.register(c,EPOLLIN|EPOLLHUP)
            fdmap[c.fileno()] = c

        elif event & EPOLLHUP:
            print("客户端退出")
            p.unregister(fd)#取消关注
            fdmap[fd].close()
            del fdmap[fd]

        elif event & EPOLLIN:#真－>pollin就绪；假-->poll未就绪
            data = fdmap[fd].recv(1024)
            print("Receive:",data.decode())
            fdmap[fd].send(b'Receive your msg')

from socket import *

#创套接字
sockfd = socket()

#发起连接
server_addr = ('172.40.71.149',8888)
sockfd.connect(server_addr)

#收发消息
while  True:
    #发
    data = input(">>")
    sockfd.send(data.encode())
    if not data:
        break
    #收
    data = sockfd.recv(1024)
    print("From server:",data.decode())

#关闭套接子
sockfd.close()

 
三.struct模块的使用
1.原理：将一组金丹数据进行打包,转换为bytes格式发送。或者将一组bytes格式数据，进行解析。
2.接口使用
   [1] Struct(fmt)
       功能：生成结构化对象
       参数：fmt 定制了数据结构
       e.g. 要发送数据 1 b'zhangsan'  1.75
            fmt参数     "i8sf"(8个字串)
  [2]st.pack(v1,v2,v3...)
      功能：将一组数据按照指定格式打包转换为bytes
      参数：要打包的数据
      返回值：bytes字节串
   [3]st.unpack(bytes)
       功能：将bytes字节串按照指定的格式解析
       参数：要解析的字符串
       返回值：解析后的内容
  [4]struct.pack(fmt,v1,v2,v3...)
      struct.unpack(fmt,bytes_data)
      说明：可以使用struct模块直接调用pack unpack
            此时这两个参数传入fmd,其他用发功能相同
   

from socket import *
import struct

s = socket(AF_INET,SOCK_DGRAM)
s.bind(('0.0.0.0',8888))

#确定数据结构
st = struct.Struct('i16sf')

while True:
    data,addr = s.recvfrom(1024)
    #解析
    data = st.unpack(data)
    print(data)

s.close()

from socket import *
import struct

ADDR = ('172.40.71.149',8888)
s = socket(AF_INET,SOCK_DGRAM)

while True:
    my_id = int(input("id:"))
    name = input("name:")
    height = float(input("height:"))
    # len = len(name)

    fmt = "i16sf"
    data = struct.pack(fmt,my_id,name.encode(),height)
    s.sendto(data,ADDR)

s.close()

       
     
四.本地套接字
     1.功能：用于本地的两个程序之间进行数据的收发
     2.套接字文件：用于本地套接字之间通信时，进行数据传输的介质。
     3.创建本地套接字的流程
       【1】创建本地套接字
            socket = sorted(AF_UNIX,SOCK_STREEAM)
       【2】绑定本地套接字文件
            sockfd.bind(file)
       【3】监听，接收客户端连接，消息收发
            listen()-->accept()-->recv(),send()     
     cookie：Linux下文件类型
         b(块设备文件)     
         c(字符设备文件)  
         d(目录)
         -(普通文件)    
         l(连接文件)   
         s(套接字文件)       
         p(管道文件)
        

from socket import *
import os

#确定套接字文件
sock_file = './sock'

#判断文件是否存在，存在就删除
if os.path.exists(sock_file):
    os.remove(sock_file)


#创建本地套接字
sockfd = socket(AF_UNIX,SOCK_STREAM)

#绑定套接字文件
sockfd.bind(sock_file)

#监听，连接
sockfd.listen(3)
while True:
    c,addr = sockfd.accept()
    while True:
        data = c.recv(1024)
        if not data:
            break
        print(data.decode())
    c.close()
sockfd.close()

from socket import *

#确保两边使用同一个套接字文件
sock_file = './sock'
sockfd = socket(AF_UNIX,SOCK_STREAM)
sockfd.connect(sock_file)

while True:
    msg = input(">>")
    if not msg:
        break
    sockfd.send(msg.encode())

sockfd.close()

    
五.多任务编程
     1.意义：充分利用计算机多核咨询,提高程序的运行效率
     2.实现方案：多进程 ，多线程
     3.并行，并发概念
       * 并发：同时处理多个任务，内核咋任务间不断切换达到多个任务被同时执行的效果，
               实际每个时刻只有一个任务占有内核
       * 并行：多个任务利用计算机多核资源在同时执行，此时多个任务间同时为并行关系。
      
      
六.进程(process)
    1.定义：程序在计算机中的一次运行
      * 程序是一个可执行的文件是静态的占有磁盘
      * 进程是一个动态的过程描述，占有计算机运行资源,有一定的生命周期
     
    2. 如何产生一个进程
       【1】用户空间通过调用程序接口命令发起请求
       【2】操作系统接收用户请求，开始创建进程
       【3】操作系统调配计算机资源，确定进程状态等
       【4】操作系统将创建的进程提供给用户使用
    3.进程概念
        * cpu时间片：如果一个进程占有cpu内核则称这个进程在cpu时间片上
        *PCB（进程控制块）：在内存中开辟的一块空间，用于存放进程的基本信息，
             也用于系统查找识别进程
        *进程ID(PID):系统为每个进程分配的一个大于0 的整数，作为进程ID，每个ID不会重复。
       
        Linux查看进程ID：ps -aux
       
        * 父子进程：系统中每一个进程(除了系统初始化进程)
         都有唯一的父进程，可以有0个或多个子进程。父子进程关系便于进程管理
        
         查看进程树：pstree

         *进程状态
              三态：
                  就绪态：进程具备执行条件。等待分配cup资源
                  运行态：进程占有cpu时间片正在运行
                  等待态：进程暂停时停止运行。
              五态：
                  新建：创建一个进程，获取资源的过程
                  终止：进程结束，释放资源的过程
                 
             状态查看命令:ps -aux --->STAT列
            
             S 等待态
             R 执行态
             D 等待态
             T 等待态
             Z 僵尸     
      
             < 有较高优先级
             N 优先级较低
             + 前台进程
             s 会话组组长
             l 有多线程的
            
            

面试要求：1.什么是进程，进程和程序有什么区别
           2.进程有哪些状态，状态之间如何转化
          
作业：1.对要求问题总结回答
       2.整理网络编程重点程序
       能够自己写出 tcp服务器 udp服务端  select服务端  poll服务端