Python 网络编程3：tcp客户端与tcp服务器以及下载器

2018-11-27 本文已影响4人 IIronMan

一、TCP介绍

1.1、TCP协议，传输控制协议（英语：Transmission Control Protocol，缩写为 TCP）是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。
1.2、TCP通信需要经过 创建连接、数据传送、终止连接 三个步骤。
1.3、TCP通信模型中，在通信开始之前，一定要先建立相关的链接，才能发送数据，类似于生活中，"打电话"，而DCP犹如生活中的 "写信"。
TCP

二、TCP特点

2.1、面向连接
- 通信双方必须先建立连接才能进行数据的传输，双方都必须为该连接分配必要的系统内核资源，以管理连接的状态和连接上的传输。
- 双方间的数据传输都可以通过这一个连接进行。
- 完成数据交换后，双方必须断开此连接，以释放系统资源。
- 这种连接是一对一的，因此TCP不适用于广播的应用程序，基于广播的应用程序请使用UDP协议。
2.2、可靠传输
- (1)、TCP采用发送应答机制
  - TCP发送的每个报文段都必须得到接收方的应答才认为这个TCP报文段传输成功
- (2)、超时重传
  - 发送端发出一个报文段之后就启动定时器，如果在定时时间内没有收到应答就重新发送这个报文段。
  - TCP为了保证不发生丢包，就给每个包一个序号，同时序号也保证了传送到接收端实体的包的按序接收。然后接收端实体对已成功收到的包发回一个相应的确认（ACK）；如果发送端实体在合理的往返时延（RTT）内未收到确认，那么对应的数据包就被假设为已丢失将会被进行重传。
- (3)、错误校验
  - TCP用一个校验和函数来检验数据是否有错误；在发送和接收时都要计算校验和。
- (4)、流量控制和阻塞管理
  - 流量控制用来避免主机发送得过快而使接收方来不及完全收下。

三、TCP与UDP的不同点

3.1、有如下不同点
- 面向连接（确认有创建三方交握，连接已创建才作传输。）
- 有序数据传输
- 重发丢失的数据包
- 舍弃重复的数据包
- 无差错的数据传输
- 阻塞/流量控制
3.2、udp通信模型
udp通信模型中，在通信开始之前，不需要建立相关的链接，只需要发送数据即可，类似于生活中，"写信""

udp通信模型
udp通信模型
3.3、TCP通信模型
tcp通信模型中，在通信开始之前，一定要先建立相关的链接，才能发送数据，类似于生活中，"打电话""

TCP通信模型

四、tcp客户端构建流程

4.1、tcp的客户端要比服务器端简单很多，如果说服务器端是需要自己买手机、查手机卡、设置铃声、等待别人打电话流程的话，那么客户端就只需要找一个电话亭，拿起电话拨打即可，流程要少很多

4.2、实例代码（四步）

(1)、创建TCP套接字

tcp_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

(2)、创建链接服务器,一个元组：服务器的IP与端口

server_ip = input("请输入要连接的服务器ip:")
server_port = input("请输入要连接的服务器port:")
server_addr = (server_ip,server_port)
tcp_socket.connect(server_addr)

(3)、发送内容或者接收内容

# 发送内容
send_data = input("亲输入要发送的内容：")
tcp_socket.send(send_data.encode("utf-8"))

# 接收对方发送过来的数据，最大接收1024个字节
recvData = tcp_client_socket.recv(1024)
print('接收到的数据为:', recvData.decode("utf-8"))

(4)、关闭套接字
```
tcp_socket.close()
```

4.3、完整的tcp客户端代码

import socket


def run_client():
      """tcp客户端代码"""

      # 1、创建TCP套接字
      tcp_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

      # 2、创建链接服务器,一个元组：服务器的IP与端口
      server_ip = input("请输入要连接的服务器ip:")
      server_port = int(input("请输入要连接的服务器port:"))
      server_addr = (server_ip,server_port)
      tcp_socket.connect(server_addr)

      # 3、发送内容或者接收内容
      send_data = input("亲输入要发送的内容：")
      tcp_socket.send(send_data.encode("utf-8"))

      # 接收对方发送过来的数据，最大接收1024个字节
      recvData = tcp_socket.recv(1024)
      print('接收到的数据为:', recvData.decode("utf-8"))

      # 4、关闭套接字
      tcp_socket.close()


if __name__ == '__main__':

      run_client()

五、tcp服务器端构建流程

