Python网络编程基础与进阶实践

python

网络编程

需积分: 0 64 浏览量更新于2024-07-24 1 收藏 309KB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

本资源主要聚焦于"Python网络编程"，它涵盖了Python编程语言在网络通信中的应用和基础原理。作者Sebastian V. Tiponut，来自Technical University Timisoara，提供了一个详细的指南，发布日期为2001年7月16日，版本为0.00。章节一"Introduction" 引入了网络编程的基本概念，为后续内容打下基础，让读者了解在Python中如何处理网络连接和数据传输。第二章"Basic socket usage"深入讲解了Python的套接字（socket）编程。这部分内容包括： 1. **创建套接字**：介绍如何使用socket模块创建一个基本的网络连接点。 2. **连接与数据传输**：阐述如何连接到服务器并进行双向数据交换，如发送和接收数据。 3. **绑定名称到套接字**：说明如何给套接字指定一个地址，以便其他设备能够找到。 4. **监听和接受连接**：讲解如何设置一个服务器，监听并管理来自客户端的连接请求。 5. **UDP sockets**：讨论用户数据报协议（UDP），一种无连接的通信方式。 6. **关闭套接字**：强调正确关闭套接字以释放系统资源的重要性。 7. **socket模块函数**：介绍了socket模块提供的各种实用函数，如解析器库、服务相关函数和杂项功能。第三章"Basic network structures design"着重于网络架构设计，涉及： - **设计TCP服务器**：详细说明如何设计能够处理多个请求的TCP服务器。 - **TCP客户端**：探讨客户端如何与服务器交互，包括连接建立和数据交换。 - **数据包应用程序**：讨论如何使用数据报（datagram）模式来实现特定的应用场景。第四章"Advanced topics on servers"探讨更高级的主题，包括： - **构建纯净环境**：可能涉及服务器的安全性和隔离性。 - **处理多连接**：介绍了线程、select和fork方法来并发处理多个客户端连接。 - **使用类和设计模式**：将面向对象编程原则应用于服务器设计，提高代码组织和可维护性。第五章"HTTP protocol"则转向了网络协议层面，特别是与Web相关的HTTP协议： - **CGI模块**：解释如何利用Python编写CGI脚本来处理HTTP请求，如生成动态网页内容。 - **简单CGI脚本示例**：提供一个入门级的CGI脚本编写实例，帮助读者理解实际应用。总结起来，这份资源是Python网络编程的实用指南，从基础知识到进阶主题，涵盖了套接字编程、服务器设计、网络协议以及与HTTP相关的CGI技术，对于希望学习或提升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页未读，继续阅读

mxh_pl

粉丝: 0
资源: 1

Python网络编程基础与进阶实践

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

python网络编程基础

PYTHON网络编程基础.pdf

python网络编程教程pdf

python网络编程 pdf

学习python网络编程的有效方法

python网络编程第三版pdf

python网络编程的html协议

python网络编程库

python网络编程讲解

python网络编程实验

python网络编程终端验证

python 网络编程

Python网络编程基础

python网络编程课程设计

python网络编程和多线程——网络五子棋游戏

Python网络编程

学生信息管理系统python系统功能分析系统功能需求python网络编程期末大作业 设计

python网络编程调用recv函数完整接收数据

python网络编程linux 赵宏pdf通过爬虫获取天气数据实例

最新资源

学生信息管理系统python系统功能分析系统功能需求python网络编程期末大作业设计