Python 函数更改变量的值

我面临以下问题； 假设我有以下几点：

a = 0

def something(variable):
    variable = variable + 1

something(a)

print(a)

输出为0而不是1

若我在函数中使用“全局变量”行，程序将显示以下错误：

“名称‘a’是参数且全局”

---

有什么提示可以让这个工作吗？或者在Python中是不可能的？

变量将函数作为参数输入，并将其作为返回值：

def something(variable)
    variable += 1
    return variable

a = 0
a = something(a)
print(a)

---

变量将函数作为参数输入，并将其作为返回值保留：

def something(variable)
    variable += 1
    return variable

a = 0
a = something(a)
print(a)

---

变量将函数作为参数输入，并将其作为返回值保留：

def something(variable)
    variable += 1
    return variable

a = 0
a = something(a)
print(a)

---

变量将函数作为参数输入，并将其作为返回值保留：

def something(variable)
    variable += 1
    return variable

a = 0
a = something(a)
print(a)

---

Python没有概念上等价的

void func（int*a）

或

void func（int&a）

，它们可以在C-like中用作“in/out”参数。虽然python中的方法参数是按引用传递的，但所有数值类型都是不可变的，因此更改数值变量值的唯一方法是通过赋值，赋值为该名称创建新引用，而不是更改现有值

更改示例中

a

值的最简单方法当然是将返回值指定给输入：

a = do_something(a)

这样做的潜在问题是，任何别名为

a

的内容都不会反映更改，即

a = 0
b = a
a = do_something(a)
print(a)
>>> 1
print(b)
>>> 0

要获得与

int*a

等效的行为，您必须将数值包装在一个简单的可变数据结构中，如列表/目录，或放入类中。举例如下：

class mutable_number(object):
    def __init__(value):
        self._value = value

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, value):
        self._value = value

list_a  = [0]
dict_a  = {'a':0}
class_a = mutable_number(0)

def do_something_l(lst):
    lst[0] += 1

def do_something_d(dct):
    dct['a'] += 1

def do_something_c(cls):
    cls.value += 1

do_something_l(list_a)
do_something_d(dict_a)
do_something_c(class_a)

print(list_a[0])
print(dict_a['a'])
print(class_a.value)
>>> 1
>>> 1
>>> 1

这些表单都可以使用别名正常工作，所以如果我已经这样做了

class_a = mutable_number(0)
class_b = class_a

然后在最后

print(class_b.value)
>>> 1

您将获得预期的输出

要记住的另一点是，python支持通过元组进行多次返回的简单语法：

return a,b,c

---

异常被认为是很好的编程风格，因此C-like中的“in/out”参数的许多用例实际上并不需要（例如：在

void

中改变输入参数、返回错误代码或改变多个输入参数）。

Python在概念上没有与

void func（int*a）等价的东西

或

void func（int&a）

可在C-like中用作“in/out”参数。虽然python中的方法参数是按引用传递的，但所有数值类型都是不可变的，因此更改数值变量值的唯一方法是通过赋值，赋值为该名称创建新引用，而不是更改现有值

更改示例中

a

值的最简单方法当然是将返回值指定给输入：

a = do_something(a)

这样做的潜在问题是，任何别名为

a

的内容都不会反映更改，即

a = 0
b = a
a = do_something(a)
print(a)
>>> 1
print(b)
>>> 0

要获得与

int*a

等效的行为，您必须将数值包装在一个简单的可变数据结构中，如列表/目录，或放入类中。举例如下：

class mutable_number(object):
    def __init__(value):
        self._value = value

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, value):
        self._value = value

list_a  = [0]
dict_a  = {'a':0}
class_a = mutable_number(0)

def do_something_l(lst):
    lst[0] += 1

def do_something_d(dct):
    dct['a'] += 1

def do_something_c(cls):
    cls.value += 1

do_something_l(list_a)
do_something_d(dict_a)
do_something_c(class_a)

print(list_a[0])
print(dict_a['a'])
print(class_a.value)
>>> 1
>>> 1
>>> 1

