一、python 函数

1.1 函数定义及调用

#函数的定义及调用
def get_sum(num):
    s=0;
    for i in range(1,num+1):
        s=s+i;
    print(f'1到{num}累计和：{s}')

get_sum(10)
get_sum(100)
get_sum(1000)

1.2 函数参数传递

1.2.1 位置传参

#函数的参数传递-位置，关键字传参
def getstr (name,age):
    print(f'祝{name}生日快乐，天天开心');
    print(f'{age} 生日快乐')

#位置传参
getstr('康康',18)

1.2.2 关键字传参

位置，关键字混合传参时，位置传参必须在前。

#函数的参数传递-位置，关键字传参
def getstr (name,age):
    print(f'祝{name}生日快乐，天天开心');
    print(f'{age} 生日快乐')

#关键字传参
getstr(name='康康',age=18)

#位置，关键字混合传参，位置传参必须在前
getstr('康康',age=18)

1.2.3 默认值传参

定义函数时，位置参数必须在前，默认值参数在后。

#函数的参数传递-默认值传参
def getstr (name='哇哈哈',age=18):
    print(f'祝{name}生日快乐，天天开心');
    print(f'{age} 生日快乐')

#默认值传参
getstr()

#位置，默认值传参
getstr('康康')

#关键字，默认值传参
getstr(name='康康')

#默认值参数
def fun1 (a=1,b=2):
    pass;

#位置参数必须在前，默认值参数在后
def fun2(a,b=2):
    pass;

#报语法错误
#def fun3(a=1,b):
#    pass;

1.2.4 可变参数传参

• 个数可变的位置传参：定义函数参数时，参数前加一颗星*，调用时列表前加*可进行解包
• 个数可变的关键字传参：定义函数参数时，参数前加两颗星**，调用时字典前加**可进行解包

#1、个数可变的位置传参
def fun1 (*para):
    print('参数类型：',type(para));
    for item in para:
        print(item)

fun1(1)
fun1(2,'康康')
fun1(1,2,3)
fun1(1,2,3,4)

#调用时，在参数前加一颗星，将列表进行解包
d=[1,2,3,4,5]
fun1(d)
fun1(*d)

#2、个数可变的关键字传参
def fun2 (**para):
    print('参数类型：',type(para));
    for key,value in para.items():
        print(key,'----',value)

fun2(name='whh')
fun2(name='whh',age=18,heigh=165)

#调用时，在参数前加两颗星，将字典进行解包
d={'name':'康康','age':181}
#fun2(d)
fun2(**d)

运行结果如下： 

1.3 函数返回值

函数返回值可以有0，1，多个，当有多个返回值时，结果是元组类型，想让返回值解包可多个变量接收即可。

#函数返回值
print('函数无返回值')
def fun1 (a,b):
    r=a+b;

fun1(1,2)
print(fun1(1,2))

print('函数一个返回值')
def fun2 (a,b):
    r=a+b;
    return r;

fun2(1,2)
print(fun2(1,2))
res=fun2(fun2(1,2),2)
print(res)

print('函数多个返回值')
def fun3 (num):
    odd=0;
    even=0;
    sum=0;
    for i in range(1,num+1):
        if i%2!=0:
            odd=odd+i;
        else:
            even=even+i;
        sum+=i;
    return odd,even,sum;

fun3(10)
print(fun3(10))
res=fun3(10)
print(type(res),res)
a,b,c=fun3(10)
print('返回值解包：',a,b,c)

运行结果如下： 

1.4 匿名函数

python 使用 lambda 来创建匿名函数。

• lambda只是一个表达式，函数体比def简单很多。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法：

lambda函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

#匿名函数
s=lambda a,b:a+b;
print(type(s))
print(s(2,3))

lis=[
    {'name':'康康1','score':85},
    {'name':'康康2','score':80},
    {'name':'康康3','score':90},
    {'name':'康康4','score':100},
]
lis.sort(key=lambda x:x.get('score'),reverse=True)
print(lis)

######### 运行结果：
<class 'function'>
5
[{'name': '康康4', 'score': 100}, {'name': '康康3', 'score': 90}, {'name': '康康1', 'score': 85}, {'name': '康康2', 'score': 80}]

Process finished with exit code 0

未完待续~~~