首页 > 代码库 > Python基础第24天

Python基础第24天

                                                                              第五模块:网络编程    

一:C/S架构

即C/S架构,包括

1.硬件C/S架构(打印机)

2.软件C/S架构(web服务)

二:socket和互联网协议

1.首先:本节课程的目标就是教会你如何基于socket编程,来开发一款自己的C/S架构软件

2.其次:C/S架构的软件(软件属于应用层)是基于网络进行通信的

3.然后:网络的核心即一堆协议,协议即标准,你想开发一款基于网络通信的软件,就必须遵循这些标准。

TCP/IP协议族包括运输层、网络层、链路层

Socket是应用层与TCP/IP协议族通信的中间软件抽象层,它是一组接口。在设计模式中,Socket其实就是一个门面模式,它把复杂的TCP/IP协议族隐藏在Socket接口后面,对用户来说,一组简单的接口就是全部,让Socket去组织数据,以符合指定的协议。

技术分享

        先从服务器端说起。服务器端先初始化Socket,然后与端口绑定(bind),对端口进行监听(listen),调用accept阻塞,等待客户端连接。在这时如果有个客户端初始化一个Socket,然后连接服务器(connect),如果连接成功,这时客户端与服务器端的连接就建立了。客户端发送数据请求,服务器端接收请求并处理请求,然后把回应数据发送给客户端,客户端读取数据,最后关闭连接,一次交互结束。

socket()模块函数用法:

import socket
socket.socket(socket_family,socket_type,protocal=0)
socket_family 可以是 AF_UNIX 或 AF_INET。socket_type 可以是 SOCK_STREAM 或 SOCK_DGRAM。protocol 一般不填,默认值为 0。

获取tcp/ip套接字
tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

获取udp/ip套接字
udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

由于 socket 模块中有太多的属性。我们在这里破例使用了from module import *语句。使用 from socket import *,我们就把 socket 模块里的所有属性都带到我们的命名空间里了,这样能 大幅减短我们的代码。
例如tcpSock = socket(AF_INET, SOCK_STREAM)
服务端套接字函数
s.bind() 绑定(主机,端口号)到套接字
s.listen() 开始TCP监听
s.accept() 被动接受TCP客户的连接,(阻塞式)等待连接的到来

客户端套接字函数
s.connect() 主动初始化TCP服务器连接
s.connect_ex() connect()函数的扩展版本,出错时返回出错码,而不是抛出异常

公共用途的套接字函数
s.recv() 接收TCP数据
s.send() 发送TCP数据(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完)
s.sendall() 发送完整的TCP数据(本质就是循环调用send,sendall在待发送数据量大于己端缓存区剩余空间时,数据不丢失,循环调用send直到发完)
s.recvfrom() 接收UDP数据
s.sendto() 发送UDP数据
s.getpeername() 连接到当前套接字的远端的地址
s.getsockname() 当前套接字的地址
s.getsockopt() 返回指定套接字的参数
s.setsockopt() 设置指定套接字的参数
s.close() 关闭套接字
三:例子
1:基于tcp套接字
技术分享
from socket import *
ip_port=(127.0.0.1,8086)
back_log=5
buffer_size=1024


tcp_server=socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)
print(服务端开始运作)
while True:   #接收多个人的链接
    conn,addr=tcp_server.accept()
    print(双向连接是,conn)
    print(客户端地址,addr)

    while True:  #跟一个人循环连接
        try:
            data=conn.recv(buffer_size)
            print(客户端发来的消息是,data.decode(utf_8))
            conn.send(data.upper())
        except Exception:
            break
    conn.close()
tcp_server.close()
server

技术分享
from socket import *
ip_port=(127.0.0.1,8086)
back_log=5
buffer_size=1024


tcp_client=socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)

while True:
    msg=input(》》》:).strip()
    tcp_client.send(hello.encode(utf-8))
    print(客户端已经发送消息)
    data=tcp_client.recv(buffer_size)
    print(客户端发来的消息是,data.decode(utf_8))
client

2:基于udp套接字

技术分享
from socket import *
ip_port=(127.0.0.1,8080)
buffer_size=1024

udp_server=socket(AF_INET,SOCK_DGRAM) #数据报
udp_server.bind(ip_port)

while True:
    data,addr=udp_server.recvfrom(buffer_size)  #接收元祖的形式
    print(data)

    udp_server.sendto(data.upper(),addr)
udp_server
技术分享
from socket import *
ip_port=(127.0.0.1,8080)
buffer_size=1024

udp_client=socket(AF_INET,SOCK_DGRAM) #数据报


while True:
    msg=input(>>>: ).strip
    udp_client.sendto(msg.encode(utf-8),ip_port)

    data,addr=udp_client.recvfrom(buffer_size)
    print(data.decode(utf-8))
udp_client

3:ntp

技术分享
from socket import *
import time
ip_port=(127.0.0.1,8087)
buffer_size=1024

udp_server=socket(AF_INET,SOCK_DGRAM) #数据报
udp_server.bind(ip_port)

while True:
    data,addr=udp_server.recvfrom(buffer_size)  #接收元祖的形式
    print(data)
    if not data:
        fmt=%Y-%m-%d %X
    else:
        fmt=data.decode(utf-8)

    back_time=time.strftime(fmt)
    udp_server.sendto(back_time.encode(utf-8),addr)
ntp_server
技术分享
from socket import *
ip_port=(127.0.0.1,8087)
buffer_size=1024

udp_client=socket(AF_INET,SOCK_DGRAM) #数据报

