Python中socket编程

1、Socket介绍：

Python中提供socket.py标准库，非常底层的接口库。

Socket是一种通用的网络编程接口，和网络层次没有一一对应关系。

跨操作系统的。紧密结合tcp和udp来使用的。

接口简单，但是背后的原理不简单，ip加tcp，通过插两端。通过socket通道；连接程序。

建立关联。

apc库。

加端口是因为应用程序太多了。绑定ip地址，作为假端口。

端口是由谁管理的

一般都是tcp和udp编程。Socket基本的，chatserver。

协议族:AF 表示address family ，用于socket()的第一个参数。


名称
含义

AF_INET
Ipv4

AF_INET6
Ipv6

AF_UNIX
Unix domain socket,windows没有

第三个本机使用效率不错的，通用的话就是应该进一步考虑了。

Socket类型：


名称
含义

Sock_STREAM
面向连接的流套接字，默认值，tcp协议

SOCK_DGRAM
无连接的数据报文套接字，UDP协议

2、tcp编程

Tcp编程是IO密集型。多线程处理的问题。

Server端：1、要有socket接口。2、找ip地址和端口绑定。3、监听端口。4、accept，接受socket，创建小的socket端。直接和应用程序连接在一起的。5、读取用户数据。6、写，发送数据。7、数据完成后断开。

Client端：1、要有socket端，主动连接别人。2、connect建立连接，有socket，和端口和ip。

3、写，发送数据。4、读取服务器端数据。5、数据完成后关闭了。

服务器端没有响应了，tcp协议管理。

Socket会占用描述符，每一个都会创建一个文件描述符。客户端看到只有的是一个。

Import socket

Server = socket.socket()   socket接口。

Server.bind(ipaddr)

Server.bind((‘0.0.0.0’,9999))绑定

Server.listen()监听

S2，iP2 = server.accept()

S1.recv（1024）缓冲区大小。

S1.send(b’ack’)

