函数进阶_2

1. 常用内置函数

1.1 range()函数

语法：range(start, stop[, step])
注意：左闭右开
示例：

>>> list(range(1,5,2))
[1, 3]

1.2 zip()函数

介绍：zip()函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回--由这些元组组成的列表。
语法：zip(iter1 [,iter2 [...]]) --> zip object
• iter为可迭代的对象
• 返回值为zip对象
示例：

>>> num = [97,98,99]  # 可迭代的对象
>>> alphabet= ['a', 'b', 'c']

>>> zip(num, alphabet)
<zip object at 0x000001B00675EE80>

>>> list(zip(num, alphabet))
[(97, 'a'), (98, 'b'), (99, 'c')]  # 由元组组成的列表

1.3 map()函数

介绍：map() 会根据提供的函数对指定序列做映射。
语法：map(func, *iterables) --> map object
• func 以参数序列中的每一个元素调用 func 函数，返回包含每次 func 函数返回值的新列表。
示例：将[1,2,3,4]中每个元素变为字符串类型

>>> li = [1,2,3,4]
>>> map(str,li)
<map object at 0x0000021049778438>

>>> list(map(str,li))
['1', '2', '3', '4']

1.4 filter()函数

介绍：filter函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。
语法：filter(func or None, iterable) --> filter object
• func为自定义函数
• iterable为可迭代的对象
• 返回值为filter对象
示例：

def is_odd(n):
    return n % 2 == 1

li = list(filter(is_odd,range(1,10)))
print(li)
# [1, 3, 5, 7, 9]

2. 匿名函数

介绍:
当我们在传入函数时，有些时候，不需要去重复调用该函数，直接传入匿名函数更方便，也无需担心函数名冲突，并且还可以将匿名函数赋值给一个变量，再利用变量来调用该函数。
语法：表达式为:lambda x:x*x
• 关键字lambda表示匿名函数
• 冒号前面的x表示函数参数
• x*x是匿名函数的表达式，并且注意匿名函数只能有一个表达式，不用写return，返回值就是该表达式的结果
示例：
对于lambda x:x*x实际上就是：

def f(x):
    return x*x

有没有发现他可以和filter()函数结合使用：

>>> list(filter(lambda i:i%2,range(1,10)))
[1, 3, 5, 7, 9]

这样是不是比在上面filter()函数中的示例要好些呢。

3. 高阶函数

实际上，我们学习过的map(),filter()等都是高阶函数。那么只要满足以下一个条件的就是高阶函数。
• 函数名作为参数传入
• 函数名作为返回值

4. 闭包

闭包的定义需要满足以下三个条件：
• 在一个外函数中定义了一个内函数
• 内函数里运用了外函数的临时变量
• 并且外函数的返回值是内函数的引用
示例：

def test(number):
    print("--1--")
    def test_in(number_in): # 1.内部函数
        print(number_in)
        print("--2--")
        return number_in + number   # 2.外部环境的变量引用
    print("--3--")
    return test_in  #3.内部函数test_in返回


res = test(20)  # res = test_in
res(25) 
# --1--
# --3--
# 25
# --2--

5. 装饰器

由于我们在开发中要遵守封闭开放原则，所以python开发者开始使用装饰器，装饰器也就是说在不改变源代码的情况下为函数添加新的功能。并且使用@符号，@符号为语法糖。

示例：

import time

def calcu_time(func):
    def test_in():
        start = time.time()
        func()
        end = time.time()
        print("spend {}".format(end - start))
    return test_in

@calcu_time 
def test1():
    print("---test1---")
    time.sleep(2)

def test2():
    start = time.time()
    print("---test2---")

    # test1()函数部分
    time.sleep(2)
    end = time.time()

    print("spend {}".format(end - start))
    
test1()     
# ---test1---
# spend 2.0002634525299072
test2()     
# ---test2---
# spend 2.0007219314575195

这里calcu_time()函数可以计算某个函数的运行时间，而如果我们想要给大量的已写好的函数加上这个功能（可以计算自己运行时间的功能），就需要改写很多的地方(例如把test1改写为test2)，任务量巨大。这时候，例如用@calcu_time这个装饰器便可以扩展test1()函数的功能，即给某函数装饰一个功能，所以叫做装饰器。