python学习之【16】网络编程

主题

客户端/服务器架构
套接字:通信终点
套接字地址
面向连接与无连接套接字
Python中的网络编程
SOCKET模块
套接字对象方法
TCP/IP客户端和服务器
UDP/IP客户端和服务器
SocketServer模块
Twisted框架介绍
相关模块

1.客户端服务器架构

客户<---->INTERNET<------->服务器。客户连上一个预先已知的服务器，提出自己的请求，发送必要的数据，然后就等待服务器返回的数据。

2.套接字:通信终点

套接字是一种具有"通信端点"概念的计算机网络数据结构。网络化的应用程序在开始任何通讯之前都需要创建套接字、就像电话插口一样，没有它就会完全没办法通信。Python只支持AF_UNIX,AF_NETLINK,AF_INET家族，由于我们只关心网络编程所以我们都只用AF_INET。

3.套接字地址

如果把套接字比作电话接口----------即通信的最底层结构，那主机与端口就像区号与电话号码的一对组合。有了电话还不够，你还要知道你要打电话给谁，往哪打。一个因特网地址由网络通信所必须的主机和端口组成，而且另一端一定要有人听才可以。

合法的端口号范围为0~65535，其中，小于1024的端口号为系统保留端口。

4.面向连接与无连接套接字

(1)面向连接

无论使用哪个地址家族，套接字的类型只有两种，面向连接和无连接。面向连接即是在通信前必须建立一条连接，就像跟朋友打电话一样。实现这种连接的主要协议就是传输控制协议(TCP)，要创建TCP套接字就得在创建的时候指定套接字类型为SOCK_STREAM。TCP套接字采用SOCK_STREAM这个名字体现了它最为流套接字的特点，由于这些套接字使用网际协议(ip)来查找网络中的主机，所以这样形成的整个系统，一般会有两个协议(TCP和IP)名的组合来描述，即TCP/IP。

(2)无连接

即无需连接就可以进行通信。但这时，数据到达的顺序、可靠性及不重复性就无法保证了。数据是整个发送的，不会像面向连接的协议那样先被拆分成小块。

实现这种连接的主要协议就是用户数据报协议(UDP)。要创建UDP套接字就得在创建的时候指定套接字类型为SOCK_DGRAM。"datagram"是"数据报"。

5.Python中的网络编程

我们将使用Python中的socket模块，模块中的socket()函数用来创建套接字。要使用socket.socket()函数来创建套接字，语法如下:

socket.socket(socket_family,socket_type,protocol=0)

如前所述,Socket_family 不是 AF_VNIX 就是 AF_INET ,socket_type可以是SOCK_STREAM或是SOCK_DGRAM,protocol一般不填，默认为0。

6.SOCKET模块

例如创建一个TCP/IP的套接字，你要这样调用socket.socket()函数:

tcpSock = socket.socket(socket.AF_INET,socket.SOCKET_STREAM)

UDP/IP的套接字

udpSock = socket.socket(socket.AF_INET,socket.SOCKET_DGRAM)

由于socket模块中有太多的属性，我们在这里可以使用 “from module import *”的语句,我们就把socket模块里所有属性都带到我们的命名空间里了。

tcpSock = socket(AF_INET,SOCKET_STREAM)

7.套接字对象(内建)方法

函数描述

服务器端套接字函数

s.bind( ) 绑定地址(主机名，端口号对)到套接字
s.listen( ) 开始TCP监听
s.accept( ) 被动接受TCP客户端连接，（阻塞式）等待连接的到来。

客户端套接字函数

s.connect( ) 主动初始化TCP服务器连接。
s.connect_ex( ) connect( )扩展版本，出错时返回错误码，而不是抛出异常。

公共用途的套接字函数

