python从网上获取数据失败_Python网络编程中的网络数据和网络错误。

上一个章节我们说的是套接字名和DNS。这篇文章我们主要解决下面问题。

我们在两台主机之间建立与关闭TCP流连接以及UDP数据报连接后。我们应该怎么准备我们需要传输的数据，该怎么对数据进行编码与格式化。

先说字节和字符串。

套接字直接将字节暴露了出来，对程序员还是应用程序来说都是可见的。

字节的特性:位(bit)是信息的最小单元。每位可以是0或者1。当然在我这个EE的人来说，用高低电平来实现就可以了。

8位组成了1字节。

如果把这些数字作为列表传入bytes()，就可以将其转换为字节字符串。通过遍历字节字符串，就可以把其转换为原来的形式。

如果想用套接字传输一个符号串，就需要使用某种编码方法。从而给每个符号分配特定的值。

一般流行的就是ASCII编码方式，现在Python3之后，Python把字符串看作是由Unicode字符组成的序列。就和Python的数据结构一样，我们不需要考虑字符串的内部实现。

编码方式也分为两大类，单字节编码和多字节编码，这里就不再详细说了。

下面说一下二进制数和网络字节顺序。如果只想通过网络发送文本，那么只需要考虑，编码与封帧问题(这个会在后面说)。

如果使用更紧凑的格式来表示数据，我们编写的Python代码就要注意另外一个问题，网络字节顺序。

一般解决方法有两种，大端法和小端法。这里可以用Python的struct模块来具体看一下具体区别，这里不再详细说明了。

一般来说，会有下面的建议：利用struct模块生成用于网络传输的二进制数据时，接收方收到后用struct模块解码。

如果要自己控制网络传输的数据格式的话，在选择网络字节顺序时使用！前缀。

如果其他人设计了协议并使用小端法，那么我们必须使用

使用struct的时候一定要进行测试。

下面说封装与引用，如果使用UDP数据报进行通信，那么协议本身就会使用独立的、可识别的模块进行数据传输。

如果使用TCP进行通信，就要面对封帧问题。即如何分割消息，让接受方可以识别消息的开始与结束。recv()就必须运行多次才能收到完整的数据包。

下面给出一段代码：

import socket

from argparse import ArgumentParser

def server(address):

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

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

sock.bind(address)

sock.listen(1)

print('Run this script in another window with "-c" to connect')

print('Listening at', sock.getsockname())

sc, sockname = sock.accept()

print('Accepted connection from', sockname)

sc.shutdown(socket.SHUT_WR)

message = b''

while True:

more = sc.recv(8192) # arbitrary value of 8k

if not more: # socket has closed when recv() returns ''

print('Received zero bytes - end of file')

break

print('Received {} bytes'.format(len(more)))

message += more

print('Message:\n')

print(message.decode('ascii'))

sc.close()

sock.close()

def client(address):

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

sock.connect(address)

sock.shutdown(socket.SHUT_RD)

sock.sendall(b'Beautiful is better than ugly.\n')

sock.sendall(b'Explicit is better than implicit.\n')

sock.sendall(b'Simple is better than complex.\n')

sock.close()

if __name__ == '__main__':

parser = ArgumentParser(description='Transmit & receive a data stream')

parser.add_argument('hostname', nargs='?', default='127.0.0.1',

help='IP address or hostname (default: %(default)s)')

parser.add_argument('-c', action='store_true', help='run as the client')

parser.add_argument('-p', type=int, metavar='port', default=1060,

help='TCP port number (default: %(default)s)')

args = parser.parse_args()

function = client if args.c else server

function((args.hostname, args.p))

上面这个算是模式一。避免了在另一方向上使用套接字，一旦客户端和服务器不再进行某一方向的通信时就直接关闭。

模式二是模式一的变体，即在两个方向上都通过流发送信息。等待一遍信息发送完，然后另一方发送数据，不能同时发送，否则会发生死锁。

