Python 提供了两个基本的 socket 模块。
第一个是 Socket，它提供了标准的 BSD Sockets API。
第二个是 SocketServer， 它提供了服务器中心类，可以简化网络服务器的开发。

下面讲的是Socket模块功能
1、Socket 类型
套接字格式：
socket(family,type[,protocal]) 使用给定的地址族、套接字类型、协议编号（默认为0）来创建套接字。

2.socket对象的方法
用tcp举例

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

服务端

客户端

公共方法

socket.SOCK_STREAM，tcp的例子：该程序可以实现读取服务端文件内容发送给客户端，或者执行shell命令。
client端：

import socket
import sys
import re
import os

class Client:
    def __init__(self,serverIp,serverPort):
        self.serverIp=serverIp #待连接的远程主机的域名
        self.serverPort = serverPort
        self.bufferSize = 10240

    def connet(self): #连接方法
        try:
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        except socket.error as e:
            print("Failed to create socket. Error: %s"%e)
            
        try:
            s.connect((self.serverIp,self.serverPort))
            while True:
                message = input('> ')#接收用户输入
                if not message:
                    break
                s.send(bytes(message, 'utf-8'))#发送命令
                data = s.recv(self.bufferSize)#接收数据
                if not data:
                    break
                if re.search("^0001",data.decode('utf-8','ignore')):#判断数据类型
                    print(data.decode('utf-8')[4:])
                else:#文件内容处理
                    s.send("File size received".encode())#通知服务端可以发送文件了
                    file_total_size = int(data.decode())#总大小
                    received_size = 0
                    f = open("new" +os.path.split(message)[-1], "wb")#创建文件
                    while received_size < file_total_size:
                        data = s.recv(self.bufferSize)
                        f.write(data)#写文件
                        received_size += len(data)#累加接收长度
                        print("已接收:", received_size)
                    f.close()#关闭文件
                    print("receive done", file_total_size, " ", received_size)
        except socket.error:
            s.close()
            raise #退出进程
        finally:
            s.close()


if __name__ == '__main__':
    cl = Client('127.0.0.1',8800)
    cl.connet()
    sys.exit() #退出进程

server端：

import socket
import sys
import os


class server:
    def __init__(self, ip, port):
        self.port = port
        self.ip = ip
        self.bufferSize = 10240

    def start(self):  # 启动监听，接收数据
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            s.bind((self.ip, self.port))  # 绑定
            s.listen(10)  # 监听
            print('等待客户端连接')
            while True:  # 一直等待新的连接
                try:
                    conn, addr = s.accept()  # 接收连接
                    print('客户端连接 ' + addr[0] + ':' + str(addr[1]))
                    while True:  # 不知道客户端发送数据大小，循环接收
                        data = conn.recv(self.bufferSize)
                        if not data:
                            break
                        else:
                            self.executeCommand(conn,data)
                    conn.close()
                except socket.error as e:
                    print(e)
                    conn.close()  # 关闭连接
        finally:
            s.close()  # 关闭服务端

    def executeCommand(self, tcpCliSock, data):  # 解析并执行命令
        try:#
            message = data.decode("utf-8")
            if os.path.isfile(message):#判断是否是文件
                filesize = str(os.path.getsize(message))#获取文件大小
                print("文件大小为：",filesize)
                tcpCliSock.send(filesize.encode())#发送文件大小
                data = tcpCliSock.recv(self.bufferSize)  
                print("开始发送")
                f = open(message, "rb")#打开文件
                for line in f:
                    tcpCliSock.send(line)#发送文件内容
            else:
                tcpCliSock.send(('0001'+os.popen(message).read()).encode('utf-8'))
        except:
            raise



if __name__ == '__main__':
    s = server('', 8800)
    s.start()

socket.SOCK_RAW，原始套接字的例子
代码来自GitHub

import os
import sys
import struct
import time
import select
import socket

ICMP_ECHO_REQUEST_RATE = 8

# This function returns the time delay between sending and receiving a single ping.
def perform_one_ping(destination_add, timeout):
    icmp_ping = socket.getprotobyname("icmp")
    mySocket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp_ping)
    myID = os.getpid() & 0xFFFF
    sendsingle_icmpping(mySocket, destination_add, myID)
    delay = receivesingle_icmpping(mySocket, myID, timeout, destination_add)
    mySocket.close()
    return delay

