day03-函数

 形参：位置参数：必须传
     *args:动态参数，可以接收任意多个位置参数
     默认值参数：可以传也可以不传
     **kwargs:动态参数，可以接收多个关键字参数。
 实参：按照位置传参，按照关键字传参。

 #顺序：位置参数，*args,默认值参数，**kwargs。
 def test(a,*args,t=10,**kwargs):   #t=10是默认值参数，要放在**kwargs前面。
     print(args,kwargs,t)
 test(1,23,3,12,45,3,1,5,1,3,5,1,3,t=200,a='asdf',b='awea') #t=200是关键字传参。

 def test1(*args):           #args是元组。
     print(args)
 a = (1,2,3,87,45,3,43,645)
 test1(*a)                   #将元祖a打散成多个元素传参。

 def test3(*args):
    print(*args)        #args是元组，*args是打散元组，所以执行结果是1 2 3
    print(args)        #结果是（1,2,3）
 test3(1,2,3)

 def test2(**kwargs):    #形参**kwargs将传入的参数放在字典里面。kwargs是字典。
     print(kwargs)
 b = {'c':1,'t':23}
 # test2(**b)              #实参**b将字典打散为键值对传给形参。跟下行代码test2(c=5,t=10)的效果一样。
 test2(c=1,t=23)

 def a():
     return 2
 print(a())  #函数名()=返回值。 a()=2

 def b(*args):
     return args
 print(b(1,2,3))

 默认值参数的陷阱
 def test(a=[]):
     a.append(1)
     print(a)
 test()         #因为a是默认值参数，所以调用函数的时候可以不传参，执行结果是[1]
 test()         #[1,1]
 test()         #[1,1,1]

 返回值
 没有返回值：返回None
         1.不写return
         2.只写return :结束函数，return下面的代码不执行。
         3.写return None 不常用
 返回一个值：
         可以返回任何数据类型：数字，字符串，元组，列表，字典等等。
         如果有多个return，只执行第一个。
 返回多个值：
         多个返回值要用多个变量接收。
 def test():
     return 1,2,3
 a1,a2,a3=test()  #多个返回值要用多个变量接收。
 print(a1,a2,a3) #打印出1 2 3
 print(test())   #打印出元组（1,2,3）

 def a(b):
     return b[1::2] #返回奇数索引对应的值
 print(a([1,3,3,6,1,4]))

 def a(b):
     return len(b)<5  #返回传入的字符串的长度是否小于5
 print(a('adsfadsf'))

 def test(n):
     if len(n)>2:   #检查传入的列表的长度是否大于2，如果是，返回前面两个元素。
         return n[:2]
 print(test([1,2,3,4]))

 def test(list):
     '''函数注释：统计传入的参数有多少个字母（字母包含汉字），数字，空白符，其他字符'''
     alpha = 0
     digit = 0
     space = 0
     other = 0
     for i in list:
         if i.isalpha():   #如果i是字母为True
             alpha += 1
         elif i.isdigit(): #数字
             digit += 1
         elif i.isspace(): #空白符
             space += 1
         else:             #其他
             other += 1
     return alpha,digit,space,other
 print(test('asdfasdfas  asdgasdg asdfasdawe645a4s4df 646 465a4 64 646 46 46 465****、、、 '))

 def test(n):
     dic={'alpha':0,'digit':0,'space':0,'other':0} #利用字典简化代码，并且返回字典，让别人易读。只看结果就知道字母，数字，空白符，其他，一共多少个。
     for i in n:
         if i.isalpha():
             dic['alpha'] += 1
         elif i.isdigit():
             dic['digit'] += 1
         elif i.isspace():
             dic['space'] += 1
         else:
             dic['other'] += 1
     return dic
 print(test('asdfa 44 6a4 645 6a6dfa687df6a**a*d*f*a*d*f*'))

 def test(dic):
     for k in dic:
         if len(dic[k]) > 2:
             dic[k] = dic[k][:2]
     return dic
 print(test({'adf':'dfa','vb':'cdag','oe':'desfg'}))

 def test(a,b):  #接收两个数字，返回小的
     return  a if a<b else b #三元运算，简化代码，适合简单的情况
 print(test(1,5))

 a = 0               #全局变量
 def outer():
     b=2             #局部变量
     def inner():    #嵌套函数
         nonlocal b  #nonlocal 声明b是外层函数的变量
         b=20000000  #修改b的值
     inner()
     print(b)
     global a        #声明a是全局变量。如果想修改全局变量，必须先声明
     a=10000000      #修改a的值
 outer()
 print(a)

 闭包：闭包的好处是外部函数变量a长期存放在内存当中，不会因为外部函数多次被调用而多次生成，导致占用空间。
 def outer():
     a=1
     def inner():
         print(a)    #内部函数调用外部的变量，叫做闭包。这里调用了a.
     return inner    #inner()是调用inner函数，inner没有()是函数对象的意思。这里返回函数对象的地址给outer()。因为函数名()=返回值，所以outer()=inner.
 outer()()         #因为outer()=inner,所以outer()()=inner()，这样就可以调用内部函数。