Python入门之函数-01

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

# 语法：
# 语法
# def 函数名(参数1,参数2,参数3,...):
#     '''注释'''
#     函数体
#     return 返回的值

# 函数名要能反映其意义
# 无参函数
# def func():
#     print('hello')
# func()


# 执行程序函数体不调用时，只检测函数内语法，不会执行


# 先定义

# 后调用

# 返回值

# 2、有参函数

# def func(x, y):  # x=10,y=20
#     print(x, y)
#
#
# func(10, 20)


# def login(in_user:str,in_pwd:str):
#     if in_user=='loky'and in_pwd =='123':
#         print('login successful!')
#     else:
#         print('密码错误')
#
# in_user =input('------>>:')
# in_pwd =input('-------->>:')
# login(in_user,in_pwd)


# 形式3、空函数 函数体为pass
# def func(x,y):
#     pass
#
# func(1,2)
#
# 三种函数形式应用场景


# 无参函数应用场景
# def register():
#     username = input('用户名：')
#     password = input('密码')
#
#     print(username, password)
#
#
# register()


# 有参函数应用场景
# 参数为原材料，返回值为产品
# def add(x, y):
#     res = x + y
#     # print(res)
#     return res
#
#
# res = add(10, 230)
# print(res)

# 空函数多数用于的构思，分配任务


# 二、调用函数

# 1、语句形式、、：只加括号


# 3、函数返回值
# return是函数结束的标志，即函数体代码一旦运行到return会立刻终止函数的运行：并且会将return后的值作为本次运行的结果返回

# 1、返回值None：函数体内没有return
# return
# return None
# 2、返回一个值
# return 值
# 3.返回多个值
# 返回多个值，逗号分隔开，会返回元组
# return a,b,c,10
# def func(x,y):
#     print('1111')
#     print('nnnnnnnn')
#     print('ddddddddddd')
#     res=x+y
#     return res
# res =func(1,2)
# print(res)


# def func():
#     return

# 四、实参，形参

'''
def func(x,y):
    print(x,y)


func(1,2)#此处传入的只要是值就行，无论以何种方式转换而来的！
'''

# 4.2位置参数
# 在函数定义，按照从左到右的顺序依次定义的参数称之为位置参数
# 位置形参
# 特点，必须被传值，多一个不行，少一个也不行

# def func(x,y):
#     print(x,y)
#
# func(y=1,x=10)
# 位置实参：在函数调用阶段，按照从左到右依次传入的值
# 特点：按照顺序与形参一一对应

# 关键字参数
# 在调用阶段，按照key=value的形式传入
# 特点：指名道姓给某个形参传值，可以完全不按照顺序

'''
def func(x,y):
    print(x,y)

func(y=1,x=10)
'''


# 混合使用
# 1、位置实参必须放在关键字实参前
# def func(a,b):
#     print(a,b)
# func(1,b=2)
# func(b=1,2)#语法错误

# 不能为形参重复传入多个值


# 默认参数：
# 默认形参：在定义阶段，就已经被赋值的形参，称之为默认参数
# 在定义阶段就已经被赋值

#
# def func1(a,b=10):
#     print(a,b)
#
# func1(1)
# func1(1,b=20)


# 位置形参与默认形参混用
# 注意：位置形参必须在默认形参的左边
# 错误写法
# def func(x=2,x):
#     pass

# 默认参数的值是在函数定义阶段被定义的
# 案例1
# m=2
# print(id(m))
# def func(x,y=m):
#     print(x,y)
# m=22222222
# print(id(m))
# func(1)#输出结果 1 2


# 案例2
# 默认的说，就是y被赋予的是m的内存地址，值的传递都是内存地址的传递
# m=[1111,]
# print(id(m))
# def func(x,y=m):
#     print(x,y)
# m.append(12002)
# print(id(m))
# func(1)#输出结果 1 [1111,12002]
# 虽然默认值可以被定义为任意数据类型，但是不推荐使用可变类型
# 要是为可变类型，输出的值无法确定
# 函数的定义所需要遵循的原则：定义的形参最好不要定义可变的数据类型


# def func(x,y,z,l=None):
#     if l is None:
#         l=[]
#         l.append(x)
#         l.append(y)
#         l.append(z)
#         print(l)
# func(1,2,3)


# 可变长度的参数(*与**用法)
# 可变长度指的是在调用函数时，传入的值(实参)，的个数不固定时
# 而实参是用来为形参赋值的，所以对应着，针对的实参必须有对应的形参来接收
# *后跟着是一个名字，规范性:*args
# 可变长度的位置参数：

# 1、*形参名：用来接收溢出位置的实参，溢出位置的实参会被*保存成元组的形式并赋值给紧跟*其后的那个形参
# def func(x,y,*z):
#     print(x,y,z)
# func(1,2,35,6,7,6)


# *形参名 用途：
# def num_sum(*args):
#     res=0
#     for i in args:
#         res+=i
#     return res
# res=num_sum(1,1,2,23,2)
# print(res)


# 可变长度的关键字参数

#:**形参名:  用来接受溢出的关键字实参，溢出位置的实参会被**保存成字典的形式并赋值给紧跟**其后的那个形参
# **后跟着是一个名字，规范性:**kwargs

# def func(x,y,**kwargs):
#     print(x,y,kwargs)
#
# func(x=1,y=2,c=3,d=1,s=2) #1 2 {'c': 3, 'd': 1, 's': 2}

# 用途


# 附加
# *也可以用在实参中，实参中带*，先*后的值打散位置实参：就是解压赋值

# def func(x,y,z):
#     print(x,y,z)

# func(*[1,12,3])
# func(*[11,22])#报错，少一个多一个都不行
# l=[11,22,33]
# func(*l)

# 形参与实参都带*的

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


# **也可以用在实参中(**后跟到只能说字典)，实参中带**，先**后的值打散成关键字实参：就是解压赋值

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

# func(**{'x':1,'y':2}) #func(x=1,y=2)#多一个不行，少一个也不行！


# 形参与实参都带**
# def func(x,y,**kwargs):
#     print(x,y,kwargs)
#
# func(**{'y':222,'x':111,'z':23131,'j':12313}) #111 222 {'z': 23131, 'j': 12313}

# 混用*与**
# *args 必须在**kwargs

# def func(*args, **kwargs):
#     print(args)
#     print(kwargs)
#
#
# func(1, 23, 231, 231, x=1, y=2, z=21)

# def func(*args):
#     print('------------>>',*args)
# def func1(*args):
#     func(args)
# func1(*(1,23,4,123123,2333,24444))

#使用**kwargs溢出的值必须为key——value的形式

# def func(x,**kwargs):
#     print(x,kwargs)
#
# func(1,a=12,c=3,b=21,)


# def index(x,y,z):
#     print(x,y,z)
#
# def wrapper(*args,**kwargs):
#     index(*args,**kwargs)
#
# wrapper(y=2,x=1,z=2)

  #补充：

#1、命名关键字参数
# 命名关键字参数：在定义函数时，*后定义的参数，如下所示，称之为命名关键字参数

#特点：
#1、命名关键字实参必须按照key=value的形式为其传值
#2、
# def func(x,y,*,a,b): #其中：a和b称之为命名关键字参数
#     print(x,y)
#     print(a,b)
#
#
# func(1,23,b=11,a=112)

#2、组合使用
#位置形参，默认形参,*args，命名关键字形参，**kwargs

def func(x,y,a=1,*args,z,**kwargs):
    print(x)
    print(y)
    print(a)
    print(args)
    print(z)
    print(kwargs)
func(1,2,a=1,z=2,l=10)