You don't need regular expressions. Python has a built-in string method that does what you need:

mystring.replace(" ", "_")

If you want to avoid replace, a faster method would just split and join. This is faster simply because .split and .join are fast:

"20%".join(string.split(" "))

For a more thorough review, I'll point out that your functions aren't equivalent. The first strips whitespace and the second doesn't. One of them must be wrong!

In the second case:

def replace_token_inplace(s, token=" "):
    for index, char in enumerate(s):
        if ord(char) == ord(token):
            s[index] = '20%'
    return s

you are doing several non-idiomatic things. For one, you are mutating and returning a list. It's better to just not return it if you mutate:

def replace_token_inplace(s, token=" "):
    for index, char in enumerate(s):
        if ord(char) == ord(token):
            s[index] = '20%'

Secondly, it'll probably be faster to do a copying transform:

def replace_token_inplace(s, token=" "):
    for char in s:
        if ord(char) == ord(token):
            yield '20%'
        else:
            yield char

which can also be written

def replace_token_inplace(s, token=" "):
    for char in s:
        yield '20%' if ord(char) == ord(token) else char

or even

def replace_token_inplace(s, token=" "):
    return ('20%' if ord(char) == ord(token) else char for char in s)

If you want to return a list, use square brackets instead of round ones.

You almost certainly have a string with a space variant in it, not the bog-standard U+0020 SPACE but more likely U+00A0 NO-BREAK SPACE. The two characters look exactly the same when printed:

>>> 'MavNandi\xa07'
'MavNandi\xa07'
>>> print('MavNandi\xa07')
MavNandi 7

There may be others; the Unicode stardard defines 17 space separators for example, many of these look like a regular space (with varying width).

As you can see the interpreter, when echoing the value uses the \xa0 escape sequence to differentiate the two. You can produce the same output by using the repr() function when printing:

>>> print(repr('MavNandi\xa07'))
'MavNandi\xa07'

There is also a ascii() function, this works just like repr() but replaces any character outside the ASCII range with an escape sequence, making it perhaps easier to see combining characters and distinguish between Unicode glyphs that would otherwise look alike.

You could use a regular expression to replace all whitespace characters, including no-break spaces, tabs, newlines and anything else the Unicode standard designates as whitespace:

import re

username = re.sub('\s+', '', username)

The \s character class matches any such whitespace character, the + matches 1 or more such character when replacing; the second argument replaces all such matches with the empty string.

Demo:

>>> import re
>>> re.sub('\s+', '', 'MavNandi\xa07')
'MavNandi7'

Are you compelled to use regex? This task can easily ne accomplished by using str.translate and string.punctuation as the deletechars

>>> from string import punctuation
>>> a="what is. your. name? It's good"
>>> a.translate(None, punctuation)
'what is your name Its good'

If you are compelled to use regex, another option for you would be

>>> from string import punctuation
>>> r = re.compile(r'[{}]+'.format(re.escape(punctuation)))
>>> r.sub('', a)
'what is your name Its good'

But, I would still suggest you to reconsider the design. Using Regex for this task is an overkill.

I believe, using the tools specially designed for text processing is faster than invoking a script written in a general-purpose interpreted language such as Python.

SED doesn't support Unicode escape sequences, but it is possible to pass the actual characters using command substitution:

sed -i -e "s/ /$(printf '\uE000')/g; s/\(.\)/ \1 /g" file

Perl is my favorite, because it is very flexible. It is also much better for text processing than Python:

The Perl languages borrow features from other programming languages including C, shell script (sh), AWK, and sed... They provide powerful text processing facilities without the arbitrary data-length limits of many contemporary Unix commandline tools,... facilitating easy manipulation of text files.

(from Wikipedia)

Example:

perl -CSDL -p -i -e 's/ /\x{E000}/g ; s/(.)/ \1 /g' file

Note, the -CSDL option enables UTF-8 for the output.

There is also an AWKward way of doing this using GNU AWK version 4.1.0 or newer:

gawk -i inplace '{
a = gsub(/ /, "\xee\x80\x80");
a = gensub(/(.)/, " \\1 ", "g");
print a; }' file

But I wouldn't recommend for obvious reasons.

I doubt that anyone would claim that a specific tool, or algorithm is the fastest one, as there are plenty of factors that may affect the performance, - hardware, the way the tools are compiled, tool versions, the kernel version, etc. Perhaps, the best way to find the right tool, or algorithm is to benchmark. I don't think it necessary to mention the time command.