s,recv( ) 接受TCP数据。
s.send( ) 发送TCP数据。
s.sendall( ) 完整发送TCP数据。
s.recvfrom( ) 接受UDP数据。
s.sendto( ) 发送UDP数据。
s.getpeername( ) 连接到当前套接字的远程的地址(TCP连接)
s.getsockname( ) 当前套接字的地址。
s.getsockopt( ) 返回当前套接字的参数。
s.setsockopt( ) 设置指定套接字的参数。
s.close( ) 关闭套接字。

面向模块的套接字函数

s.setblocking( ) 设置套接字的阻塞与非阻塞模式。
s.settimeout( ) 设置阻塞套接字操作的超时时间。
s.gettimeout( ) 得到阻塞套接字操作的超时时间。

面向文件套接字函数

s.fileno( ) 套接字文件描述符。
s.makefile( ) 创建一个与该套接字关联的文件对象。

8.TCP/IP客户端和服务器

TCP服务器设计伪代码:

ss = socket() #创建服务器套接字

ss.bind() #把地址绑定到套接字上

ss.listen() #监听连接

inf_loop: #服务器无线循环

cs = ss.accept() #接受客户端连接

comm_loop: #通信循环

cs.recv()/cs.send() #对话（接收与发送）

cs.close() #关闭客户端套接字

ss.close() #关闭服务器套接字(可选)

所有套接字都用socket.socket( )函数来创建。服务器需要"坐在某个端口上"等待请求。所以它们必须要"绑定"到一个本地的地址上。一个简单的(单线程)服务器会调用accept( )函数等待连接的到来。默认情况下，accept( )函数是阻塞式的，即程序在连接到来之前会处于挂起状态。套接字也支持非阻塞状态。

TCP时间戳服务器(tsTserv.py)

创建一个能接受客户端的消息，在消息前加一个时间戳后返回TCP服务器

 from socket import *

     from time import ctime

     HOST = ''

     PORT = 21567

     BUFSIZE = 1024

     ADDR = (HOST,PORT)

     tcpSerSock = socket(AF_INET,SOCK_STREAM)

     tcpSerSock.bind( ADDR)

     tcpSerSock.listen(5)

     while True:

          print 'waiting for connection......'

          tcpCliSock,addr = tcpSerSock.accept( )

          print '......connected from:',addr

          while True:

               data = tcpCliSock.recv(BUFSIZ)

               if not data:

                    break

               tcpCliSock.send('[%s]%s' %(ctime(),data))

               tcpCliSock.close( )

    tcpSerSock.close()

创建TCP客户端

伪代码:

cs = socket( ) #创建客户端套接字

cs.connect( ) #尝试连接服务器

comm_loop:

cs.send( )/cs.recv( ) #对话(发送/接收)

cs.close( ) #关闭客户端套接字

TCP时间戳客户端(tsTclnt.py)

  from socket import *

      HOST = 'localhost'

      PORT = 21567

      BUFSIZ = 1024

      ADDR = (HOST,PORT)

      tcpCliSock = socket(AF_INET,SOCK_STREAM)

      tcpCliSock.connect(ADDR)

      while True:

           data = raw_input('>')

           if not data:

                break

           tcpCliSock.send(data)

           data = tcpCliSock.recv(BUFSIZ)

           if not data:

                break

           print data

 tcpCliSock.close()

9.UDP/IP客户端和服务器

UDP时间戳服务器(tsUserv.py)

 from socket import *

      from time import ctime

      HOST = ''

      PORT = 21567

      BUFSIZ = 1024

      ADDR = (HOST,PORT)

      udpSerSock = socket(AF_INET,SOCK_DGRAM)

      udpSerSock.bind(ADDR)

      while True:

           print 'waiting for message......'

           data,addr = udpSerSock.recvfrom(BUFSIZ)

           udpSerSock.sendto('[%s] %s' % (ctime,data) ,addr)

           print '......received from and returned to:',addr

 udpSerSock.close()

