python之socket

一、初识socket
　　      socket 是网络连接端点，每个socket都被绑定到一个特定的IP地址和端口。IP地址是一个由4个数组成的序列，这4个数均是范围 0~255中的值（例如，　　　　        220,176,36,76)；端口数值的取值范围是0~65535。端口数小于1024的都是为众所周知的网络服务所保留的 （例如Web服务使用的80端口）；最大的保留数被存            储在socket模块的IPPORT_RESERVED变量中。你也可以为你的程序使用另外的端口数 值。
    不是所有的IP地址都对世界的其它地方可见。实际上，一些是专门为那些非公共的地址所保留的（比如形如192.168.y.z或10.x.y.z）。地址127.0.0.1是本机地址；它始       终指向当前的计算机。程序可以使用这个地址来连接运行在同一计算机上的其它程序。
     IP地址不好记，你可以花点钱为特定的IP地址注册一个主机名或域名（比如使用www.jb51.net代替222.76.216.16）。域名服务器（DNS）处理名字到IP地址的映射。
　　多少信息通过一个网络被传送基于许多因素，其中之一就是使用的协议。许多的协议是基于简单的、低级协议以形成一个协议栈。例如HTTP协议，它是用在Web浏览器　      与　Web服务器之间通信的协议，它是基于TCP协议，而TCP协议又基于IP协议。
　　当 在你自己的两个程序间传送信息的时候，你通常选择TCP或UDP协议。TCP协议在两端间建立一个持续的连接，并且你所发送的信息有保证的按顺序到达它们 的目的　     地。UDP不建立连接，它的速度快但不可靠。你发送的信息也可能到不了另一端；或它们没有按顺序到达。有时候一个信息的多个复制到达接收端，即使你 只发送了一次。
二、使用地址和主机名
　　socket模块提供了几个函数用于使用主机名和地址来工作。

