函数基础

一 函数知识体系

什么是函数？
为什么要用函数？
函数的分类：内置函数与自定义函数
如何自定义函数
语法
定义有参数函数，及有参函数的应用场景
定义无参数函数，及无参函数的应用场景
定义空函数，及空函数的应用场景
调用函数
如何调用函数
函数的返回值
函数参数的应用：形参和实参，位置参数，关键字参数，默认参数，*args，**kwargs
高阶函数（函数对象）
函数嵌套
作用域与名称空间
装饰器
迭代器与生成器及协程函数
三元运算，列表解析、生成器表达式
函数的递归调用
内置函数
面向过程编程与函数式编程

二 函数基础

# 注册功能
uname=input('username>>：').strip()
pwd1=input('password>>: ').strip()
pwd2=input('重复输入密码>>: ').strip()
if pwd1 == pwd2:
    with open('db.txt','at',encoding='utf-8') as f:
        f.write('%s:%s
' %(uname,pwd1))
        f.flush()

#认证功能
inp_uname=input('请输入你的账号：').strip()
inp_pwd=input('请输入你的密码：').strip()
with open('db.txt','rt',encoding='utf-8') as f:
    for line in f:
        info=line.strip('
').split(':')
        if inp_uname == info[0] and inp_pwd == info[1]:
            print('login successfull')
            break
    else:
        print('账号或密码错误')

 

一 为何要用函数之不用函数的问题

#1、代码的组织结构不清晰，可读性差
#2、遇到重复的功能只能重复编写实现代码，代码冗余
#3、功能需要扩展时，需要找出所有实现该功能的地方修改之，无法统一管理且维护难度极大 

 

二 函数是什么

针对二中的问题，想象生活中的例子，修理工需要实现准备好工具箱里面放好锤子，扳手，钳子等工具，然后遇到锤钉子的场景，拿来锤子用就可以，而无需临时再制造一把锤子。

修理工===>程序员
具备某一功能的工具===>函数

要想使用工具，需要事先准备好，然后拿来就用且可以重复使用
要想用函数，需要先定义，再使用

 

1、什么是函数？

在程序中,函数就具备某一功能的工具
事先将工具准备好即函数的定义
遇到应用场景拿来就用即函数的调用
所以务必记住:#函数的使用必须遵循先定义,后调用的原则

 

2、为何要用函数

不用函数问题是：
1、程序冗长
2 程序的扩展性差
3 程序的可读性差

 

3 如何用函数:

函数的使用必须遵循先定义,后调用的原则

二 定义函数

一 如何自定义函数？

def 函数名(参数1,参数2,...):
    '''
    函数功能的描述信息
    :param 参数1: 描述
    :param 参数2: 描述
    :return: 返回值
    '''
    代码1
    代码2
    代码3
    ...
    return 返回值

# 准备好工具=>函数的定义阶段
def register():
    while True:
        uname=input('username>>：').strip()
        if uname.isalpha():
            break
        else:
            print('用户名必须由字母组成傻叉')

    while True:
        pwd1=input('密码>>: ').strip()
        pwd2=input('重复输入密码>>: ').strip()
        if pwd1 == pwd2:
            break
        else:
            print('两次输入的密码不一致,眼瞎吗')

    with open('db.txt','at',encoding='utf-8') as f:
        f.write('%s:%s
' %(uname,pwd1))
        f.flush()

def auth():
    #认证功能
    inp_uname=input('请输入你的账号：').strip()
    inp_pwd=input('请输入你的密码：').strip()
    with open('db.txt','rt',encoding='utf-8') as f:
        for line in f:
            info=line.strip('
').split(':')
            if inp_uname == info[0] and inp_pwd == info[1]:
                print('login successfull')
                break
        else:
            print('账号或密码错误')

# 拿来就用=>函数的调用阶段
# print(register)
# register()
# auth()
# register()
# register()

 

二 函数使用的原则：先定义，再调用

函数的使用必须遵循先定义,后调用的原则,没有事先定义函数，而直接引用函数名，就相当于在引用一个不存在的变量名

#测试一
def foo():
    print('from foo')
    bar()
foo() #报错

#测试二
def bar():
    print('from bar')
def foo():
    print('from foo')
    bar()
foo() #正常

#测试三
def foo():
    print('from foo')
    bar()
    
def bar():
    print('from bar')
foo() #会报错吗?  不会

#测试四
def foo():
    print('from foo')
    bar()
    
foo() #会报错吗?  会

def bar():
    print('from bar')

#结论:函数的使用,必须遵循原则:先定义,后调用
#我们在使用函数时,一定要明确地区分定义阶段和调用阶段

#定义阶段
def foo():
    print('from foo')
    bar()
def bar():
    print('from bar')
#调用阶段
foo()

 

三 函数在定义阶段都干了哪些事？

只检测语法，不执行代码

也就说，语法错误在函数定义阶段就会检测出来，而代码的逻辑错误只有在执行时才会知道

 

四 定义函数的三种形式

#1、无参：应用场景仅仅只是执行一些操作，比如与用户交互，打印
#2、有参：需要根据外部传进来的参数，才能执行相应的逻辑，比如统计长度，求最大值最小值
#3、空函数：设计代码结构

#定义函数时的参数就是函数体接收外部传值的一种媒介，其实就一个变量名

#1、无参函数：
# 在函数定义阶段括号内没有参数，称为无参函数
# 注意：定义时无参，意味着调用时也无需传入参数
# 应用：
#如果函数体代码逻辑不需要依赖外部传入的值，必须定义无参函数

# def func():
#     print('hello world')
# func()


#2、有参函数
# 在函数定义阶段括号内有参数，称为有参函数
# 注意：定义时有参，意味着调用时也必须传入参数
# 应用：
#如果函数体代码逻辑需要依赖外部传入的值，必须定义成有参函数
# def sum2(x,y):
#     # x=10
#     # y=20
#     res=x+y
#     print(res)
#
# sum2(10,20)
# sum2(30,40)

def check_user():
    while True:
        uname=input('username>>：').strip()
        if uname.isalpha():
            return uname
            # break
        else:
            print('用户名必须由字母组成傻叉')

def check_pwd():
    while True:
        pwd1=input('密码>>: ').strip()
        pwd2=input('重复输入密码>>: ').strip()
        if pwd1 == pwd2:
            return pwd1
        else:
            print('两次输入的密码不一致,眼瞎吗')

def db_hanle(uname,pwd1):
    with open('db.txt','at',encoding='utf-8') as f:
        f.write('%s:%s
' %(uname,pwd1))
        f.flush()

def register():
    # 检测用户名是否合法
    x=check_user() #x='EGON'
    # 检测密码是否合法
    y=check_pwd() #y='123'

    # 写入数据文件
    # db_hanle(合法的用户名，合法的密码)
    db_hanle(x,y)

# register()

#3、空函数

# def func():
#     pass

def check_user():
    pass

def check_pwd():
    pass

def write_db(x,y):
    pass

def register():
    #1 输入用户名，并进行合法性校验
    #2 输入密码，并进行合法性校验
    #3 将合法的用户名、密码写入文件
    x=check_user()
    y=check_pwd()
    write_db(x,y)

三 调用函数

一 调用函数

函数的调用：函数名加括号
1 先找到名字
2 根据名字调用代码

二 函数返回值

无return->None
return 1个值->返回1个值
return 逗号分隔多个值->元组

什么时候该有返回值？
　　　　调用函数，经过一系列的操作，最后要拿到一个明确的结果，则必须要有返回值
　　　　通常有参函数需要有返回值，输入参数，经过计算，得到一个最终的结果
什么时候不需要有返回值？
　　　　调用函数，仅仅只是执行一系列的操作，最后不需要得到什么结果，则无需有返回值
　　　　通常无参函数不需要有返回值

三 函数调用的三种形式

1 语句形式：foo()
2 表达式形式：3*len('hello')
3 当中另外一个函数的参数：range(len('hello'))

四 函数的参数

一 形参与实参

#形参即变量名，实参即变量值，函数调用时，将值绑定到变量名上，函数调用结束，解除绑定

二 具体应用

#1、位置参数：按照从左到右的顺序定义的参数
        位置形参：必选参数
        位置实参：按照位置给形参传值

#2、关键字参数：按照key=value的形式定义的实参
        无需按照位置为形参传值
        注意的问题：
                1. 关键字实参必须在位置实参右面
                2. 对同一个形参不能重复传值

#3、默认参数：形参在定义时就已经为其赋值
        可以传值也可以不传值，经常需要变得参数定义成位置形参，变化较小的参数定义成默认参数（形参）
        注意的问题：
                1. 只在定义时赋值一次
                2. 默认参数的定义应该在位置形参右面
                3. 默认参数通常应该定义成不可变类型


#4、可变长参数：
        可变长指的是实参值的个数不固定
        而实参有按位置和按关键字两种形式定义，针对这两种形式的可变长，形参对应有两种解决方案来完整地存放它们，分别是*args，**kwargs

        ===========*args===========
        def foo(x,y,*args):
            print(x,y)
            print(args)
        foo(1,2,3,4,5)

        def foo(x,y,*args):
            print(x,y)
            print(args)
        foo(1,2,*[3,4,5])


        def foo(x,y,z):
            print(x,y,z)
        foo(*[1,2,3])

        ===========**kwargs===========
        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,a=1,b=2,c=3)

        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,**{'a':1,'b':2,'c':3})


        def foo(x,y,z):
            print(x,y,z)
        foo(**{'z':1,'x':2,'y':3})

        ===========*args+**kwargs===========

        def foo(x,y):
            print(x,y)

        def wrapper(*args,**kwargs):
            print('====>')
            foo(*args,**kwargs)

#5、命名关键字参数：*后定义的参数，必须被传值（有默认值的除外），且必须按照关键字实参的形式传递
可以保证，传入的参数中一定包含某些关键字
        def foo(x,y,*args,a=1,b,**kwargs):
            print(x,y)
            print(args)
            print(a)
            print(b)
            print(kwargs)

        foo(1,2,3,4,5,b=3,c=4,d=5)
        结果：
            2
            (3, 4, 5)
            3
            {'c': 4, 'd': 5}

此乃重点知识！！！

#总的分类：
# #1、形参：在函数定义阶段括号内定义的参数，称之为形式参数，简称形参，本质就是变量名
# def foo(x,y): #x=1,y=2
#     print(x)
#     print(y)
# #2、实参：在函数调用阶段括号内传入的值，称之为实际参数，简称实参，本质就是变量的值
# foo(1,2)
#

#详细的分类：
#一、位置参数：
#位置形参：在函数定义阶段，按照从左到右的顺序依次定义的形参，称之为位置形参
#特点：但凡是按照位置定义的形参，都必须被传值，多一个不行，少一个也不行
# def foo(x,y):
#     print('x:',x)
#     print('y:',y)

#位置实参：在函数调用阶段，按照从左到右的顺序依次定义的实参，称之为位置实参
#特点：按照位置为对应的形参依次传值
# foo(1,2)
# foo(2,1)


#二、关键字实参:在调用函数时，按照key=value的形式为指定的参数传值，称为关键字实参
#特点：可以打破位置的限制，但仍能为指定的形参赋值
# foo(y=2,x=1)

#注意：
#1、可以混用位置实参与关键字实参，但位置实参必须放在关键字实参的前面
# foo(1,y=2)
# foo(y=2,1) #SyntaxError: positional argument follows keyword argument

#2、可以混用，但不能对一个形参重复赋值
# foo(1,y=2,x=10)


#三：默认参数：在函数定义阶段，就已经为形参赋值，该形参称为默认形参
#特点：在定义阶段就已经被赋值，意味着在调用可以不用为其赋值
# def foo(x,y=10):
#     print('x:',x)
#     print('y:',y)

# foo(1)
# foo(1,3)
# 注意：
#1、位置形参必须放到默认形参的前面，否则报语法错误
# def foo(x=1,y):
#     pass

#2、默认参数的值只在定义阶段赋值一次，即默认参数的值在函数定义阶段就已经固定死了

# m=10
# def foo(x=m,y=11):
#     print(x)
#     print(y)
# m=1111111111111111111111111111111111111111111111111111111111
# foo()

#3、默认参数的值通常应该定义不可变类型

# def register(name,hobby,hobbies=[]):
#     hobbies.append(hobby)
#     print('%s的爱好' %name,end=':')
#     print(hobbies)
#
# register('egon','play')
# register('alex','piao')
# register('lxx','烫头')

# def register(name,hobby,hobbies=None):
#     if hobbies is None:
#         hobbies=[]
#     hobbies.append(hobby)
#     print('%s的爱好' %name,end=':')
#     print(hobbies)
#
# register('egon','play')
# register('alex','piao')
# register('lxx','烫头')



#总结：
#实参的应用：取决于个人习惯，
#形参的应用：
#1、位置形参：大多数情况下的调用值都不一样，就应该将该参数定义成位置形参
#2、默认形参：大多数情况下的调用值都一样，就应该将该参数定义成默认形参
# def register(name,age,sex='male'):
#     print(name)
#     print(age)
#     print(sex)
#
#
# register('egon',18,)
# register('大脑门',73,'female')
# register('小脑门',84,)
# register('大高个',18,)



#四：可变长参数：指的是在调用函数时，传入的参数个数可以不固定
#而调用函数时，传值的方式无非两种，一种位置实参，另一种时关键字实参
#所以对应着，形参也必须有两种解决方案，来分别接收溢出的位置实参(*)与关键字实参(**)

#1、形参中某个参数带*
#形参中的*会将溢出的位置实参全部接收，然后存储元组的形式，然后把元组赋值给*后的变量名
# def foo(x,y,*z): #x=1,y=2,z=(3,4,5,6,7)
#     print(x)
#     print(y)
#     print(z)
# foo(1,2,3,4,5,6,7)

# 应用
# def my_sum(*nums):
#     res=0
#     for num in nums:
#         res+=num
#     return res
#
# print(my_sum(1,2,3,4,5))

# 2、实参中的参数也可以带*
# 实参中带*，*会将该参数的值循环取出，打散成位置实参
#ps：以后但凡碰到实参中带*的，它就是位置实参，应该立马打散成位置实参去看
# def foo(x,y,z):
#     print(x,y,z)

# foo(1,*[2,3]) #foo(1,2,3)
# foo(1,*'he') #foo(1,'h','e')
# foo(1,*(2,3,4)) #foo(1,2,3,4)

# def foo(x,y,z,*args):
#     print(x)
#     print(y)
#     print(z)
#     print(args)
#
# foo(1,2,3,4,5,6,7,*[8,9,10,11]) #foo(1,2,3,4,5,6,7,8,9,10,11)
#注意：约定俗成形参中的*变量名的写法都是：*args



#1、形参中某个参数带**
#形参中的**会将溢出的关键字实参全部接收，然后存储字典的形式，然后把字典赋值给**后的变量名
# def foo(x,y,**z): #x=1,y=2,z={'c':5,'b':4,'a':3}
#     print(x)
#     print(y)
#     print(z)
# foo(1,2,a=3,b=4,c=5)

# 2、实参中的参数也可以带**,该参数必须是字典
# 实参中带**，**会将该参数的值循环取出，打散成关键字实参
#ps：以后但凡碰到实参中带**的，它就是关键字实参，应该立马打散成关键字实参去看
# def foo(x,y,z):
#     print(x)
#     print(y)
#     print(z)

# foo(1,2,**{'a':1,'b':2,'c':3,'z':3}) #foo(1,2,c=3,b=2,a=1,z=3)
# foo(**{'z':3,'x':1,'y':2}) #foo(y=2,x=1,z=3)

#注意：约定俗成形参中的**变量名的写法都是：**kwargs

# def index(name,age,sex):
#     print('welecome %s:%s:%s to index page' %(name,age,sex))
#
# def wrapper(*args,**kwargs): #args=(1,),kwargs={'x': 1, 'y': 2, 'z': 3}
#     index(*args,**kwargs) #index(*(1,),**{'x': 1, 'y': 2, 'z': 3}) #index(1,x=1,y=2,z=3)
#
# wrapper(name='egon',sex='male',age=18)
#

# 五 命名关键字形参:在函数定义阶段，*后面的参数都是命名关键字参数(**)
# 特点：在传值时，必须按照key=value的传，并且key必须命名关键字参数指定的参数名
# def register(x,y,z,**kwargs): #kwargs={'b':18,'a':'egon'}
#     if 'name' not in kwargs or 'age' not in  kwargs:
#         print('用户名与年龄必须使用关键字的形式传值')
#         return
#     print(kwargs['name'])
#     print(kwargs['age'])
# register(1,2,3,a='egon',b=18)


# def register(x,y,z,*args,name='egon',age):
#     print(args)
#     print(name)
#     print(age)
# register(1,2,3,4,5,6,7,age=18)




# def foo(x,y=1,*args,z=1,a,b,**kwargs):
#     pass


# foo(1,*[1,2,3],a=1,**{'x':1,'y':2}) #foo(1,1,2,3,a=1,y=2,x=1)


# foo(1,2)
# foo(x=1,y=2)


# open('a.txt','w',encoding='utf-8')

# 五 命名关键字形参:在函数定义阶段，*后面的参数都是命名关键字参数(**)
# 特点：在传值时，必须按照key=value的传，并且key必须命名关键字参数指定的参数名
def register(x,y,z,**kwargs): #kwargs={'b':18,'a':'egon'}
    if 'name' not in kwargs or 'age' not in  kwargs:
        print('用户名与年龄必须使用关键字的形式传值')
        return
    print(kwargs['name'])
    print(kwargs['age'])
register(1,2,3,a='egon',b=18)


def register(x,y,z,*args,name='egon',age):
    print(args)
    print(name)
    print(age)
register(1,2,3,4,5,6,7,age=18)




def foo(x,y=1,*args,z=1,a,b,**kwargs):
    pass


foo(1,*[1,2,3],a=1,**{'x':1,'y':2}) #foo(1,1,2,3,a=1,y=2,x=1)

4.动态参数

按位置传值多余的参数都由*args统一接收，保存成一个元组的形式

按关键字传值接受多个关键字参数，由**kwargs接收，保存成一个字典的形式

def 函数名(参数1,参数2,默认参数,*args,命名关键字参数,**kwargs):
#def foo(1,2,x=1,*args,name='han',**kwargs):

        """注释：函数功能和参数说明"""
        函数体
        ……
        return 返回值