前言
 
    定义一个名为temp的函数，参数列表共4个参数
 
def temp(first,second="Hello World",*args,**kwargs)
    print(first)
    print(second)
    print(args)
    print(kwargs)

 
1、参数first称为位置参数
 
2、参数second称为默认参数
 
3、参数*args称为可变参数
 
4、参数**kwargs也称为可变参数
 
接下来我们展开讨论这些术语
 
 
 
位置参数
 
1、位置参数的中文名非常多……以下都是我见过的名称，它们指的都是位置参数，共计8个别称……
 
a、必选参数
 
b、必备参数
 
c、固定参数
 
d、定位参数
 
e、选中参数
 
f、普通参数
 
g、一般参数
 
h、常规参数
 
2、英文名：positional parameter
 
3、特点：函数的参数列表中定义x个位置参数，函数调用时就必须传入x个参数，参数数量必须保持一致
 
4、举例说明↓
 
定义一个temp函数，它包含3个位置参数，调用temp函数时，必须传入3个参数
 
def temp(first,second,third):
    print(first)
    print(second)
    print(third)
 
调用temp函数的代码
 
temp("hi","ni","hao")

#等同于

temp(first="hi",second="ni",third="hao")

#等同于

my_str = ("hi","ni","hao")
temp(*my_str)
 
5、位置参数的使用率：Python代码中最常使用的参数就是位置参数了
 
接下来学习一下默认参数
 
 
 
默认参数
 
1、中文别称，同样指的都是默认参数
 
a、可选参数
 
b、默认值参数
 
2、英文名：Default Argument Values或者optional arguments
 
3、个人理解：将默认参数称为具有默认值的位置参数更为准确，原因请往下继续学习
 
4、特点：调用函数时可省略参数
 
5、举例说明：定义一个temp函数，此函数定义了2个默认参数
 
def temp(first="hi",second="man"):
    print(first)
    print(second)
 
调用包含默认参数的temp函数 
 
temp() #省略传入所有参数，函数内会使用默认参数的默认值

temp("我是你哥") #为第一个默认参数传入值，另一个默认参数继续使用默认值

temp("hello","world") #为两个默认参数都传入值

temp(first="喜欢你") #指定一个默认参数使用传入值
 
调用含有默认参数的函数时，传入的参数，会按照从左到右的顺序被默认参数匹配，这就是我认为默认参数的名字称为具有默认值的位置参数的原因！！！
 
6、重要警告：默认值只能会执行一次（来自官方）
 
默认值只执行一次。这条规则在默认值为可变对象（列表、字典以及大多数类的实例）时非常重要。
 
比如，下面的函数会存储在后续调用中传递给它的参数:
 
def f(a, L=[]):
    L.append(a)
    return L


print(f(1))
print(f(2))
print(f(3))
这将打印出

[1]
[1, 2]
[1, 2, 3]

如果你不想要在后续调用之间共享默认值，你可以这样写这个函数:
def f(a, L=None):
    if L is not None:
        L = []
    L.append(a)
    return L
 
官方建议默认参数尽量使用不可变对象！！
 
 
 
可变参数
 
1、中文别称，以下都表示可变参数
 
a、任意参数
 
b、未知参数
 
def temp(*args,**kwargs):
    print(args)
    print(kwargs)
 
2、可变参数经常使用的变量名
 
*参数：最常见的变量名是args，看到该变量名，一眼就知道变量args指向一个tuple对象
 
**参数：最常见的变量名是kwargs，看到该变量名，一眼就知道变量kwargs指向一个dict对象
 
3、*args在函数定义中出现时的特点
 
自动收集所有未匹配的位置参数到一个tuple对象中，变量名args指向了此tuple对象
 
4、**kwargs在函数定义出现时的特点
 
自动收集所有未匹配的关键字参数到一个dict对象中，变量名kwargs指向了此dict对象
 
---->可变参数的详细解读请看这篇--->点我
 
 
 