decode()解码
encode(）编码

创建socket对象，

一个ip和一个端口只能被一个程序使用。端口只能进行一次监听，绑定，再次监听或者绑定的话就会报错。

使用完毕后必须进行关闭。

应用：

简单的实现：解决中文的情况，编解码的时候全部注明统一编码和解码。

import socket

server =socket.socket()
server.bind((‘127.0.0.1‘,99))
server.listen(99)

s1,ip = server.accept()
print(s1)
print(ip)

while True:
    data = s1.recv(1024)
    print(data)
    s1.send(‘ack{}‘.format(data.decode(‘gbk‘)).encode(‘gbk‘))

s1.close()

server.close()
 
 
 
 
 

<socket.socket fd=192, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=(‘127.0.0.1‘, 99), raddr=(‘127.0.0.1‘, 50149)>

(‘127.0.0.1‘, 50149)

b‘\xd6\xd0\xb9\xfa‘

客服端和服务器端建立间接，需要建立一条socket通道，每次建立连接，listen的端口都会和客户端建立的新的端口，因为连接端口就会阻塞，所以需要建立新的端口。隐士的还是看到连接的端口还是原来的socket。

应用：写一个群聊程序

1）第一步：import threading
import logging
import socket

FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘
logging.basicConfig(format=FORMAT,level=logging.INFO)

class ChatServer:
    def __init__(self,ip=‘127.0.0.1‘,port=999):
        self.addr = (ip , port)
        self.socket = socket.socket()

    def start(self):
        self.socket.bind(self.addr)
        self.socket.listen()

        threading.Thread(target=self.accept,name=‘accept‘).start()

    def accept(self):
        while True:
            s,ip = self.socket.accept()
            logging.info(s)
            logging.info(ip)
            threading.Thread(target=self.connt,name=‘connt‘,args=(s,)).start()

    def connt(self,sockets):
        while True:
            data = sockets.recv(1024)
            logging.info(data)
            sockets.send(‘ack-{}‘.format(data.decode()).encode())

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

cs = ChatServer()
cs.start()

2）第二步

把所有的客户端的ip和端口保留在一个容器里面，一个客户端发送消息到服务器端，服务器端，进行消息的转发等。

import threading
import logging
import socket

FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘
logging.basicConfig(format=FORMAT,level=logging.INFO)

class ChatServer:
    def __init__(self,ip=‘127.0.0.1‘,port=999):
        self.addr = (ip , port)
        self.socket = socket.socket()
        self.cliens = {}

    def start(self):
        self.socket.bind(self.addr)
        self.socket.listen()

        threading.Thread(target=self.accept,name=‘accept‘).start()

    def accept(self):
        while True:
            s,ip = self.socket.accept()
            logging.info(s)
            logging.info(ip)
            self.cliens[ip] = s
            threading.Thread(target=self.connt,name=‘connt‘,args=(s,)).start()

    def connt(self,sockets):
        while True:
            data = sockets.recv(1024)
            logging.info(data)
            sockets.send(‘ack-{}‘.format(data.decode(‘gbk‘)).encode(‘gbk‘))
            for s in self.cliens.values():
                s.send(‘ack1-{}‘.format(data.decode(‘gbk‘)).encode(‘gbk‘))

    def stop(self):
        for s in self.cliens.values():
                s.close()
        self.socket.close()

cs = ChatServer()
cs.start()

其他方法：


名称
含义

Socket.recv(bufsize[,flags])
获取数据，默认阻塞的方式

Socket.recvfrom(bufsize[,flags])
获取数据，返回一个二元组（bytes，address）

Socket.recv_into(buffer[,nbytes[,flags]])
获取nbytes的数据后，存储到buffer中，如果nbytes没有指定或0，将buffer大小的数据存入buffer中，返回接受的字节数

Socket.recvfrom_into(buffer[,nbytes[,flags]])
获取数据，返回一个二元组（bytes，address）到buffer中

Socket.send(bytes[,flags])
TCP 发送数据

Socket.sendall(bytes[,flags])
TCP发送全部数据，成功返回None

Socket.sendto(string[,flag],address)
UDP发送数据

Socket.sendfile(file,offset=0,count=None)
发送一个文件直到EOF，使用高性能的os.sendfile机制，返回发送的字节数，如果win下不支持sendfile，或者不是普通文件，使用send()发送文件，offset告诉其实位置，3.5版本开始。

Makefile

Socket.makefile(mode=’r’,buffering=None,*,encoding=None,errors=None,newline=None)创建一个与该套接字相关连的文件对象，将recv方法看做读方法，将send方法看做是写方法。

异常不捕获会导致当前线程异常退出，不捕获直接到最外层，也就是主线程。

3、客户端tcp编程

import socket

raddr = (‘127.0.0.1‘,999)
client = socket.socket()
client.connect(raddr)

while True:
    data =  client.recv(1024)
    print(data)
    if data.strip() == b‘quit‘:
        break
    client.send(b‘ack‘)
client.close()
import threading
import socket
import logging
import datetime
FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘
logging.basicConfig(format=FORMAT,level=logging.INFO)

class ChatClient:
    def __init__(self,ip=‘127.0.0.1‘,port=8080):
        self.clients = socket.socket()
        self.raddr = (ip,port)
        self.event = threading.Event()

    def start(self):
        self.clients.connect(self.raddr)
        self.send(‘I am ok‘)

        threading.Thread(target=self.recive,name=‘receive‘).start()

    def recive(self):
        while not self.event.is_set():
            data = self.clients.recv(1024)
            # logging.info(data)
            if data.strip() == b‘quit‘:
                break
            message = ‘{:%Y/%m/%d %H:%M:%S}{}:{}\n{}\n‘.format(datetime.datetime.now(),*self.raddr,data.strip())
            logging.info(message)
    def send(self,message:str):
        data = ‘{}\n‘.format(message.strip()).encode()
        self.clients.send(data)

    def stop(self):
        self.event.set()
        self.clients.close()

def main():
    cc = ChatClient()
    cc.start()

    while True:
        cmd = input(‘>>>>‘)
        if cmd.strip() == ‘quit‘:
            cc.stop()
            break
        cc.send(cmd)
        logging.info(threading.enumerate())

if __name__ == ‘__main__‘:
    main()

4、udp编程

同一个协议下绑定同一个端口，才会有端口冲突。Udp不会真的连接。

Import socket

Server=socket.socket（type=）

Server.bind（laddr）绑定本地自己用的。

Server.recv(1024)

Data ,raddr = Server.recvfrom(1024)

Server.sendto（b’back’,raddr）;后面的ip可以是不存在的，都会发送出去的。

Server.connect(raddr)后面才可以使用send。一般都是客户端向服务端连接用的。

服务器端代码：

import socket
import threading
import logging

FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘
logging.basicConfig(format=FORMAT,level=logging.INFO)

class ChatServer:

    def __init__(self,ip=‘127.0.0.1‘,port=9999):
        self.addr = (ip,port)
        self.sockets = socket.socket(type=socket.SOCK_DGRAM)
        self.event = threading.Event()

    def start(self):
        self.sockets.bind(self.addr)
        threading.Thread(target=self.recv,name=‘recv‘).start()

    def recv(self):
        while not self.event.is_set():
            data,laddr = self.sockets.recvfrom(1024)
            logging.info(data)
            logging.info(laddr)

            msg = ‘ack.{}from{}{}‘.format(data.decode(),*laddr)
            masg1 = msg.encode()
            logging.info(msg)
            self.sockets.sendto(masg1,laddr)

    def stop(self):
        self.sockets.close()
        self.event.set()

def main():
    cs = ChatServer()
    cs.start()

    while True:
        cmd = input(‘>>>>‘)
        if cmd.strip() == ‘quit‘:
            cs.stop()
            break
        logging.info(threading.enumerate())

if __name__ == ‘__main__‘:
    main()

客户端代码：

import threading
import socket
import logging
import datetime

FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘
logging.basicConfig(format=FORMAT,level=logging.INFO)

class ChatUdpClient:
    def __init__(self,ip=‘127.0.0.1‘,port=8080):
        self.addr = (ip,port)
        self.cucsocket = socket.socket(type=socket.SOCK_DGRAM)
        self.event = threading.Event()

    def start(self):
        self.cucsocket.connect(self.addr)
        threading.Thread(target=self.recive,name=‘recive‘).start()

    def recive(self):
        while not self.event.is_set():
            data,raddr =self.cucsocket.recvfrom(1024)
            logging.info(data)
            logging.info(raddr)

            message = ‘{}from{}{}‘.format(data.decode(),*raddr)

    def send(self,message:str):
        self.cucsocket.sendto(message.encode(), self.addr)

    def stop(self):
        self.cucsocket.close()
        self.event.set()

def main():
    cuc = ChatUdpClient()
    cuc.start()

    while True:
        cmd = input(‘>>>‘)
        if cmd.strip() == ‘quit‘:
            cuc.stop()
            break
        cuc.send(cmd)
        logging.info(threading.enumerate())

if __name__ == ‘__main__‘:
    main()

ack机制和心跳heartbeat。

心跳机制：

1）一般来说客户端定时发往服务器端，服务器端并不需要ack回复客户端，只是需要记录客户端活着就可以了。（严格考虑时间的问题）

2）服务器端定时发往客户端，一般需要客户端ack响应来表示活着，如果没有收到ack的客户端，服务端移除其信息，这种实现复杂，用的较少。

3）也可以是双向都发心跳包的，用的情况下较少。

为True的时候就不进入循环了。

心跳包客户端代码：

import threading
import socket
import logging
import datetime

FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘
logging.basicConfig(format=FORMAT,level=logging.INFO)

class ChatUdpClient:
    def __init__(self,ip=‘127.0.0.1‘,port=8080):
        self.addr = (ip,port)
        self.cucsocket = socket.socket(type=socket.SOCK_DGRAM)
        self.event = threading.Event()

    def start(self):
        self.cucsocket.connect(self.addr)
        threading.Thread(target=self.sen_hb,name=‘hb‘).start()
        threading.Thread(target=self.recive,name=‘recive‘).start()

    def recive(self):
        while not self.event.is_set():
            data,raddr =self.cucsocket.recvfrom(1024)
            logging.info(data)
            logging.info(raddr)

            message = ‘{}from{}{}‘.format(data.decode(),*raddr)

    def send(self,message:str):
        self.cucsocket.sendto(message.encode(), self.addr)

    def sen_hb(self):
        self.send(‘hb‘)

    def stop(self):
        self.cucsocket.close()
        self.event.set()

def main():
    cuc = ChatUdpClient()
    cuc.start()

    while True:
        cmd = input(‘>>>‘)
        if cmd.strip() == ‘quit‘:
            cuc.stop()
            break
        cuc.send(cmd)
        logging.info(threading.enumerate())

if __name__ == ‘__main__‘:
    main()

心跳包服务器端代码：

import threading
import socket
import logging
import datetime

FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘
logging.basicConfig(format=FORMAT,level=logging.INFO)

class ChatUdpServer:
    def __init__(self,ip=‘127.0.0.1‘,port=8080,interval=10):
        self.addr = (ip,port)
        self.udpsocket = socket.socket(type=socket.SOCK_DGRAM)
        self.event = threading.Event()
        self.interval = interval
        self.clients = {}

    def start(self):
        self.udpsocket.bind(self.addr)
        threading.Thread(target=self.revice,name=‘recive‘).start()

    def revice(self):
        while not self.event.is_set():
            lset = set()
            data,raddr = self.udpsocket.recvfrom(1024)
            logging.info(data)
            logging.info(raddr)

            current = datetime.datetime.now().timestamp()
            if data.strip() == b‘hb‘:
                self.clients[raddr]=current
                continue
            elif data.strip() == b‘quit‘:  #有可能发出来的数据不在clients。
                self.clients.pop(raddr,None)
                logging.info(‘{}leaving‘.format(raddr))
                continue
            self.clients[raddr] = current
            
            message = ‘{}form{}{}‘.format(data.decode(),*raddr)
            
            
            for c ,stamp in self.clients.items():
                if current - stamp >self.interval:
                    lset.add(c)
                else:
                    self.udpsocket.sendto(message.encode(), raddr)
            
            for c in lset:
                self.clients.pop(c)

    def stop(self):
        self.event.set()
        self.udpsocket.close()

def main():

    cus = ChatUdpServer()
    cus.start()

    while True:
        cmd = input(‘>>>>‘)
        if cmd == ‘quit‘:
            cus.stop()
            break
        logging.info(threading.enumerate())

if __name__ == ‘__main__‘:
    main()

正在迭代字典的时候不能进行pop。。

将其添加到set中，之后再进行pop。

Udp协议应用：

是无连接协议，基于以下假设：网络足够好 消息不会丢包，包不会乱序。

但是，即使在局域网，也不能保证不丢包，而且包到达不一定有序。

应用场景在视频、音频传输，一般来说，丢些包，问题不大，最多丢图像，听不清话语，可以重新发话语来解决，海量采集数据，例如传感器发来的数据，丢十几，几百条没有太大问题，DNS协议，数据内容小，一个包能 查询到结果，不存在乱序，丢包，重新请求解析。

Udp性能优于tcp，但是可靠性场所适用于tcp。

Udp广域网。

二、Socketserver

Socket编程过于底层，Python中对api进行封装的就是socketserver模块，是网络编程框架，便于企业快速开发；

类的继承关系

Socketserver简化了网络服务器的编写。

有四个同步类：TCPserver，UDPserver，Unixstreamserver，Unixdatagramserver

2个Mixin类：ForkingMixin和threadingMixin类，用来支持异步

Class forKingUDPserver（forKingMixin，UDPserver）：pass

Class forKingTCPserver（forKingMixin，TCPPserver）：pass

Class ThreadingUDPserver（ThreadingMixin，UDPserver）：pass

Class ThreadingTCPserver（ThreadingMixin，TCPserver）：pass

class BaseServer:
        def __init__(self, server_address, RequestHandlerClass):
         """Constructor.  May be extended, do not override."""
         self.server_address = server_address
         self.RequestHandlerClass = RequestHandlerClass
         self.__is_shut_down = threading.Event()
         self.__shutdown_request = False
        def finish_request(self, request, client_address):
         """Finish one request by instantiating RequestHandlerClass."""
         self.RequestHandlerClass(request, client_address, self)

baserequesthandler类：

他是和用户连接的用户请求处理类的基类，定义为baserequesthandler（request，client_address,server)

