Python网络编程(weekly summary1)

  1. 云栖社区>
  2. 博客>
  3. 正文

Python网络编程(weekly summary1)

巴黎香榭 2018-08-12 14:17:06 浏览1507
展开阅读全文
网络的目的是什么?
    用于信息传输、接受  能把各个点、面、体的信息链接到一起 实现资源的共享
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)
      面向无连接的不可靠的传输服务 数据报套接字
      1.创建套接字:
            socket = socket.socket(AF_INET,SOCK_DGRAM)
      2.绑定地址:
            socket.bind()
      3.收发消息:
            socket.recvfrom()
            socket.sento()
      4.关闭套接字:
            socket.close()
      客户端:
          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.响应头:
         对响应内容的具体描述
      3.空行
      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 表示非阻塞 
           返回退的子进程的怕pid和退出状态
利用二级子进程:
      父进程创建子进程等待进程退出
      子进程创建下一个进程,然后立即退出
      二级子进程成为孤儿进程  处理具体工作

multiprocessing模块

   process()
     功能:
       创建进程对象
     参数:
       target:函数对象
       name 给进程新名称()
       args:元组 用来给target函数位置传参
       kwargs:字典 用来给target函数键值传参
   启动进程:
       p.start()
         调用绑定函数有子进程运行
   等待子进程退出:
       p.join([超时检测])
          不使用join回收可能后产生僵尸进程

   使用multiprocessing创建进程子进程同样复制父进程的全部内存空间
   之后有自己的独立空间 执行上互不干扰 子进程也有自己的PID特有资源等
   使用multiprocessing创建子进程,一般父进程功能就是只用来创建子进程
   回收子进程,返回事件交给子进程完成

网友评论

登录后评论
0/500
评论