创建一个UDP客户端

 from socket import *

      HOST = 'localhost'

      PORT = ""

      BUFSIZ = 1024

      ADDR = (HOST,PORT)

      udpCliSock = socket(AF_INET,SOCK_DGRAM)

      while Trus:

           data = raw_input('>')

           if not data:

                break

           udpCliSock.sendto(data,ADDR)

           data,ADDR = udpCliSock.recvfrom(BUFSIZ)

           if not data:

                break

           print data

 udpCliSock.close()

10.SocketServer模块

SocketServer 是标准库中一个高级别的模块。用于简化实现网络客户端与服务器所需的大量样板代码。该模块中，已经实现了一些可供使用的类。

SocketServer模块的类

类	描述
BaseServer	包含服务器核心功能与混合(mix-in)类挂钩;这个类只用于派生，所以不会生成这个类的实例;可以考虑使用TCPServer和UDPServer
TCPServer/UDPServer	基本的网络同步TCP/UDP服务器
UnixStreamServer/UnixDatagramServer	基本的基于文件同步TCP/UDP服务器
ForkingMixIn/ThreadingMixIn	实现了核心的进程化或线程化的功能;作为混合类，与服务器类一并使用以提供一些异步特性;这个类不会直接实例化。
ThreadingTCPServer/ThreadingUDPServer	ThreadingMixIn和TCPServer/UDPServer的组合
BaseRequestHandler	包含处理服务器请求的核心功能，这个类只用于派生，所以不会生成这个类的实例可以考虑使用StreamRequestHandler 或 DatagramRequestHandler
StreamRequestHandler/DatagramRequestHandler	用于TCP/UDP服务器处理工具

创建一个SocketServerTCP服务器

在代码中，先导入我们的服务器类，然后像之前一样定义主机常量。主机常量后就是我们的请求处理器类，然后是启动代码。

例 SocketServer 时间戳TCP服务器（TsTservss.py）

 from SocketServer import (TCPServer as TCP,StreamRequsetHandler as SRH)

     from time import ctime

     HOST = ''

     PORT = 21567

     ADDR = (HOST,PORT)

     class MyRequestHandler(SRH):

          def handle(self):

               print '......connected from:',self.client_address

               self.wfile.write('[%s]%s' % (ctime(),self.rfile.readline()))

     tcpServ = TCP(ADDR,MyRequestHandler)

     print 'waiting for connection...'

     tcpServ.serve_forever( )

创建SocketServerTCP客户端

 from socket import *

      HOST = 'localhost'

      PORT = 21567

      BUFSIZ = 1024

      ADDR = (HOST,PORT)

      while True:

           tcpCliSock = socket(AF_INET,SOCK_STREAM)

           tcpCliSock.connect(ADDR)

           data = raw_input('>')

           if not data:

                break

           tcpCliSock.send('%s\r\n' %data)

           data = tcpCliSock.recv(BUFSIZ)

           if not data:

                break

           print data.strip()

           tcpCliSock.close()

11.Twisted框架介绍

Twsited是一个完全事件驱动的网络框架。它允许你使用和开发完全异步的网络应用程序和协议。需要安装它，系统中可以有:网络协议、线程、安全和认证、聊天/即时通讯、数据库管理、关系数据库集成、Web/internet、电子邮件、命令行参数、图形界面集成等。

创建一个Twisted Reactor TCP服务器

Twsited Reactor事件戳服务器(tsTservTW.py)

from twisted.internet import protocol,reactor

from time import ctime

PORT = 21567

class TSServProtocol(protocol.Protocol)

-----------------------

课后题

16-1. 套接字,面向连接与无连接有何区别?

答:socket第二个参数不同。面向连接即tcp通信函数为socket.socket(socket.AF_INET,socket.SOCK_STREAM),UDP通信函数第二个参数为SOCK_DGRAM。

16-2. 客户端/服务器架构。用你自己的语言描述这个架构。并给出几个例子?

答:服务器在某端口等待客户端的连接。怎么说呢 client<------------>internet<------------->server

16-3. 套接字。TCP和UDP中，哪一种服务器在接受连接后，把连接交给不同的套接字处理与客户端的通讯。

