Python网络编程基础与进阶指南

需积分: 16 56 浏览量更新于2024-08-02 收藏 309KB PDF 举报

《Python网络编程》是一本由Sebastian V. Tiponut撰写的教材，出自于蒂米什瓦拉理工大学的技术文档，发行于2001年7月16日，专注于使用Python进行网络编程。该书共分为五个主要部分，深入讲解了Python在网络编程中的应用。 **第一部分：介绍** 本章介绍了网络编程的基础概念，让读者对Python在互联网通信中的角色有个初步了解，可能包括Python的优势、其在处理网络请求和响应方面的灵活性以及与其他编程语言的比较。 **第二部分：基本套接字使用** - **创建套接字**：这部分讲解如何在Python中创建套接字对象，这是所有网络通信的基础。 - **连接套接字与数据传输**：涉及客户端-服务器模型，如何通过套接字进行数据发送和接收。 - **绑定名称到套接字**：展示了如何给套接字分配一个可识别的地址或端口号。 - **监听和接受连接**：介绍如何设置服务器来等待客户端连接，并处理连接请求。 - **UDP套接字**：探讨无连接的用户数据报协议（UDP）的应用，适合实时性要求高的场景。 - **关闭套接字**：讨论了套接字在通信结束后如何正确关闭以释放资源。 - **socket模块的函数**：详细解释了socket模块提供的各种功能，包括解析器库函数、服务相关函数和其他辅助工具。 **第三部分：基本网络结构设计** - **设计TCP服务器**：涵盖了服务器架构的设计，如服务器如何监听、处理和管理客户端连接。 - **TCP客户端**：介绍客户端如何连接到服务器，执行请求并获取响应。 - **数据报应用模型**：讨论如何设计和实现基于UDP的简单应用程序，比如消息传递系统。 **第四部分：服务器的高级主题** - **构建纯净环境**：可能涉及到隔离和安全性，确保服务器的稳定运行。 - **多连接处理**： - **线程服务器**：使用多线程技术来并发处理多个连接。 - **select函数**：讲解事件驱动编程，提高服务器性能。 - **fork服务器**：探讨进程复制技术在并发处理中的应用。 - **类和面向对象编程**：如何利用面向对象设计模式优化服务器代码结构。 **第五部分：HTTP协议及CGI** - **HTTP协议**：深入解释HTTP工作原理，作为Web编程的核心。 - **CGI模块**：讲解如何使用Python编写CGI脚本来处理HTTP请求，实现动态网页内容生成。《Python网络编程》是一本实用的教程，涵盖了从基础套接字操作到高级网络编程技巧，特别是针对HTTP和CGI的实战应用，适合希望学习和提升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页未读，继续阅读

kennypku

粉丝: 1
资源: 36

Python网络编程基础与进阶指南

Python网络编程基础与进阶

Python 3网络编程实战指南

Beej's Guide to Network Programming：轻松学习网络编程

Learning Python Network Programming.pdf 0分

Packt.Python Network Programming Cookbook.2014.pdf

Python Network Programming Cookbook.pdf 0分

Learning.Python.Network.Programming.1784396001

Packt.Python.Network.Programming.Cookbook.2nd.Edition.2017

Prentice.Hall.Rapid.GUI.Programming.with.Python.and.Qt.the.definitive.guide.to.PyQt.programming.2008.pdf

Beej's Guide to Network Programming.pdf

最新资源