《python网络编程基础》笔记(未完待续)

偏执的太偏执、 2022-07-16 12:27 287阅读 0赞

[**《python网络编程基础》pdf 下载**][python_pdf]

1.客户/服务器网络介绍：

1.1基本客户端：

# -*-coding:utf-8-*-
    import socket, sys
    
    #端口
    port = 70
    #IP或者域名
    host = sys.argv[1]#"127.0.0.1"
    #文件路径
    filename = sys.argv[2]#"txt"
    
    #建立一个socket连接，参数是用internet socket来进行TCP通讯
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    #这个连接连接到对应的IP和端口
    s.connect((host, port))
    
    #这个连接向另一端发送内容
    s.sendall(filename+"\r\n")
    
    #死循环
    while True:
        #接收另一端的数据
        buf = s.recv(2048)
        if not len(buf):
            break
        #内容打印在终端，sys.stdout.write函数是print函数的下层
        sys.stdout.write(buf)

终端输入：python testc.py quux.org /

这个程序的作用是打印出quux.org根目录下的文件名

1.2 错误和异常

如果使用不存在域名或者IP会报一个socket.error: \[Errno 10060\]错误，服务器没有响应

# -*-coding:utf-8-*-
    import socket, sys
    
    #端口
    port = 70
    #IP或者域名
    host = sys.argv[1]#"127.0.0.1"
    #文件路径
    filename = sys.argv[2]#"txt"
    
    #建立一个socket连接，参数是用internet socket来进行TCP通讯
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        #这个连接连接到对应的IP和端口
        s.connect((host, port))
    except socket.error as e:
        print(str(e))
        #主线程退出
        sys.exit(1)
    
    #这个连接向另一端发送内容
    s.sendall(filename+"\r\n")
    
    #死循环
    while True:
        #接收另一端的数据
        buf = s.recv(2048)
        if not len(buf):
            break
        #内容打印在终端，sys.stdout.write函数是print函数的下层
        sys.stdout.write(buf)

终端输入：python testc.py nameyouxxhahahw123.com /

结果：

\[Errno 10060\]

在sendall 和 recv 也就是发送和接收时也容易产生异常，可以捕捉

2.网络客户端

2.1理解socket

可以把socket操作看作是文件操作，文件有open( )，socket有socket( )，文件有read( )，write( )，socket有recv( )，send( )

2.2建立一个socket

创建一个socket就两步，一是创建一个socket对象，二是让它连接到远程服务器

socket对象包括了通信类型 和 协议族

通信类型是指明用什么协议传输数据，一般都是Internet通信，通信类型是AF\_INET(对应了IPv4)

协议族一般表示TCP通信的SOCK\_STREAM，UDP通信的SOCK\_DGRAM

建立一个TCP的sockrt连接：

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

连接socket包含IP或者远程主机名和端口：

s.connect(("www.baidu.com", 80))

python的connect( )函数可以利用DNS把域名自动转换成对应的IP

2.3寻找端口

根据服务名得到对应的端口号

# -*-coding:utf-8-*-
    import socket
    
    #建立一个TCP连接
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    #getservbyname()函数是根据服务名得到对应的端口号
    port = socket.getservbyname("http", "tcp")
    print(port)
    #连接到服务端
    s.connect(("www.baidu.com" ,port))

结果：

2.4从socket获得信息

# -*-coding:utf-8-*-
    import socket
    
    #建立一个TCP连接
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    #getservbyname()函数是根据服务名得到对应的端口号
    port = socket.getservbyname("http", "tcp")
    #连接到服务端
    s.connect(("www.baidu.com", port))
    #getsockname()获得自身IP和端口
    print(s.getsockname())
    #getpeername()获得远程IP和端口
    print(s.getpeername())

结果：

('192.168.16.23', 52172)

('61.135.169.121', 80)

2.5 利用socket通信

socket建立连接以后利用它发送和接收信息，python提供了 socket对象 和 文件类对象。

socket对象提供了操作体统的 send( )，sendto( )，recv( ) 和 recvfrom( )接口。

文件类对象提供了 read( )，write( ) 和 readline( )接口。

2.6 socket异常

