Python：网络编程

socket介绍

socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄，应用程序通常通过"套接字"向网络发出请求或者应答网络请求。

socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，对于文件用【打开】【读写】【关闭】模式来操作。socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭）

socket和file的区别：

• file模块是针对某个指定文件进行【打开】【读写】【关闭】
• socket模块是针对 服务器端 和 客户端Socket 进行【打开】【读写】【关闭】

 

socket server

import socket

sk = socket.socket()
sk.bind(("127.0.0.1",9999,)) # 绑定
sk.listen(5) #最多5个人等待

while True:
    print("start")
    conn,address = sk.accept() # accept 阻塞
    print(address,conn)
    conn.sendall(bytes("Hello",encoding="utf-8")) # 向客户端发送内容
    while True:
        ret_bytes = conn.recv(1024) # 接受内容，一次性接受1024字节
        ret_str = str(ret_bytes,encoding="utf-8") # 将接受到的字节转为字符串
        if ret_str == "q": # 当接受的字符串为q
            break # 退出循环
        conn.sendall(bytes(ret_str + "ok",encoding="utf-8"))

 

socket client

import socket
obj = socket.socket()
obj.connect(("127.0.0.1",8889)) # 进行连接

obj_bytes = obj.recv(1204) # 接收到服务器发送的内容
obj_str = str(obj_bytes,encoding="utf-8") # 将内容装换成字符串进行打印
print(obj_str)

while True:
    inp = input("请输入内容：")
    if inp == "q":
        break
    else:
        obj.sendall(bytes(inp,encoding="utf-8")) # 发送输入的内容
        ret = str(obj.recv(1024),encoding="utf-8") # 接收发送的内容转为字符串并打印
        print(ret)

obj.close() #关闭连接

 

WEB服务应用：

#!/usr/bin/env python
#coding:utf-8
import socket
 
def handle_request(client):
    buf = client.recv(1024)
    client.send("HTTP/1.1 200 OK\r\n\r\n")
    client.send("Hello, World")
 
def main():
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.bind(('localhost',8080))
    sock.listen(5)
 
    while True:
        connection, address = sock.accept()
        handle_request(connection)
        connection.close()
 
if __name__ == '__main__':
  main()

 

更多功能

sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)

参数一：地址簇

　　socket.AF_INET IPv4（默认）
　　socket.AF_INET6 IPv6

　　socket.AF_UNIX 只能够用于单一的Unix系统进程间通信

参数二：类型

　　socket.SOCK_STREAM　　流式socket , for TCP （默认）
　　socket.SOCK_DGRAM　　 数据报式socket , for UDP

　　socket.SOCK_RAW 原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。
　　socket.SOCK_RDM 是一种可靠的UDP形式，即保证交付数据报但不保证顺序。SOCK_RAM用来提供对原始协议的低级访问，在需要执行某些特殊操作时使用，如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。
　　socket.SOCK_SEQPACKET 可靠的连续数据包服务

参数三：协议

　　0　　（默认）与特定的地址家族相关的协议,如果是 0 ，则系统就会根据地址格式和套接类别,自动选择一个合适的协议

import socket
ip_port = ('127.0.0.1',9999)
sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)
sk.bind(ip_port)

while True:
    data = sk.recv(1024)
    print data




import socket
ip_port = ('127.0.0.1',9999)

sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)
while True:
    inp = raw_input('数据：').strip()
    if inp == 'exit':
        break
    sk.sendto(inp,ip_port)

sk.close()

 

sk.bind(address)

　　sk.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()

 

实例：智能机器人

import socket

ip_port = ('127.0.0.1',8888)
sk = socket.socket()
sk.bind(ip_port)
sk.listen(5)

while True:
    conn,address =  sk.accept()
    conn.sendall('欢迎致电 10086，请输入1xxx,0转人工服务.')
    Flag = True
    while Flag:
        data = conn.recv(1024)
        if data == 'exit':
            Flag = False
        elif data == '0':
            conn.sendall('通过可能会被录音.balabala一大推')
        else:
            conn.sendall('请重新输入.')
    conn.close()

import socket


ip_port = ('127.0.0.1',8005)
sk = socket.socket()
sk.connect(ip_port)
sk.settimeout(5)

while True:
    data = sk.recv(1024)
    print 'receive:',data
    inp = raw_input('please input:')
    sk.sendall(inp)
    if inp == 'exit':
        break

sk.close()

 

基于socket实现文件上传

服务端：

import socket
sk = socket.socket()
sk.bind(("127.0.0.1",9990,))
sk.listen(2)

