import socket
socket.socket(socket_family,socket_type,protocal=0)
socket_family 可以是 AF_UNIX 或 AF_INET。socket_type 可以是 SOCK_STREAM 或 SOCK_DGRAM。protocol 一般不填,默认值为 0。

获取tcp/ip套接字
tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
tcpSock = socket.socket()  # 不传参默认也是tcp协议

获取udp/ip套接字
udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
udpSock = socket.socket(type=socket.SOCK_DGRAM)  # 这种也行

import socket
sk = socket.socket()  # 买手机
# sk:<socket.socket fd=452, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0>
# sk.bind(''ip'',''port'')  # 绑手机卡
sk.bind((''127.0.0.1'', 8080))  # 绑手机卡，服务端要有固定地址，类似于域名，有固定地址客户端才知道如何访问
# listen(5)的参数为最大连接数
sk.listen()  # 监听，等人打电话来
while True:
    # sk.accept()的返回值为：
    # (<socket.socket fd=456, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=(''127.0.0.1'', 8080), raddr=(''127.0.0.1'', 65162)>, (''127.0.0.1'', 65162))
    # 前一个参数为连接对象，后一个为客户端地址，所以用两个参数接收返回值
    conn, addr = sk.accept()  # 接电话
    while True:
        ret = conn.recv(1024).decode(''utf-8'')
        if ret == ''bye'':
            sk.send(b''bye'')
            break
        print(ret)
        info = input(''>>>>'')
        conn.send((info.encode(''utf-8'')))
        if info == ''bye'':
            break
# ret = conn.recv(1024)  # 限定一次接多少字节
# print(ret)
# conn.send(b''hi'')  # 发消息
# ret = conn.recv(1024)
# print(ret.decode(''utf-8''))
# conn.send(''吃食堂''.encode(''utf-8''))

    conn.close()  # 挂电话
sk.close()  # 关手机

import socket
sk = socket.socket()  # 随便拿个手机
sk.connect((''127.0.0.1'', 8080))  # 给服务端固定地址打电话
while True:
    info = input(''>>>'')
    sk.send(info.encode(''utf-8''))
    ret = sk.recv(1024).decode(''utf-8'')
    print(ret)
    if ret == ''bye'':
        sk.send(b''bye'')
        break
# sk.send(b''hello'')
# ret = sk.recv(1024)
# print(ret.decode(''utf-8''))
# sk.send(bytes(''中午吃啥'', encoding=''utf-8''))
# ret = sk.recv(1024)
# print(ret.decode(''utf-8''))
sk.close()

#加入一条socket配置，重用ip和端口

phone=socket(AF_INET,SOCK_STREAM)
phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
phone.bind((''127.0.0.1'',8080))

发现系统存在大量TIME_WAIT状态的连接，通过调整linux内核参数解决，
vi /etc/sysctl.conf

编辑文件，加入以下内容：
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_fin_timeout = 30
 
然后执行 /sbin/sysctl -p 让参数生效。
 
net.ipv4.tcp_syncookies = 1 表示开启SYN Cookies。当出现SYN等待队列溢出时，启用cookies来处理，可防范少量SYN攻击，默认为0，表示关闭；

net.ipv4.tcp_tw_reuse = 1 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接，默认为0，表示关闭；

net.ipv4.tcp_tw_recycle = 1 表示开启TCP连接中TIME-WAIT sockets的快速回收，默认为0，表示关闭。

net.ipv4.tcp_fin_timeout 修改系統默认的 TIMEOUT 时间

import socket
sk = socket.socket(type=socket.SOCK_DGRAM)  # DGRAM:数据报文
sk.bind((''127.0.0.1'',8080))  # 不需要监听
while True:
    msg, addr = sk.recvfrom(1024)
    print(addr)
    print(msg.decode(''utf-8''))
    info = input(''>>>>'').encode(''utf-8'')
    sk.sendto(info, addr)

sk.close()

import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
ip_port = (''127.0.0.1'',8080)
while True:
    info = input(''一号：'')
    info = (''来自一号的消息：%s'' %info).encode(''utf-8'')
    sk.sendto(info,ip_port)
    msg, addr = sk.recvfrom(1024)
    print(msg.decode(''utf-8''))

######################
import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
ip_port = (''127.0.0.1'',8080)
while True:
    info = input(''二号：'')
    info = (''来自二号的消息：%s'' %info).encode(''utf-8'')
    sk.sendto(info,ip_port)
    msg, addr = sk.recvfrom(1024)
    print(msg.decode(''utf-8''))

import socket
sk = socket.socket()
sk.bind((''127.0.0.1'', 8080))
sk.listen()

conn, addr = sk.accept()
while True:
    info = input(''>>>>'').encode(''utf-8'')
    if info == b''q'':
        conn.send(info)
        break
    else:
        conn.send(info)
        ret = conn.recv(100).decode(''utf-8'')
        print(ret)
        ret = conn.recv(1024).decode(''utf-8'')
        print(ret)
conn.close()
sk.close()

import socket, subprocess
sk = socket.socket()

