How do I reverse words in a string with Python

Try splitting each word in the string into a list (see: https://docs.python.org/2/library/stdtypes.html#str.split).

Example:

>>string = "This will be split up"
>>string_list = string.split(" ")
>>string_list
>>['This', 'will', 'be', 'split', 'up']

Then iterate through the list and reverse each constituent list item (i.e. word) which you have working already.

orig = "what is my name"
reverse = ""
for word in orig.split():
    reverse = "{} {}".format(reverse, word[::-1])
print(reverse)

def reverse_in_place(phrase):
    res = []
    phrase = phrase.split(" ")
    for word in phrase:
        word = word[::-1]
        res.append(word)
    res = " ".join(res)
    return res

Since everyone else’s covered the case where the punctuation moves, I’ll cover the one where you don’t want the punctuation to move.

import re
def reverse_words(sentence):
    return re.sub(r'[a-zA-Z]+', lambda x : x.group()[::-1], sentence)

Breaking this down.

re is python’s regex module, and re.sub is the function in that module that handles substitutions. It has three required parameters.

The first is the regex you’re matching by. In this case, I’m using r'w+'. The r denotes a raw string, [a-zA-Z] matches all letters, and + means “at least one”.

The second is either a string to substitute in, or a function that takes in a re.MatchObject and outputs a string. I’m using a lambda (or nameless) function that simply outputs the matched string, reversed.

The third is the string you want to do a find in a replace in.

So “What is my name?” -> “tahW si ym eman?”

Addendum:

I considered a regex of r'w+' initially, because better unicode support (if the right flags are given), but w also includes numbers and underscores. Matching - might also be desired behavior: the regexes would be r'[a-zA-Z-]+' (note trailing hyphen) and r'[w-]+' but then you’d probably want to not match double-dashes (ie --) so more regex modifications might be needed.

The built-in reversed outputs a reversed object, which you have to cast back to string, so I generally prefer the [::-1] option.

[thread has been closed, but IMO, not well answered]

the python string.lib doesn’t include an in place str.reverse() method.
So use the built in reversed() function call to accomplish the same thing.

>>> S = ” what is my name”
>>> (“”).join(reversed(S))
’eman ym si tahw’

def rev(a):
    if a == "":
        return ""
    else:
        z = rev(a[1:]) + a[0]
        return z

Reverse string –> gnirts esreveR

def rev(k):
    y = rev(k).split()
    for i in range(len(y)-1,-1,-1):
        print y[i],

–>esreveR gnirts

There is no obvious way of reversing a string “truly” in-place with Python. However, you can do something like:

def reverse_string_inplace(string):
    w = len(string)-1
    p = w
    while True:
        q = string[p]
        string = ' ' + string + q
        w -= 1
        if w < 0:
            break
    return string[(p+1)*2:]

Hope this makes sense.

In Python, strings are immutable. This means you cannot change the string once you have created it. So in-place reverse is not possible.

There are many ways to reverse the string in python, but memory allocation is required for that reversed string.

print(' '.join(word[::-1] for word in string))

inplace refers to modifying the object without creating a copy. Yes, like many of us has already pointed out that python strings are immutable. So technically we cannot reverse a python string datatype object inplace. However, if you use a mutable datatype, say bytearray for storing the string characters, you can actually reverse it inplace

#slicing creates copy; implies not-inplace reversing
def rev(x):
    return x[-1::-1]

# inplace reversing, if input is bytearray datatype
def rev_inplace(x: bytearray):
    i = 0; j = len(x)-1
    while i<j:
        t = x[i]
        x[i] = x[j]
        x[j] = t
        i += 1; j -= 1
    return x

Input:

x = bytearray(b'some string to reverse')      
rev_inplace(x)

Output:

bytearray(b'esrever ot gnirts emose')

s1 = input("Enter a string with multiple words:")

print(f'Original:{s1}')
print(f'Reverse is:{s1[::-1]}')

each_word_new_list = []

s1_split = s1.split()

for i in range(0,len(s1_split)):
    each_word_new_list.append(s1_split[i][::-1])

print(f'New Reverse as List:{each_word_new_list}')

each_word_new_string=' '.join(each_word_new_list)

print(f'New Reverse as String:{each_word_new_string}')

If the sentence contains multiple spaces then usage of split() function will cause trouble because you won’t know then how many spaces you need to rejoin after you reverse each word in the sentence. Below snippet might help:

# Sentence having multiple spaces
given_str = "I  know this   country runs by mafia "
tmp = ""
tmp_list = []
for i in given_str:
    if i != ' ':
        tmp = tmp + i
    else:      
        if tmp == "":
            tmp_list.append(i)
        else:
            tmp_list.append(tmp)
            tmp_list.append(i)
            tmp = ""

print(tmp_list)
rev_list = []
for x in tmp_list:
    rev = x[::-1]
    rev_list.append(rev)
print(rev_list)
print(''.join(rev_list))

output: