Python仅在我第一次调用函数时声明变量

我在python中有一个函数，我只想在第一次调用该函数时声明2个变量，然后更改它们的值，类似这样：

def function():
  x=0
  z=2
  if(x>z):
    other_function()
  else:
    x+=1

通过这种方式，每次调用

函数（）

，x变为0，z变为2

我试图使它们在函数（）之外成为全局的，但它给了我错误：

UnboundLocalError:赋值前引用了局部变量“x”

---

如何在第一次调用函数（）时声明值？

如果要从函数之外的某个地方获取x和z，则必须将它们作为参数传递给

函数。例如：

def function(a,b):
    if(a>b):
        other_function()
    else:
        a+=1

    return a, b

然后可以用

x, z = function(0,2)

如果要从函数之外的某个地方获取x和z，则必须将它们作为参数传递给
函数。例如：

def function(a,b):
    if(a>b):
        other_function()
    else:
        a+=1

    return a, b

然后可以用

x, z = function(0,2)

可以使用默认函数参数

即。）

如果您传递了
x或z的值，则会使用传递的值，否则会将其初始化为函数中给定的值
您可以使用默认函数参数

即。）

如果您传递了
x或z的值，则会使用传递的值，否则会将其初始化为函数中给定的值
您可以小心地滥用强大的可变默认值

def func(vals = {'x': 0, 'z': 2}):
    print vals['x']
    vals['x'] += 1

func()
>> 0
func()
>> 1
func()
>> 2

尽管我认为正确的方法是使用装饰器：

def default_value_decorator(func):
    def inner(*args, **kwargs):
        returned_val = func(*args, **kwargs)
        inner.x += 1
        return returned_val
    inner.x = 0
    inner.z = 2
    return inner

@default_value_decorator
def func():
    print func.x

func()
>> 0
func()
>> 1

def default_value_decorator(x, z):
    def a(func):
        def inner(*args, **kwargs):
            returned_val = func(*args, **kwargs)
            inner.x += 1
            return returned_val
        inner.x = x
        inner.z = z
        return inner
    return a

@default_value_decorator(0, 2)
def func():
    print func.x

func()
>> 0
func()
>> 1

还有一个更可重用的版本，其中
x
和
z
的起始值可以传递给装饰器：

def default_value_decorator(func):
    def inner(*args, **kwargs):
        returned_val = func(*args, **kwargs)
        inner.x += 1
        return returned_val
    inner.x = 0
    inner.z = 2
    return inner

@default_value_decorator
def func():
    print func.x

func()
>> 0
func()
>> 1

def default_value_decorator(x, z):
    def a(func):
        def inner(*args, **kwargs):
            returned_val = func(*args, **kwargs)
            inner.x += 1
            return returned_val
        inner.x = x
        inner.z = z
        return inner
    return a

@default_value_decorator(0, 2)
def func():
    print func.x

func()
>> 0
func()
>> 1

您可以小心地滥用强大的可变默认值

def func(vals = {'x': 0, 'z': 2}):
    print vals['x']
    vals['x'] += 1

func()
>> 0
func()
>> 1
func()
>> 2

尽管我认为正确的方法是使用装饰器：

def default_value_decorator(func):
    def inner(*args, **kwargs):
        returned_val = func(*args, **kwargs)
        inner.x += 1
        return returned_val
    inner.x = 0
    inner.z = 2
    return inner

@default_value_decorator
def func():
    print func.x

func()
>> 0
func()
>> 1

def default_value_decorator(x, z):
    def a(func):
        def inner(*args, **kwargs):
            returned_val = func(*args, **kwargs)
            inner.x += 1
            return returned_val
        inner.x = x
        inner.z = z
        return inner
    return a

@default_value_decorator(0, 2)
def func():
    print func.x

func()
>> 0
func()
>> 1

还有一个更可重用的版本，其中
x
和
z
的起始值可以传递给装饰器：

def default_value_decorator(func):
    def inner(*args, **kwargs):
        returned_val = func(*args, **kwargs)
        inner.x += 1
        return returned_val
    inner.x = 0
    inner.z = 2
    return inner

@default_value_decorator
def func():
    print func.x

func()
>> 0
func()
>> 1

def default_value_decorator(x, z):
    def a(func):
        def inner(*args, **kwargs):
            returned_val = func(*args, **kwargs)
            inner.x += 1
            return returned_val
        inner.x = x
        inner.z = z
        return inner
    return a

@default_value_decorator(0, 2)
def func():
    print func.x

func()
>> 0
func()
>> 1

您可以在Python中使用词法作用域和全局：

x = 0
z = 2
def foo():
    global x
    if (x > z):
        bar()
    else:
        x += 1
foo()

您可以在Python中使用词法作用域和全局：

x = 0
z = 2
def foo():
    global x
    if (x > z):
        bar()
    else:
        x += 1
foo()

欢迎来到

你应该这样写：


def f（x）：
def g（y）：
返回x+y
返回g

def h（x）：
返回λy:x+y

a=f（1）
b=h（1）
f（1）（5）
h（1）（5）
欢迎来到

你应该这样写：


def f（x）：
def g（y）：
返回x+y
返回g

def h（x）：
返回λy:x+y

a=f（1）
b=h（1）
f（1）（5）
h（1）（5）
为了更好的可读性，我会把它们放在字典里：

_VALS = {'x': 0, 'z': 2}
def function():
  if _VALS['x'] > _VALS['z']:
    other_function()
  else:
     _VALS['x'] += 1

为了更好的可读性，我会把它们放在字典里：

_VALS = {'x': 0, 'z': 2}
def function():
  if _VALS['x'] > _VALS['z']:
    other_function()
  else:
     _VALS['x'] += 1

我不同意其他答案，他们只是试图直接回答你的问题

您有状态（变量）与使用该状态的函数的组合。这就是课程的目的

class myclass:
    def __init__(self):
        self.x = 0
        self.z = 2

    def myfunction(self):
        if self.x > self.z:
            other_function()  # Possibly self.other_function()
                              # if that one also uses x or z
        else:
            self.x += 1

用作：

instance = myclass()
instance.myfunction()
instance.myfunction()  # Etc

我不同意其他答案，他们只是试图直接回答你的问题

您有状态（变量）与使用该状态的函数的组合。这就是课程的目的

class myclass:
    def __init__(self):
        self.x = 0
        self.z = 2

    def myfunction(self):
        if self.x > self.z:
            other_function()  # Possibly self.other_function()
                              # if that one also uses x or z
        else:
            self.x += 1

用作：

instance = myclass()
instance.myfunction()
instance.myfunction()  # Etc

不幸的是，这不起作用，因为a是本地的，所以
a+=1
不起作用。然而你的想法是好的。啊，非常正确。我将编辑以反映这将不起作用，不幸的是，因为a将是本地的，因此
a+=1
将不起作用。然而你的想法是好的。啊，非常正确。我将编辑以反映这一点！非常感谢。成功了！非常感谢。