Python网络编程：Socket接口与高级应用

需积分: 19 151 浏览量更新于2024-07-21 收藏 309KB PDF 举报

本资源主要介绍Python网络编程，由Sebastian V. Tiponut撰写，出自于蒂米什瓦拉理工大学的技术文档，发布日期为2001年7月16日。该文档详细探讨了Python如何利用Socket接口进行网络通信，覆盖了从基础概念到高级技术的广泛内容。第1章"Introduction"介绍了网络编程的基本概念，以及Python在其中的角色，强调了其灵活性和强大功能，适合初学者了解Python在网络开发中的应用基础。第2章"Basic socket usage"深入浅出地讲解了Socket的基本操作，包括： 1. 创建Socket：学习如何创建一个新的套接字对象，它是网络通信的起点。 2. 连接Socket与数据传输：展示了如何通过套接字进行连接，并进行数据的发送和接收。 3. 绑定Socket到地址：解释了如何将套接字绑定到特定的IP地址和端口。 4. 监听并接受连接：涵盖了服务器模式下，如何监听来自客户端的连接请求。 5. UDP sockets：简述用户数据报协议（UDP），无连接的、不可靠的通信方式。 6. 关闭Socket：阐述了释放资源的重要性，确保正确结束网络会话。 7. 使用socket模块的函数：展示了socket模块提供的各种实用功能，如解析器库函数、服务相关功能和其它辅助工具。第3章"Basic network structures design"探讨了网络应用程序的设计，包括： - 设计TCP服务器：讲解了服务器架构，以及如何设计处理多个客户端连接的方法。 - TCP客户端：介绍了客户端如何与服务器交互，以及数据包模型的应用。 - 数据报应用：讨论了无连接服务，如简单消息传递或实时通信。第4章"Advanced topics on servers"针对服务器开发的进阶主题展开： - 建立纯净环境：可能涉及部署和隔离服务器环境的相关技巧。 - 处理多连接：讲解了线程、select()和fork()等并发处理技术。 - 类的使用：如何将面向对象编程引入网络服务，包括简单的连接对象和设计模式的应用。 - 客户端高级特性：探讨更复杂的客户端行为和需求。第5章"HTTP protocol"专门研究HTTP协议及其在Python中的应用： - CGI模块：介绍如何使用Python编写和执行CGI脚本来处理HTTP请求，以及简单的CGI示例。这份文档提供了丰富的Python网络编程知识，不仅适合想要入门学习者，也对有一定经验的开发者深入了解Python在实际网络应用中的操作和设计提供了实用指导。通过阅读和实践，读者可以掌握如何利用Python进行高效、灵活的网络编程。

6 2 BASIC SOCKET USAGE

2.2 Connecting a socket and data transfer

A server from our point of view is a process which listen on a speciﬁed port. We may call

the association port, process as a service. When another process wants to meet the server or

use a speciﬁc service it must connect itself to the address and portnumber speciﬁed by the

server. This is done calling the socket method connect(address ), where address is a pair

(host, port) in the Internet domain and a pathname in the UNIX domain. When using

the Internet domain a connection is realized with the following code:

sock.connect((’localhost’, 8000))

while in UNIX domain,

sock.connect(’/tmp/sock’)

If the service is unavailable or the server don’t want to talk with the client process a socket.error-

(111, ’Connection refused’) is issued. Elsewhere, after the connection is established with the

desired server, data is sent and received with send(buffer [, flags ]) and recv(buffer [,

flags ]) methods. These methods accepts as mandatory parameter the size of the buﬀer in

bytes and some optional flags ; for a description about the meaning of the ﬂags consult the

UNIX man page for the corresponding function

2.3 Binding a name to socket

The socket, after creation, is nameless, though it have an associated descriptor. Before it can

be used it must be bind to a proper address since this is the only way a foreign process may

reference it. The bind(address ) method is used to “name” a socket. The meaning of the

address is explained above. Next call will bind a socket in the Internet domain with address

composed from hostname localhost and port number 8000 :

sock.bind((’localhost’, 8000))