# -*-coding:utf-8-*-
    import socket, sys
    
    #远程主机名或者IP
    host = sys.argv[1]
    #远程端口
    textport = sys.argv[2]
    #文件路径
    filename = sys.argv[3]
    
    try:
        #I/O 和 通信异常 socket.error
        #创建socket连接
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    except socket.error as e:
        print(str(e))
        #退出主线程
        sys.exit(1)
    
    try:
        port = int(textport)
    except ValueError as e:
        print(str(e))
        try:
            #这里好像是通过服务反向找端口，但是貌似没啥用(愚见)
            port = socket.getservbyname(textport,"tcp")
        except socket.error as e:
            print(str(e))
            sys.exit(1)
    
    try:
        #查询地址信息的异常 socket.gaierror(主机名不对时才报这个错，连接不上报socket.error错)
        #连接socket
        s.connect((host, port))
    except socket.gaierror as e:
        print(str(e))
        sys.exit(1)
    except socket.error as e:
        print(str(e))
        sys.exit(1)
    
    try:
        #发送信息
        s.sendall("GET %s HTTP/1.1\r\n\r\n" % filename)
    except socket.error as e:
        print(str(e))
        sys.exit(1)
    
    while 1:
        try:
            #接收信息
            buf = s.recv(2048)
        except socket.error as e:
            print(str(e))
            sys.exit(1)
        if not len(buf):
            break
        #打印在控制台
        sys.stdout.write(buf)

终端输入：python testc.py quux.org 70 /

python 的 socket 模块定义了4种异常：

I/O 和 通信问题有关的 socket.error

与查询地址信息有关的 socket.gaierror

与其他地址错误有关的 socket.herror

与在一个socket上调用settimeout( )后处理超时的 socket.timeout

2.7 遗漏的异常

客户端向服务端发送信息，如果服务端断开连接，那客户端recv( )就接收不到数据，程序停止。

为了让客户端在管道中没有数据就不调用recv( )，可以使用shutdown( )，用来强制清除管道内的缓存，管道里空的就不会调用recv( )

这个其实有点不理解，因为书后面写到“数据只有调用shutdown( )后才会被发送”，难道是这个函数是在清空前还又一次发送动作？

# -*-coding:utf-8-*-
    import socket, sys
    
    #远程主机名或者IP
    host = sys.argv[1]
    #远程端口
    textport = sys.argv[2]
    #文件路径
    filename = sys.argv[3]
    
    try:
        #I/O 和 通信异常 socket.error
        #创建socket连接
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    except socket.error as e:
        print(str(e))
        #退出主线程
        sys.exit(1)
    
    try:
        port = int(textport)
    except ValueError as e:
        print(str(e))
        try:
            #这里好像是通过服务反向找端口，但是貌似没啥用(愚见)
            port = socket.getservbyname(textport,"tcp")
        except socket.error as e:
            print(str(e))
            sys.exit(1)
    
    try:
        #查询地址信息的异常 socket.gaierror(貌似没什么用，2.7报socket.error错)
        #连接socket
        s.connect((host, port))
    except socket.gaierror as e:
        print(str(e))
        sys.exit(1)
    except socket.error as e:
        print(str(e))
        sys.exit(1)
    
    try:
        #发送信息
        s.sendall("GET %s HTTP/1.1\r\n\r\n" % filename)
    except socket.error as e:
        print(str(e))
        sys.exit(1)
    
    try:
        #强制清除缓存
        s.shutdown(1)
    except socket.error as e:
        print(str(e))
        sys.exit(1)
    
    while 1:
        try:
            #接收信息
            buf = s.recv(2048)
        except socket.error as e:
            print(str(e))
            sys.exit(1)
        if not len(buf):
            break
        #打印在控制台
        sys.stdout.write(buf)

shutdown( )函数的参数用法：

使用shutdown来关闭socket的功能

SHUT\_RDWR：关闭读写，即不能使用send/write/recv/read等：s.shutdown(socket. SHUT\_RDWR)

SHUT\_RD：关闭读，即不能使用read/recv等：s.shutdown(socket. SHUT\_RD)

SHUT\_WR:关闭写功能，即不能使用send/write等：s.shutdown(socket. SHUT\_WR)

0：表示将缓冲区中的内容清空 禁止将来读取：s.shutdown(0)

1：表示将缓冲区中的内容清空 禁止将来写入：s.shutdown(1)

2：表示将缓冲区中的内容清空 禁止将来读取和写入：s.shutdown(2)

2.8文件类引发的异常

makefile( )函数从socket得到一个文件类对象，这样就可以像操作文件一样操作socket。

文件类对象的readline( )，read( ) 对应 socket对象的recv( )

文件类对象的write( )，writelines( ) 对应 socket对象的send( )，sendall( )