关键字参数
 
1、函数调用时，指定参数名称，称为关键字参数（别和默认参数混淆，这里是函数调用）
 
def temp(a,b,c):
    print(a)
    print(b)
    print(c)


temp(1,3,c=99)

temp(a=1,b=2,c=3)

temp(1,b=2,c=100)
 
2、顺序要求：函数调用时，关键字参数必须在普通参数的后面
 
temp(100,b=200,c=300)


temp(a=100,32,100) #错误语法，关键字参数不能在普通参数的前面
 
3、使用字典解包方式传入关键字参数
 
hi = {"a":100,"b":99,"c":1000}
temp(**hi)

#等同于#

temp(a=100,b=99,c=1000)

 
4、函数调用时，当剩余的参数全部为关键字参数时，可随意定义顺序
 
当全部为关键字参数时，调用函数时的参数顺序可随意书写，因为你指定了参数名，但是参数的数量不能少于函数定义时要求的位置参数的数量
 
temp(c=100,b=38,a=10)
 
 
 
命名关键字参数
 
1、英文名：Keyword-only parameter
 
2、特点：必须使用关键字方式传递参数
 
3、语法
 
def only_kw(a,*,b,c)
    print(a)
    print(b)
    print(c)


only_kw(100,b=1000,c=99) #b和c必须使用参数名传递参数
 
 
 
命名位置参数
 
def only_position(a,b,/)
    print(a)
    print(b)
 
函数调用时，必须使用位置参数方式传递参数……，不能再使用关键字参数调用该函数
 
 
 
思考：函数调用时的实际参数有哪些？
 
    函数调用时，只会包括两种实际参数（元组解包对应于普通参数、字典解包对应于关键字参数）
 
1、普通参数
 
2、关键字参数
 
 
 
总结
 
1、希望这篇文章能为所有Python爱好者带来帮助
 
2、同时我也会不断的巩固自己的知识，一起奋斗吧

一、位置参数：按照从左到右的顺序依次定义的参数称之为位置参数
 
 
位置形参：在函数定义阶段，按照从左到右的顺序直接定义的‘变量名’
 特点：必须被传值，多一个不行少一个也不行
 
 
位置实参：在函数调用阶段， 按照从左到右的顺序依次传入的值
 
 二、关键字参数
 
 
默认参数（默认形参）：在定义函数阶段，就已经被赋值的形参，称之为默认参数
 特点：在定义阶段就已经被赋值，意味着在调用阶段可以不用为其赋值
 
 
 
关键字实参：在函数调用阶段，按照key=value的形式传入的值
 特点：指名道姓给某个形参传值，可以完全不参照顺序
 
 
 
三、位置形参与默认参数（默认形参）混用
 
 
位置形参必须在默认形参的左边
 
 
 
默认参数的值是在函数定义阶段被赋值的，准确地说被赋予的是值的内存地址
 
 
示例1：
 
a = 7


def func(x, b=a):b=>7的内存地址
    print(x, b)


a = 8
func(1)
 
结果：
 
1 7
 
示例2：
 
a = [1, 3]


def func(x, y=a):   # y=>[1,]的内存地址
    print(x, y)


a.append(9)
func(2)
 
结果：
 
2 [1, 3, 9]
 
默认值可以被指定为任意数据类型，但是最好不要使用可变类型，函数最理想的状态：函数的调用只跟函数本身有关系，不受外界代码的影响
 
a = [1, 2, 3]


def func(x, y=a):
    print(x, y)


a.append(4)
a.append(5)
a.append(6)

func(11)
func(22)
func(33)
 
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)
func(11, 22, 33)
list_1 = [111, 222]
func(1, 2, 3, list_1)
 
结果：
 
[1, 2, 3]
[11, 22, 33]
[111, 222, 1, 2, 3]

Python函数的参数传递-位置参数、关键字参数、默认参数、不定长参数
 
