Python网络编程基础与进阶

4星 · 超过85%的资源需积分: 50 51 浏览量更新于2024-07-31 4 收藏 309KB PDF 举报

"Python网络编程.pdf" Python网络编程是利用Python语言进行网络通信和数据交换的技术领域。本书由Sebastian V. Tiponut在Technical University Timisoara编写，介绍了如何使用Python进行网络编程的基础和高级概念。 1. **介绍** 这一章节为读者提供了网络编程的基本概念，并解释了Python在网络编程中的应用，帮助初学者理解网络通信的基础原理。 2. **基本socket使用** - **创建socket**：在Python中，使用socket模块可以创建一个套接字对象，这是进行网络通信的基础。 - **连接socket和数据传输**：套接字对象可以用来连接到远程服务器并发送/接收数据。 - **绑定名称到socket**：通过调用bind()函数，可以将套接字与特定的IP地址和端口号关联。 - **监听与接受连接**：服务器端的socket使用listen()函数监听连接请求，然后用accept()函数接收客户端的连接。 - **UDP sockets**：与TCP（传输控制协议）不同，UDP（用户数据报协议）是无连接的，适用于对实时性要求高的场景。 - **关闭socket**：完成通信后，应使用close()方法关闭套接字。 - **使用socket模块提供的函数**：包括基于解析器库的函数、服务相关的函数和一些杂项函数，这些扩展了基本的socket功能。 3. **基本网络结构设计** - **设计TCP服务器**：讲解如何构建一个能够接收和处理客户端连接的TCP服务器。 - **TCP客户端**：介绍客户端如何连接到服务器并发起通信请求。 - **建模数据报应用程序**：讨论基于UDP的应用程序设计，它们通常用于一次发送小量数据且不需要保持连接的情况。 4. **高级服务器主题** - **构建纯净环境**：确保服务器程序在多线程或多进程环境中运行的稳定性和效率。 - **处理多个连接** - **线程服务器**：使用多线程来并发处理多个客户端连接。 - **使用select**：select模块允许服务器监控多个套接字，以便在有数据可读时进行响应，提高并发处理能力。 - **fork服务器**：通过进程复制（fork）来处理每个新的客户端连接，提供另一种并发策略。 - **处理类**：介绍如何使用面向对象编程来组织和管理服务器代码，包括简单的连接对象和设计模式的应用。 5. **HTTP协议** - **CGI模块**：Python的CGI模块用于创建Web服务器上的CGI（通用网关接口）脚本，使得服务器可以处理动态内容。 - **构建简单的CGI脚本**：演示如何编写一个基本的CGI脚本来响应HTTP请求。 - **使用CGI**：深入讨论如何使用CGI处理表单数据和其他HTTP请求。这本书涵盖了Python网络编程的广泛主题，从基础的socket操作到高级的服务器设计和HTTP协议处理，是学习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页未读，继续阅读

warmb123

粉丝: 21
资源: 73

Python网络编程基础与进阶

PYTHON网络编程基础.pdf

python网络编程.pdf

Python网络编程基础.pdf

Python高级编程.pdf

Python高级编程 .pdf

Python 核心编程.pdf

python核心编程.pdf

基于Python混合编程.pdf

面向Arcgis的python脚本编程.pdf

面向ArcGIS的Python脚本编程.pdf

最新资源