如何遍历字符串列表，进行一些字符串操作并返回它们？

Question

Here is the way I come up with:

a = 'bats bear'
b = 'cats pear'

def sub_strings(a, b):
    for s in [a, b]:
        s = re.sub('\\b.ear\\b', '', s)  
    return a, b

a, b = sub_strings(a, b)

But that doesn't work at all, and the function still outputs the original strings ('bats bear', 'cats pear') . What's wrong with this approach?

Answer 1

s = re.sub('\\b.ear\\b', '', s) 

does not do what you think it does. It merely rebinds the variable named s to the modified string returned by re.sub() . It does not alter the variables a nor b . You can check that by printing out the value of s in the loop.

Instead you can return a generator:

def sub_strings(a, b):
    return (re.sub(r'\b.ear\b', '', s) for s in (a, b))

A list comprehension will also work:

def sub_strings(a, b):
    return [re.sub(r'\b.ear\b', '', s) for s in (a, b)]

Either way, the result will be unpacked into the variables a and b as required.

---

You might want to consider generalising the function so that it accepts an arbitrary number of parameters:

def sub_strings(*args):
    return (re.sub(r'\b.ear\b', '', s) for s in args)

Now you can call it with any number of arguments:

>>> print(list(sub_strings('bats bear', 'cats pear', 'rats hear')))
['bats ', 'cats ', 'rats ']
>>> print(list(sub_strings('bats bear', 'cats pear', 'rats hear', 'gnats rear')))
['bats ', 'cats ', 'rats ', 'gnats ']

Answer 2

Try this

a = 'bats bear'
b = 'cats pear'

def sub_strings(a, b):
    result = []
    for s in [a, b]:
        result.append(re.sub('\\b.ear\\b', '', s)  )
    return result[0], result[1]

a, b = sub_strings(a, b)

Answer 3

The problem you are having is that in Python, strings (ie, str type objects) are immutable objects. Because a string object cannot be changed, ANY function you perform on a string never changes the original string . It ALWAYS remains the same:

>>> s = 'abc'
>>> s.replace('abc', 'def') #  perform some method on s
>>> print(s) #  has s been changed?
abc # NOPE

If you want to get a manipulated version of your string, you have to save the manipulated version somewhere and return THAT . The other answers that have been provided show clearly how to do this.

As for your actual problem, I would suggest using a generator. A generator is a function that behaves very differently from a normal function. One of these differences is the generator function is capable of generating multiple results- one at a time- with only a single function call.

To make a generator, instead of using the word return , you use yield . Here is an example:

a = 'bats bear'
b = 'cats pear'

def sub_string_gen(*strings):
    for s in strings:
        yield re.sub('\\b.ear\\b', '', s)  

a, b = sub_strings(a, b) #  generator is "unpacked" here

Note that the *strings syntax allows the function to accept multiple arguments. The arguments are available inside your function under a list with the name strings .

The reason the above code works is that the last line auto-magically performs an UNPACKING of your executed generator. In other words, each result is yielded one at a time, and unpacked into the corresponding provided names one at a time.

Be careful, however, that you don't try to do THIS:

a = sub_strings(a) #  BAD!

This will NOT work the way you expect. It will not work because a = sub_strings(a) does not unpack the generator; it instead creates a generator and assigns it to a ; the generator has NOT been unpacked. Clarification on terminology: sub_strings is a generator function ; sub_strings(a,b,c) creates a generator using that generator function.

To unpack the generator to a single name, do this instead:

a, = sub_strings(a) #  Note the comma

The extra comma makes the a into a tuple of symbols instead of a singleton. This lets the interpreter know that you mean to "unpack" the generator into the lone symbol, a .

I like this syntax very much because it keeps you from making errors that are not always easy to see. For example, if you provide too many arguments to sub_strings but not enough variables, it will give you an error and let you know there is a problem:

>>> a, b = sub_strings(a, b, c) #  extra c argument
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)

Another way to use your generator is to simply stuff the results into a list, a tuple, or anything else that accepts an iterable object (generators are iterable):

>>> results = list(sub_strings(a, b, c, d, e, f))

There is also another very nice alternative syntax that does the same thing. Here we see that star again (some people call it the "splat"). The splat "unpacks" the generator one value at a time, much the same as it was automatically unpacked before:

>>> results = [*sub_strings(a, b, c, d, e, f)]

Lastly: you don't even have to define a function to make a generator. You can instead just use what is called a generator expression .

>>> a, b = (re.sub('\\b.ear\\b', '', s)  for s in (a, b))

You can use such an expression in any of the places we used our generator above:

>>> results = list((re.sub('\\b.ear\\b', '', s)  for s in (a, b)))
>>> results = [*(re.sub('\\b.ear\\b', '', s)  for s in (a, b))]

Observe that the part that is called the generator expression replaced the generator function call- which creates a generator- in the previous versions of the code.

However, if your goal is a list an even shorter syntax is just to use what is called a list comprehension:

>>> results = [re.sub('\\b.ear\\b', '', s)  for s in (a, b)]

There is much, MUCH more to learn about Python generators. Go here to get started.