# -*-coding:utf-8-*-
    import socket, sys
    
    #远程主机名或者IP
    host = sys.argv[1]
    #远程端口
    textport = sys.argv[2]
    #文件路径
    filename = sys.argv[3]
    
    try:
        #I/O 和 通信异常 socket.error
        #创建socket连接
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    except socket.error as e:
        print(str(e))
        #退出主线程
        sys.exit(1)
    
    try:
        port = int(textport)
    except ValueError as e:
        print(str(e))
        try:
            #这里好像是通过服务反向找端口，但是貌似没啥用(愚见)
            port = socket.getservbyname(textport,"tcp")
        except socket.error as e:
            print(str(e))
            sys.exit(1)
    
    try:
        #查询地址信息的异常 socket.gaierror(貌似没什么用，2.7报socket.error错)
        #连接socket
        s.connect((host, port))
    except socket.gaierror as e:
        print(str(e))
        sys.exit(1)
    except socket.error as e:
        print(str(e))
        sys.exit(1)
    
    #makefile()得到文件类对象
    fb = s.makefile("rw",0)
    time.sleep(10)
    
    try:
        #write()写入数据
        fb.write("GET %s HTTP/1.1\r\n\r\n" % filename)
    except socket.error as e:
        print(str(e))
        sys.exit(1)
    
    try:
        #flush()会将缓存中内容送到目标中，刷新缓存区
        #书中说makefile()没有指定缓存区，所以flush()不是必须的，只有使用缓存区才调用
        fb.flush()
    except socket.error as e:
        print(str(e))
        sys.exit(1)
    
    try:
        #强制清除缓存
        s.shutdown(1)
    except socket.error as e:
        print(str(e))
        sys.exit(1)
    
    while 1:
        try:
            #读取数据
            buf = fb.read(2048)
        except socket.error as e:
            print(str(e))
            sys.exit(1)
        if not len(buf):
            break
        #打印在控制台
        sys.stdout.write(buf)

文件类对象不提供对shutdown( )的调用，所以要保存socket对象

2.9 使用UDP

UDP不提供文件类对象，因为不能保证数据的发送接收完整性

UDP通信的SOCK\_DGRAM

UDP客户端：

# -*-coding:utf-8-*-
    import socket, sys
    
    #远程主机名或者IP
    host = sys.argv[1]
    #远程端口
    textport = sys.argv[2]
    
    try:
        #创建一个UDP连接
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    except socket.error as e:
        print(str(e))
        sys.exit(1)
    
    try:
        port = int(textport)
    except ValueError as e:
        print(str(e))
        try:
            port = socket.getservbyname(textport,"udp")
        except socket.error as e:
            print(str(e))
            sys.exit(1)
    
    try:
        #连接到远程服务器
        s.connect((host, port))
    except socket.gaierror as e:
        print(str(e))
        sys.exit(1)
    except socket.error as e:
        print(str(e))
        sys.exit(1)
    
    #接收终端输入
    data = sys.stdin.readline().strip()
    #发送信息
    s.sendall(data)
    
    while 1:
        #接收数据
        buf = s.recv(2048)
        if not len(buf):
            break
        #写到控制台
        sys.stdout.writelines(buf)

UDP 和 TCP 的区别：

TCP 是 SOCK\_STREAM

UDP 是 SOCK\_DGRAM

TCP是完整接收和发送数据

UDP不关系是否发送或者接收成功

有时候UDP根本不关心有没有connect( )，不关系有没有连接上对方

# -*-coding:utf-8-*-
    import socket, sys, struct, time
    
    hostname = "time.nist.gov"
    port = 37
    
    #gethostbyname( )主机名 的IPv4 的地址格式
    host = socket.gethostbyname(hostname)
    
    #创建连接
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    #sendto()用于发送UDP数据，第一个参数是发送的数据，第二个是要发送到的地址
    s.sendto("",(host, port))
    
    #recvfrom()返回一个元组，一个是数据，第二个是远程地址
    buf = s.recvfrom(2048)[0]
    if len(buf) !=4:
        print(len(buf), buf)
        sys.exit(1)
    
    #struct是处理二进制的库
    secs = struct.unpack("!I",buf)[0]
    secs -= 2208988800
    print(time.ctime(secs))

结果：

Wed Oct 19 15:22:36 2016

这个程序就没有connect( )，直接向远程地址发送信息，因为UDP不保证发送成功，接不保证接收成功

3.网络服务器

3.1准备连接

客户端建立一个TCP连接只需两步，建立socket对象，调用connect( )与远程连接

服务端需要四步：

建立socket对象

设置socket选项

绑定端口

监听连接

# -*-coding:utf-8-*-
    import socket
    
    #要绑定的地址
    host = ""
    #要绑定的端口
    port = 9999
    
    #创建一个连接
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    #设置选项
    #SOL_SOCKET，意思是正在使用的socket选项
    #SO_REUSEADDR，当socket关闭后，本地端用于该socket的端口号立刻就可以被重用
    #1，表示将SO_REUSEADDR标记为TRUE
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,1)
    #bind( )绑定地址和端口
    s.bind((host, port))
    #listen( )等待队列最大数量
    s.listen(5)

