day30:TCP&UDP:socket

#  ### 服务端

import socket

# 1.创建一个socket对象

sk = socket.socket()

# 2.绑定对应的ip和端口号(让其他主机在网络中可以找得到)

"""127.0.0.1代表本地ip"""

sk.bind( ("127.0.0.1",9001) )

# 3.开启监听

sk.listen()

# 4.建立三次握手

conn,addr  = sk.accept()

# 5.处理收发数据的逻辑

"""recv 接受 send 发送"""

res = conn.recv(1024)# 最多一次接受 1024 字节

print(res.decode("utf-8"))

# 6.四次挥手

conn.close()

# 7.退还端口

sk.close()

客户端

# ### 客户端

import socket

# 1.创建一个socket对象

sk = socket.socket()

# 2.与服务器建立连接

sk.connect( ("127.0.0.1",9001) )

# 3.发送数据(只能发送二进制的字节流)

sk.send("北京昨天迎来了暴雨,如今有车是不行的,还得有船".encode("utf-8"))

# 4.关闭连接

sk.close()

2.TCP循环发消息

服务端

# ### 服务端

import socket

# 1.创建socket对象

sk = socket.socket()

# # 在bind方法之前加上这句话，可以让一个端口重复使用

sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

# 2.绑定ip和端口号(在网络中注册该主机)

sk.bind( ("127.0.0.1" , 9000) )

# 3.开启监听

sk.listen()

"""

print(conn)

print(addr)

conn:<socket.socket fd=4, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9002), raddr=('127.0.0.1', 53620)>

addr:('127.0.0.1', 53620)

"""

# 5.处理收发数据的逻辑

"""send(字节流)"""

"""

conn.send("我去北京先买船".encode("utf-8"))

"""

while True:

    # 4.三次握手

    conn,addr = sk.accept()

    while True:

        res = conn.recv(1024)

        print(res.decode())

        strvar = input("请输入服务端要给客户端发送的内容")

        conn.send(strvar.encode())

        if strvar.upper() == "Q":

            break

# 6.四次挥手

conn.close()

# 7.退还端口

sk.close()

客户端

# ### 客户端

import socket

# 1.创建socket对象

sk = socket.socket()

# 2.连接服务端

sk.connect( ("127.0.0.1" , 9000) )

# 3.收发数据

"""

res = sk.recv(1024) # 一次最多接受1024个字节

print(res.decode())

"""

while True:

    strvar = input("请输入您要发送的内容:")

    sk.send(strvar.encode())

    res = sk.recv(1024)

    if res == b"q" or res == b"Q":

        break

    print(res.decode())

# 4.关闭连接

sk.close()

3.UDP基本语法

服务端

# ### 服务端

import socket

# 1.创建udp对象

sk = socket.socket(type=socket.SOCK_DGRAM)

# 2.绑定地址端口号

sk.bind( ("127.0.0.1",9000) )

# 3.udp服务器,在一开始只能够接受数据

msg,cli_addr = sk.recvfrom(1024)

print(msg.decode())

print(cli_addr)

# 服务端给客户端发送数据

msg = "我是你老娘,赶紧给我回家吃饭"

sk.sendto(msg.encode(),cli_addr)

# 4.关闭连接

sk.close()

客户端

# ### 客户端

import socket

# 1.创建udp对象

sk = socket.socket(type=socket.SOCK_DGRAM)

# 2.收发数据的逻辑

# 发送数据

msg = "你好,你是mm还是gg"

# sendto( 消息,(ip,端口号) )

sk.sendto( msg.encode() ,  ("127.0.0.1",9000)  )

# 接受数据

msg,server_addr = sk.recvfrom(1024)

print(msg.decode())

print(server_addr)

# 3.关闭连接

sk.close()

4.UDP循环发消息

服务端

# ### 服务端

import socket

# 1.创建udp对象

sk = socket.socket(type=socket.SOCK_DGRAM)

# 2.绑定地址端口号

sk.bind( ("127.0.0.1",9000) )

# 3.udp服务器,在一开始只能够接受数据

while True:

    # 接受消息

    msg,cli_addr = sk.recvfrom(1024)

    print(msg.decode())

    message = input("服务端给客户端发送的消息是?:")

    # 发送数据

    sk.sendto(message.encode() , cli_addr)

# 4.关闭连接

sk.close()

客户端

# ### 客户端

import socket

# 1.创建udp对象

sk = socket.socket(type=socket.SOCK_DGRAM)

# 2.收发数据的逻辑

while True:

    # 发送数据

    message = input("客户端给服务端发送的消息是?:")

    sk.sendto(message.encode(), ("127.0.0.1",9000) )

    # 接受数据

    msg,addr = sk.recvfrom(1024)

    print(msg.decode("utf-8"))

# 3.关闭连接

sk.close()

4.黏包

1.出现黏包的原因

tcp协议在发送数据时,会出现黏包现象.

1.数据粘包是因为在客户端/服务器端都会有一个数据缓冲区，

缓冲区用来临时保存数据，为了保证能够完整的接收到数据，因此缓冲区都会设置的比较大。

2.在收发数据频繁时，由于tcp传输消息的无边界,不清楚应该截取多少长度

导致客户端/服务器端,都有可能把多条数据当成是一条数据进行截取，造成黏包

2.黏包出现的两种情况

黏包现象一:

在发送端,由于两个数据短,发送的时间隔较短,所以在发送端形成黏包

