1. 作业讲解

登录校验装饰器+用户权限
1.有几个普通函数
2.需要在执行之前添加校验用户信息的功能
3.编写一个校验用户是否登录的装饰器
4.定义全局变量存储用户是否登录的信息(由于不单单需要记录用户登录状态还需要记录当前用户的权限 所以使用了字典)
5.装饰器每次获取用户信息之前先判断用户是否已登录
	如果没有登录则获取用户名和密码
 	如果登录了则获取当前登录的执行权限
6.装饰器内部如何获取当前用户想要执行的功能编号
	有参装饰器
7.登录之后获取执行权限然后判断功能编号是否存在于执行权限内

昨日回顾

重要内置函数

1.map()       映射 map（func，array...） array是可迭代对象   map方法会依次迭代array，得到的值依次传给匿名函数（也可以是有名函数），而map函数得到的结果仍然是迭代器。
map会根据提供的函数对指定的序列做映射。第一个参数接受一个函数名,后面的参数接受一个或多个可迭代的序列.

2.max() min()
def max(*args, key=None):

res = max(d1, key=lambda k: d1.get(k))
d1是字典   key是关键字参数，默认为none，不传值就默认for循环迭代出得值直接比较大小。
当给key传值后字典for循环出的值会经过函数处理后比较大小，最终得出最大值所对应的键！！

3.reduce()
函数先从列表（或序列）中取出2个元素执行指定函数，并将输出结果与第3个元素传入函数，输出结果再与第4个元素传入函数，…，以此类推，直到列表每个元素都取完。
传多个值返回一个值，会对参数序列中元素进行累积。（累积包括累加、累乘、等）
res=reduce(func,array)  假设func等于lambda x,y:x+y，先对array迭代一次得到的值最为x，再迭代一次的值作为y，x与y相加后的值再作为x，array迭代三次的值作为y，如此往复直到array结束！！！

4.zip() 拉链
l1 = [11, 22, 33, 44, 55]
l2 = ['jason', 'kevin', 'oscar', 'jerry', 'tony']
l3 = [1, 2, 3, 4, 5]
res = zip(l1, l2, l3)
print(list(res))
[(11, 'jason', 1), (22, 'kevin', 2), (33, 'oscar', 3), (44, 'jerry', 4), (55, 'tony', 5)]
它从每个迭代器中聚合元素，返回一个元组的迭代器，当最短的输入迭代被耗尽时，迭代器就停止了。zip的 最终结果一组一组的元组，每个元组里面的数据是要拉链的迭代器的每一次迭代的取值，但最终zip方法最终的返回值无法直接打印，可以想成生成了工厂，工厂里面可以产生每次拉链操作产生的元组，必须最后用list转化一下，才能一次性全部拿出所有拉链出的元组数据。

5.filter()  过滤
它主要用来根据特定条件过滤迭代器中不符合条件的元素，返回一个惰性计算的filter对象或迭代器。需要用list函数进行转换，才能得到符合的条件元素组成的新列表。
filter(function or None, iterable)
function：函数，作用是对iterable中的每个元素判断是否符合特定条件。
None：不调用任何函数，只对可迭代对象中的元素本身判断真假，保留为真的元素。
iterables：可迭代对象(序列、字典等)。
c = [-10, 28, 9, -5, 30, 5]
res = filter(lambda a:a>0, c)
print(res)
print(list(res))
<filter object at 0x000001915DFF00D0>
[28, 9, 30, 5]

6.sorted()
如果对python中的列表进行排序，可以使用List类的成员函数sort，该函数会在原空间上进行操作，对列表本身进行修改，不返回副本。语法如下：
L.sort(cmp=None, key=None, reverse=False)

sorted函数就比sort函数要强大许多了，sort只能对列表进行排序，sorted可以对所有可迭代类型进行排序，并且返回新的已排序的列表。语法如下：
sorted(iterable, cmp=None, key=None, reverse=False)
iterable可迭代对象    比较函数cmp    

1. 迭代器介绍:

迭代器即用来迭代取值的工具!!!!!!而迭代是重复反馈过程的活动!!!!!!
其目的通常是为了逼近所需的目标或结果.
每一次对过程的重复称为一次“迭代”.
而每一次迭代得到的结果会作为下一次迭代的初始值,单纯的重复并不是迭代!!!!!!