5.1、服务器端主要有以下6步（固定）
- (1)、socket创建一个套接字
- (2)、bind绑定ip和port
- (3)、listen使套接字变为可以被动链接
- (4)、accept等待客户端的链接
- (5)、recv/send接收发送数据
- (6)、关闭套接字

5.2、socket创建一个tcp服务器套接字

tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

5.3、bind绑定ip和port

tcp_server_socket.bind(("服务器的ip",服务器的端口))

5.4、改变服务器套接字由默认的主动变被动 listen
```
tcp_server_socket.listen(128)
```

5.5、等待别人发信息过来(等待客户端的链接 accept)
如果有新的客户端来链接服务器，那么就产生一个新的套接字专门为这个客户端服务

# new_client_socket：用来为这个客户端服务
# tcp_server_socket：就可以省下来专门等待其他新客户端的链接
new_client_socket,client_addr = tcp_server_socket.accept()

5.6、接收客户端发送过来的数据

receive_data = new_client_socket.recv(1024)
print(receive_data.decode("utf-8"))

5.7、回复一部分数据给客户端

new_client_socket.send("哈哈哈哈😆😆😆😆😆😆".encode("utf-8"))

5.8、关闭套接字

new_client_socket.close()
tcp_server_socket.close()

5.9、完整的服务器端代码

import socket

def run_server():

       # 1、创建tcp服务器套接字
       tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

       # 2、绑定服务器信息
       tcp_server_socket.bind(("192.168.3.223",7890))

       # 3、改变服务器套接字由默认的主动变被动 listen
       tcp_server_socket.listen(128)

       print('---1---')

       # 4、等待别人发信息过来(等待客户端的链接 accept)
       # 如果有新的客户端来链接服务器，那么就产生一个新的套接字专门为这个客户端服务
       # new_client_socket：用来为这个客户端服务
       # tcp_server_socket：就可以省下来专门等待其他新客户端的链接
       new_client_socket,client_addr = tcp_server_socket.accept()

       print('---2---')

       # 5、接收客户端发送过来的数据
       receive_data = new_client_socket.recv(1024)
       print(receive_data.decode("utf-8"))

       # 6、回复一部分数据给客户端
       new_client_socket.send("哈哈哈哈😆😆😆😆😆😆".encode("utf-8"))

       # 7、关闭套接字
       new_client_socket.close()
       tcp_server_socket.close()


if __name__ == '__main__':

      run_server()

六、tcp服务器循环为多个客户端服务（对上面tcp服务器代码的改进）

6.1、分析：
在我们开启tcp服务器后，服务器的套接字进入等待客户端的状态，当客户端进行了连接服务器，服务器将为其服务，等待客户端的数据，接收到用户的数据后为其服务，服务完再等待客户端的新的指令，服务器接到客户端的数据后为其服务，再次等待客户端的数据，如果客户端关闭了自己的套接字，服务器端将收到一个空数据，这时服务器也将关闭为这个客户端服务的套接字，一个客户端与服务器的链接结束

6.2、完善后的代码

import socket


def run_server():

     # 1、创建tcp服务器套接字
     tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

     # 2、绑定服务器信息
     tcp_server_socket.bind(("192.168.3.6",7890))

     # 3、改变服务器套接字由默认的主动变被动 listen
     tcp_server_socket.listen(128)

     # 4、等待别人发信息过来(等待客户端的链接 accept)
     # new_client_socket：用来为这个客户端服务
     # tcp_server_socket：就可以省下来专门等待其他新客户端的链接

    # 为多个客户端服务
    while True:

          print("等待一个新的客户端的到来")
          new_client_socket, client_addr = tcp_server_socket.accept()
          print("一个新的客户端已经到来%s"%str(client_addr))

          # 循环的目的：为同一个客户端 服务多次
          while True:

                # 5、接收客户端发送过来的请求数据
                receive_data = new_client_socket.recv(1024)
                print(receive_data.decode("utf-8"))

                # 如果recv解堵塞，那么有2种方式：
                # 1、客户端发送过来数据
                # 2、客户端调用 close 导致了 这里 recv 堵塞
                if receive_data:

                     # 6、回复一部分数据给客户端
                     new_client_socket.send("哈哈哈哈😆😆😆😆😆😆".encode("utf-8"))
                     print("给客户端回复了：哈哈哈哈😆😆😆😆😆😆")
                else:
                     print("客户端关闭了自己的套接字或则断开了链接")
                     break

           # 7、关闭套接字，关闭accept 返回的套接字 意味着 不会在为这个客户端服务
           new_client_socket.close()

    # 如果将监听套接字 关闭了，那么会导致 不能再次等待新客户端的到来，也就是 套接字.accept()会失败
    tcp_server_socket.close()