# This function receives a single ping.
def receivesingle_icmpping(mySocket, ID, timeout, destAddr):
    global roundTrip_min, roundTrip_max, roundTrip_sum, roundTrip_cnt
    timeRemain = timeout
    while 1:
        startedSelect = time.time()
        arr = select.select([mySocket], [], [], timeRemain)
        howLongInSelect = (time.time() - startedSelect)
        if arr[0] == []:
            return "Request timed out."
        timeReceived = time.time()
        received_Packet, addr = mySocket.recvfrom(1024)
        type, code, checksum, id, seq = struct.unpack('bbHHh', received_Packet[20:28])
        if type != 0:
            return 'expected type=0, but got {}'.format(type)
        if code != 0:
            return 'expected code=0, but got {}'.format(code)
        if ID != id:
            return 'expected id={}, but got {}'.format(ID, id)
        trans_time, = struct.unpack('d', received_Packet[28:])
        roundTrip = (timeReceived - trans_time) * 1000
        roundTrip_cnt += 1
        roundTrip_sum += roundTrip
        roundTrip_min = min(roundTrip_min, roundTrip)
        roundTrip_max = max(roundTrip_max, roundTrip)
        ip_pkt_head = struct.unpack('!BBHHHBBH4s4s', received_Packet[:20])
        ttl = ip_pkt_head[5]
        saddr = socket.inet_ntoa(ip_pkt_head[8])
        length = len(received_Packet) - 20
        return '{} bytes from {}: icmp_seq={} ttl={} time={:.3f} ms'.format(length, saddr, seq, ttl, roundTrip)
        timeRemain = timeRemain - howLongInSelect
        if timeRemain <= 0:
            return "Request timed out."


# The checksum function used to evaluate the checksum.
# The answer of the checksum calculation is returned.
def checksum(str):
    count_sum = 0
    countTo = (len(str) / 2) * 2
    count = 0
    while count < countTo:
        thisVal = ord(str[count + 1]) * 256 + ord(str[count])
        count_sum = count_sum + thisVal
        count_sum = count_sum & 0xffffffffL
        count = count + 2
    if countTo < len(str):
        count_sum = count_sum + ord(str[len(str) - 1])
        count_sum = count_sum & 0xffffffffL
    count_sum = (count_sum >> 16) + (count_sum & 0xffff)
    count_sum = count_sum + (count_sum >> 16)
    calc = ~count_sum
    calc = calc & 0xffff
    calc = calc >> 8 | (calc << 8 & 0xff00)
    return calc


# This function sends a single ping.
def sendsingle_icmpping(mySocket, destination_add, ID):
    count_checksum = 0
    pkt_head = struct.pack("bbHHh", ICMP_ECHO_REQUEST_RATE, 0, count_checksum, ID, 1)
    data = struct.pack("d", time.time())
    count_checksum = checksum(pkt_head + data)
    if sys.platform == 'darwin':
        count_checksum = socket.htons(count_checksum) & 0xffff
    else:
        count_checksum = socket.htons(count_checksum)
    pkt_head = struct.pack("bbHHh", ICMP_ECHO_REQUEST_RATE, 0, count_checksum, ID, 1)
    packet = pkt_head + data
    mySocket.sendto(packet, (destination_add, 1))




# This function displays the ping statistics.
def icmp_ping(host, timeout=1):
    global roundTrip_min, roundTrip_max, roundTrip_sum, roundTrip_cnt
    roundTrip_min = float('+inf')
    roundTrip_max = float('-inf')
    roundTrip_sum = 0
    roundTrip_cnt = 0
    count = 0
    dest = socket.gethostbyname(host)
    print "Pinging " + dest + " using Python:"
    try:
        while True:
            count += 1
            print perform_one_ping(dest, timeout)
            time.sleep(1)
    except KeyboardInterrupt:
        if count != 0:
            print '--- {} ping statistics ---'.format(host)
            print '{} packets transmitted, {} packets received, {:.1f}% packet loss'.format(count, roundTrip_cnt,
                                                                                            100.0 - roundTrip_cnt * 100.0 / count)
            if roundTrip_cnt != 0:
                print 'round-trip min/avg/max {:.3f}/{:.3f}/{:.3f} ms'.format(roundTrip_min, roundTrip_sum / roundTrip_cnt, roundTrip_max)


icmp_ping("www.baidu.com")