在函数外部调用函数内部的函数，两个方式，一个是return 返回值，用返回值，第二是声明是全局变量用global

可以使用这两种方式在函数外部调用函数内部的函数。如果需要在函数外部使用函数内部的变量，可以使用全局变量来实现。但是需要注意，全局变量的使用应该谨慎，因为它可能会影响程序的可读性和可维护性。在实际编程中，应该尽量避免使用全局变量，而是使用函数参数和返回值来传递数据。

相关问题

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

以下是一个简单的函数实现，它接受一个字符串参数，并在其中查找特定的子字符串。如果找到了，则返回 True，否则返回 False。该函数还具有默认参数，可以自定义要查找的子字符串。

def search_substring(string, sub_string="hello"):
    # 使用全局变量
    global global_variable
    
    # 搜索子字符串
    if sub_string in string:
        # 修改全局变量的值
        global_variable = 100
        
        # 修改列表参数的值
        string_list = list(string)
        string_list[0] = "H"
        string = "".join(string_list)
        
        return True, string
    else:
        return False, None

在这个函数中，我们使用了默认参数 `sub_string="hello"`，这意味着如果我们不提供第二个参数，函数将搜索 "hello" 子字符串。我们还使用了两个返回值，这两个返回值分别是布尔值和字符串。如果找到了子字符串，则第一个返回值为 True，第二个返回值为修改后的字符串。否则，第一个返回值为 False，第二个返回值为 None。

我们还使用了全局变量 `global_variable`，并在函数内部修改了它的值。此外，我们还将字符串参数转换为列表，并在列表上进行操作，然后将其转换回字符串。这样的操作将修改原始参数的值。

接下来，我们将使用这个函数进行一些实验来验证上述功能。

## 实验1：默认参数的使用

我们首先调用该函数并只提供一个字符串参数，而不提供第二个参数：

result, modified_string = search_substring("hello world")
print(result)   # True
print(modified_string)  # "Hello world"

在这个例子中，函数使用默认参数 "hello" 进行搜索，并返回找到了子字符串的结果以及修改后的字符串。

## 实验2：函数的返回值

我们现在将使用函数的两个返回值来检查函数的工作原理：

result, modified_string = search_substring("world")
print(result)   # False
print(modified_string)  # None

result, modified_string = search_substring("Hey, hello there!")
print(result)   # True
print(modified_string)  # "Hey, Hello there!"

在这个例子中，我们使用了不同的字符串参数来测试函数。第一个字符串中没有子字符串 "hello"，所以函数返回 False 和 None。第二个字符串中有子字符串 "hello"，所以函数返回 True 和修改后的字符串。

## 实验3：变量的作用域

我们将在函数内部和外部定义一个变量，并在函数内部和外部分别访问它们：

global_variable = 0   # 全局变量

def search_substring(string, sub_string="hello"):
    local_variable = 5   # 局部变量
    print("local_variable inside function:", local_variable)
    
    # 访问全局变量
    print("global_variable inside function (before modification):", global_variable)
    
    # 修改全局变量的值
    global_variable = 100
    
    if sub_string in string:
        return True
    else:
        return False

local_variable = 10   # 局部变量
print("local_variable outside function:", local_variable)

# 访问全局变量
print("global_variable outside function (before modification):", global_variable)

result = search_substring("hello world")

# 访问全局变量
print("global_variable outside function (after modification):", global_variable)

在这个例子中，我们定义了两个变量：全局变量 `global_variable` 和局部变量 `local_variable`。我们在函数内部和外部分别访问这两个变量，并在函数内部修改了全局变量的值。

## 实验4：在函数内部使用全局变量

我们将在函数内部访问和修改全局变量 `global_variable` 的值：

global_variable = 0   # 全局变量

def search_substring(string, sub_string="hello"):
    # 访问全局变量
    print("global_variable inside function (before modification):", global_variable)
    
    # 修改全局变量的值
    global global_variable
    global_variable = 100
    
    if sub_string in string:
        return True
    else:
        return False

# 访问全局变量
print("global_variable outside function (before modification):", global_variable)

