python函数-高级1

1.函数的使用秒数

    1.1场景：当我们编写三方函数，为了方便他人使用，就要描述清楚我们所写的函数功能及使用方式等信息。

    1.2定义格式：直接在函数体的最上面，添加三个双引号对注释

                        def 函数():

                                        """这里是帮助信息"""

    1.3查看函数使用文档：help(函数)

def test(a,b):
    """
    计算两个数据的和，以及差
    :param a:数值1，数值类型，不可选，没有默认值
    :param b:数值2，数值类型，可选，默认值为1
    :return:返回的是计算的结果，元组：（和，差）
    """
    return

help(test)

    1.4经验：一般函数的描述，需要说明如下几个信息。

                  函数的功能

                  参数->含义

                            类型

                            是否可以省略

                            默认值

                    返回值->含义

                                 类型

2.偏函数

    2.1概念&场景：当我们写一个参数比较多的函数时，如果有些参数，大部分场景下都是某一个固定值，那么为了简化使用，就可以创建一个新函数，指定我们要使用的函数的某个参数，为某个固定的值。这个新函数就是“偏函数”。

    2.2语法：

         方式一：自己写一个新的

def test(a, b, c, d=1):
    print(a + b + c + d)

# # test(1, 2, 3)
#
# def test2(a, b, c, d=2):   # 这就是偏函数
#     test(a, b, c, d)
# test2(1, 2, 3)

        方式二：借助functools模块的partial函数

        import functools

        newFunc = functools.partial(函数, 特定参数=偏爱值)

import functools
newFunc = functools.partial(test,c=5)

print(newFunc, type(newFunc))

newFunc(1, 2)

    偏函数应用场景案例

    int()

numStr = "100010"
result = int(numStr, base=2)
print(result)

# 在往后的一段时间内，我都需要把一个二进制的字符串，转换为对应的十进制数据。

import functools
int2 = functools.partial(int, base=2)

print(int2(numStr))

3.高阶函数

    3.1概念：当一个函数A的参数，接收的又是另一个函数时，则把这个函数A成为是“高阶函数”

    3.2例如：sorted函数

l = [{"name": "fj", "age": 18}, {"name": "fj2", "age": 19}, {"name": "fj3", "age": 18.5}]

def getKey(x):
    return x["age"]


result = sorted(l, key=getKey)
print(result)

    3.3案例：动态计算两个数据

def caculate(num1, num2, caculateFunc):
    print(caculateFunc(num1, num2))        #这里等同于这种情况 result = caculateFunc(num1, num2)
                                                             # print(result)


def sum(a, b):
    return a + b

def jf(a, b):
    return a - b


caculate(6, 2, sum)
caculate(6, 2, jf)

4.返回函数

    4.1概念：是指一个函数内部，它返回的数据是另外一个函数；把这样的操作成为“返回函数”

    4.2案例：根据不同参数，获取不同操作，做不同计算

def getFunc(flag):
    # 1.再次定义几个函数
    def sum(a, b, c):
        return a + b + c
    def jian(a, b, c):
        return a - b - c
    # 2.根据不同的flag值，来返回不同的操作函数。
    if flag == "+":
        return sum
    elif flag == "-":
        return jian
result = getFunc("-")
# print(result, type(result))
res = result(1, 3, 5)
print(res)

5.匿名函数

    5.1概念：匿名函数也称之为“lambda函数”，顾名思义，就是指没有名字的函数。

    5.2语法：lambda 参数1, 参数2, ...:表达式

                  限制：只能写一个表达式，不能直接写return。

                            表达式的结果就是返回值。

                            所以，只适用于一些简单的操作处理。

result = (lambda x, y, z: x + y + z)(1, 2, 3)
print(result)

newFunc = lambda x, y, z: x + y + z
print(newFunc(4, 5, 6))

    5.3测试：

l = [{"name": "fj", "age": 18}, {"name": "fj2", "age": 19}, {"name": "fj3", "age": 18.5}]

# def getKey(x):
#     return x["name"]
# result = sorted(l,key=getKey)
# print(result)

# 上面可以写成
result = sorted(l, key=lambda x: x["name"])
print(result)

6.闭包

    6.1概念：在函数嵌套的前提下，内层函数引用了外层函数的变量（包括参数）。外层函数，又把内层函数当做返回值进行返回。->这个内层函数 + 所引用的外层变量，称为“闭包”。

def test():   # 外层函数
    a = 10
    def test2(): # 内层函数
        print(a)
    return test2
newFunc = test()
newFunc()

    6.2标准格式：

        def test1(a):

                b = 10

                其他函数定义代码：def test2():

                                                    print(a)

                                                    print(b)

                return test2

def test():   # 外层函数
    a = 10
    def test2(): # 内层函数
        print(a)
    return test2
newFunc = test()
newFunc()

    6.3应用场景：外层函数，根据不同的参数，来生成不同作用功能的函数。

    6.4案例：根据配置信息，生成不同的分割线函数。

# 案例：根据配置信息，生成不同的分割线函数。

def line_config(content, length):
    def line():
        print("-" * (length // 2) + content + "-" * (length // 2) )
    return line
line1 = line_config("闭包", 40)

line1()
line1()
line1()
line1()
line1()
line2 = line_config("大分隔", 100)
line2()
line2()
line2()
line2()

    6.5注意事项：

        6.5.1闭包当中，如果要修改引用的外层变量，需要使用nonlocal变量，声明。否则当做是比包内，新定义的变量。

def test():
    num = 10
    def test2():
        nonlocal num #声明 num为非局部变量。
        num = 666
        # print(a)
        print(num)
    print(num)
    test2()
    print(num)

    return test2

result = test()
# result()

        6.5.2当闭包内，引用了一个，后期会发生变化的变量时，一定要注意：

# def test():
#     a = 1
#     def test2():
#         print(a)
#     a = 2
#     return test2
# newFunc = test()
# newFunc()

# 函数，什么时候才会确定，内部，变量表示，对应的值？
# 当函数被调用的时候，才会真正的确定对应的值，到底是什么。之前，都是以普通的变量标识名而存在。
# def test():
#     print(b)
#
# print("xxxxxxxx")
#
# test()


# def test():
#     funcs = []
#     for i in range(1, 4):
#         def test2():
#             print(i)
#         funcs.append(test2)
#     return funcs
# newFunc = test()
#
# print(newFunc)
# newFunc[0]()
# newFunc[1]()
# newFunc[2]()


def test():
    funcs = []
    for i in range(1, 4):
        def test2(num):
            def inner():
                print(num)
            return inner
        funcs.append(test2(i))
    return funcs
newFunc = test()

print(newFunc)
newFunc[0]()
newFunc[1]()
newFunc[2]()