Python学习第七天 局部变量 全局变量 global nonlocal local 嵌套 递归 尾递归

五 局部变量和全局变量

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

全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。

当全局变量与局部变量同名时：

在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

 

• global 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()
#   - 无声明局部变量
        # NAME = ["产品经理","廖波湿"]
        # def qupengfei():
        #     global NAME
        #     NAME = ["阿毛"]
        #     NAME.append('XXOO')
        #     print('我要搞', NAME)
        # qupengfei()

函数中，可以引用time模块，使用sleep函数暂停运行

import time
res=time.sleep(10)

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

name = "刚娘"

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

    weiweihou()
    print(name)

print(name)
weihou()
print(name)

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

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

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

name='lhf'

def change_name():
    print('我的名字',name)

change_name()

def change_name():
    name='帅了一笔'
    print('我的名字',name)

change_name()
print(name)

def change_name():
    global name
    name='帅了一笔'
    print('我的名字',name)

change_name()
print(name)

六 前向引用之'函数即变量'

def action():
    print 'in the action'
    logger()
action()
报错NameError: global name 'logger' is not defined


def logger():
    print 'in the logger'
def action():
    print 'in the action'
    logger()
 
action()
 

def action():
    print 'in the action'
    logger()
def logger():
    print 'in the logger'
 
action()

下记同样报错，

def action():
    print('in the action')
    logger()
action()
def logger():
    print('in the logger')

七 嵌套函数和作用域

看上面的标题的意思是，函数还能套函数？of course

name = "Alex"
 
def change_name():
    name = "Alex2"
 
    def change_name2():
        name = "Alex3"
        print("第3层打印",name)
 
    change_name2() #调用内层函数
    print("第2层打印",name)
 
 
change_name()
print("最外层打印",name)

此时，在最外层调用change_name2()会出现什么效果？

没错， 出错了， 为什么呢？

作用域在定义函数时就已经固定住了，不会随着调用位置的改变而改变

#函数的作用域只跟函数声明时定义的作用域有关，跟函数的调用位置无任何关系

name = 'alex'
def foo():
    name='linhaifeng'
    def bar():
        # name='wupeiqi'
        print(name)
    return bar
a=foo()
print(a)
a() #bar()

例一：return bar:把函数bar返回给func, 后运行func()时，再调用print(name),仍是打印原先name
name='alex'

def foo():
    name='lhf'
    def bar():
        print(name)
    return bar

func=foo()
func()


例二：func()()相当于foo()()()，运行时，foo()返回bar,foo()返回tt，故foo()()()运行tt子程序
name='alex'

def foo():
    name='lhf'
    def bar():
        name='wupeiqi'
        def tt():
            print(name)
        return tt
    return bar

func=foo()
func()()

八 递归调用

古之欲明明德于天下者，先治其国；欲治其国者，先齐其家；欲齐其家者，先修其身；欲修其身者，先正其心；欲正其心者，先诚其意；欲诚其意者，先致其知，致知在格物。物格而后知至，知至而后意诚，意诚而后心正，心正而后身修，身修而后家齐，家齐而后国治，国治而后天下平。

在函数内部，可以调用其他函数。如果在调用一个函数的过程中直接或间接调用自身本身

def calc(n):
    print(n)
    if int(n/2) ==0:
        return n
    return calc(int(n/2))
 
calc(10)
 
输出：
10
5
2
1

#_*_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）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

堆栈扫盲http://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html 

尾递归优化：http://egon09.blog.51cto.com/9161406/1842475

data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]
 
 
def binary_search(dataset,find_num):
    print(dataset)
 
    if len(dataset) >1:
        mid = int(len(dataset)/2)
        if dataset[mid] == find_num:  #find it
            print("找到数字",dataset[mid])
        elif dataset[mid] > find_num :# 找的数在mid左面
            print("33[31;1m找的数在mid[%s]左面33[0m" % dataset[mid])
            return binary_search(dataset[0:mid], find_num)
        else:# 找的数在mid右面
            print("33[32;1m找的数在mid[%s]右面33[0m" % dataset[mid])
            return binary_search(dataset[mid+1:],find_num)
    else:
        if dataset[0] == find_num:  #find it
            print("找到数字啦",dataset[0])
        else:
            print("没的分了,要找的数字[%s]不在列表里" % find_num)
 
 
binary_search(data,66)

二分查找