python的高级特性

列表生成式

列表生成式就是一个用来生成列表的特定语法形式的表达式。
是Python提供的一种生成列表的简洁形式, 可快速生成一个新的list。
使用列表生成式可以生成复杂列表。

普通的语法格式：[exp for iter_var in iterable]

带过滤功能语法格式: [exp for iter_var in iterable if_exp]

循环嵌套语法格式: [exp for iter_var_A in iterable_A for iter_var_B in iterable_B]

生成集合：

生成字典：

生成器

一边循环一边计算的机制，称为生成器
生成器一般在性能受到限制的时候才会用到

创建生成器
1.将列表生成式的 [ ] 改为 （）
2.yield关键字

生成器默认返回的时一个生成器对象，那怎么打印生成器对象中的元素呢？
1.for循环依次计算
2.next()方法

生成器的特点：
节省内存，迭代到下一次调用时，参数都是上次调用时留下的。

案例：使用生成器创建斐波那契数列

def fibonaqie(n):
    a = 0
    b = 1
    count=0
    if n<=0:
        print('输入有误，请重新输入')
    else :
        while count<n:
            count+=1
            yield b
            a,b=b,a+b

f=fibonaqie(5)
for i in f:
    print(i)

迭代器

迭代时访问序列元素的方式
迭代器对象从序列第一个元素开始访问，直到最后一个元素结束。

可迭代对象：可以for循环的对象：
list，str，set，tuple，dict
生成器
迭代器（）

生成器和迭代器的区别

生成器时创建迭代器的生成工具
迭代器是用来帮助我们记录每次迭代访问到的位置，当我们对迭代器使用next()函数的时候，迭代器会向我们返回它所记录位置的下一个位置的数据。for循环的本质就是先通过iter()函数获取可迭代对象Iterable的迭代器，然后对获取到的迭代器不断调用next()方法来获取下一个值并将其赋值给item，当遇到StopIteration的异常后循环结束。
生成器是只能遍历一次的

闭包

闭包是由函数及其相关的引用环境组合而成的实体。

当闭包执行完后，仍然能够保持住当前的运行环境。
改变外部变量，可以实现不同功能

def add(a,b):
    def sum(x):
        return a*x+b*x
    return sum

add1=add(6,7)
add2=add(10,27)
sum1=add1(5)
sum2=add2(10)

装饰器

装饰器通过闭包形成，本质上是一个python函数或者类，可以让其他的函数在不做修改的前提下实现扩展功能装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景，
比如：插入日志、性能测试、事务处理、缓存、权限校验等应用场景。

面向对象遵循的开放封闭原则，对已完成功能的代码块封闭，对扩展开发。

比如：

def foo():
	print("this is a test")

要给该函数插入日志

def foo():
	print("this is a test")
	logging.info("foo is running")

如果函数数量不多可以这样实现，但如果有成百上千个函数都有需求，就很麻烦，所以引入装饰器，将插入日志封装成一个装饰器。

def logging(func):
	def warpper():
		logging.info("%s is running" %(func.__name__))
		result=func()
		return result
	return warpper

@logging
def foo():
	print("this is a test")

foo()

在接下来的执行foo或其他函数时，只要添加logging装饰器，就能实现插入日志功能

在上面的例子中，被装饰的函数不需要传递参数，因为不确定传入的参数个数，所以无法编写一个统一的装饰器模板，那怎么解决函数的参数问题呢？

def logging(func):
	def warpper(*args,**kwargs):
		logging.info("%s is running" %(func.__name__))
		result=func(*args,**kwargs)
		return result
	return warpper

@logging
def foo(*args,**kwargs):
	print("this is a test")

foo()

带参数的装饰器

装饰器的语法允许我们时，提供其他参数，这样就可以提供更大的灵活性

def  logging_more(type)
	def logging(func):
		def warpper(*args,**kwargs):
			logging.info("%s is running" %(func.__name__))
			if type='local':
				result=func(*args,**kwargs)
			return result
		return warpper
	return loggin

@logging_more(type='loca')
def foo():
	print("this is a test")

foo()

类装饰器

装饰器不止可以通过函数实现，还可以通过类实现。
类装饰器灵活度高，更封装，高内聚，类装饰器靠__call__方法实现。

import logging

class sus:
    def __init__(self,func):
        self.func=func

    def __call__(self, *args, **kwargs):
        logging.info("%s is running" %(self.func.__name__))

@sus
def foo():
    print("this is a test")

foo()

多个装饰器执行顺序

当一个函数被多个装饰器装饰时，执行顺序是从下到上。
举例来说：

def is_login(func):
	def warpper1(*args,**kwargs):
		print("正在登录")
		result=func(*args,**kwargs)
		return result
	return warpper

def is_permission(fun):
	def warpper2(*args,**kwargs):
		print("判断是否有权限")
		result=fun(*args,**kwargs)
		return result
	def warpper
	
@is_login  # delete = is_login(delete)
@is_permission
def delete():
    return "正在删除学生信息"

装饰器的装饰顺序为:
delete=is_permission(delete),delete=warpper2() ，delete=is_login(warpper2), delete=warpper1
调用顺序：
warpper1() -> warpper2() ->delete()

高阶函数

map函数：

map()函数接收两个参数，一个是函数，一个是序列，map 将传入的函数依次作用到序列的每个元素，并把结果作为新的 list 返回，返回的是一个map对象。
当序列接受的序列参数大于一个时，map函数会并行执行。如图

reduce函数

reduce() 函数会对参数序列中元素进行累积。
reduce函数需从functools模块中导入
第一个参数接受一个函数名，后面的参数接受一个或多个可迭代的序列，返回的是一个结果。 如图

from functools import reduce
add=lambda x,y:x*y
print(reduce(add,[5,3,10,13]))

filter函数

和 map()类似，filter()也接收一个函数和一个序列。和 map()不同的时，filter()把传入
的函数依次作用于每个元素，然后根据返回值是 True 还是 False 决定保留还是丢弃该元素。

print(list(filter(lambda x:x%2==0,[123,456,789,62,52,21])))

sorted函数

sort()函数和sorted()函数的区别：
<1. 排序对象不同: sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
<2. 返回值不同:
list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，
内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

练习：
1.

def cache(func):
    def warpper(*args,**kwargs):
        lee=[]
        if <=len(lee):
            print(lee[])
        elif >len(lee):
            lee.append(fib())
        else:
            print("请输入正确数字")
    return warpper


@cache
def fib(n):
    if n<=2:
        return 1
    elif n>2:
        return fib(n-1)+fib(n-2)

fib(8)

import string
def comp(version1,version2):
    ver1=list(map(int,version1.split(".")))
    ver2=list(map(int,version2.split(".")))
    len1=len(ver1)
    len2=len(ver2)
    max=0
    if len1<len2:
        for i in range(len2-len1):
            ver1.append(0)
    elif len1>len2:
        for i in range(len1-len2):
            ver2.append(0)
    for i in range(len(ver1)):
        if ver1[i]>ver2[i]:
            return 1
        elif ver1[i]<ver2[i]:
            return -1
        else:
            return 0

def main():
    vers1=input("please input str1:")
    vers2=input("please input sre2:")
    print(comp(vers1,vers2))

if __name__ == '__main__':
    main()