Python，混淆列表中的字母

Question

I have created a list characters = list(original.lower()) to list an input of a four letter word. This breaks down the input into sepearte characters and makes them all lowercase.

In a following function I need to call each letter that was seperated and replace them with 1 of 5 set ascii chars which are ! % * # @

I have created the list into a var called - obfuscate = ["!", "%", "*", "#", "@"] and now need to but have no idea how to bring in each char and apply a random symbol to each of the letters of the input.

original = input("Enter a 4-letter word:  ")

    letters = isolate_letters(original) 
    obsfucate_letters(letters) 
    obfuscated = recompose_obfuscated_letters(letters)

    print("Original:  ", original)
    print("Obfuscated:  ", obfuscated)

def isolate_letters(original):

    characters = list(original.lower())
    print (characters)
    return characters


def obsfucate_letters(original):

    import random
    obfuscate = ["!", "%", "*", "#", "@"]
    print (random.choice(obfuscate))

EDIT:

def obfuscate_letters(word):

    import random
    new_word = ''
    for char in word:
        if random.random() < 0.9:
            new_word += random.choice(['!', '%', '&', '#', '@'])
        else:
            new_word += char
    letters = new_word
    print (letters)

def recompose_obfuscated_letters(letters):

        obfuscated = ''.join(letters)
        return obfuscated

These are my last two functions, i cannot get the letters variable returned:

this is the respons to dddd:

!@%!
Original: dddd 
Obfuscated: dddd

The top line of garble is what i need to go next to the Obfuscated bit ;/

Answer 1

You could make a dictionary that can map the letter to its obfuscated character

import random
def encode(word, symbols):
    obfuscate = list(symbols)
    random.shuffle(obfuscate)
    d = dict(zip(word, obfuscate))
    return ''.join(d[i] for i in word)

>>> obfuscate = ["!", "%", "*", "#", "@"]
>>> word = 'test'
>>> encode(word, obfuscate)
'#%*#'

In the encode function, the third line creates a dictionary of the following form

{'s': '*',
 't': '#',
 'e': '%'}

Since I am shuffling the list before zip ing it, the map will be randomly paired. See the following few test calls

>>> encode(word, obfuscate)
'%!#%'
>>> encode(word, obfuscate)
'@#%@'
>>> encode(word, obfuscate)
'@#*@'
>>> encode(word, obfuscate)
'%!*%'
>>> encode(word, obfuscate)
'@*%@'

Answer 2

If you don't need to recreate the word latter. Here's a one line solution.

import random
def obfuscate(word):
    return ''.join([random.choice(["!", "%", "*", "#", "@"]) for char in word])

Explantion:

[... for ... in ...] is a list comprehension , it generates a list of random characters using the random.choice(), then the ''.join() , concatenate all the generated characters in a single string.

---

EDIT:

what if the 'word' was a user input (a four letter word)?

user_input = raw_input("Enter a 4-letter word:  ")
if len(user_input) == 4:
    print obfuscate(user_input)

is there a way that there is a 10% chance of a letter in the word being left alone and not being changed?

For this the list comprehension won't work (as far as I know), but you can still do it in a for loop.

def obsfucate(word):
    new_word = ''
    for char in word:
        if random.random() > 0.1:
            new_word += random.choice(["!", "%", "*", "#", "@"])
        else:
            new_word += char
    return new_word

output:

Enter a 4-letter word:  Damn
D%*#

---

EDIT2:

Actually you can use list comprehensions!

def obsfucate(word):
    return ''.join([random.choice(["!", "%", "*", "#", "@"]) if random.random() > 0.1 else char for char in word])

But for me it gets a little messy.

---

EDIT 3:

Full code should be something like:

import random

def obfuscate(word):
    new_word = ''
    for char in word:
        if random.random() > 0.1:
            new_word += random.choice(["!", "%", "*", "#", "@"])
        else:
            new_word += char
    return new_word

user_input = raw_input("Enter a 4-letter word:  ")
if len(user_input) == 4:
    print "Original:", user_input
    print "Obfuscate:", obfuscate(user_input)

Output:

Enter a 4-letter word:  Damn
Original: Damn
Obfuscate: D@m%

---

If you want to use you code as it is:

import random

def isolate_letters(original):
    characters = list(original.lower())
    return characters

def obsfucate(word):
    return [random.choice(["!", "%", "*", "#", "@"]) if random.random() > 0.1 else char for char in word]

def recompose_obfuscated_letters(letters):
    obfuscated = ''.join(letters)
    return obfuscated

original = input("Enter a 4-letter word:  ")

letters = isolate_letters(original)
obsfucate_letters = obsfucate(letters)
obfuscated = recompose_obfuscated_letters(obsfucate_letters)

print("Original:", original)
print("Obfuscated:", obfuscated)

Output:

Enter a 4-letter word:  Damn
Original: Damn
Obfuscated: d!!%

Answer 3

This is my whole code, that you can use as is in your code excerpt.

from __future__ import print_function

def isolate_letters(s):
    return [c for c in s]

def obfuscate_letters(loc):
    from random import shuffle
    funny = ['!', '%', '*', '#', '@']
    # shuffle the list of funny characters
    shuffle(funny)
    # create a dictionary
    d = {c:f for f,c in zip(funny,set(loc))}
    # change in place the list of characters
    for i, c in enumerate(loc):
        loc[i] = d[c]

def recompose_obfuscated_letters(looc):
    return "".join(looc)

# here it is a copy and past from your OP (except for the spellung of obfuscate...)
original = 'funk'
letters = isolate_letters(original)
obfuscate_letters(letters)
obfuscated = recompose_obfuscated_letters(letters)

print('Original:    "%s"' % original)
print('Obfuscated:  "%s"' % obfuscated)

the output I have is

Original:    "funk"
Obfuscated:  "*#%@"

Key is using the shuffle function from the random module. shuffle changes at random the positions of the items in a list, so that when I access the terms in funny sequentially, I in effect access them at random...

Next issue, I find the unique characters in the input word using set() and then construct a mapping, from real characters to funny characters.

The last step is, of course, go through the original list and changing all its items one by one using the mapping that we have defined two lines above.

(this last part, modifying in place the original list, follows from how the OP coded her/his example)

Answer 4

A new answer because the OP has, substantially, a new question

def obfuscate_letters(s,funny=[c for c in "!!!%%%&&&###@@@  "]):
    from random import shuffle
    shuffle(funny)
    for i, c in enumerate(s):
        s[i] = funny[i] if funny[i] != ' ' else s[i]

(yes, the default argument is mutable and changes at each invocation)