1.函数作用域

1.1作用域介绍

• python中的作用域分4种情况：
  L：local，局部作用域，即函数中定义的变量；
  E：enclosing，嵌套的父级函数的局部作用域，即包含此函数的上级函数的局部作用域，但不是全局的；
  G：global，全局变量，就是模块级别定义的变量；
  B：built-in，系统固定模块里面的变量，比如int, bytearray等。 搜索变量的优先级顺序依次是：作用域局部>外层作用域>当前模块中的全局>python内置作用域，也就是LEGB。

x = str(100)  # int built-in
print('hello' + x)

str = 33# str内置函数被破坏，绝对不要这样做
print(str)

g_count = 0  # global
def outer():
    o_count = 1  # enclosing
    def inner():
        i_count = 2  # local
        print(o_count)
    # print(i_count) 找不到
    inner()
outer()

# print(o_count) #找不到

当然，local和enclosing是相对的，enclosing变量相对上层来说也是local。

1.2 作用域产生

在Python中，只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如if、try、for等）是不会引入新的作用域的，如下代码：

if 2>1:
    x = 1
print(x)  # 1

这个是没有问题的，if并没有引入一个新的作用域，x仍处在当前作用域中，后面代码可以使用。

def test():
    x = 2
print(x) # NameError: name 'x2' is not defined

def、class、lambda是可以引入新作用域的。

1.3 变量的修改

x=6
def f2():
    print(x)
    x=5
f2()
  
# 错误的原因在于print(x)时,解释器会在局部作用域找,会找到x=5(函数已经加载到内存),但x使用在声明前了,所以报错:
# local variable 'x' referenced before assignment.如何证明找到了x=5呢?简单:注释掉x=5,x=6
# 报错为:name 'x' is not defined
#同理
x=6
def f2():
    x+=1 #local variable 'x' referenced before assignment.
f2()

1.5.4 global关键字

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了，当修改的变量是在全局作用域（global作用域）上的，就要使用global先声明一下，代码如下：

count = 10
def outer():
    global count
    print(count) 
    count = 100
    print(count)
outer()
#10
#100

1.5.5 nonlocal关键字

global关键字声明的变量必须在全局作用域上，不能嵌套作用域上，当要修改嵌套作用域（enclosing作用域，外层非全局作用域）中的变量怎么办呢，这时就需要nonlocal关键字了

def outer():
    count = 10
    def inner():
        nonlocal count
        count = 20
        print(count)
    inner()
    print(count)
outer()
#20
#20

• 小结
  （1）变量查找顺序：LEGB，作用域局部>外层作用域>当前模块中的全局>python内置作用域；
  （2）只有模块、类、及函数才能引入新作用域；
  （3）对于一个变量，内部作用域先声明就会覆盖外部变量，不声明直接使用，就会使用外部作用域的变量；
  （4）内部作用域要修改外部作用域变量的值时，全局变量要使用global关键字，嵌套作用域变量要使用nonlocal关键字。nonlocal是python3新增的关键字，有了这个 关键字，就能完美的实现闭包了

2.1 递归函数

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

• 递归特性：
  (1)必须有一个明确的结束条件
  (2)每次进入更深一层递归时，问题规模相比上次递归都应有所减少
  (3)递归效率不高，递归层次过多会导致栈溢出(在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返 回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。)

例1(阶乘)：

def factorial(n):
 
    result=n
    for i in range(1,n):
        result*=i
 
    return result
 
print(factorial(4))
 
 
#**********递归*********
def factorial_new(n):
 
    if n==1:
        return 1
    return n*factorial_new(n-1)
 
print(factorial_new(3))

例2(斐波那契数列)

def fibo(n):
 
    before=0
    after=1
    for i in range(n-1):
        ret=before+after
        before=after
        after=ret
 
    return ret
 
print(fibo(3))
 
#**************递归*********************
def fibo_new(n):#n可以为零，数列有［0］
 
    if n <= 1:
        return n
    return(fibo_new(n-1) + fibo_new(n-2))
 
print(fibo_new(3))

print(fibo_new(30000))#maximum recursion depth exceeded in comparison 递归函数的优点: 是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

3.1导入整个模块

要让函数是可导入的，得先创建模块。模块是扩展名为.py的文件，包含要导入到程序中的代码。下面来创建一个包含函数make_pizza()的模块。

pizza.py

    def make_pizza(size, *toppings):
        """概述要制作的比萨"""
        print("\nMaking a " + str(size) +
              "-inch pizza with the following toppings:")
        for topping in toppings:
            print("- " + topping)

接下来，我们在pizza.py所在的目录中创建另一个名为making_pizzas.py的文件，这个文件导入刚创建的模块，再调用make_pizza()两次：

making_pizzas.py

      import pizza

      pizza.make_pizza(16, 'pepperoni')
      pizza.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

