"""
一、形参与实参介绍
函数的参数分为形式参数和实际参数，简称形参和实参：
形参既在定义函数时，括号内声明的参数。形参本身就是一个变量名，用来接收外部传来的值
实参既在调用函数时，括号内传入的值，值可以是常量、变量、表达式或者三者的组合
"""
# 1：实参是常量
# res = my_min(1,2)
# print(res)
# 2: 实参是变量
# a = 1
# b = 2
# res = my_min(a,b)
# 3: 实参是表达式
# res = my_min(10*2,10*my_min(1,2))
# 4: 实参可以是常量、变量、表达式的任意组合
# a = 2
# res = my_min(1*4,my_min(2,a*3))
"""
在调用有参函数时，实参（值）会赋值给形参（变量名）。在Python中，变量名与值只是单纯的绑定关系，
而对于函数来说，这种绑定关系只在函数调用时生效，在调用结束后解除。
"""
# 二、形参与实参的具体使用
# 2.1位置参数
"""
位置即顺序，位置参数指的是按顺序定义的参数，需要从两个角度去看：
1.在定义函数时，按照从左到右的顺序依次定义形参,称为位置形参，凡是按照这种形式定义的形参都必须被传值
1.1在调用函数时，按照从左到右的顺序依次定义实参，称为位置实参，凡是按照这种形式定义的实参会按照从左
到右的顺序与形参一一对应
"""
# def register(name, age, sex): # 定义位置形参: name,age,sex, 三者都必须被传值
# print(‘name:%s,age:%s,sex:%s‘ % (name, age, sex))
#
#
# register(‘alex‘, ‘19‘, ‘male‘)
# 2.2关键字参数
"""
在调用函数时，实参可以是key=value的形式，称为关键字参数，凡是按照这种形式定义的实参
，可以完全不按照从左到右的顺序定义，但仍能为指定的形参赋值
"""
# register(name=‘egon‘, sex=‘female‘, age=19)
"""
需要注意在调用函数时，实参也可以是按位置或按关键字的混合使用，但必须保证关键字参数在
位置参数后面，且不可以对一个形参重复赋值
"""
# register(‘alex‘,age=19,sex=‘male‘)
# register(‘egon‘,19,sex=‘male‘)
# 2.3 默认参数
"""
在定义函数时，就已经为形参赋值，这类形参称之为默认参数，当函数有多个参数时，需要将值
经常改变的参数定义成位置参数，而将值改变较少的参数定义成默认参数。例如编写一个注册学
生信息的函数，如果大多数学生的性别都为男，那完全可以将形参sex定义成默认参数
需要注意：
1.默认参数必须在位置参数之后
2.默认参数的值仅在函数定义阶段被赋值一次
"""
# def register(name,age,sex = ‘male‘):
# print(‘Name:%s,Age:%s,Sex:%s‘%(name,age,sex))
# # 定义时就已经为参数sex赋值，意味着调用时可以不对sex赋值，这降低了函数调用的复杂度
# register(‘egon‘,19)
# x = ‘female‘
# def register(name,age,sex = x):
# print(‘res:%s,%s,%s‘ %(name,age,sex))
# register(‘egon‘,‘19‘)
# def foo(n,arg=[]): # []为可变，可以不断的调用foo函数给list里面添加值
# arg.append(n)
# print(arg)
# return arg
# foo(1)
# foo(2)
# foo(3)
# def foo(n, arg=None):# None 不可变，没一次调用foo()函数时arg默认参数都为None
# if arg is None:
# arg = []
# arg.append(n)
# print(arg)
# return
# 2.4可变长的参数(与*的用法)
"""
参数的长度可变指的是在调用函数时，实参的个数可以不固定，而在调用函数时，实参的定
义无非是按位置或者按关键字两种形式，这就要求形参提供两种解决方案来分别处理两种形
式的可变长度的参数
"""
# 2.4.1可变长的位置参数
"""
如果在最后一个形参名前加号*,那么在调用函数时，溢出的位置实参，都会被接收，以元组
的形式保存下来赋值给该形参
"""
# def foo(x,y,z=1,*args): # 在最后一个形参名args前面加*号
# print(x)
# print(y)
# print(z)
# print(args)
# foo(1,2,3,4,5,6,7)
# 1
# 2
# 3
# (4, 5, 6, 7)
"""
如果我们事先生成了一个列表,仍然是可以传值给*args的
"""
# def foo(x,y,*args):
#
# print(x)
# print(y)
# print(args)
# L = [6,7,8,9]
# foo(1,2,3,4,5,*L) # *L就相当于位置参数3，4，5, foo(1,2,*L)就等同于foo(1,2,3,4,5)
# 如果传入L时没有加*,那L就只是一个普通的位置参数
# 1
# 2
# (3, 4, 5, 6, 7, 8, 9)
"""
如果形参为常规的参数（位置或默认），实参仍可以是*的形式
"""
# def foo(x, y, z=3):
# print(x)
# print(y)
# print(z)
#
#
# foo(*[1, 2])
"""
=================================================*args
如果我们想要求多个值的和，*args就派上用场了,如果实参溢出，实参会以(元组)的形式
存到*args里
"""
# add求和函数
# def add(*args):
# res = 0
# for i in args:
# res+=i
# else:
# print(res)
# return res
# add(1,2,3,4,5)
# def add(*args):
# res = 0
# for i in args:
# res += i
#
# print(res)
# return res
# def add(*args):
# sum = 0
# for i in args:
# sum += i
# print(sum)
# return sum
# add(1,2,3,4,5)
# 2.4.2 可变长度的关键字参数
"""
======================================================**kwargs
如果在最后一个形参名前加号**,那么在调用函数时，溢出的关键字参数，都会被接收
，以字典的形式保存下来赋值给该形参
"""
# def foo(**kwargs):
# for key in kwargs:
# print(key)
# print(kwargs)
#
# foo(x=1,y=2,z=3)
# def foo(x,**kwargs):
# print(x)
# print(kwargs) # 溢出的关键字实参y=2,z=3,e=4都会被**接收以字典的形式保
# 存下来赋值给kwargs
# foo(x=1,y=2,z=3,e=4)
# def foo(x, y, **kwargs):
# print(x)
# print(y)
# print(kwargs)
#
#
# dic = {‘a‘: 1, ‘b‘: 2}
# foo(1,2,**dic) #**dic就相当于关键字参数a=1,b=2,foo(1,2,**dic)等同于foo(1,2,a=1,b=2)
"""
如果形参为常规参数（位置或默认），实参仍可以是**的形式
"""
# def foo(x,y,z=3):
# print(x)
# print(y)
# print(z)
# foo(**{‘y‘:2,‘x‘:1})
# def foo(x,y,z):
# print(x)
# print(y)
# print(z)
# foo(**{‘x‘:1,‘y‘:2,‘z‘:3})
"""
如果我们要编写一个用户认证的函数，起初可能只基于用户名密码的验证就可以了，可以使用**kwargs
为日后的扩展供良好的环境，同时保持了函数的简洁性。
"""
# 用户登录函数=========================
# def auth(user_name, user_password, **kwargs):
# with open(r‘C:\python_test\demo1\pythonweek3\day12\user_password.txt‘, mode=‘rt‘, encoding=‘utf-8‘) as f:
# data = f.read().split(‘\n‘)
# go = 3
# while go:
# for line in range(len(data)-1):
# user,password = data[line].split(‘:‘)
# go -= 1
# if user_name == user and user_password == password:
# print(‘登录成功‘.center(50,‘*‘))
# go = 0
# break
#
# else:
# break
# print(‘登录失败,还有{}次机会‘.format(go))
# auth(‘egon‘,‘123‘)
# def auth(user, password, **kwargs):
# # """
# # 这是一个用户登录函数调用方法为auth()
# # :param user: 用户账户（用户数据储存于C:\python_test\demo1\pythonweek3\day12\user_password.txt）
# # :param password: 用户密码
# # :param kwargs: 程序拓展（）
# # :return:
# # """
# with open(r‘C:\python_test\demo1\pythonweek3\day12\user_password.txt‘, mode=‘rt‘, encoding=‘utf-8‘) as f:
# data = f.read().split(‘\n‘)
# go = True
# while go:
# for line in range(len(data) - 1):
# user_txt, password_txt = data[line].split(‘:‘)
# if user_txt == user and password_txt == password:
# print(‘登录成功‘)
# go = False
# break
# else:
# print(‘登录失败‘)
# break
#
# auth(‘egon‘,‘123‘)
# auth(‘alex‘,‘123‘)
# def auth(user,password,**kwargs):
# pass
# 2.5命名关键字参数
"""
在定义了**kwargs参数后，函数调用者就可以传入任意的关键字参数key=value，
如果函数体代码的执行需要依赖某个key，必须在函数内进行判断
"""
# def register(name, age, **kwargs):
# if ‘sex‘ in kwargs:
# # 代表**kwargs字典里有key = sex，代表有sex参数
# pass
# if ‘height‘ in kwargs:
# # 代表**kwargs字典里有key = height，代表有height参数
# pass
"""
命名关键字参数===========================================================
想要限定函数的调用者必须以key=value的形式传值，Python3提供了专门的语法：
需要在定义形参时，用*作为一个分隔符号，*号之后的形参称为命名关键字参数。
对于这类参数，在函数调用时，必须按照key=value的形式为其传值，且必须被传值
"""
# def register(name, age, *, sex, height): # 默认参数必须在位置参数之后
# pass
# 命名关键字参数也可以有默认值，从而简化调用
# register(‘alex‘, 19, sex=‘male‘, height=‘1.75m‘)
# register(‘alex‘, 19, sex=‘male‘, height=‘1.75m‘)
# def register(name, age, *, sex=‘male‘, height):
# print(‘name:%s,age:%s,sex:%s,height:%s‘ % (name, age, sex, height))
#
#
# register(‘egon‘, ‘19‘, height=‘1.75m‘)
"""
需要强调的是：sex不是默认参数，height也不是位置参数，因为二者均在后，所以都是
命名关键字参数，形参sex=’male’属于命名关键字参数的默认值，因而即便是放到形参
height之前也不会有问题。另外，如果形参中已经有一个args了，命名关键字参数就不再
需要一个单独的*作为分隔符号了
"""
# def register(name, age, *args, sex=‘male‘, height):
# print(‘name:%s,age:%s,args:%s,sex:%s,height:%s‘ % (name, age, args, sex, height))
#
#
# register(‘egon‘, 19, 1, 2, 3, height=‘1.75m‘, sex=‘female‘)
# =================================================================================
# 可变长位置参数*args ，可边长关键字参数 **kwargs ,*,后面的为命名关键字参数，
# 如果形参中已经有了一个args可变长参数就不用在,*,了，*args可变长参数后面的形参已经
# 变成了命名关键字参数
# 2.6组合使用
"""
终上所述所以参数可以任意组合使用，但定义顺序必须是：
位置参数、默认参数、*args（可变长位置参数）、命名关键字参数、**kwargs（可变长关键字参数）
"""
"""
可变长参数*arg与关键字参数**kwargs通常是组合在一起使用的，如果一个函数的形参为*args与
**kwargs，那么代表该函数可以接受任意形式，任意长度的参数
*args以元组的形式储存非关键字参数，**kwargs以字典的形式储存关键字参数
"""
"""
按照上述写法，在为函数wrapper传参时，其实遵循的是函数func的参数规则，调用函数wrapper的过程分析如下：
位置实参1被接收，以元组的形式保存下来，赋值给args，即args=(1,),关键字实参z=3，y=2被*接收，以字典的形式保存下来，赋值给kwargs，即kwargs={‘y‘: 2, ‘z‘: 3}
执行func(args,kwargs),即func((1,),* {‘y‘: 2, ‘z‘: 3}),等同于func(1,z=3,y=2)
"""
# def func(x, y, z):
# print(x, y, z)
#
#
# def wrapper(*args, **kwargs):
# func(*args, **kwargs)
#
# wrapper(1,y = 3,z = 5)
# def interactive():
# name = input(‘name‘)
# age = input(‘age‘)
# gender = input(‘gender‘)
# res = ‘name:{},age:{},gender:{}‘.format(name,age,gender)
# print(res)
#
# interactive()
# 定义函数的三种方式
# 无参函数，有参函数，空函数
# 三、函数返回值
# return是函数结束的标志，即函数体代码一旦运行到return会like
# 终止函数的运行，并且会将return后的值当做本次运行的结果返回
# 1、返回None：函数体没有ruturn 或者 return 后面没有变量值
# def func():
# print(1111111111111111111111111111)
# while True:
# while True:
# while True:
# return
# print(2)
# print(3)
# func()
# 3、返回多个值：用逗号隔开多个值；会被return返回成元组
# def func():
# return 10,‘aaa‘,[1,2]
# res = func()
# print(res)
# s = ‘123456‘
# print(s[3:5])
# def func (x,y = 3):
# print(x,y)
# func(3,4)
# 常用 的定义为默认形参
# 默认参数的值是在函数定义时被赋值的，被赋予的是内存地址
# 默认参数的值不建议定义为可变
# def register(name, age, gender=‘男‘):
# print(name, age, gender)
#
#
# register(‘三炮‘, 19, ‘男‘)
#
# def func(x, y, z, l=None):
# if l == None:
# l = []
# l.append(x)
# l.append(y)
# l.append(z)
# print(l)
#
# def func(x,y,l=[]):
# # l.append(x)
# # l.append(y)
# print(x,y,l)
# l = []
# def func(x,y):
# l.append(x)
# l.append(y)
# print(l)
# func(1,2)
# func(2,3)
# def add(*args):
# sum = 0
# for i in args:
# sum += i
# return sum
# add(1,2,3,4,5)
# print(add(1,2,3,4,5))
# def foo(x,y,*args):
# print(x,y)
# print(args)
# for i in args:
# print(i,type(i))
#
# foo(1,2,3,*(‘4‘,5,6))
# dic = {‘k1‘:1,‘k2‘:2,‘k3‘:3}
# for key,value in dic.items():
# print(key,value)
"""
考试：====================================================================
1、
内置函数、自定义函数
内置函数直接使用，自定义函数先定义后使用
2、
形参：函数定义节点用来接收实参值的一个变量名，实参：函数调用阶段用来给形参传值
3、
位置形参与默认形参的区别：位置形参用于接收位置参数，位置形参必须全部传参满足
默认形参在函数定义阶段就设有默认的值，可以在调用阶段不进行传值
4、位置实参与关键字实参的区别：
位置实参按照位置对位置形参传值，关键字实参通过关键字形参进行传值，位置参数必须
在关键字参数之前，关键字参数不能二次传值
5、*与**在形参与实参中的区别“
形参：
*args用来接收函数调用阶段溢出的位置实参并存成一个元组，**kwargs在函数调用阶段用来接收溢出的
关键字实参并存成一个字段
实参：* 代表分解，把实参分解成多个然后对位置形参进行传值，** 则分解成关键字实参
6、解释下述形式，既函数wrapper的参数特点是什么
def index(x,y):
print(x,y)
def wrapper(*args,**kwargs):
index(*args,**kwargs)
wrapper(1,y=2)
特点：1传值给args,y=2传值给kwargs,wrapper()里的实参必须满足位置实参在关键字实参之前，
由于wrapper函数体为调用index函数，所以args，kwargs都必须被传至少一个值
"""
"""
1.命名关键字参数（了解）
在定义函数时，*后定义的参数，如下，称之为命名关键字参数
"""
# 1、命名关键字实参必须按照key = value的形式为其传值
# 2、 形参定义的顺序：
#位置，默认，可变长位置，命名关键字，可变长关键字
# 3、 实参混用顺序
# def func(x,y,*args,a,b): # 其中a和b称之为命名关键字参数
# print(x,y)
# print(a,b)
# 实参的两种格式：位置实参参，关键字实参
# *之后的a，b为命名关键字实参
# x = 35+9+8+5+12+14
# print(x)
原文：https://www.cnblogs.com/Edendd/p/14594682.html