函数与lambda表达式

函数

调用

def hello(name): #参数，形参没有实际的值
    print('hello',name)

hello('taom') #调用,参数匹配

计算

def hello(name): #参数，形参没有实际的值
    print('hello',name)


def add(x, y):
    return x + y

hello('taom') #调用,参数匹配

result = add(5,3)#声明新变量
print(result)

字符串也支持相加

result = add('abc','xyz')#声明新变量
结果：
hello taom
abcxyz

1参数匹配：默认位置匹配，也可按名称匹配。2、关键字匹配。3、默认值

def func(a,b,c): #定义函数func，接收abc
    print(a,b,c)

func(1,2,3)
func('a','b','c')
func([1,2,3],(5,6),{'a':1,'b':2}) #传递不受限制

def func(a,b,c): #定义函数func，接收abc
    print(a,b,c)

func(c=1,a=2,b=3) #使用可换

 默认值（调用时省略传值）

def func(a,b=2,c=3):
    print(a,b,c)

func(1)

def func(a,b=2,c=3):
    print(a,b,c)

func(1,c=5)

结果：1，2，5

算平均分

def avg(score1,score2):
    return (score1 + score2) / 2

result = avg(98.2,88.4)

print(result)

定义参数可以使用元组传递参数

def avg(*scores):#加*代表后面可能有很多，定义参数里真是类型是tuple
    return sum(scores) / len(scores) #把集合的值汇总起来，len全局函数

result = avg(98.2,88.1,70,65)

print(result)

*args传值，任意数量参数

def avg(*scores):#加*代表后面可能有很多，定义参数里真是类型是tuple
    return sum(scores) / len(scores) #把集合的值汇总起来，len全局函数

scores = (88,89,90) #类型兼容的多个变量

result = avg(*scores) #把tuple变量类型传入,*是解开，必须解开

print(result)

**kwargs关键字参数，声明函数时传递字典表信息：**

emp = {
    'name':'Tom',
    'age':22,
    'job':'dev'
}

def display(**employee):#**传递字典
    print(employee)
display(name='tom',age=22,job='dev')

emp = {
    'name':'Tom',
    'age':22,
    'job':'dev'
}



def display(**employee):#**传递字典
    print(employee)

d = {'name':'Jerry','age':22}#声明一个字典表
d2 = dict(name='Mike',age=23,job='dev')

display(**emp)

Lambda 表达式：定义匿名函数 动态语言

lambda 基本格式：参数1,...:函数

定义

def hello(name): #：定义函数名称，参数，方法体
    print(name)

f = lambda name:print(name) #接收一个对象引用名称,表明定义函数，lambda表达式

f('tom')

def add(a,b):
    return a + b

def hello(name): #：定义函数名称，参数，方法体
    print(name)

f = lambda name:print(name) #接收一个对象引用名称,表明定义函数，lambda表达式
f2 = lambda x,y:x+y#定义函数需要return，lambda表达式不需要,返回x+y直接写

f('tom')
print(f2(5,3))

 做一个软件，根据不同语言实现打招呼的版本

def hello_chinese(name):#定义一个hellochinese函数，跟谁打招呼写上名称
    print("您好",name)

def hello_english(name):
    print('Hello',name)

