Python网络编程（weekly summary1）

网络的目的是什么？

    用于信息传输、接受  能把各个点、面、体的信息链接到一起 实现资源的共享

OSI模型：

    应用层：提供程序服务

    表示层：数据加密、优化、压缩

    会话层：建立链接、传输服务

    传输层：提供数据传输服务

    网络层：路由选择 网路互联

    连表层：链接交换

    物理层：硬件、接口、网卡规定等

    特点：

       将功能分开来达到高内聚低耦合

       让开发更为清晰

什么是网络协议？

    是为了完成计算机网络通讯而制定的规则、约定、标准

各模型使用的协议：

    应用层：TFTP（文件传输）、HTTP（超文本传输协议）、DNS(域名解析)、SMTP（邮件传输）

    传输层：TCP（面向有链接的可靠的传输服务）、UDP（面向无连接的不可的传输靠服务）

    网络层：IP（IP地址）常用IPV4：点分十进制   取值0~256之间（32位）  IPV6：:128位

    物理层：IEEE

特殊IP：

   127.0.0.1      本机IP

   0.0.0.0        自动使用本地可用网卡IP

   192.168.1.0    代表网段

   192.168.1.1    通常为网关地址

   192.198.1.255  广播地址

端口：

  取值范围1~65535之间

  1~255      一些通用端口

  256~1023   系统端口

  1024~65535 自用端口

Linux命令：

     ifconfig   查看本机IP

     ping IP    查看延迟

     ps -aux    查看系统进程信息

     chmod      设置文件权限

     nice -9 ./hello.py  以9的优先级运行

     pstree     查看进程树

     ps -ajx    查看父子进程ID

Linux下文件类型：

      bcd -lsp

         b（快  设备文件）

         c（字符设备文件）

         d（目录）

         -（普通文件）

         l（链接文件）

         s（套接字文件）

         p（管道文件） 

ps -aux   查询结果的 STAT表示进程状态：

    D  等待态  阻塞  不可中断等待态

    S  等待态  睡眠  可中断等待态

    T  等待态  暂停  暂停执行

    R  运行态（就绪态）

    Z  僵尸

      +  前台进程（在终端运行）

      <  有较高优先级的进程

      N  较低优先级的进程

       s  回话组

       l  有子进程链接

    进程优先级：

        取值范围：-20~19   -20最高

Python socket模块

     socket.gethostname()  获取本机名

     socket.gethostbyname("主机名")   利用主机名获取IP

     soccket.gethostbtname（“IP”）  获取本地IP

IP的十六进制转换：

    socket.inet_aton(IP)       十进制转十六进制

    socket.inet_atoa(十六进制) 十六进制转十进制

    socket.gethostbyaddr('127.0.0.1')

      返回值：元组（主机， 别名，ip地址）

    socket.getservbyname("程序名")   获取程序端口

套接字：是通过编程语言提供的套接字编程借口

传输层服务：

    tcp：（SOCK_STREAM）

      面向有链接的可靠的传输服务   流式套接字

      1.创建套接字：

             socket = socket.socket（）

      2.绑定地址：

             socket.bind

      3.设置监听：

             socket.listen（）

      4.等待客户端链接：

            socket.accept（）

      5.消息收发：

            socket.recv（4096）

            socket.send（“”）

      6.关闭套接字：

            socket.close（）

      客户端：

         1.创建套接字

            socket.socket.socket()

         2.发起链接

               socket.connect(地址)

         3.消息收发

               socket.recv(1024)  收消息

               socket.send("")    发消息

               socket.sendall（）：

                   事物发消息 成功返回None 失败异常

         4.关闭套接字

                socket.close（）

      recv特性：

           建立链接的另一端被断开，会返回一个空字符串  从缓冲区取内容

      send特性：

           另一端不纯在产生一个pipe Broken 异常  向缓冲区写内容

      缓冲区：

           减少和和磁盘交互协调数据收发  提高效率

      粘包：

           由于tcp是数据流套接字的原因每次发送的数据间

           没有边界一次取不完下次取数据时会形成粘包

    udp：（SOCK_DGRAM）

      面向无连接的不可靠的传输服务 数据报套接字

            socket = socket.socket（AF_INET,SOCK_DGRAM）

            socket.bind（）

      3.收发消息：

            socket.recvfrom（）

            socket.sento()

      4.关闭套接字：

          1.创建套接字：

            socket = socket.socket()

          2.收发消息;

            socket.recvform()

            socket.sendto(“”， 地址)

          3.关闭套接字：

            socket.close()

