Pythonsocket二进制码流

① 请教如何使用python的socket发送二进制数据

socket发送的本来就是按二进制发送，你是想把数据打包成str用socket发出去吧？
可以用struct来打包
import struct
data = struct.pack('i', 123)
然后用socket发送就行了，这里打包一个整数的例子，struct很强大可以网络一下具体用法。

② 请教如何使用python的socket发送二进制数据

客户端clt.py

#coding:utf8
importsocket

HOST='192.168.1.101'
PORT=12008
defsend_data(data):
try:
sock_clt=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sock_clt.connect((HOST,PORT))
sock_clt.send(data)
finally:
sock_clt.close()

whileTrue:
send_data('你的二进制数据')

服务端svr.py

#coding:utf8
importsocket
HOST=''
PORT=12008
SIZE=4096

sock_svr=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
#pythonsocketserver重启后，端口被占用的解决方法
sock_svr.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
sock_svr.bind((HOST,PORT))
sock_svr.listen(1)

whileTrue:
print"waitingoftheclienttoconnect"
clt_conn_sock,addr=sock_svr.accept()
print'Connectedby',addr
comp_data=''

whileTrue:
data=clt_conn_sock.recv(SIZE)
ifnotdata:
break
comp_data+=data
clt_conn_sock.close()
ifnotcomp_data:
continue
printcomp_data

服务端可以使用socket的select或poll,也可以使用twisted

③ python 用socket怎么发送一段二进制数据

参考python 的struct mole — Interpret strings as packed binary data, 用来将数据封装到类似C语言的结构体中进行发送。具体可以参考:
https://docs.python.org/2/library/struct.html
http://www.cnblogs.com/gala/archive/2011/09/22/2184801.html
http://stackoverflow.com/questions/3753589/packing-and-unpacking-variable-length-array-string-using-the-struct-mole-in-py

④ 在python中如何从二进制文件中读取信息

你是指读入二进制文件吧？
可以使用numpy.fromfile()，也可以使用open(filename, 'rb')，其中的'b'就是二进制的意思，然后使用文件类型的read方法，读取一些字节，再用struct.unpack()方法来解析二进制。
第一种方法是一次性读入文件（或文件的前多少个连续字节）到一个数组中，因此，灵活性差。
第二种方法灵活性很高，可以读取任意位置（使用文件的seek()方法跳跃位置）的二进制数据，再使用struct.unpack()方法来进行各种二进制解析。

提示：二进制文件是不保留存储方式的数据格式，因此，读二进制文件时应该知道二进制文件的存储格式。

⑤ 如何用python获取websocket数据

这里，介绍如何使用 Python 与前端 js 进行通信。
websocket 使用 HTTP 协议完成握手之后，不通过 HTTP 直接进行 websocket 通信。
于是，使用 websocket 大致两个步骤：使用 HTTP 握手，通信。
js 处理 websocket 要使用 ws 模块； python 处理则使用 socket 模块建立 TCP 连接即可，比一般的 socket ，只多一个握手以及数据处理的步骤。
握手
过程

包格式
js 客户端先向服务器端 python 发送握手包，格式如下：
?

1
2
3
4
5
6
7
8

GET
/chat HTTP/1.1
Host:
server.example.com
Upgrade:
websocket
Connection:
Upgrade
Sec-WebSocket-Key:
dGhlIHNhbXBsZSBub25jZQ==
Origin:
Sec-WebSocket-Protocol:
chat, superchat
Sec-WebSocket-Version:
13

服务器回应包格式：
?

1
2
3
4
5

HTTP/1.1
101 Switching Protocols
Upgrade:
websocket
Connection:
Upgrade
Sec-WebSocket-Accept:
s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
Sec-WebSocket-Protocol:
chat

其中， Sec-WebSocket-Key 是随机的，服务器用这些数据构造一个 SHA-1 信息摘要。
方法为： key+migic ， SHA-1 加密， base-64 加密，如下：

Python 中的处理代码
?

1
2

MAGIC_STRING='258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
res_key=base64.b64encode(hashlib.sha1(sec_key
+MAGIC_STRING).digest())

握手完整代码
js 端
js 中有处理 websocket 的类，初始化后自动发送握手包，如下：
var socket = new WebSocket('ws://localhost:3368');
Python 端
Python 用 socket 接受得到握手字符串，处理后发送
?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

HOST='localhost'
PORT=3368
MAGIC_STRING='258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
HANDSHAKE_STRING="HTTP/1.1
101 Switching Protocols\r\n"
\
"Upgrade:websocket\r\n"\
"Connection:
Upgrade\r\n"
\
"Sec-WebSocket-Accept:
{1}\r\n"
\
"WebSocket-Location:ws://{2}/chat\r\n"

