как изменить значение в вложенном списке в зависимости от элементов два других различных списков и функции трудно читать

Question

цели функции заключается в изменении элементов этого

image=[[(15,103,225), (0,3,19)],    
     [(22,200,1), (8,8,8)],    
     [(0,0,0), (5,123,19)]] 

в это с кодированием (вложенным, сообщение)

>>>encode(image,'hello) 
[[(14, 103, 255), (0, 3, 18)], [(22, 200, 0), (9, 9, 8)], [(0, 1, 0), (5, 122, 19)]] 

каждый символ в сообщении преобразуется в это соответствующий ASCII вещь, и тогда каждая вещь ASCII превращается в 8-значные, база-двух чисел. получил это.

теперь, чтобы изменить список, как выше, то, что я имею:

def char_to_bits(char): 
"""char_to_bits(char) -> string 

Convert the input ASCII character to an 8 bit string of 1s and 0s. 

>>> char_to_bits('A') 
'01000001' 
""" 
result = '' 
char_num = ord(char) 
for index in range(8): 
    result = get_bit(char_num, index) + result 
return result 


def get_bit(int, position): 
"""get_bit(int, position) -> bit 

Return the bit (as a character, '1' or '0') from a given position 
in a given integer (interpreted in base 2). 

The least significant bit is at position 0. The second-least significant 
bit is at position 1, and so forth. 

>>> for pos in range(8): 
...  print(b.get_bit(167, pos)) 
... 
1 
1 
1 
0 
0 
1 
0 
1 
""" 
if int & (1 << position): 
    return '1' 
else: 
    return '0' 

def message_to_bits(message): 
if len(message)==0: 
    return ''               
for m in message: 
    return "".join("".join(str(bits.char_to_bits(m)))for m in message) 

def set_bit_on(int, position): 
"""set_bit_on(int, position) -> int 

Set the bit at a given position in a given integer to 1, 
regardless of its previous value, and return the new integer 
as the result. 

The least significant bit is at position 0. The second-least significant 
bit is at position 1, and so forth. 

>>> set_bit_on(0, 0) 
1 
>>> set_bit_on(0, 1) 
2 
>>> set_bit_on(167, 3) 
175 
""" 
    return int | (1 << position) 

def set_bit_off(int, position): 
"""set_bit_off(int, position) -> int 

Set the bit at a given position in a given integer to 0, 
regardless of its previous value, and return the new integer 
as the result. 

The least significant bit is at position 0. The second-least significant 
bit is at position 1, and so forth. 

>>> set_bit_off(0, 0) 
0 
>>> set_bit_off(1, 0) 
0 
>>> set_bit_off(167, 0) 
166 
>>> set_bit_off(175, 3) 
167 
""" 
    return int & ~(1 << position) 

def set_bit(int, bit, position): 
"""set_bit(int, bit, position) -> int 

Set the bit at a given position to the given bit (as a char, either 
'1' or '0') regardless of its previous value, and return the new integer 
as the result. 

The least significant bit is at position 0. The second-least significant 
bit is at position 1, and so forth. 

>>> set_bit(0, '1', 0) 
1 
>>> set_bit(0, '1', 1) 
2 
>>> set_bit(0, '1', 2) 
4 
>>> set_bit(0, '1', 3) 
8 
>>> set_bit(175, '0', 3) 
167 
>>> set_bit(175, '1', 3) 
175 
""" 

    if bit == '1': 
     return set_bit_on(int, position) 
    else: 
     return set_bit_off(int, position)​ 

from collections import Iterable 
def flatten(nested):  
    for item in nested:   
     if isinstance(item, Iterable) and not isinstance(item, basestring):    
      for x in flatten(item):     
       yield x 
     else: 
      yield item 
def encode(nested, message): 
    position= 0 
    fnested= list(flatten(nested)) 
    bitlist= list("".join("".join(str(bits.char_to_bits(m)))for m in message)) 
    for int in fnested: 
     for bit in bitlist: 
      return "".join("".join(("".join(str(bits.set_bit(int,bit,position)))for int in fnested)) for bit in bitlist) 

закодированного материала возвращает строку длиной 1200, который является эпический провал, и это выглядит очень не-удобно.

пожалуйста, помогите

Answer 1

Первые несколько нот

• При работе с битами, строки используют в качестве последнего средства
• Не используйте list или int в качестве имен переменных

И наконец, на самом деле это не кодировка, поскольку вы никогда не сможете вернуть исходные данные. Вместо этого шифр XOR может лучше соответствовать вашим потребностям.

def message_to_bits(msg): 
    result = 0 
    for c in msg: 
     result = (result << 8) | ord(c) 
    return result 

def get_bit(num, position): 
    return num & (1 << position) 

def set_bit_on(num, position): 
    return num | (1 << position) 

def set_bit_off(num, position): 
    return num & ~(1 << position) 

def set_bit(num, value, position): 
    if value: 
     return num | (1 << position) 
    else: 
     return num & ~(1 << position) 

def encode(nested_list_thing, key): 
    key_bits = message_to_bits(key) 
    key_length = 8 * len(key) 
    print ('key: {:0%db}' % key_length).format(key_bits) 

    # Mask keeps track of which bit in 
    # key_bits we are using to set the value of 
    mask = 1 << (key_length - 1) 

    result = [] 
    for list_ in nested_list_thing: 
     encoded_list = [] 

     for tuple_ in list_: 
      encoded_tuple = [] 

      for num in tuple_: 
       # Encode the number 
       set_to_bit = key_bits & mask 
       encoded_num = set_bit(num, set_to_bit, 0) 
       encoded_tuple.append(encoded_num) 
       # Move to next position in key_bits 
       mask = mask >> 1 
      encoded_list.append(tuple(encoded_tuple)) 
     result.append(encoded_list) 
    return result 

image = [[(15, 103, 225), (0, 3, 19)], 
     [(22, 200, 1), (8, 8, 8)], 
     [(0, 0, 0), (5, 123, 19)]] 
key = 'hello' 
print encode(image, key) 

Это выводит

> key: 0110100001100101011011000110110001101111 
> [[(14, 103, 225), (0, 3, 18)], [(22, 200, 0), (9, 9, 8)], [(0, 1, 0), (5, 122, 19)]] 

EDIT: О расшифровке: Если я дал вам закодированный список и ключ, как вы можете сказать, что биты были перед процессом кодирования? Вы не можете. Ключ только говорит вам, что биты были установлены, а не то, что они были до того, как вы их установили.

Вот почему я рекомендовал шифрование XOR вместо того, чтобы устанавливать бит на определенное значение, мы переворачиваем некоторые и оставляем других в покое. Если у вас нет ключа, вы не знаете, какие биты были перевернуты и какие остались. Если у вас есть ключ, вы снова переворачиваете их, чтобы вернуть оригинал.

Попробуйте изменить эти строки в encode

... 
     for num in tuple_: 
      xor_key = 1 if key_bits & mask else 0 
      encoded_num = num^xor_key 
      encoded_tuple.append(encoded_num) 
      # Move to next position in key_bits 
      mask = mask >> 1 
    ... 

затем этого в нижней

image = [[(15, 103, 225), (0, 3, 19)], 
     [(22, 200, 1), (8, 8, 8)], 
     [(0, 0, 0), (5, 123, 19)]] 

key = 'hello' 

encoded_image = encode(image, key) 
decoded_image = encode(encoded_image, key) 

print encoded_image 
print decoded_image 

Это должно дать вам

> [[(15, 102, 224), (0, 2, 19)], [(22, 200, 1), (9, 9, 8)], [(0, 1, 0), (4, 123, 18)]] # <-- encoded 
> [[(15, 103, 225), (0, 3, 19)], [(22, 200, 1), (8, 8, 8)], [(0, 0, 0), (5, 123, 19)]] # <-- decoded