while True:
    name = input('请输入您的姓名：
')
    if name == 'stop':#做判断,如果stop就跳出，不是就继续
        break
    language = input('请选择语言：
 c => 中文版
 e => 英文版
 j => 日文版
')#请输入打招呼的版本,输入c表明执行中文
    if language == 'c':
        hello_chinese(name)
    elif language == 'e':
        hello_english(name)
    elif language == 'j':
        (lambda name:print('こんにちは',name))(name)#传递给变量才好使用，大括号当整体，再把name传进去

def hello_chinese(name):
    print('您好',name)

def hello_english(name):
    print('hello:',name)

def hello_japanese(name):
    print('こんにちは',name)

while True:#调用
    name = input('请输入姓名：
')
    if name == 'stop':
        break
    language = input('请选择语言：
 c => 中文版
 e => 英文版
 j => 日文版
 r => 俄文版
')

    f = lambda name:print('привет',name) #适用于临时用一次

    if language == 'c':
        hello_chinese(name)
    elif language =='e':
        hello_english(name)
    elif language == 'j':
        hello_japanese(name)
    elif language == 'r':
        f(name) #用f把name传入

action 委托

def hello_chinese(name):#定义一个hellochinese函数，跟谁打招呼写上名称
    print("您好",name)

def hello_english(name):
    print('Hello',name)

while True:
    name = input('请输入您的姓名：
')
    if name == 'stop':#做判断,如果stop就跳出，不是就继续
        break
    language = input('请选择语言：
 c => 中文版
 e => 英文版
 j => 日文版
')
    if language == 'c':
        action = hello_chinese #执行工作嫁给action，委托
    elif language == 'e':
        action = hello_english
    elif language == 'j':
        action = lambda name:print('こんにちは',name)

    action(name)

简化

def hello_chinese(name):#定义一个hellochinese函数，跟谁打招呼写上名称
    print("您好",name)

def hello_english(name):
    print('Hello',name)

hello = hello_chinese #hello委托hello_chinese来执行一个方法，来执行hellotom的逻辑
hello('tom')

hello = lambda name:print('こんにちは',name)

def hello(name):
    print('hello',name)

f = lambda name,age:print('hello {},age:{}'.format(name,age))

f('tom',20)

啰嗦版：

def hello_chinese(name):
    print('您好',name)

def hello_english(name):
    print('hello:',name)

def hello_japanese(name):
    print('こんにちは',name)

while True:#调用
    name = input('请输入姓名：
')
    if name == 'stop':
        break
    language = input('请选择语言：
 c => 中文版
 e => 英文版
 j => 日文版
 r => 俄文版
')

    #f = lambda name:print('привет',name) #适用于临时用一次

    if language == 'c':
        hello_chinese(name)
    elif language =='e':
        hello_english(name)
    elif language == 'j':
        hello_japanese(name)
    elif language == 'r':
        (lambda name:print('привет',name))(name)#前括号是定义，后括号是调用

把要执行的操作放入字典表里

In[2]: emp = {'name':'Jerry','age':22,'job':'dev'}
In[3]: emp['name']
Out[3]: 'Jerry'
In[4]: emp.get('age')
Out[4]: 22
In[6]: emp.get('Name','无此键值')
Out[6]: '无此键值'

get的应用比[ ]广，大小写都支持，且可以指定默认值

 通过字典表方式模拟了其他的case

def hello_chinese(name):
    print('您好',name)

def hello_english(name):
    print('hello:',name)

def hello_japanese(name):
    print('こんにちは',name)

operation = {
    'e':hello_english,#不写括号只是引用，写了代表马上就要传值
    'c':hello_chinese,
    'j':hello_japanese,
    'r':lambda name:print('привет',name) #定义没有调用，只是赋了个键
}#放入字典表

while True:#调用
    name = input('请输入姓名：
')
    if name == 'stop':
        break
    language = input('请选择语言：
 c => 中文版
 e => 英文版
 j => 日文版
 r => 俄文版
')

    operation.get(language,hello_chinese)(name)#调用键值,可以将行为放入字典表做键值，想执行写上参数name

打印一个不同版本的内容

def hello_chinese(name):
    print('您好',name)

def hello_english(name):
    print('hello:',name)

def hello_japanese(name):
    print('こんにちは',name)

def hello(action,name):#委托,name封装不同语言调用函数功能
    action(name)

hello(hello_chinese,'tom')#hello_是形参，tom对应name是实参，是委托

想改个不存在的把最后一行换成

hello(lambda name:print('привет',name),'tom')#hello_是形参，tom对应name是实参

lambda表达式好处

目标输出偶数

l = list(range(1,21)) #range全局函数,list将结果转换成列表

result = []

#找偶数放入[]
#1.使用循环
for n in l:
    if n % 2 == 0:
        result.append(n)


print(result)

法2：推导

l = list(range(1,21)) #range全局函数,list将结果转换成列表

result = []

#找偶数放入[]
#1.使用循环
for n in l:
    if n % 2 == 0:
        result.append(n)

#2.使用推导
result = [x for x in l if x % 2 == 0] #l里找出所有变量叫x，过滤条件if

print(result)

l = list(range(1,21))

res = []

def add_number(x):#法3里添加的
    return x + 5

#1.循环
for x in l:
    res.append(x + 5)

#2.推导
res = [x+5 for x in l]

#3.map()列表把某一函数用到列表每一个元素上
res = list(map(add_number,l))#map映射把每一个元素取出来传递给参数add_number,放入列表里

print(res)

#3.map()列表把某一函数用到列表每一个元素上
res = list(map((lambda n:n**2),l))#接收一个n，求平方值,第一个lambda是它要执行的第二个对象集合

l = list(range(1,11))

def even_number(x): #判断是不是偶数
    return x % 2 == 0

res = list(filter(even_number, l)) #filter函数en是判断，从l找出符合条件的放入新结果,把它转成列表

print(res)

l = list(range(1,11))

def even_number(x): #判断是不是偶数
    return x % 2 == 0

res = filter(even_number, l) #filter函数en是判断，从l找出符合条件的放入新结果,把它转成列表

for n in res:
    print(n,end='') #可迭代对象

lambda

l = list(range(1,11))

res = filter(lambda n:n %2 == 0, l) #filter函数en是判断，从l找出符合条件的放入新结果,把它转成列表

res = [x for x in l if x %2 ==0]
for n in res:
    print(n,end=' ') #可迭代对象