2、pathon 函数相关知识

函数的参数：可以接受各种形式的参数  

1、调用函数时

有几个位置参数就要传几个参数。且一 一对应。

2、默认参数

指【定义函数】时，参数带有默认值。在调用函数时，可以不传参数。不传时，使用默认值

①官方建议默认参数尽量使用不可变对象，因为可变对象会存储在后续调用时传递给他的参数。

②默认值最好只执行一次。在默认值为可变对象（列表、字典等）时非常重要。见①

def abc(a=100,b=200):  #---默认参数后面必须是默认参数，普通参数写最前面
    print(a+b)
abc()                  #省略了调用的参数，函数会自动使用默认参数
abc(600)               #只有一个默认参数时，会按照顺序传给第一个参数。另一个还是使用默认参数
abc(b=1000)            #指定给b 一个默认参数

#--------------------------------------
def abcd(a,b=[]):   #b是可变对象
    b.append(a)
    print(b)
#---调用---
abcd(100)           #输出：[100]
abcd(300)           #输出：[100,300]  b中存储了以往的旧数据

#-===============更改=====
def abcdg(a,b=None):  #b是可变对象 
    if(b is None):
        b=[]          #b使用默认时，置为空的列表
    b.append(a)
    print(b)
#--调用---
abcdg(100)  #[100]
abcdg(300)  #[300]  目标达成

3、关键字参数：--调用函数

   【调用函数】时，指定参数名funxc(a="cc")

#调用时，关键字参数必须在普通参数后面
abc(x,a=100,b=200）  #x是普通参数。a=100是关键字参数

4、限定关键字形参（命名关键字参数）

   参数中间用* 限定 *后面的参数必须用关键字形参

   因为：后面几个形参具有一定的意义，显式写出有利于可读性；形参随着版本可能变化，强制关键字有助于提醒，有利于保证跨版本的兼容性

def abc(s,*,c,d):  # *后面的c 和d 必须使用关键字形参
	print(s)
abc(100,c=2,d=3)   # c 和d 必须使用关键字形参

5、可变参数---参数可传可不传

 1）*参数：最常见变量名 *args。自动收集所有未匹配的 位置参数 到一个Tuple对象中。args指向tuple对象。

 2）**参数：最常见变量名 **kwargs  。dict(字典对象) 以键值对形式

#-----------*参数-------空元组-----
# def abc(a,*b):
# 	print(a)       #调用abc(100)，输出100
# 	print(b)       #调用abc(100)，输出（）。是一个空元组--没给b传值时候
# abc(100)         #没有给b传值
# abc(1,2)         #b打印出(2,) 
# abc(1,2,3,4,5)   #b打印出(2, 3, 4, 5)

#----------**参数-------空字典-----
def abcd(a,**kwargs):
	print(a)
	print(kwargs)
abcd(100,x=2,b=4)  #输出：{'x': 2, 'b': 4}

6、参数的解包

 1）参数数据类型是：字符串|列表|元组|集合|字典的时候可以解包

    传递实参时，可以在序列类型的参数前面加*号。这样会将序列中的元素依次作为参数传递

 2）参数解包可可变参数一起使用  **x只收集未匹配的关键字参数

#---预先定义的值---
s='123'
l=[1,2,3]
t=(1,2,3)
s1={1,2,3}
d={
	"a":"x",
	"b":"vvv",
	"c":"sss"
}
#-------参数解包------------
def abc(a,b,c):
	print(a,b,c)

# abc(*s)
# abc(*l)     #前面加*号
# abc(*d)     #得到键名
# abc(**d)    #得到键值---字典中的键名和函数中的参数名需要一致，否则会报错

#-----参数解包+可变参数 一个*args
def abcd(a,*args):
	print(a,args)

# abcd(1,(2,3,4))        #1 ((2, 3, 4),)
# abcd(1,*(2,3,4))       #1 (2, 3, 4) 元组中的每个元素，作为args中的每个元素
# abcd(1,*[100,200,300])

#-----参数解包+可变参数 2个**kwargs
d={
	"姓名":"xx",
	"性别":"boy",
	"年龄":"19"
}
def abcs(a,**kwargs):    #只收集未匹配的 关键字参数
	print(a,kwargs)

# abcs(100,b=100,c=200)  #输出：100 {'b': 100, 'c': 200}
abcs(100,**d)            #输出：100 {'姓名': 'xx', '性别': 'boy', '年龄': '19'}
# abcs(100,*d)           #报错：abcs() takes 1 positional argument but 4 were given

7、各种参数排列位置的注意事项

1、顺序为：普通参数，默认值参数，可变参数

2、*args 在**kwargs之前

   def abc(普通参数，默认值参数，name='c',*参数，**参数)

def abc(a,name="xx",*args,**kwargs):
		print(a,name,args,kwargs)
		for i in args:                    #遍历元组
			print (i)

		for key,value in kwargs.items():  #遍历字典
			print(key,value)

abc(100,"张三",1,2,3,4,x=100,y=200,c="sss")

#输出：100 张三 (1, 2, 3, 4) {'x': 100, 'y': 200, 'c': 'sss'}

 8、函数的返回值

return 返回处理好的结果.不返回时。默认返回None

def xyz():
	print("hello")
r = xyz()            #函数调用的返回值，可以用变量接收
# print(r)           #None

#-----return 返回多个数据
def abc(a,b,c):
	return a+100,b+200,c+300
r=abc(1,2,3)
print(type(r))       #<class 'tuple'> 一个元组
print(r)             # (101, 202, 303)

#--解包--
x,y,z=r
print(x,y,z)         #  输出：101 202 303

9、返回函数的函数

    1函数里面嵌套函数

    2函数返回函数

def abc():
	def xyz():
		return [1,2,3]
	return xyz               #函数返回函数

#---------调用返回函数 的函数---
r=abc()                      #r接收的是一个函数   是xyz这个函数
print(r)                     # <function abc.<locals>.xyz at 0x00000282D4707EC0>

r()                          # 输出[1, 2, 3]