黏包现象二:

在接收端,由于两个数据几乎同时被发送到对方的缓存中,所有在接收端形成了黏包

总结:

发送端,包之间时间间隔短或者接收端,接受不及时, 就会黏包

核心是因为tcp对数据无边界截取,不会按照发送的顺序判断

3.黏包的应用场景

解决黏包场景:

应用场景在实时通讯时,需要阅读此次发的消息是什么

不需要解决黏包场景:

下载或者上传文件的时候,最后要把包都结合在一起,黏包无所谓.

5.解决黏包问题

1.解决黏包方式一:先发送接下来要发送数据的大小

服务端

# ### 服务端

import time

import socket

sk = socket.socket()

sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

sk.bind( ("127.0.0.1",9000) )

sk.listen()

conn,addr = sk.accept()

# 处理收发数据的逻辑

# 先发送接下来要发送数据的大小

conn.send("5".encode()) # 发送5个字节

# 发完长度之后,再发数据

conn.send("hello".encode())

conn.send(",world".encode())

conn.close()

sk.close()

客户端

# ### 客户端

"""

黏包出现的两种情况:

    (1) 发送端发送数据太快

    (2) 接收端接收数据太慢

"""

import socket

import time

sk = socket.socket()

sk.connect( ("127.0.0.1",9000) )

time.sleep(2) # 睡2s，让其接受速度慢一些,制造黏包效果

# 处理收发数据的逻辑

# 先接受接下来要发送数据的大小

res = sk.recv(1) # res = "5"

num = int(res.decode()) # num = 5

# 接受num这么多个字节数

res1 = sk.recv(num) # 一次最多只能接收5个字节

res2 = sk.recv(1024)

print(res1)

print(res2)

sk.close()

2.解决黏包方式二:conn.send("00000100".encode())

服务端:

# ### 服务端

import time

import socket

sk = socket.socket()

sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

sk.bind( ("127.0.0.1",9000) )

sk.listen()

conn,addr = sk.accept()

# 处理收发数据的逻辑

# 先发送接下来要发送数据的大小

conn.send("00000100".encode())

# 发完长度之后,再发数据

msg = "hello" * 20

conn.send(msg.encode())

conn.send(",world".encode())

conn.close()

sk.close()

客户端:

# ### 客户端

"""

黏包出现的两种情况:

    (1) 发送端发送数据太快

    (2) 接收端接收数据太慢

"""

import socket

import time

sk = socket.socket()

sk.connect( ("127.0.0.1",9000) )

time.sleep(2)

# 处理收发数据的逻辑

# 先接受接下来要发送数据的大小

res = sk.recv(8)

num = int(res.decode())

# 接受num这么多个字节数

res1 = sk.recv(num)

res2 = sk.recv(1024)

print(res1)

print(res2)

sk.close()

其实，这两种写法都存在一定的限制，并非最完美的解决方案

下面介绍一个模块，用来完美的解决黏包现象

3.前戏:struct模块

struct模块里有两个方法:

pack :把任意长度数字转化成具有固定4个字节长度的字节流

unpack :把4个字节值恢复成原来的数字,返回最终的是元组

import struct

# pack

# i => int 要转化的当前数据是整型

res1 = struct.pack("i",999999999)

print(res1,len(res1)) # b'\xff\xc9\x9a;' 4

res2 = struct.pack("i",1)

print(res2,len(res2)) # b'\x01\x00\x00\x00' 4

res3 = struct.pack("i",4399999)

print(res3,len(res3)) # b'\x7f#C\x00' 4

# pack 的范围 -2147483648 ~ 2147483647 21个亿左右

res4 = struct.pack("i",2100000000)

print(res4,len(res4)) # b'\x00u+}' 4

# unpack

# i => 把对应的数据转换成int整型

tup = struct.unpack("i",res)

print(tup) # (2100000000,)

print(tup[0]) # 2100000000

4.解决黏包方式三:使用struct模块

服务端

# ### 服务端

import time

import socket

import struct

sk = socket.socket()

sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

sk.bind( ("127.0.0.1",9000) )

sk.listen()

conn,addr = sk.accept()

# 处理收发数据的逻辑

strvar = input("请输入你要发送的数据")

msg = strvar.encode()

length = len(msg) # 你输入字符串的长度

res = struct.pack("i",length) # 无论长度是多少，res都是固定4个字节长度的字节流

print("---",res)

# 第一次发送的是字节长度

conn.send(res)

# 第二次发送真实的数据

conn.send(msg)

# 第三次发送真实的数据

conn.send("世界真美好123".encode())

conn.close()

sk.close()

客户端

# ### 客户端

"""

黏包出现的两种情况:

    (1) 发送端发送数据太快

    (2) 接收端接收数据太慢

"""

import socket

import time

import struct

sk = socket.socket()

sk.connect( ("127.0.0.1",9000) )

time.sleep(2)

# 处理收发数据的逻辑

# 第一次接受的是字节长度

n = sk.recv(4) # 接收到4个字节长度的字节流

tup = struct.unpack("i",n) # 将4个字节长度的字节流转化成数字

n = tup[0] # n就是长度

# 第二次接受真实的数据

res = sk.recv(n)

print(res.decode())

# 第三次接受真实的数据

res = sk.recv(1024)

print(res.decode())

sk.close()

struct如何做到控制接受字节数的呢?