函数的正式参数类型、参数组合、函数的作用域、匿名函数、filter()过滤器、map()

函数参数的类型

• 必选参数：形参和实参一一对应（个数，数据类型，顺序）
• 形参:定义方法时的参数
• 实参：调用方法时的参数

def fun1(a,b):#形参
    '''
    :param a:#第一个加数
    :param b:#第二个加数
    :return:#a+b的和
    '''
    return a+b;
h=fun1(3,3);#实参
print(fun1.__doc__);
print(h);

• 默认参数：(缺省参数)缺省参数必须写在后面,可以不指定参数名，但是顺序要保证，否则要指定参数名

def fun1(a,b=5):#b=5为默认值
    '''
    :param a:
    :param b:
    :return:
    '''
    return a+b;
h=fun1(3);#未填写参数值时。识别默认值
print(fun1.__doc__);
print(h);

def printinfo( name, age = 35 ):
 "打印任何传入的字符串"
 print ("名字: ", name);
 print ("年龄: ", age);
 return;

printinfo('ok');

• 关键字参数：关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict
• 关键字参数：**kw

def student(name,age,**kw):
    print('姓名{} ,年龄{} other:{}'.format(name,age,kw));
student('ok',30,xingqu='学习',aihao='运动');

dic={'一':123,'二':223,'三':323};#当需要传入多个键值的形式时，可通过字典形时传递
student('ok',30,**dic);

• 命名关键字参数:name=value

def show(name,age,sorce=90):#一旦以name=value的传参数的形式存在  以后都要以这种形式存在
    print('姓名：{} 年龄：{} 成绩：{}'.format(name,age,sorce));
show('ok',30);
show(name='ok',age='30',sorce=80);
show(name='ok',sorce=80,age='30');#name=value的传参数的形式 不要求顺序
#show(name='ok',name='30',sorce=80);#报错('OK',sorce=30,age=30) ,后者不能重复以name=value赋值

• 不定长参数(可变参数):可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple（元组）

def GetSum(*nums):
    sum=0;
    for i in nums:
        sum+=i;
    return sum;
print(GetSum(2,3));
print(GetSum(2,3,4,5));
print(GetSum(2,3,4,5,6,7,8));

def GetSum(*nums):
    sum=0;
    for i in nums:
        sum+=i;
    return sum;

s=[2,3,4,5];
t=(2,3,4,5,6,7,8)
print(GetSum())
print(GetSum(*s))#“*”代表把列表或元组当中的每一个值逐个赋值给函数
print(GetSum(*t))

• 参数组合:定义一个函数，包含上述若干种参数：

def f1(a, b, c=0, *args, **kw):
  print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw);

args = (1, 2, 3, 4);
kw = {'d': 99, 'x': '#'};
f1('A','B');
f1(b='B',a='A');
f1(b='B',a='A',c=9);
f1(*args);
f1('A','B',**kw);
f1(*args,**kw);

总结

• Python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。
• 默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！
• 要注意定义可变参数和 **kw 关键字参数的语法：
  *args是可变参数，args接收的是一个tuple；
  **kw是关键字参数，kw接收的是一个dict。
• 传参数：*args 会逐个分割args 逐个对应形参列表
  **kw 只能对应到形参列表的 **kw

函数的作用域

#全局变量与局部变量的作用域不同
#生命周期不同
g_a=10;#全局变量
def changeNum():
    global a
    a=5;#局部变量
    print("函数内部：",a);
print("调用前：",g_a);
changeNum()
print("调用后：",g_a);
print("调用后：",a)
#当全局变量和局部变量同名时，局部变量优先 -->就近一致原则

匿名函数

• python 使用 lambda 来创建匿名函数
  语法：lambda [arg1 [,arg2,…..argn]]:expression
  语法：lambda [参数列表]:函数体内部代码

def fun1(a,b):
    '''
    :param a:#第一个加数
    :param b:#第二个加数
    :return:#a+b的和
    '''
    return a+b;
sum=lambda a,b:a+b;
s=sum(2,2);
print(s);
sum=lambda a,b:a*b;
s=sum(2,4);
print(s);

def add(a,b,fun):
    '''

    :param a:
    :param b:
    :param fun: 传递过来的函数
    :return:
    '''
    print(fun(a,b));
add(11,22,lambda a,b:a-b);

filter()：对于序列中的元素进行筛选，最终获取符合条件的序列

foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]
f=filter(lambda x:x%3!=0,foo);
print(list(f))

fun=lambda x: x%2!=0;
f=filter(fun,foo);
print(list(f));

• 利用filter()，可以完成很多有用的功能，例如，删除 None 或者空字符串：

def is_not_empty(s):
    return  s and len(s.strip())>0;

names=[    'ko',None,'','ok'];

l=list(filter(lambda s:s and len(s.strip())>0,names))
print(l);

map()：将序列的每个元素传入函数中执行，并把结果作为新的list返回。

foo = [2, 18, 9, 22, 17, 24, 8, 12, 27];
print(list(map(lambda x:x%2,foo)));