while True:
    conn,adress = sk.accept()
    conn.sendall(bytes("Hello",encoding="utf-8"))

    f_size = str(conn.recv(1024),encoding="utf-8")
    conn.sendall(bytes("ok",encoding="utf-8"))

    #接收文件
    total_size = int(f_size)
    has_size = 0
    f = open("new.png","wb")
    while True:
        if total_size == has_size:
            break
        else:
            ret = conn.recv(1024)
            f.write(ret)
        has_size += len(ret)
    f.close()

 

客户端：

import socket
import os

obj = socket.socket()
obj.connect(("127.0.0.1",9990))

obj_str = str(obj.recv(1024),encoding="utf-8")
print(obj_str)

#发送文件大小
file_size = os.stat("XX.png").st_size
obj.sendall(bytes(str(file_size),encoding="utf-8"))
ret = str(obj.recv(1024),encoding="utf-8")
print(ret)

#发送文件
with open("XX.png","rb") as f:
    for line in f:
        obj.sendall(line)

obj.close()

 

并发操作：

可以通过IO多路复用，也可以通过socketserver来实现。

socketsercver内部是基于IO多路复用和多线程来实现多并发操作

socketserver模块实现并发操作：

服务端：

import socketserver


class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        conn = self.request
        conn.sendall(bytes("Hello", encoding="utf-8"))  # 向客户端发送内容
        while True:
            conn_bytes = conn.recv(1024)
            conn_str = str(conn_bytes,encoding="utf-8")
            if conn_str == "q":
                break
            conn.sendall(bytes(conn_str + "ok",encoding="utf-8"))

if __name__ == "__main__":
    sever = socketserver.ThreadingTCPServer(("127.0.0.1", 8888), MyServer)
    sever.serve_forever()

注：

1、socketserver可并发处理多个客户端请求

2、使用时创建类，必须继承

3、类里面必须有handle方法

4、把类当做参数传到对象里面，然后执行server_forever

 

 

IO多路复用

　　I/O多路复用指：通过一种机制，可以监视多个描述符。一旦某个描述符就绪（一般是读就绪或者写就绪），就能够通知程序进行相应的读写操作。

　　Python中有一个select模块，其中提供了：select、poll、epoll三个方法，分别调用系统的 select，poll，epoll 从而实现IO多路复用

import socket

sk1 = socket.socket()
sk1.bind(("127.0.0.1",8001,))
sk1.listen(5)

sk2 = socket.socket()
sk2.bind(("127.0.0.1",8002,))
sk2.listen(5)

inp = [sk1,sk2]
import select
while True:
    #[sk1,sk2],select内部自动监听sk1,sk2两个对象，一旦某个句柄发生变化
    #如果有人连接sk1==>r_list = [sk1]
    r_list,w_list,e_list = select.select(inp,[],[],1)
    for sk in r_list:
        #每一个连接对象
        conn,adress = sk.accept()
        conn.sendall(bytes("Hello",encoding="utf-8"))
        conn.close()

 

参数说明：

r_list:如果有人连接sk1 or sk2...，就将sk1 or sk2添加到里面

w_list:将客户端发送给服务端的客户端对象添加到里面

e_list:监听出现错误的文件句柄，将错误的放到里面

2：最多等待的时间：select是检测句柄变化的，2表示用2秒检测是否发生变化

import socket
sk1 = socket.socket()
sk1.bind(("127.0.0.1",8005,))
sk1.listen(5)

inp = [sk1]
outputs = [] # 哪个客户端发来消息就基类哪个客户端
message_dict = {} # 客户端对应的发送的消息

import select
while True:
    r_list,w_list,e_list = select.select(inp,outputs,inp,2)
    print("正在监听的socket对象%d" % len(inp))
    print(r_list)
    for sk1_or_conn in r_list:
        #每连接一个对象
        if sk1_or_conn == sk1:
            #表示有新用户来连接
            conn,adress = sk1_or_conn.accept()
            inp.append(conn)
            message_dict[conn] = []
        else:
            try:
                sk1_bytes = sk1_or_conn.recv(1024)
                # sk1_str = str(sk1_bytes,encoding="utf-8")
                # sk1_or_conn.sendall(bytes(sk1_str + "ok",encoding="utf-8"))
            except Exception as ex:
                inp.remove(sk1_or_conn)
            else:
                sk1_str = str(sk1_bytes,encoding="utf-8")
                message_dict[sk1_or_conn].append(sk1_str)
    for conn in w_list:
        recv_str = message_dict[conn][0]
        del message_dict[conn][0]
        conn.sendall(bytes(recv_str + "ok",encoding="utf-8"))
        outputs.remove(conn)

    for sk in e_list:
        inp.remove(sk)