Python网络编程入门与进阶

需积分: 19 10 浏览量更新于2024-08-01 收藏 309KB PDF 举报

"Python网络编程书籍，英文版，由Sebastian V. Tiponut撰写，技术大学蒂米索阿拉发布，介绍了Python网络编程的基础到高级主题，包括socket使用、服务器设计、多线程与多进程处理、HTTP协议及CGI模块等。" Python网络编程是一个广泛的领域，涵盖了许多用于构建网络应用程序的技术。这本书由Sebastian V. Tiponut编写的《Python Network Programming》提供了深入的见解和实践指导，旨在帮助读者理解和应用Python在这一领域的知识。 1. **基础Socket使用**：Socket是网络通信的基本组件，Python的socket模块提供了创建和管理socket的接口。创建一个socket，连接到远程服务器并进行数据传输是网络编程的基础。书中介绍了如何绑定一个名字到socket，监听和接受连接，以及如何处理UDP（用户数据报协议）socket。 2. **网络结构设计**：书中的第3章讨论了基本的网络结构设计，包括TCP（传输控制协议）服务器和客户端的设计。TCP服务器负责接收和响应客户端的连接请求，而TCP客户端则发起这些连接。此外，还涉及了数据报应用程序的建模，这是UDP协议的特点。 3. **高级服务器主题**：在高级话题中，作者探讨了如何构建一个纯净的服务器环境，以处理多个并发连接。这包括使用线程、select函数以及fork方法来管理多个客户端连接。线程服务器允许多个任务同时执行，而select和fork则提供了一种更有效的方法来处理并发，避免阻塞。 4. **类和设计模式**：在处理多个连接时，使用类和设计模式可以提高代码的可读性和可维护性。书中有简单的连接对象示例，并展示了如何将设计模式应用于网络编程场景。 5. **HTTP协议与CGI模块**：HTTP是互联网上最广泛使用的协议，书中的第5章介绍了HTTP协议，特别是与Python相关的部分。CGI（通用网关接口）模块允许Python脚本处理HTTP请求。书中展示了如何编写简单的CGI脚本以及如何利用CGI模块来增强Web服务。《Python Network Programming》是一本全面的指南，适合想要深入理解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页未读，继续阅读

skiplow

粉丝: 1
资源: 6

Python网络编程入门与进阶

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

python网络编程基础

PYTHON网络编程基础.pdf

python网络编程

Python 网络编程 python网络编程 socket

python 网络编程

Python网络编程 Python套接字编程

Python网络编程基础

PYTHON网络编程基础

python网络编程源码

最新资源