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()，这样就可以调用内部函数。