模式三更加好理解，就是用自己设计的recv()来循环接收消息。

模式四是通过某些方法，使用特殊字符来划分消息的边界。

模式五是每个消息前面加上长度作为前缀，这样就无需分析直接就可以发送二进制数据块。

如果我们想利用模式五的简洁高效，又无法事先知道消息的长度，我们可以使用模式六，使用模式六时，我们并非只发送单个消息，而是会多发送多个数据块，并且将每个数据块前面加上数据块长度作为前缀。到达尾部时，发送方可以发送一个与接收方事先约定好的信号，告知接收方，所有数据块已经发送完毕。

下面这段代码就是模式六的例子：

import socket, struct

from argparse import ArgumentParser

header_struct = struct.Struct('!I') # messages up to 2**32 - 1 in length

def recvall(sock, length):

blocks = []

while length:

block = sock.recv(length)

if not block:

raise EOFError('socket closed with {} bytes left'

' in this block'.format(length))

length -= len(block)

blocks.append(block)

return b''.join(blocks)

def get_block(sock):

data = recvall(sock, header_struct.size)

(block_length,) = header_struct.unpack(data)

return recvall(sock, block_length)

def put_block(sock, message):

block_length = len(message)

sock.send(header_struct.pack(block_length))

sock.send(message)

def server(address):

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

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

sock.bind(address)

sock.listen(1)

print('Run this script in another window with "-c" to connect')

print('Listening at', sock.getsockname())

sc, sockname = sock.accept()

print('Accepted connection from', sockname)

sc.shutdown(socket.SHUT_WR)

while True:

block = get_block(sc)

if not block:

break

print('Block says:', repr(block))

sc.close()

sock.close()

def client(address):

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

sock.connect(address)

sock.shutdown(socket.SHUT_RD)

put_block(sock, b'Beautiful is better than ugly.')

put_block(sock, b'Explicit is better than implicit.')

put_block(sock, b'Simple is better than complex.')

put_block(sock, b'')

sock.close()

if __name__ == '__main__':

parser = ArgumentParser(description='Transmit & receive blocks over TCP')

parser.add_argument('hostname', nargs='?', default='127.0.0.1',

help='IP address or hostname (default: %(default)s)')

parser.add_argument('-c', action='store_true', help='run as the client')

parser.add_argument('-p', type=int, metavar='port', default=1060,

help='TCP port number (default: %(default)s)')

args = parser.parse_args()

function = client if args.c else server

function((args.hostname, args.p))

编写代码时需要注意的就是，尽管4B的数据量很小，很难想像recv()不会一次性返回所有4字节数据，但是，只有仔细的在一个循环中调用recv()，这个代码才是正确的。这样才能不断接受数据，直到所有的4B数据全被接受为止。

下面说的是pickle自定义定界符的格式。这个pickle是Python原生的标准库。它是将Python数据结构的内容存储起来，以供在另一台机器上重组该数据结构。

>>> import pickle

>>> pickle.dumps([5, 6, 7])

b'\x80\x03]q\x00(K\x05K\x06K\x07e.'

上面最后是以字符串末尾的.字符结束的，它用于标记一个pickle的结束。遇到.后加载器将停止读取，并立刻返回数据。加上其他数据，也会直接被忽略。

>>> pickle.loads(b'\x80\x03]q\x00(K\x05K\x06K\x07e.blahblahblah')

[5, 6, 7]

实际当中是不能使用load()的。可以使用如下的方式：

>>> from io import BytesIO

>>> f = BytesIO(b'\x80\x03]q\x00(K\x05K\x06K\x07e.blahblahblah')

>>> pickle.load(f)

[5, 6, 7]

>>> f.tell()

14

>>> f.read()

b'blahblahblah'

当然还有另外一种方案，就是可以创建一个协议，协议唯一的内容就是在两个Python程序员中发送pickle。