查看系统所支持的socket选项列表

# -*-coding:utf-8-*-
    import socket
    
    #dir( )函数返回对象的变量和方法
    #startswith( )以什么字符开头
    solist = [x for x in dir(socket) if x.startswith("SO_")]
    #sort()列表排序
    solist.sort()
    for x in solist:
        print(x)

绑定socket：

bind( ( host, port ) )

监听连接

listen( 5 )

一直不理解这个，一直以为是允许同时最大连接数，但是想一下单进程单线程时这个有什么用

其实这个是队列里最大等待的连接数，不过对于多线程意义不大，但是必须有

3.2接受连接

服务器需要长时间运行，通常的办法使设计一个死循环

# -*-coding:utf-8-*-
    import socket
    
    #要绑定的地址
    host = ""
    #要绑定的端口
    port = 9999
    
    #建立一个TCP连接
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    #设置socket选项
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    #绑定地址和端口
    s.bind((host, port))
    #最大等待数
    s.listen(1)
    
    #死循环
    while 1:
        #accept()，接受TCP连接并返回（conn,address）
        #conn是新的套接字对象，可以用来接收和发送数据。
        #address是连接客户端的地址
        sock, addr = s.accept()
        #getpeername(),获取客户端地址和端口
        print(sock.getpeername())
        #关闭连接
        sock.close()

这个死循环只有异常报错或者强制退出才会停止

通常死循环会耗尽CPU资源，但是这里的死循环只有客户端连接上才会有返回，否则它一直处于阻塞

上面的服务器可以用一个简单的客户端测试：

# -*-coding:utf-8-*-
    import socket
    
    host = "127.0.0.1"
    port = 9999
    
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((host, port))
    s.sendall("")
    s.close()

3.3 处理错误

客户端的错误导致程序停止还能接受，但是服务端没事儿就报错停止，然后重启就太不友好了，所有服务端的异常捕捉更重要

# -*-coding:utf-8-*-
    import socket, traceback
    
    host = ""
    port = 9999
    
    #创建socket
    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 1:
        try:
            #捕捉一个按键强制停止错误
            #捕捉到任意错误都跳出这个循环(如果客户端连接上出错，直接跳过)
            #traceback库可以定位异常在哪一行发生
            #traceback.print_exc()，将错误信息打印出来
            sock, addr = s.accept()
        except KeyboardInterrupt:
            raise
        except:
            traceback.print_exc()
            continue
        try:
            print(sock.getpeername())
        except (KeyboardInterrupt, SystemExit):
            raise
        except:
            traceback.print_exc()
    
        try:
            sock.close()
        except KeyboardInterrupt:
            raise
        except:
            traceback.print_exc()

服务端遇到错误通常会断开客户端的连接在继续

3.4 使用UDP

UDP的服务端是比较不负责任的，它不关客户端是不是发送成功，只有客户端成功了，他就处理，完全不管客户端是尝试了多少次才连上的

# -*-coding:utf-8-*-
    import socket, traceback
    
    #远程地址
    host = ""
    #远程端口
    port = 9999
    
    #建立一个UDP连接
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    #设置socket选项
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    绑定地址和端口
    s.bind((host, port))
    
    #死循环接收
    while 1:
        try:
            #接收客户端连接，并接收数据
            age, addr = s.recvfrom(8192)
            #age,接收的数据
            print(age)
            #addr,客户端地址
            print(addr)
            #将数据发送客户端
            s.sendto(age, addr)
        except (KeyboardInterrupt, SystemExit):
            #raise，抛出异常
            raise
        except:
            traceback.print_exc()

测试的UDP客户端：

# -*-coding:utf-8-*-
    import socket
    
    host = "127.0.0.1"
    port = 9999
    
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    s.sendto("xxx",(host, port))
    data = s.recvfrom(2048)
    print(data)
    s.close()

UDP服务器错误检查明显少，因为它不负责任，责任都抛给了客户端

UDP适合建立短连接，端的请求和短的响应

用UDP实现一台网络时间服务器

# -*-coding:utf-8-*-
    import socket, traceback, time, struct
    
    host = ""
    port = 9999
    
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    s.bind((host, port))
    
    while 1:
        try:
            age, addr = s.recvfrom(8192)
            secs = int(time.time())
            print(secs)
            secs -= 60 * 60 *24
            print(secs)
            secs += 2208988800
            print(secs)
            reply = struct.pack("!I",secs)
            print(reply)
            s.sendto(reply, addr)
        except (KeyboardInterrupt, SystemExit):
            raise
        except:
            traceback.print_exc()