服务器端server实例接受用户的请求偶，最后会实例化这个类。

被初始化以后，送入三个构造参数，request，client_address,server 本身。

以后就可以在baserequesthandler类的实例上使用以下属性：

Self.request是和客户端的连接的socket对象，

Self.server是TCPserver本身

Self.client_address是客户端地址。

这个类在初始化的过程中，会依次调用3个方法，子类可以覆盖这些方法

class BaseRequestHandler:

    """Base class for request handler classes.

    This class is instantiated for each request to be handled.  The
    constructor sets the instance variables request, client_address
    and server, and then calls the handle() method.  To implement a
    specific service, all you need to do is to derive a class which
    defines a handle() method.

    The handle() method can find the request as self.request, the
    client address as self.client_address, and the server (in case it
    needs access to per-server information) as self.server.  Since a
    separate instance is created for each request, the handle() method
    can define other arbitrary instance variables.

    """

    def __init__(self, request, client_address, server):
        self.request = request
        self.client_address = client_address
        self.server = server
        self.setup()
        try:
            self.handle()
        finally:
            self.finish()

    def setup(self):
        pass

    def handle(self):
        pass

    def finish(self):
        pass
import threading
import socketserver

class Myhandler(socketserver.BaseRequestHandler):
    def handle(self):
        print(‘--------‘)
        print(self.server)
        print(self.request)
        print(self.client_address)
        print(self.__dict__)
        print(self.server.__dict__)

        print(threading.enumerate())
        print(threading.current_thread())