　　socket 也定义了一些变量来代表保留的IP地址。INADDR_ANY和INADDR_BROADCAST是被保留的IP地址分别代表任意IP地址和广播地 址；　　　　                 INADDR_LOOPBACK　　代表loopback设备，总是地址127.0.0.1。这些变量是32位字节数字形式的。
　　getfqdn([name])函数返回关于给定主机名的全域名（如果省略，则返回本机的全域名）。
三、使用低级的socket通信
尽管Python提供了一些封装，使得使用socket更容易，但是你也可以直接使用socket来工作。
1、创建和销毁socket
socket 模块中的socket(family,type[,proto])函数创建一个新的socket对象。family的取值通常是AF_INET。type 的取值通常是SOCK_STREAM(用于定向的连接，可靠的TCP连接)或SOCK_DGRAM(用于UDP)：
>>> from socket import *
>>> s=socket(AF_INET,SOCK_STREAM)
family和type参数暗指了一个协议，但是你可以使用socket的第三个可选的参数（proto的取值如IPPROTO_TCP或IPPROTO_RAW）来指定所使用的协议。代替使用IPPROTO_XX变量，你可以使用函数getprotobyname：
>>> getprotobyname('tcp')
6
>>> IPPROTO_TCP
6
fromfd(fd,type[,proto]) 是一个很少被使用的函数，它用来从打开的一个文件描述符创建一个socket对象（文件描述符由文件的fileno()方法返回）。文件描述符与一个真实 的socket连接，而非一个文件。socket对象的fileno()方法返回关于这个socket的文件描述符。
当你使用完工 socket对象时，你应调用close()方法显式的关闭socket以尽快释放资源（尽管socket被垃圾回收器回收时将自动被关闭）。另外，你也 可以使用shutdown(how)方法来关闭连接一边或两边。参数0阻止socket接收数据，1阻止发送，2阻止接收和发送。
2、连接socket
当 两个socket连接时(例如使用TCP)，一端监听和接收进来的连接，而另一端发起连接。临听端创建一个socket，调用bind(address) 函数去绑定一个特定的地址和端口，调用listen(backlog)来临听进来的连接，最后调用accept()来接收这个新的，进来的连接,下面是在 服务器端的代码：
>>> s=socket(AF_INET,SOCK_STREAM)
>>> s.bind(('127.0.0.1',44444))
>>> s.listen(1)
>>> q,v=s.accept() #返回socket q和地址v
注意：上面的代码将一直处于等待直到连接被建立。下面我们再打开另一个Python解释器，用作客户端；然后键入如下代码：
>>> from socket import *
>>> s=socket(AF_INET,SOCK_STREAM)
>>> s.connect(('127.0.0.1',44444) #发起连接
好了，我们验证一下连接是否建立了。我们在服务器端键入以下代码来发送一条信息：
>>> q.send('hello,i come from pythontik.com') 注：有时可能出现send() argument 1 must be string or buffer,not str 错误，原因可能是您的机器不支持UTF-8字符集，临时解决方案是q.send(b' hello...')
31 #发送的字节数
在客户端键入以下代码来接收信息：
>>> s.recv(1024)
'hello,i come from pythontik.com'
你 传递给bind和connect的地址是一个关于AF_INET的socket的元组(ipAddress,port)。代替connect，你也可以调 用connect_ex(address)方法。如果背后对C的connect的调用返回一个错误，那么connect_ex也将返回一个错误（否则返回 0代表成功），代替引发一个异常。
当你调用listen时，你给了它一个参数，这个数值表示在等待队列中允许放置的进来的连接总数。当等待队列已满时，如果有更多的连接到达，那么远程端将被告知连接被拒绝。在socket模块中的SOMAXCONN变量表明了等待队列所能容纳的最大量。
accept()方法返回形如bind和connect的一个地址，代表远程socket的地址。下面显示变量v的值：
>>> v
('127.0.0.1', 1334)
UDP是不定向的连接，但是你仍然可以使用给定的目的地址和端口来调用connect去关联一个socket。
3、发送和接收数据
函 数send(string[,flags])发送给定的字符串到远程socket。sendto(string[,flags],address)发送给 定的字符串到一个特定的地址。通常，send方法用于可靠连接的socket，sendto方法用于不可靠连接的socket，但是如果你在一个 UDP socket上调用connect来使它与一个特定的目标建立联系，那么这时你也可以使用send方法来代替sendto。
send和sendto都返回实际发送的字节数。当你快速发送大量的数据的时候，你可能想去确保全部信息已被发送，那么你可以使用如下的一个函数：
def safeSend(sock,msg):
sent=0
while msg:
i=sock.send(msg)
if i==-1: #发生了错误
return -1
sent+=i
msg=msg[i:]
time.sleep(25)
return sent
recv(bufsize[,flags]) 方法接收一个进来的消息。如果有大量的数据在等待，它只返回前面的bufsize字节数的数据。recvfrom(bufsize[,flags])做同 样的事，除了它使用AF_INET socket的返回值是(data,(ipAddress,port)),这便于你知道消息来自哪儿（这对于非连接的 socket是有用的）。
send,sendto,recv和recvfrom方法都有一个可选的参数flags，默认值为0。你可以通过对socket.MSG_*变量进行组合（按位或）来建立flags的值。这些值因平台而有所不同，但是最通用的值如下所示：
MSG_OOB:处理带外数据（既TCP紧急数据）。
MSG_DONTROUTE:不使用路由表；直接发送到接口。
MSG_PEEK:返回等待的数据且不把它们从队列中删除。
例如，如果你有一个打开的socket，它有一个消息等待被接收，你可以接收这个消息后并不把它从进来的数据的队列中删除：
>>> q.recv(1024,MSG_PEEK)
'hello'
>>> q.recv(1024,MSG_PEEK) #因为没有删除，所以你可以再得到它。
'hello'
makefile([mode[,bufsize]]) 方法返回一个文件类对象，其中封装了socket，以便于你以后将它传递给要求参数为一个文件的代码（或许你喜欢使用文件的方法来代替send和 recv）。这个可选的mode和bufsize参数的取值和内建的open函数一样。
4、使用socket选项
socket对象的getpeername()和 getsockname()方法都返回包含一个IP地址和端口的二元组（这个二元组的形式就像你传递给connect和bind的）。 getpeername返回所连接的远程socket的地址和端口，getsockname返回关于本地socket的相同信息。
在默认 情况下，socket是阻塞式的，意思就是socket的方法的调用在任务完成之前是不会返回的。例如，如果存储向外发送的数据的缓存已满，你又企图发送 更多的数据，那么你对send的调用将被阻塞直到它能够将更多的数据放入缓存。你可以通过调用setblocking(flag)方法（其中flag取值 是0，setblocking(0)）来改变这个默认行为，以使socket为非阻塞式。当socket为非阻塞式的时候，如果所做的动作将导致阻塞，将 会引起error异常。下面一段代码将试图不断地接受新的连接并使用函数processRequest来处理。如果一个新连接无效，它将间隔半秒再试。另 一方法是在你的监听socket上调用select或poll来检测一个新的连接的到达。
别的socket的选项可以使用 setsockopt(level,name,value)和getsockopt(level,name[,buflen])方法来设置和获取。 socket代表了一个协议栈的不同层，level参数指定了选项应用于哪一层。level的取值以SOL_开头（SOL_SOCKET,SOL_TCP 等等）。name表明你涉及的是哪个选项。对于value，如果该选项要求数值的值，value只能传入数字值。你也可以传递入一个缓存（一个字符串）， 但你必须使用正确的格式。对getsockopt，不指定buflen参数意味你要求一个数字值，并返回这个值。如果你提供了 buflen，getsockopt返回代表一个缓存的字符串，它的最大长度是buflen的字节数。下面的例子设置了一个socket的用于发送的缓存 尺寸为64KB：
>>> s=socket(AF_INET,SOCK_STREAM)
>>> s.setsockopt(SOL_SOCKET,SO_SNDBUF,65535)
要得到一个包在被路由丢弃前所能有的生命周期（TTL）和跳数，你可以使用如下代码：
>>> s.getsockopt(SOL_IP,IP_TTL)
32
5、数值转换
由于不同平台的字节顺序不一样，所以当在网络中传输数据时我们使用标准的网络字节顺序。nthol(x)和ntohs(x)函数要求一个网络字节顺序的数值并把它转换为当前主机字节顺序的相同数值，而htonl(x)和htons(x)则相反：
>>> import.socket
>>> socket.htons(20000) #转换为一个16位的值
8270
>>> socket.htonl(20000) #转换为一个32位的值
541982720
>>> socket.ntohl(541982720)
20000
使用SocketServers
SocketServers模块为一组socket服务类定义了一个基类，这组类压缩和隐藏了监听、接受和处理进入的socket连接的细节。
1、SocketServers家族
TCPServer和UDPServer都是SocketServer的子类，它们分别处理TCP和UDP信息。
注意：SocketServer也提供UnixStreamServer(TCPServer的子类)和UNIXdatagramServer(UDPServer的子类)，它们都如同其父类一样除了在创建监听socket时使用AF_UNIX代替了AF_INET。
默 认情况下，socket服务一次处理一个连接，但是你可以使用ThreadingMixIN和ForkingMixIn类来创建任一 SocketServer的线程和子进程。实际上，SocketServer模块提供了一些对些有用的类来解决你的麻烦，它们 是：ForkingUDPServer、ForkingTCPServer、ThreadingUDPServer、 ThreadingTCPServer、ThreadingUnixStreamServer和 ThreadingUnixDatagramServer。
SocketServer以通常的方法处理进入的连接；要使它更有用，你应该 提供你自己的请求处理器类给它以便它传递一个socket去处理。SocketServer模块中的BaseRequestHandler类是所有请求处 理器的父类。假设，例如你需要写一个多线程的电子邮件服务器，首先你要创建一个MailRequestHandler，它是 BaseRequestHandler的子类，然后把它传递给一个新创建的SocketServer:
import SocketServer
...#创建你的MailRequestHandler
addr=('220.172.20.6',25) #监听的地址和端口
server=SocketServer.ThreadingTCPServer(addr,MailRequestHandler)
server.serve_forever()
每 次一个新的连接到来时，这个server创建一个新的MailRequestHandler实例并调用它的handle()方法来处理这个新的请求。因为 server继承自ThreadingTCPServer，对于每个新的请求它都启动一个单独的线程来处理这个请求，以便于多个请求能够被同时处理。如果 用handle_request()代替server_forever，它将一个一个的处理连接请求。server_forever 只是反复调用 handle_request而已。
一般来说，你只需使用socket服务之一，但是如果你需要创建你自己的子类的话，你可以覆盖我们下面提到的方法来定制它。
当 服务被第一次创建的时候，__init__函数调用server_bind()方法来绑定监听socket(self.socket)到正确的地址 (self.server_address)。然后调用server_activate()来激活这个服务(默认情况下，调用socket的listen 方法)。
这个socket服务不做任何事情直到调用了handle_request或serve_forever方法。 handle_request调用get_request()去等待和接收一个新的socket连接，然后调用 verify_request(request,client_address)去看服务是否会处理这个连接(你可以在访问控制中使用这个，默认情况下 verify_request总是返回true)。如果会处理这个请求，handle_request然后调用 process_request(request,client_address)，如果 process_request(request,client_address)导致一个异常的话，将调用 handle_error(request,client_address)。默认情况下，process_request简单地调用 finish_request(request,client_address)；子进程和线程类覆盖了这个行为去开始一新的进程或线程，然后调用 finish_request。finish_request实例化一个新的请求处理器，请求处理器轮流调用它们的handle()方法。
当SocketServer创建一个新的请求处理器时，它传递给这个处理器的__init__函数的self变量，以便于这个处理器能够访问关于这个服务的信息。
SocketServer 的fileno()方法返回监听socket的文件描述符。address_family成员变量指定了监听socket的socket族(如 AF_INET)，server_address包含了监听socket被绑定到的地址。socket变量包含监听socket自身。
2、请求处理器
请 求处理器有setup()、handle()和finish()方法，你可以覆盖它们来定制你自己的行为。一般情况下，你只需要覆盖handle方法。 BaseRequestHandler的__init__函数调用setup()方法来做初始化的工作，handle()服务于请求，finish()用 于执行清理工作，如果handle或setup导致一个异常，finish不会被调用。记住，你的请求处理器会为每个请求创建一个新的实例。
request 成员变量有关于流(TCP)服务的最近接受的socket；对于数据报服务，它是一个包含进入消息和监听socket的元组。 client_address包含发送者的地址，server有对SocketServer的一个引用(通过这你可以访问它的成员，如 server_address)。
下面的例子实现了一个EchoRequestHandler，这作为一个服务端它将客户端所发送的数据再发送回客户端：
>>> import SocketServer
>>> class EchoRequestHandler(SocketServer.BaseRequestHandler):
... def handle(self):
... print 'Got new connection!'
... while 1:
... mesg=self.request.recv(1024)
... if not msg:
... break
... print 'Received:',msg
... self.request.send(msg)
... print 'Done with connection'
>>> server=SocketServer.ThreadingTCPServer(('127.0.0.1',12321),EchoReuestHandler)
>>> server.handle_request() #执行后将等待连接
Got new connection!
Received: Hello!
Received: I like Tuesdays!
Done with connection
打开另一个Python解释器作为客户端，然后执行如下代码：
>>> from socket import *
>>> s=socket(AF_INET,SOCK_STREAM)
>>> s.connect(('120.0.0.1',12321))
>>> s.send('Hello!')
6
>>> print s.recv(1024)
Hello!
>>> s.send('I like Tuesdays!')
16
>>> print s.recv(1024)
I like Tuesdays!
>>> s.close()
SocketServer 模块也定义了BaseRequestHandler的两个子类：StreamRequestHandler和 DatagramRequestHandler。它们覆盖了setup和finish方法并创建了两个文件对象rfile和wfile，你可以用这两个文 件对象来向客户端读写数据，从而代替使用socket方法。
socket的阻塞或同步编程

三、使用socket
网 络编程中最基本的部分就是socket(套接字）。socket有两种：服务端socket和客户端 socket。在你创建了一个服务端socket之 后，你告诉它去等待连接。然后它将监听某个网络地址（形如：xxx.xxx.xxx.xxx:xxx) 直到客户端连接。然后这两端就可以通信了。
处理客户端socket通常比处理服务端socket要容易一点，因为服务端必须时刻准备处理来自客户端的连接，并且它必须处理多个连接，而客户端只需要简单的连接，然后做点什么，然后断开连接。
实 例化一个socket时，可以指定三个参数：地址系列（默认为socket.AF_INET）、流socket（这是个默认 值： socket.SOCK_STREAM）或数据报socket（socket.SOCK_DGRAM）、协议（默认值是0）。对于简单的 socket，你可以不指定任何参数而全部使用默认值。
服务端socket在使用bind方法之后调用listen方法去监听一个给定的 地址。然后，客户端socket就可以通过使用connect方法（connect方法所使用的地址参数与bind相同）去连接服务端。listen方法 要求一个参数，这个参数就是等待连接队列中所能包含的连接数。
一旦服务端socket调用了listen方法，就进入了临听状态，然后通 常使用一个无限的循环：1、开始接受客房端的连接，这通过调用accept方法来实现。调用了这个方法后将处于阻塞状态（等待客户端发起连接）直到一个客 户端连接，连接后，accept返回形如(client,address)的一个元组，其中client是一个用于与客户端通信的 socket，address是客户端的形如xxx.xxx.xxx.xxx:xxx的地址；2、然后服务端处理客户端的请求；3、处理完成之后又调用 1。
关于传输数据，socket有两个方法：send和recv。send使用字符串参数发送数据；recv参数是字节数，表示一次接受的数据量，如果你不确定一次该接受的数据量的话，最好使用1024。
下面给出一个最小的服务器/客户机的例子：
服务端：
import socket
s = socket.socket()
host = socket.gethostname()
port = 1234
s.bind((host, port))
s.listen(5)
while True:
c, addr = s.accept()
print 'Got connection from', addr
c.send('Thank you for connecting')
c.close()
客户端：
import socket
s = socket.socket()
host = socket.gethostname()
port = 1234
s.connect((host, port))
print s.recv(1024)
注意：如果你使用Ctrl-C来停止服务端的话，如果再次使用相同的端口可能需要等待一会儿。
四、使用SocketServer
SocketServer模块简单化了编写网络服务器的工作。
它提供了四个基本的服务类：TCPServer(使用TCP协议)、UDPServer(使用数据报)、UnixStreamServer、
UnixDatagramServer。UnixStreamServer和UnixDatagramServer用于类Unix平台。
这四个类处理请求都使用同步的方法，也就是说，在下一个请求处理开始之前当前的请求处理必须已完成
。
用SocketServer创建一个服务器需要四步：
1、通过子类化BaseRequestHandler类和覆盖它的handle()方法来创建一个请求处理器类，用于处理进来
的请求；
2、实例化服务类如TCPServer，并传递给它参数：服务器地址和请求处理器类；
3、调用服务实例对象的handle_request()或serve_forever()方法去处理请求。
下面使用SocketServer用同步的方法写一个最简单的服务器：
from SocketServer import TCPServer, StreamRequestHandler
#第一步。其中StreamRequestHandler类是BaseRequestHandler类的子类，它为流socket定义了
#rfile和wfile方法
class Handler(StreamRequestHandler):
def handle(self):
addr = self.request.getpeername()
print 'Got connection from', addr
self.wfile.write('Thank you for connecting')
#第二步。其中''代表运行服务器的主机
server = TCPServer(('', 1234), Handler)
#第三步。serve_forever()导致进入循环状态
server.serve_forever()
注意：使用阻塞或同步的方法一次只能连接一个客户端，处理完成后才能连接下一个客户端。
非阻塞或异步编程

五、简单的例子

　　1.socket server

　　

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

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#import SocketServer
import socketserver,json,sys,subprocess
class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        # print self.request,self.client_address,self.server
        self.request.sendall(bytes('欢迎进入管理界面.',encoding="utf-8"))
        while True:
            #第一次获取客服端发送内容
            data = self.request.recv(1024)
            #如果输入为空，继续下一次输入
            if len(data) == 0:break
            #如果输入为查看目录内容
            if str(data,encoding='utf-8')=='dir':
                cmd=subprocess.Popen(data.decode(),shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
                cmd_res=cmd.stdout.read()
                if not cmd_res:
                    cmd_res=cmd.stderr.read()
                if len(cmd_res)==0:
                    cmd_res=bytes("result",encoding='gbk')
                self.request.send(cmd_res)
                #接受下一次任务
                continue
            #目录切换，如果接收内容包含cd
            if 'cd' in str(data,encoding='utf-8'):
                cmd=subprocess.Popen(data.decode(),shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
                cmd_res=cmd.stdout.read()
                if not cmd_res:
                    cmd_res=cmd.stderr.read()
                if len(cmd_res)==0:
                    cmd_res=bytes("result",encoding='gbk')
                self.request.send(bytes("%s成功"%data,encoding='gbk'))
                continue
            print("data", data)
            print("[%s] says:%s" % (self.client_address,data.decode() ))

            #执行传输任务
            task_data = json.loads( data.decode()  )
            task_action = task_data.get("action")

            if hasattr(self, "task_%s"%task_action):
               func = getattr(self,"task_%s" %task_action)
               func(task_data)        
            else:
               print("task action is not supported",task_action)

    def task_put(self,*args,**kwargs):
        print("---put",args,kwargs)         
        filename = args[0].get('filename')
        filesize = args[0].get('file_size')
        server_response = {"status":200}
        self.request.send(bytes( json.dumps(server_response), encoding='utf-8'  ))
        f = open(filename,'wb')
        recv_size = 0
        while recv_size < filesize:
            data = self.request.recv(4096)
            f.write(data)
            recv_size += len(data)

            #进度条
            rate = recv_size / filesize
            rate_num= int(rate * 100)
            r = '\r[%-100s]%d%%' % ('=' * rate_num,rate_num, )
            sys.stdout.write(r)
            print("connect success")
            sys.stdout.flush()

        f.close()

if __name__ == '__main__':
    server = socketserver.ThreadingTCPServer(('127.0.0.1',8009),MyServer)
    server.serve_forever()

　　2.socket client

　　

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

import socket
import os ,json
ip_port=('127.0.0.1',8009)
#买手机
s=socket.socket()
#拨号
s.connect(ip_port)
#发送消息
welcome_msg = s.recv(1024)
print("from server:",welcome_msg.decode())
while True:
    send_data=input(">>: ").strip()
    if len(send_data) == 0:continue
    #查看目录下的文件
    if send_data=='dir':
         s.send(bytes(send_data,encoding='utf-8'))
         recv_data=s.recv(1024)
         print(str(recv_data,encoding='gbk'))
         continue

    cmd_list = send_data.split( ' ')
    if len(cmd_list) <2:continue
    task_type = cmd_list[0]
    #目录切换方法
    if task_type=='cd':
         s.send(bytes(send_data,encoding='utf-8'))
         recv_data=s.recv(1024)
         print(str(recv_data,encoding='gbk'))
         continue

    #文件传输
    if task_type == 'put':
        abs_filepath = cmd_list[1]
        if os.path.isfile(abs_filepath):
            file_size = os.stat(abs_filepath).st_size
            filename = abs_filepath.split("\\")[-1]
            print('file:%s size:%s' %(abs_filepath,file_size))
            msg_data = {"action":"put",
                        "filename":filename,
                        "file_size":file_size}

            s.send(  bytes(json.dumps(msg_data),encoding="utf-8")  )
            server_confirmation_msg = s.recv(1024)
            confirm_data = json.loads(server_confirmation_msg.decode())
            if confirm_data['status'] ==200:

                print("start sending file ",filename)
                f = open(abs_filepath,'rb')
                for line in f:
                    s.send(line)

                print("send file done ")
                #跳出本次任务，开始下个任务
                continue

        else:
            print("\033[31;1mfile [%s] is not exist\033[0m" % abs_filepath)
            continue
    else:
        print("doesn't support task type",task_type)
        continue
    #s.send(bytes(send_data,encoding='utf8'))
    #收消息
    recv_data=s.recv(1024)
    print(str(recv_data,encoding='utf8'))
    #挂电话
s.close()

六、socket之IO多路复用

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

　　

　　rlist,wlist,elist=select.select(inputs,outputs,[sk,],1)
　　select（）方法提供四个参数 并提取返回值，rlist监听socket对象的连接变化，wlist监听服务端和客户端的收发消息变化，elist监听socket对象的操作正确与否，最后一个参数表明该服务端没个多少秒去监听一次；
　　socket单进程单线程只提供了一个服务端，一个客户端的交互，采用了select的IO多路复用后，避免了客户端连接及收发消息时的阻塞，从而达到了伪多线程的效果，以下是简单代码：
　　服务端：
　　

# -*- coding: utf-8 -*-

__author__ = 'pxb'

import socket,select

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

inputs=[sk,]
outputs=[]
#按用户存放收到的客户端消息
messages={}
while True:
    #IO多路复用，将每个变化的socket对象存到rlist列表中
    rlist,wlist,elist=select.select(inputs,outputs,[sk,],1)
    print(len(inputs),len(rlist),len(wlist),len(outputs))

    for r in rlist:
        if r==sk:
            conn,address=r.accept()
            inputs.append(conn)
            messages[conn]=[]
            conn.sendall(bytes('hello',encoding='utf-8'))
            print('hello')
        else:
            print("=====================")
            try:
                ret=r.recv(1024)
                if not ret:
                    raise Exception('断开连接')
                else:
                    outputs.append(r)
                    messages(r).append(ret)

            except Exception as e:
                inputs.remove(r)
                del messages[r]

    for w in wlist:
        #w.sendall(bytes('response',encoding='utf-8'))
        msg=messages[w].pop()
        resp=msg+bytes('response',encoding='utf-8')
        w.sendall(resp)
        outputs.remove(w)

客户端：

# -*- coding: utf-8 -*-

__author__ = 'pxb'

import socket

sk=socket.socket()
sk.connect(('127.0.0.1',9999),)
data=sk.recv(1024)
print(data)
while True:
    inp=input('>>>>')
    sk.sendall(bytes(inp,encoding='utf-8'))
    print(sk.recv(1024))
sk.close()

七、作用域
1、python中无块级作用域

if 1==1:
    name='alex'
print('无块级作用域测试',name)

for i in range(10):
    name1=i
print('无块级作用域测试',name1)

2、python以函数为作用域（函数以外调用局部变量会报错）

def fun():
    name2='alex'
fun()
print('函数作用域测试',name2)

3、python的作用域在执行之前已经确定（作用域不关乎程序的执行顺序，基于以上两条进行）

name='mqq'
def f1():
    print(name)

def f2():
    name='pxb'
    return  f1
ret=f2()
ret()

八、多线程
多线程是为了更好地利用资源及节省时间而形成的一套独有的编码方式，结合alex甄嬛西游传，python的多线程有一定的局限性，即每个进程同时只能派出一个线程去执行，io操作不占用cpu资源，计算代码会消耗cpu
多线程演示小代码：

import time
def f1(arg):
    time.sleep(1)
    print(arg)

#单进程，单线程的应用程序
import  threading

t=threading.Thread(target=f1,args=(123,))
t.setDaemon(True)#true表示主线程不在此等子线程
t.start()#不代表当前线程会被立刻执行，取决于操作系统
t.join(2)#表示主线程在此等待，直到子线程完毕
        #参数，表示主线程在此最多等待n秒
print('end')
print('end')
print('end')

f1(888)

九、socket源码查看
以下面集成关系为例，class A，class B（A）,class C(A),class D(B)，class E（C）
以最底层 方法开始集成，不同版本的python集成顺序是不同的
python2.7:D、B、A、E、C
python3.5:D、B、E、C、A