We Keep Coding

replace all characters in a string with asterisks

I have a string
name = "Ben"
that I turn into a list
word = list(name)
I want to replace the characters of the list with asterisks. How can I do this?
I tried using the .replace function, but that was too specific and didn't change all the characters at once.
I need a general solution that will work for any string.

I want to replace the characters of the list w/ asterisks
Instead, create a new string object with only asterisks, like this
word = '*' * len(name)
In Python, you can multiply a string with a number to get the same string concatenated. For example,
>>> '*' * 3
'***'
>>> 'abc' * 3
'abcabcabc'

You may replace the characters of the list with asterisks in the following ways:
Method 1
for i in range(len(word)):
word[i]='*'
This method is better IMO because no extra resources are used as the elements of the list are literally "replaced" by asterisks.
Method 2
word = ['*'] * len(word)
OR
word = list('*' * len(word))
In this method, a new list of the same length (containing only asterisks) is created and is assigned to 'word'.

I want to replace the characters of the list with asterisks. How can I
do this?
I will answer this question quite literally. There may be times when you may have to perform it as a single step particularly when utilizing it inside an expression
You can leverage the str.translate method and use a 256 size translation table to mask all characters to asterix
>>> name = "Ben"
>>> name.translate("*"*256)
'***'
Note because string is non-mutable, it will create a new string inside of mutating the original one.

Probably you are looking for something like this?
def blankout(instr, r='*', s=1, e=-1):
if '#' in instr:
# Handle E-Mail addresses
a = instr.split('#')
if e == 0:
e = len(instr)
return instr.replace(a[0][s:e], r * (len(a[0][s:e])))
if e == 0:
e = len(instr)
return instr.replace(instr[s:e], r * len(instr[s:e]))

Replacing symbols using list comprehension

I want to simplify replacing specific characters of a string in-situ - with a list comprehension. Attempts so far simply return a list of strings - each list item with each character replaced from the check string.
Advice / solutions?
Inputs:
reveal = "password"
ltrTried = "sr"
Required Output:
return = "**ss**r*"
Getting:
('**ss****', '******r*')

If you want to do this using a list comprehension, you'd want to replace it letter by letter like this:
reveal = "".join((letter if letter in ltrFound else "*") for letter in reveal)
Notice that
We're iterating over your reveal string, not your ltrFound list (or string).
Each item is replaced using the ternary operator letter if letter in ltrFound else "*". This ensures that if the letter in reveal is not in ltrFound, it will get replaced with a *.
We end by joining together all the letters.

