python网络编程-Socket详解

一.前言

　　套接字：

　　套接字是一种且有通信端点概念的计算机网络数据结构。C/S

　　套接字地址：主机与端口

　　套接字类型：

　　　　面向连接与无连接

　　面向连接：在通信之前需要建立一条连接。实现面向连接的主要协议TCP

　　无连接：无需建立连接就可以通信。实现无连接的主要协议是UCP

二. socket模块简介

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

　　socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，对于文件用【打开】【读写】【关闭】模式来操作。socket就是该模式的一个实现

　　socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭）

　　socket和file的区别：

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

　　

　　使用socket.socket()创建套接字

　　创建一个TCP/IP套接字　

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

　　创建UDP/IP套接字

udpsock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

三. SOCKET内建方法

　　

3.1创建TCP服务器

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

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

　　2.开始监听链接

s.listen()

　　3.进入循环，不断接受客户端的链接请求

While True:
    s.accept()

　　4.接收客户端传来的数据，并且发送给对方发送数据

s.recv()
s.sendall()

　　5.传输完毕后，关闭套接字

s.close()

例：服务端完整代码

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#socket

import socket

obj = socket.socket()
obj.bind(("127.0.0.1",9000,))
obj.listen(5)

while True:
    conn, addr = obj.accept()
    conn.sendall(bytes("欢迎登录！！",encoding="utf-8"))
    print(conn, addr)
    while True:
        ret_bytes = conn.recv(1024)
        ret_str = str(ret_bytes, encoding="utf-8")
        if ret_str == "q":
            break
        conn.sendall(bytes(ret_str+"test",encoding="utf-8"))
Server.py

3.2 客户端

 1.创建套接字并链接至远端地址

c = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
c.connect(('IP地址',9000))

 2.链接后发送数据和接收数据

c.sendall()
c.recv()

3.传输完毕后，关闭套接字

c.close()

例:客户端完代码

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import socket

client = socket.socket()

client.connect(("127.0.0.1", 9000))
ret_bytes = client.recv(1024)
ret_str = str(ret_bytes, encoding="utf-8")
print(ret_str)
while True:
    inp = input("请输入要发送内容，q退出")
    if inp == "q":
        client.sendall(bytes(inp, encoding="utf-8"))
        break
    else:
        client.sendall(bytes(inp, encoding="utf-8"))
        ret = str(client.recv(1024), encoding="utf-8")
        print(ret)
client.close()
client.py

3.2 创建UDP服务器

　　sk = socket()　　#创建一个服务器的套接字

　　sk.bind()　　　　#绑定服务器套接字

　　loop:　　　　#服务器循环不间断监听

　　cs = sk.recvfrom()/sk.sendto()　　#对话（接收与发送）

　　sk.close()　　#关闭连接

#服务端
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()
View Code

四.IO多路复用

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

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

Windows Python：
    提供： select
Mac Python：
    提供： select
Linux Python：
    提供： select、poll、epoll

注意：网络操作、文件操作、终端操作等均属于IO操作，对于windows只支持Socket操作，其他系统支持其他IO操作，但是无法检测 普通文件操作 自动上次读取是否已经变化。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#select监听实例

import select
import threading
import sys

while True:
    readable, writeable, error = select.select([sys.stdin,],[],[],1)
    if sys.stdin in readable:
        print 'select get stdin',sys.stdin.readline()
View Code
#!/usr/bin/env python
# -*- coding:utf-8 -*-

import socket
import select

sk1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sk1.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sk1.bind(('127.0.0.1',8002))
sk1.listen(5)
sk1.setblocking(0)

inputs = [sk1,]

while True:
    readable_list, writeable_list, error_list = select.select(inputs, [], inputs, 1)
    for r in readable_list:
        # 当客户端第一次连接服务端时
        if sk1 == r:
            print 'accept'
            request, address = r.accept()
            request.setblocking(0)
            inputs.append(request)
        # 当客户端连接上服务端之后，再次发送数据时
        else:
            received = r.recv(1024)
            # 当正常接收客户端发送的数据时
            if received:
                print 'received data:', received
            # 当客户端关闭程序时
            else:
                inputs.remove(r)

sk1.close()
View Code
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#利用select实现伪同时处理多个Socket客户端请求：客户端
import socket

ip_port = ('127.0.0.1',8002)
sk = socket.socket()
sk.connect(ip_port)

while True:
    inp = raw_input('please input:')
    sk.sendall(inp)
sk.close()
View Code

此处的Socket服务端相比与原生的Socket，他支持当某一个请求不再发送数据时，服务器端不会等待而是可以去处理其他请求的数据。但是，如果每个请求的耗时比较长时，select版本的服务器端也无法完成同时操作

#!/usr/bin/env python
#coding:utf8

'''
 服务器的实现 采用select的方式
'''

import select
import socket
import sys
import Queue

#创建套接字并设置该套接字为非阻塞模式

server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.setblocking(0)

#绑定套接字
server_address = ('localhost',10000)
print >>sys.stderr,'starting up on %s port %s'% server_address
server.bind(server_address)

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

server.listen(5)

#初始化读取数据的监听列表,最开始时希望从server这个套接字上读取数据
inputs = [server]

#初始化写入数据的监听列表，最开始并没有客户端连接进来，所以列表为空

outputs = []

#要发往客户端的数据
message_queues = {}
while inputs:
    print >>sys.stderr,'waiting for the next event'
    #调用select监听所有监听列表中的套接字，并将准备好的套接字加入到对应的列表中
    readable,writable,exceptional = select.select(inputs,outputs,inputs)#列表中的socket 套接字  如果是文件呢？ 
    #监控文件句柄有某一处发生了变化 可写 可读  异常属于Linux中的网络编程 
    #属于同步I/O操作，属于I/O复用模型的一种
    #rlist--等待到准备好读
    #wlist--等待到准备好写
    #xlist--等待到一种异常
    #处理可读取的套接字

    '''
        如果server这个套接字可读，则说明有新链接到来
        此时在server套接字上调用accept,生成一个与客户端通讯的套接字
        并将与客户端通讯的套接字加入inputs列表，下一次可以通过select检查连接是否可读
        然后在发往客户端的缓冲中加入一项，键名为:与客户端通讯的套接字，键值为空队列
        select系统调用是用来让我们的程序监视多个文件句柄(file descrīptor)的状态变化的。程序会停在select这里等待，
        直到被监视的文件句柄有某一个或多个发生了状态改变
        '''

    '''
        若可读的套接字不是server套接字,有两种情况:一种是有数据到来，另一种是链接断开
        如果有数据到来,先接收数据,然后将收到的数据填入往客户端的缓存区中的对应位置，最后
        将于客户端通讯的套接字加入到写数据的监听列表:
        如果套接字可读.但没有接收到数据，则说明客户端已经断开。这时需要关闭与客户端连接的套接字
        进行资源清理
        '''
        
    for s in readable: 
        if s is server:
            connection,client_address = s.accept()
            print >>sys.stderr,'connection from',client_address
            connection.setblocking(0)#设置非阻塞
            inputs.append(connection)
            message_queues[connection] = Queue.Queue()
        else:
            data = s.recv(1024)
            if data:
                print >>sys.stderr,'received "%s" from %s'% \
                (data,s.getpeername())
                message_queues[s].put(data)
                if s not in outputs:
                    outputs.append(s)
            else:
                print >>sys.stderr,'closing',client_address
                if s in outputs:
                    outputs.remove(s)
                inputs.remove(s)
                s.close()
                del message_queues[s]
                    
    #处理可写的套接字
    '''
        在发送缓冲区中取出响应的数据，发往客户端。
        如果没有数据需要写，则将套接字从发送队列中移除，select中不再监视
        '''

    for s in writable:
        try:
            next_msg = message_queues[s].get_nowait()

        except Queue.Empty:
            print >>sys.stderr,'  ',s,getpeername(),'queue empty'
            outputs.remove(s)
        else:
            print >>sys.stderr,'sending "%s" to %s'% \
            (next_msg,s.getpeername())
            s.send(next_msg)



    #处理异常情况

    for s in exceptional:
        for s in exceptional:
            print >>sys.stderr,'exception condition on',s.getpeername()
            inputs.remove(s)
            if s in outputs:
                outputs.remove(s)
            s.close()
            del message_queues[s]
View Code
posted @ 2016-06-11 22:30  jl_bai  阅读(479)  评论(0)    收藏  举报

♥

收藏

∧

返回顶部