Python之Socket&异常处理

Socket

Socket用于描述IP地址和端口号，每一个应用程序都是经过它来进行网络请求或者网络应答。

socket模块和file模块有类似之处，file主要对某个文件进行打开、读写、关闭操做。socket主要对服务端和客户端应用程序进行打开、读写、关闭。

经常使用方法：

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.recv(bufsize[,flag])

　接受套接字的数据。数据以字符串形式返回，bufsize指定最多能够接收的数量。flag提供有关消息的其余信息，一般能够忽略。

sk.send(string[,flag])

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

sk.sendall(string[,flag])

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

    内部经过递归调用send，将全部内容发送出去。

sk.close()

　　关闭套接字。

客户端与服务端socket通讯示例：

服务器端：

import socket
ip_port = ('127.0.0.1',8888)

sk = socket.socket()
sk.bind(ip_port)#向系统申请地址和端口号，并绑定
sk.listen(5)

while True:
    print 'wating...'
    conn,addr = sk.accept()#接收客户端的地址和端口，创建链接
    client_data = conn.recv(1024)#接收客户端数据
    print client_data
    conn.sendall('recive your message!')
    conn.close()

socket_server

客户端：

import socket

ip_port = ('127.0.0.1',8888)
sk = socket.socket()#生成socket句柄实例
sk.connect(ip_port)#链接
sk.sendall('hello hello hello...')#向服务器端发送
server_reply = sk.recv(1024)#接收服务器回应
print server_reply
sk.close()

socket_client

连续交互示例：

服务端：

import socket
ip_port = ('127.0.0.1',8888)

sk = socket.socket()
sk.bind(ip_port)
sk.listen(5)

while True:
    print 'ready...'
    conn,addr = sk.accept()
    while True:
        client_data = conn.recv(1024)
        print client_data
        response = raw_input('>>')
        conn.sendall(response)
    conn.close()

socket_server

客户端：

import socket

ip_port = ('127.0.0.1',8888)
sk = socket.socket()
sk.connect(ip_port)
while True:
    request = raw_input('>>')
    sk.sendall(request)
    server_reply = sk.recv(1024)
    print server_reply
sk.close()

socket_client

 

socket实现ssh功能：

总体思路:

#服务端监听端口ip及端口，客户端发起链接请求，服务器端确认链接，并开始准备接收客户端发来的消息(循环，若是没有收到客户端发来的消息，退出循环)。
#收到客户端发来的命令，执行该命令，并将该命令执行结果的大小返回给客户端(ack_msg)。
#客户端收到ack_msg后，会给服务端发送确认接收命名执行结果的client_ack_msg,而后服务端开始发送执行结果(此过程是为了不socket粘包问题)客户端开始接收，并根据ack_msg中标记的大小来循环接收命令执行结果。

 服务端：

import socket
import os

ip_port = ('127.0.0.1',8888)

sk = socket.socket()
sk.bind(ip_port)
sk.listen(5)

while True:
    print 'Socker Server is ready...'
    conn,addr = sk.accept()
    while True:
        client_data = conn.recv(1024)
        if not client_data:#没有接受的到客户端消息，退出循环
            break
        print client_data
        response = os.popen(client_data).read()#获取命令执行结果
        if len(response) == 0:#命令执行结果为空，告知客户端，不然客户端会一直等待接受响应
            conn.sendall('command no result!')
        else:
            ack_msg = 'cmd result size is | %s' % len(response)#将命令执行结果的长度发给客户端，‘|’符号便于客户端切割处理
            conn.sendall(ack_msg)#给客户端发送ack
            client_ack = conn.recv(1024)#接收客户端发来的确认接收数据ack
            print client_ack
            if client_ack == 'client_ready_to_recv':#确认接收到客户端发来确认接收数据的ack
                conn.sendall(response)#开始发送命令执行结果
    conn.close()

SSH_Server

客户端：

import socket

