如何在 Python 中声明全局变量

另一个块可以访问的变量称为全局变量。它可以在块外部定义。换句话说，全局变量是在函数外部定义的，我们可以在函数内部访问它。

另一方面，在一个块中定义并在该块中可用的变量称为局部变量。这样的变量只能在定义的块中访问。

让我们理解以下局部和全局变量的例子。

示例-局部变量


# example of local variable
def sum():
    a = 10   # local variables
    b = 20
    c = a + b
    print("the sum is:", c)

sum()  # function calling

输出:

The sum is: 30

解释:

变量是在函数内部定义的，它只能在已定义的函数中使用，因此变量的性质称为局部变量。我们无法在其他功能中访问它们。

为了克服这个问题，我们使用全局变量。让我们理解一个全局变量的例子。

示例-


# example of a global variable
a = 20   # defined outside the function
b = 10

def sum():
    c = a + b  # Using global variables
    print("The sum is:", c)

def sub():
    d = a - b   # using global variables
    print("The sub is:", d)

sum()  # function calling
sub()

输出:

The sum is: 30
The sub is: 10

解释:

在上面的代码中，我们在函数外定义了两个全局变量 a 和 b。我们在 sum()和 sub()函数中使用了它们。当我们调用时，这两个函数都返回结果。

如果我们定义相同名称的局部变量，它将打印函数内部的值，然后打印全局变量值。

示例- 3:


def msg():
    m = "Hello, how are you?"
    print(m)

msg()
m = "I am fine"  # global scope
print(m)

输出:

Hello, how are you?
I am fine

解释:

我们已经定义了与全局变量同名的局部变量；首先，它打印局部变量，然后打印全局变量值。

全球关键词

Python 提供了全局关键字，用于修改函数内部全局变量的值。当我们想要改变全局变量的值或分配一些其他值时，这是有益的。下面是一些定义全局变量的规则。

全局关键词规则

如果该值被定义为函数输出，它将自动成为全局变量或其全局范围。
全局关键字用于声明函数内部的全局变量。
我们不需要使用全局关键字来声明函数外部的全局变量。
函数内部有引用的变量是隐式全局。

示例-没有全局关键字


# The example of without using the global keyword

c = 10

def mul():

    # Multiply by 10
    c = c * 10
    print(c)

mul()

输出:

line 8, in mul
    c = c * 10
UnboundLocalError: local variable 'c' referenced before assignment

解释:

上面的代码抛出了一个错误，因为我们试图给全局变量赋值。我们可以使用 global 关键字修改函数内部的 global value 的值。

示例-带有全局关键字


# The example using the global keyword

c = 10

def mul():
    global c
    # Multiply by 10
    c = c * 10
    print("The value inside function: ", c)

mul()
print('The value outside the function: ', c)

输出:

The value inside function:  100
The value outside the function:  100

解释:

在上面的例子中，我们已经使用全局关键字定义了 mul()函数中的变量 c。c 的值乘以 10；因此，它返回了 200。我们可以在输出中看到，函数内部值的变化反映在全局变量外部的值中。

Python 模块中的全局变量

全局关键字的好处是创建全局变量，并在不同的模块之间共享它们。例如-我们创建了一个由全局变量组成的名称. py 。如果我们改变这些变量，那么这种改变将无处不在。让我们理解下面的例子。

代码- 1: 创建一个 name.py 文件来存储全局变量。


a = 10
b = 20
msg = "Hello World"

代码- 2: 创建一个 change.py 文件来修改全局变量。


import name
name.a = 15
name.b = 26
name.msg = "Welcome to JavaTpoint"

这里，我们修改了 a、b 和 msg 的值。这些全局变量是在 name.py 文件中定义的，我们导入了 name，并访问了这些变量。

代码- 3: 制作一个 result.py 文件，打印修改后的全局变量。


import name 
import change
print(change.a) 
print(change.b)  
print(change.msg)

输出:

15
26
Welcome to JavaTpoint

嵌套函数中的全局

我们可以在嵌套函数中使用全局关键字。我们必须在嵌套函数中使用全局关键字声明变量。让我们理解下面的例子。

示例-


# The example of global in nested function

def add():
    a = 15

    def modify():
        global a
        a = 20

    print("Before modifying : ", a)
    print("Making change")
    modify()
    print("After modifying: ", a)

add()
print("value of x: ", a)

输出:

Before modifying :  15
Making change
After modifying:  15
value of x 20

说明:

在上面的代码中，add()内部的值取局部变量 x = 15 的值。在 modify()函数中，我们已经使用 global 关键字分配了 x = 20。这种变化反映在 add()函数变量中。

原创文章，作者：小蓝，如若转载，请注明出处：https://www.506064.com/n/253285.html