全局变量，局部变量，递归---Python重新开始第四天

全局与局部变量

NAME = "产品经理"

def yangjian():
    # NAME = "史正文"
    global NAME # 已经声明，ＮＡＭＥ就是全局的的那个变量
    print('我要搞', NAME)
    NAME = "小东北"  # 修改 全局的变量
    print('我要搞', NAME)

def qupengfei():
    NAME = "基"
    print('我要搞', NAME)

如果函数的内容无global关键字，
  - 有声明局部变量(打印自己，内部定义了局部变量，用自己内部的)
        NAME = ["产品经理","廖波湿"]
        def qupengfei():
            NAME = "自己"
            print('我要搞', NAME)
        qupengfei()
  - 无声明局部变量（打印三个，没有局部变量，就用全局变量）
        NAME = ["产品经理","廖波湿"]
        def qupengfei():
            NAME.append('XXOO')
            print('我要搞', NAME)
        qupengfei()

如果函数的内容有global关键字
  - 有声明局部变量（声明了这个是全局变量，把“自己”赋值给全局了，打印改变的全局变量）
        NAME = ["产品经理","廖波湿"]
        def qupengfei():
            global NAME
            NAME = "自己"
            print('我要搞', NAME)
        qupengfei()
        错误示例（报错，重复赋值，先定义局部变量，再声明是全局变量，这样不行）
        NAME = ["产品经理","廖波湿"]
        def qupengfei():
            NAME = "自己"
            global NAME
            print('我要搞', NAME)
        qupengfei()
  - 无声明局部变量（修改了全局，在修改的基础上，加了新的，打印“阿毛，XXOO”）
        NAME = ["产品经理","廖波湿"]
        def qupengfei():
            global NAME
            NAME = ["阿毛"]
            NAME.append('XXOO')
            print('我要搞', NAME)
        qupengfei()

####### 全局变量变量名大写
####### 局部变量变量名小写


优先读取局部变量，能读取全局变量，无法对全局变量重新赋值 NAME=“fff”，
    但是对于可变类型，可以对内部元素进行操作
如果函数中有global关键字，变量本质上就是全局的那个变量，可读取可赋值 NAME=“fff”
qupengfei()
yangjian()

注意：nonlocal   可指定上一级变量，如果没有就继续往上直到找到为止

函数即变量

概念：定义函数时相当于定义了一个变量，没有调用时不会执行功能，
但是存在于程序中，下面举两个例子，比较容易理解

例1：程序不会出错
def foo():
    print('from foo')
    bar()

def bar():
    print('from bar')
foo()    #在执行foo函数前已经定义好了bar

例2：程序会出错
def foo():
    print('from foo')
    bar()
foo()    #在调用foo前没有定义好bar函数
def bar():
    print('from bar')

 另外：

如果一个函数没有return，那么默认return 的值是None

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

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

def bar():
    print('from bar')
foo()
####################
#这样不行，第一步foo函数编译，第二部执行foo(),
#执行到第三部发现，不知道bar()函数是干嘛的，报错
def foo():             1
    print('from foo')  
    bar()              3

foo()                  2

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

递归函数

递归函数效率不高，占用内存

例1

def calc(n):
    print(n)
    if int(n / 2) == 0:
        return n
    res=calc(int(n / 2))    #这样更好理解
    return res              #这样更好理解
     #return calc(int(n / 2))#两句合并成
res=calc(10)
print(res)

例2

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(1)
    res=ask_way(person_list)

    #此级别没完，在得到返回值后，还要执行打印，再把它返回的值，返回到上一级等待的res
    print('%s问的结果是: %res' %(person,res))
    return res

res=ask_way(person_list)
print(res)
# 我             来英            杨建           是征文
# res等 <————————res等  <————————res等  <——————return ‘沙河’
# print(res)     print(res)      print(res)     

总结：递归函数，在进入下级递归时，有一个res在等待返回的值，但是返回的值又是执行函数本身，一直执行，每一级都有个res在等着它的下一级返回值，

直到设定的边界，边界return了值，返回给边界的上一级，上一级运行完，要执行res=xxx 后面的同级代码，遇到return，再返回给上上级

看结果：

------------------------------------------------------------
hi 美男[alex],敢问路在何方
alex回答道:我不知道,但念你慧眼识猪,你等着,我帮你问问['wupeiqi', 'linhaifeng', 'zsc']...
------------------------------------------------------------
hi 美男[wupeiqi],敢问路在何方
wupeiqi回答道:我不知道,但念你慧眼识猪,你等着,我帮你问问['linhaifeng', 'zsc']...
------------------------------------------------------------
wupeiqi问的结果是: 'linhaifeng说:我知道,老男孩就在沙河汇德商厦,下地铁就是'es
alex问的结果是: 'linhaifeng说:我知道,老男孩就在沙河汇德商厦,下地铁就是'es
linhaifeng说:我知道,老男孩就在沙河汇德商厦,下地铁就是