day7 socket网络编程基础
Socket
Socket是什么?
下面来看一下网络的传输过程:
上面图片显示了网络传输的基本过程,传输是通过底层实现的,有很多底层,我们写传输过程的时候,要知道所有的过程那就太复杂了,socket为我们封装了底层的传输流程,让我们直接可以在socket上直接实现数据交换。
socket本质:对底层网络协议的封装。
socket实现数据的发送和接收,通过什么建立连接呢?下面看一幅简单的图片:
在计算机上,我们运行了很多线程,我们如何实现数据的定向交换呢?如何实现客户端和服务器的连接呢?连接我们可以通过IP地址进行连接,连接上之后发送给那个程序呢?这时候我们就要通过port(端口号)进行指明,因为实现连接的过程是通过IP+端口号(port)进行连接。
客户端
import socket
while True:
s = socket.socket()
'''生成一个socket连接'''
s.connect(("localhost",)) #建立连接,连接本地,端口号是6969端口 message = input("请输入您要发送的信息:").encode('utf-8')
if message == "quit":
break
s.sendall(message) #python3上只能传输二进制字节
data = s.recv() #接收服务器端传来的内容
print(data) s.close() #关闭连接
上面代码就是客户端,通过客户端发送数据到服务器,实现交互,客户端加上了一个while循环,能够实现多次交互,我们知道,正常情况下,交互一次就退出了,通过While循环,让客户端不停的产生新的连接,就能不断与客户端进行数据交换。
下面是客户算发送的数据,只能以字符的形式进行发送,所以发送的是字符,汉字看不到,进行转换了。而且不知道为什么,输入空之后,客户端没有响应,静止不动了:
请输入您要发送的信息:dasfda
b'dasfda'
请输入您要发送的信息:不能发送汉字吗
b'\xe4\xb8\x8d\xe8\x83\xbd\xe5\x8f\x91\xe9\x80\x81\xe6\xb1\x89\xe5\xad\x97\xe5\x90\x97'
请输入您要发送的信息:放大法是否对
b'\xe6\x94\xbe\xe5\xa4\xa7\xe6\xb3\x95\xe6\x98\xaf\xe5\x90\xa6\xe5\xaf\xb9'
请输入您要发送的信息:dfafdas
b'dfafdas'
请输入您要发送的信息:dfasdfa
b'dfasdfa'
请输入您要发送的信息:dfasfd
b'dfasfd'
请输入您要发送的信息:afdasdfas
fb'afdasdfas'
请输入您要发送的信息:dasfda
b'fdasfda'
请输入您要发送的信息:dfa
fdab'dfa'
请输入您要发送的信息:
b'fda'
请输入您要发送的信息:afasfda
b'afasfda'
请输入您要发送的信息:afdasfd
b'afdasfd'
请输入您要发送的信息:afdasdfa
b'afdasdfa'
请输入您要发送的信息:
服务器
import socket '''生成socket实例'''
s = socket.socket()
s.bind(("localhost",)) #绑定本地IP和6969端口号
s.listen() #监听客户端发送的信息,一旦有客户端发送过来连接,就接收,现在是等待状态,防止堵塞
print("连接建立完毕,正在等待数据.......")
while True:
conn,addr = s.accept() #接收数据,accept()会接收两个数据,一个是连接conn,一个是地址addr(IP和端口号)
print("Addr:",addr)
data = conn.recv() #通过连接接收数据
print(data)
conn.send(data) #发送数据,把接收到的信息发送 conn.close()
s.close()
上面是服务器的代码,我们也使用了一个循环,让服务器一直挂着,等待客户端发送数据,不停的接收:
下面是服务器接收的数据:
连接建立完毕,正在等待数据.......
Addr: ('127.0.0.1', )
b'dasfda'
Addr: ('127.0.0.1', )
b'\xe4\xb8\x8d\xe8\x83\xbd\xe5\x8f\x91\xe9\x80\x81\xe6\xb1\x89\xe5\xad\x97\xe5\x90\x97'
Addr: ('127.0.0.1', )
b'\xe6\x94\xbe\xe5\xa4\xa7\xe6\xb3\x95\xe6\x98\xaf\xe5\x90\xa6\xe5\xaf\xb9'
Addr: ('127.0.0.1', )
b'dfafdas'
Addr: ('127.0.0.1', )
b'dfasdfa'
Addr: ('127.0.0.1', )
b'dfasfd'
Addr: ('127.0.0.1', )
b'afdasdfas'
Addr: ('127.0.0.1', )
b'fdasfda'
Addr: ('127.0.0.1', )
b'dfa'
Addr: ('127.0.0.1', )
b'fda'
Addr: ('127.0.0.1', )
b'afasfda'
Addr: ('127.0.0.1', )
b'afdasfd'
Addr: ('127.0.0.1', )
b'afdasdfa'
Addr: ('127.0.0.1', )
可以看出,数据进行了多次的交互,并且接收了数据,是以字符编码形式进行接收的。
客户端
import socket client = socket.socket() #声明socket类型,同时生成socket连接对象
client.connect(("localhost",)) client.send("我要下载A片".encode("utf-8")) #在python3中只能发送字节
data = client.recv() #默认接收数据的大小,定义1024个字节
print("recv:",data.decode()) client.close() #关闭连接 服务器
#服务器端
import socket server = socket.socket()
server.bind(("localhost",)) #绑定要监听端口
server.listen() #监听 print("我要开始等电话了")
conn,addr = server.accept() #等待接收,conn对方的连接,addr对方的地址,接收会接收到一个IP编号和地址
#conn就是客户端连过来而在服务器端为其生成的一个连接实例
print(conn,addr) print("电话来了")
data = conn.recv() #接收的数据大小,不能直接调用server接收,打电话新的进来,可以切换
print("recv:",data)
conn.send(data.upper()) server.close()
下面来看一个循环的代码:
#服务器端
import socket server = socket.socket()
server.bind(("localhost",)) #绑定要监听端口
server.listen() #监听 print("我要开始等电话了")
while True:
conn,addr = server.accept() #等待接收,conn对方的连接,addr对方的地址,接收会接收到一个IP编号和地址
#conn就是客户端连过来而在服务器端为其生成的一个连接实例
print(conn,addr) print("电话来了")
data = conn.recv() #接收的数据大小,不能直接调用server接收,打电话新的进来,可以切换
print("recv:",data)
conn.send(data.upper()) server.close()
首先启动服务器端,等待客户端发送数据:
客户端:
import socket client = socket.socket() #声明socket类型,同时生成socket连接对象
client.connect(("localhost",)) while True:
msg = input(">>:").strip() #输入空会卡主,我们知道,QQ也是不允许用户输入空的,会提示输入为空
client.send(msg.encode("utf-8")) #在python3中只能发送字节
data = client.recv() #默认接收数据的大小,定义1024个字节
print("recv:",data.decode()) client.close() #关闭连接
客户端输入:
>>:我
recv: 我
>>:要
上面可以看出,客户端输入第一次正常,第二次卡住了,只能进行一次通讯,说明客户端的实现一次通讯之后终止了。
服务端接收:
我要开始等电话了
<socket.socket fd=4, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 6969), raddr= ('127.0.0.1', 58460)> ('127.0.0.1', 58460)
电话来了
recv: b'\xe6\x88\x91'
可以看出,服务器端第一次接收数据之后,也卡住了,服务器端卡主是由于没有新的连接进来,连接并没有终端,而只是客户端自己断开,找不到新的连接挂在哪里。
下面来修改服务器代码:
#服务器端
import socket server = socket.socket()
server.bind(("localhost",)) #绑定要监听端口
server.listen() #监听 print("我要开始等电话了")
conn, addr = server.accept() # 等待接收,conn对方的连接,addr对方的地址,接收会接收到一个IP编号和地址
# conn就是客户端连过来而在服务器端为其生成的一个连接实例
print(conn, addr)
print("电话来了") while True:
data = conn.recv() #接收的数据大小,不能直接调用server接收,打电话新的进来,可以切换
# if not data:
# break
print("recv:",data)
conn.send(data.upper()) server.close()
现在重新启动服务器,然后启动客户端,在客户端输入交互内容,如下:
客户端输入呢绒:
>>:wo
recv: WO
>>:yao
recv: YAO
>>:zixue
recv: ZIXUE 服务器端接收内容:
我要开始等电话了
<socket.socket fd=, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=, laddr=('127.0.0.1', ), raddr=('127.0.0.1', )> ('127.0.0.1', )
电话来了
recv: b'wo'
recv: b'yao'
recv: b'zixue
现在显示一切都是那么完美,现在来断开客户端,看会怎样,如下:
ecv: b''
recv: b''
recv: b''
recv: b''
recv: b''
......
客户端断开之后,服务器端并没有断开,由于服务器端在循环接收消息,由于没有客户端发送消息,因为接收到的消息一直是空的,并且服务器端server = socket.accept()并没有执行接收过程,因为一直在运行循环。
下面我们来验证服务器端的情况,看客户端断了之后,服务器端是如何执行的,为此我们需要简单修改一下服务器端代码,如下:
#服务器端
import socket server = socket.socket()
server.bind(("localhost",)) #绑定要监听端口
server.listen() #监听 print("我要开始等电话了")
conn, addr = server.accept() # 等待接收,conn对方的连接,addr对方的地址,接收会接收到一个IP编号和地址
# conn就是客户端连过来而在服务器端为其生成的一个连接实例
print(conn, addr)
print("电话来了") count =
while True:
data = conn.recv() #接收的数据大小,不能直接调用server接收,打电话新的进来,可以切换
# if not data:
# break
print("recv:",data)
conn.send(data.upper())
count +=
if count >= :
break server.close()
运行结果如下:
我要开始等电话了
<socket.socket fd=4, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 7071), raddr= ('127.0.0.1', 51532)> ('127.0.0.1', 51532)
电话来了
recv: b'wo'
recv: b'yao'
recv: b'\xe8\x87\xaa\xe5\xad\xa6'
recv: b'\xe5\xbe\x80'
recv: b''
recv: b''
recv: b''
recv: b''
recv: b''
recv: b''
从上面代码可以看出,当客户端端口之后,服务器端并没有断开,由于连接断开了,服务器一直在循环接收数据。(在Windows上,如果客户端断开,服务器端也会断开)
下面来修改一下代码,让客户端断开,服务器端也断开。
如下:
#服务器端
import socket server = socket.socket()
server.bind(("localhost",)) #绑定要监听端口
server.listen() #监听 print("我要开始等电话了")
conn, addr = server.accept() # 等待接收,conn对方的连接,addr对方的地址,接收会接收到一个IP编号和地址
# conn就是客户端连过来而在服务器端为其生成的一个连接实例
print(conn, addr)
print("电话来了") while True:
data = conn.recv() #接收的数据大小,不能直接调用server接收,打电话新的进来,可以切换
if not data: #加入一个判断,如果接收为空,则断开服务器
break
print("recv:",data)
conn.send(data.upper()) server.close()
上面代码中,对服务器端代码进行了简单完善,让客户端断开的时候,服务器端也断开,如何实现呢?只需要判断客户端接收到空的时候终止既可以。然后启动服务器,启动客户端进行数据传输如下:
客户端输入:
/usr/bin/python3. /home/zhuzhu/第七天/socket_client.py
>>:woyao
recv: WOYAO
>>:自学
recv: 自学
>>:Traceback (most recent call last):
File "/home/zhuzhu/第七天/socket_client.py", line , in <module>
msg = input(">>:").strip() #输入空会卡主,我们知道,QQ也是不允许用户输入空的,会提示输入为空
KeyboardInterrupt 服务器端接收:
我要开始等电话了
<socket.socket fd=, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=, laddr=('127.0.0.1', ), raddr=('127.0.0.1', )> ('127.0.0.1', )
电话来了
recv: b'woyao'
recv: b'\xe8\x87\xaa\xe5\xad\xa6'
从上面结果可以看出,客户端断开时候,服务器端也断开了,那么如何实现客户端断开,服务器端接收新的客户端的消息,只断开当前连接,重新生成一个新的连接。如下:
服务器端
#服务器端
import socket server = socket.socket()
server.bind(("localhost",)) #绑定要监听端口
server.listen() #监听
while True:
print("我要开始等电话了")
conn, addr = server.accept() # 等待接收,conn对方的连接,addr对方的地址,接收会接收到一个IP编号和地址
# conn就是客户端连过来而在服务器端为其生成的一个连接实例
print(conn, addr)
print("电话来了") while True:
data = conn.recv() #接收的数据大小,不能直接调用server接收,打电话新的进来,可以切换
if not data:
break
print("recv:",data)
conn.send(data.upper()) server.close()
上面代码进行了两层嵌套,内层嵌套是如果接收消息为空,则断开本次连接,外层循环是内存连接断开之后,重新生成一个新的连接,因此我们首先启动服务器端,现在同时打开三个客户端如下:
启动服务器:
我要开始等电话了
<socket.socket fd=4, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 7071), raddr= ('127.0.0.1', 51568)> ('127.0.0.1', 51568)
电话来了
客户端1:
/usr/bin/python3.5 /home/zhuzhu/第七天/socket_client.py
>>:
客户端2:
/usr/bin/python3.5 /home/zhuzhu/第七天/socket_client.py
>>:
客户端3:
/usr/bin/python3.5 /home/zhuzhu/第七天/socket_client.py
>>:
首先在客户端1发送消息,如下:
>>:11
recv: 11
服务器:
/usr/bin/python3.5 /home/zhuzhu/第七天/socket_server.py
我要开始等电话了
<socket.socket fd=4, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 7071), raddr= ('127.0.0.1', 51568)> ('127.0.0.1', 51568)
电话来了
recv: b'11'
可以看到,服务器接收到了客户端1发送的消息,在客户端2和客户端3发送消息,如下:
客户端2:
>>:shibushi
客户端3:
/usr/bin/python3.5 /home/zhuzhu/第七天/socket_client.py
>>:接收不到吗?
服务器端:
/usr/bin/python3.5 /home/zhuzhu/第七天/socket_server.py
我要开始等电话了
<socket.socket fd=4, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 7071), raddr= ('127.0.0.1', 51568)> ('127.0.0.1', 51568)
电话来了
recv: b'11'
可以看到,服务器并没有接收到客户端2和客户端3的信息,现在终端客户端1,如下:
客户端1:
>>:11
>>:Traceback (most recent call last):
File "/home/zhuzhu/第七天/socket_client.py", line 7, in <module>
msg = input(">>:").strip() #输入空会卡主,我们知道,QQ也是不允许用户输入空的,会提示输入为空
KeyboardInterrupt
服务器:
我要开始等电话了
<socket.socket fd=4, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 7071), raddr= ('127.0.0.1', 51568)> ('127.0.0.1', 51568)
电话来了
recv: b'11'
我要开始等电话了
<socket.socket fd=5, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 7071), raddr= ('127.0.0.1', 51570)> ('127.0.0.1', 51570)
电话来了
recv: b'shibushi'
从上面可以看出,客户端1断开后,服务器与客户端1的连接也断开了,生成了一个新的连接,连接客户端2,并接收客户端2发送过来的消息。
因此我们得出结论,上面代码实现了客户端断开后,服务器端重新挂起,等待新的连接的任务。
当所有客户端中断后,如下:
/usr/bin/python3. /home/zhuzhu/第七天/socket_server.py
我要开始等电话了
<socket.socket fd=, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=, laddr=('127.0.0.1', ), raddr=('127.0.0.1', )> ('127.0.0.1', )
电话来了
recv: b''
我要开始等电话了
<socket.socket fd=, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=, laddr=('127.0.0.1', ), raddr=('127.0.0.1', )> ('127.0.0.1', )
电话来了
recv: b'shibushi'
我要开始等电话了
<socket.socket fd=, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=, laddr=('127.0.0.1', ), raddr=('127.0.0.1', )> ('127.0.0.1', )
电话来了
recv: b'\xe6\x8e\xa5\xe6\x94\xb6\xe4\xb8\x8d\xe5\x88\xb0\xe5\x90\x97\xef\xbc\x9f'
recv: b'shibush'
recv: b'duankaiyixai'
recv: b'exit'
我要开始等电话了
可以看出,当客户端所有连接断开后,服务器端还在等待消息。等待新的连接介入。
上面客户端代码是有缺陷的,因为send()是不能发送空的,我们发送空就会让客户端卡主,如下:
客户端输入:
>>:eoyoa
recv: EOYOA
>>:dfasfd
recv: DFASFD
>>: #发送空,卡住了
从上面客户端执行代码可以看出,确实当前卡主了,现在来完善一下客户端,让当用户输入为空的时候,跳过本次过程,告诉用户不能发送空,重新输入:
import socket client = socket.socket() #声明socket类型,同时生成socket连接对象
client.connect(("localhost",)) while True:
msg = input(">>:").strip() #输入空会卡主,我们知道,QQ也是不允许用户输入空的,会提示输入为空
if not msg:
print("对不起,发送消息不能为空!")
continue
client.send(msg.encode("utf-8")) #在python3中只能发送字节,send()不能发送空
data = client.recv() #默认接收数据的大小,定义1024个字节
print("recv:",data.decode()) client.close() #关闭连接
上面代码中,客户端加入了一个判断,当用户输入发送消息为空时,告诉用户不能为空,并跳过本次循环(我们知道,QQ聊天也是不能发送空消息的),运行如下:
客户端输入:
/usr/bin/python3.5 /home/zhuzhu/第七天/socket_client.py
>>:dasfd
arecv: DASFD
>>:dfasfd
recv: ADFASFD
>>:
对不起,发送消息不能为空!
>>:发顺丰达
recv: 发顺丰达 #不小心打了一个广告
>>:
对不起,发送消息不能为空!
>>:
可以看出,上述代码实现了不能发送为空的功能,如果想要空的时候退出,可以把continue改成break,当然这是非主流做法了。任何聊天工具不会让用户输入空就终止聊天的。
day7 socket网络编程基础的更多相关文章
- day7 socket网络编程
Python Socket网络编程 Socket是进程间通信的一种方式,它与其他进程间通信的一个主要不同是:它能实现不同主机间的进程间通信,我们网络上各种各样的服务大多都是基于Socket来完成通信的 ...
- python全栈开发从入门到放弃之socket网络编程基础
网络编程基础 一 客户端/服务器架构 1.硬件C/S架构(打印机) 2.软件C/S架构 互联网中处处是C/S架构 如黄色网站是服务端,你的浏览器是客户端(B/S架构也是C/S架构的一种) 腾讯作为服务 ...
- Socket网络编程-基础篇
Socket网络编程 网络通讯三要素: IP地址[主机名] 网络中设备的标识 本地回环地址:127.0.0.1 主机名:localhost 端口号 用于标识进程的逻辑地址 有效端口:0~65535 其 ...
- 【linux高级程序设计】(第十三章)Linux Socket网络编程基础 2
BSD Socket网络编程API 创建socket对象 int socket (int __domain, int __type, int __protocol) :成功返回socket文件描述符, ...
- windows socket网络编程基础知识
下面介绍网络7层协议在WINDOWS的实现: 7层协议 WIN系统 ________________________________________ 7 应用层 7 应用程序 ____________ ...
- java架构《Socket网络编程基础篇》
本章主要介绍Socket的基本概念,传统的同步阻塞式I/O编程,伪异步IO实现,学习NIO的同步非阻塞编程和NIO2.0(AIO)异步非阻塞编程. 目前为止,Java共支持3种网络编程模型:BIO.N ...
- socket网络编程基础小记
"一切皆Socket!" 话虽些许夸张.可是事实也是,如今的网络编程差点儿都是用的socket. --有感于实际编程和开源项目研究. 我们深谙信息交流的价值,那网络中进程之间怎样通 ...
- 【linux高级程序设计】(第十三章)Linux Socket网络编程基础
IP地址定义: struct in_addr{ __u32 s_addr; }; in_addr_t inet_addr (__const char * __cp) :把点分十进制IP地址字符串转换 ...
- 【linux高级程序设计】(第十三章)Linux Socket网络编程基础 4
网络调试工具 tcpdump 功能:打印指定网络接口中与布尔表达式匹配的报头信息 关键字: ①类型:host(默认).net.port host 210.27.48.2 //指明是一台主机 net 2 ...
随机推荐
- Hadoop生态圈-Hbase的API常见操作
Hadoop生态圈-Hbase的API常见操作 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任.
- 笔记 jquery 的一个bug解决方法积累
本博客是自己在学习和工作途中的积累与总结,仅供自己参考,也欢迎大家转载,转载时请注明出处 当id或匹配条件中包含特殊字符时,浏览器控制台会报缺少")"的异常,解决办法目前有两个: ...
- Coffeescript的安装与编译
安装 npm install -g coffee-script 在cmd中输入coffee可以进入coffeescript的命令行模式(REPL),然而到我写完这篇博文为止,我觉得这并没有什么卵用 C ...
- ELASTIC SEARCH 安装
elastic search 2017年3月18日 安装&使用 环境 表 1 环境信息 Centos cat /etc/issue CentOS release 6.8 (Final) cat ...
- 把JS和CSS合并到1个文件
合并JS文件和CSS文件很多人都知道,也用过,目的是为了减少请求数.但有时候我们觉的把JS合并到1个文件,CSS又合并到另外1个文件也是浪费,我们如何能把CSS和JS一起合并进1个文件了? 这里需要使 ...
- 解决IE6中 PNG图片透明的终极方案-八种方案!
“珍惜生命,远离IE6”,IE6中的bug令很多Web前端开发人员实为头疼,因此不知道烧了多少脑细胞,在众多的Bug中最令人抓狂的就是IE对png图片的不支持,导致设计师和重构师放弃了很多很炫的效果, ...
- 20155233 2016-2017-2 《Java程序设计》第7周学习总结
20155233 2016-2017-2 <Java程序设计>第7周学习总结 学习目标 了解Lambda语法 了解方法引用 了解Fucntional与Stream API 掌握Date与C ...
- 问题 1476: [蓝桥杯][基础练习VIP]龟兔赛跑预测 (模拟)
题目链接 题目描述 话说这个世界上有各种各样的兔子和乌龟,但是 研究发现,所有的兔子和乌龟都有一个共同的特点--喜欢赛跑.于是世界上各个角落都不断在发生着乌龟和兔子的比赛,小华对此很感兴趣,于是决定研 ...
- [转]Linux 线程分离状态
线程的分离与结合 在任何一个时间点上,线程是可结合的(joinable),或者是分离的(detached).一个可结合的线程能够被其他线程收回其资源和杀死:在被其他线程回收之前,它的存储器资源(如栈) ...
- 安卓微信、QQ自带浏览器 UXSS 漏洞
安卓微信.QQ自带浏览器 UXSS 漏洞 注:PDF报告原文下载链接 Author: hei@knownsec.com Date: 2016-02-29 一.漏洞描述 在安卓平台上的微信及QQ自带浏览 ...