Python 之网络编程之socket(1)TCP 方式与UDP方式

 

一:socket介绍

网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket。

建立网络通信连接至少要一对端口号(socket)。socket本质是编程接口(API)，对TCP/IP的封装，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口；HTTP是轿车，提供了封装或者显示数据的具体形式；Socket是发动机，提供了网络通信的能力。通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄，可以用来实现不同虚拟机或不同计算机之间的通信。在Internet上的主机一般运行了多个服务软件，同时提供几种服务。每种服务都打开一个Socket，并绑定到一个端口上，不同的端口对应于不同的服务。

二:socket的参数介绍

Python 提供了两个基本的 socket 模块。

 第一个是 Socket，它提供了标准的 BSD Sockets API。 

第二个是 SocketServer， 它提供了服务器中心类，可以简化网络服务器的开发。

套接字格式：

socket(family,type[,protocal]) 使用给定的地址族、套接字类型、协议编号（默认为0）来创建套接字。

1.Socket 类型

 

2.Socket 函数

注意点:

1）TCP发送数据时，已建立好TCP连接，所以不需要指定地址。UDP是面向无连接的，每次发送要指定是发给谁。

2）服务端与客户端不能直接发送列表，元组，字典。需要字符串化repr(data)。

sk.bind(address) 必会

　　s.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。

sk.listen(backlog) 必会

　　开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。

      backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5
      这个值不能无限大，因为要在内核中维护连接队列

sk.setblocking(bool) 必会

　　是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。

sk.accept() 必会

　　接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。

　　接收TCP 客户的连接（阻塞式）等待连接的到来

sk.connect(address) 必会

　　连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。

sk.connect_ex(address)

　　同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061

sk.close() 必会

　　关闭套接字

sk.recv(bufsize[,flag]) 必会

　　接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。

sk.recvfrom(bufsize[.flag])

　　与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。

sk.send(string[,flag]) 必会

　　将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。

sk.sendall(string[,flag]) 必会

　　将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。

      内部通过递归调用send，将所有内容发送出去。

sk.sendto(string[,flag],address)

　　将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。

sk.settimeout(timeout) 必会

　　设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如 client 连接最多等待5s ）

sk.getpeername()  必会

　　返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。

sk.getsockname() 

　　返回套接字自己的地址。通常是一个元组(ipaddr,port)

sk.fileno() 

　　套接字的文件描述符

socket.sendfile(file, offset=0, count=None)

     发送文件 ，但目前多数情况下并无什么卵用。

三: socket 实例

首先是socket客户端与服务端的编程思想,首先以TCP的socket开始

TCP服务端：

1 创建套接字，绑定套接字到本地IP与端口

   # socket.socket(socket.AF_INET,socket.SOCK_STREAM) , s.bind()

2 开始监听连接                   #s.listen()

3 进入循环，不断接受客户端的连接请求              #s.accept()

4 然后接收传来的数据，并发送给对方数据         #s.recv() , s.sendall()

5 传输完毕后，关闭套接字                     #s.close()

TCP客户端:

1 创建套接字，连接远端地址

       # socket.socket(socket.AF_INET,socket.SOCK_STREAM) , s.connect()

2 连接后发送数据和接收数据          # s.sendall(), s.recv()

3 传输完毕后，关闭套接字          #s.close()

 

(1)TCP socket实现

首先来一个一收一发的socket的实例:

##(1) 一发一会的tcp socket

client.py  就是客户端代码:

 

import socket
# 产生一个socket对象
sk = socket.socket()

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

#发送消息
sk.send("你好".encode("utf-8"))

#接收消息
res = sk.recv(1024)
strvar = res.decode("utf-8")
print(strvar)
sk.close()

 

server.py  就是服务端代码:

import socket
#创建一个socket对象
sk = socket.socket()

# 绑定ip和端口(注册网络,让客户端可以找到你)
# #'127.0.0.1" 默认本机的ip
sk.bind(("127.0.0.1",9000))

#开始监听
sk.listen()


#建立三次握手,建立连接,程序加了阻塞
#建立三次握手如果失败,程序不往下执行
#接受客户端的连接请求
conn,addr = sk.accept()
print(conn,addr)

# 设置最大一次性接收1024字节,程序再次加上阻塞,没有接收到数据,不会向下执行代码
msg = conn.recv(1024)

