Python(day.5 函数与 Lambda 表达式)

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/qq_43605275/article/details/102743657

函数

创建函数用关键字del，函数后面要有冒号以及他的执行体。

>>>del MyFirstFunction():
print('hello')
print('world')
print('!')
>>>MyFirstFunction()
hello
world
!

函数的参数

调用函数的时候参数位置要赋值,定义函数的参数不要太多，三到四个为宜。

>>>del MySecondFunction(name):
print(name + '你好')
>>>MySecondFunction('moshengren')
moshengren你好

形参和实参

函数文档

>>>del MyFirstFunction(name):
'函数定义过程中的name为形参'
#因为他只是一个形式，表示占据一个参数的位置
print（'传递进来的'+name+'叫做实参，因为他是具体的参数值')

其中，单引号部分为函数文档，使用MyFirstFunction._doc_可以调用。

MyFirstFunction('moshengren')

传递进来的moshengren为实参，因为他是具体的参数值。

函数的返回值

return

>>>del add(num1,num2):
return (num1+num2)
>>>print(add(5,6))
11

关键字参数

>>>del SaySome(name,words):
print(name + '->' + words)
>>>SaySome('小甲鱼','让编程改变世界！')
小甲鱼->让编程改变世界！
>>>SaySome('让编程改变世界！','小甲鱼')
让编程改变世界！->小甲鱼
>>>SaySome(words='让编程改变世界！',name='小甲鱼')
小甲鱼->让编程改变世界！

有了关键字以后，Python不会按照顺序索引，而是按照关键字来索引参数。

默认参数

是定义了默认值的参数。此时函数调用时不给参数也能正常运行。
关键字参数是在参数调用时通过参数名指定需要赋值的参数；默认参数是在参数定义的过程中为形参赋初值。

收集参数（可变参数）

因为在创建函数之初并不知道需要多少参数，所以创造一个元组，将打包成组放到带星号参数中；此时只需在参数前面加上星号即可；但是值得注意的是，如果收集参数后面要加上其他的定值参数时，在调用函数时就要使用关键字参数来定值，否则后面的参数会被列为收集参数的范畴。

>>>def test(*params):
print('参数的长度是：',len(params));
print('第二个参数是：',params[1]);
>>>test(1,'小甲鱼',3.14,5,6,7,8)
参数的长度是：7
第二个参数是：小甲鱼

>>>def test(*params,exp):
print('参数的长度是：',len(params),exp);
print('第二个参数是：',params[1]);
>>>test(1,'小甲鱼',3.14,5,6,7,exp=8)
参数的长度是：6 8
第二个参数是：小甲鱼

或者此时将收集参数后面的参数变成默认参数亦可。

函数与过程

>>>def hello():
print('hello world!')
>>>temp hello()
hello world!

此时如果调用temp,print(temp)均不管用。

>>>def back():
return [1,'小甲鱼',3.14]
>>>back()
[1,'小甲鱼',3.14]

让Python返回多个值时可以选用列表；不用列表打包时默认返回元组。

函数变量的作用域

局部变量，全局变量。

def discounts(price,rate):
final_price=price*rate
return final_price
old_price=float(input('请输入原价：'))
rate=float(input('请输入折扣率：'))
new_price=discounts(old_price,rate)
print('打折后价格是：',new_price)

price,rate,final_price均为局部变量。old_price,rate,new_price均为全局变量。
全局变量在定义前方如果没有定义的话也可使用。

内嵌函数和闭包

一、global关键字

>>>count=5
>>>def MyFun():
global count
count=10
print(10)
>>>MyFun()
10
>>>print(count)
10

二、内嵌函数

>>>def fun1():
print('fun1()正在被调用……')
def fun2():
print('fun2()正在被调用……')
fun2()#该行属于fun1,属于fun1调用fun2
>>>fun1()
fun1()正在被调用……
fun2()正在被调用……

三、闭包
函数式编程的一个重要的语法结构。
定义：如果在一个内部函数里，对在外部作用域的变量进行引用，则称内部函数为闭包。

>>>def FunX(x):
def FunY9Y0;
return x*y
return FunY
>>>FunX(8)(5)
40
>>>i=FunX(8)#或者该方法亦可
>>>i(5)
40

两种调用方式均可。
注意：闭包中的内部函数在外面不能直接被调用。

>>>def Fun1():
x=5
def Fun2():
x*=x
return x
return Fun2()
>>>Fun1()#此时会报错，因为Fun2()中的x相当于一个未定义的局部变量

>>>def Fun1():
x=[5]
def Fun2():
x[0]*=x[0]
return Fun2()
>>>Fun1()
25#此时成功运行，因为列表不属于栈的范畴，可以保存数据

>>>def Fun1():
x=5
def Fun2():
nonlocal x
x*=x
return x
return Fun2()
>>>Fun1()

定义一个nonlocal关键字可以解释x不为局部变量即可。

Lambda表达式

基本语法：冒号前面是原函数的参数，冒号后面是函数的返回值。

>>>g=lambda x:2*x+1
>>>g(5)
11

下面的例子说明当有多个参数的如何调用该表达式。

>>>def add(x,y):
return x+y
>>>add(3,4)
7
>>>g=lambda x,y:x+y
>>>g(3,4)
7

lambda表达式作用：
1.可以省下定义函数过程，只需写个简单的脚本管理服务器时间，就不需要专门定义一个函数然后再调用。
2.对于一些抽象并且整个程序执行下来只需调用一两次的函数，使用该表达式不用考虑起名问题。
3.简化代码可读性。

两个牛逼的BIF

1.filter()
起过滤功能，筛选掉非True内容。
如筛选掉所有的偶数：

>>>de odd(x):
return x%2
>>>temp=range(10)
>>>show=filter(odd,temp)
>>>list(show)
[1,3,5,7,9]
>>>list(filter(lambda x:x%2,range(10)))
[1,3,5,7,9]

2.map()
起映射功能；效果同filter()。

>>>list(map(lambda x: x*2,range(10)))
[0,2,4,6,8,10,12,14,16,18]