\
"WebSocket-Protocol:chat\r\n\r\n"

defhandshake(con):
#con为用socket，accept()得到的socket

headers={}
shake=con.recv(1024)

ifnot

len(shake):
returnFalse

header,
data =shake.split('\r\n\r\n',1)
forline
inheader.split('\r\n')[1:]:
key,
val =line.split(':
',1)
headers[key]=val

if'Sec-WebSocket-Key'

not
in
headers:
print('This
socket is not websocket, client close.')
con.close()
returnFalse

sec_key=headers['Sec-WebSocket-Key']
res_key=base64.b64encode(hashlib.sha1(sec_key
+MAGIC_STRING).digest())

str_handshake=HANDSHAKE_STRING.replace('{1}',
res_key).replace('{2}',
HOST +':'

+
str(PORT))
printstr_handshake
con.send(str_handshake)
returnTrue

通信
不同版本的浏览器定义的数据帧格式不同， Python 发送和接收时都要处理得到符合格式的数据包，才能通信。
Python 接收
Python 接收到浏览器发来的数据，要解析后才能得到其中的有用数据。
浏览器包格式

固定字节：
（ 1000 0001 或是 1000 0002 ）这里没用，忽略
包长度字节：
第一位肯定是 1 ，忽略。剩下 7 个位可以得到一个整数 (0 ~ 127) ，其中
（ 1-125 ）表此字节为长度字节，大小即为长度；
（126）表接下来的两个字节才是长度；
（127）表接下来的八个字节才是长度；
用这种变长的方式表示数据长度，节省数据位。
mark 掩码：
mark 掩码为包长之后的 4 个字节，之后的兄弟数据要与 mark 掩码做运算才能得到真实的数据。
兄弟数据：
得到真实数据的方法：将兄弟数据的每一位 x ，和掩码的第 i%4 位做 xor 运算，其中 i 是 x 在兄弟数据中的索引。
完整代码
?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

defrecv_data(self,
num):
try:
all_data=self.con.recv(num)
ifnot

len(all_data):
returnFalse
except:
returnFalse
else:
code_len=ord(all_data[1])
& 127
ifcode_len
==126:
masks=all_data[4:8]
data=all_data[8:]
elifcode_len
==127:
masks=all_data[10:14]
data=all_data[14:]
else:
masks=all_data[2:6]
data=all_data[6:]
raw_str=""
i=0
ford
indata:
raw_str+=chr(ord(d)
^ ord(masks[i%4]))
i+=1
returnraw_str

js 端的 ws 对象，通过 ws.send(str) 即可发送
ws.send(str)
Python 发送
Python 要包数据发送，也需要处理，发送包格式如下

固定字节：固定的 1000 0001( ‘ \x81 ′ )
包长：根据发送数据长度是否超过 125 ， 0xFFFF(65535) 来生成 1 个或 3 个或 9 个字节，来代表数据长度。
?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

defsend_data(self,
data):
ifdata:
data=str(data)
else:
returnFalse
token="\x81"
length=len(data)
iflength
< 126:
token+=struct.pack("B",
length)
eliflength
<=0xFFFF:
token+=struct.pack("!BH",126,
length)
else:
token+=struct.pack("!BQ",127,
length)
#struct为Python中处理二进制数的模块，二进制流为C，或网络流的形式。
data='%s%s'

%
(token, data)
self.con.send(data)
returnTrue

js 端通过回调函数 ws.onmessage() 接受数据
?

1
2
3
4
5

ws.onmessage
= function(result,nTime){
alert("从服务端收到的数据:");
alert("最近一次发送数据到现在接收一共使用时间:"+
nTime);
console.log(result);
}

最终代码
Python服务端
?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

#
_*_ coding:utf-8 _*_
__author__='Patrick'

importsocket
importthreading
importsys
importos
importMySQLdb
importbase64
importhashlib
importstruct

#
====== config ======
HOST='localhost'
PORT=3368
MAGIC_STRING='258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
HANDSHAKE_STRING="HTTP/1.1
101 Switching Protocols\r\n"
\
"Upgrade:websocket\r\n"\
"Connection:
Upgrade\r\n"
\
"Sec-WebSocket-Accept:
{1}\r\n"
\
"WebSocket-Location:ws://{2}/chat\r\n"

\
"WebSocket-Protocol:chat\r\n\r\n"

classTh(threading.Thread):
def__init__(self,
connection,):
threading.Thread.__init__(self)
self.con=connection

defrun(self):
whileTrue:
try:
pass
self.con.close()

defrecv_data(self,
num):
try:
all_data=self.con.recv(num)
ifnot

len(all_data):
returnFalse
except:
returnFalse
else:
code_len=ord(all_data[1])
& 127
ifcode_len
==126:
masks=all_data[4:8]
data=all_data[8:]
elifcode_len
==127:
masks=all_data[10:14]
data=all_data[14:]
else:
masks=all_data[2:6]
data=all_data[6:]
raw_str=""
i=0
ford
indata:
raw_str+=chr(ord(d)
^ ord(masks[i%4]))
i+=1
returnraw_str

#
send data
defsend_data(self,
data):
ifdata:
data=str(data)
else:
returnFalse
token="\x81"
length=len(data)
iflength
< 126:
token+=struct.pack("B",
length)
eliflength
<=0xFFFF:
token+=struct.pack("!BH",126,
length)
else:
token+=struct.pack("!BQ",127,
length)
#struct为Python中处理二进制数的模块，二进制流为C，或网络流的形式。
data='%s%s'

%
(token, data)
self.con.send(data)
returnTrue

#
handshake
defhandshake(con):
headers={}
shake=con.recv(1024)

ifnot

len(shake):
returnFalse

header,
data =shake.split('\r\n\r\n',1)
forline
inheader.split('\r\n')[1:]:
key,
val =line.split(':
',1)
headers[key]=val

if'Sec-WebSocket-Key'

not
in
headers:
print('This
socket is not websocket, client close.')
con.close()
returnFalse

sec_key=headers['Sec-WebSocket-Key']
res_key=base64.b64encode(hashlib.sha1(sec_key
+MAGIC_STRING).digest())

str_handshake=HANDSHAKE_STRING.replace('{1}',
res_key).replace('{2}',
HOST +':'

+
str(PORT))
printstr_handshake
con.send(str_handshake)
returnTrue

defnew_service():
"""start
a service socket and listen
when
coms a connection, start a new thread to handle it"""

sock=socket.socket(socket.AF_INET,
socket.SOCK_STREAM)
try:
sock.bind(('localhost',3368))
sock.listen(1000)
#链接队列大小
print"bind
3368,ready to use"
except:
print("Server
is already running,quit")
sys.exit()

whileTrue:
connection,
address =sock.accept()
#返回元组（socket,add），accept调用时会进入waite状态
print"Got
connection from ",
address
ifhandshake(connection):
print"handshake
success"
try:
t=Th(connection,
layout)
t.start()
print'new
thread for client ...'
except:
print'start
new thread error'
connection.close()

if__name__
=='__main__':
new_service()

js客户 端
?

1
2
3
4
5
6
7
8

<script>
varsocket
= newWebSocket('ws://localhost:3368');
ws.onmessage
= function(result,nTime){
alert("从服务端收到的数据:");
alert("最近一次发送数据到现在接收一共使用时间:"+
nTime);
console.log(result);
}
</script>

⑥ 请问下python网络编程的字节序怎么处理

多谢楼上的，不是这么处理的python发送的都是二进制的string串，对数字类型的数据可以使用struct模块来实现，具体例子如下：struct.pack('>l',
3)这里是输出一个整数3，>表示使用网络字节序，l表示数据类型

⑦ Python中b101011是合法的二进制数值表示形式

是的，是 Python 中有效的二进制数表示形式。在 Python 中，二进制数使用前缀后跟一系列 and 数字来表示。例如，二进制数可以像在 Python 中一样写。b1010110b011010110b101011

下面是在 Python 中使用前缀定义二进制数的示例：0b

回答不易望请采纳

⑧ 求助：python如何按位解析二进制数据

可以的，二进制是计算机内的表示方法，处理二进制数据是最基本的能力。

如果是二进制字符串转十进制：

>>>x='10101010'
>>>int(x,2)
170

如果是从文件或网络中获取的数据，要知道某一位是0还是1的话，获取的数据可以按字符读取，由于一个字符由8位二进制表示，分别读取1到8位的二进制值就可以了：

>>>get_char_bit=lambdachar,n:(char>>(8-n))&1#从高到低分别为第1～8位
>>>data=b'ab'#在python3中字符串默认是unicode，所以加上b前缀兼容
>>>#在python3中按字符读取byte字符串是数字，而python2读出来的却是字符，但bytearray是一致的都是数字
>>>data=bytearray(data)
>>>result=[]
>>>forcharindata:
foriinrange(1,9):
result.append(get_char_bit(char,i))

>>>result
[0,1,1,0,0,0,0,1,0,1,1,0,0,0,1,0]

还有一种比较简单的方法是使用内置的bin函数

>>>data=bytearray(b'ab')
>>>result=[]
>>>forcharindata:
result.extend(bin(char)[2:].rjust(8,'0'))

>>>result
['0','1','1','0','0','0','0','1','0','1','1','0','0','0','1','0']

⑨ 如何用Python将十进制数字转为二进制，以及将二进制转为十六进制

1、将十进制转换成二进制，利用bin()方法。