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）

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

      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创建子进程，一般父进程功能就是只用来创建子进程

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

 

 

socket模块

 

Socket 对象(内建)方法

函数	描述
服务器端套接字
s.bind()	绑定地址（host,port）到套接字， 在AF_INET下,以元组（host,port）的形式表示地址。
s.listen()	开始TCP监听。backlog指定在拒绝连接之前，操作系统可以挂起的最大连接数量。该值至少为1，大部分应用程序设为5就可以了。
s.accept()	被动接受TCP客户端连接,(阻塞式)等待连接的到来
客户端套接字
s.connect() 主动初始化TCP服务器连接，。一般address的格式为元组（hostname,port），如果连接出错，返回socket.error错误。	s.connect_ex() connect()函数的扩展版本,出错时返回出错码,而不是抛出异常
公共用途的套接字函数
s.recv()	接收TCP数据，数据以字符串形式返回，bufsize指定要接收的最大数据量。flag提供有关消息的其他信息，通常可以忽略。
s.send()	发送TCP数据，将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。
s.sendall()	完整发送TCP数据，完整发送TCP数据。将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。
s.recvfrom()	接收UDP数据，与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。
s.sendto()	发送UDP数据，将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。
s.close()	关闭套接字
s.getpeername()	返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。
s.getsockname()	返回套接字自己的地址。通常是一个元组(ipaddr,port)
s.setsockopt(level,optname,value)	设置给定套接字选项的值。
s.getsockopt(level,optname[.buflen])	返回套接字选项的值。
s.settimeout(timeout)	设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如connect()）
s.gettimeout()	返回当前超时期的值，单位是秒，如果没有设置超时期，则返回None。
s.fileno()	返回套接字的文件描述符。
s.setblocking(flag)	如果flag为0，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式（默认值）。非阻塞模式下，如果调用recv()没有发现任何数据，或send()调用无法立即发送数据，那么将引起socket.error异常。
s.makefile()	创建一个与该套接字相关连的文件

OS模块：

#OS模块
 
#os模块就是对操作系统进行操作，使用该模块必须先导入模块：
import os
 
#getcwd() 获取当前工作目录(当前工作目录默认都是当前文件所在的文件夹)
result = os.getcwd()
print(result)
 
#chdir()改变当前工作目录
os.chdir('/home/sy')
result = os.getcwd()
print(result)
 
open('02.txt','w')
 
#操作时如果书写完整的路径则不需要考虑默认工作目录的问题,按照实际书写路径操作
open('/home/sy/下载/02.txt','w')
 
#listdir() 获取指定文件夹中所有内容的名称列表
result = os.listdir('/home/sy')
print(result)
 
#mkdir()  创建文件夹
#os.mkdir('girls')
#os.mkdir('boys',0o777)
 
#makedirs()  递归创建文件夹
#os.makedirs('/home/sy/a/b/c/d')
 
#rmdir() 删除空目录
#os.rmdir('girls')
 
#removedirs 递归删除文件夹  必须都是空目录
#os.removedirs('/home/sy/a/b/c/d')
 
#rename() 文件或文件夹重命名
#os.rename('/home/sy/a','/home/sy/alibaba'
#os.rename('02.txt','002.txt')
 
#stat() 获取文件或者文件夹的信息
#result = os.stat('/home/sy/PycharmProject/Python3/10.27/01.py)
#print(result)
 
#system() 执行系统命令(危险函数)
#result = os.system('ls -al')  #获取隐藏文件
#print(result)
 
#环境变量
'''
环境变量就是一些命令的集合
操作系统的环境变量就是操作系统在执行系统命令时搜索命令的目录的集合
'''
#getenv() 获取系统的环境变量
result = os.getenv('PATH')
print(result.split(':'))
 
#putenv() 将一个目录添加到环境变量中(临时增加仅对当前脚本有效)
#os.putenv('PATH','/home/sy/下载')
#os.system('syls')
 
#exit() 退出终端的命令
 
#os模块中的常用值
#curdir  表示当前文件夹   .表示当前文件夹  一般情况下可以省略
print(os.curdir)
 
#pardir  表示上一层文件夹   ..表示上一层文件夹  不可省略!
print(os.pardir)
 
#os.mkdir('../../../man')#相对路径  从当前目录开始查找
#os.mkdir('/home/sy/man1')#绝对路径  从根目录开始查找
 
#name 获取代表操作系统的名称字符串
print(os.name) #posix -> linux或者unix系统  nt -> window系统
 
#sep 获取系统路径间隔符号  window ->\    linux ->/
print(os.sep)
 
#extsep 获取文件名称和后缀之间的间隔符号  window & linux -> .
print(os.extsep)
 
#linesep  获取操作系统的换行符号  window -> \r\n  linux/unix -> \n
print(repr(os.linesep))
 
#导入os模块
import os
 
#以下内容都是os.path子模块中的内容
 
#abspath()  将相对路径转化为绝对路径
path = './boys'#相对
result = os.path.abspath(path)
print(result)
 
#dirname()  获取完整路径当中的目录部分  &  basename()获取完整路径当中的主体部分
path = '/home/sy/boys'
result = os.path.dirname(path)
print(result)
 
result = os.path.basename(path)
print(result)
 
#split() 将一个完整的路径切割成目录部分和主体部分
path = '/home/sy/boys'
result = os.path.split(path)
print(result)
 
#join() 将2个路径合并成一个
var1 = '/home/sy'
var2 = '000.py'
result = os.path.join(var1,var2)
print(result)
 
#splitext() 将一个路径切割成文件后缀和其他两个部分,主要用于获取文件的后缀
path = '/home/sy/000.py'
result = os.path.splitext(path)
print(result)
 
#getsize()  获取文件的大小
#path = '/home/sy/000.py'
#result = os.path.getsize(path)
#print(result)
 
#isfile() 检测是否是文件
path = '/home/sy/000.py'
result = os.path.isfile(path)
print(result)
 
#isdir()  检测是否是文件夹
result = os.path.isdir(path)
print(result)
 
#islink() 检测是否是链接
path = '/initrd.img.old'
result = os.path.islink(path)
print(result)
 
#getctime() 获取文件的创建时间 get create time
#getmtime() 获取文件的修改时间 get modify time
#getatime() 获取文件的访问时间 get active time
 
import time
 
filepath = '/home/sy/下载/chls'
 
result = os.path.getctime(filepath)
print(time.ctime(result))
 
result = os.path.getmtime(filepath)
print(time.ctime(result))
 
result = os.path.getatime(filepath)
print(time.ctime(result))
 
#exists() 检测某个路径是否真实存在
filepath = '/home/sy/下载/chls'
result = os.path.exists(filepath)
print(result)
 
#isabs() 检测一个路径是否是绝对路径
path = '/boys'
result = os.path.isabs(path)
print(result)
 
#samefile() 检测2个路径是否是同一个文件
path1 = '/home/sy/下载/001'
path2 = '../../../下载/001'
result = os.path.samefile(path1,path2)
print(result)
 
#os.environ 用于获取和设置系统环境变量的内置值
import os
#获取系统环境变量  getenv() 效果
print(os.environ['PATH'])
 
#设置系统环境变量 putenv()
os.environ['PATH'] += ':/home/sy/下载'
os.system('chls')