addr = (‘127.0.0.1‘,8080)
server = socketserver.ThreadingTCPServer(addr,Myhandler)

server.serve_forever()
import threading
import socketserver
import logging

FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘
logging.basicConfig(format=FORMAT,level=logging.INFO)

class Myhandler(socketserver.BaseRequestHandler):
    def handle(self):
        print(‘--------‘)
        print(self.server)
        print(self.request)
        print(self.client_address)
        print(self.__dict__)
        print(self.server.__dict__)

        print(threading.enumerate())
        print(threading.current_thread())
        for i in range(2):
            data = self.request.recv(1024)
            logging.info(data)

addr = (‘127.0.0.1‘,8080)
server = socketserver.ThreadingTCPServer(addr,Myhandler)

server.serve_forever()

类命名：

编程接口：

Socketserver.baseserver(server_address,RequestHandlerclass)

需要提供服务器绑定的地址信息，和用于请求处理请求的requesthandlerclass类。

Requesthandlerclass类必须是baserequesthandler类的子类，在baseserver中代码如下：

创建、传端口、handler。

ThreadingTCPServer。多线程，异步的，同时处理多个连接,

TCPServer  TCP的，串行的。同步的，一个处理完毕后，才能处理下一个。只有主线程。

创建服务器需要几个步骤：

1）从baseRequestHandler类派生出子类，并覆盖其handler()方法来创建请求处理程序类，此方法将处理传入处理。

2）实例化一个服务器类，传参服务器的地址和请求处理类。

3）调用服务器实例的handle_request()或server_forever()方法。

4）调用server_close()关闭套接字。

实现echoserver

import threading
import socketserver
import logging
import sys

FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘
logging.basicConfig(format=FORMAT,level=logging.INFO)

class EchoHandler(socketserver.BaseRequestHandler):
    clients = {}

    def setup(self):
        self.event = threading.Event()
        self.clients[self.client_address] = self.request

    def finish(self):
        self.event.set()

    def handle(self):
        while not self.event.is_set():
            data = self.request.recv(1024)
            logging.info(data)
            if data == b‘‘ or data ==‘quit‘:
                break
            msg = ‘{}‘.format(data.decode())
            for c in self.clients.values():
                c.send(msg.encode())

addr = (‘127.0.0.1‘,8080)
server = socketserver.ThreadingTCPServer(addr,EchoHandler)

# server.serve_forever()
t = threading.Thread(target=server.serve_forever,name=‘encho‘)
t.start()

if __name__ == ‘__main__‘:

    try:
        while True:
            cmd = input(‘>>>‘)
            if cmd.strip() == ‘quit‘:
                server.server_close()
                break
            logging.info(threading.enumerate())
    except Exception as e:
        logging.info(e)

    finally:
        print(‘exit‘)
        sys.exit(0)

解决客户端主动断开连接服务器端报错的方式：客户端主动断开，会导致recv方法会立即返回一个空bytes，并没有同事抛出异常，当循环到recv这一句的时候就会抛出异常，所以，可以通过判断data数据是否为空客户端是否断开。

总结：

为每一个连接提供requesthandlerclass类实例，依次调用setup、handler、finish方法，且使用了try..finally结构，保证finish方法一定被调用、这些方法一次执行完毕，如果想维持这个连接和客户端通信，就需要在handler函数中循环。

所持socketserver模块提供不同的类，但是编程接口一样的，即使是多进程、多线程的类也是一样，大大减少了编程的难度。

原文地址：https://www.cnblogs.com/wangchunli-blogs/p/9949903.html

时间： 2024-10-05 12:26:25

Python中socket编程的相关文章

Python 3 socket编程