1. 函数的参数
 
 
 
参数列表：如果函数所实现的需求中涉及到未知项参与运算（这些未知项需要函数的调用者来决定），就可以将未知项设置为参数。
 
 
格式：参数1，参数2，参数3，…
 
 
形式参数：在方法中（函数内）定义的，用于接收中间参数的值
 
 
实际参数：在函数外面定义，实际参与运算的值，就是为了给形式参数赋值
 
 
#函数的定义
#name是形参
def myPrint(name):
	print("%s is a good man !"%name)

#"lili" 是实参
myPrint("lili")
#结果
lili is a good man !
 
#形参 参数一：name  参数二：age
def myPrint(name, age):
	print("%s is %d year old"%(name, age))
#函数调用，传递两个参数	
myPrint("lili", 18)
#结果
lili is 18 year old
 
1.2 函数的返回值
 
 
 
函数的返回值表示一个函数执行完成之后得到的结果
 
 
使用return返回函数的返回值，用于结束函数，得到最终运算的结果。
 
 
两个作用：1、返回计算到的函数值；2、用于结束函数（return之后下一行的语句不执行）
 
 
1.3 参数传递
 
 
 
参数传递的本质：实参给形参赋值的过程
 
 
1.3.1 位置参数
 
 
 
位置参数又称必选参数
 
 
传递参数的顺序与定义的顺序有关，必须按照定义的顺序来进行传递，传递参数的个数与参数的个数必须保持一致。
 
 
def ins(name,age,address):
    print("大家好我是%s,我今年%d岁,我家乡在%s"%(name,age,address))
ins("小明",29,"深圳")
#结果
大家好我是小明,我今年29岁,我家乡在深圳
 
 
 
位置参数之值传递：指传递不可变类型，一般指string、tuple和number类型
 
 
def func1(a):
	print(a)
	a = 10
	print(a)
temp = 20
#将temp作为实参传递给func1函数，将赋值给形参a
#相当于 a = temp
func1(temp)
#结果 
#20
#10
 
打印地址，如下
 
def func1(a):
	print(id(a))
	a = 10
	print(id(a))
	
temp = 20
#将temp作为实参传递给func1函数，将赋值给形参a
#相当于 a = temp
print(id(temp))
func1(temp)
print(temp)
#结果两个id地址相同
#140735888668080
#140735888668080
#140735888667760
#20
 
 
 
位置参数之引用传递：一般传递的是可变类型，一般指list，dict和set
 
 
def func1(c):
	c[0] = 100
	
d =[1, 2, 3, 4]
#将引用传递过去
func1(d)
print(d[0])
#结果
100
 
说明：引用传递的本质上还是值传递，只不过传递的是地址
 
1.3.2 关键字参数
 
 
 
概念：用于函数调用时，通过“键-值”的形式加以指定，可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求（位置关系）
 
 
def func(name, age):
	print("I am %s, and I am %d year old"%(name, age))
#一般调用（位置参数）
func("lili", 18)
#使用关键字参数
func(age = 18, name = "lili")
 
注意：当同时出现位置参数与关键字参数时，位置参数必须在关键字参数的前面（即只能是前若干个连续的参数为位置参数，后面再接关键字参数），但是关键字参数之间是不存在先后顺序的。
 
1.3.4 默认参数
 
 
 
概念：用于定义函数，为参数提供默认值，调用函数时可传递也可不传递该默认参数的值。调用函数时，如果没有传递参数则会使用默认参数，传递则覆盖默认函数。
 
 
比如：在使用sort()排序的时候，不更改其参数的时候我们一般情况下默认会升序排列
 
 
def func(name, age=18)
	print("I am %s, and I am %d year old"%(name, age))

#一般的函数调用
func('lilei', 19)
#关键字参数调用
func(name = 'leilei')
#使用默认参数调用
func('lili')
 
使用默认参数可以简化函数的调用。
 