ip_port = ('127.0.0.1',8888)
sk = socket.socket()
sk.connect(ip_port)
while True:
    cmd = raw_input('cmd:')
    if len(cmd) == 0:#输入为空时，继续要求输入
        continue
    if cmd == 'q':#输入为q时退出
        break
    sk.sendall(cmd)
    server_ack_msg = sk.recv(1024)
    cmd_res_size = int(server_ack_msg.split('|')[1])#命令执行结果的大小
    print server_ack_msg
    if server_ack_msg.split('|')[0] =='cmd result size is':#若是收到的是服务端发来的ack信息
        print 'hello'
        sk.sendall('client_ready_to_recv')#给服务端发送确认接收数据的ack
    res = ''
    recv_size = 0
    while recv_size < cmd_res_size:#只要接收的比总大小小，就继续接收
        data = sk.recv(1024)
        recv_size += len(data)#将本次接收到的大小加到已接收里
        res += data#拼接接收的内容
    else:
        print res
sk.close()

SSH_Client

以上示例都是能一对一的链接，下面是一个服务端接受多个客户端链接的实例：

服务端：

import  SocketServer

class Handler(SocketServer.BaseRequestHandler):
    def handle(self):
        print 'new conn: %s' % str(self.client_address)
        while True:
            data = self.request.recv(1024)
            if not data:
                break
            else:
                print 'client said:'+data
                self.request.sendall(data)

if __name__ == '__main__':
    host,port = 'localhost',8888
    server = SocketServer.ThreadingTCPServer((host,port),Handler)
    server.serve_forever()

Socket_server

客户端：

import  socket

host_port ='localhost',8888
sk = socket.socket()
sk.connect(host_port)
while True:
    msg = raw_input('>>:').strip()
    sk.sendall(msg)
    server_reply = sk.recv(1024)
    print 'server reply:'+server_reply
sk.close()

Socket_client

 

异常处理

程序运行出现异常时，避免将该异常展示给用户。根据异常处理机制，能够自定义异常抛出信息。

没有添加异常处理：

a = range(10)
print a[11]

运行结果抛出异常：IndexError: list index out of range，程序中止运行

有异常处理：

a = range(10)

try:
    print a[11]
except Exception:
    print '超出范围' #自定义异常提示
     

try:
    print a[11]
except Exception as e:
    print '超出范围' #自定义异常提示
    print e #系统抛出的异常

运行结果：程序正常退出

 

经常使用的异常：

AttributeError 试图访问一个对象没有的树形，好比foo.x，可是foo没有属性x
IOError 输入/输出异常；基本上是没法打开文件
ImportError 没法引入模块或包；基本上是路径问题或名称错误
IndentationError 语法错误（的子类） ；代码没有正确对齐
IndexError 下标索引超出序列边界，好比当x只有三个元素，却试图访问x[5]
KeyError 试图访问字典里不存在的键
KeyboardInterrupt Ctrl+C被按下
NameError 使用一个还未被赋予对象的变量
SyntaxError Python代码非法，代码不能编译(我的认为这是语法错误，写错了）
TypeError 传入对象类型与要求的不符合
UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是因为另有一个同名的全局变量，致使你觉得正在访问它
ValueError 传入一个调用者不指望的值，即便值的类型是正确的

捕获ctrl-c：

while True:
    try:
        input = raw_input('input:')
    except KeyboardInterrupt:
        print '请不要按ctrl+c'#输入ctrl+c后，程序依然运行。

自定义异常：

pass：关于类方法的补充

class a:
    def __init__(self,name):#当建立该类的一个实例时，该方法马上执行。
        self.name = name
    def __str__(self):#返回字符串给用户
        return 'hello %s' % self.name

if __name__ == '__main__':
    p = a('ahaii')
    print p

#运行结果：hello ahaii

class a:
    def __init__(self,name):
        self.name = name

if __name__ == '__main__':
    p = a('ahaii')
    print p

#运行结果：< at 0x7f2b89ecff38>，只返回内存地址

自定义一个异常：

class ahaiiException(Exception):
    def __init__(self,msg):
        self.msg = msg
    def __str__(self):
        return self.msg

try:
    raise ahaiiException('自定义异常')#主动触发异常
except ahaiiException as e:
    print e

'自定义异常'

另外的格式：

try:
    command
except Exception:
    command
finally:
    command#不管是否异常，finally都会执行。

断言：assert

a = 1
assert a == 1 

判断a == 1是否成立，若不成立，程序停止。