客户端测试代码:

# -*-coding:utf-8-*-
    import socket, sys, struct, time
    
    hostname = "127.0.0.1"#"time.nist.gov"
    port = 9999#37
    
    #gethostbyname( )主机名 的IPv4 的地址格式
    host = socket.gethostbyname(hostname)
    
    #创建连接
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    #sendto()用于发送UDP数据，第一个参数是发送的数据，第二个是要发送到的地址
    s.sendto("",(host, port))
    
    #recvfrom()返回一个元组，一个是数据，第二个是远程地址
    buf = s.recvfrom(2048)[0]
    if len(buf) !=4:
        print(len(buf), buf)
        sys.exit(1)
    
    #struct是处理二进制的库
    secs = struct.unpack("!I",buf)[0]
    # print(secs)
    secs -= 2208988800
    print(time.ctime(secs))

结果：

Wed Oct 19 10:42:46 2016

3.5 使用inetd 或 xinetd（书上说不适用于windows于是弃了没看）

3.6通过syslog记录日志 （书上说不适用于windows于是弃了没看）

windows下用标准库logging

# -*-coding:utf-8-*-
    
    import logging
    
    def print_log(log_data):
        logging.basicConfig(level=logging.DEBUG,
                  format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s',
                  datefmt='%m-%d %H:%M',
                  filename='myapp.log', (这里可以加一个绝对路径，因为这个日志是出现在程序执行的位置)
                  filemode='a+')
        # 定义一个Handler打印INFO及以上级别的日志到sys.stderr
        console = logging.StreamHandler()
        console.setLevel(logging.INFO)
        # 设置日志打印格式
        formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')
        console.setFormatter(formatter)
        # 将定义好的console日志handler添加到root logger
        logging.getLogger('').addHandler(console)
        logger = logging.getLogger('mysqlupdata_app')
        logger.info(log_data)

3.7避免死锁

死锁一般发生在客户端和服务端同时向一个连接写东西 或者 同时向一个连接读东西的时候，这种情况下没有进程会得到数据

设计一个死锁

TCP服务端：

# -*-coding:utf-8-*-
    import socket, traceback
    
    host = ""
    port = 9999
    
    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 1:
        try:
            sock, addr = s.accept()
        except KeyboardInterrupt:
            raise
        except:
            traceback.print_exc()
            continue
        try:
            while 1:
                data = sock.recv(4096)
                if not len(data):
                    break
                sock.sendall(data)
        except (KeyboardInterrupt, SystemExit):
            raise
        except:
            traceback.print_exc()
    
        try:
            sock.close()
        except KeyboardInterrupt:
            raise
        except:
            traceback.print_exc()

TCP 客户端：

# -*-coding:utf-8-*-
    import socket, sys
    
    host = "127.0.0.1"
    port = 9999
    
    data = "x" * 10485760
    
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((host, port))
    
    byteswritten= 0
    
    while byteswritten < len(data):
        startpos = byteswritten
        endpos = min(byteswritten + 1024,len(data))
        byteswritten += s.send(data[startpos:endpos])
        sys.stdout.write(str(byteswritten)+"\n")
        sys.stdout.flush()
    
    s.shutdown(1)
    
    while 1:
        buf = s.recv(1024)
        if not len(buf):
            break
        sys.stdout.write("data:"+data)

运行服务端和客户端会发现，两边都停住了，为什么呢？

因为服务端是读取4K数据以后就开始想连接里写内容，但是客户端的数据没有写完，它有10M的数据在往连接中写入，它的策略是全部写入以后再全部读取，这样就造成了服务端和客户端都在写入的情况，于是就死锁了

如何解决呢？

要么客户端一次性写入的数据小于服务端读取的数据

要么客户端也写一部分读一部分，如下：

# -*-coding:utf-8-*-
    import socket, sys
    
    host = "127.0.0.1"
    port = 9999
    
    data = "x" * 10485760
    
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((host, port))
    
    byteswritten= 0
    
    while byteswritten < len(data):
        startpos = byteswritten
        endpos = min(byteswritten + 1024,len(data))
        byteswritten += s.send(data[startpos:endpos])
        sys.stdout.write(str(byteswritten)+"\n")
        sys.stdout.flush()
        buf = s.recv(1024)
        if not len(buf):
            break
        #不要打印出来内容，不然程序会执行很久还消耗资源
        # sys.stdout.write("data:" + data+"\n")

3.8总结

TCP连接

TCP客户端建立只要两步

