Try This

{unicodedata.normalize("NFKD", key): unicodedata.normalize("NFKD", item) for key, item in dict1.items()}

Output

 'Repeat interval': '23 days',
 'Epoch': '25 January 2015, 00:45:13 UTC[2]',
 'Band': 'S Band(TT&C support)X Band(science data acquisition)',
 'Bandwidth': 'up to 722kbit/s download (S Band)up to 18.4Mbit/s download (X Band)up to 4kbit /s upload (S Band)'}

This should do the trick:

for emote, replacement in dict_lookup.items():
      text = text.replace(emote, replacement)

Mostly this looks good, but I’ll make a few suggestions:

Boolean arguments in your function signature

These control whether certain strings/mappings are lowercased first. I think this behaviour should be removed from keymap_replace(). It's scope creep: it’s gone from being string replacements to more complicated string manipulations. I’d leave that sort of manipulation to the caller.

(And you could continue to add options like this: what about uppercasing the string, or reversing it, or another pattern. Rather than muddling up your function with this, I’d just take it out.)

That makes the arguments simpler, and simplifies the function definition as well.

But if you really want those parameters in there, then I’d suggest making them keyword-only. In Python 3, you can insert an asterisk as so:

def keymap_replace(
    string: str, 
    mappings: dict,
    *,
    lower_keys=False,
    lower_values=False,
    lower_string=False,
) -> str:

and when the function is called, those boolean arguments have to be as keyword arguments, not positional. There can never be ambiguity in how the function is being used.

Dictionaries are unordered

There’s a possibility for ambiguity, or for substitutions to be chained. For example:

keymap_replace('Hello world', {
    'J': 'K',
    'H': 'J'
})

Should this call return "Jello world" or "Kello world"?

I think the first is more natural – I don’t expect substitutions to be chained – but when I tried the function, I got the latter. You should try to make this less confusing.

One possibility that springs to mind:

replaced_string = ''.join(mappings.get(char, char) for char in string)

Each character in the original string is subject to at most one substitution.

Yes, there exists better way:

def print_dict(d):
    new = {}
    for k, v in d.iteritems():
        if isinstance(v, dict):
            v = print_dict(v)
        new[k.replace('.', '-')] = v
    return new

(Edit: It's recursion, more on Wikipedia.)

after the editing I understood your question more properly, the recursion solution for unknown amount of nested dicts is as below:

def fixKeys(dictionary):
    for k,v in list(dictionary.items()):
        if isinstance(v, dict):
            dictionary[k.replace('.', '/')] = fixKeys(v)
        else:
            dictionary[k.replace('.', '/')] = v
        if "." in k:
            dictionary.pop(k)
    return dictionary

m_dict = {"gender":"male", "name.data": {"last.name":"Arabulut","first.name":"Altay","parents.names":{"father.name":"John","mother.name":"Jennifer"}}, "birthday.data":{"birthday.day":"01","birthday.month":"03","birthday.year":"1977"}}

new_dict = fixKeys(m_dict)
print(str(new_dict))

output:

{'gender': 'male', 'name/data': {'last/name': 'Arabulut', 'first/name': 'Altay', 'parents/names': {'father/name': 'John', 'mother/name': 'Jennifer'}}, 'birthday/data': {'birthday/day': '01', 'birthday/month': '03', 'birthday/year': '1977'}}

very good question. like the coding and debugging!

Strings are immutable, you can't change a character by assignment. You can use replace, if you do e.g.

val = val.replace(...)

But to change only the last character you need:

val = val[:-1] + val[-1].replace(...)

Or just:

val = val[:-1] + "d"

However, this still won't update the dictionary, again because strings are immutable and this creates a new object. To do that:

d[key] = ...

You can write a recursive function, like this

from collections.abc import Mapping
def rec_key_replace(obj):
    if isinstance(obj, Mapping):
        return {key.replace('.', '_'): rec_key_replace(val) for key, val in obj.items()}
    return obj

and when you invoke this with the dictionary you have shown in the question, you will get a new dictionary, with the dots in keys replaced with _s

{'delicious_apples': {'green_apples': 2}, 'green_pear': 4, 'brown_muffins': 5}

Explanation

Here, we just check if the current object is an instance of dict and if it is, then we iterate the dictionary, replace the key and call the function recursively. If it is actually not a dictionary, then return it as it is.

Have another dictionary with your replacements, like this

keys = {"a": "append", "h": "horse", "e": "exp", "s": "see"}

Now, if your events look like this

event_types = {"as": 0, "ah": 0, "es": 0, "eh": 0}

Simply reconstruct it with dictionary comprehension, like this

>>> {" ".join([keys[char] for char in k]): v for k, v in event_types.items()}   
{'exp see': 0, 'exp horse': 0, 'append see': 0, 'append horse': 0}

Here, " ".join([keys[char] for char in k]), iterates the characters in the k, fetches corresponding words from keys dictionary and forms a list. Then, the elements of the list are joined with space character, to get the desired key.

    address = "123 north anywhere street"
    
    for word, initial in {"NORTH": "N", "SOUTH": "S"}.items():
        address = address.replace(word.lower(), initial)
    print(address)

nice and concise and readable too.

import datetime
ticketsearch= "2019-10-11T23:57:34Z"
response= datetime.datetime.strptime(f'{ticketsearch}', '%Y-%m-%dT%H:%M:%SZ')
new_Date = response .strftime('%Y-%m-%d %H:%M:%S')