第十课：函数作用域
// python 中的嵌套函数  在一个函数中再定义一个函数
# 小结 ：
# 函数作用域：因为：python是动态语言，定义变量的时候是不需要指定变量类型的，这样的话，我们在使用或者定义变量的时候作用域会分不清
# 如果在函数中定义一个变量，而且变量名和该函数上一级的作用域中的变量名相同
# 那么在该函数使用该变量时，就会使用局部变量
# 如果在函数中使用一个变量，但该变量在函数中并没有定义，那么会到该函数上一层的作用域去寻找该变量，如果还没有找到，会继续到上一层作用域去寻找，如果没找到会抛出变量未定义异常
x = 10          # 定义了一个变量 并赋值 
def fun1():
    x = 100
fun1()
print(x)         # 10

y = 123
def fun2():
    print(y)
fun2()            # 123 在函数中，如果在函数体中没有定义变量的话，首先会在函数体中去找 变量的值，如果没有，就找全局的作用域去找  

n = 332
def fun3():
    n = 4
    print(n)
fun3()            # 4   这个和第一个例子有什么区别呢？ 多了一个 print(n) 其实这个就是局部作用域，在调用函数的时候就已经算出值了。

def fun4():
    print(n)
    n = 100
# fun4()  抛出异常

# 定义一个嵌套函数 
m = 10
def fun5():
    # m = 100
    def fun6():
        print(m)
        print('fun6')
    return fun6           # 反映 函数的引用 
fun5()()           # 100 fun6   调用函数fun6的引用      比如在fun6这个函数中没有定义m 那么就会在上一层 m = 100 找 找到了100 那么就输出100 接下来 如果注释掉m = 100 那么就需要去上一层再找 找了 m = 10 那么就输出10    如果再注释了，那么就找不到了 就会报错

----------------------------------------------------------
第11课：函数的递归
# 函数递归：在一个函数中调用函数本身    自己调用自己 

# 阶乘
# n! = 1 * 2 * 3 * ... *n
# n! = (n - 1)! * n  n == 0 or n == 1
def jc(n):
    # 终止条件
    if n == 0 or n == 1:
        return 1           # 返回结果为1 
    else:
        return jc(n - 1) * n
print(jc(10))   # 3628800

# 斐波那契数列   ： 当前的数列值，表示前2项数列之和
# 0 1 1 2 3 5 8 13 21 
# f(n) = f(n - 1) + f(n - 2)   
# n == 0  return 0    n == 1 return 1
def fibnonacci(n):
    # 终止条件
    if n == 0:
        return 0      # 直接返回0
    elif n == 1:
        return 1      # 直接返回1 
    else:
        return fibnonacci(n - 1) + fibnonacci(n - 2)

print(fibnonacci(8))    # 21 

--------------------------------------------------------------------------
第十四课： python变量作用域
局部变量： 比如在函数体内 有用 
全局变量： 在整个范围内都有用
在py中有3个函数 可以获取局部变量和全局变量
globals： 获取全局范围内所有的变量
locals： 获取当前作用域内的所有变量
vars(object): 获取指定对象范围内所有的变量，如果不指定object ，vars和locals的作用是完全一样的

def hanshu():
    name = 'majihui'
    age = 30
    print(name,age)    # majihui 30
    print(locals())    # {'name': 'majihui', 'age': 30} 转化为了字典
    #print(globals())  #{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7fb62815d7b8>, '__spec__': None, '__annotations__': {}, '__builtins__': , '__file__': '/Users/majihui/pycharm_work/test07.py', '__cached__': None, 'hanshu': }
    # 全局变量输出的什么鬼，太多了
    print(vars())      # {'name': 'majihui', 'age': 30}
    #print(vars(object)) # {'__repr__': , '__hash__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__lt__': , '__le__': , '__eq__': , '__ne__': , '__gt__': , '__ge__': , '__init__': , '__new__': , '__reduce_ex__': , '__reduce__': , '__subclasshook__': , '__init_subclass__': , '__format__': , '__sizeof__': , '__dir__': , '__class__': , '__doc__': 'The most base type'}
    # 输出的什么鬼
    print(locals()['age'])  # 30
    locals()['age'] = 50    # 尝试去修改，结果为 不会去修改参数值 并不是变量本身
    print(age)              # 30

hanshu()

x = 20
y = 40

print(globals()['x'])    # 20

#我们接下来，可以定义一个对象
class myclass():
    def __init__(self):
        self.name = 'majihui'
print(vars(myclass()))        # {'name': 'majihui'}

#如何在一个函数中使用全局变量
value = 100
def a():
    value = 200     # 定义了一个新的局部变量
    print(value)
a()                 # 200

-------------------------------------------------------------------------
第十五课：局部函数
局部变量只在函数的内部起作用，
局部函数和局部的变量是一样的，只有在函数的内部才能被定义，才能被调用

def process(type,n):
    def pinfang(n):
        return n * n
    def lifang(n):
        return n * n * n
    def add(n):
        return n + n

    if type == 'pinfan':
        return pinfang(n)
    elif type == 'lifang':
        return  lifang(n)
    else:
        return add(n)

print(process('pinfang',10))     
print(process('lifang',10))
print(process('add',10))
结果为：
20
1000
20

def xyz():
    name = 'majihui'
    def x():
        #print(name)
        name = 'mjh'
        print(name)
    x()
xyz()    # mjh

def xyz():
    name = 'majihui'
    def x():
        nonlocal name
        print(name)
        name = 'mjh'
        #print(name)
    x()
xyz()    # majihui 

----------------------------------------------------------------------
第十六课 使用函数变量
在python语言中，可以将函数当成一个变量使用，可以将一个函数傅给变量

# 这一步将一个函数付给另外一个变量的方式
def pow(base,exponent):
    result = 1
    for i in range(1,exponent +1):
        result *= base
    return result

print(pow(2,10))   # 1024 

f = pow

print(f(3,10))   # 59049 

# 将函数本身最为一个参数
def area(width,height):
    return width * height
f = area

print(f(3,4))  # 12

# 这个area函数也可以作为一个函数的参数

def process(fun,a1,a2):
    return fun(a1,a2)

print(process(pow,4,5))    # 1024
print(process(area,10,20))  # 200 

# 将函数本身作为一个返回值
print("-----------")
def process1(type):
    def square(n):
        return n * n
    def add(n,m):
        return n + m
    if type == 'square':
        return square
    else:
        return add

print(process1('square')(12))     # 144
print(process1('add')(12,43))      # 55

---------------------------------------------------------------------
第十七课 使用lambda表达式代替局部函数
# 使用lambda表达式代替局部函数
# lambda表达式本身就是一个表达式，这个表达式他可传入一个参数，可以有1行的执行代码
# 他实际上就是一个简化的函数

def get_math_func(type):
    if type == 'sequare':
        return lambda n:n * n
    elif type == 'cube':
        return lambda n:n * n * n
    else:
        return lambda n:n + n

math_func01 = get_math_func('sequare')
print(math_func01(10))                              # 100
math_func02 = get_math_func('cube')
print(math_func02(10))                              # 1000
math_func03 = get_math_func('add')
print(math_func03(10))                              # 20 
# 调用的方式和其他的都是一样的 

当前题目：39py函数作用域递归函数变量作用域局部函数使用lam
文章源于：http://myzitong.com/article/ipcigo.html