python学习-day15：函数作用域、匿名函数、函数式编程、map、filter、reduce函数、内置函数r

2024-03-16 12:23:28

---恢复内容开始---

一、全局变量与局部变量

　　在子程序中定义的变量称为局部变量，

在程序的一开始定义的变量称为全局变量。

全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。当全局变量与局部变量同名时：在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

通过在函数内部，先添加一个 global name 相当于在子模块定义了一个全局变量。把局部的name扩到到全局变脸，后续name的变化，也是全局的！

name='lhf'

def change_name():

    #global name

    name='帅了一比'

    print('change_name',name)

change_name()

print(name)

>>>

change_name 帅了一比

lhf

name='lhf'

def change_name():

    global name

    name='帅了一比'

    print('change_name',name)

change_name()

print(name)

>>>

change_name 帅了一比

帅了一比

局部变量：在私人的小圈子内才可以被引用到。

全局变量：所有人都可以获得值，　

NAME = "杠娘"

def yangjian():

        # NAME = "史正文"

    global NAME

        #NAME = "小东北"

    print('我要搞', NAME)

def qupengfei():

    NAME = "基"

    print('我要搞', NAME)

yangjian()

qupengfei()    

>>>>

我要搞 杠娘

我要搞 基

NAME = "杠娘"

def yangjian():

    # NAME = "史正文"

    global NAME       NAME变为全局变量

    NAME = "小东北"

    print('我要搞', NAME)

def qupengfei():

    #NAME = "基"

    print('我要搞', NAME)

yangjian()

qupengfei()

>>>>

我要搞 小东北

我要搞 小东北

NAME = ["产品经理", "廖波湿"]

def qupengfei():

    global NAME

    NAME = ["阿毛"]

    NAME.append('XXOO')

    print('我要搞', NAME)

qupengfei()

>>>

我要搞 ['阿毛', 'XXOO']

总结：

全局变量变量名大写

局部变量变量名小写

优先读取局部变量，能读取全局变量，无法对全局变量重新赋值 NAME=“fff”，

# 但是对于可变类型，可以对内部元素进行操作
# 如果函数中有global关键字，变量本质上就是全局的那个变量，可读取可赋值 NAME=“fff”

二、函数的嵌套

①、按照同级别，从上往下执行。遇到函数，先编译，不执行

②内部包含global name，同一层出现name和global name的话就会报错。如果name在global在里面一级，则不会报错。

name = '刚娘'

def weihou():

    name='陈卓'

    def weiweihou():

        global name

        name='冷静'

    weiweihou()

    print(name)

print(name)

weihou()

print(name)

>>>>

刚娘

陈卓

冷静

③global带子全局变量，nonlocal 代指上一层变量

name = '刚娘'

def weihou():

    name='陈卓'

    def weiweihou():

        nonlocal name

        name='冷静'

    weiweihou()

    print(name)

print(name)

weihou()

print(name)

>>>>

刚娘

冷静

刚娘

三、前向引用，函数即变量----引用前已经定义

def fool() 相当于变量的赋值操作。test=函数体！内存中的处理过程：

python一加载到def foo（），就相当于做了一个赋值操作。把函数内部的函数体都作为普通的“字符串”放入内存中。

内存调用-执行函数体的内容

所以：

调用bar（），调用各种各样的函数，所以：函数先定义后调用。遇到调用执行命令，函数的定义和函数体都必须已经加载到内存。

def fool():

    print('from fool')

    bar()

fool()    #出现报错，执行fool过程之中，调用bar的时候，还未加载到内存。所以出现报错

def bar():

    print('from bar')

3.1、定义域、作用域

　　作用域：同级作用

四、递归

4.1定义：

　　　　在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

①有明确的判断条件，且判断条件在调用自身函数的前面：

②每次调用控制循环的字数都会减少一层。【见后面】

③循环的最后一程：有一个确定的返回值，之后层层递归回来，

4.2：

递归例子：N！阶层

　　举个例子，我们来计算阶乘n! = 1 x 2 x 3 x ... x n，用函数fact(n)表示，可以看出：

fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n

所以，fact(n)可以表示为n x fact(n-1)，只有n=1时需要特殊处理。

于是，fact(n)用递归的方式写出来就是

def fact(n):

    if n==1:

        return 1

    return n * fact(n - 1)

如果我们计算fact(5)，可以根据函数定义看到计算过程如下：

===> fact(5)

===> 5 * fact(4)

===> 5 * (4 * fact(3))

===> 5 * (4 * (3 * fact(2)))

===> 5 * (4 * (3 * (2 * fact(1))))

===> 5 * (4 * (3 * (2 * 1)))

===> 5 * (4 * (3 * 2))

===> 5 * (4 * 6)

===> 5 * 24

===> 120

4.3、

　　例子②：递归问路_day-15函数递归还没看完！

#_*_coding:utf-8_*_

__author__ = 'Linhaifeng'

import time

person_list=['alex','wupeiqi','yuanhao','linhaifeng']

def ask_way(person_list):

    print('-'*60)

    if len(person_list) == 0:

        return '没人知道'

    person=person_list.pop(0)

    if person == 'linhaifeng':

        return '%s说:我知道,老男孩就在沙河汇德商厦,下地铁就是' %person

    print('hi 美男[%s],敢问路在何方' %person)

    print('%s回答道:我不知道,但念你慧眼识猪,你等着,我帮你问问%s...' %(person,person_list))

    time.sleep(3)

    res=ask_way(person_list)

    # print('%s问的结果是: %res' %(person,res))

    return res

res=ask_way(person_list)

print(res)

递归特性：

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

---恢复内容结束---