《Python网络编程》Part1 Socket、IPv4和简单的客户端/服务器编程

《Python网络编程》Part1 Socket、IPv4和简单的客户端/服务器编程

1、获取主机名和IP地址

.py:

import socket

def print_machine_info():
host_name = socket.gethostname()
ip_address= socket.gethostbyname(host_name)
print "Host name: %s" % host_name
print "IP address: %s" % ip_address

if __name__ == '__main__':
print_machine_info()

2、获取远程设备的IP地址
.py：

import socket

def get_remote_machine_info():
remote_host = 'www.python.org'
try:
print "IP address: %s" %socket.gethostbyname(remote_host)
except socket.error, err_msg:
print "%s: %s" %(remote_host,err_msg)

if __name__ == '__main__':
get_remote_machine_info()

3、将IPv4地址转换成不同的格式
定义convert_ip4_address()函数，调用inet_aton()和inet_ntoa()转换IP地址。

import socket
from binascii import hexlify

def convert_ip4_address():
for ip_addr in ['127.0.0.1','192.168.0.1']:
packed_ip_addr = socket.inet_aton(ip_addr)
unpacked_ip_addr = socket.inet_ntoa(packed_ip_addr)
print "IP Adress: %s => Packed: %s, Unpacked: %s"\
%(ip_addr,hexlify(packed_ip_addr),unpacked_ip_addr)

if __name__ == '__main__':
convert_ip4_address()

4、通过制定的端口和协议找到服务名

如果想找到网络服务，最好知道该服务运行在TCP或UDP协议的哪个端口上。

使用for—in语句比那里一组变量。在每次遍历中，获取端口对应的服务名。

.py:

import socket

def find_service_name():
protocolname = 'tcp'
for port in [80,25]:
print "Port: %s => service name: %s" %(port, socket.getservbyport(port,protocolname))
print "Port: %s => service name: %s" %(53,socket.getservbyport(53,'udp'))

if __name__ == '__main__':
find_service_name()

5、主机字节序和网络字节序之间相互转换

编写底层网络应用是，或许需要处理通过电缆在两台设备之间传送的底层数据。在这种操作中，需要把主机操作系统发出的数据转换成网络格式，或者做你想转换，因为这两种数据的表示方式不一样。

Python的socket库提供了将数据在网路字节序和主机字节序之间相互转换的函数，例如ntohl()和htonl()，ntohs()和htons()。

.py:

import socket

def convert_integer():
data = 1234
# 32-bit
print "Original: %s => Long host byte order: %s,Network byte order: %s"\
%(data,socket.ntohl(data),socket.htonl(data))
# 16-bit
print "Original: %s => Short host byte order: %s,Network byte order: %s"\
%(data,socket.ntohs(data),socket.htons(data))

if __name__ == '__main__':
convert_integer()

以整数为例，演示了如何把它转换成网络自己序和主机字节序。socket库中的类函数ntohl()把网络自己序转换成长整形主机字节序。函数名中的n表示网络；h表示主机；l表示长整形；s表示短整形，即16位。



6、设定并获取默认的套接字超时时间
有时需要处理socket库某些属性的默认值，例如套接字超时时间。

.py:

import socket

def test_socket_timeout():
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
print "Default socket timeout: %s" %s.gettimeout()
s.settimeout(100)
print "Current socket timeout: %s" %s.gettimeout()

if __name__ == '__main__':
test_socket_timeout()

首先创建一个套接字对象。套接字构造方法的第一个参数是地址簇，第二个参数是套接字类型。然后，调用gettimeout()方法获取套接字超时时间，再调用settimeout()方法修改超时时间。传给settimeout()方法的参数可以是秒数（非浮点数）也可以是None。这个方法在处理阻塞式套接字操作时使用。如果把超时时间设为None，则禁用了套接字操作的超时检测。



7、优雅地处理套接字错误

在网络中经常会遇到这种情况：一方尝试连接，但另一方由于网络媒介失效或者其他原因无法响应。Python的socket库提供了一个方法，能通过socket.error异常优雅地处理套接字错误。

import socket
import sys
import argparse

