Python中的洗牌位

作为Python的初学者，我认为创建一个超越我掌握掌握Python语言能力的项目是很好的。不幸的是，项目中最困难的部分涉及到移动比特，这是另一个挑战，因为我发现很难将我的头围绕比特。我知道每个操作员都在做什么，我只是觉得很难让他们做我想做的事情

显然，我失败了，因此提出了这个问题

我试图通过使用预定义的索引列表更改位顺序来加密字符串。我认为我做得很好，但它不起作用，我不知道为什么

即使当我的代码应该完成这项工作时，我也很不确定它是否能在不同类型的数据中工作（没有错误）。欢迎更多反馈

---

test.py

import bitshuffle, random

# New bit order
# TODO present this as an int, rather a string
code = "01234567"
code = "".join(random.sample(code, len(code)))

# The data obviously
data = b'Jalape\xc3\xb1o\x00\xff'

encrypted = bitshuffle.encrypt(code, data)
decrypted = bitshuffle.decrypt(code, encrypted)

print data         # Jalapeño�
print encrypted    # �d�d,tGi��
print decrypted    # Jalapeño�

---

bitshuffle.py

import struct

def encrypt(code, data):
    """
    encrypt(string, string) --> string
    Shuffles bits according to code
    """
    format = str(len(data)) + 'c'

    chars = struct.unpack(format, data)
    args = [format]

    for c in chars:
        dec = ord(c)
        ndec = 0

        for i in xrange(8):
            bit = dec >> i & 1
            ndec = ndec | bit << int(code[i])

        args.append(chr(ndec))

    return struct.pack(*args)

def decrypt(code, data):
    """
    decrypt(string, string) --> string
    Shuffles bits according to code
    """

    format = str(len(data)) + 'c'

    chars = struct.unpack(format, data)
    args = [format]

    for c in chars:
        dec = ord(c)
        ndec = 0

        for i in xrange(8):
            bit = dec >> i & 1
            ndec = ndec | bit << code.find(str(i))

        args.append(chr(ndec))

    return struct.pack(*args)

导入结构
def加密（代码、数据）：
"""
加密（字符串，字符串）-->字符串
根据代码洗牌位
"""
格式=str（len（data））+'c'
chars=struct.unpack（格式、数据）
args=[格式]
对于以字符表示的c：
dec=作战需求文件（c）
ndec=0
对于x范围内的i（8）：
bit=dec>>i&1
无损检测=无损检测|位>i&1
ndec=ndec | bit您还没有指定作为
code
传递的确切内容，以及为什么需要在其上调用
int（）

那么，问题之一就是你总是朝着同一个方向移位，所以你的“解密”例程不会撤销你的“加密”例程正在做的事情

将
0b10000000
左移一位不会使其成为
0b0000001
，结果是
0b100000000
 
7-代码[i]
不起作用。你应该把
代码
倒过来

例如，如果代码是
[1,3,5,7,0,2,4,6]
，则反向应该是
[4,0,5,1,6,2,7,3]
。（
4
相反，表示原始代码中
0
的索引。）


code[4]==0
code[0]==1
code[5]==2



导入结构
>>>
>>>def加密（代码、数据）：
...     返回算法（代码、数据）
...
>>>def解密（代码、数据）：
...     code={x:i表示枚举（code）}#>>def算法（code，data）中的i，x：
...     chars=struct.unpack（'c'*len（数据），data）
...     args=['c'*len（数据）]
...     对于以字符表示的c：
...         dec=作战需求文件（c）
...         ndec=0
...         对于x范围内的i（8）：
...             bit=dec>>i&1
...             ndec=ndec |位>>代码=[1,3,5,7,0,2,4,6]
>>>加密（代码“abc”）
“\x16\x1c\x1e”
>>>解密（代码）
“abc”
请描述预期结果和观察到的结果。我想我是个白痴，但我希望你上面写的列表“颠倒”会是。。。颠倒的。我不明白发生了什么事。为什么
[1,3,5,7,0,2,4,6]
没有反转
[6,4,2…]
@bigbadonk420，我没有写任何“反转d”。你是什么意思？我指的是你在回答中上面说“反向应该是”的那部分。@bigbadonk420，你读了括号中的解释了吗（
4
，反向是指原始代码中
0
的索引）？我现在明白了，我误解了你的答案。如果你说
code[4]
解析为
0
而不是
4
解析为
0
，也许会更清楚，我把索引编号和实际值弄混了：）无论如何，我还是不明白答案，但可能只有我一个人，所以别担心。
>>> import struct
>>>
>>> def encrypt(code, data):
...     return algorithm(code, data)
...
>>> def decrypt(code, data):
...     code = {x:i for i, x in enumerate(code)} # <----
...     return algorithm(code, data)
...
>>> def algorithm(code, data):
...     chars = struct.unpack('c' * len(data), data)
...     args = ['c' * len(data)]
...     for c in chars:
...         dec = ord(c)
...         ndec = 0
...         for i in xrange(8):
...             bit = dec >> i & 1
...             ndec = ndec | bit << code[i]
...         args.append(chr(ndec))
...     return struct.pack(*args)
...
>>> code = [1, 3, 5, 7, 0, 2, 4, 6]
>>> encrypt(code, 'abc')
'\x16\x1c\x1e'
>>> decrypt(code, _)
'abc'