# 把字节流恢复成正常的字符串
print(msg.decode("utf-8"))

# 发送给客户端数据,发送前需要把数据编码成二进制字节流
conn.send("你也好呀".encode("utf-8"))

# 执行四次挥手,断开连接
conn.close()

#  传输完毕后，关闭套接字,退还占用的端口
sk.close()

先运行server端后,再运行client端,就会出现如下截图:

首先是server端输出:(这个你好是客户端发过来的)

然后client端的截图为:(这个你也好呀是服务端向客户端发出的内容)

只有一个发送一个接收就结束肯定不能满足我们的需求,所以接下来

## (2)可以循环发送消息的tcp socket

首先是客户端

client2.py   

import socket

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

while True:
    content = input("客户端说:")
    #发送的二进制字节流数据,所以都需要先编码
    sk.send(content.encode("utf-8"))
    res = sk.recv(1024).decode("utf-8")
    if res == "q":
        break
    print("服务端说:",res)

# 关闭连接
sk.close()

然后是服务端代码

server2.py

import socket

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

#监听端口
sk.listen()

while True:
    #建立三次握手
    conn,addr = sk.accept()

    while True:
        res = conn.recv(1024)
        #把字节流编程原本字符串
        res2 = res.decode("utf-8")
        print("客户端说:",res2)
        content = input("服务器说:")
        conn.send(content.encode("utf-8"))
        if content == "q":
            break
    # 执行四次挥手
    conn.close()

#退出系统端口
sk.close()

运行的结果如下,客户端发一句,服务端发一句,有来有回,可以一直持续,然后如果服务器按q可以和客户端断开,见如下两个截图:

客户端截图:

服务端截图:

服务端还能继续监听,知道下一个连接.

 (2)UDP socket实现

 同样的先来一个简单的udp例子

## (1) 只有一收一发的udp

#首先是服务端代码:

server_udp_1.py

import socket

#socket.SOCK_DGRAM 代表udp协议
sk = socket.socket(type = socket.SOCK_DGRAM)
#绑定地址(例子为本机地址)
sk.bind(("127.0.0.1", 9000))

# udp 作为服务器,第一次一定是先接收消息
# 接收消息可以得到,客户端发的信息和客户端ip地址
msg,cli_addr = sk.recvfrom(1024)

# 记得一定要将接收到的数据进行解码
print("udp客户端说:",msg.decode("utf-8"))

#将要发送给客户端的消息进行编码
msg2 = "你也好呀".encode("utf-8")

#sendto ( "要发送的消息".encode() , (ip, 端口 ) )
sk.sendto(msg2,cli_addr)

#关闭udp连接
sk.close()

#然后是客户端代码

import socket

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

msg = "你好服务端"
# udp 发送数据
# sendto ( "要发送的消息".encode() , (ip,端口) )
sk.sendto(msg.encode("utf-8"), ("127.0.0.1", 9000))

# udp 接收数据
msg, addr = sk.recvfrom(1024)
# 打印接收的数据前解码
res = msg.decode("utf-8")
print("udp服务端说:", res)

# 关闭upd连接
sk.close()

先运行服务端,再接着运行客户端,然后客户端和服务器的输出截图如下:

服务端输出截图:

然后是客户端截图:

# # (2) 可以循环发送消息的tcp socket

 首先是服务端:server_udp_2.py

import socket

sk = socket.socket(type = socket.SOCK_DGRAM)
# 绑定网络(在网络上注册自己,让客户端能找到你)
sk.bind(("127.0.0.1", 9000))

while True:
    #客户端发过来的的信息和客户端地址
    msg,cli_addr = sk.recvfrom(1024)
    print("客户端说:", msg.decode("utf-8"))
    message = input("服务端说:")

    sk.sendto(message.encode("utf-8"), cli_addr)

# 关闭udp连接
sk.close()

然后是客户端代码:client_udp_2.y

import socket

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

while True:
    # 发送数据
    message = input("客户端说:")
    sk.sendto(message.encode("utf-8"), ("127.0.0.1", 9000))

    #接收数据
    msg,addr = sk.recvfrom(1024)
    print("服务器说:",msg.decode("utf-8"))

#关闭udp连接
sk.close()

然后是运行发送信息截图分别是客户端和服务端:

客户端截图:

服务端截图:

两边可以无限对话,也可将服务端代码改为tcp的无限对话,按q退出.