if __name__ == '__main__':

           run_server()

上面两个while的作用：

第1个: 为多个客户端服务

第2个: 为同一个客户端服务多次

七、TCP下载器：客户端 与 服务器端（注释都在代码里面）

7.1、客户端

import socket


def main():

      # 1、创建tcp套接字
      tcp_client_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

      # 2.创建与服务器的链接
      server_ip = input("请输入连接服务器的ip：")
      server_port = int(input("请输入服务器对应的端口："))
      tcp_client_socket.connect((server_ip,server_port))

      # 3、发送下载的文件名字给服务器
      file_name = input("请输入要下载的文件名字：")
      tcp_client_socket.send(file_name.encode("utf-8"))

      # 4、接收服务器返回的文件的数据 ,接收一个小的试试
      receive_data = tcp_client_socket.recv(1024)

      # 5、判断数据是否有(保存接收到的数据到一个文件夹中)
      if receive_data:

           with open("[new]"+file_name,'wb') as file:

                 file.write(receive_data)

      # 6、关闭tcp套接字
      tcp_client_socket.close()

if __name__ == '__main__':

        main()

7.2、服务器

import socket


def exec_file(new_tcp_socket,client_addr):

       print("等待客户端的指令")
       # 1、接收客户端要下载的文件名
       file_name = new_tcp_socket.recv(1024).decode("utf-8")
       print("客户端：%s 要下载的文件名是：%s"%(str(client_addr),file_name))

       # 2、在服务器找到这个文件，打开读取，发送给客户端
       file_data = None
       try:

           file = open(file_name,'rb')
           file_data = file.read()
           file.close()
       except:
           print("% 文件不存在" % file_name)

      # 3、发送文件内的数据给客户端
      new_tcp_socket.send(file_data)

def server_down():

      # 1、创建服务器套接字
      tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

      # 2、绑定本地的服务器与端口
      tcp_server_socket.bind(("192.168.3.6",7893))

      # 3、让tcp套接字由主动变被动
      tcp_server_socket.listen(128)

      while True:

           print("等待客户端的连接")

           # 4、等待客户端的连接
           new_tcp_socket,client_addr = tcp_server_socket.accept()

           # 5、处理客户端的内容
           exec_file(new_tcp_socket,client_addr)

           # 6.关闭为这个客户端服务的套接字
           new_tcp_socket.close()

      # 7.关闭监听服务器套接字
      tcp_server_socket.close()

if __name__ == '__main__':

      server_down()

7.3、说一下写与读文件的注意点，在往文件里面写内容的时候，文件可以不存在，可以自己根据文件名在当前目录下创建，然后如果是读取文件的内容的时候，文件是必须存在的才可以进行读取，否则会报错，还有一个注意点是：with 的使用，with可以保证文件打开后，一定会关闭，如上面客户端的代码
```
with open("[new]"+file_name,'wb') as file:
             file.write(receive_data)
```

八、tcp注意点

8.1、tcp服务器一般情况下都需要绑定，否则客户端找不到这个服务器
8.2、tcp客户端一般不绑定，因为是主动链接服务器，所以只要确定好服务器的ip、port等信息就好，本地客户端可以随机
8.3、tcp服务器中通过listen可以将socket创建出来的主动套接字变为被动的，这是做tcp服务器时必须要做的
8.4、当客户端需要链接服务器时，就需要使用connect进行链接，udp是不需要链接的而是直接发送，但是tcp必须先链接，只有链接成功才能通信
8.5、当一个tcp客户端连接服务器时，服务器端会有1个新的套接字，这个套接字用来标记这个客户端，单独为这个客户端服务
8.6、listen后的套接字是被动套接字，用来接收新的客户端的链接请求的，而accept返回的新套接字是标记这个新客户端的
8.7、关闭listen后的套接字意味着被动套接字关闭了，会导致新的客户端不能够链接服务器，但是之前已经链接成功的客户端正常通信。
8.8、关闭accept返回的套接字意味着这个客户端已经服务完毕
8.9、当客户端的套接字调用close后，服务器端会recv解堵塞，并且返回的长度为0，因此服务器可以通过返回数据的长度来区别客户端是否已经下线

Python 网络编程3：tcp客户端与tcp服务器以及下载器

猜你喜欢

热点阅读