python网络基础知识

网络的基础知识

ip 地址 ： 网络设备为网络 中的每一台计算机分配的唯一标识。（能够更好的更方便的找到你的机器）
ip 地址v4：四位的点分十进制
xxx.xxx.xxx.xxx 0~255
127.0.0.1 本地回环地址 (测试的时候用的)
ipv6: 冒号分 十六进制
不变的 : mac地址 能够唯一标识你这台机器的 。（每台计算机网卡中都有这个序号）
查看自己的ip地址 ipconfig/ifconfig（linux系统中）
ip地址分为：公网地址 :需要我们自己申请购买的地址
内网地址 :保留字段
子网掩码也是一个ip地址 用来判断两台机器在不在一个局域网内
端口（port） ：可以认为是设备与外界通讯交流的出口（确认机器上的具体应用程序的）
了解：分类：知名端口，动态端口
知名端口 0~1023 固定不变，用户也不能使用
21 FTP 服务
22 SSH 服务
80 Web 服务
动态端口 1024~65535 程序可以绑定
局域网的概念
交换机
在同一个局域网内的机器由交换机负责通信
交换机只认识mac地址
可以完成广播 组播 单播
单播 – mac地址(在网卡上)
局域网之间通信
路由器
提供网关ip,同一个局域网的所有机器共享一个网关
#我们不能访问除了本局域网之外的其他内网的IP地址
网络开发架构
C/S架构 : 需要安装一下才能使用
client 客户端 我们用的 需要安装的
server 服务端
B/S架构 : 百度 博客园 谷歌 码云
browser 浏览器
server 服务端
b/s和c/s什么关系?
B/S架构也是C/S架构中的一种
C/S架构的好处
# 可以离线使用/功能更完善/安全性更高
B/S架构
不用安装就可以使用
统一PC端用户的入口

网络的传输方式

面向无连接
两台计算机通讯的时候，不需要建立连接（逻辑），就可以进行数据的收发，数据可能丢失 传输协议：UDP
特点：不需要建立连接 就可以通信的
不占用连接 \ 不可靠(消息因为网络不稳定丢失)\ 速度快
udp应用的简单的例子 (发消息) - 在线播放视频\qq发消息\微信消息等。
面向有连接
两台计算机通信的时候，需要先建立连接，再能通信。 传输协议： TCP
特点 ：需要先建立连接 然后才能通信的
占用连接\ 可靠(消息不会丢失)\ 实时性高\ 速度慢\ 全双工的通信
tcp应用的简单例子 (语音聊天/视频聊天) - 线下缓存高强电影\qq远程控制\发邮件 等
三次握手 :
三次握手是TCP建立连接时候发送的三个数据包
客户端向服务器端发送syn请求,
服务端向客户端回复ack并发送syn请求,
客户端接收到请求之后再回复ack表示建立连接
由客户端的connect + 服务端的accept
四次挥手 :
四次挥手，指的TCP断开连接的时候发送的四个数据包，确保断开连接
客户端向服务端发送fin请求,
服务端回复ack确认
服务端向客户端发送fin请求,
客户端回复ack确认
有客户端的close和服务端的close
osi5层协议
应用层 python
传输层 port udp tcp 四层路由器 四层交换机
网络层 ipv4 ipv6 路由器 三层交换机
数据链路层 mac arp协议 网卡 二层交换机
物理层

UDP 及TCP 协议的基本用法

udp是无链接的，启动服务之后可以直接接受消息，不需要提前建立链接
例子： server and client

import socket
#UDP server端
sk = socket.socket(type = socket.SOCK_DGRAM)  # type= socket.SOCK_DGRAM 是创建UDP套接字方式
sk.bind(('127.0.0.1',9001)) # 绑定服务器套接字 
while True:  #可以接受多个客户端 消息
    msg,addr= sk.recvfrom(1024)  #每次接受1024个字节   （UDP先接受客户端发来的消息，在发送 ） （addr 是元组，发送方的ip和端口）
    print(msg.decode('utf-8'))
    msg = input('>>>')
    sk.sendto(msg.encode('utf-8'),addr)  #发送数据
