定义全局变量a ，将a作为参数传入函数，改变a的值

在Python中，定义全局变量可以使用关键字global，如下：

global a
a = 1

def change_value(a):
    a = 2
    print(a)

change_value(a)
print(a)

这段代码中，我们先定义了全局变量a，并赋值为1。然后定义了一个函数change_value，接收一个参数a。在函数中，我们将参数a的值改为2，然后打印出来。最后在函数外部，我们再次打印出a的值，看看是否被函数改变了。

当我们运行这段代码时，输出结果为：

2
1

可以看到，函数change_value中的a确实被改变了，但是全局变量a的值并没有受到影响。这是因为在函数中，我们使用了一个新的变量a来接收参数，而不是直接修改全局变量a。

如果我们希望在函数中直接修改全局变量a的值，可以在函数中使用global关键字，如下：

global a
a = 1

def change_value():
    global a
    a = 2
    print(a)

change_value()
print(a)

这段代码中，我们在函数中使用了global关键字声明了变量a是全局变量，然后直接修改了它的值。当我们运行这段代码时，输出结果为：

2
2

可以看到，函数中修改了全局变量a的值，而且函数外部打印a的值也变成了2。

相关问题

c++定义全局变量a ，将a作为参数传入函数，改变a的值

这是一个示例代码：

#include <stdio.h>

int a = 10; // 定义全局变量a

void changeValue(int *ptr) { // 定义函数，参数为指向整型变量的指针
    *ptr = 20; // 改变指针所指向的变量的值
}

int main() {
    printf("a = %d\n", a); // 输出全局变量a的值，输出结果为 a = 10
    changeValue(&a); // 将全局变量a的地址作为参数传入函数
    printf("a = %d\n", a); // 再次输出全局变量a的值，输出结果为 a = 20
    return 0;
}

在这个示例代码中，全局变量a被定义为整型变量，并且被初始化为10。然后，我们定义了一个函数changeValue，它接受一个指向整型变量的指针作为参数。在函数中，我们通过解引用指针来改变指针所指向的变量的值。在main函数中，我们首先输出全局变量a的值，然后将a的地址作为参数传入changeValue函数中，改变了a的值。最后，我们再次输出全局变量a的值，可以看到它已经被改变为20。

自行设计简单的函数实现（具体功能不限），并完成以下实验：（1）默认参数的使用；（2）函数的返回值（包括无返回值、一个及多个返回值）；（3）变量的作用域；（4）在函数内部使用全局变量；（4）在函数内部修改全局变量的值；（5）以可变数据类型（例如列表和字典）作为参数，在函数内部对其进行修改，并检验函数调用前后对应变量的值的变化情况；（6）参考“3.2 有关函数的更多信息.pdf”中的“重新赋值与修改（Reassignment vs Modifying）”部分内容，设计相关实验以检验在函数体内部修改值和重新分配变量名称之间的区别。

好的，我来设计一个函数，并完成以上实验。

我们来设计一个函数，可以接收一个列表作为参数，并返回该列表中所有偶数元素的和。如果不传入列表参数，则默认为一个空列表。

def sum_of_evens(lst=[]):
    """
    接收一个列表作为参数，并返回该列表中所有偶数元素的和
    如果不传入列表参数，则默认为一个空列表
    """
    # 在函数内部使用全局变量
    global total
    total = 0
    for num in lst:
        if num % 2 == 0:
            total += num
    return total

接下来我们进行实验：

1. 默认参数的使用

我们可以直接调用函数，不传入参数，此时将会使用默认参数。

print(sum_of_evens())  # 输出 0

2. 函数的返回值

函数 `sum_of_evens` 返回的是总和，我们可以将它打印出来，或者将它赋值给一个变量。

result = sum_of_evens([1, 2, 3, 4, 5, 6])
print(result)  # 输出 12

3. 变量的作用域

在函数内部定义的变量只能在函数内部使用，不能在函数外部使用。

def test_scope():
    x = 10  # 局部变量
    print(x)

test_scope()  # 输出 10
print(x)  # 报错，x 未定义

4. 在函数内部使用全局变量

我们可以在函数内部使用全局变量，但需要使用 `global` 关键字声明。

total = 0  # 全局变量

def sum_of_evens(lst=[]):
    global total  # 声明全局变量
    total = 0
    for num in lst:
        if num % 2 == 0:
            total += num
    return total

sum_of_evens([1, 2, 3, 4, 5, 6])
print(total)  # 输出 12

5. 在函数内部修改全局变量的值

如果我们在函数内部修改了全局变量的值，那么这个变量的值也会在函数外部被改变。

total = 0  # 全局变量

def sum_of_evens(lst=[]):
    global total  # 声明全局变量
    total = 0
    for num in lst:
        if num % 2 == 0:
            total += num
    return total

sum_of_evens([1, 2, 3, 4, 5, 6])
print(total)  # 输出 12

total = 100
print(total)  # 输出 100

6. 以可变数据类型作为参数，在函数内部对其进行修改

我们可以将一个列表作为参数传入函数，然后在函数内部修改它。这样做会改变原始列表的值。

def modify_list(lst):
    lst.append(10)
    lst[0] = 100

my_list = [1, 2, 3]
modify_list(my_list)
print(my_list)  # 输出 [100, 2, 3, 10]

7. 重新赋值与修改的区别

重新赋值和修改的区别在于，重新赋值会创建一个新的变量，并将其指向新的对象，而修改则是直接改变原始对象的值。

def reassign(x):
    x = 10

def modify(x):
    x.append(10)

y = 5
reassign(y)
print(y)  # 输出 5

z = [1, 2, 3]
print(z)  # 输出 [1, 2, 3]
modify(z)
print(z)  # 输出 [1, 2, 3, 10]