while True:
    msg=input(>>>:).strip
    udp_client.sendto(msg.encode(utf-8),ip_port)

    data,addr=udp_client.recvfrom(buffer_size)
    print(data.decode(utf-8))
ntp_client

四:recv与recvfrom的区别

1.tcp协议:

(1)如果收消息缓冲区里的数据为空,那么recv就会阻塞

(2)tcp基于链接通信,如果一端断开了链接,那另外一端的链接也跟着完蛋recv将不会阻塞,收到的是空

2.udp协议

(1)如果如果收消息缓冲区里的数据为“空”,recvfrom不会阻塞

(2)recvfrom收的数据小于sendinto发送的数据时,数据丢失

(3)只有sendinto发送数据没有recvfrom收数据,数据丢失


tcp/udp总结:


1.udp的sendinto不用管是否有一个正在运行的服务端,可以己端一个劲的发消息

2.udp的recvfrom是阻塞的,一个recvfrom(x)必须对一个一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失,这意味着udp根本不会粘包,但是会丢数据,不可靠.

3.tcp的协议数据不会丢,己端总是在收到ack时才会清除缓冲区内容。数据是可靠的,但是会粘包。

五:粘包   须知:只有TCP有粘包现象,UDP永远不会粘包

粘包原因:发送端一K一k地发送数据,而接收端不确定收多少数据,TCP是面向流的协议,出现粘包

而UDP是面向消息的协议,无链接。接收端的套接字缓冲区采用链式结构来记录每一个到达的UDP包

TCP基于流,收发的消息不能为空,而 UDP是基于数据报的,即便是空格也不是空消息

 

两种情况下会发生粘包。

 

1、发送端需要等缓冲区满才发送出去,造成粘包(发送数据时间间隔很短,数据了很小,会合到一起,产生粘包)。

2、接收方不及时接收缓冲区的包,造成多个包接收(客户端发送了一段数据,服务端只收了一小部分,服务端下次再收的时候还是从缓冲区拿上次遗留的数据,产生粘包) 

 

粘包解决:
①:low方式
技术分享
import socket,subprocess
ip_port=(127.0.0.1,8080)
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

s.bind(ip_port)
s.listen(5)

while True:
    conn,addr=s.accept()
    print(客户端,addr)
    while True:
        msg=conn.recv(1024)
        if not msg:break
        res=subprocess.Popen(msg.decode(utf-8),shell=True,                            stdin=subprocess.PIPE,                         stderr=subprocess.PIPE,                         stdout=subprocess.PIPE)
        err=res.stderr.read()
        if err:
            ret=err
        else:
            ret=res.stdout.read()
        data_length=len(ret)
        conn.send(str(data_length).encode(utf-8))
        data=conn.recv(1024).decode(utf-8)
        if data =http://www.mamicode.com/= recv_ready:
            conn.sendall(ret)
    conn.close()
server

技术分享
import socket,time
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex((127.0.0.1,8080))

while True:
    msg=input(>>: ).strip()
    if len(msg) == 0:continue
    if msg == quit:break

    s.send(msg.encode(utf-8))
    length=int(s.recv(1024).decode(utf-8))
    s.send(recv_ready.encode(utf-8))
    send_size=0
    recv_size=0
    data=b‘‘
    while recv_size < length:
        data+=s.recv(1024)
        recv_size+=len(data)


    print(data.decode(utf-8))
client

②:new方法

#socket_server_tcp
from socket import *
import subprocess
import struct
ip_port=(222.28.46.49,8087)
back_log=5
buffer_size=1024

tcp_server=socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)

while True:
    conn,addr=tcp_server.accept()
    print(新的客户端连接,addr)
    while True:
        try:
            cmd=conn.recv(buffer_size)
            print(收到客户端的命令,cmd)

            res=subprocess.Popen(cmd.decode(utf-8),shell=True,
                                 stderr=subprocess.PIPE,
                                 stdin=subprocess.PIPE,
                                 stdout=subprocess.PIPE)
            err=res.stderr.read()
            if err:
                cmd_res=err
            else:
                cmd_res=res.stdout.read()

            if not cmd_res:
                cmd_res=执行成功.encode(gbk)

            length=len(cmd_res)
            # conn.send(str(length)).encode(‘utf-8‘)
            # client_read=conn.recv(buffer_size)
            # if client_read == b‘read‘:
            data_length=struct.pack(i,length)
            conn.send(data_length)
            conn.send(cmd_res)
        except Exception as e:
            print(e)
            break
    conn.close()
#socket_client_tcp
from socket import *
from functools import partial
import struct
ip_port=(222.28.46.49,8087)
back_log=5
buffer_size=1024

tcp_client=socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)

while True:
    cmd=input(>>>:).strip()
    if not cmd:continue
    if cmd == quit:break

    tcp_client.send(cmd.encode(utf-8))

    #解决low粘包
    # length=tcp_client.recv(buffer_size)
    # tcp_client.send(b‘ready‘)
    #
    # length=int(length.decode(‘utf-8‘))
    # recv_size=0
    # recv_msg=b‘‘
    # while recv_size < length:
    #     recv_msg+=tcp_client.recv(buffer_size)
    #     recv_size=len(recv_msg)

    #new------------
    length_data=http://www.mamicode.com/tcp_client.recv(4)
    length=struct.unpack(i,length_data)[0]
    recv_msg=‘‘.join(iter(partial(tcp_client.recv,buffer_size),b‘‘))

    print(命令的执行结果是,recv_msg.decode(gbk))
tcp_client.close()

 

 

 

                                                                                                             

Python基础第24天