Just for fun, here's a different way to do this immutably, by using a translation map.
If you wanted to replace everything that was in ltrFound, that would be easy:
tr = str.maketrans(ltrFound, '*' * len(ltrFound))
print(reveal.translate(tr))
But you want to do the opposite, replace everything that's not in ltrFound. And you don't want to build a translation table of all of the 100K+ characters that aren't s. So, what can you do?
You can build a table of the 6 characters that aren't in s but are in reveal:
notFound = ''.join(set(reveal) - set(ltrFound)) # 'adoprw'
tr = str.maketrans(notFound, '*' * len(notFound))
print(reveal.translate(tr))
The above is using Python 3.x; for 2.x, maketrans is a function in the string module rather than a classmethod of the str class (and there are a few other differences, but they don't matter here). So:
import string
notFound = ''.join(set(reveal) - set(ltrFound)) # 'adoprw'
tr = string.maketrans(notFound, '*' * len(notFound))
print(reveal.translate(tr))

try this
re.sub("[^%s]"%guesses,"*",solution_string)
assuming guesses is a string

Get character position in alphabet

I'm 90% sure there is a built in function that does this.
I need to find the position of a character in an alphabet. So the character "b" is position 1 (counting from 0), etc. Does anyone know what the function is called?
What I'm trying to do is to send all the characters X amount of "steps" back in the alpha bet, so if I have a string with "hi", it would be "gh" if I send it back one step. There might be a better way of doing it, any tips?

It is called index. For e.g.
>>> import string
>>> string.lowercase.index('b')
1
>>>
Note: in Python 3, string.lowercase has been renamed to string.ascii_lowercase.

Without the import
def char_position(letter):
return ord(letter) - 97
def pos_to_char(pos):
return chr(pos + 97)

You can use ord() to get a character's ASCII position, and chr() to convert a ASCII position into a character.
EDIT: Updated to wrap alphabet so a-1 maps to z and z+1 maps to a
For example:
my_string = "zebra"
difference = -1
new_string = ''.join((chr(97+(ord(letter)-97+difference) % 26) for letter in my_string))
This will create a string with all the characters moved one space backwards in the alphabet ('ydaqz'). It will only work for lowercase words.

# define an alphabet
alfa = "abcdefghijklmnopqrstuvwxyz"
# define reverse lookup dict
rdict = dict([ (x[1],x[0]) for x in enumerate(alfa) ])
print alfa[1] # should print b
print rdict["b"] # should print 1
rdict is a dictionary that is created by stepping through the alphabet, one character at a time. The enumerate function returns a tuple with the list index, and the character. We reverse the order by creating a new tuple with this code: ( x[1], x[0]) and then turn the list of tuples into a dictionary. Since a dictionary is a hash table (key, value) data structure, we can now look up the index of any alphabet character.
However, that is not what you want to solve your problem, and if this is a class assignment you would probably get 0 for plagiarism if you submit it. For encoding the strings, first create a SECOND alphabet that is organised so that alfa2[n] is the encoded form of alfa[n]. In your example, the second alphabet would be just shifted by two characters but you could also randomly shuffle the characters or use some other pattern to order them. All of this would continue to work with other alphabets such as Greek, Cyrillic, etc.

I've only just started learning Python, so I have no idea how efficient this is compared to the other methods, but it works. Also, it doesn't matter whether the text is upper case, lower case or if there is any punctuation etc.
If you want to change all letters:
from string import maketrans
textin = "abcdefghijklmnopqrstuvwxyz"
textout = "cdefghijklmnopqrstuvwxyzab"
texttrans = maketrans(textin, textout)
text = "qcc, gr umpiq"
print text.translate(texttrans)
Also works to change some characters:
from string import maketrans
textin = "81972"
textout = "Seios"
texttrans = maketrans(textin, textout)
text = "811, 9t w7rk2"
print text.translate(texttrans)

Here's a catch all method that might be useful for someone...
def alphabet(arg, return_lower=True):
"""
Indexing the english alphabet consisting of 26 letters.
Note: zero indexed
example usage:
alphabet('a')
>> 0
alphabet(25, return_lower=False)
>> 'Z'
:param arg: Either type int or type chr specifying the \
index of desired letter or ther letter at \
the desired index respectivley.
:param return_lower: If index is passes, returns letter \
with corresponding case. Default is \
set to True (lower case returned).
:returns: integer representing index of passed character \
or character at passed index.
"""
arg = str(arg)
assert arg.isdigit() or arg.isalpha()
if arg.isdigit():
if return_lower:
return chr(int(arg) + 97).lower()
return chr(int(arg) + 97).upper()
return ord(arg.lower()) - 97

Equivalent of COLUMN function in excel
def position(word):
if len(word)>1:
pos = 0
for idx, letter in enumerate(word[::-1]):
pos += (position(letter)+(1 if idx!=0 else 0))*26**(idx)
return pos
return ord(word.lower()) - 97
print(position("A")) --> 0
print(position("AA")) --> 26
print(position("AZ")) --> 51

Separating a string in Python

How would I separate characters once I have a string of unseparated words?
For example to translate "take the last character of the suffix and add a space to it every time ("aSuffixbSuffixcSuffix" --> "aSuffix bSuffix cSuffix").`
Or, more generally, to replace the x-nth character, where x is any integer (e.g., to replace the 3rd, 6th, 9th, etc. character some something I choose).

Assuming you're getting your string from this question, the easiest way is to not cram all the strings together in the first place. Your original create_word could be changed to this:
def create_word(suffix):
letters="abcdefghijklmnopqrstuvwxyz"
return [i + suffix for i in letters]
Then you'd be able to take e and ''.join(e) or ' '.join(e) to get the strings you want.

str = "SuffixbSuffixcSuffix"
def chunk_str(str, chunk_size):
return [str[i:i+chunk_size] for i in range(0, len(str), chunk_size)]
" ".join(chunk_str(str,3))
returns:
'Suf fix bSu ffi xcS uff ix'

You could use the replace method of strings. Check the documentation
initial = "aSuffixbSuffixcSuffix"
final = initial.replace("Suffix", "Suffix ")
print(final)

How to delete a character from a string using Python

There is a string, for example. EXAMPLE.
How can I remove the middle character, i.e., M from it? I don't need the code. I want to know:
Do strings in Python end in any special character?
Which is a better way - shifting everything right to left starting from the middle character OR creation of a new string and not copying the middle character?

In Python, strings are immutable, so you have to create a new string. You have a few options of how to create the new string. If you want to remove the 'M' wherever it appears:
newstr = oldstr.replace("M", "")
If you want to remove the central character:
midlen = len(oldstr) // 2
newstr = oldstr[:midlen] + oldstr[midlen+1:]
You asked if strings end with a special character. No, you are thinking like a C programmer. In Python, strings are stored with their length, so any byte value, including \0, can appear in a string.

To replace a specific position:
s = s[:pos] + s[(pos+1):]
To replace a specific character:
s = s.replace('M','')

This is probably the best way:
original = "EXAMPLE"
removed = original.replace("M", "")
Don't worry about shifting characters and such. Most Python code takes place on a much higher level of abstraction.

Strings are immutable. But you can convert them to a list, which is mutable, and then convert the list back to a string after you've changed it.
s = "this is a string"
l = list(s) # convert to list
l[1] = "" # "delete" letter h (the item actually still exists but is empty)
l[1:2] = [] # really delete letter h (the item is actually removed from the list)
del(l[1]) # another way to delete it
p = l.index("a") # find position of the letter "a"
del(l[p]) # delete it
s = "".join(l) # convert back to string
You can also create a new string, as others have shown, by taking everything except the character you want from the existing string.

How can I remove the middle character, i.e., M from it?
You can't, because strings in Python are immutable.
Do strings in Python end in any special character?
No. They are similar to lists of characters; the length of the list defines the length of the string, and no character acts as a terminator.
Which is a better way - shifting everything right to left starting from the middle character OR creation of a new string and not copying the middle character?
You cannot modify the existing string, so you must create a new one containing everything except the middle character.

Use the translate() method:
>>> s = 'EXAMPLE'
>>> s.translate(None, 'M')
'EXAPLE'

def kill_char(string, n): # n = position of which character you want to remove
begin = string[:n] # from beginning to n (n not included)
end = string[n+1:] # n+1 through end of string
return begin + end
print kill_char("EXAMPLE", 3) # "M" removed
I have seen this somewhere here.

card = random.choice(cards)
cardsLeft = cards.replace(card, '', 1)
How to remove one character from a string:
Here is an example where there is a stack of cards represented as characters in a string.
One of them is drawn (import random module for the random.choice() function, that picks a random character in the string).
A new string, cardsLeft, is created to hold the remaining cards given by the string function replace() where the last parameter indicates that only one "card" is to be replaced by the empty string...

On Python 2, you can use UserString.MutableString to do it in a mutable way:
>>> import UserString
>>> s = UserString.MutableString("EXAMPLE")
>>> type(s)
<class 'UserString.MutableString'>
>>> del s[3] # Delete 'M'
>>> s = str(s) # Turn it into an immutable value
>>> s
'EXAPLE'
MutableString was removed in Python 3.

Another way is with a function,
Below is a way to remove all vowels from a string, just by calling the function
def disemvowel(s):
return s.translate(None, "aeiouAEIOU")

Here's what I did to slice out the "M":
s = 'EXAMPLE'
s1 = s[:s.index('M')] + s[s.index('M')+1:]

To delete a char or a sub-string once (only the first occurrence):
main_string = main_string.replace(sub_str, replace_with, 1)
NOTE: Here 1 can be replaced with any int for the number of occurrence you want to replace.

You can simply use list comprehension.
Assume that you have the string: my name is and you want to remove character m. use the following code:
"".join([x for x in "my name is" if x is not 'm'])

If you want to delete/ignore characters in a string, and, for instance, you have this string,
"[11:L:0]"
from a web API response or something like that, like a CSV file, let's say you are using requests
import requests
udid = 123456
url = 'http://webservices.yourserver.com/action/id-' + udid
s = requests.Session()
s.verify = False
resp = s.get(url, stream=True)
content = resp.content
loop and get rid of unwanted chars:
for line in resp.iter_lines():
line = line.replace("[", "")
line = line.replace("]", "")
line = line.replace('"', "")
Optional split, and you will be able to read values individually:
listofvalues = line.split(':')
Now accessing each value is easier:
print listofvalues[0]
print listofvalues[1]
print listofvalues[2]
This will print
11
L
0

Two new string removal methods are introduced in Python 3.9+
#str.removeprefix("prefix_to_be_removed")
#str.removesuffix("suffix_to_be_removed")
s='EXAMPLE'
In this case position of 'M' is 3
s = s[:3] + s[3:].removeprefix('M')
OR
s = s[:4].removesuffix('M') + s[4:]
#output'EXAPLE'

from random import randint
def shuffle_word(word):
newWord=""
for i in range(0,len(word)):
pos=randint(0,len(word)-1)
newWord += word[pos]
word = word[:pos]+word[pos+1:]
return newWord
word = "Sarajevo"
print(shuffle_word(word))

Strings are immutable in Python so both your options mean the same thing basically.