答:TCP。

16-4. 修改TCP(tsTclnt.py)和UDP（tsUclnt.py）客户端，让服务器的名字不要在代码里写死，要允许用户指定一个主机名和端口，只有在两个值都没有输入的时候才使用默认值。

答:修改后的tsTclnt.py

 from socket import *

 from time import ctime

 HOST = ''

 PORT = 21567

 BUFSIZ = 1024

 ADDR = (HOST,PORT)

 tcpSerSock = socket(AF_INET,SOCK_STREAM)

 tcpSerSock.bind(ADDR)

 tcpSerSock.listen(5)

 while True:

         print 'waitiing for connection...'

         tcpCliSock,addr = tcpSerSock.accept()

         print '...connected from:',addr

         while True:

                 data = tcpCliSock.recv(BUFSIZ)

                 if not data:

                         break

                 tcpCliSock.send('[%s] %s' % (ctime(),data))

 tcpSerSock.close()

16-5. 网络互联和套接字。找到《python library reference》示例tcp客户端/服务器程序，实现它并让它运行起来。先运行服务器，然后是客户端。http://www.python.org/doc/current/lib/Socket_Example.html

你认为这个服务器太无聊，决定要修改服务器，让它能识别以下命令:

data 服务器将返回它的当前时间，即time.ctime(time.time())

os 得到操作系统的信息（os.name）

ls 得到当前目录的文件列表

做这个作业的时候，你不一定要有网络------你的机器可以自己通讯。注：在服务器退出后，要清除绑定后才能再次运行，否则有可能得碰到‘端口已经被使用’的错误信息，操作系统一般会在5分钟内清除绑定。所以请耐心等待。

服务器端

 from socket import *

 import time,os

 HOST = ''

 PORT = 21567

 BUFSIZ = 1024

 ADDR = (HOST,PORT)

 tcpSerSock = socket(AF_INET,SOCK_STREAM)

 tcpSerSock.bind(ADDR)

 tcpSerSock.listen(5)

 while True:

         print 'waitiing for connection...'

         tcpCliSock,addr = tcpSerSock.accept()

         print '...connected from:',addr

         while True:

                 data = tcpCliSock.recv(BUFSIZ)

                 data = data.strip()

                 if not data:

                         break

                 if data == "date":

                         tcpCliSock.send('%s' % (time.ctime(time.time())))

                 elif data == "os":

                         tcpCliSock.send('%s' % (os.name))

                 elif data == "ls":

                         tcpCliSock.send('%s' % (os.listdir(os.curdir)))

                 else:

                         tcpCliSock.send('[%s] %s' % (time.ctime(),data))

 tcpSerSock.close()

16-6日期时间服务。使用socket.getservbyname()函数得到UDP协议中"daytime"服务所对应的端口。请参考getservbyname()函数的文档，查阅如何使用的详细语法。现在，写一个程序发送一个随便什么数据过去，等待回答。一旦你收到了服务器的信息，显示到屏幕上去。

答：服务端

 from socket import *

 from time import ctime

 HOST = "localhost"

 PORT = getservbyname("daytime","udp")

 BUFSIZ = 1024

 ADDR = (HOST,PORT)

 udpSerSock = socket(AF_INET,SOCK_DGRAM)

 udpSerSock.bind(ADDR)

 while True:

     print "waiting for message..."

     data,addr = udpSerSock.recvfrom(BUFSIZ)

     udpSerSock.sendto("[%s]%s" % (ctime(), data),addr)

     print "...received from and returned to:",addr

 udpSerSock.close

客户端

 from socket import *

 from time import ctime

 HOST = "localhost"

 PORT = getservbyname("daytime","udp")

 BUFSIZ = 1024

 ADDR = (HOST,PORT)

 udpCliSock = socket(AF_INET,SOCK_DGRAM)

 while True:

     data = raw_input(">")

     if not data:

         break

     udpCliSock.sendto(data,ADDR)

     data,ADDR = udpCliSock.recvfrom(BUFSIZ)

     if not data:

         break

     print data

 tcpCliSock.close()

