python 网络 socket

---恢复内容开始---

1.socket

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

所以，我们无需深入理解tcp/udp协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。

2.socket发展和分类

套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。

基于文件类型的套接字家族

套接字家族的名字：AF_UNIX

AF=Address Familly

unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信

基于网络类型的套接字家族

套接字家族的名字：AF_INET

(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)

3.socket工作流程：

#!/usr/bin/python env

# coding:utf-8

# 套接字编程

# 基于套接字编程

'''

类似情形

服务端：

1.买手机 socket()

2.绑定手机卡 bind()

3.开机 listen()

4.等电话 拿到一个电话链接 accept()

5.收信息 recv()

6.发信息 send()

7 断开电话链接 close()

8.关机

客户端：

1.买手机 socket()

2.拨电话 connect()

3.发信息 send()

4.收信息 recv()

5.结束通话 close()

'''

# 服务端

import socket

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

phone.bind(("127.0.0.1", 8000))

phone.listen(10)

# 链接 地址

conn, addr = phone.accept()

msg = conn.recv(1024)

print("客户端发来信息: ", msg.decode("utf-8"))

conn.send(msg.upper())

conn.close()

phone.close()

#!/usr/bin/python env

# coding:utf-8

'''

客户端：

1.买手机 socket()

2.拨电话 connect()

3.发信息 send()

4.收信息 recv()

5.结束通话 close()

'''

import socket

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

phone.connect(("127.0.0.1", 8000))

phone.send("你好".encode("utf-8"))

data = phone.recv(1024)

print("收服务端信息:", data.decode("utf-8"))

4.三次握手四次挥手

5.数据：用户态数据内核态数据缓冲区

6. 解决socket服务器time_out问题

#加入一条socket配置，重用ip和端口在bind前加 phone.bind(('127.0.0.1',8080))

socket对象.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)

7.基于tcp的套接字实例

A.  tcp服务端

#!/usr/bin/python env

# coding:utf-8

from socket import *

ip_port = ("127.0.0.1", 8000)

back_log = 10

buffer_size = 1024

tcp_server = socket(AF_INET, SOCK_STREAM)

tcp_server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)  # 解决socket服务端 time_out问题

tcp_server.bind(ip_port)

tcp_server.listen(back_log)

# while 开启多个链接

while True:

    conn, addr = tcp_server.accept()

    # while 和一个客户端循环通信

    while True:

        # 解决客户端断开链接抛出的异常

        try:

            print("双向链接：", conn)

            print("客户端地址：", addr)

            data = conn.recv(buffer_size)

            # if not data: break  # 有的系统上用此方法解决客户端断开连接抛出的异常

            print("客户端发来信息：", data.decode("utf-8"))

            conn.send(data.upper())

        except Exception as e:

            break

    conn.close()

tcp_server.close()

B.  tcp客户端

#!/usr/bin/python env

# coding:utf-8

from socket import *

ip_port = ("127.0.0.1", 8000)

back_log = 10

buffer_size = 1024

tcp_client = socket(AF_INET, SOCK_STREAM)

tcp_client.connect(ip_port)

while True:

    msg = input(">>: ")

    if not msg: continue  # 解决输入空数据问题

    tcp_client.send(msg.encode("utf-8"))

    data = tcp_client.recv(back_log)

    print("客户端发来信息：", data.decode("utf-8"))

tcp_client.close()

8.基于udp的套接字实例

# recv在自己这端缓冲区为空时，阻塞

# recvfrom在自己这端缓冲区为空时，就收一个空？？？

# udp套接字服务端

from socket import *

ip_port = ("127.0.0.1", 8000)

back_log = 10

buffer_size = 1024

udp_server = socket(AF_INET,SOCK_DGRAM)

udp_server.bind(ip_port)

while True:

    data,addr = udp_server.recvfrom(buffer_size)

    if len(data.decode("utf-8")) == 0:continue

    print(data.decode("utf-8"))

    msg = input(">>: ").strip()

    # if not msg: continue

    udp_server.sendto(msg.encode("utf-8"),addr)

# udp套接字客户端

from socket import *

ip_port = ("127.0.0.1", 8000)

back_log = 10

buffer_size = 1024

udp_client = socket(AF_INET,SOCK_DGRAM)

while True:

    msg = input(">>: ").strip()

    if not msg: continue

    udp_client.sendto(msg.encode("utf-8"),ip_port)

    data,addr = udp_client.recvfrom(buffer_size)

    # if len(data)== 0:continue

    print(data.decode("utf-8"))

