创建 Socket
首先要做的就是创建一个 Socket,socket 的 socket 函数可以实现,代码如下:
1 |
#Socket client example in python |
2 |
3 |
import socket #for sockets
|
4 |
5 |
#create an AF_INET, STREAM socket (TCP) |
6 |
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
7 |
8 |
print 'Socket Created'
|
函数 socket.socket 创建了一个 Socket,并返回 Socket 的描述符可用于其他 Socket 相关的函数。
上述代码使用了下面两个属性来创建 Socket:
地址簇 : AF_INET (IPv4)
类型: SOCK_STREAM (使用 TCP 传输控制协议)
错误处理
如果 socket 函数失败了,python 将抛出一个名为 socket.error 的异常,这个异常必须予以处理:
01 |
#handling errors in python socket programs |
02 |
03 |
import socket #for sockets
|
04 |
import sys #for exit
|
05 |
06 |
try :
|
07 |
#create an AF_INET, STREAM socket (TCP)
|
08 |
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
09 |
except socket.error, msg:
|
10 |
print 'Failed to create socket. Error code: ' + str (msg[ 0 ]) + ' , Error message : ' + msg[ 1 ]
|
11 |
sys.exit();
|
12 |
13 |
print 'Socket Created'
|
好了,假设你已经成功创建了 Socket,下一步该做什么呢?接下来我们将使用这个 Socket 来连接到服务器。
注意
与 SOCK_STREAM 相对应的其他类型是 SOCK_DGRAM 用于 UDP 通讯协议,UDP 通讯是非连接 Socket,在这篇文章中我们只讨论 SOCK_STREAM ,或者叫 TCP 。
连接到服务器
连接到服务器需要服务器地址和端口号,这里使用的是 www.oschina.net 和 80 端口。
首先获取远程主机的 IP 地址
连接到远程主机之前,我们需要知道它的 IP 地址,在 Python 中,获取 IP 地址是很简单的:
01 |
import socket #for sockets
|
02 |
import sys #for exit
|
03 |
04 |
try :
|
05 |
#create an AF_INET, STREAM socket (TCP)
|
06 |
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
07 |
except socket.error, msg:
|
08 |
print 'Failed to create socket. Error code: ' + str (msg[ 0 ]) + ' , Error message : ' + msg[ 1 ]
|
09 |
sys.exit();
|
10 |
11 |
print 'Socket Created'
|
12 |
13 |
host = 'www.oschina.net'
|
14 |
15 |
try :
|
16 |
remote_ip = socket.gethostbyname( host )
|
17 |
18 |
except socket.gaierror:
|
19 |
#could not resolve
|
20 |
print 'Hostname could not be resolved. Exiting'
|
21 |
sys.exit()
|
22 |
|
23 |
print 'Ip address of ' + host + ' is ' + remote_ip
|
我们已经有 IP 地址了,接下来需要指定要连接的端口。
代码:
01 |
import socket #for sockets
|
02 |
import sys #for exit
|
03 |
04 |
try :
|
05 |
#create an AF_INET, STREAM socket (TCP)
|
06 |
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
07 |
except socket.error, msg:
|
08 |
print 'Failed to create socket. Error code: ' + str (msg[ 0 ]) + ' , Error message : ' + msg[ 1 ]
|
09 |
sys.exit();
|
10 |
11 |
print 'Socket Created'
|
12 |
13 |
host = 'www.oschina.net'
|
14 |
port = 80
|
15 |
16 |
try :
|
17 |
remote_ip = socket.gethostbyname( host )
|
18 |
19 |
except socket.gaierror:
|
20 |
#could not resolve
|
21 |
print 'Hostname could not be resolved. Exiting'
|
22 |
sys.exit()
|
23 |
|
24 |
print 'Ip address of ' + host + ' is ' + remote_ip
|
25 |
26 |
#Connect to remote server |
27 |
s.connect((remote_ip , port)) |
28 |
29 |
print 'Socket Connected to ' + host + ' on ip ' + remote_ip
|
现在运行程序
1 |
$ python client.py |
2 |
Socket Created |
3 |
Ip address of www.oschina.net is 61.145.122.155 |
4 |
Socket Connected to www.oschina.net on ip 61.145.122.155 |
这段程序创建了一个 Socket 并进行连接,试试使用其他一些不存在的端口(如81)会是怎样?这个逻辑相当于构建了一个端口扫描器。
已经连接上了,接下来就是往服务器上发送数据。
免费提示
使用 SOCK_STREAM/TCP 套接字才有“连接”的概念。连接意味着可靠的数据流通讯机制,可以同时有多个数据流。可以想象成一个数据互不干扰的管道。另外一个重要的提示是:数据包的发送和接收是有顺序的。
其他一些 Socket 如 UDP、ICMP 和 ARP 没有“连接”的概念,它们是无连接通讯,意味着你可从任何人或者给任何人发送和接收数据包。
发送数据
sendall 函数用于简单的发送数据,我们来向 oschina 发送一些数据:
01 |
import socket #for sockets
|
02 |
import sys #for exit
|
03 |
04 |
try :
|
05 |
#create an AF_INET, STREAM socket (TCP)
|
06 |
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
07 |
except socket.error, msg:
|
08 |
print 'Failed to create socket. Error code: ' + str (msg[ 0 ]) + ' , Error message : ' + msg[ 1 ]
|
09 |
sys.exit();
|
10 |
11 |
print 'Socket Created'
|
12 |
13 |
host = 'www.oschina.net'
|
14 |
port = 80
|
15 |
16 |
try :
|
17 |
remote_ip = socket.gethostbyname( host )
|
18 |
19 |
except socket.gaierror:
|
20 |
#could not resolve
|
21 |
print 'Hostname could not be resolved. Exiting'
|
22 |
sys.exit()
|
23 |
|
24 |
print 'Ip address of ' + host + ' is ' + remote_ip
|
25 |
26 |
#Connect to remote server |
27 |
s.connect((remote_ip , port)) |
28 |
29 |
print 'Socket Connected to ' + host + ' on ip ' + remote_ip
|
30 |
31 |
#Send some data to remote server |
32 |
message = "GET / HTTP/1.1\r\n\r\n"
|
33 |
34 |
try :
|
35 |
#Set the whole string
|
36 |
s.sendall(message)
|
37 |
except socket.error:
|
38 |
#Send failed
|
39 |
print 'Send failed'
|
40 |
sys.exit()
|
41 |
42 |
print 'Message send successfully'
|
上述例子中,首先连接到目标服务器,然后发送字符串数据 "GET / HTTP/1.1\r\n\r\n" ,这是一个 HTTP 协议的命令,用来获取网站首页的内容。
接下来需要读取服务器返回的数据。
接收数据
recv 函数用于从 socket 接收数据:
01 |
#Socket client example in python |
02 |
03 |
import socket #for sockets
|
04 |
import sys #for exit
|
05 |
06 |
#create an INET, STREAMing socket |
07 |
try :
|
08 |
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
09 |
except socket.error:
|
10 |
print 'Failed to create socket'
|
11 |
sys.exit()
|
12 |
|
13 |
print 'Socket Created'
|
14 |
15 |
host = 'oschina.net' ;
|
16 |
port = 80 ;
|
17 |
18 |
try :
|
19 |
remote_ip = socket.gethostbyname( host )
|
20 |
21 |
except socket.gaierror:
|
22 |
#could not resolve
|
23 |
print 'Hostname could not be resolved. Exiting'
|
24 |
sys.exit()
|
25 |
26 |
#Connect to remote server |
27 |
s.connect((remote_ip , port)) |
28 |
29 |
print 'Socket Connected to ' + host + ' on ip ' + remote_ip
|
30 |
31 |
#Send some data to remote server |
32 |
message = "GET / HTTP/1.1\r\nHost: oschina.net\r\n\r\n"
|
33 |
34 |
try :
|
35 |
#Set the whole string
|
36 |
s.sendall(message)
|
37 |
except socket.error:
|
38 |
#Send failed
|
39 |
print 'Send failed'
|
40 |
sys.exit()
|
41 |
42 |
print 'Message send successfully'
|
43 |
44 |
#Now receive data |
45 |
reply = s.recv( 4096 )
|
46 |
47 |
print reply
|
下面是上述程序执行的结果:
01 |
$ python client.py |
02 |
Socket Created |
03 |
Ip address of oschina.net is 61.145.122. |
04 |
Socket Connected to oschina.net on ip 61.145.122.155 |
05 |
Message send successfully |
06 |
HTTP/1.1 301 Moved Permanently |
07 |
Server: nginx |
08 |
Date: Wed, 24 Oct 2012 13:26:46 GMT |
09 |
Content-Type: text/html |
10 |
Content-Length: 178 |
11 |
Connection: keep-alive |
12 |
Keep-Alive: timeout=20 |
13 |
Location: http://www.oschina.net/ |
oschina.net 回应了我们所请求的 URL 的内容,很简单。数据接收完了,可以关闭 Socket 了。
关闭 socket
close 函数用于关闭 Socket:
1 |
s.close() |
这就是了。
让我们回顾一下
上述的示例中我们学到了如何:
1. 创建 Socket
2. 连接到远程服务器
3. 发送数据
4. 接收回应
当你用浏览器打开 www.oschina.net 时,其过程也是一样。包含两种类型,分别是客户端和服务器,客户端连接到服务器并读取数据,服务器使用 Socket 接收进入的连接并提供数据。因此在这里 www.oschina.net 是服务器端,而你的浏览器是客户端。
接下来我们开始在服务器端做点编码。
服务器端编程
服务器端编程主要包括下面几步:
1. 打开 socket
2. 绑定到一个地址和端口
3. 侦听进来的连接
4. 接受连接
5. 读写数据
我们已经学习过如何打开 Socket 了,下面是绑定到指定的地址和端口上。
绑定 Socket
bind 函数用于将 Socket 绑定到一个特定的地址和端口,它需要一个类似 connect 函数所需的 sockaddr_in 结构体。
示例代码:
01 |
import socket
|
02 |
import sys
|
03 |
04 |
HOST = '' # Symbolic name meaning all available interfaces
|
05 |
PORT = 8888 # Arbitrary non-privileged port
|
06 |
07 |
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
08 |
print 'Socket created'
|
09 |
10 |
try :
|
11 |
s.bind((HOST, PORT))
|
12 |
except socket.error , msg:
|
13 |
print 'Bind failed. Error Code : ' + str (msg[ 0 ]) + ' Message ' + msg[ 1 ]
|
14 |
sys.exit()
|
15 |
|
16 |
print 'Socket bind complete'
|
绑定完成后,就需要让 Socket 开始侦听连接。很显然,你不能将两个不同的 Socket 绑定到同一个端口之上。
连接侦听
绑定 Socket 之后就可以开始侦听连接,我们需要将 Socket 变成侦听模式。socket 的 listen 函数用于实现侦听模式:
1 |
s.listen(10) |
2 |
print 'Socket now listening'
|
listen 函数所需的参数成为 backlog,用来控制程序忙时可保持等待状态的连接数。这里我们传递的是 10,意味着如果已经有 10 个连接在等待处理,那么第 11 个连接将会被拒绝。当检查了 socket_accept 后这个会更加清晰。
接受连接
示例代码:
01 |
import socket
|
02 |
import sys
|
03 |
04 |
HOST = '' # Symbolic name meaning all available interfaces
|
05 |
PORT = 8888 # Arbitrary non-privileged port
|
06 |
07 |
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
08 |
print 'Socket created'
|
09 |
10 |
try :
|
11 |
s.bind((HOST, PORT))
|
12 |
except socket.error , msg:
|
13 |
print 'Bind failed. Error Code : ' + str (msg[ 0 ]) + ' Message ' + msg[ 1 ]
|
14 |
sys.exit()
|
15 |
|
16 |
print 'Socket bind complete'
|
17 |
18 |
s.listen( 10 )
|
19 |
print 'Socket now listening'
|
20 |
21 |
#wait to accept a connection - blocking call |
22 |
conn, addr = s.accept()
|
23 |
24 |
#display client information |
25 |
print 'Connected with ' + addr[ 0 ] + ':' + str (addr[ 1 ])
|
输出
运行该程序将会显示:
1 |
$ python server.py |
2 |
Socket created |
3 |
Socket bind complete |
4 |
Socket now listening |
现在这个程序开始等待连接进入,端口是 8888,请不要关闭这个程序,我们来通过 telnet 程序来进行测试。
打开命令行窗口并输入:
1 |
$ telnet localhost 8888 |
2 |
3 |
It will immediately show |
4 |
$ telnet localhost 8888 |
5 |
Trying 127.0.0.1... |
6 |
Connected to localhost. |
7 |
Escape character is '^]' .
|
8 |
Connection closed by foreign host. |
而服务器端窗口显示的是:
1 |
$ python server.py |
2 |
Socket created |
3 |
Socket bind complete |
4 |
Socket now listening |
5 |
Connected with 127.0.0.1:59954 |
我们可看到客户端已经成功连接到服务器。
上面例子我们接收到连接并立即关闭,这样的程序没什么实际的价值,连接建立后一般会有大量的事情需要处理,因此让我们来给客户端做出点回应吧。
sendall 函数可通过 Socket 给客户端发送数据:
01 |
import socket
|
02 |
import sys
|
03 |
04 |
HOST = '' # Symbolic name meaning all available interfaces
|
05 |
PORT = 8888 # Arbitrary non-privileged port
|
06 |
07 |
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
08 |
print 'Socket created'
|
09 |
10 |
try :
|
11 |
s.bind((HOST, PORT))
|
12 |
except socket.error , msg:
|
13 |
print 'Bind failed. Error Code : ' + str (msg[ 0 ]) + ' Message ' + msg[ 1 ]
|
14 |
sys.exit()
|
15 |
|
16 |
print 'Socket bind complete'
|
17 |
18 |
s.listen( 10 )
|
19 |
print 'Socket now listening'
|
20 |
21 |
#wait to accept a connection - blocking call |
22 |
conn, addr = s.accept()
|
23 |
24 |
print 'Connected with ' + addr[ 0 ] + ':' + str (addr[ 1 ])
|
25 |
26 |
#now keep talking with the client |
27 |
data = conn.recv( 1024 )
|
28 |
conn.sendall(data) |
29 |
30 |
conn.close() |
31 |
s.close() |
继续运行上述代码,然后打开另外一个命令行窗口输入下面命令:
1 |
$ telnet localhost 8888 |
2 |
Trying 127.0.0.1... |
3 |
Connected to localhost. |
4 |
Escape character is '^]' .
|
5 |
happy |
6 |
happy |
7 |
Connection closed by foreign host. |
可看到客户端接收到来自服务器端的回应内容。
上面的例子还是一样,服务器端回应后就立即退出了。而一些真正的服务器像 www.oschina.net 是一直在运行的,时刻接受连接请求。
也就是说服务器端应该一直处于运行状态,否则就不能成为“服务”,因此我们要让服务器端一直运行,最简单的方法就是把 accept 方法放在一个循环内。
一直在运行的服务器
对上述代码稍作改动:
01 |
import socket
|
02 |
import sys
|
03 |
04 |
HOST = '' # Symbolic name meaning all available interfaces
|
05 |
PORT = 8888 # Arbitrary non-privileged port
|
06 |
07 |
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
08 |
print 'Socket created'
|
09 |
10 |
try :
|
11 |
s.bind((HOST, PORT))
|
12 |
except socket.error , msg:
|
13 |
print 'Bind failed. Error Code : ' + str (msg[ 0 ]) + ' Message ' + msg[ 1 ]
|
14 |
sys.exit()
|
15 |
|
16 |
print 'Socket bind complete'
|
17 |
18 |
s.listen( 10 )
|
19 |
print 'Socket now listening'
|
20 |
21 |
#now keep talking with the client |
22 |
while 1 :
|
23 |
#wait to accept a connection - blocking call
|
24 |
conn, addr = s.accept()
|
25 |
print 'Connected with ' + addr[ 0 ] + ':' + str (addr[ 1 ])
|
26 |
|
27 |
data = conn.recv( 1024 )
|
28 |
reply = 'OK...' + data
|
29 |
if not data:
|
30 |
break
|
31 |
|
32 |
conn.sendall(reply)
|
33 |
34 |
conn.close() |
35 |
s.close() |
很简单只是加多一个 while 1 语句而已。
继续运行服务器,然后打开另外三个命令行窗口。每个窗口都使用 telnet 命令连接到服务器:
1 |
$ telnet localhost 5000 |
2 |
Trying 127.0.0.1... |
3 |
Connected to localhost. |
4 |
Escape character is '^]' .
|
5 |
happy |
6 |
OK .. happy |
7 |
Connection closed by foreign host. |
服务器所在的终端窗口显示的是:
1 |
$ python server.py |
2 |
Socket created |
3 |
Socket bind complete |
4 |
Socket now listening |
5 |
Connected with 127.0.0.1:60225 |
6 |
Connected with 127.0.0.1:60237 |
7 |
Connected with 127.0.0.1:60239 |
你看服务器再也不退出了,好吧,用 Ctrl+C 关闭服务器,所有的 telnet 终端将会显示 "Connection closed by foreign host."
已经很不错了,但是这样的通讯效率太低了,服务器程序使用循环来接受连接并发送回应,这相当于是一次最多处理一个客户端的请求,而我们要求服务器可同时处理多个请求。
处理多个连接
为了处理多个连接,我们需要一个独立的处理代码在主服务器接收到连接时运行。一种方法是使用线程,服务器接收到连接然后创建一个线程来处理连接收发数据,然后主服务器程序返回去接收新的连接。
下面是我们使用线程来处理连接请求:
01 |
import socket
|
02 |
import sys
|
03 |
from thread import *
|
04 |
05 |
HOST = '' # Symbolic name meaning all available interfaces
|
06 |
PORT = 8888 # Arbitrary non-privileged port
|
07 |
08 |
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
09 |
print 'Socket created'
|
10 |
11 |
#Bind socket to local host and port |
12 |
try :
|
13 |
s.bind((HOST, PORT))
|
14 |
except socket.error , msg:
|
15 |
print 'Bind failed. Error Code : ' + str (msg[ 0 ]) + ' Message ' + msg[ 1 ]
|
16 |
sys.exit()
|
17 |
|
18 |
print 'Socket bind complete'
|
19 |
20 |
#Start listening on socket |
21 |
s.listen( 10 )
|
22 |
print 'Socket now listening'
|
23 |
24 |
#Function for handling connections. This will be used to create threads |
25 |
def clientthread(conn):
|
26 |
#Sending message to connected client
|
27 |
conn.send( 'Welcome to the server. Type something and hit enter\n' ) #send only takes string
|
28 |
|
29 |
#infinite loop so that function do not terminate and thread do not end.
|
30 |
while True :
|
31 |
|
32 |
#Receiving from client
|
33 |
data = conn.recv( 1024 )
|
34 |
reply = 'OK...' + data
|
35 |
if not data:
|
36 |
break
|
37 |
|
38 |
conn.sendall(reply)
|
39 |
|
40 |
#came out of loop
|
41 |
conn.close()
|
42 |
43 |
#now keep talking with the client |
44 |
while 1 :
|
45 |
#wait to accept a connection - blocking call
|
46 |
conn, addr = s.accept()
|
47 |
print 'Connected with ' + addr[ 0 ] + ':' + str (addr[ 1 ])
|
48 |
|
49 |
#start new thread takes 1st argument as a function name to be run, second is the tuple of arguments to the function.
|
50 |
start_new_thread(clientthread ,(conn,))
|
51 |
52 |
s.close() |
运行上述服务端程序,然后像之前一样打开三个终端窗口并执行 telent 命令:
01 |
$ telnet localhost 8888 |
02 |
Trying 127.0.0.1... |
03 |
Connected to localhost. |
04 |
Escape character is '^]' .
|
05 |
Welcome to the server. Type something and hit enter |
06 |
hi |
07 |
OK...hi |
08 |
asd |
09 |
OK...asd |
10 |
cv |
11 |
OK...cv |
1 |
$ python server.py |
2 |
Socket created |
3 |
Socket bind complete |
4 |
Socket now listening |
5 |
Connected with 127.0 . 0.1 : 60730
|
6 |
Connected with 127.0 . 0.1 : 60731
|
线程接管了连接并返回相应数据给客户端。
这便是我们所要介绍的服务器端编程。
结论
到这里为止,你已经学习了 Python 的 Socket 基本编程,你可自己动手编写一些例子来强化这些知识。
你可能会遇见一些问题:Bind failed. Error Code : 98 Message Address already in use,碰见这种问题只需要简单更改服务器端口即可。
发表评论
-
针对代码审查的一些想法
2013-08-20 10:00 546在软件开发项 ... -
浅谈Yield的使用方式
2013-08-16 17:02 634http://www.luanxiang.org/tech/ ... -
http协议初解
2013-08-15 10:41 416最近总是遇到http ... -
http 状态吗大全扫盲篇
2013-08-06 14:37 4941xx消息 这一类型的 ... -
算法导论学习系列之算法设计
2013-07-31 22:19 01、分治法 分治策略是将原问题划分成n个规 ... -
python-memcached 使用方法总结
2012-11-16 10:12 10281.Python-memcached API总结 整 ... -
python 安装memcached
2012-11-16 09:45 6331、安装python-memcached的时候要确保安装 ... -
使用django创建表结构的命令
2012-11-06 15:48 681创建app模型 python manage.py st ... -
python datetime解析
2012-11-02 09:25 837刚学习python,使用到了datetime和time库,以为 ... -
windows下安装apache2.2 + python + django
2012-10-31 16:08 880转载至:http://blog.csdn.net/ppgs89 ...
相关推荐
Python网络编程教程主要介绍如何使用Python语言开发基于socket的网络应用程序,通过本教程的学习,初学者可以掌握Python在网络编程方面的基础知识和高级特性。本教程采用的示例为聊天程序,旨在通过实例加深对Python...
在"python socket 网络编程"这个主题中,我们将深入探讨如何利用socket进行文件传输、命令行执行等核心功能。 一、Python Socket基础 Python中的socket模块源于C语言的socket接口,它提供了TCP/IP协议族的网络通信...
### Python的Socket编程 在计算机网络中,socket(套接字)是一种用于进程间通信的机制,它允许不同计算机上的程序通过网络进行双向通信。本文将深入探讨如何使用Python进行socket编程,特别是创建一个简单的图形...
Python的socket编程是网络通信的基础,它允许不同的计算机之间相互通信。socket编程是构建客户端和服务器应用程序的核心技术之一。 标题中提到的“Python socket编程实例”意味着本文将通过实例来指导Python开发者...
Python异步Socket编程代码,对想学习python socket的人有用
为了开始我们的套接字世界之旅,我们将在 python 中进行 tcp socket 编程。 首先,让我们从创建一个套接字开始创建套接字要创建套接字,我们可以使用 python 的 。 现在让我们创建一个: # Code 1.pyimport sockets...
附件是一个简单的 Python socket 编程的例子,包括一个服务器端和一个客户端。 附件代码在实际使用中可能需要进行错误处理和异常管理的增强,以确保程序的健壮性。此外,服务器端代码中的 while True 循环会无限期...
【大纲】使用Python进行socket编程一、体验Python二、为什么使用Python?三、Pythonsocket模块3.1、基本的Pythonsocket模块3.2、Socket模块3.3、SocketServer模块前提条件创建和销毁socketSocket地址服务器socket...
Python 网络编程_python网络编程_socket Python 网络编程是指使用 Python 语言进行网络通信编程,包括 socket 编程、网络通信协议等方面的内容。下面是对 Python 网络编程的详细介绍: 1. 网络通信的概念 网络...
Python的socket库是进行网络通信的基础模块,它提供了低级别的、原始的套接字接口,...理解并熟练掌握socket编程是成为合格的网络程序员的基础。通过这个实例,你可以进一步探索网络编程的奥秘,不断拓展自己的技能树。
一个简单的Python Socket编程示例,包括一个简单的服务器和客户端。 解释说明: 服务器端代码: 使用 socket.socket() 创建一个新的socket对象 server_socket,参数 socket.AF_INET 表示使用IPv4地址族,socket....
本项目通过socket编程实现了1bit滑动窗口协议,这将帮助我们深入理解该协议的工作原理。 1. **滑动窗口协议基础**: - 滑动窗口协议允许发送方在等待确认之前发送一定数量的数据,这个数量由窗口大小决定。 - ...
在Python中,通过socket编程可以创建反向shell,实现对目标系统的控制。 3. 模糊测试(Fuzz Testing):模糊测试是一种通过向程序输入大量的随机数据,以发现程序中的错误或漏洞的技术。在Python安全编程中,可以...
Pythonsocket网络编程 socket编程也叫套接字编程,应用程序可以通过它发送或者接受数据,可对其像打开文件一样打开/关闭/读写等操作. 套接字允许应用程序将I/O插入到网络中,并与网络中的其他应用程序进行通信. 网络套...
本教程将深入探讨如何使用Python进行Socket编程,包括创建Socket、处理错误、连接到服务器以及使用TCP协议。 首先,创建Socket是Socket编程的第一步。在Python中,我们使用`socket`模块的`socket()`函数来创建一个...
《Python编程案例教程》是一本深入浅出的Python学习资源,旨在通过实例教学来帮助初学者和有一定基础的程序员提升Python编程技能。本教程可能包含了各种类型的Python编程案例,涵盖了基础语法、数据结构、函数、模块...
通过这个过程,我们将学习到Python中的socket编程基础、多线程处理以及如何设计一个简单的网络应用程序。 #### 技术栈与环境 - **Python版本**:推荐使用Python 3.x。 - **开发工具**:推荐使用PyCharm或VS Code等...
在IT领域,网络编程是构建分布式系统和互联网应用程序的基础,而Python作为一种强大的脚本语言,提供了简洁易用的socket库来处理网络通信。本项目"Python Socket多人聊天编程"是基于Python实现的一个简单的多用户...
### Python Socket 编程详解 #### 一、引言 Socket 编程是网络编程的基础,它使得不同计算机之间的通信成为可能。Python 提供了一个强大的 `socket` 模块,支持多种类型的网络通信,包括 TCP 和 UDP。本篇文章将...
python简介,使用_Python_进行_socket_编程