使用默认参数的时候需注意：
 
1.若默认参数与位置参数同时存在的时候，必选参数在前，默认参数在后，否则python解释器会报错
 
2.默认参数必须指向不可变对象（会影响下一次调用的结果）
 
如何设置默认参数
 
 
 
当函数有多个参数时，把变化大的参数放在前面，变化小的放在后面，变化小的可以作为默认参数。
 
 
练习：
 
我们写一个小学生入学注册信息，要求输入姓名，性别，年龄，城市等信息，设计一个函数。
 
def student(name, sex, age = 6, city = '广州'):
	print("name :", name)
	print("sex :",sex)
	print("age :",age)
	print("city :",city)
#函数调用
student('lili', 'boy')
student('lili', 'boy', 7)
student('lili', 'boy', city='Beijing')
 
注意：有多个默认参数的时候，可以按顺序提供默认参数，当不按顺序提供参数的时候需要使用关键字参数进行调用。
 
1.3.5 不定长参数【可变参数】
 
 
 
概念：定义函数时，有时候我们不确定调用的时候会传递多少个参数（可能传递1个也可能多个或者不传递），此时我们可以使用包裹位置参数或者包裹关键字参数来进行参数传递。
 
 
特点：能处理比当初声明时更多的参数（传递多少参数，就处理多少参数，不传递则不处理）
 
 
*1.包裹位置传递–args
 
 
 
用法:**变量名 (一般用*args)
 
 
功能：可以收集除了必选参数以外剩余的位置参数,会根据传进参数的位置合并成一个元组（tupe），args是元组类型，这就是包裹位置传递。
 
 
#与之前形参不同的是在hoby的变量名之前添加了“*”
#添加了星号(*)的变量名会存放所有未命名的变量参数
#如果在函数调用时没有指定参数，它就是一个空的元组
#一般情况下使用*args
>>def func(name, *hoby):
>>	print("I am ",name,"I like",hoby)
	
>>func('lili','flower','money')
I am  lili I like ('flower', 'money')
 
**2.包裹关键字参数–****kwargs
 
 
 
用法：**变量名 一般用****kwargs
 
 
功能：收集除定义的变量的关键字参数之外，其它剩余关键字参数。kwargs是一个字典（dict），收集所有的关键字参数。
 
 
def ins2(name,age=18,*args,**kwargs):
    print(name)
    print(age)
    print(args)
    print(kwargs)

ins2("lili",18,"打豆豆","吃手手",hobby1="吃饭",hobby2="睡觉")
#结果
lili
18
('打豆豆', '吃手手')
{'hobby1': '吃饭', 'hobby2': '睡觉'}
 
注意：在python中定义函数，可以用必选参数、默认参数、可变参数和关键字参数，这4中参数可以一起使用，或者是只用其中的某些，但是注意，参数定义与调用的顺序必须是：
 
必选参数【位置参数】、默认参数、可变参数【包裹位置】和关键字参数【包裹关键字】。(默认参数与包裹位置参数可以根据需求进行位置调换)

调用函数时可以使用的参数类型有以下五种:
 （1）必须参数。
 （2）关键字参数。
 （3）默认参数。
 （4）可变参数。
 （5）组合参数。
 一、必须参数
 即函数调用时必须要传的参数。
 特点:
 ☞ 以正确顺序传入函数。
 ☞ 调用时的数量必须与声明时的数量一致。
 例如:
 
 
 二、关键字参数
 一些函数，同时它们具有许多参数，而此刻你只想对其中一部分进行指定，那你可以对它们进行命名，从而给你想指定的参数赋值，这就是关键字参数。
 简单的说就是:
 使用命名（关键字）来指定函数中的参数。
 特点:
 ☞不需要考虑参数顺序，Python解释器能够用参数名匹配参数值。
 ☞我们可以只对那些我们希望赋予的参数赋值，只要其它的参数都具有默认参数值。
 例如: