For a simpler solution you could instead use rjust on the last 4 characters of the string, and fill it with # up to its original length:

s = 'TestName'
s[-4:].rjust(len(s), '#')

'####Name'

The problem with your function, is that you have to repeat the elements you want to use to replace as many times as replacements there will be. So you should do:

def maskify(cc):
    c2 = cc.replace(cc[:-4], '#'*len(cc[:-4]))
    return c2

As strings are immutable in Python, just create a new string which includes the value at the desired index.

Assuming you have a string s, perhaps s = "mystring"

You can quickly (and obviously) replace a portion at a desired index by placing it between "slices" of the original.

s = s[:index] + newstring + s[index + 1:]

You can find the middle by dividing your string length by 2 len(s)/2

If you're getting mystery inputs, you should take care to handle indices outside the expected range

def replacer(s, newstring, index, nofail=False):
    # raise an error if index is outside of the string
    if not nofail and index not in range(len(s)):
        raise ValueError("index outside given string")

    # if not erroring, but the index is still not in the correct range..
    if index < 0:  # add it to the beginning
        return newstring + s
    if index > len(s):  # add it to the end
        return s + newstring

    # insert the new string between "slices" of the original
    return s[:index] + newstring + s[index + 1:]

This will work as

replacer("mystring", "12", 4)
'myst12ing'

you can do

s="cdabcjkewabcef"
snew="".join((s[:9],"###",s[12:]))

which should be faster than joining like snew=s[:9]+"###"+s[12:] on large strings

There are two things you should do with this:

• Create a function that prints the current playing field, given the cells. So, you can print it whenever you want.
• Change the item of the cells list, which corresponds to the entered coordinates.

In the example below I used your code to look up the index of the cell you need to change by adding cellnum = coordinates.index(t_given_coordinates). This line defines a new integer variable that holds the cell number according to your map. You may then use this index to change the content of this cell and redraw the complete thing.

cells = ['-']*9

def print_matrix(cells):
    matrix = """
    ---------
    | {0} {1} {2} |
    | {3} {4} {5} |
    | {6} {7} {8} |
    ---------
    """.format(*cells)
    print(matrix)

coordinates = [
                ("1", "3"), ("2", "3"), ("3", "3"),
                ("1", "2"), ("2", "2"), ("3", "2"),
                ("1", "1"), ("2", "1"), ("3", "1")
]


print_matrix(cells)

end = False
while not end:
    try:
        given_coordinates = input("Enter the coordinates: ").split(", ")
        t_given_coordinates = tuple(given_coordinates)
        cellnum = coordinates.index(t_given_coordinates)
        cells[cellnum] = "X"
        print_matrix(cells)
    except:
        print("That was an invalid input")
        end = True

The output will look somewhat like that:

    ---------
    | - - - |
    | - - - |
    | - - - |
    ---------
    
Enter the coordinates: 1, 1

    ---------
    | - - - |
    | - - - |
    | X - - |
    ---------
    
Enter the coordinates: 2, 3

    ---------
    | - X - |
    | - - - |
    | X - - |
    ---------
    
Enter the coordinates: hello world
That was an invalid input

But, if I may suggest a slight change:

• The initial filling of the cells could already be the cell indices. So, the user just has to enter the index of the next cell to fill, which is a single integer. That's much less prone to raise errors. So, when the field is empty, it just reads:

---------
| 0 1 2 |
| 3 4 5 |
| 6 7 8 |
---------

You don't actually update s ever. So, your changes don't accrue. Try this:

for i in final_ranges:
    key = s[i[0]:i[1]]
    if (key in d):
        s = s[:i[0]] + d[key] + s[i[1]:]
        print(s)

Although, as has been stated in the comments, you should probably use replace:

for k, v in d.items():
    s = s.replace(k, v)
    print(s)

You can even do this as a list comprehension if you're willing to drop the print statement:

from functools import reduce
s = reduce(lambda string, kv: string.replace(kv[0], kv[1]), d.items(), s)

The problem is that .replace(old, new) returns a copy of the string in which the occurrences of old have been replaced with new.

Instead, you can swap the character at index i using:

new_str = old_str[:i] + "b" + old_str[i+1:]

strings are immutable (unchangeable). But you can index and join items.

mystring = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
mystring = 'ABCDE'.join([mystring[:20],mystring[24:]])

'XXXXXXXXXXXXXXXXXXXXABCDEXXXXXXXXXXXXXX'

Do be careful as the string length "ABCDE" and the number of items you omit between mystring[:20], mystring[24:] need to be the same length.