result = search_substring("hello world")

# 访问全局变量
print("global_variable outside function (after modification):", global_variable)

在这个例子中，我们在函数内部使用了关键字 `global` 来将全局变量 `global_variable` 带入函数作用域中，并修改了它的值。我们还在函数外部访问了全局变量的值，以验证它是否在函数内部正确修改了。

## 实验5：在函数内部修改全局变量的值

我们将在函数内部修改全局变量 `global_variable` 的值：

global_variable = 0   # 全局变量

def search_substring(string, sub_string="hello"):
    # 修改全局变量的值
    global global_variable
    global_variable += 1
    
    if sub_string in string:
        return True
    else:
        return False

print("global_variable outside function (before modification):", global_variable)

result = search_substring("hello world")

print("global_variable outside function (after modification):", global_variable)

在这个例子中，我们在函数内部使用关键字 `global` 将全局变量 `global_variable` 带入函数作用域中，并将其值加 1。我们还在函数外部访问了全局变量的值，以验证它是否在函数内部正确修改了。

## 实验6：以可变数据类型作为参数

我们将使用可变数据类型（列表）作为函数的参数，并在函数内部修改它的值：

def modify_list(my_list):
    my_list.append(4)
    my_list[0] = 100

original_list = [1, 2, 3]
print("Original list:", original_list)

modify_list(original_list)
print("Modified list:", original_list)

在这个例子中，我们定义了一个函数 `modify_list`，它接受一个列表作为参数，并在其中添加一个新元素并修改第一个元素的值。我们还定义了一个原始列表 `original_list`，并将其作为参数传递给函数。在函数调用后，我们打印了修改后的列表，以验证函数是否正确地修改了列表。

## 实验7：重新赋值与修改

我们将定义一个函数，它接受一个整数作为参数并对其进行重新赋值和修改：

def reassign_vs_modify(my_int):
    # 重新赋值
    my_int = 10
    
    # 修改值
    my_int += 5
    
    return my_int

original_int = 1
print("Original integer:", original_int)

new_int = reassign_vs_modify(original_int)
print("New integer:", new_int)
print("Original integer (after function call):", original_int)

在这个例子中，我们定义了一个函数 `reassign_vs_modify`，它接受一个整数作为参数，并将其重新赋值为 10，然后将其增加 5。我们还定义了一个原始整数 `original_int`，并将其作为参数传递给函数。在函数调用后，我们打印了修改后的整数和原始整数，以验证函数是否重新分配了变量名称而不是修改了原始参数的值。

有一个一维数组，内放 10 个学生成绩，写一个函数，当主函数调用此函数后，能求出平均分、最高分和最低分。解题思路:调用一个函数可以得到一个函数返回值，现在希望通过函数调用能得到3个结果。可以利用全局变量来达到此目的。用C语言

以下是一个求解平均分、最高分和最低分的函数实现：

#include <stdio.h>

int scores[10]; // 全局数组，存放学生成绩

void calc_stats(int num_scores, int *max, int *min, double *avg) {
    int i;
    *max = scores[0];
    *min = scores[0];
    *avg = 0.0;
    for (i = 0; i < num_scores; ++i) {
        if (scores[i] > *max) {
            *max = scores[i];
        }
        if (scores[i] < *min) {
            *min = scores[i];
        }
        *avg += scores[i];
    }
    *avg /= num_scores;
}

int main() {
    int i, max, min;
    double avg;
    printf("请输入 10 个学生成绩：\n");
    for (i = 0; i < 10; ++i) {
        scanf("%d", &scores[i]);
    }
    calc_stats(10, &max, &min, &avg);
    printf("最高分：%d\n", max);
    printf("最低分：%d\n", min);
    printf("平均分：%.2f\n", avg);
    return 0;
}

这个程序中，全局变量 `scores` 存放学生成绩。`calc_stats` 函数接受学生成绩数量、指向最高分、最低分和平均分的指针作为参数，并计算出这三个值。主函数读取学生成绩并调用 `calc_stats` 函数，然后输出计算结果。