sk.connect((''127.0.0.1'', 8080))
while True:
    cmd = sk.recv(1024).decode(''gbk'')
    if cmd == ''q'':
        break
    else:
        # ret = subprocess.Popen(cmd.decode("gbk"),.......)在前面解码后下文中就不需要再进行解码操作了
        ret = subprocess.Popen(cmd, shell=True, # subprocess.PIPE, 每次执行一次该语句都相当于重新生成一个管道
                               stdout=subprocess.PIPE,  # 管道里面的缓存数据只能读一次
                               stderr=subprocess.PIPE)
        std_out = ''stdout:'' + (ret.stdout.read()).decode(''gbk'')
        # std_oughd = ''stdout:'' + (ret.stdout.read()).decode(''gbk'') # 再读了一次就拿不到东西了，输出为空
        # print(''dsafffffffffff'',std_oughd)
        std_err = ''stderr:'' + (ret.stderr.read()).decode(''gbk'')
        print(std_out)
        print("-----------------stdout", std_out)
        print(std_err)
        sk.send(std_out.encode(''utf-8''))
        sk.send(std_err.encode(''utf-8''))
sk.close()

import json,struct
#假设通过客户端上传1T:1073741824000的文件a.txt

#为避免粘包,必须自定制报头
header={''file_size'':1073741824000,''file_name'':''/a/b/c/d/e/a.txt'',''md5'':''8f6fbf8347faa4924a76856701edb0f3''} #1T数据,文件路径和md5值

#为了该报头能传送,需要序列化并且转为bytes
head_bytes=bytes(json.dumps(header),encoding=''utf-8'') #序列化并转成bytes,用于传输

#为了让客户端知道报头的长度,用struck将报头长度这个数字转成固定长度:4个字节
head_len_bytes=struct.pack(''i'',len(head_bytes)) #这4个字节里只包含了一个数字,该数字是报头的长度

#客户端开始发送
conn.send(head_len_bytes) #先发报头的长度,4个bytes
conn.send(head_bytes) #再发报头的字节格式
conn.sendall(文件内容) #然后发真实内容的字节格式

#服务端开始接收
head_len_bytes=s.recv(4) #先收报头4个bytes,得到报头长度的字节格式
x=struct.unpack(''i'',head_len_bytes)[0] #提取报头的长度

head_bytes=s.recv(x) #按照报头长度x,收取报头的bytes格式
header=json.loads(json.dumps(header)) #提取报头

#最后根据报头的内容提取真实的数据,比如
real_data_len=s.recv(header[''file_size''])
s.recv(real_data_len)

#_*_coding:utf-8_*_
#http://www.cnblogs.com/coser/archive/2011/12/17/2291160.html
__author__ = ''Linhaifeng''
import struct
import binascii
import ctypes

values1 = (1, ''abc''.encode(''utf-8''), 2.7)
values2 = (''defg''.encode(''utf-8''),101)
s1 = struct.Struct(''I3sf'')
s2 = struct.Struct(''4sI'')

print(s1.size,s2.size)
prebuffer=ctypes.create_string_buffer(s1.size+s2.size)
print(''Before : '',binascii.hexlify(prebuffer))
# t=binascii.hexlify(''asdfaf''.encode(''utf-8''))
# print(t)


s1.pack_into(prebuffer,0,*values1)
s2.pack_into(prebuffer,s1.size,*values2)

print(''After pack'',binascii.hexlify(prebuffer))
print(s1.unpack_from(prebuffer,0))
print(s2.unpack_from(prebuffer,s1.size))

s3=struct.Struct(''ii'')
s3.pack_into(prebuffer,0,123,123)
print(''After pack'',binascii.hexlify(prebuffer))
print(s3.unpack_from(prebuffer,0))

关于struct的详细用法

import socket
import struct
import json
import subprocess
import os

class MYTCPServer:
    address_family = socket.AF_INET

    socket_type = socket.SOCK_STREAM

    allow_reuse_address = False

    max_packet_size = 8192

    coding=''utf-8''

    request_queue_size = 5

    server_dir=''file_upload''

    def __init__(self, server_address, bind_and_activate=True):
        """Constructor.  May be extended, do not override."""
        self.server_address=server_address
        self.socket = socket.socket(self.address_family,
                                    self.socket_type)
        if bind_and_activate:
            try:
                self.server_bind()
                self.server_activate()
            except:
                self.server_close()
                raise

    def server_bind(self):
        """Called by constructor to bind the socket.
        """
        if self.allow_reuse_address:
            self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.socket.bind(self.server_address)
        self.server_address = self.socket.getsockname()

    def server_activate(self):
        """Called by constructor to activate the server.
        """
        self.socket.listen(self.request_queue_size)

    def server_close(self):
        """Called to clean-up the server.
        """
        self.socket.close()

    def get_request(self):
        """Get the request and client address from the socket.
        """
        return self.socket.accept()

    def close_request(self, request):
        """Called to clean up an individual request."""
        request.close()

    def run(self):
        while True:
            self.conn,self.client_addr=self.get_request()
            print(''from client '',self.client_addr)
            while True:
                try:
                    head_struct = self.conn.recv(4)
                    if not head_struct:break

                    head_len = struct.unpack(''i'', head_struct)[0]
                    head_json = self.conn.recv(head_len).decode(self.coding)
                    head_dic = json.loads(head_json)

                    print(head_dic)
                    #head_dic={''cmd'':''put'',''filename'':''a.txt'',''filesize'':123123}
                    cmd=head_dic[''cmd'']
                    if hasattr(self,cmd):
                        func=getattr(self,cmd)
                        func(head_dic)
                except Exception:
                    break

    def put(self,args):
        file_path=os.path.normpath(os.path.join(
            self.server_dir,
            args[''filename'']
        ))

        filesize=args[''filesize'']
        recv_size=0
        print(''----->'',file_path)
        with open(file_path,''wb'') as f:
            while recv_size < filesize:
                recv_data=self.conn.recv(self.max_packet_size)
                f.write(recv_data)
                recv_size+=len(recv_data)
                print(''recvsize:%s filesize:%s'' %(recv_size,filesize))