def main():
#setup argument parsing
parser = argparse.ArgumentParser(description = 'Socket Error Examples')
parser.add_argument('--host',action="store",dest="host",required=False)
parser.add_argument('--port',action="store",dest="port",type=int,required=False)
parser.add_argument('--file',action="store",dest="file",required=False)
given_args = parser.parse_args()
host = given_args.host
port = given_args.port
filename = given_args.file

#First try-except block -- creat socket
try:
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
except socket.error, e:
print "Error creating socket: %s" %e
sys.exit(1)

#Second try-except block -- connect to given host/port
try:
s.connect((host, port))
except socket.gaierror, e:
print "Address-related error connecting to server: %s" % e
sys.exit(1)
except socket.error, e:
print "Connect error: %s" %e
sys.exit(1)

#Third try-except block -- sending data
try:
s.sendall("GET %s HTTP/1.0\r\n\r\n" %filename)
except socket.error, e:
print "Error sending data: %s" %e
sys.exit(1)

while 1:
#Forth try-except block -- waiting to recieve data from remote host
try:
buf = s.recv(2048)
except socket.error, e:
print "Error receiving data: %s" %e
sys.exit(1)
if not len(buf):
break;
#write the recieved data
sys.stdout.write(buf)

if __name__ == '__main__':
main()

8、修改套接字发送和接收的缓冲区大小

很多时候，默认的套接字缓冲大小可能不够用。此时，可以将默认的套接字缓冲区大小改成一个更合适的值。

在套接字对象上可调用方法getsockopt()he setsockopt()分别获取和修改套接字对象的属性。setsockopt()方法接收三个参数：level、opename和value。其中，optname是选项名，value是该选项的值。第一个参数所用的符号变量是（SO_*等）可在socket模块中查看。

.py:

import socket

SEND_BUF_SIZE = 4096
RECV_BUF_SIZE = 4096

def modify_buf_size():
sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

#Get the size of the socket's send buffer
bufsize = sock.getsockopt(socket.SOL_SOCKET,socket.SO_SNDBUF)
print "Buffer size  [Before]:%d" %bufsize

sock.setsockopt(socket.SOL_TCP,socket.TCP_NODELAY,1)
sock.setsockopt(
socket.SOL_SOCKET,
socket.SO_SNDBUF,
SEND_BUF_SIZE)
sock.setsockopt(
socket.SOL_SOCKET,
socket.SO_RCVBUF,
RECV_BUF_SIZE)
bufsize =sock.getsockopt(socket.SOL_SOCKET,socket.SO_SNDBUF)
print "Buffer size [After]:%d" %bufsize

if __name__ == '__main__':
modify_buf_size()

9、把套接字改成阻塞或费阻塞模式

默认情况下，TCP套接字处于阻塞模式中。也就是说，除非完成了某项操作，否则不会把控制权交还给程序。例如，调用connect（）API后，链接操作会组织程序继续往下执行，直到链接成功为止。很多情况下，你并不想让程序一直等待服务器响应或者有异常终止操作。例如，如果编写了一个网页浏览器客户端链接服务器，你应该考虑提供取消功能，以便在操作过程中取消连接。这是就要把套接字设置成非阻塞模式。

在Python中，套接字可以被设置为阻塞模式或者非阻塞模式。在非阻塞模式中，调用API后，例如send（）或recv（）方法，如果遇到问题就会跑出异常。但在阻塞模式中，遇到错误并不会阻止操作。我们可以创建一个普通的TCP套接字，分别在阻塞模式和非阻塞模式中执行操作实验。

为了能在阻塞模式中处理套截止，首先要创建一个套接字对象。然后调用setblocking（1）把套接字设为阻塞模式，或者调用setblocking（0）把套接字设为非阻塞模式。最后，吧套接字绑定到指定的端口上，监听进入的链接。

.py：

import socket

SEND_BUF_SIZE = 4096
RECV_BUF_SIZE = 4096

def test_socket_modes():
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
#blocking mode
s.setblocking(1)
s.settimeout(0.5)
s.bind(("127.0.0.1",0))

socket_address = s.getsockname()
print "Trivial Server launched on socket: %s" %str(socket_address)
while(1):
s.listen(1)

