连接到Raspberry Pi（零W）的256 * 64像素OLED显示器将4位灰度像素数据打包成一个字节（即每个字节两个像素），因此总共8192个字节。例如。字节
0a 0b 0c 0d (only lower nibble has data)
成为
ab cd
当天真地迭代像素数据时，根据颜色深度，将获得bytes或from a Pillow (PIL) Image的cairo ImageSurface转换为0.9秒。
组合枕头“L”（单色8位）图像中的每两个字节：
imd = im.tobytes()
nibbles = [int(p / 16) for p in imd]
packed = []
msn = None
for n in nibbles:
nib = n & 0x0F
if msn is not None:
b = msn << 4 | nib
packed.append(b)
msn = None
else:
msn = nib
这（省略状态并保存浮点/整数转换）将其降低到大约一半（0.2秒）：
packed = []
for b in range(0, 256*64, 2):
packed.append( (imd[b]//16)<<4 | (imd[b+1]//16) )
基本上第一个应用于RGB24（32位！）cairo ImageSurface，但是使用粗灰度转换：
mv = surface.get_data()
w = surface.get_width()
h = surface.get_height()
f = surface.get_format()
s = surface.get_stride()
print(len(mv), w, h, f, s)
# convert xRGB
o = []
msn = None
for p in range(0, len(mv), 4):
nib = int( (mv[p+1] + mv[p+2] + mv[p+3]) / 3 / 16) & 0x0F
if msn is not None:
b = msn << 4 | nib
o.append(b)
msn = None
else:
msn = nib
需要大约两倍的时间（0.9秒对0.4秒）。
struct模块不支持半字节（半字节）。
bitstring允许包装半字节：
>>> a = bitstring.BitStream()
>>> a.insert('0xf')
>>> a.insert('0x1')
>>> a
BitStream('0xf1')
>>> a.insert(5)
>>> a
BitStream('0b1111000100000')
>>> a.insert('0x2')
>>> a
BitStream('0b11110001000000010')
>>>
但似乎没有一种方法可以快速将其解压缩为整数列表 - 这需要30秒！：
a = bitstring.BitStream()
for p in imd:
a.append( bitstring.Bits(uint=p//16, length=4) )
packed=[]
a.pos=0
for p in range(256*64//2):
packed.append( a.read(8).uint )
Python 3是否有办法有效地执行此操作，还是需要替代方法？
外包装用ctypes包裹？与Cython 相同但更简单（我还没有看过这些）？看起来很好，看到我的答案。
答案 0 :(得分：0)
just wrapping the loop in a function
从200毫秒减少到130毫秒def packer0(imd):
"""same loop in a def"""
packed = []
for b in range(0, 256*64, 2):
packed.append( (imd[b]//16)<<4 | (imd[b+1]//16) )
return packed
Cythonizing 相同的代码
，最短由35毫秒def packer1(imd):
"""Cythonize python nibble packing loop"""
packed = []
for b in range(0, 256*64, 2):
packed.append( (imd[b]//16)<<4 | (imd[b+1]//16) )
return packed
类型
，低至16毫秒def packer2(imd):
"""Cythonize python nibble packing loop, typed"""
packed = []
cdef unsigned int b
for b in range(0, 256*64, 2):
packed.append( (imd[b]//16)<<4 | (imd[b+1]//16) )
return packed
＆＃34;简化＆＃34;没有什么区别？环
def packer3(imd):
"""Cythonize python nibble packing loop, typed"""
packed = []
cdef unsigned int i
for i in range(256*64/2):
packed.append( (imd[i*2]//16)<<4 | (imd[i*2+1]//16) )
return packed
甚至可能更快（15毫秒）
def packer4(it):
"""Cythonize python nibble packing loop, typed"""
cdef unsigned int n = len(it)//2
cdef unsigned int i
return [ (it[i*2]//16)<<4 | it[i*2+1]//16 for i in range(n) ]
此处有timeit
>>> timeit.timeit('packer4(data)', setup='from pack import packer4; data = [0]*256*64', number=100)
1.31725951000044
>>> exit()
pi@raspberrypi:~ $ python3 -m timeit -s 'from pack import packer4; data = [0]*256*64' 'packer4(data)'
100 loops, best of 3: 9.04 msec per loop
这已经满足了我的要求，但我想输入/输出可迭代（ - ＆gt; unsigned int array？）或使用更宽的数据类型访问输入数据可能会进一步优化（Raspbian是32位，{ {3}}是ARM1176JZF-S单核）。
或BCM2835或多核Raspberry Pis上的并行性。
与C（GPU）中相同循环的粗略比较：
#include <stdio.h>
#include <stdint.h>
#define SIZE (256*64)
int main(void) {
uint8_t in[SIZE] = {0};
uint8_t out[SIZE/2] = {0};
uint8_t t;
for(t=0; t<100; t++){
uint16_t i;
for(i=0; i<SIZE/2; i++){
out[i] = (in[i*2]/16)<<4 | in[i*2+1]/16;
}
}
return 0;
}
它显然快了100倍：
pi@raspberry:~ $ gcc p.c
pi@raspberry:~ $ time ./a.out
real 0m0.085s
user 0m0.060s
sys 0m0.010s
消除转移/除法可能是另一个轻微的优化（我没有检查结果C，也没有检查二进制）：
def packs(bytes it):
"""Cythonize python nibble packing loop, typed"""
cdef unsigned int n = len(it)//2
cdef unsigned int i
return [ ( (it[i<<1]&0xF0) | (it[(i<<1)+1]>>4) ) for i in range(n) ]
结果
python3 -m timeit -s 'from pack import pack; data = bytes([0]*256*64)' 'pack(data)'
100 loops, best of 3: 12.7 msec per loop
python3 -m timeit -s 'from pack import packs; data = bytes([0]*256*64)' 'packs(data)'
100 loops, best of 3: 12 msec per loop
python3 -m timeit -s 'from pack import packs; data = bytes([0]*256*64)' 'packs(data)'
100 loops, best of 3: 11 msec per loop
python3 -m timeit -s 'from pack import pack; data = bytes([0]*256*64)' 'pack(data)'
100 loops, best of 3: 13.9 msec per loop