函数基础、函数参数及函数简单应用

友情提示：查看博客前，请打开目录，查找内容。感谢您前来参考，希望对您有用

函数基础

1 为什么要有函数？没有函数带来的困扰？
组织结构不清晰，可读性差
代码冗余
可扩展性差

2 什么是函数
具备某一个功能的工具—>函数
事先准备工具—>函数的定义
拿来就用、重复使用—>函数的调用
ps：先定义后调用

3 函数的分类：
内置函数：len，max(10,11)，help(函数名)
自定义函数：def

语法：
            def 函数名(参数1，参数2，...):
                """注释"""
                函数体
                return 返回值

函数类型与变量

def print_tag():
    print('*'*20)
print_tag()
print(print_tag)   #打印变量print_tag对应的内存地址

定义函数阶段，只检测语法，不执行代码

定义阶段：

def bar():   #定义一个函数名字为bar
    print('from bar')

调用阶段：

bar()   #调用函数

函数的使用：先定义后调用

def bar():
    print('from bar')
def foo():
    print('from foo')
    bar()   #先定义后调用
foo()  #foo函数调用bar函数

定义函数的三种形式

第一种：无参函数

def auth():   #无参函数
    name=input('name>>>').strip()
    password=input('password>>>').strip()
    if name == 'lqx' and password == '123':
        print('login successfull')
    else:
        print('login err')
auth()

第二种：有参函数

def auth(name,password):
    if name == 'lqx' and password == '123':
        print('login successfull')
    else:
        print('login err')
def interactive():
    name=input('name>>>').strip()
    password=input('password>>>').strip()
    auth(name,password)  #参数传入auth中
interactive()

第三种：空函数

def auth():
    pass

def put():
    pass

def get():
    pass

def ls():
    pass

函数的返回值

return的特点

1、函数内可以有多个return，但是只能执行一次return
2、执行return函数就立刻结束，并且return的后值当做本次调用的结果返回

def foo():
    print('first') 
    return 1  
    print('second')
    return 2
    print('third')
    return 3
foo()

返回的值没有类型限制

def bar():
    print('from bar')
def foo():
    return bar  #返回bar
print(foo() is bar)
a=foo()
a() #这里的a()就是bar()函数

返回值的个数

1、没有return：默认返回None
2、return值：值本身
3、return多个值：返回一个元组

def foo():
    pass
    return 1,'a',[1,2],{'name':123}
a=foo()
print(a)

函数调用的三种形式

def my_max(x,y):
    if x >= y:
        return x
    else:
        return y
res1=my_max(1,2)
res2=my_max(1,2)*10
res3=my_max(my_max(1,2),3)
print(res1,res2,res3)

函数参数

函数的参数分类两种

形参：在定义阶段括号内指定的参数，相当于变量名
实参：在调用阶段括号内传入的值称为实参，相当于值
在调用阶段，实参的值会绑定给形参，在调用结束后解除绑定

def foo(x,y):    #x=1,y=2
    print(x,y)
foo(1,2)

在python中参数的分类

位置参数：按照从左到右的顺序依次定义的参数

位置形参：必须被传值，多一个少一个都不行
位置实参：与形参一一对应传值

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

关键字参数：在函数调用时，按照key=value的形式定义的实参

特点：指名道姓地给形参传值，不在依赖与位置

注意：
1、关键字实参必须在位置实参的后面
2、不能为同一个参数赋值多次

def foo(name,age,sex):
    print(name,age,sex)
foo('lqx',18,'male')
foo(name='lqx',age=18,sex='male')

默认参数：在函数定义阶段，就已经为形参赋值了

特点：定义阶段已经有值意味着调用阶段可以不用传值
位置参数通常用于经常变化的参数，而默认参数指的是大多数情况下都一样的

注意：
1、默认参数必须放到位置形参的后面
2、默认参数的值只在定义时被赋值一次
3、默认的参数的值通常应该是不可变类型（str，int，tuple）

def register(name,age,sex='male'):
    print(name,age,sex)

register('egon1',18)           #位置实参，传参
register('egon2',18)           #关键字实参，传参
register('egon3',18)           #位置实参，默认参数，传参
register('alex',38,'female')   #关键字实参，默认参数，传参

可变长参数：在调用函数时，实参值的个数不固定

*args的用法：(多余的值以元组的形式保留)

# *args的用法:
def foo(x,y,*args):     #args=(4,5,6,7)
    print(x,y)
    print(args)
foo(1,2,4,5,6,7)
foo(*[1,2,4,5,6,7])    #这里的*的意思是把list中的值解压

**kwargs的用法：（多余的值以字典的形式保留）

#**kwargs的用法
def foo(x,y,**kwargs):
    print(x,y)
    print(kwargs)
foo(x=1,y=2,z=3,a=5,b=6)
foo(**{'x':1,'y':2,'z'=3,'a':5,'b':6})  #这里的**的用法是把dict中的值解压

*args和**kwargs的用法：

def bar(x,y,z):
    print(x,y,z)
def wrapper(*args,**kwargs):  #args=(1) kwargs={'y':43,'z':1213}
    bar(*args,**kwargs)         #bar(*(1),**{'y':43,'z':1213})
wrapper(1,y=43,z=1213)

命名关键字参数：指的是定义在*后的参数，该参数必须被传值（除非它有默认值），而且必须按照key=value的形式传参

def foo(x,y,*args,n):   #这里的n必须使用关键字传参
    print(x,y)
    print(args)
    print(n)
foo(1,2,3,4,5,n=1231)