Please take care when typing: indeed there are two pairs of parenthesis. Doing elsewhere

the interpreter will issue a TypeError. The purpose of the two pairs of parenthesis is simple:

address is a tuple containing a string and an integer. The hostname must be properly picked,

the best method is to use gethostname() routine in order to assure host independence and

portability

. Creating a socket in the UNIX domain use address as a single string, naming

a local path:

sock.bind(’/tmp/sock’)

This will create the ’/tmp/sock’ ﬁle (pipe) which will be used for communication between

the server and client processes. The user must have read/write permissions in that speciﬁc

directory where the socket is created and the ﬁle itself must be deleted once it’s no longer of

interest.

2.4 Listening and accepting connections

Once we have a socket with a proper name bound to it, next step is calling the listen(queue )

method. It instructs the socket to passively listen on port port . listen() take as parameter

Do “man recv(2)” or “man send(2)”.

Don’t bind a real hostname to a socket unless you do it for testing purposes only; if you do so the program

will run solely on that particular system whom hostname was bind to the socket.

2 BASIC SOCKET USAGE 7

an integer representing the maximum queued connection. This argument should be at least

1 and maximum, system-dependent, 5. Until now we have a socket with a proper bounded

address. When a connection request arrives, the server decide whether it will be accepted or

not. Accepting a connection is made through the accept() method. It takes no parameter

but it returns a tuple (clientsocket, address) where clientsocket is a new socket server

uses to communicate with the client and address is the client’s address. accept() normally

blocks until a connection is realized. This behavior can be overridden running the method in

a separate thread, collecting the new created socket descriptors in a list and process them in

order. Meantime, the server can do something else. The above mentioned methods are used

as follows:

sock.listen(5)

clisock, address = sock.accept()

The code instructs the socket on listening with a queue of ﬁve connections and accept all

incoming “calls”. As you can see, accept() returns a new socket that will be used in further

data exchanging. Using the chain bind-listen-accept we create TCP servers. Remember, a

TCP socket is connection-oriented; when a client wants to speak to a particular server it must

connect itself, wait until the server accepts the connection, exchange data then close. This

is modeling a phone call: the client dial the number, wait till the other side establish the

connection, speak then quit.

2.5 UDP sockets

We chose to deal with connectionless sockets separately because these are less common in

day to day client/server design. A datagram socket is characterized by a connectionless and

symmetric message exchange. Server and client exchange data packets not data streams,

packets ﬂowing between client and server separately. The UDP connection resemble the

postal system: each message is encapsulated in an envelope and received as a separate entity.

A large message may be split into multiple parts, each one delivered separately (not in the

same order, duplicated and so on). Is the receiver’s duty to assemble the message.

The server

have a bind() method used to append a proper name and port. There are

no listen() and accept() method, because the server is not listening and is not accepts

connection. Basically, we create a P.O.Box where is possible to receive messages from client

processes. Clients only send packets, data and address being included on each packet.

Data packets are send and received with the sendto(data, address ) and recvfrom(buf-

fer [, flags ]) methods. First method takes as parameters a string and the server address

as explained above in connect() and bind(). Because is speciﬁed the remote end of the

socket there is no need to connect it. The second method is similar to recv().

2.6 Closing the socket

After the socket is no longer used, it must be closed with close() method. When a user is no

more interested on any pending data a shutdown may be performed before closing the socket.

The method is shutdown(how ), where how is: 0 if no more incoming data will be accepted, 1

will disallow data sending and a value of 2 prevent both send and receive of data. Remember:

always close a socket after using it.

Which process is the server and which is the client is hard to predict at socket level, because of the

symmetrical connection.

剩余30页未读，继续阅读

qq_29478833

粉丝: 0
资源: 1

Python网络编程：Socket接口与高级应用

Python网络编程(Linux)_网络编程_python_linux网络编程_

python网络编程基础

PYTHON网络编程基础.pdf

python网络编程

Python 网络编程 python网络编程 socket

python 网络编程

python 网络编程和网络编程基础

Python网络编程 Python套接字编程

Python网络编程基础

PYTHON网络编程基础

最新资源