1：创建一个socket连接

s = socket.socket(socket.AF\_INET, socket.SOCK\_STREAM)

2：连接到远程地址

s.connect((host, port))

TCP服务端创建需要四步

1：创建一个socket连接

s = socket.socket(socket.AF\_INET, socket.SOCK\_STREAM)

2：设置socket选项

s.setsockopt(socket.SOL\_SOCKET, socket.SO\_REUSEADDR, 1) (可选)

3：绑定地址

s.bind((host, port))

4：最大未连接等待数

s.listen(1)

UDP连接

UDP客户端只需建立一个连接以后就可以直接发送信息

1：建立socket连接

s = socket.socket(socket.AF\_INET, socket.SOCK\_DGRAM)

UDP服务端需要三步

1：建立一个socket连接

s = socket.socket(socket.AF\_INET, socket.SOCK\_DGRAM)

2：设置socket选项

s.setsockopt(socket.SOL\_SOCKET, socket.SO\_REUSEADDR, 1) (可选)

3：绑定地址

s.bind((host, port))

TCP服务端一般会用accept( )来为每一个连接的客户端建立新的socket，然后发送响应，但是UDP服务端不需要管，一个单一的socket就可以用recvfrom( )返回的值来判断该往哪里发响应

小心死锁

4.域名系统，DNS

域名系统(DNS)是一个分布式数据库，主要用于把主机名转换成IP地址。

DNS之所以存在主要原因有两个：

1，域名比IP好记

2，允许服务器改变IP，或者多个IP，但域名相同

4.1进行DNS查询

python中的 gethostbyname( ) 和 getaddrinfo( )函数都能通过域名找出IP，不同的是gethostbyname( )不兼容IPv6只兼容IPv4，而getaddrinfo( )两者都兼容

# -*-coding:utf-8-*-
    import socket, sys
    
    result = socket.getaddrinfo(sys.argv[1],None)
    print(result)
    print(socket.gethostbyname(sys.argv[1]))

终端输入：python testc1.py [ www.baidu.com][www.baidu.com]

结果：

\[(2, 0, 0, '', ('61.135.169.125', 0)), (2, 0, 0, '', ('61.135.169.121', 0))\]

61.135.169.121

会出现多个IP很正常，网站为了解决负载问题会使用多台服务器

找出域名下所有IP：

# -*-coding:utf-8-*-
    import socket, sys
    
    result = socket.getaddrinfo(sys.argv[1], None)
    counter = 0
    for item in result:
        print(counter,item[4])
        counter +=1

终端输入：python testc1.py [ www.baidu.com][www.baidu.com]

结果：

(0, ('61.135.169.125', 0))

(1, ('61.135.169.121', 0))

4.2反向查找

python中的gethostbyaddr( )函数用来反向查询

# -*-coding:utf-8-*-
    import socket, sys
    
    try:
        result = socket.gethostbyaddr(sys.argv[1])
        print("Domain Name:"+result[0])
    
        for item in result[2]:
            print("IP:"+item)
    #socket.herror，得到主机信息报错
    except socket.herror as e:
        print(str(e))

终端输入：python testc1.py 127.0.0.1

结果：

Domain Name:PC-20160606QEUC

IP:127.0.0.1

输入：python testc1.py 127.0.0.2

结果报错：\[Errno 11004\] host not found( ip没有对应的域名会报错 )

这里有个很有意思的地方，通过上面socket.getaddrinfo( )得到百度的IP，但是用这个IP反向找却失败

输入：python testc1.py 61.135.169.125

结果：\[Errno 11004\] host not found

但是用书上的雅虎IP能找到雅虎

终端输入：python testc1.py 216.109.118.73

结果：

Domain Name:unknown-216-109-118-x.yahoo.com

IP:216.109.118.73

这一点没搞明白

反向查询验证真实性

说实话这个没看明白，反正就是反向查询好了再正向查询一次

# -*-coding:utf-8-*-
    import socket, sys
    
    #反向查询
    def getipaddrs(hostname):
        result = socket.getaddrinfo(hostname, None, 0, socket.SOCK_STREAM)
        return [x[4][0] for x in result]
    
    #正向查询
    def gethostname(ipaddr):
        return socket.gethostbyaddr(ipaddr)[0]
    
    try:
        hostname = gethostname(sys.argv[1])
        ipaddrs = getipaddrs(hostname)
    except socket.herror as e:
        print(str(e))
        #0,没错误退出
        sys.exit(0)
    except socket.gaierror as e:
        print(str(e))
        #1,有错误退出
        sys.exit(1)
    
    if not sys.argv[1] in ipaddrs:
        print("hostname:"+hostname)
        print("IP:"+sys.argv[1])
        sys.exit(1)