```python
import socket
#UDP 客户端
sk = socket.socket(type=socket.SOCK_DGRAM)
server = ('127.0.0.1',9001)
while True:
    msg = input('>>>')
    if msg.upper() == 'Q':break  #输入q 会退出 消息（UDP在发消息前可以接if判断 ）
    sk.sendto(msg.encode('utf-8'),server)
    msg = sk.recv(1024).decode('utf-8')
    if msg.upper() == 'Q':break
    print(msg)


**tcp是基于链接的，必须先启动服务端，然后再启动客户端去链接服务端**
例子 server and client

import socket
#TCP server 端
sk = socket.socket()
sk.bind(('127.0.0.1',9001))   # 申请操作系统的资源 ，绑定端口
sk.listen() # 设置监听 

while True:  # 为了和多个客户端进行握手
    conn,addr = sk.accept() # 能够和多个客户端进行握手了 conn 是新的套接字 
    print('conn : ',conn) # 有新的客户端连接会打印出来
    while True: # 可以一直接收和发送消息
        send_msg = input('>>>') 
        conn.send(send_msg.encode('utf-8')) #向客户端发送消息，并解码 
        if send_msg.upper() == 'Q':# 发送后判断 发送的数据 是否为q  
            break
        msg = conn.recv(1024).decode('utf-8') #接收客户端发送的数据   
        if msg.upper() == 'Q': break
        print(msg)
    conn.close()    # 挥手 断开连接

sk.close()      # 归还申请的操作系统的资源

import socket
#TCP client  
sk = socket.socket()
sk.connect(('127.0.0.1',9001))


while True:
    msg = sk.recv(1024)
    msg2 = msg.decode('utf-8')
    if msg2.upper() == 'Q':break
    print(msg,msg2)
    send_msg = input('>>>')
    sk.send(send_msg.encode('utf-8'))
    if send_msg.upper() == 'Q':
            break
sk.close()

粘包现象
     什么粘包?
         两条或更多条分开发送的信息连在一起就是粘包现象
     发生在发送端 : 发送间隔短,数据小,由于优化机制就合并在一起发送了
     发生在接收端 : 接收不及时,所以数据就在接收方的缓存端黏在一起了
     粘包发生的本质 : tcp协议的传输是流式传输 数据与数据之间没有边界
     怎么解决粘包 : 自定义协议 struct模块
        # 先发送四字节的数据长度       # 先接受4字节 知道数据的长度
        # 再按照长度发送数据           # 再按照长度接收数据
案例： TCP 协议文件上传

```python
import json
import socket
# TCP 文件 上传 服务端 server 
# 接收
sk = socket.socket()
sk.bind(('127.0.0.1',9001))
sk.listen()

conn,_ =sk.accept()
msg = conn.recv(1024).decode('utf-8') #接受 客户端上传的文件
msg = json.loads(msg) # 将已编码的 JSON 字符串解码为 Python 对象 ，得到一个字典

with open(msg['filename'],'wb') as f: #利用下标找到对应的文件名 
    while msg['filesize'] > 0:
        content = conn.recv(1024) #recv(1024)不代表一定收到1024个字节,而是最多只能收这么多
        msg['filesize'] -= len(content) # 所以文件字节 要减去每次 content的长度 
        f.write(content) 
conn.close()
sk.close()




# TCP协议 文件传输 client 
import os
import json
import socket
# 发送
sk = socket.socket()
sk.connect(('127.0.0.1',9001))

# 文件名\文件大小
abs_path = r'D:\python_22\day30\tmp' # 需要文件上传的绝对路径
filename = os.path.basename(abs_path) # 利用os.path。basename  得到文件名字
filesize = os.path.getsize(abs_path)# 得到文件大小
dic = {'filename':filename,'filesize':filesize}   #拼接成一个字典
str_dic = json.dumps(dic)#将 Python 对象编码成 JSON 字符串
sk.send(str_dic.encode('utf-8')) 

with open(abs_path,mode = 'rb') as f:
    while filesize>0:   #文件大的情况 分开读 判断 filesize>0 
        content = f.read(1024)  # 每次只读1024 个
        filesize -= len(content)  #读取的文件 减去 每次tcp协议上传的字节个数 （）
        sk.send(content)  #发送content

sk.close()

并发的tcp协议server端 – socketserver
socketserver 基于socket完成的，tcp协议的server端处理并发的客户端请求
代码：

import time
import socketserver  #处理并发客户端的请求

class Myserver(socketserver.BaseRequestHandler): # 需要创建一个类 ， 继承 socketserver.BaseRequestHandler 类
    def handle(self):  # 重写 handle（self）方法  （名字不能错）
        conn = self.request  # 固定写法
        while True:
            try:
                content = conn.recv(1024).decode('utf-8')
                conn.send(content.upper().encode('utf-8'))
                time.sleep(0.5)
            except ConnectionResetError:
                break
server = socketserver.ThreadingTCPServer(('127.0.0.1',9001),Myserver) #  固定的 传参数 ，ip地址和端口 ， 在传入自己写的MyServer对象 
server.serve_forever() # 一直在使用 server端