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

一、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，因此服务器可以通过返回数据的长度来区别客户端是否已经下线