Python学习笔记【week02day4】函数参数，万能函数，匿名函数，zip函数，装饰器

函数参数

1. 位置参数【又称必选参数】

传递参数的顺序与定义的顺序有关，必须按照定义的顺序来进行传递。
传递参数的个数与参数的个数必须保持一致。

def func1(name,age）

2. 关键字参数：

指函数调用的时候，可以通过"键-值"的形式来加以指定，可以清除位置关系。

注意：当出现位置参数与关键字参数的时候，需要将位置参数写在关键字参数前面

fun1("James", age=18)

3. 默认参数

定义函数的时候，我们可以给参数提供默认值，调用函数的时候：
1）可以传递此参数：当传递此参数的时候，函数则使用传递的参数。
2）可以不传：若不传递则使用默认值。
优点：方便函数的调用
注意：
1.若默认参数与位置参数同时存在的时候，位置参数要写在默认参数的前面
2.给定默认参数的时候，默认参数需要指向不可变对象。

def func2(name,age,address="江西"):

4. 不定长参数

定义函数的时候，我们不确定调用的时候到底会传递多少参数进来【可能传递1个也可能多个或者不传递】,此时我们可以使用不定长参数来解决
特点：能处理比声明时候更多的参数【传递多少参数，处理多少参数，不传递不处理】
不定长参数又包括包裹位置参数与包裹关键字参数

1. 包裹位置参数：
   使用：*变量名 一般用*args 接收方式为元组
   功能：可以收集除了必选参数以外剩余的位置参数，按照元组来进行处理

   def mysort2(*args,reverse=False):
   	args = list(args)
   	args.sort()
   	if reverse:
   		args.reverse()
   		return tuple(args)
   	else:
   		return tuple(args)
   
   
   print(mysort(11,2,3,34,1,3,12))
   

2. 包裹关键字参数：
   使用：**变量名 一般用**kwargs 接收方式为字典
   功能：收集除定义的变量的关键字参数之外，剩余关键字参数。
   包裹关键字参数只处理剩余的关键字参数，收集作为字典来进行处理。

   注意：**kwargs传递参数必须使用关键字传参（写在最后，收集剩余关键字参数）

    def ins2(name,age=18,*args,**kwargs):
    	print(name)
    	print(age)
    	print(args)
    	print(kwargs)
   

万能(参数)函数

	def func(*args,**kwargs):
	    pass
	
	*args接收所有位置参数，**kwargs接受所有关键字参数

匿名函数

定义：指的是一类无须定义标识符【函数名】的函数或者子程序。
在python中定义匿名函数使用lambda来进行定义。
语法：lambda 参数列表: 表达式
特点：

1. lambda后面的跟的只是一个表达式，结构体比def的简单
2. 参数列表可以有多个参数，参数与参数之间使用逗号隔开
3. 无须写return，表达式的结果就是该表达式的返回值。

优点：

1. 结构简单
2. 匿名函数没有名字无须担心函数名的冲突。

匿名函数的调用：
将lambda表达式赋值给一个变量，通过调用变量来调用我们的匿名函数。

func = lambda a,b: a if a>b else b

print(func)
print(type(func))
print(func(10,20))

zip函数

zip(iter1,iter2,…)
功能：打包,将可迭代对象中对应位置的元素进行打包，
长度取决于最短的那个，返回zipobj打包好的对象，以迭代器的方式返回(只有唯一一遍)

list1 = [1,2,3,4,5]
list2 = ["hello","good","nice","great","hi"]
list3 = ["hello2","good2","nice2","great2"]
zipobj = zip(list1,list2,list3)

print(next(zipobj))
print(list(zipobj))

结果：
(1, 'hello', 'hello2')
[(2, 3), ('good', 'nice'), ('good2', 'nice2')]

因为已经next(zipobj)一次，将第一个打印，所以list(zipobj)只打印剩下的全部

解包,将之前打包的元素进行解包处理，以迭代器方式返回。

list1 = [1,2,3]
list2 = ["hello","good","nice","great","hi"]
list3 = ["hello2","good2","nice2","great2"]
#压缩
zipobj = zip(list1,list2,list3)
#解压缩
obj = zip(*zipobj)
print(list(obj))
结果：
[(1, 2, 3), ('hello', 'good', 'nice'), ('hello2', 'good2', 'nice2')]

装饰器

在代码运行的期间动态的增加功能的方式我们称之为装饰器。

最简单的装饰器：

def outer(func):
	def inner():
    	#增强的功能
    	#在内函数中执行func函数
    	return func()
	return inner

#装饰器
@outer
def func():
	pass

在装饰器中，分为外函数与内函数：
外函数（outer）：
1.将被装饰的函数传递进来–》func
2.将装饰好的函数返回给调用者 --》inner
内函数：
1.添加动态增加的功能
2.执行被装饰的函数

内函数中return什么时候可以省略？
注意：当被装饰的函数没有返回值的时候，内函数的return可以省略，
若被装饰的函数中存在返回值，则内函数的return则不能省略。

@的功能：将被装饰的函数的函数名作为参数传递给外函数，将外函数返回的
替代版的函数赋值给原本的函数。

e.g.

def outer(func):
	def inner():
    	print("*********")
    	res = func()
    	print("*********")
    return res
return inner

@outer
def now():
	print("2019-6-13")
	return True

复杂点的装饰器

def outer(func):
	def inner(参数列表):
    	#添加增加的功能
    	return func(参数列表)
	return inner

注意：
1.使用内函数来接收被装饰函数的参数
2.调用被装饰的函数的时候，需要将参数传递进去。

	
def moneydec(func):
	def inner(mon):
    	if mon.startswith("+") and mon[1:].isdecimal() or mon.isdecimal():
        	return func(mon)
    	else:
        	print("金额有误")

	return inner

# 获取钱 1.必须是数字 2.必须大于0
@moneydec
def getMoney(mon):
	return int(mon)
	
print(getMoney("123"))
print(getMoney("+123"))
print(getMoney("-123"))