08周报

软件开发框架

C/S架构      
1.client 客户端
2.server 服务端

B/S架构
1.browser 浏览器
2.server  服务端

C/S架构 需要用户下载应用软件才可以享受服务，
B/S架构 用户使用浏览器即可享受服务

网络编程

1.基于网络编写代码 实现数据间的远程交互
2.数据远程交互必备条件 需要 物理连接介质
  早期的电话
  	电话线
  早期电脑
  	有线网线
  现在手机电脑
  	内置无线网卡

OSI七层协议

七层协议：
1.应用层
2.表示层
3.会话层
4.传输层
5.网络层
6.数据链路层
7.物理连接层

大部分统称为5层协议  应用层 传输层 网络层 数据链路层 物理连接层

接收数据：由下往上传递
		1.物理层接收二进制信号
 		2.数据链路层 处理数据帧
    3.网络层  系统处理IP头
    4.传输层  系统处理TCP头
    5.应用层  应用程序处理数据
    
发送数据：有上往下传递
		1.应用层 发送数据
    2.传输层 ICP协议将数据包再次封装为TCP数据包
    3.网络层 再通过IP协议再次封装
    4.数据链路层 在增加以太网协议 在加上mac编号封装成为数据帧
    5.物理层 发送二进制电信息
    

物理连接层：
    计算机物理连接介质，传递数据 bytes类型数据

数据链路层：
		规定了电信号的分组方式
    以太网协议：
       相当于每个计算机的身份证号
       mac地址 12位数的16进制数据
       前6位 产商编号  后6位生产流水线号
      
网络层：
    IP协议
  	每一个连入互联网的计算机都需要有一个ip地址
    IP地址为动态分配，不同地区不同场景ip地址不同
    IP地址特产：
    		IPV4：点 分 十进制
        最小 0.0.0.0
        最大 255.255.255.255
        IPV6:
        不同的数字 字母 符号组成 无限大
        
传输层：
    PORT协议 端口协议
    用来标识某一个应用程序
    范围 0 - 65535
    特征： 动态分配 每次随机分配一个 程序完全关闭后回收端口号
    0-1024 端口号 默认被系统应用使用
    1024-8080 常用软件已使用
    
URL：网址，网址的本质就是IP+PORT端口号组成的
		 114.55.205.139:80
  
应用层 
	  应用层是程序员自己写的程序，里面的协议很多常见的为HTTP HTTPS
  FTP协议等

TCP协议

1.TCP别名 可靠协议 数据不易丢失 因为有反馈机制
   
三次握手建立连接
   第一次  客户端发出连接请求到服务端
   第二次  服务端同意客户端请求 建立通道，服务端同时向客户端发送请求
   第三次  服务端同意客户端发送的请求
通过三次握手完毕，客户端和服务端双向通道建立完成


四次挥手断连接
	第一次 客户端发送请求断开单向通道
  第二次 服务端同意断开 客户端 到 服务端 通道
  第三次 服务端确定已收到客户端全部消息 发送请求断开到客户端
  第四层 客户端同意 断开 服务端 到 客户端 通道
通过四次挥手  客户端 和 服务端 的双向通道彻底断开连接

UDP协议

别名 简单协议 不可靠协议

只是把数据发送到一个地址，不保证对方是否成功接收 

简单 快捷 粗暴 不可靠

Socket模块

可以帮助我们实现网络通讯的模块

别名 套接字模块

server = socket.socket()
# 创建一个对象，默认使用的TCP协议
server.bind(('127.0.0.1',9999))
# 绑定IP地址和端口号
server.listen(5)
# 设置半连接池
sock,addr = server.accept()
# 等待客户端传送数据
sock 数据
addr 对方ip 和 端口号 

data = sock.recv(1024)
print(data.encode('utf8'))
# 接收信息 并设定接收信息的最大字节数
# 接收和发送的都是二进制 都需要编码

sock.send(''.encode('utf8'))
# 发送二进制的数据

sock.close()
# 关闭此连接通道

server.close
# 关闭服务端服务

黏包现象/解决黏包

因为我们使用的TCP协议是流式协议 如果在很短的时间内连续发送数据
我们不知道每次接收的数据准确大小
会导致 多条数据连在一起被一起接收 这称之为 黏包现象

解决方案
   要明确知道对方发来的数据 每条数据的准确大小 精准接收
   这样就不会导致出现黏包问题
    
    
struct模块

msg = input('请输入您要发送的内容')
msg_len = len(msg.encode('uft8'))
msg_head = 	struct.pick('i',msg_len)
send(msg_head)
send(msg.encode('uft8'))
# 打包生产报头 发送信息的准确大小