tcpserver1=MYTCPServer((''127.0.0.1'',8080))

tcpserver1.run()






#下列代码与本题无关
class MYUDPServer:

    """UDP server class."""
    address_family = socket.AF_INET

    socket_type = socket.SOCK_DGRAM

    allow_reuse_address = False

    max_packet_size = 8192

    coding=''utf-8''

    def get_request(self):
        data, client_addr = self.socket.recvfrom(self.max_packet_size)
        return (data, self.socket), client_addr

    def server_activate(self):
        # No need to call listen() for UDP.
        pass

    def shutdown_request(self, request):
        # No need to shutdown anything.
        self.close_request(request)

    def close_request(self, request):
        # No need to close anything.
        pass

服务端

import socket
import struct
import json
import os



class MYTCPClient:
    address_family = socket.AF_INET

    socket_type = socket.SOCK_STREAM

    allow_reuse_address = False

    max_packet_size = 8192

    coding=''utf-8''

    request_queue_size = 5

    def __init__(self, server_address, connect=True):
        self.server_address=server_address
        self.socket = socket.socket(self.address_family,
                                    self.socket_type)
        if connect:
            try:
                self.client_connect()
            except:
                self.client_close()
                raise

    def client_connect(self):
        self.socket.connect(self.server_address)

    def client_close(self):
        self.socket.close()

    def run(self):
        while True:
            inp=input(">>: ").strip()
            if not inp:continue
            l=inp.split()
            cmd=l[0]
            if hasattr(self,cmd):
                func=getattr(self,cmd)
                func(l)


    def put(self,args):
        cmd=args[0]
        filename=args[1]
        if not os.path.isfile(filename):
            print(''file:%s is not exists'' %filename)
            return
        else:
            filesize=os.path.getsize(filename)

        head_dic={''cmd'':cmd,''filename'':os.path.basename(filename),''filesize'':filesize}
        print(head_dic)
        head_json=json.dumps(head_dic)
        head_json_bytes=bytes(head_json,encoding=self.coding)

        head_struct=struct.pack(''i'',len(head_json_bytes))
        self.socket.send(head_struct)
        self.socket.send(head_json_bytes)
        send_size=0
        with open(filename,''rb'') as f:
            for line in f:
                self.socket.send(line)
                send_size+=len(line)
                print(send_size)
            else:
                print(''upload successful'')




client=MYTCPClient((''127.0.0.1'',8080))

client.run()

客户端

我有一个PyQt Gui应用程序。此应用程序有一个主窗口，应在启动后打开。

此应用程序应监听websocket。

我试着解决它是这样的：

...

if __name__ == '__main__':
    app = QtGui.QApplication(sys.argv)

    window = Window()
    window.show()

    websocket.enableTrace(True)
    ws = websocket.WebSocketApp("ws://localhost:8080/chatsocket",on_message = on_message,on_error = on_error,on_close = on_close)
#    ws.on_open = on_open

    ws.run_forever()

    sys.exit(app.exec_())

但是，启动应用程序后，主窗口没有打开。

如果没有“ ws.run_forever（）”行，则打开主窗口，但应用程序不侦听websocket。

我需要在“背景”中收听网络套接字吗？你能帮助我吗？

PS ：（对不起，我的英语）

我有一个PyQt Gui应用程序。此应用程序有一个主窗口，应在启动后打开。

此应用程序应监听websocket。

我试着解决它是这样的：

...

if __name__ == '__main__':
    app = QtGui.QApplication(sys.argv)

    window = Window()
    window.show()

    websocket.enableTrace(True)
    ws = websocket.WebSocketApp("ws://localhost:8080/chatsocket",on_message = on_message,on_error = on_error,on_close = on_close)
#    ws.on_open = on_open

    ws.run_forever()

    sys.exit(app.exec_())

但是，启动应用程序后，主窗口没有打开。

如果没有“ ws.run_forever（）”行，则打开主窗口，但应用程序不侦听websocket。

我需要在“背景”中收听网络套接字吗？你能帮助我吗？

PS ：（对不起，我的英语）