二、函数基础

一、函数分类

　　1. 内置函数：

　　　　python解释器已经定义好了的函数，拿来即用

　　2. 自定义函数：

             def 函数名(参数1,参数2,参数3,...):
                  '''注释'''
    　　　　　　　　函数体
    　　　　　　　　return 返回的值

 二、 自定义函数需先定义，再使用

　　  函数定义后会检测语法错误，逻辑错误只有被调用后才能检测

三、 函数调用

　　1. 函数调用方式

　　　　函数名（）

　　2. 函数返回值

　　　　没有return------------>返回None

　　　　return1个值---------->返回一个值

　　　　return多个值--------->返回一个元组

　　3. 函数调用的三种形式

　　　　语句形式----------------------->foo()

　　　　表达式形式-------------------->6*len(x)

　　　　作为另一个函数的参数------>len(upper(x))

四、形参和实参

　　1. 形参即变量名

　　2. 实参即变量值

　　3. 位置参数

　　　　按照从左到右的顺序定义的参数，实参在传给形参时，也必须按照顺序传递　

　　　　def aaa(x,y,z)
    　　　　#计算3个参数的和
   　　　　 a=x+y+z
   　　　　 return(a)

　　　　res=aaa(1,2,3)
　　　　#调用时1赋值给x,2赋值给y,3赋值给z

　　4. 关键字参数

　　　　按照x=2,y=3,z=4的形式给形参传值

　　5. 默认参数

　　　　形参在定义时，已经给了一个参数，调用时，若不给这个参数赋值，则使用默认参数

　　6. 可变长参数

　　　　指实参的个数不固定

　　　　针对可变长参数，使用 *args 存放元组形式的参数， **kwargs 存放字典形式的参数

def foo(x,y,*args):
    print(x,y)
    print(args)
print(foo(1,2,3,4,5))

运行结果：
1,2
（3,4,5）          #元组形式传入的实参
None              #没有定义函数返回值，默认返回None

def foo1(x,y,*args):
    print(args)
    print(len(args))

foo1(1,2,*(3,4,5))      #依次拿出元组（3,4,5）的元素，组成元组args的元素

运行
(3,4,5)
3


##########
def foo(x,y,z):
    print(x,y,z)
foo(*[1,2,3])
print(*[1,2,3])

1 2 3
1 2 3


##########
def foo(x,y,**kwargs):
    print(x,y)
    print(kwargs)
foo(1,y=2,a=1,b=2,c=3)

1 2 
{'b':2,'c':3,'a':1}


##########
def foo(x,y,**kwargs):
    print(x,y)
    print(kwargs)
foo(1,y=2,**{'a':1,'b':2,'c':3})

1 2 
{'b':2,'c':3,'a':1}


##########
def foo(x,y,z):
    print(x,y,z)
foo(**{'z':1,'x':2,'y':3})

2 3 1


##########
def foo(x,y):
    print(x,y)
def wrapper(*args,**kwargs):
    print('====>')
    foo(*args,**kwargs)
wrapper((66,77),{'a':1,'b':2,'c':3})

(66,77),{'a':1,'b':2,'c':3}


##########
def aaa(*args,**kwargs):
    print(args)
    print(kwargs)
    print(len(args),len(kwargs))
aaa(*(66,77),**{'a':1,'b':2,'c':3})  #args=(66,77)   kwargs={'a':1,'b':2,'c':3}
aaa((66,77),{'a':1,'b':2,'c':3})     #args=(66,77),{'a':1,'b':2,'c':3}    kwargs为空


##########
def foo(x,y,*args,a=1,b,**kwargs):
    print(x,y)
    print(args)
    print(a)
    print(b)
    print(kwargs)
foo(1,2,3,4,5,b=3,c=4,d=5)

1 2
(3, 4, 5)
1
3
{'c': 4, 'd': 5}

五、练习题

1、写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数

def  aaa(x):
    num=0
    string=0
    space=0
    others=0
    for i in x:
        if i.isdigit():
            num+=1
        elif i.isalpha():
            string+=1
        elif i.isspace():
            space+=1
        else:
            others+=1
    print('%s这个字符串中，有数字%s个，字母%s个，空格%s个，其他%s个'%(x,num,string,space,others))
aaa('dgajg sdjigaj s3438ng %%#%')

2、 写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5

def aaa(x):
    if len(x)>5:
        print('%s的长度大于5，长度为%s'%(x,len(x)))
    else:
        print('%s的长度不大于5，长度为%s'%(x,len(x)))
aaa((1,2,3,4,5,6,7))
aaa([1,2,3,4,5,6,7])
aaa('sfhusgange')

(1,2,3,4,5,6,7)的长度大于5，长度为7

[1,2,3,4,5,6,7]的长度大于5，长度为7

sfhusgange的长度大于5，长度为10

 3、 写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者

def aaa(x):
    if len(x)>2:
        x=x[0:2]
    print(x)
    return(x)
aaa(['aaa'])
aaa(['aaa','bbb','ccc','ddd'])

['aaa']
['aaa','bbb']

 4、写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者

def aaa(x):
    return x[1::2]
print(aaa([1,2,3,4,5,6,7,8,9]))

5、写函数，检查字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者

def aaa(x):
    d={}
    for k,v in x.items():
        if len(v)>2:
            d[k]=v[0:2]
        else:
            d[k]=v
    return d
print(aaa({'k1':'abcdef','k2':[1,2,3,4],'k3':('a','b','c'),'k4':'a'}))

{'k1':'ab','k2':[1,2],'k3':('a','b'),'k4':'a'}