Python 3 socket编程 一 客户端/服务器架构 互联网中处处是C/S架构 1.C/S结构,即Client/Server(客户端/服务器)结构 2.在互联网中处处可见c/s架构 比如说浏览器,在线视频,各种社交软件. C/S架构与socket的关系: 我们学习socket就是为了c/s架构的开发 学习socket一定要先学习互联网协议: 1.如何基于socket编程,来开发一款自己的C/S架构软件 2..C/S架构的软件(软件属于应用层)是基于网络进行通信的 3.网络的核心即一堆协议,

【python】socket编程常量错误问题-1 &#39;AF_INET&#39;错误

1 2 3 4 5 6 7 8 9 # -*- coding: utf-8 -*- import socket print "Creating socket" s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  print "Done!" print "Connecting to remote host..." s.connect(("www.baidu.com", 8

Python 的 Socket 编程教程

这是用来快速学习 Python Socket 套接字编程的指南和教程.Python 的 Socket 编程跟 C 语言很像. Python 官方关于 Socket 的函数请看 http://docs.python.org/library/socket.html 基本上,Socket 是任何一种计算机网络通讯中最基础的内容.例如当你在浏览器地址栏中输入 www.oschina.net 时,你会打开一个套接字,然后连接到 www.oschina.net 并读取响应的页面然后然后显示出来.而其他一些聊

Python异步Socket编程

异步网络据说能极大的提高网络server的连接速度,所以打算写一个专题,来学习和了解异步网络.因为Python有个非常出名的异步Lib:Twisted,所以就用Python来完成. OK,首先写一个pythone socket的server段,对开放三个端口:10000,10001,10002.krondo的例子中是每个server绑定一个端口,测试的时候需要分别开3个shell,分别运行.这太麻烦了,就分别用三个Thread来运行这些services. Java代码   import optp

Python基础-socket编程

一.网络编程 自从互联网诞生以来,现在基本上所有的程序都是网络程序,很少有单机版的程序了. 计算机网络就是把各个计算机连接到一起,让网络中的计算机可以互相通信.网络编程就是如何在程序中实现两台计算机的通信. 举个例子,当你使用浏览器访问新浪网时,你的计算机就和新浪的某台服务器通过互联网连接起来了,然后,新浪的服务器把网页内容作为数据通过互联网传输到你的电脑上. 由于你的电脑上可能不止浏览器,还有QQ.Skype.Dropbox.邮件客户端等,不同的程序连接的别的计算机也会不同,所以,更确切地说,

Python中socket初次尝试

算了,选择了Python就一路走下去,管对还是错,既然选择了前方,就不要顾风雨兼程,今天看了Python的socket的编程,真实遇到了各种问题,防火墙,error 10054 ,10049 ,自己就在百度上各种搜索,最终还是出来了,bug调出来的那感觉只有自己最清楚.这些都是自己socket的时候,一些笔记: 1  .netstat -no 这个命令是察看端口的,并且可以通过pid察看是哪些程序在用这些端口! 2  在Python中或其它语言中,利用Socket编写服务器和客户端通信程序,经常

python之socket编程

一.概述 socket通常也称作"套接字",用于描述IP地址和端口,是一个通信链的句柄,应用程序通常通过"套接字"向网络发出请求或者应答网络请求. socket起源于Unix,而Unix/Linux基本哲学之一就是"一切皆文件",对于文件用[打开][读写][关闭]模式来操作.socket就是该模式的一个实现,socket即是一种特殊的文件,一些socket函数就是对其进行的操作(读/写IO.打开.关闭) socket和file的区别: file模

Python 006- python socket编程详细介绍

转自https://blog.csdn.net/rebelqsp/article/details/22109925 Python 提供了两个基本的 socket 模块. 第一个是 Socket,它提供了标准的 BSD Sockets API. 第二个是 SocketServer, 它提供了服务器中心类,可以简化网络服务器的开发. 下面讲的是Socket模块功能 1.Socket 类型 套接字格式: socket(family,type[,protocal]) 使用给定的地址族.套接字类型.协议编

python中socket模块

一.初识socket      socket 是网络连接端点,每个socket都被绑定到一个特定的IP地址和端口.IP地址是一个由4个数组成的序列,这4个数均是范围 0~255中的值(例如,220,176,36,76):端口数值的取值范围是0~65535.端口数小于1024的都是为众所周知的网络服务所保留的 (例如Web服务使用的80端口):最大的保留数被存储在socket模块的IPPORT_RESERVED变量中.你也可以为你的程序使用另外的端口数 值. 不是所有的IP地址都对世界的其它地方可