7.Python（变量，前向引用，递归）

一、全局变量和局部变量

A.

1.简要说明

   全局变量，顶着头开始写，没有任何缩进，在py文件的任何位置都能调用，习惯用大写

   局部变量，在函数内部声明，只有这个函数能用，出去就不能用了，局部变量与全局变量变量名重名，给局部赋值并不能改变全局变量内容

name = 'lhf'# 全局变量

def change_name():
    name = '帅了一比' # 局部变量
    print('change_name', name)

change_name() #全局与局部变量名一样，先调用局部的
print(name) #全局变量没有改变

2.全局变量内容在函数内部操作后进行变化

函数内部没有global关键字并可以改变全局变量内容要求，全局变量是一个可变类型，比如列表，函数内部才可以对其进行操作

NAME = ["啊啊","刚刚"]
def qupengfei():
    NAME.append('XXOO')
    print(NAME)
qupengfei()

B.global关键字

1.简要说明

global  关键字。想要在函数里面修改全局变量应该这样：

在函数内声明global name，就代表调用全局的变量name

专业的说法是global 后面的name是一个指针，一个内存地址，直接调用的那个内存地址

调用之后在子程序（局部程序）里面再次给name赋值的话就修改了全局变量name了

name = "gouguoqi"
def change_name():
    global name
    name = "miaoye"
change_name()
print (name)

2.在函数内部操作，改变全局变量

NAME = ["产品经理","啦啦"]
def qupengfei():
    global NAME
    NAME = "自己"
    print(NAME)
qupengfei()

NAME = ["产品经理","啦啦"]
def qupengfei():
    global NAME
    NAME = ["阿毛"]
    NAME.append('XXOO')
    print(NAME)
qupengfei()

C.nonlocal

nonlocal关键字用来在函数或其他作用域中使用外层(非全局)变量

如果在内部函数中只是仅仅读外部变量，可以不在此变量前加nonlocal

如果在内部函数中尝试进行修改外部变量，且外部变量为不可变类型，则需要在变量前加nonlocal，如果变量为可变类型，则不需要添加nonlocal

错误示例：

def fun():  
    num2=3  
    def fun2():  
        num2=num2*2  
        print("num2=",num2)  
    return fun2()  
  
fun()  

正确示例：

def fun():
    num2 = 3

    def fun2():
        nonlocal num2
        num2 *= 2
        print("num2=", num2)

    return fun2()
fun()

又一个示例

name = "刚娘"

def weihou():
    name = "陈卓"
    def weiweihou():
        nonlocal name   # nonlocal，指定上一级变量，如果没有就继续往上直到找到为止
        name = "冷静"

    weiweihou()
    print(name)

print(name)
weihou()
print(name)

D.各种嵌套

name = "北爷"   #1 第一步 定义全局变量name 1
def huangwei():  #2 第二步 定义一个函数，到14行第二步结束，把这些都放到内存里面加载上，并没有执行 2
    name = "黄伟" #4.1  定义局部变量name 5
    print(name) #4.2 打印局部变量name的值  "黄伟" 6
    def liuyang(): #4.3 定义一个函数，然后把这段到12行的代码又放入了内存，等待下次调用 7
        name = "刘洋" #4.4.1定义局部变量name 9
        print(name) #4.4.2打印出局部变量name "刘洋" 10
        def nulige():#4.4.3  又遇到def了。又把这一部分到10行的代码放入了内存，没有执行。等待下次调用 11
            name = "喵爷"#4.4.5.1定义了一个局部变量name 14
            print(name)#4.4.5.2打印局部变量name的值"喵爷" 15
        print(name)#4.4.4 打印name 刘洋 12
        nulige()#4.4.5 调用nulige这个函数，开始向上找 13
    liuyang()#4.4 调用liuyang这个函数，开始向上找 8
    print(name) #4.5 第五步 打印name 这时候的name的值是"黄伟" 16
print(name) #3 第三步  打印name 这时候name="北爷" 3
huangwei() #4 第四步 执行huangwei这个函数，开始向上找他 4
print(name)#5第五步 打印全局变量name 17

二、前向引用

代码从上到下执行，一旦遇到定义的函数体，内存便为其开辟空间，并用该函数的名字作为一个标识
但是该函数体内具体是什么内容，这个时候并不着急去读取
而是在程序中需要调用执行该函数时，去执行该函数内的具体内容
如果一个函数还未开辟内存空间就先调用，就会报错
这也很好理解，因为程序都不知道这个函数放在哪里，也不知道该函数的标识是什么，
自然也不知道去哪里找它啊

示例错误的：在定义foo（）函数之后bar（）函数定义之前会报错，因为调用foo（）函数的时候bar还未定义。

def foo():
    print('from foo')
    bar()
foo() #name 'bar' is not defined
def bar():
    print('from bar')

正确的示例：在定义foo（）和bar（）之后调用foo（），虽然foo（）定义在bar（）之前，且调用了bar（），但是在python中，若不执行函数，函数并不会执行，且在调用之前已经定义了bar（），所以不会报错，这就是前向引用。

def foo():
    print('from foo')
    bar()
 
def bar():
    print('from bar')
 
foo()

 三、递归

在函数中调用自身的方式叫做递归。

递归特性：

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

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

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

import time
person_list=['alex','wupeiqi','linhaifeng','zsc']
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)