python3自学之路-笔记16_各种函数的详解

 python3自学之路-笔记16_各种函数的详解

 

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# File  : 各种函数.py
# Author: DaShenHan&道长-----先苦后甜，任凭晚风拂柳颜------
# Date  : 2019/3/16

'''
1.偏函数

def test(a,b,c,d=1):
    print(a,b,c,d)
def test2(a,b,c,d=2):  改变默认传参调用老的函数，所以是偏函数
    test(a,b,c,d)

import  functools
test2(=functools.partial(test,d=2)
int2=functools.partial(int,base=2)
print(int2('1010'))

上面这两种都是定义偏函数的定义方法:指明某个函数里的某个参数偏爱某个值


2.高阶函数

def test(a):
    print(a)
test2=test   函数本身可以赋值给一个变量

当一个函数A的参数，接收的是另一个函数时，则把这个函数A称为是高阶函数
比如sorted函数，内部的参数key接收一个函数，所以它是高阶函数

l=[{'name':'sz1','age':'16'},{'name':'sz3','age':'15'},{'name':'sz2','age':'17'}]
def te(a):
    return a['age']
print(sorted(l,key=te,reverse=True))


def caculate(a,b,key):
    print(key(a,b))
def sum(a,b):
    return a+b
def jian(a,b):
    return a-b

caculate(5,3,sum)


3.返回函数

是指一个函数内部，它返回的数据是另外一个函数，就把这样的操作称为返回函数

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
    if flag=='-'
       return jian

 result=getfunc('+')
 res=resulet(1,3,5)


 4.匿名函数

 lambda 参数1，参数2:表达式
 只能写一个表达式，不能直接return 表达式的结果就是返回值 只适用于一些简单的操作处理


res=(lambda x,y:x+y)(1,2)
print(res)

l=[(1,2),(2,3),(4,1)]
res=sorted(l,key=lambda x:x[1])
print(res)

5.闭包

在函数嵌套的情况下，内层函数引用了外层函数的变量(包括参数)
外层函数，又把内层函数 当作返回值进行返回

def test():
    a=123
    def test2():
        print(a)
        b=666
    return  test2

new=test()
new()

def line_config(content,length):
    def line():
        print('-'*(length//2)+content+'-'*(length//2))
    return line

line1=line_config('哈哈',10)
line1()
line1()
line2=line_config('哈喽摩托',20)
line2()
line2()

注意事项1:
闭包中，如果需要修改引用的外层变量，需要用nonlocal 变量申明 否则会当作是闭包内新定义的变量
def test():
    a=123
    def test2():
        nonlocal a#改外层的变量a
        a=666
        print(a)
    return  test2

new=test()
new()

注意事项2:
当闭包内，引用了一个, 后期会发生变化的变量时，一定要注意

#函数什么时候才会确定内部变量标识对应的值
#当函数被调用的时候，才会真正的确定对应的值到底是什么，之前都是以普通的变量标识名称而存在
def test():
    a=123
    def test2():
        print(a)
    a=2
    return  test2

new=test()
new()


复杂闭包
def test():
    funcs=[]
    for i in range(1,4):
        def test2():
            print(i)
        funcs.append(test2)
    return funcs
    #print( funcs)

myfuncs=test()
print(myfuncs)
myfuncs[0]()
myfuncs[1]()
myfuncs[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
    #print( funcs)

myfuncs=test()
print(myfuncs)
myfuncs[0]()
myfuncs[1]()
myfuncs[2]()

6.装饰器

作用:在函数名以及函数体不变的前提下，给一个函数附加一些额外的代码
案例：发说说 发图片

#相关的功能函数 很少变动

def login(func):
    def inner():
        print('登录验证....')
        func()
    return  inner
def fss():
    print('发说说')
def ftp():
    print('发图片')

#相关的业务逻辑代码 经常变动
fss=login(fss)
ftp=login(ftp)
btnindex=2
if btnindex==1:
    fss()
else:
    ftp()

#发说说，发图片有个前提，就是用户必须登录成功

#1.直接在业务逻辑代码里面去修改，添加一个验证操作
# 因为业务逻辑代码非常多，所以造成了每一份逻辑代码在调用具体的功能函数之前，都需要去做一个登录验证。
# 代码冗余度就比较大，而且代码的复用性比较差，代码的维护性比较差


#2.直接在功能函数里面去修改，方便代码的重用
#
#

#3.开放封闭原则:已经写好的代码，尽量不要修改 如果想要新增功能，在原先代码基础上，单独进行拓展
#违背了单一功能原则 比如发图片就发图片，别搞什么检查登录

装饰器语法糖写法:

def login(func):
    def inner():
        print('登录验证。。。')
        func()
    return inner
@login
def ftp():
    print('发图片')
def fss():
    print('发说说')


ftp()
fss()

def zhuangshiqi_line(func):
    def innner():
        print('----------------------------')
        func()
    return innner

def zhuangshiqi_star(func):
    def inner():
        print('*'*30)
        func()
    return  inner

@zhuangshiqi_line

def print_content():
    print('社会我达哥，人狠话不多')
print_content()


'''