msg = input('>>: ').strip()
while True:
    print(msg)

下述while循环才是一个迭代过程，不仅满足重复，而且以每次重新赋值后的index值作为下一次循环中新的索引进行取值，反复迭代，最终可以取尽列表中的值

goods=['mac','lenovo','acer','dell','sony']
count=0
while index < len(goods):
    print(goods[count])
    count += 1

2. 可迭代对象 就是可迭代的东西 Iterable

通过索引的方式进行迭代取值，实现简单，但仅适用于序列类型：字符串，列表，元组。
对于没有索引的字典、集合等非序列类型，必须找到一种不依赖索引来进行迭代取值的方式，这就用到了迭代器。
迭代器：可以不依赖索引来进行迭代取值！！！！
要想了解迭代器为何物，必须事先搞清楚一个很重要的概念：可迭代对象(Iterable)。从语法形式上讲，内置有__iter__方法的对象都是可迭代对象，字符串、列表、元组、字典、集合、打开的文件都是可迭代对象：

'123'.__iter__()
[1,2,3].__iter__()
(3,4,5).__iter__()
{7,8,9}.__iter__()
{'name':'jason'}.__iter__()

3. 迭代器对象 就是迭代器Iterator

调用obj.iter()方法返回的结果就是一个迭代器对象(Iterator)。
迭代器对象是内置有__iter__和__next__方法，打开的文件本身就是一个迭代器对象。
执行迭代器对象.iter()方法得到的仍然是迭代器本身，
执行迭代器.next()方法就会计算出迭代器中的下一个值。
迭代器是Python提供的一种统一的、不依赖于索引的迭代取值方式，只要存在多个“值”，无论序列类型还是非序列类型都可以按照迭代器的方式取值！！！！！！

s = [1,2,3]               # 可迭代对象s
i = s.__iter__()          # 可迭代对象s变成迭代器
print(i.__next__())
print(i.__next__())   # 迭代器继续调用.__next__方法，就会计算出迭代器中的下一个值
print(i.__next__())
print(i.__next__())       # 发现迭代器中无值可取，报异常了
1
2
3
StopIteration            # 抛出StopIteration的异常，代表无值可取，迭代结束
i = s.__iter__() 语法与 i=iter(s)一个意思
i.__next__()  语法与next(i) 一个意思

4. for循环原理

有了迭代器后，我们便可以不依赖索引迭代取值了，使用while循环的实现方式如下

goods=['mac','lenovo','acer','dell','sony']
i=iter(goods)             # 生成一个迭代器对象
while True:
    try:
        print(next(i))   # 迭代器调用.__iter__方法后，计算出迭代器中产生的第一个值，循环后计算第二个...
    except StopIteration:  # 捕捉异常终止循环
        break

for循环又称为迭代循环，in后可以跟任意可迭代对象，上述while循环可以简写为

goods=['mac','lenovo','acer','dell','sony']
for item in goods:
    print(item)

for 循环在工作时，首先会调用可迭代对象goods内置的__iter__方法拿到一个迭代器对象，然后再调用该迭代器对象的__next__方法将取到的值赋给item,执行循环体完成一次循环，周而复始，直到捕捉StopIteration异常，结束迭代。

5. 迭代器的优缺点

基于索引的迭代取值，所有迭代的状态都保存在了索引中，而基于迭代器实现迭代的方式不再需要索引，所有迭代的状态就保存在迭代器中，然而这种处理方式优点与缺点并存：

优点

1、为序列和非序列类型提供了一种统一的迭代取值方式。

2、惰性计算：迭代器对象表示的是一个数据流，可以只在需要时才去调用__next__来计算出一个值，就迭代器本身来说，同一时刻在内存中只有一个值，因而可以存放无限大的数据流，而对于其他容器类型，如列表，需要把所有的元素都存放于内存中，受内存大小的限制，可以存放的值的个数是有限的。

缺点

1、除非取尽，否则无法获取迭代器的长度

2、只能取下一个值，不能回到开始，更像是‘一次性的’，迭代器产生后的唯一目标就是重复执行next方法直到值取尽，否则就会停留在某个位置，等待下一次调用next；若是要再次迭代同个对象，你只能重新调用iter方法去创建一个新的迭代器对象，如果有两个或者多个循环使用同一个迭代器，必然只会有一个循环能取到值。