末学者笔记--Python函数二玄

Python函数：二玄

一．名称空间和作用域

1.内置名称空间:

（python启动时就有）python解释器内置的名字，print,max,min

Print其实是python内置的函数。

1. 全局名称空间:

（执行python文件时启动）定投定义的变量，如在Python界面直接定义的变量：a = 3 ，即为全局变量。

2. 局部名称空间:

（调用函数时启动，调用结束失效）函数内部定义的变量

如：

在函数内的定义的一个变量即为局部变量。

总结：

三者的加载顺序

内置--->全局--->局部

三者的访问顺序

局部--->全局--->内置

二．装饰器

1.什么是装饰器?

在不修改源代码和调用方式的基础上给函数增加新的功能，即为装饰器，多个装饰器可以装饰在同一个函数上。

2.无参装饰器

def add(he):
    def wrpper():
        he() #he=message
        print('这是一个笑话')
    return wrpper
@add     #@add达到的效果：message=add(message)=wrpper 这是其id内存地址
def message():
    print('有2棵树就有4只鸟')
message()

》》

有2棵树就有4只鸟

这是一个笑话

》》

3.有参装饰器：

def add(he):
    def wrpper(x,y):
        he(x,y) #he=message
        print('这是一个笑话')
    return wrpper
@add   #message=add(message)=wrpper 这是其id内存地址
def message(x,y):
    print('有%s棵树就有%s只鸟' % (x,y))
message(2,4)

》》

有2棵树就有4只鸟

这是一个笑话

》》

4.带参数的装饰器：

def default_engine(engine=None):
    def auth(func):
        def deco(*args, **kwargs):
            user = input('user:')
            password = input('password:')
            if engine == 'mysql':
                if user == 'root' and password == 'root':
                    res = func(*args, **kwargs)
                    return res
                else:
                    print('用户名或密码错误')
            else:
                print('没有这个引擎')
        return deco
    return auth

@default_engine(engine='mysql')
def index():
    print('welcome to home page')
# res = default_engine(engine='mysql')
# index = res(index)
index()

三．迭代器

1.什么是迭代器？

　迭代是一个重复的过程，即每一次重复为一次迭代，并且每次迭代的结果都是下一次迭代的初始值

while True: #只是单纯的重复，因此不是迭代

print('===>')

l = [1,2,3]

count = 0

while count<len(l): #首先是重复动作，其次上一次的结果是下一次的初始值，因此，是迭代

print(l[count])

count+=1

2.为什么要有迭代器？及可迭代对象和迭代器对象

（1）为何要有迭代器？

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

（2）什么是可迭代对象？

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

'world'.__iter__

(4,5,6).__iter__

[1,2,3].__iter__

{'a':1}.__iter__

{'a','b'}.__iter__

open('a.txt').__iter__

（3）什么是迭代器对象？

可迭代对象执行obj.__iter__()得到的结果就是迭代器对象

而迭代器对象指的是即内置有__iter__又内置有__next__方法的对象

（4）文件类型是迭代器对象

open('a.txt').__iter__()

open('a.txt').__next__()

（5）总结：

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

四：生成器

1.什么是生成器？

只要函数里有yield关键字，那么函数名（）得到的结果就是生成器，并且不会执行函数内部代码。

# 生成器就是迭代器

2.return和yield区别:

# return只能返回一个值

# yield可以返回多个值，同一时间只能存储一个值；缺点:没有索引，不能后退取值

return的方式：
def test():
    l = []
    for i in range(10):
        l.append(i)
    return l
print(test()[4])

Yield方式：

def test():
    l = ['a','b','c']
    for i in l:
        yield i
for i in test():
    print(i)

》》

【特殊】：

def test():
    l = ['a','b','c']
    for i in l:
        yield i
print(next(test()))
print(next(test()))
print(next(test()))

print('==============')

a = test() #生成器的算法是：每次直接调用如‘print(next(test()))’，都会刷新迭代数位，即从新取值；赋予给一个变量即可免去算法刷新
print(next(a))
print(next(a))
print(next(a))

》》

==============

》》

五：匿名函数

1. 定义

匿名函数的定义：lambda，自带return；

匿名函数通常只调用一次，之后不再使用。

2. 格式：

lambda x,y: x+y

其整体是一个函数内存地址，即(lambda x,y: x+y)(a，b)为调用函数

直接输出：

print((lambda x,y:x+y)(1,2))

》》

3.lambda的使用场景

【#max sorted map filter zip】

info = {
    'li':2000,
    'zhao':35000,
    'wu': 34000,
    'du': 40000
}

（1）# max：取最大值

print(max(info,key=lambda k:info[k])) #max 本身做了一个循环比较；

》》

解释：max本身开始循环info字典的key值，将key值赋予给匿名函数的参数‘k’，匿名函数代入‘k’值后返回info字典的对应value值，此时max再进行大小比较，取出最大value值，但输出的是其对应的key值。

（2）# sorted：排序

print(sorted(info,key=lambda k:info[k]))
print(sorted(info,key=lambda k:info[k],reverse=True)) #反向排序

》》

['li', 'wu', 'zhao', 'du']

['du', 'zhao', 'wu', 'li']

》》

原理：同max的原理，

（3）# map：映射

names = ['zhao','wu','du']

#想在每个元素后面加一个‘nb’，通常如下：
l1 = []
for name in names:
res = '%s_nb' % name
l1.append(res)
print(l1)

》》

['zhao_nb', 'wu_nb', 'du_nb']

》》

但使用匿名函数更简单：

print(list(map(lambda name:'%s_nb' % name,names)))

结果一样，同理map映射也是变成迭代器对象

res = map(lambda name:'%s_nb' % name,names)
print(res.__next__())
print(res.__next__())
print(res.__next__())

》》

zhao_nb

wu_nb

du_nb

》》

（4）# filter：过滤

names = ['zhao_nb', 'wu_nb', 'du_nb','li']
print(list(filter(lambda i: i.endswith('nb'),names)))
print(list(filter(lambda i: not i.endswith('nb'),names)))

》》