sys.argv() 命令行获取参数

返回值：

    元组：sys.argv[0] 开始  空格隔开 引号隔开

套接字属性方法:

     套接字的属性：

            socket.type

     地址类型：

            socket.family

     套接字IO描述符：

            socket.fileno()

            系统IO描述符：

               sys.stdin = 0

               sys.stdout = 1

               sys.stderr = 2

     获取套接字地址：

             socket.getsockname()

     获取套接字客户端地址：

             socket.getpeername()

     设置端口重用：

             socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)

     获取套接字选项值：

             socket.getsockopt()

     设置为非阻塞状态:

             socket.setblocking(False)

     超时检测：

             socket.settimeout（sec）

HTTP协议（超文本传输协议）：

     网站浏览器获取网页的一种协议

     并且所有的www.文件都必须遵守这个标准

HTTP请求：

      1.请求行：

            说明具体的请求类别和内容

           GET        /index.html    /HTTP/1.1

         请求类别      请求内容       协议版本

      请求类别：

         GET：              获取网络资源

         POST：           提交一定的附加数据

         HEAD：          获取响应头

         PUT：             更新服务器资源

         DELETE：        删除服务器资源

         CONNECT：   未使用

         TRACE：         用于测试

         OPTIONS：    获取服务器性能信息

      2.请求头：

            对请求的具体描述

      3.空行

      4.请求体：

            具体的参数或提交的内容

HTTP响应：

      1.响应行:反馈具体的响应情况

          HTTP/1.1     20       OK

          版本协议   响应码   附加信息

       响应吗：

           1xx：提示信息，表示请求已经接收

           2xx：响应成功

           3xx：响应需要定向（重新记载链接第三方链接）

           4xx：客户端错误

           5xx：服务器端错误

      2.响应头：

         对响应内容的具体描述

      4.响应体：

         将客户端请求内容进行返回

IO：

    在内存中存在数据交换的操作可以认为是IO操作（输入输出）

    IO密集程序：

         大量的IO操作，消耗CPU较少

    CPU密集程序：

         大量的内存CPU运算，IO相对较少

IO分类：

    阻塞IO：

       因为某些条件没有达成 导致程序堵塞 如：input函数

    非阻塞IO：

       改变阻塞函数的状态不让其阻塞

IO多路复用：

     通过一个监测

     监控多个IO事件的行为，

     哪个IO事件准备就绪就执行哪个IO事件

IO准备就绪：

     IO事件即将发生时的临界状态

select模块

      监控IO事件

      rs， ws， xs = select（rlist， wlist， xlist[， timeout]）

      rlist：  等待处理的IO

      wlist：  主动处理的IO

      xlist：  出错希望去处理的IO

位运算：

   按照二进制位进行位运算操作

    & 按为与   |  按位或   ^  按位异或    << 左异    >>右移

poll方法实现IO多路复用：

   1.创建poll对象：

       p = select.poll

   2.注册关注的IO：

       p.register(s， POLLIN | PLLERR)

       不关注：

          p.unregister(s)

       事件类别：

          POLLIN  POLLOUT  POLLERR  POLLHUP   POLLPRI

            rlist           wlist          xlist          断开       紧急处理 

   3.监控IO：

       events = p.poll（）

       功能：监控关注的IO事件

       返回值：

           返回发生IO事件

   events是一个列表[(fileno, evnet), (), ()....]

   每个就绪IO对应一个元组（描述符，就绪事件）

           IO地图：{s.fileno():s}

   4.处理IO事件