如果要设计支持其他编程语言的协议，或者只是希望使用通用标准，这时候就可以使用JSON和XML数据。这两种数据都不支持封帧。因此，在处理网络数据之前，先要使用某种方法提起出完整的文本字符串。

JSON是在两种不同的编程语言之间发送数据的最佳选择之一。Python2.6标准库就提供了对JSON的支持，封装在json模块中。

JSON是通过一个字符串来表示的。而且JSON不仅仅在字符串中支持Unicode字符，如果告诉Python的json模块不需要将输出字符限制在ASCII字符表的话，那就甚至可以在数据中包含Unicode字符的字面值。

但是，对于文档来说，XML格式更为实用。原因在于它的基本结构就是将字符串封装为包含在尖括号中的元素，并为他们打上标签。而且不要只把XML局限在HTTP协议中。

下面我们说一下压缩。数据在网络传输中需要的时间常常多余CPU准备的时间。因此，在发送之前进行压缩是非常值得的。

GUN的zlib是当今互联网最普遍的压缩形式之一。Python标准库提供了对于zlib的支持，能够进行封帧是zlib的一个特点。

一般来说，大多数协议设计者会把压缩数据设置为可选项。并且自行为其设置封帧策略。如果会使用zlib的话，那么各种惯例用法会能够让我们充分利用zlib提供的流终止信息，自动探测每个压缩流的结尾。

下面说一下网络错误和异常以及处理方法。套接字发生的几种常见的异常如下。OSError：这是socket模块的可能抛出的主要错误。网络传输的所有阶段可能发生的任何问题几乎都会抛出该异常。

socket.gaierror：该异常在getaddrinfo()无法找到提供的名称或服务时被抛出。

socket.timeout：有时我们会决定为套接字设定超时参数，而不希望永远等待send()或者recv()的操作的完成。只有使用的库设置了套接字超时参数时，才会抛出这个异常。证明等待操作正常完成的时间已经超过了超时参数的值。

当然，使用Python提供的基于套接字的高层协议时，我们可以在代码中直接处理原始套接字错误，然后将他们转换为协议特定的错误类型。

举个例子，httplib认为自己相对底层，因此在连接到未知主机名时，能看到底层套接字错误。

但是urllib2就把相同的错误隐藏起来，并抛出一个URLError。这可能是urllib2认为自己是一个用于将URL解析为文档的干净且中性的系统，所以希望保持相应的语义。

我们在网络错误处理的时候，我们会将异常封装，提供给其他调用API的程序员使用，有时会中途拦截某些异常，把合适的信息提供给终端用户。这两种情况下使用的方法是不同的。

给传递使用我们API的用户时，有两种方法。

第一种就是不作处理，调用者负责处理异常，他们捕捉异常，直接把异常输出至报告。

另一种方法就是把网络错误封装为我们自己的异常。这样会对开发者更加友好。

然后我们说捕捉和报告网络异常。

捕捉异常有两种方法，granular异常处理程序与blanket异常处理程序。

granular方法就是针对每个网络调用，都使用try...except语句，然后在except从句中打印出简洁的错误信息。

另一种方法是blanket异常处理程序。要使用这个方法，需要重新审视我们的代码，识别出进行特定操作的代码段。整个程序都用于连接许可证服务器

这个函数中的所有套接字操作都用于从数据库获取响应

最后一部分代码都用来进行清理与关闭操作

然后外部程序使用try...except语句调用这些代码段。然后在程序的顶层捕捉抛出的所有FatalError异常，并打印出错误信息。而且可以增加一个命令行选项，可以把严重错误发送到系统的错误日志里面去。

到这里，关于Python网络编程中的网络数据和网络错误的文章就结束了。

谢谢大家关注。如果觉得有用就收藏或者点赞吧，每次总是收藏总是比赞多，哈哈，不过大家随心就好。

再次谢谢大家，希望大家在新的一年里万事胜意。