if __name__ == '__main__':
test_socket_modes()

将s.setblocking(1)改为s.setblocking(0)，即由阻塞模式改为非阻塞模式，运行：



10、重用套接字地址

不管链接是被有意还是无意关闭，有时你想时钟在同一个端口上运行套接字服务器。某些情况下，如果客户端程序需要一直链接指定的服务器端口，这么做就很有用，因为无需改变服务器端口。

创建套接字对象之后，我们可以查询地址重用的状态，比如说旧状态。然后，调用setsocketopt()方法，修改地址重用状态的值。再按照常规的步骤，把套接字绑定到一个地址上，监听进入的客户端链接。在这个例子中，我们要捕获KeyboardInterrupt异常，这样按下Ctrl+C键后，Python脚本会终止运行，但不会显示任何异常消息。

.py：

import socket
import sys

def reuse_socket_addr():
sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

#Get the old state of the SO_REUSEADDR option
old_state = sock.getsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR)
print "Old sock state: %s" %old_state

#Enable the SO_REUSEADDR option
sock.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
new_state  =sock.getsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR)
print "New sock state: %s" %new_state

local_port = 8282

srv = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
srv.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
srv.bind( ('', local_port) )
srv.listen(1)
print "Listen on port: %s" %local_port
while True:
try:
connection, addr =srv.accept()
print 'Connected by %s' %(addr[0], addr[1])
except KeyboardInterrupt:
break
except socket.error, msg:
print '%s' % (msg,)

if __name__ == '__main__':
reuse_socket_addr()

可以在一个终端窗口运行这个脚本，然后在另一个终端窗口中输入telnet localhost 8282，尝试连接这个服务器。关闭服务器后，还可以使用同一个端口再次连接。然而，如果你把设定SO_REUSEADDR的那行代码注释掉，服务器将不会再次运行脚本。

11、从网络时间服务器获取并打印当前时间

很多程序要求设备的时间精准，例如Unix系统中的make命令。设备上的时间可能不都准确，需要和网络中的时间服务器同步。

你可以编写一个python客户端，让设备上的时间和某个网络时间服务器同步。要完成这一操作，需要使用ntplib，通过“网络时间协议”（Network Time Protocol，简称NTP）处理客户端和服务器之间的通信。如果设备中没有安装ntplib，可以使用pip或easy_install从PyPI中安装，命令如下：
$pip install ntplib

如果是Windows系统，到官方网站上，https://pypi.python.org/pypi/ntplib，下载ntplib-0.3.3.tar.gz ，然后解压，将ntplib.py拷贝到D:\Python27\Lib（这是我的路径，自己的安装路径自己注意），这就解决了，为啥Linux的包解压的文件能在Windows里用，这个我就不解释了。

.py：

import ntplib
from time import ctime

def print_time():
ntp_client = ntplib.NTPClient()
response = ntp_client.request('pool.ntp.org')
print ctime(response.tx_time)

if __name__ == '__main__':
print_time()

12、编写一个SNTP客户端

与上一个程序不同，有时并不需要从NTP服务器上获取精确的时间。遇到这种情况，就可以使用NTP的简化版本，叫作“简单网络时间协议（SNTP）”

不使用任何第三方库来编写一个简单的SNTP客户端。

首先定义两个常量：NTP_SERVER和TIME1970。NTP_SERVER是客户端要链接的服务器地址，TIME1970是指1970年1月1日（也叫Epoch）。在http://www.epochconverter.com/上可以查看Epoch时间值，或者把时间转换成Epoch时间值。这个客户端通过UDP协议创建一个UDP套接字（SOCK_DGRAM），用于连接服务器。然后，客户端要在一个数据包中把数据'\x1b'
+ 47 * '\0'发送给SNTP服务器。UDP客户端分别使用sendto（）和recvfrom（）方法发送和接收数据。

服务器返回的时间信息打包在一个数组中，客户端需要使用struct模块取出数据。我们所需的数据是数组中的第11个元素。最后，我们要从取出的数据上减掉TIME1970，得到真正的当前时间。

