python精选11集（局部变量、全局变量、函数递归）

作业

作业1：

• 定义函数,删除列表中所有偶数,返回删除的数量

def delete_even(list_number):
    count = 0
    for i in range(len(list_number)-1,-1,-1):
        if list_number[i] % 2 == 0:
            count += 1
            del list_number[i]
    return count
list01 = [4,6,8,43,2,6,4,23,1,90,5,4,3]
# count = delete_even(list01)
count = delete_even(list01)
print(list01)
print("删除数量：",count)

作业2：

• 定义函数,实现对列表的降序排列

def desc_sort(list_number):
    for r in range(len(list_number)-1):
        for c in range(r+1,len(list_number)):
            if list_number[r] < list_number[c]:
                list_number[r],list_number[c] = list_number[c],list_number[r]

list01 = [4,5,6,7,8,9]
desc_sort(list01)
print(list01)

作业3：

# 商品信息列表
		shop_list_infos = [
    {"cid": 1001, "name": "戴尔", "price": 4634},
    {"cid": 1002, "name": "华硕", "price": 5743},
    {"cid": 1003, "name": "苹果", "price": 10325},
    {"cid": 1004, "name": "惠普", "price": 12000},
    {"cid": 1005, "name": "小米", "price": 7786},
]
# 订单列表
list_orders = [
    {"cid": 1001, "count": 3},
    {"cid": 1002, "count": 1},
    {"cid": 1005, "count": 5},
]
# 1.  定义函数,打印所有商品信息
def print_list_infos():
    for list_info in shop_list_infos:
        print("商品编号：%d,商品名称：%s,商品价格：%d"%(list_info["cid"],list_info["name"],list_info["price"]))
print_list_infos()
print("-----------------------------------------------")

# 2.  定义函数,查找商品单价小于1万的商品信息
def find_order_price(price):
    result = []
    for list_info in shop_list_infos:
        if list_info["price"] < price:
            #
            result.append(list_info)
    return result
res = find_order_price(10000)
for i in res:
    print("商品编号：%d,商品名称：%s,商品价格：%d" % (i["cid"], i["name"], i["price"]))
print("-----------------------------------------------")

# 3.  定义函数,计算订单总价格
def cal_sum():
    sum = 0
    for order in list_orders:
        for commodity in shop_list_infos:
            if order["cid"] == commodity["cid"]:
                sum += commodity["price"] * order["count"]
                break
    print("总价格：" + str(sum))
cal_sum()
print("-----------------------------------------------")

# 4.  定义函数,根据购买数量对订单列表降序排列
def order_desc():
    for r in range(len(list_orders)-1):
        for c in range(r+1,len(list_orders)):
            if list_orders[r]["count"] < list_orders[c]["count"]:
                list_orders[r],list_orders[c] = list_orders[c],list_orders[r]

order_desc()
for i in list_orders:
    print("商品编号：%d,订单数量：%d" % (i["cid"], i["count"]))

一、作用域

1.作用域：变量起作用的范围。

2.Local局部作用域：函数内部。

3.Enclosing 外部嵌套作用域 ：函数嵌套。

4.Global全局作用域：模块(.py文件)内部。

5.Builtin内置模块作用域：builtins.py文件。

x = int(2.9)  # int built-in 内置模块作用域

g_count = 0  # global 全局作用局

def outer():
    o_count = 1  # enclosing 外部嵌套作用域

    def inner():
        i_count = 2  # local 函数内部
        print(o_count)

    # print(i_count)  # 变量i_count在inner函数里面，所以在inner函数外面找不到
    inner()

outer()  # 1

# print(o_count) # 变量o_count在outer函数里面，所以在outer函数外面找不到

当然，local和enclosing是相对的，enclosing变量相对上层来说也是local。

变量名的查找规则

1.由内到外：L -> E -> G -> B

2.在访问变量时，先查找本地变量，然后是包裹此函数外部的函数内部的变量，之后是全局变量，最后是内置变量。

二、局部变量

1. 定义在函数内部的变量(形参也是局部变量)
2. 只能在函数内部使用
3. 调用函数时才被创建，函数结束后自动销毁

三、全局变量

1、定义

1. 定义在函数外部,模块内部的变量。
2. 在整个模块(py文件)范围内访问（但函数内不能将其直接赋值）。

2、global语句

• 作用

1. 在函数内部修改全局变量。
2. 在函数内部定义全局变量(全局声明)。

• .语法：

global 变量1, 变量2, …

• 注意：

1. 在函数内直接为全局变量赋值，视为创建新的局部变量。
2. 不能先声明局部的变量，再用global声明为全局变量。

3、nonlocal 语句

• 作用：在内层函数修改外层嵌套函数内的变量
• 语法：

 nonlocal 变量名1,变量名2, ...

4、总结

（1）变量查找顺序：LEGB，作用域局部>外层作用域>当前模块中的全局>python内置作用域；

（2）只有模块、类、及函数才能引入新作用域；

（3）对于一个变量，内部作用域先声明就会覆盖外部变量，不声明直接使用，就会使用外部作用域的变量；

（4）内部作用域要修改外部作用域变量的值时，全局变量要使用global关键字，嵌套作用域变量要使用nonlocal关键字。nonlocal是python3新增的关键字，有了这个关键字，就能完美的实现闭包了。

说明：在被嵌套的内函数中进行使用

四、函数递归

函数调用自身的编程技巧称为递归

1、递归函数的特点

特点

• 一个函数内部调用自己
  • 函数内部可以调用其他函数，当然在函数内部也可以调用自己

代码特点

1. 函数内部的代码是相同的，只是针对参数不同，处理的结果不同
2. 当参数满足一个条件时，函数不再执行
   • 这个非常重要，通常被称为递归的出口，否则会出现死循环！

示例代码

def sum_numbers(num):

    print(num)
    
    # 递归的出口很重要，否则会出现死循环
    if num == 1:
        return

    sum_numbers(num - 1)
    
sum_numbers(3)

2、 递归案例 —— 计算数字累加

需求

1. 定义一个函数sum_numbers
2. 能够接收一个num的整数参数
3. 计算 1 + 2 + … num 的结果

def sum_numbers(num):

    if num == 1:
        return 1
    
    # 假设 sum_numbers 能够完成 num - 1 的累加
    temp = sum_numbers(num - 1)

    # 函数内部的核心算法就是 两个数字的相加
    return num + temp

print(sum_numbers(2))

提示：递归是一个编程技巧，初次接触递归会感觉有些吃力！在处理不确定的循环条件时，格外的有用，例如：遍历整个文件目录的结构