终端输入：python testc1.py 216.109.118.73

结果：

hostname:UNKNOWN-216-109-118-X.yahoo.com

IP:216.109.118.73

4.3使用pydns进行高级查询

pydns是第三方库，需要安装

我没有看这篇，直接翻篇了

5.高级网络操作

5.1 半开放socket

通常socket是双向的，数据可以在socket上双向发送。但是socket也可以建立一个单向的连接，即数据只向一个方向发送，单向的socket被称为半开放socket。

如何让socket变成半开放呢？

需要调用shutdown( )，对于socket这个操作是不可逆的

shutdown( )参数值：

0：表示将缓冲区中的内容清空 禁止将来读取：s.shutdown(0)

1：表示将缓冲区中的内容清空 禁止将来写入：s.shutdown(1)

2：表示将缓冲区中的内容清空 禁止将来读取和写入：s.shutdown(2)

一旦给出关闭的方向，socket就不能在该方向上重新打开。

shutdown( )是累计的，调用了s.shutdown(0)后再调用s.shutdown(1)的效果和直接调用s.shutdown(2)时一样的

5.2 超时

对于socket服务端来说，客户端长时间没有响应原本是等待操作系统的失败通知后才发现出问题了，如果使用超时机制，服务端可以对规定时间内没有响应的客户端断开连接。

如何设置超时呢？

需要settimeout( )这个函数，参数是多少秒超时

服务端例子：

# -*-coding:utf-8-*-
    import socket, traceback
    
    #地址
    host = ""
    #端口
    port = 9999
    
    #建立一个连接
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    #设置socket选项
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    #绑定地址和端口
    s.bind((host, port))
    #最大等待数
    s.listen(1)
    
    #死循环
    while 1:
        try:
            #一个客户端连接上来就创建一个新的socket
            sock, addr = s.accept()
        #捕捉键盘强制停止
        except KeyboardInterrupt:
            #抛出异常
            raise
        except:
            #捕捉所有错误并给出出错行
            traceback.print_exc()
            #这个客户端连接有问题就跳过
            continue
    
        #设置客户端响应超时
        sock.settimeout(10)
    
        try:
            #getpeername()，客户端信息
            print("GOT connection from", sock.getpeername())
            while 1:
                #接收客户端信息
                data = sock.recv(4096)
                #客户端没有信息发送过来就断掉
                if not len(data):
                    break
                #把客户端发来的信息返回
                sock.sendall(data)
        #捕捉键盘强制停止 和 系统退出 异常
        except (KeyboardInterrupt, SystemExit):
            #抛出
            raise
        #捕捉超时错误 ，因为读写信息也会超时所以要在读写中捕捉
        except sock.timeout:
            pass
        except:
            traceback.print_exc()
    
        try:
            #断开客户端连接
            sock.close()
        except KeyboardInterrupt:
            raise
        except:
            traceback.print_exc()

客户端例子：

# -*-coding:utf-8-*-
    import socket
    
    #远程地址
    host = "127.0.0.1"
    #远程端口
    port = 9999
    
    #建立一个连接
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    #连接到远程地址
    s.connect((host, port))
    #向服务端发送信息
    s.send("aa")
    #接收服务端信息
    data, adrr = s.recvfrom(2048)
    print(data)
    #关闭连接
    s.close()

5.3 传输字符串

一般传输都是不确定长度的字符串，但是一些的报文形式会在开头加一个长度，然后定长的读取数据，或者在结束加一个结束标识

5.4理解网络字节顺序

网络上发送整型数据时通常有两种选择：

一个是ASCII码的字符串，接收方需要解析

一个是二进制，一般16或者32位

二进制的传送有点问题，因为不同的平台对二进制的编码方式是不同的，为了解决这个问题有一种标准的二进制数据表达方式，网络字节顺序，在发送一个二进制整数前，这个整数会被转换成网络字节顺序，接收以后在使用这个数据前会先把网络字节数据转换成本地的表示方式

python的struct模块提供了数据和二进制间的转换

参数：

H，表示16位整数

I，表示32位整数

！，表示使用网络字节顺序来进行编码和解码

import struct
    
    def htons(num):
        return struct.pack("!H", num)
    
    def htonl(num):
        return struct.pack("!I", num)
    
    def ntohs(data):
        return struct.unpack("!H", data)[0]
    
    def ntohl(data):
        return struct.unpack("!I", data)[0]
    
    def sendstring(data):
        return htons(len(data))
    
    print("Enter a string:")
    str = "xxxx."
    
    print(repr(sendstring(str)))
    
    data = sendstring(str)
    
    print(ntohs(data))