16-7.半双工聊天。创建一个简单的半双工聊天程序。“半双工”的意思是当创建一个连接，服务启动的时候，只有一个人可以打字，另一个人只有在等到消息通知他输入消息时才能说话。一旦消息发送出去后，要等到有回复了才能发送下一条消息。一个人是服务端，另一个人是客户端。

客户端

from socket import *

HOST = "localhost"

PORT = 23346

BUFSIZ = 1024

ADDR = (HOST,PORT)

tcpCliSock = socket(AF_INET,SOCK_STREAM)

tcpCliSock.connect(ADDR)

while True:

    data = raw_input("client>")

    if not data:

        continue

    tcpCliSock.send(data)

    while True:

        data = tcpCliSock.recv(BUFSIZ)

        if not data:

            continue

        else:

            print "server>",data

            break

tcpCliSock.close()

服务端

 from socket import *

 HOST = "localhost"

 PORT = 23346

 BUFSIZ = 1024

 ADDR = (HOST,PORT)

 tcpServSock = socket(AF_INET,SOCK_STREAM)

 tcpServSock.bind(ADDR)

 tcpServSock.listen(5)

 while True:

     print "waiting for connection..."

     tcpCliSock,addr = tcpServSock.accept()

     print "connected from:",addr

     while True:

         data = tcpCliSock.recv(BUFSIZ)

         if not data:

             continue

         print "client>",data

         data = raw_input("server>")

         tcpCliSock.send(data)

 tcpServSock.close()

---------------------------------------------------------------------

16-8 全双工聊天。修改你刚才的程序，改成全双工，即两个人可以独立地发送和接收消息。

答：

服务端

 #!/usr/bin/env python

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

 import socket,traceback,os

 from threading import *

 host = 'localhost'

 port = 51423     #监听所有的接口

 #接受消息的线程

 def handlerecv(clientsock):

     print "New child",currentThread().getName()

     print "Got connection from",clientsock.getpeername()

     while True:

         data = clientsock.recv(4096)

         if not len(data):

             break

         print data

     clientsock.close()

 #发送消息的线程

 def handlesend(clientsock):

     while True:

         data = raw_input(">")

         data = data + "\n";   #加上换行，好看一点。

         clientsock.sendall(data)

     #关闭连接

     clientsock.close()

 #建立套接字

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

 s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

 s.bind((host,port))

 s.listen(1)

 while True:

     try:

         clientsock,clientaddr = s.accept()

     except KeyboardInterrupt:

         raise

     except:

         traceback.print_exc()

         continue

     t = Thread(target = handlerecv,args=[clientsock])

     t.setDaemon(1)

     t.start()

     r = Thread(target = handlesend,args=[clientsock])

     r.setDaemon(1)

     r.start()

客户端

 #!/usr/bin/env python

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

 from socket import *

 import sys

 from threading import *

 if(len(sys.argv) < 3):

     HOST = 'localhost'

     PORT = 51423

 else:

     HOST = sys.argv[1]

     PORT = int(sys.argv[2])

 BUFSIZ = 1024

 ADDR = (HOST,PORT)

 def handlesend(tcpCliSock):

     while True:

         sdata = raw_input('> ')

         if not sdata:

             break

         tcpCliSock.send(sdata)

     tcpCliSock.close()

 tcpCliSock = socket(AF_INET,SOCK_STREAM)

 tcpCliSock.connect(ADDR)

 #建立发送消息的线程

 s = Thread(target = handlesend,args=[tcpCliSock])

 s.setDaemon(1)

 s.start()

 while True:

     rdata = tcpCliSock.recv(BUFSIZ)

     if not rdata:

         break

     print rdata

 tcpCliSock.close()

------------------------------------------------------------------