9.基于udp socket实现ntp服务

# _*_coding:utf-8_*_

__author__ = 'Linhaifeng'

from socket import *

from time import strftime

# ntp服务端

ip_port = ('127.0.0.1', 9000)

bufsize = 1024

tcp_server = socket(AF_INET, SOCK_DGRAM)

tcp_server.bind(ip_port)

while True:

    msg, addr = tcp_server.recvfrom(bufsize)

    print('===>', msg)

    if not msg:

        time_fmt = '%Y-%m-%d %X'

    else:

        time_fmt = msg.decode('utf-8')

    back_msg = strftime(time_fmt)

    tcp_server.sendto(back_msg.encode('utf-8'), addr)

tcp_server.close()

# ntp客户端

#_*_coding:utf-8_*_

__author__ = 'Linhaifeng'

from socket import *

ip_port=('127.0.0.1',9000)

bufsize=1024

tcp_client=socket(AF_INET,SOCK_DGRAM)

while True:

    msg=input('请输入时间格式(例%Y %m %d)>>: ').strip()

    tcp_client.sendto(msg.encode('utf-8'),ip_port)

    data=tcp_client.recv(bufsize)

    print(data.decode('utf-8'))

tcp_client.close()

10.基于tcp socket实现shell 粘包问题解决

# 服务端

# struct 解决粘包

from socket import *

import subprocess

import struct

ip_port = ('127.0.0.1', 800)

back_log = 10

buffer_size = 1024

tcp_server = socket(AF_INET, SOCK_STREAM)

tcp_server.bind(ip_port)

tcp_server.listen(back_log)

while True:  # 接受多个客户端连接

    conn, addr = tcp_server.accept()  # 等待连接中

    print("新客户端地址: ", addr)

    while True:  #接受一个客户端连接

        try:

            cmd = conn.recv(buffer_size)

            if not cmd:break #  基于linux系统 处理客户端quit处理

            print("收到客户端发来的信息：", cmd)

            res = subprocess.Popen(cmd.decode('utf-8'),shell=True,

                                   stderr=subprocess.PIPE,

                                   stdout=subprocess.PIPE,

                                   stdin=subprocess.PIPE)

            err = res.stderr.read()

            if err:

                cmd_res = err

            else:

                cmd_res = res.stdout.read()

            if not cmd_res:  # 处理cd ..  cmd_res 没有返回值是None

                cmd_res = 'ok'.encode('gbk')

            # 解决粘包

            length = len(cmd_res) #求出执行命令结果的数据长度

            data_length = struct.pack('i',length)

            print(data_length)

            # 发送下次要发送数据的长度

            conn.send(data_length)

            conn.send(cmd_res)

        except Exception as e:

            print(e)

            break

    conn.close()

tcp_server.close()

#客户端

# 解决粘包

from socket import *

import struct

from functools import partial

ip_port = ('192.168.8.102', 800)

buffer_size = 1024

tcp_client = socket(AF_INET, SOCK_STREAM)

tcp_client.connect(ip_port)

while True:

    cmd = input("[root@localhost ~]# ".strip())

    if not cmd: continue

    if cmd == 'quit': break

    tcp_client.send(cmd.encode('utf-8'))

    # 解决粘包

    length_data = tcp_client.recv(4)  # 接受服务器发来的下次将要发送数据的长度 整数的长度是4个字节 是一个元组类型

    print(length_data)

    length = struct.unpack('i', length_data)[0]

    print(length)

    recv_size = 0

    recv_msg = b''

    while recv_size < length:

        recv_msg += tcp_client.recv(buffer_size)

        recv_size = len(recv_msg)

    print("服务器命令执行的结果: ", recv_msg.decode('utf-8'))

tcp_client.close()

11.iter 和 functools中偏函数 partial

l = ["a", "b", "c", "d"]

def func():

    return l.pop()

# 迭代到"b"结束 抛出异常

l1 = iter(func,"b")

print(next(l1))

print(next(l1))

# print(next(l1))

# 偏函数

from functools import partial

def add(x,y):

    return x + y

func = partial(add,100)

print(func(1))  #

'''

recv_size = 0

recv_msg = b''

while recv_size < length:

    recv_msg += tcp_client.recv(buffer_size)

    recv_size = len(recv_msg)

'''

recv_msg = "".join(iter(partial(tcp_client.recv,buffer_size),b''))

参考：http://www.cnblogs.com/linhaifeng/articles/6129246.html

---恢复内容结束---