msg_head = sock.recv(4)
# 接收报头
msg_len = struct.unpick('i',msg_head)
# 解包报头 获得真实数据大小
msg_byeat = sock.recv(msg_len)
# 获得真实数据

print(msg_byeat.encode('utf8'))

  
'''
个人理解： 
客户端： 1.制作字典报头 	发字典报头     2.发真实字典    3.发真实数据 

服务端： 1.收字典报头 解压出来字典字节长短
          2.收真实字典数据， 解压出来 真实数据字节
         3.收真实数据
'''

同步与异步 阻塞与非阻塞

用来表达任务的提交方式
  同步： 提交完任务后原地等待 等待任务完成 期间不做任何事情
  异步：	提交完任务后 去做其他事情 等任务完成了再回来取结果
  
用来表达任务的执行状态
	阻塞：任务处理阻塞态 进入了io操作或input等
  非阻塞：就绪态 运行态
  
综合使用：
		同步 阻塞
    同步非阻塞
    异步 阻塞
    异步非阻塞
 # CPU利用率最高的为 异步非阻塞 效率最高

如何创建多线程-multiprocessing 模块

使用 multiprocessing 模块 Process

def task(name):
  print('111'，name)
  

if __name__ == '__main__':
   p1 = Process(target=task,args=('name',))
   # 创建一个子进程 执行target=task 传入参数  args=('name',)
   p1.start()
   # 执行子进程
   print('主')
   # 子进程执行属于异步操作 不影响主进程继续执行
  
  

进程间数据隔离

子进程的数据默认情况下是隔离的，不影响其他子进程和主进程


from multiprocessing import Process
import time

m1 = 1000

def run():
    global m1
    m1 = 666
    print(m1)

if __name__ == '__main__':
    p1 = Process(target=run,)
    p1.start()
    time.sleep(2)
    # 子进程已经执行结束了，正常m1应该被重复赋值了
    print(m1)
    # 1000 但是结果是没有，因为子进程数据独立，不影响主进程数据

进程join方法

使子进程的异步执行变为同步
p1.start()
# 子进程开始进行
p2.start()
# 子进程开始进行
p1.join()
# 等待子进程 p1运行结束
p2.join()
# 等待子进程 p2运行结束
print('主进程')
# 最后才执行主进程

IPC机制

进程间的通讯方法
建立消息队列

multiprocessing 模块 Queue
q = Queue(10)
# 可以生产一个消息队列，10为可设置队列最大消息存储数量

.put 
# 向队列中条件消息 如果已满则程序等待，直到添加进去
.get
# 队列中取消息，如果没有 则等着，直到取到为止
.get(timeout=3)
# 可设置等待时间，超过等待时间没有取到报错
.get_nowait()
# 立即取消息，没有就报错
.full()
# 判断队列中数据是否已存满
.empty
# 判断队列是否为空


"""
full() empty() get_nowait()在多进程中都不能使用!!!
因为在多线程情况下可能出现同时间的存取
"""

生产者消费者模型

只是一个编程思维概念
举例：爬虫工程师

生产者：
   负责生产数据的人，把你需要的数据都给你 
  
消费者：
 	 负责处理数据的人，拿到提供的数据然后二次加工
  
该模型除了有生产者和消费着之外还必须有消息队列(只要是能提供数据保存服务和提取服务的理论上都可以)

进程对象的多种方法

如何查看进程的进程号
  win电脑 cmd输入 tasklist命令
  mac电脑 终端输入 ps aux
  
  
  p = Process(target=task)
  # 创建子进程
  p.start()
  # 执行子进程
  p.terminate()
  # 杀死子进程
  p.is_alive()
  # 查看子进程是否存活
  os.getpid()
  # 获取当前进程号

僵尸进程与孤儿进程

僵尸进程：
  进程已经运行完毕，但是还没有立刻是否进程号 还没有完全结束 需要等一会才会释放进程号，这期间为僵尸进程
孤儿进程：
   子进程还在运行中，父进程突然结束。操作系统会针对孤儿进程作出对应管理

守护进程

关键词 daemon

    p = Process(target=task,args=('moon',))
    # p = Process(target=task,kwargs={'name':'moon'})
    p.daemon = True
    # 将子进程 P 设置成为守护进程
    # 必须要在子进程开始前设置好
    p.start()
    print('主进程结束')
    # 主进程结束 子进程立即结束

原文地址：http://www.cnblogs.com/moongodnnn/p/16908744.html