python_高级特性

目录

1、匿名函数

2、函数引用

2、偏函数

3、闭包

3.1、闭包简单使用

3.2、nonlocal

4、装饰器

5、高阶函数

5.1 map/reduce

5.2 filter

5.3 sorted

6、列表生成式 List Comprehensions

7、列表生成器 generator

8、迭代器与迭代器对象

9、引用

10、可变类型和不可变类型

11、递归函数

---

1、匿名函数

"""
    匿名函数：没有名字的函数，它是 以表达式来    定义的简单函数
    定义格式：
        lambda 参数1， 参数2：返回值
    调用格式：
        （lambda 参数1，参数2：返回值）（实参1，实参2）
    优点：
        匿名函数调用完的内存就会回收；
        性能比普通函数要好一些
"""

print((lambda num1, num2: num1 + num2)(1, 2))

"""（lambda 参数1，参数2：返回值）相当于函数名"""
# 匿名函数的应用：
data = filter(lambda num: num % 2 != 0, [1, 2, 3, 4, 5])  # filter(__function, __iterable)
for num in data:
    print(num)

list1 = [['zs', 10], ['lisi', 33], ['ww', 8]]
list1.sort(key=lambda arg: arg[1])
print(list1)    # [['ww', 8], ['zs', 10], ['lisi', 33]]

2、函数引用

# 函数名相当于变量名，而且还是一个全局变量，是一个代号，指向了这个函数
def fun():
    return '丫头'


a = fun
print(a())      # 丫头
print(fun())    # 丫头
print(a, fun)   # <function fun at 0x000001DEA6291048> <function fun at 0x000001DEA6291048>

print('。。。。。。。。。。。。。。求和、求差')


def func_sum(num1, num2):
    return num1 + num2


def func_sub(num1, num2):
    return num1 - num2


def fun_all(num1, num2, func_arg):
    ret = func_arg(num1, num2)
    print('运算结果为：%s' % ret)


fun_all(1, 2, func_sum)
fun_all(1, 2, func_sub)

'''
    要求定义函数可以对数据进行过滤，并可以自由指定过滤算法
'''


def func1(num):
    return num % 2 == 0


def func2(num):
    return num % 2 == 1


def func_filter(*args, func_arg):
    return [num for num in args if func_arg(num)]


data = func_filter(1, 2, 3, 4, 5, 8, 6, func_arg=func1)
print(data)
data = func_filter(1, 2, 3, 4, 5, 8, 6, func_arg=func2)
print(data)

print('。。。。。。。。')

'''
    引出：内置高阶函数filter
    python中将函数的参数为函数引用的函数称为高阶函数
    匿名函数可用于辅助高阶函数来使用
'''
data = filter(func1, [1, 2, 3, 4, 8])
for num in data:
    print(num, '')
data = filter(lambda num: num > 3, [1, 2, 3, 4, 8])
for num in data:
    print(num)


# （lambda 参数1，参数2：返回值）（实参1，实参2）
def func_filter(*args):
    return [num for num in args if (lambda num: num % 2 == 0)(num)]


print(func_filter(1, 2, 3, 4, 5, 8, 6))

2、偏函数

        Python的functools模块提供了很多有用的功能，其中一个就是偏函数（Partial function），functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。

import functools

# builtins: def __init__(self, x, base=10)
# int()函数可以把其他进制的字符串转换为十进制整数
print(int('526'))  # 526
print(int('526', base=8))  # 342
print(int('526', base=16))  # 1318
print(int('1000000', base=2))  # 64


# 每次都传入int(x, base=2)非常麻烦，可借助functools.partial

"""
    ❀ 创建偏函数时，实际上可以接收函数对象、*args和**kw这3个参数
    int2('1000000')相当于：
        kw = { 'base': 2 }
        int('1000000', **kw)
"""
int2 = functools.partial(int, base=2)  # 创建偏函数时，实际上固定了int()函数的关键字参数base
print(int2('1000000'))  # 64


# max(*args, key=None)
max2 = functools.partial(max, 10)  # 实际上会把10作为*args的一部分自动加到左边
print(max2(1, 4, 7))  # 10，此时的max2(1, 4, 7)相当于max(10, 1, 4, 7)
print(max(1, 4, 7))   # 7

3、闭包

3.1、闭包简单使用

需要满足的条件：

1. 函数嵌套函数
2. 返回内函数
3. 内函数引用外部函数环境

def lazy_sum(*args):
    """
    函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量，
当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”的程序结构拥有极大的威力
    ❀ 注意：当我们调用lazy_sum()时，【每次调用都会返回一个新的函数】，即使传入相同的参数
    :param args:
    :return:
    """

    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax

    return sum


f = lazy_sum(1, 3, 5, 7, 9)  # 调用lazy_sum()时，返回的并不是求和结果，而是求和函数
f1 = lazy_sum(1, 3, 5, 7, 9)
print(f())  # 25
print(f == f1)  # False

print('---------------')


def f(a):
    def g(b):
        def k(c):
            return a + b + c

        return k

    return g


print(f(1)(2)(3))

 注意：返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量，eg:

def count():
    fs = []
    for i in range(1, 4):
        def f():