函数的三种定义方式

函数

# 什么是函数
可以实现某一个功能

# 先定义，后执行
def foo():
    print('from foo')
    bar()
def bar()
	print('from bar')
foo()  # foo() 这个函数是可以执行的    
===================================================
def foo():
    print('from foo')
    bar()
foo()  # foo() 这个函数是不可以执行的    
def bar()
	print('from bar')

无参函数

# 无参函数     
# func（）函数的变量名跟变量名一样，以数字字母下划线组成，原理也一样，从内存开辟一个空间将代码放进去，将内存地址跟函数名绑定在一起
def func():
    print("ojbk")
    print("ojbk")
func()  # 使用函数

有参函数

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

空函数,函数体pass

# 空函数，函数体pass
def func(x,y):
    pass

应用场景

# 第一种场景  有参函数
def func(x, y):  # x，y 原材料     
    res = x + y
    return res  # res 加工出的产品


res = func(2, 5)
print(res)

# 用户登录界面的函数   无参函数
def input_name_passwd():
    name = input("please input your name: ")
    passwd = input("please input your password: ")
    res = 'my name is {0},my age is {1}'.format(name, passwd)
    return res


res = input_name_passwd()
print(res)

# 空函数   构思函数功能
def func()：
	'''构思函数'''
	pass

return

# 返回值,函数的处理结果
当一个函数需要返回值的情况可以返回值
# 遇到return整个函数中断
# 返回值没有参数默认是None，不设置返回值是默认也是None
def foo(x,y):
    res = x + y
    return res
res = foo(5,6)
print(res)
11

形参和实参

# 形参 ：在定义函数阶段时的参数做形参，相当于变量名
def func(x,y):
    print(x,y)
# 实参：在调用函数阶段的值称之为实参，相当于变量值
func(1,2)

# 形参与实参的关系
1.在函数调用阶段，实参会绑定给形参
2.这种绑定关系只能在函数体内使用
3.函数调用结束时，解除绑定关系

# 实参可以分为哪几类
1.直接是一个值
func(1,2)

2.可以是变量
a = 1
b = 2
func(a,b)

3.可以是功能值
func(int('1'),2)
func(func(1,2),func(3,4))

形参，实参的具体使用

# 位置参数
1.位置形参：按照从左到右的顺序直接定义的变量名
	特点：必须被传值，多一个不行，少一个不行
def func(x,y):
    print(x,y)
2.位置实参：按照从左到右的顺序把值传给形参
	特点：按照顺序，与形参一一对应
func(1,2)

# 关键字参数
1. 可以不一一对应，但是实参不能多一个，也不能少一个
def func(x,y):
    print(x,y)
func(y=1,x=2)

2.混合使用，强调
	1.位置实参必须放在关键字实参前
    	func（1，y=2）
        func(y=2,1)  # 这种不符合语法
        
    2.不能为同一个形参重复传值
        func(1,y=2,x=3)  # 报错

        
# 默认形参
def func(x=1,y=2):
    print(x,y)
    
def func(x,y=2):
    print(x,y) 
func(1)
func(x=1)
func(1,3)  # 此时结果 1  3  y以实参为准

# 位置形参和默认形参混用
1.位置形参必须在默认形参前面
	def func(x,y=2)
    	print(x,y)
    func(x=1)

2.默认参数的值是在函数定义阶段被赋值的，准确的说被赋予的值的内存地址
	方式一：
    m = 2
    def func(x,y=m)
    	print(x,y)
    m = 333333
    func(1)
    1,2
    
    方式二：
    m = [111]
    def func(x,y=m)
    	print(x,y)
     m.append('sun')
    func(1)
    1,[111,'sun']

# 可变长度的参数
	# 位置形参的可变长度
        1.*args	形参名：用来接收溢出的位置参数，溢出的位置实参会被*保存成元组
        def func(*args):  # args = (1,2,3,4,5,6)
            res = 0
            for y in  x :
                res += y
            print(res)
        func(1,2,3,4,5,6)
            21
    # 关键字形参的可变长度
    1.**kwargs形参名：用来接受溢出的位置参数，或移除的位置实参会被**保存成字典
		def func(**kwargs):  # kwargs = {'a': 1, 'b': 2, 'c': 3}
    		print(x)
		func(a=1,b=2,c=3)
        {'a': 1, 'b': 2, 'c': 3}
        
    # *位置实参的可变长度
    def func(x,y,z):
    	print(x,y,z)

	func(*[11,222,33])  # func(11,222,33)   列表可以拆分，元组也可以，集合，字符串，字典取出的是Key
   	 11 222 33
    
   # ** 关键字实参的可变长度  只能跟字典，将字典打散成key=value
def func(a,b,c):
    print(a,b,c)
func(**{'a':1,'b':2,'c':3})
1 2 3
    
# 命令关键字形参，在*和**之间，不属于默认形参和位置形参
特点：传参的时候必须是key=value的关键字参数
def func(a, b, *args, c, d=66, **kwargs):
    print(a)
    print(b)
    print(args)
    print(c)
    print(d)
    print(kwargs)
func(1, 2, 345, c=55, Y=11, p=456)
1
2
(345,)
55
66
{'Y': 11, 'p': 456}

装饰器

# 要根据内部调用的函数的规则
def index(a, b):
    print(a, b)


def wrapper(*args, **kwargs):
    print(args, kwargs)
    index(*args, **kwargs)


wrapper(1, b=2)

解释形参的的数据类型

def add(x:int,y:int)->int:  # 注释x，y因该输入什么类型，最后是注释 return的值数据类型
    res = x + y
    return res
r = add（10，20）
print(r)
30

总结

# 形参
位置形参：
1.必须传值，
2.位置实参与位置形参必须一一对应

默认形参
1.当实参不给参数的时候，默认形参生效
2.当实参给新的参数的时候，会被赋值
3.可以不被传值
# 实参
位置实参：
1.与形参一一对应

关键字实参：
1.与形参可以不一一对应

# *
形参：
*会将溢出的实参赋值给*后面的变量，组成一个元组

实参：
会将一个任意类型的数据打散

# ** 
形参：
将关键字实参转换成字典的形式

实参：
将字典的形式转换成key=value的形式