按函数更改字符串值[重复]

Question

我注意到我的代码中有很多这样的语句：

var = "some_string"
var = some_func(var)
var = another_func(var)
print(var)  # outputs "modified_string"

这真的让我很烦，它看起来很糟糕（与整个 Python 相反）。 如何避免使用它并以这样的方式开始使用它：

var = "some_string"
modify(var, some_func)
modify(var, another_func)
print(var) # outputs "modified_string"

Answer 1

这可能不是最“pythonic”的事情，但你可以“包装”你的字符串在一个列表中，因为列表是 em> 在 Python 中是可变的。 例如：

var = "string"
var_wrapper = [var]

现在您可以将该列表传递给函数并访问其唯一元素。更改后，它将在函数外部可见：

def change_str(lst):
    lst[0] = lst[0] + " changed!"

你会得到：

>>> change_str(var_wrapper)
>>> var_wrapper[0]
"string changed!"

---

为了使内容更具可读性，您可以更进一步，创建一个 "wrapper" 类：

class my_str:
    def __init__(self, my_string):
        self._str = my_string

    def change_str(self, new_str):
        self._str = new_str

    def __repr__(self):
        return self._str

现在让我们运行相同的示例：

>>> var = my_str("string")
>>> var
string
>>> var.change_str("new string!")
>>> var
new string!

^{* 感谢@Error-SyntacticalRemorse 提出上课的意见。}

Answer 2

事实上，已经有at least one attempt 为functools 添加了compose 函数。我想我明白他们为什么不这样做了……但是，这并不意味着我们不能自己制造：

def compose(f1, f2):
    def composition(*args, **kwargs):
        return f1(f2(*args, **kwargs))
    return composition

def compose_many(*funcs):
    if len(funcs) == 1:
        return funcs[0]
    if len(funcs) == 2:
        return compose(funcs[0], funcs[1])
    else:
        return compose(funcs[0], compose_many(*funcs[1:]))

测试：

>>> def append_foo(s):
...     return s + ' foo'
... 
>>> def append_bar(s):
...     return s + ' bar'
... 
>>> append_bar(append_foo('my'))
'my foo bar'
>>> compose(append_bar, append_foo)('my')
'my foo bar'
>>> def append_baz(s):
...     return s + ' baz'
... 
>>> compose_many(append_baz, append_bar, append_foo)('my')
'my foo bar baz'

想一想，这可能不是解决您问题的最佳方法。但是写起来很有趣。

Answer 3

问题是str、int 和 float（long 也是，如果你在 Py 2.x 中（True 和 False 真的是 ints，所以它们也是））是你在 Python 中所说的“不可变类型”。这意味着您不能修改它们的内部状态：对str（或int 或float）的所有操作都将导致str 的“新” 实例（或其他），而旧值将保留在 Python 的缓存中，直到下一个垃圾回收周期。

基本上，您无能为力。对不起。

Answer 4

其他人已经解释了为什么这是不可能的，但你可以：

for modify in some_func, other_func, yet_another_func:
 var = modify(var)

或如 pst 所说：

var = yet_another_func(other_func(some_func(var)))

Answer 5

字符串在 python 中是不可变的，所以你的第二个例子不能工作。在第一个示例中，您将名称 var 绑定到每行上的一个全新对象。

通常对一个名称进行多次赋值是一种代码异味。也许如果您在这里发布更大的代码示例，有人可以向您展示更好的方法？

Answer 6

有一种方法可以修改不可变变量，通过在本地符号表中重写它，但是，我认为这不是很好，应该尽可能避免。

def updatevar(obj, value, callingLocals=locals()):
    callingLocals[next(k for k, o in callingLocals.items() if o is obj)] = value

另一种方式，甚至更少 Pythonic，是将 exec 与格式化指令一起使用。由于this solution，它以字符串形式获取变量名：

def getname(obj, callingLocals=locals()):
    """
    a quick function to print the name of input and value.
    If not for the default-Valued callingLocals, the function would     always
    get the name as "obj", which is not what I want.
    """
    return next(k for k, v in callingLocals.items() if v is obj)

def updatevar2(k, v, callingLocals=locals()):
    n = getname(k, callingLocals)
    exec('global {};{}={}'.format(n, n, repr(v)))

结果如预期：

var = "some_string"
updatevar(var, "modified_string")
print(var) # outputs "modified_string"
updatevar2(var, var + '2')
print(var) # outputs "modified_string2"

Answer 7

我只是把它放在这里（因为似乎还没有答案解决它）

如果您经常重复相同的函数序列，请考虑将它们包装在更高级别的函数中：

def metafunc(var):
    var = somefunc(var)
    var = otherfunc(var)
    var = thirdfunc(var)
    return lastfunc(var)

然后，当您调用函数metafunc 时，您确切地知道您的var 发生了什么：什么都没有。你从函数调用中得到的只是metafunc 返回的任何东西。 此外，您可以确定您忘记的程序部分没有发生任何事情。这一点非常重要，尤其是在脚本语言中，通常会有很多你不知道/记得的幕后发生的事情。

这有利有弊，理论讨论属于纯函数式编程范畴。一些现实世界的交互（例如 i/o 操作）需要非纯函数，因为它们需要超出代码执行范围的现实世界影响。 这里简要定义其背后的原理：

http://en.wikipedia.org/wiki/Functional_programming#Pure_functions