Python读取这个文件时，代码行import pizza让Python打开文件pizza.py，并将其中的所有函数都复制到这个程序中。你看不到复制的代码，因为这个程序运行时，Python在幕后复制这些代码。你只需知道，在making_pizzas.py中，可以使用pizza.py中定义的所有函数。

    Making a 16-inch pizza with the following toppings:
    - pepperoni

    Making a 12-inch pizza with the following toppings:
    - mushrooms
    - green peppers
    - extra cheese

这就是一种导入方法：只需编写一条import语句并在其中指定模块名，就可在程序中使用该模块中的所有函数。如果你使用这种import语句导入了名为module_name.py的整个模块，就可使用下面的语法来使用其中任何一个函数：

_module_name.function_name_()

3.2导入特定的函数

你还可以导入模块中的特定函数，这种导入方法的语法如下：

from  _module_name_  import  _function_name_

通过用逗号分隔函数名，可根据需要从模块中导入任意数量的函数：

from  _module_name_  import  _function_0, function_1, function_2_

对于前面的making_pizzas.py示例，如果只想导入要使用的函数，代码将类似于下面这样：

from pizza import make_pizza

make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

若使用这种语法，调用函数时就无需使用句点。由于我们在import语句中显式地导入了函数make_pizza()，因此调用它时只需指定其名称。

3.3使用as给函数指定别名

如果要导入的函数的名称可能与程序中现有的名称冲突，或者函数的名称太长，可指定简短而独一无二的别名——函数的另一个名称，类似于外号。要给函数指定这种特殊外号，需要在导入它时这样做。

下面给函数make_pizza()指定了别名mp()。这是在import语句中使用make_pizza as mp实现的，关键字as将函数重命名为你提供的别名：

    from pizza import make_pizza as mp

    mp(16, 'pepperoni')
    mp(12, 'mushrooms', 'green peppers', 'extra cheese')

上面的import语句将函数make_pizza()重命名为mp()；在这个程序中，每当需要调用make_pizza()时，都可简写成mp()，而Python将运行make_pizza()中的代码，这可避免与这个程序可能包含的函数make_pizza()混淆。

指定别名的通用语法如下：

from  _module_name_  import  _function_name_  as  _fn_

3.4使用as给模块指定别名

你还可以给模块指定别名。通过给模块指定简短的别名（如给模块pizza指定别名p），让你能够更轻松地调用模块中的函数。相比于pizza.make_pizza()，p.make_pizza()更为简洁：

    import pizza as p

    p.make_pizza(16, 'pepperoni')
    p.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

上述import语句给模块pizza指定了别名p，但该模块中所有函数的名称都没变。调用函数make_pizza()时，可编写代码p.make_pizza()而不是pizza.make_pizza()，这样不仅能使代码更简洁，还可以让你不再关注模块名，而专注于描述性的函数名。这些函数名明确地指出了函数的功能，对理解代码而言，它们比模块名更重要。

给模块指定别名的通用语法如下：

import  _module_name as mn_

3.5导入模块中的所有函数

使用星号（*）运算符可让Python导入模块中的所有函数：

    from pizza import *

    make_pizza(16, 'pepperoni')
    make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

import语句中的星号让Python将模块pizza中的每个函数都复制到这个程序文件中。由于导入了每个函数，可通过名称来调用每个函数，而无需使用句点表示法。然而，使用并非自己编写的大型模块时，最好不要采用这种导入方法.

最佳的做法是，要么只导入你需要使用的函数，要么导入整个模块并使用句点表示法。这能让代码更清晰，更容易阅读和理解。这里之所以介绍这种导入方法，只是想让你在阅读别人编写的代码时，如果遇到类似于下面的import语句，能够理解它们：

from  _module_name_  import  *

4.1函数文档字符串

函数文档字符串documentation string （docstring）是在函数开头，用来解释其接口的字符串。简而言之：帮助文档

• 包含函数的基础信息
• 包含函数的功能简介
• 包含每个形参的类型，使用等信息
• 必须在函数的首行，经过验证前面有注释性说明是可以的，不过最好函数文档出现在首行
• 使用三引号注解的多行字符串（当然，也可以是一行），因三引号可以实现多行注解（展示）(''' ''') 或(""" """)
• 函数文档的第一行一般概述函数的主要功能，第二行空，第三行详细描述。

查看方式

• 在交互模式下可以使用ｈｅｌｐ查看函数，帮助文档，该界面会跳到帮助界面，需要输入q退出界面
• 使用doc属性查看，该方法的帮助文档文字直接显示在交互界面上。 代码如下：

def test(msg):
   """
        函数名：test
        功能：测试
        参数：无
        返回值：无
   """
    print("函数输出成功"+msg)

test('hello')
print( help(test))
print(test.__doc__)