本地套接字：

   作用：

      用于本地文件不同程序间进行数据传输

   本地套接字传输流程：

      1.创建本地套接字对象

          sockfd = socket（AF_UNIX, SOCK_STREAM）

      2.绑定套接字文件，如果文件不存在则自动创建 存在则报错

         sockfd.bind（file）

      3.监听

         listen

      4.消息收发

         recv send

多任务编程：

     通过程序利用计算机的多个核心达到同时执行多个任务的目的

     因此达到提升程序运行效率的目的

     并行：

        多个计算机核心在同时处理多个任务，

        这时多个任务之间是并行关系

     并发：

        同时运行多个任务，内核在多个任务之间的不断切换，

        达到多个任务都会执行的处理效果

        此时多个任务之间是并发关系

     程序:

        可执行文件，是静态的，只占有磁盘

     进程：

        是一个动态过程  程序的运行过程

     CPU时间片：

         如果有个进程占有CPU此时我们称为该进程占有CPU的时间片

         多个进程任务或轮流占有CPU时间片并形成并发效果

    进程特征：

        进程是操作系统分配资源的最小单元

        每个进程拥有自己独立的运行空间（4个G的虚拟内存空间）

        进程之间相互独立各不影响

    进程的状态：

        三态：

            就绪状态：

                 进程具备执行条件，等待系统分配处理器资源进入运行态

            运行态：

                 进程占有CPU处于运行状态

            等待态：

                 进程暂时不具备运行条件，需要阻塞等待

        五态：

             在三态的基础上增加新建和终止态 

             新建：

                  创建一个新的程序，获取系统资源的过程

             终止：

                  进程执行结束，释放资源的过程

OS模块：

   判断一个文件是否存在：

       os.path.exists（file）

   删除文件：

       os.remove(file)

       os.unlink(file)

   创建进程：

       os.fork（）

   获取进程id：

       os.getpid（）

   获取父进程id：

       os.getppid（）

   退出一个进程：

       os.exit()

       sys.exit（退出提示）

   sys.exit（） 可以通过捕获 SystemExit异常退出

孤儿进程：

    当父进程优先于子进程退出，此时子进程就会成为孤儿进程

    孤儿进程会被系统指定进程收养  退出后会自动处理

僵尸进程：

    当子进程优先于父进程退出，父进程没有处理子进程的退出状态

    就会变成僵尸进程   僵尸进程会滞留PCB 消耗内存资源

如何避免僵尸进程的产生：

    1.父进程先退出

    2.父进程处理子进程状态

处理僵尸进程：   

       PID，status = os.wait（）：

           wait 在父进程中阻塞等待处理子进程的退出

           返回退的子进程的怕pid和退出状态

       pid，status = os.waitpid（pid，option）：

           waitpid 在父进程阻塞等待处理子进程的退出

           参数 ：

               pid   -1 表示等待任意子进程退出 

                     >0 表示等待对应PID号的子进程退出 option 

                      0 表示阻塞等待 WNOHANG 表示非阻塞 

利用二级子进程：

      父进程创建子进程等待进程退出

      子进程创建下一个进程，然后立即退出

      二级子进程成为孤儿进程  处理具体工作

multiprocessing模块

   process（）

     功能：

       创建进程对象

     参数：

       target：函数对象

       name 给进程新名称（）

       args：元组 用来给target函数位置传参

       kwargs：字典 用来给target函数键值传参

   启动进程：

       p.start（）

         调用绑定函数有子进程运行

   等待子进程退出：

       p.join（[超时检测]）

          不使用join回收可能后产生僵尸进程

   使用multiprocessing创建进程子进程同样复制父进程的全部内存空间

   之后有自己的独立空间 执行上互不干扰 子进程也有自己的PID特有资源等

   使用multiprocessing创建子进程，一般父进程功能就是只用来创建子进程

   回收子进程，返回事件交给子进程完成