这段代码没明白，因为用字符串长度去转换，但是长度相同的字符串转出来的结果是一样的

5.5使用广播数据

广播数据可以发送局域网上所有机器，会用一种特殊的模式不向每台机器发送重复信息

广播数据多数使用UDP来实现

socket发送广播数据必须先调用s.socket(socket.SOL\_SOCK, socket.SO\_BROADCAST, 1)来使该socket支持广播。发送一个广播可以用特殊地质"<broadcast>"，而不是标准的IP和主机名

广播分为发送方 和 接收方

接收方：

# -*-coding:utf-8-*-
    import socket, traceback
    
    host = ""
    port = 9999
    
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST ,1)
    s.bind((host, port))
    
    while 1:
        try:
            age, addr = s.recvfrom(8192)
            print("Got data from",addr)
            s.sendto("I am here", addr)
        except (KeyboardInterrupt, SystemExit):
            raise
        except:
            traceback.print_exc()

发送方：

# -*-coding:utf-8-*-
    import socket
    
    dest = ("<broadcast>", 9999)
    
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
    s.sendto("Hello", dest)
    while 1:
        (buf ,addr) = s.recvfrom(2048)
        if not len(buf):
            break
        print(addr,buf)

不知道实际有什么用处，，就先练了一遍，因为书上说尽量少用广播，汗

5.6 使用IPv6

因为IPv4地址短缺已经是一个问题了，所以未来趋势会是IPv6

python编写IPv6程序只有在建立连接上有点不一样，一旦建立连接就其它步骤都一样

IPv6建立连接

s = socket.socket(socket.AF\_INET6, socket.SOCK\_DGRAM)

5.7 使用poll( ) 或 select( )实现事件通知(非阻塞)

windows不支持poll( )

select( )例子，服务端：

# -*-coding:utf-8-*-
    import socket,select
    
    host = "127.0.0.1"
    prot = 10000
    s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    #setblocking(False)，设置非阻塞
    s.setblocking(False)
    s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
    s.bind((host,prot))
    s.listen(1)
    #需要监听的可读对象列表
    inputs=[s]
    while 1:
        #select.select( )，第一个参数是可读对象列表，第二个参数是储存连接的客户端socket列表，第三个参数错误文件列表，第四个是超时
        #select.select( )，返回三个元组，每个元组都是准备好的对象列表，顺序和参数一样
        rs,ws,es=select.select(inputs,[],[],1)
        for r in rs:
            if r is s:
                sock,ddr=r.accept()
                #将客户端socket添加到等待可读对象列表中
                inputs.append(sock)
            else:
                data=r.recv(1024)
                if not data:
                    #数据接收好后将客户端socket从等待读取的列表中删除
                    inputs.remove(r)
                else:
                    print data

测试的客户端：

# -*-coding:utf-8-*-
    import socket
    host='127.0.0.1'
    port=10000
    s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    s.connect((host,port))
    s.send('hello from client')
    s.close()

6.web客户端访问

用urllib2写爬虫，因为现在基本用requests，所以不看了

7.解析HTML和XHTML

用HTMLParser解析HTML，因为现在用beautifulsoup4，所以不看了

8.XML和XML-RPC

用xml解析XML，用beautifulsoup4也可以解析，所以不看了

这里也讲了如何生成一个xml，不过现在工作中一般都用json传输数据，所以也没有看

9.E-mail的编写和编码

一般一个E-mail包含两部分：header 和 body

header包含控制数据，如：寄件人，目的地，标题

body包含信息本身

9.1 header处理

设置一个header(书上的例子有点老了，模块结构有点不一样了)

# -*-coding:utf-8-*-
    from email.mime.text import MIMEText
    
    message = "hello"
    #MIMEText()建立一个
    msg = MIMEText(message)
    #设置header信息
    msg["To"] = "xxxxx@xxxx.com"
    msg["From"] = "Test Sender <xxxx@qq.com>"
    msg["Subject"] = "Test Message"
    #打印出信息
    print(msg.as_string())

结果：

Content-Type: text/plain; charset="us-ascii"

MIME-Version: 1.0

Content-Transfer-Encoding: 7bit

To: xxxxx@xxxx.com

From: Test Sender <xxxx@qq.com>

Subject: Test Message

Date: Mon, 24 Oct 2016 14:49:13 +0800

Message-ID: <147729175300.10276.10806171512034289345@TRY-�����.hzdomain1.com>

hello

[python_pdf]: http://download.csdn.net/detail/u013055678/9657281
[www.baidu.com]: http://www.baidu.com/