16-9----10 多用户全双工聊天。再次修改你的程序，把聊天服务改成支持多用户版本。(扩展功能多人，多房间，多线程，全双工)

服务端 cs.py

 #!/usr/bin/env python

 # _*_ coding: utf8 _*_

 from socket import *

 from time import ctime

 import threading

 from string import split

 HOST = ''

 PORT = 21567

 BUFSIZE = 1024

 ADDR = (HOST, PORT)

 def Deal(sck, username, room):

     while True:

         data = sck.recv(BUFSIZE)

         for i in  clients[room].iterkeys():

             if i <> username:

                 if data <> "quit":

                     clients[room][i].send("[%s] %s: %s" %(ctime(), username, data))

                 else:

                     clients[room][i].send("用户%s在%s退出房间%s" %(username, ctime(), room ))

         if data == "quit":

             del clients[room][username]

             sck.send(data)

             sck.close()

             break

 chatSerSock = socket(AF_INET, SOCK_STREAM)

 chatSerSock.bind(ADDR)

 chatSerSock.listen(5)

 clients = {"":{},}

 while True:

     print 'waiting for connection...'

     chatCliSock, addr = chatSerSock.accept()

     print "...connected romt: ", addr

     data = chatCliSock.recv(BUFSIZE)

     username, room = split(data)

     print username

     if not clients.has_key(room):

         clients[room] = {}

     if clients[room].has_key(username):

         chatCliSock.send("reuse")

         chatCliSock.close()

     else:

         chatCliSock.send("success")

         clients[room][username] = chatCliSock

         t = threading.Thread(target=Deal, args=(chatCliSock, username, room))

         t.start()

 chatSerSock.close()

客户端 cc.py

 #!/usr/bin/env python

 # _*_ coding: utf8 _*_

 from socket import *

 from time import ctime

 import threading

 import random

 from sys import argv, exit, stdout

 from getopt import gnu_getopt, GetoptError

 help_info = ["cs.py [ -h | --help | -u | --username] username",

     "\t-h or --help\t显示帮助信息",

     "\t-u or --username\指定用户名",

     "\t-r or --room\t指定房间"]

 def help():

     for i in help_info:

         print i

 def Send(sck, test):

     while True:

         data = raw_input('>')

         sck.send(data)

         if  data == "quit":

             break

 def Recieve(sck, test):

     while True:

         data = sck.recv(BUFSIZ)

         if data == "quit":

             sck.close()

             break

         str = "\n" + data + "\n>"

         stdout.write(str)

 HOST = 'localhost'

 PORT= 21567

 BUFSIZ = 1024

 ADDR = (HOST, PORT)

 threads = []

 if __name__ == "__main__":

     # 解析命令行参数

     try:

         opts, args = gnu_getopt(argv[1:], "hu:r:", ["help", "username=", "room="])

     except GetoptError, err:

         print str(err)

         help()

         exit(2)

     username = ""

     room = ""

     for o, a in opts:

         if o in ("-h", "--help"):

             help()

             exit(0)

         elif o in ("-u", "--username"):

             username = a

         elif o in ("-r", "--room"):

             room = a

         else:

             print "未知选项"

             help()

             exit(2)

     if not username or not room:

         help()

         exit(2)

     chatCliSock = socket(AF_INET, SOCK_STREAM)

     chatCliSock.connect(ADDR)

     chatCliSock.send("%s %s" %(username, room))

     data = chatCliSock.recv(BUFSIZ)

     if data == "reuse":

         print "用户%s已登录房间%s" %(username, room)

         raw_input()

         exit(1)

     elif data == "success":

         print "用户%s成功登录房间%s" %(username, room)

         t = threading.Thread(target=Send, args = (chatCliSock, None))

         threads.append(t)

         t = threading.Thread(target=Recieve, args = (chatCliSock, None))

         threads.append(t)

         for i in range(len(threads)):

             threads[i].start()

         threads[0].join()

巴特西

python学习之【16】网络编程

最新文章

热门文章