python之---函数部分详解

函数基础

• 函数时第一类对象, 即函数可以当做数据传递

1 可以被引用
2 可以当作参数传递
3 返回值可以是函数
3 可以当作容器类型的元素

利用该特性, 可以取代多分支if判断

def foo():
    print('foo')

def bar():
    print('bar')

dic={
    'foo':foo,
    'bar':bar,
}
while True:
    choice=input('>>: ').strip()
    if choice in dic:
        dic[choice]()

函数嵌套调用(容易产生递归)

def max(x,y):
    return x if x > y else y

def max4(a,b,c,d):
    res1=max(a,b)
    res2=max(res1,c)
    res3=max(res2,d)
    return res3
print(max4(1,2,3,4))

函数的嵌套定义

def f1():
    def f2():
        def f3():
            print('from f3')
        f3()
    f2()

f1()
f3() #报错，为何？
闭包函数上线

• 名称空间和作用域

名称空间：存放名字的地方，三种名称空间，（之前遗留的问题x=1，1存放于内存中，那名字x存放在哪里呢？
名称空间正是存放名字x与1绑定关系的地方）

名称空间加载顺序

python test.py
1、python解释器先启动，因而首先加载的是：内置名称空间
2、执行test.py文件，然后以文件为基础，加载全局名称空间
3、在执行文件的过程中如果调用函数，则临时产生局部名称空间

名称空间查找顺序

局部名称空间--->全局名称空间--->内置名称空间

需要注意的是：在全局无法查看局部的，在局部可以查看全局的

作用域

1、作用域即范围
        - 全局范围（内置名称空间与全局名称空间属于该范围）：全局存活，全局有效
　     - 局部范围（局部名称空间属于该范围）：临时存活，局部有效
2、作用域关系是在函数定义阶段就已经固定的，与函数的调用位置无关

3、查看作用域：globals(),locals()

LEGB 代表名字查找顺序: locals -> enclosing function -> globals -> __builtins__
locals 是函数内的名字空间，包括局部变量和形参
enclosing 外部嵌套函数的名字空间（闭包中常见）
globals 全局变量，函数定义所在模块的名字空间
builtins 内置模块的名字空间

global与nonlocal关键字

golobal: 打破局部对外变量的改变

nonlocal: 内层函数对外层函数值修改

闭包函数

内部函数包含对外部作用域而非全局作用域的引用

提示：之前我们都是通过参数将外部的值传给函数，闭包提供了另外一种思路，包起来喽，包起呦，包起来哇

def wrapper(func):
    def inner(*args,**kwargs):
        res = func(*args,**kwargs)
        return res
    return inner

闭包是的应用

闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论
在何处调用，优先使用自己外层包裹的作用域
应用领域：延迟计算（原来我们是传参，现在我们是包起来）

主要就是利用外部访问不到内部功能, 只能通过接口来访问内部, 

装饰器

装饰器就是闭包函数的一种应用场景

开放封闭原则：对修改封闭，对扩展开放

解释:

装饰器他人的器具，本身可以是任意可调用对象，被装饰者也可以是任意可调用对象。
强调装饰器的原则：1 不修改被装饰对象的源代码 2 不修改被装饰对象的调用方式
装饰器的目标：在遵循1和2的前提下，为被装饰对象添加上新功能

标准无参装饰器
def wrapper(func):
    def inner(*args,**kwargs):
        res = func(*args,**kwargs)
        return res
    return inner
   

标准有参装饰器
def auth(file):
    def wrapper(func):
        def inner(*args,**kwargs):
            # file为传参, 形参在这里使用或上一层使用
            res = func(*args,**kwargs)
            return res
        return inner
    return wrapper

装饰器语法糖

被装饰函数的正上方，单独一行
        @deco1
        @deco2
        @deco3
        def foo():
            pass

        foo=deco1(deco2(deco3(foo)))

当多个装饰器存在时, 加载顺序从下往上, 执行顺序从上往下

装饰器补充: wraps 把原文档一并拷过来, 伪装的更像了

from functools import wraps

def deco(func):
    @wraps(func) #加在最内层函数正上方
    def wrapper(*args,**kwargs):
        return func(*args,**kwargs)
    return wrapper

@deco
def index():
    '''哈哈哈哈'''
    print('from index')

print(index.__doc__)