这个SNTP客户端创建一个套接字连接，然后通过协议发送数据。从NTP服务器（这里使用的是0.uk.pool.ntp.org）收到数据后，使用struct模块取出数据。最后，减去1970年1月1日对应的时间截，再使用Python内置的time模块提供的ctime（）方法打印时间。

.py:

import socket
import struct
import sys
import time

NTP_SERVER = "0.uk.pool.ntp.org"
TIME1970   = 2208988800L

def sntp_client():
client = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
data ='\x1b' + 47 * '\0'
client.sendto(data,(NTP_SERVER,123))
data, address = client.recvfrom(1024)
if data:
print 'Response receiveed from:', address
t=struct.unpack('!12I', data)[10]
t -= TIME1970
print '\tTime = %s' %time.ctime(t)

if __name__ == '__main__':
sntp_client()

13、编写一个简单的回显客户端/服务器应用

尝试过Python中socket模块的基本API后，现在来编写一个套接字服务器和客户端。这里，你将有机会利用在签署攻略中掌握的基本知识。

不管服务器从客户端收到什么输入，都会将其回显来。我们要使用Python中的argparse模块，在命令行中指定TCP端口。服务器脚本和客户端脚本都要用到这个参数。

先写一个服务器。首先创建一个TCP套接字对象。然后设定启用重用地址，这样想运行多少次服务器就能运行多少次。我们把套接字绑定在本地设备的指定端口上。在监听阶段，把backlog参数传入listen（）方法中，让服务器在队列中监听多个客户端。最后，等待客户端连接，向服务器发送一些数据。收到数据后，服务器会把数据回显给客户端。

echo_server.py:

import socket
import sys
import argparse

host = 'localhost'
data_payload = 2048
backlog = 5

def echo_server(port):
"""A simple echo server"""
#create a TCP socket
sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
#Enable reuse address/port
sock.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
#bind the socket to the port
server_address = (host,port)
"""Pay attention to " %s port %s",or it will trow exceptions"""
print "Starting up echo server on %s port %s" %server_address
sock.bind(server_address)
#Listen to clients, backlog argument specifies the max no. of queued connections
sock.listen(backlog)
while True:
print "Waiting to receive message from client "
client,address = sock.accept()
data = client.recv(data_payload)
if data:
print "Data: %s" %data
client.send(data)
print "sent %s bytes back to %s" %(data,address)
#end connection
client.close()

if __name__ == '__main__':
parser = argparse.ArgumentParser(description = 'Socket Server Example')
"""Pay attention to tab position ,or it will throw exceptions!!!"""
parser.add_argument('--port',action="store",dest="port",type=int,
required=True)
given_args = parser.parse_args()
port = given_args.port
echo_server(port)

Python的语法格式一定要多加注意，否则一直编译出错。

客户端中，我们创建一个客户端套接字，然后使用命令行参数中指定的端口链接服务器。客户端把消息Test message. This will be echoed发送给服务器后，立即就会在几个数据片段中收到返回的消息。这里用到了两个try-except块，捕获交互过程中发生的任何异常。

echo_client.py:

import socket
import sys

import argparse

host = 'localhost'

def echo_client(port):
"""A simple echo client"""
#create a TCP/IP socket
sock =socket.socket(socket.AF_INET,socket.SOCK_STREAM)
#connect the socket to the server
server_address = (host,port)
print "connecting to %s port %s" %server_address
sock.connect(server_address)

#send data
try:
#Send data
message = "Test message. This will be echoed"
print "Sending %s " %message
sock.sendall(message)
#Look for the response
amount_received = 0
amount_expected = len(message)
while amount_received < amount_expected:
data = sock.recv(16)
amount_received += len(data)
print "Received: %s" %data
except socket.errno, e:
print "Socket error: %s" %str(e)
except Exception, e:
print "Other exception: %s" %str(e)
finally:
print "Closing connection to the server"
sock.close()

if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Socket Server Example')
parser.add_argument('--port',action="store",dest="port",type=int,
required=True)
given_args = parser.parse_args()
port = given_args.port
echo_client(port)

3、重复步骤1，键入echo_client.py --port=9900



然后服务器端窗口显示如下：


4、修改接收的消息长度，将客户端的data = sock.recv(16）修改为32：

重复上述步骤：