在python中，我得到了一个64位整数。这个Integer是通过取几个不同的8位整数并将它们混合为一个巨大的64位整数而创建的。我的工作是再次把它们分开。
例如：
Source number: 2592701575664680400
Binary (64 bits): 0010001111111011001000000101100010101010000101101011111000000000
int 1: 00100011 (35)
int 2: 11111011 (251)
int 3: 00100000 (32)
int 4: 01011000 (88)
int 5: 10101010 (170)
int 6: 00010110 (22)
int 7: 10111110 (190)
int 8: 00000000 (0)
因此，我想做的是获取我的源编号2592701575664680373，并返回一个长度为8的数组，其中数组中的每个int都是上面列出的int。
我本来打算使用struct，但老实说，阅读文档并没有完全清楚地表明我将如何实现这一点。
解决方案
不将数字转换为字符串的解决方案：
x = 0b0010001111111011001000000101100010101010000101101011111000000000
numbers = list((x >> i) & 0xFF for i in range(0,64,8))
print(numbers) # [0, 190, 22, 170, 88, 32, 251, 35]
print(list(reversed(numbers))) # [35, 251, 32, 88, 170, 22, 190, 0]
解释
在这里，我使用了列表理解，在i上以8为增量进行循环。因此i取值0, 8, 16, 24, 32, 40, 48, 56。每次，比特移位运算器>>将数字x临时下移i比特。这相当于除以256^i。
因此得到的数字是：
i = 0: 0010001111111011001000000101100010101010000101101011111000000000
i = 8: 00100011111110110010000001011000101010100001011010111110
i = 16: 001000111111101100100000010110001010101000010110
i = 24: 0010001111111011001000000101100010101010
i = 32: 00100011111110110010000001011000
i = 40: 001000111111101100100000
i = 48: 0010001111111011
i = 56: 00100011
通过使用& 0xFF，我选择了这个数字的最后8位。示例：
x >> 48: 001000111111101100100000
0xff: 11111111
(x >> 48) & 0xff: 000000000000000000100000
由于前导零无关紧要，所以您就有了所需的数字。
结果被转换成一个列表，并按正常和相反的顺序打印(就像OP想要的那样(。
性能
我将这个结果的时间与本线程中提出的其他解决方案进行了比较：
In: timeit list(reversed([(x >> i) & 0xFF for i in range(0,64,8)]))
100000 loops, best of 3: 13.9 µs per loop
In: timeit [(x >> (i * 8)) & 0xFF for i in range(7, -1, -1)]
100000 loops, best of 3: 11.1 µs per loop
In: timeit [(x >> i) & 0xFF for i in range(63,-1,-8)]
100000 loops, best of 3: 10.2 µs per loop
In: timeit reversed(struct.unpack('8B', struct.pack('Q', x)))
100000 loops, best of 3: 3.22 µs per loop
In: timeit reversed(struct.pack('Q', x))
100000 loops, best of 3: 2.07 µs per loop
结果：我的解决方案是而不是最快！目前，直接使用struct(由Mark Ransom提出(似乎是最快的代码片段。
在Python 2.x中，struct.pack返回一个字节字符串。很容易将其转换为整数数组。
>>> bytestr = struct.pack('>Q', 2592701575664680400)
>>> bytestr
'#xfb Xxaax16xbdxd0'
>>> [ord(b) for b in bytestr]
[35, 251, 32, 88, 170, 22, 189, 208]
python中的struct模块用于将python对象转换为字节字符串，通常根据C结构打包规则进行打包。struct.pack采用一个格式说明符(一个描述结构字节布局的字符串(和一些python数据，并将其打包为一个字节字符串。struct.unpack执行相反的操作，使用一个格式说明符和一个字节字符串，并再次以python对象的格式返回一个未打包数据的元组。
所使用的格式说明符由两部分组成。前导字符指定字符串的字节序。以下字符指定要打包或解包的结构的字段类型。因此'>Q'意味着将给定的数据打包为大端序unsigned long long。要按相反的顺序获取字节，可以使用<代替little-endian。
最后一个操作是列表理解，它对字节字符串的字符进行迭代，并使用ord内置函数来获得该字符的整数表示。
最后注意：Python实际上并没有整数大小的概念。在2.x中，存在被限制为32比特的int和大小不受限制的long。在3.x中，这两者被统一为一个单一的类型。因此，尽管这个操作保证给出只占一个字节的整数，但如果在其他操作中使用python，则注意python会强制生成的整数保持这种状态。
bn = "0010001111111011001000000101100010101010000101101011111000000000"
print([int(bn[i:i+8], 2) for i in range(0,len(bn), 8)])
[35, 251, 32, 88, 170, 22, 190, 0]
如果你使用n的二进制表示，那么输出会有所不同：
n = 2592701575664680373
bn = bin(n)
print([int(bn[i:i+8], 2) for i in range(0,len(bn), 8)])
[35, 251, 32, 88, 170, 22, 189, 181]
一些时间安排：
In [16]: %%timeit
numbers = list((n >> i) & 0xFF for i in range(0,64,8))
list(reversed(numbers))
....:
100000 loops, best of 3: 2.97 µs per loop
In [17]: timeit [(n >> (i * 8)) & 0xFF for i in range(7, -1, -1)]
1000000 loops, best of 3: 1.73 µs per loop
In [18]: %%timeit
bn = bin(n)
[int(bn[i:i+8], 2) for i in range(0,len(bn), 8)]
....:
100000 loops, best of 3: 3.96 µs per loop
你也可以只是divmod:
out = []
for _ in range(8):
n, i = divmod(n, 256)
out.append(i)
out = out[::-1]
哪个几乎同样有效：
In [31]: %%timeit
....: n = 2592701575664680411
....: out = []
....: for _ in range(8):
....: n, i = divmod(n, 1 << 8)
....: out.append(i)
....: out[::-1]
....:
100000 loops, best of 3: 2.35 µs per loop
使用python进行位转换几乎没有什么优势，我更倾向于使用您和其他人认为可读性更强的内容。
下面是一个使用struct:的版本
import struct
n = 2592701575664680400
bytes = struct.unpack('8B', struct.pack('Q', n))
bytes的返回顺序与您在问题中显示的顺序相反。
以下是性能统计数据：
python -m timeit -s "import struct" "struct.unpack('8B', struct.pack('Q', 2592701575664680400))"
1000000 loops, best of 3: 0.33 usec per loop
在我的电脑上，这比字节移位解决方案快三倍。
对于一堆单元64来说，这似乎更快。使用numpy。
from cytpes import *
import numpy as np
l1 = c_uint64 * 512
payload64 = l1(0)
payload8 = np.frombuffer(payload64, dtype=np.uint8)
其中payload8是np.unit8的数组，其后是payload64大小的8倍，并且其中有converter字节
对我来说，它比结构变体更快。。。
for i in range(len(payload64)):
payload8[i*8:i*8+8] = struct.unpack('8B', struct.pack('Q', payload64[i]))