迭代器

概念:

迭代器即迭代的工具，那什么是迭代呢？
迭代是一个重复的过程，每次重复即一次迭代，并且每次迭代的结果都是下一次迭代的初始值

对于序列类型：字符串、列表、元组，我们可以使用索引的方式迭代取出其包含的元素。但对于字典、集合、文
件等类型是没有索引的，若还想取出其内部包含的元素，则必须找出一种不依赖于索引的迭代方式，这就是迭代器

什么是可迭代对象？

可迭代对象指的是内置有__iter__方法的对象，即obj.__iter__

什么是迭代器对象？

可迭代对象执行obj.__iter__()得到的结果就是迭代器对象
而迭代器对象指的是即内置有__iter__又内置有__next__方法的对象

文件类型是迭代器对象

注意：
迭代器对象一定是可迭代对象，而可迭代对象不一定是迭代器对象

迭代器对象的使用

iter_dic=dic.__iter__() #得到迭代器对象，迭代器对象即有__iter__又有__next__，
但是：迭代器.__iter__()得到的仍然是迭代器本身

next一次出一个值
有了迭代器，我们就可以不依赖索引迭代取值了

for循环工作原理

基于for循环，我们可以完全不再依赖索引去取值了
dic={'a':1,'b':2,'c':3}
for k in dic:
    print(dic[k])
    
1：执行in后对象的dic.__iter__()方法，得到一个迭代器对象iter_dic
2: 执行next(iter_dic),将得到的值赋值给k,然后执行循环体代码
3: 重复过程2，直到捕捉到异常StopIteration,结束循环

迭代器优缺点

优点：
  - 提供一种统一的、不依赖于索引的迭代方式
  - 惰性计算，节省内存
缺点：
  - 无法获取长度（只有在next完毕才知道到底有几个值）
  - 一次性的，只能往后走，不能往前退

生成器

只要函数内部包含有yield关键字，那么函数名()的到的结果就是生成器，并且不会执行函数内部代码

生成器就是迭代器

g.__iter__
g.__next__
所以生成器就是迭代器，因此可以这么取值
res=next(g)
print(res)

总结:
把函数做成迭代器
对比return，可以返回多次值，可以挂起/保存函数的运行状态

面向过程编程

1、首先强调：面向过程编程绝对不是用函数编程这么简单，面向过程是一种编程思路、思想，而编程思路是不依
赖于具体的语言或语法的。言外之意是即使我们不依赖于函数，也可以基于面向过程的思想编写程序

2、定义
基于面向过程设计程序就好比在设计一条流水线，是一种机械式的思维方式

3、优点：复杂的问题流程化，进而简单化
4、缺点：可扩展性差，修改流水线的任意一个阶段，都会牵一发而动全身
5、应用：扩展性要求不高的场景，典型案例如linux内核，git，httpd

三元表达式 用于if判断

name=input('姓名>>: ')
res='css' if name == 'chen' else 'NB'
print(res)

列表推导式

lis = [“xxx%s” %i for i in range(10)]

3、优点：方便，改变了编程习惯，可称之为声明式编程

生成器表达式

把列表推导式的[]换成()就是生成器表达式

示例：生一筐鸡蛋变成给你一只老母鸡，用的时候就下蛋，这也是生成器的特性

chicken=(‘鸡蛋%s’ %i for i in range(5))

递归与二分法

递归调用是函数嵌套调用的一种特殊形式，函数在调用时，直接或间接调用了自身，就是递归调用

递归调用应该分为两个明确的阶段：递推，回溯

1、递归调用应该包含两个明确的阶段：回溯，递推

回溯就是从外向里一层一层递归调用下去，
回溯阶段必须要有一个明确地结束条件，每进入下一次递归时，问题的规模都应该有所减少（否则，单纯地重复调用自身是毫无意义的）

递推就是从里向外一层一层结束递归

二分法

pass

• 匿名函数(函数高阶)

匿名函数就是没有名字的函数

lambda x,y,z=1:x+y+z 
#与函数有相同的作用域，但是匿名意味着引用计数为0，使用一次就释放，除非让其有名字

有名函数与匿名函数的对比
有名函数：循环使用，保存了名字，通过名字就可以重复引用函数功能

匿名函数：一次性使用，随时随时定义

应用：max，min，sorted,map,reduce,filter