这些表单都可以使用别名正常工作，所以如果我已经这样做了

class_a = mutable_number(0)
class_b = class_a

然后在最后

print(class_b.value)
>>> 1

您将获得预期的输出

要记住的另一点是，python支持通过元组进行多次返回的简单语法：

return a,b,c

---

异常被认为是很好的编程风格，因此C-like中的“in/out”参数的许多用例实际上并不需要（例如：在

void

中改变输入参数、返回错误代码或改变多个输入参数）。

Python在概念上没有与

void func（int*a）等价的东西

或

void func（int&a）

可在C-like中用作“in/out”参数。虽然python中的方法参数是按引用传递的，但所有数值类型都是不可变的，因此更改数值变量值的唯一方法是通过赋值，赋值为该名称创建新引用，而不是更改现有值

更改示例中

a

值的最简单方法当然是将返回值指定给输入：

a = do_something(a)

这样做的潜在问题是，任何别名为

a

的内容都不会反映更改，即

a = 0
b = a
a = do_something(a)
print(a)
>>> 1
print(b)
>>> 0

要获得与

int*a

等效的行为，您必须将数值包装在一个简单的可变数据结构中，如列表/目录，或放入类中。举例如下：

class mutable_number(object):
    def __init__(value):
        self._value = value

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, value):
        self._value = value

list_a  = [0]
dict_a  = {'a':0}
class_a = mutable_number(0)

def do_something_l(lst):
    lst[0] += 1

def do_something_d(dct):
    dct['a'] += 1

def do_something_c(cls):
    cls.value += 1

do_something_l(list_a)
do_something_d(dict_a)
do_something_c(class_a)

print(list_a[0])
print(dict_a['a'])
print(class_a.value)
>>> 1
>>> 1
>>> 1

这些表单都可以使用别名正常工作，所以如果我已经这样做了

class_a = mutable_number(0)
class_b = class_a

然后在最后

print(class_b.value)
>>> 1

您将获得预期的输出

要记住的另一点是，python支持通过元组进行多次返回的简单语法：

return a,b,c

---

异常被认为是很好的编程风格，因此C-like中的“in/out”参数的许多用例实际上并不需要（例如：在

void

中改变输入参数、返回错误代码或改变多个输入参数）。

Python在概念上没有与

void func（int*a）等价的东西

或

void func（int&a）

可在C-like中用作“in/out”参数。虽然python中的方法参数是按引用传递的，但所有数值类型都是不可变的，因此更改数值变量值的唯一方法是通过赋值，赋值为该名称创建新引用，而不是更改现有值

更改示例中

a

值的最简单方法当然是将返回值指定给输入：

a = do_something(a)

这样做的潜在问题是，任何别名为

a

的内容都不会反映更改，即

a = 0
b = a
a = do_something(a)
print(a)
>>> 1
print(b)
>>> 0

要获得与

int*a

等效的行为，您必须将数值包装在一个简单的可变数据结构中，如列表/目录，或放入类中。举例如下：

class mutable_number(object):
    def __init__(value):
        self._value = value

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, value):
        self._value = value

list_a  = [0]
dict_a  = {'a':0}
class_a = mutable_number(0)

def do_something_l(lst):
    lst[0] += 1

def do_something_d(dct):
    dct['a'] += 1

def do_something_c(cls):
    cls.value += 1

do_something_l(list_a)
do_something_d(dict_a)
do_something_c(class_a)

print(list_a[0])
print(dict_a['a'])
print(class_a.value)
>>> 1
>>> 1
>>> 1

这些表单都可以使用别名正常工作，所以如果我已经这样做了

class_a = mutable_number(0)
class_b = class_a

然后在最后

print(class_b.value)
>>> 1

您将获得预期的输出

要记住的另一点是，python支持通过元组进行多次返回的简单语法：

return a,b,c

异常被认为是良好的编程风格，所以C-like中“in/out”参数的许多用例并不是真正需要的