8.Python入门之函数类型

函数和过程

一般认为函数有返回值,而过程是简单,特殊并且没有返回值的.但严格地说Python只有函数,没有过程，因为其一定有返回值，如下:

>>>def hello():
print("hello")

>>>print(hello())
hello      #该行是hello()函数执行的
None

      

None是因为hello()函数没有return语句,默认是return None,这样的话所有函数都有返回值.

函数返回值

Python的返回值特殊,可以动态地确定返回值类型，可以返回不同类型的多个值.之前曾说'Python没有变量,只有名字',所以只需知道Python会返回一个东西.

>>>def test();
return[1,'one',3.14] #利用列表打包多个类型的值一次性返回
>>>test()
[1,'one',3.14]

>>>def test();
return(1,'one',3.14) #利用元组打包多个类型的值一次性返回
>>>test()
(1,'one',3.14)

函数变量作用域

变量的作用域即变量的可见性.

函数的参数和函数内定义的变量都是局部变量,局部变量只能在函数体内有效,因为Python运行函数时利用栈进行储存,当执行完函数后,函数的所有数据都会删除,所以无法访问函数内部的局部变量

函数外定义的是全局变量,可以在函数内访问到.




若想在函数内修改全局变量,则Python会在函数内创建新的局部变量替代(名字同全局变量),但真正的全局变量不变.

>>>def hello(a,b):
c=a*b
a=10
print('局部变量中a的值为',a)
return c

>>>a=float(input('输入第一个数:'))
b=float(input('输入第二个数:'))
c=hello(a,b)
print('全局变量中a的值为',a)
print('c的值为',c)

输入第一个数:2
输入第二个数:3
局部变量中a的值为10
全局变量中a的值为2
c的值为6

全局变量在整个代码段都可以访问到，但不要试图在函数内修改全局变量的值，因为Python会在函数内部新建一个名字相同的局部变量来替代

global关键字

全局变量的作用域是整个代码块,在所有函数内部可以访问到局部变量,但函数内部仅仅去访问就好,不要试图修改,因为Python使用屏蔽方式保护全局变量:一旦函数内部试图修改全局变量,Python在函数内自动创建一个同样名字的局部变量,则修改结果只影响到局部变量,而不影响全局变量.

要想在函数内部修改全局变量,可以使用global关键字达到目的.

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

>>>myFun()
10
>>>count
10

内嵌函数

函数定义可以嵌套,即在函数内部定义另一个函数,这种函数称为内嵌函数或内部函数

>>>def fun1():
print("fun1() is using")
def fun2():
print("fun2() is using")
fun2()

>>>fun1()
fun1() is using
fun2() is using

注意点:内部函数作用域在外部函数之内,即fun2()的作用域都在fun1()内,在fun1()内才能自由调用fun2(),在外部试图调用fun2()就会出错

闭包(closure)

闭包是函数式编程的重要语法结构,LISP语言就是函数式编程语言.Python的闭包定义为:若在一个内部函数中,对在外部作用域(但不是全局作用域)的变量进行引用,则内部函数被认为是闭包

>>>def funX(x):
def funY(y):
return x*y
return funY

>>>i=funX(8)
>>>i(5)
40
#也可以这么写
>>>funX(8)(5)

40

理解闭包:若在一个内部函数(FunY)中,对在外部作用域(但不是全局作用域)的变量(x就是在外部作用域被引用的变量,但不是全局作用域)进行引用,则内部函数(FunY)被认为是闭包.

使用闭包注意闭包概念由内部函数而来,所以不能在外部函数以外的地方调用内部函数,如funY(5)是错误的

闭包中,外部函数的局部变量与内部函数的局部变量相当于全局变量和局部变量的对应关系,在内部函数中只能对外部函数的局部变量进行访问而不能修改.

>>>def funX():
x = 5
def fun Y():
x *= x    #报错
return x
return funY

报错,因为Python认为内部函数的x是局部变量时,外部函数的x就屏蔽起来,所以执行x *= x时,根本找不到局部变量x的值.

在Python3之前,只能间接地通过容器类型来存放这种方式解决,因为容器类型不是放在栈里的,所以不会被屏蔽掉

容器类型包括字符串,列表,元组,即可以放不同类型数据的容器

>>>def funX():
x = [5]
def funY():
x[0] *= x[0]
return x[0]
return funY

>>>funX()()
25

nonlocal关键字

Python3使用关键字nonlocal解决在内部函数修改外部函数局部变量值的问题

与用关键字global解决在函数内部修改全局变量值类比

>>>def funX():
x = 5
def fun Y():
nonlocal x
x *= x
return x
return funY

>>>funX()()

lambda表达式

使用lambda关键字创建匿名函数

一般函数

>>>def ds(x):
return 2 * x + 1
>>>ds(5)
11

lambda语句

>>>lambda x : 2 * x + 1
<function <lambda> at Ox00000000007FCD08>

lambda语句语法就是冒号":"左边放原函数的参数,多个参数用逗号隔开,右边是返回值.

lambda 语句实际返回的是一个函数对象,若对其使用,只需要进行赋值操作

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

多个参数

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

lambda表达式好处

1)不必考虑命名问题

2)简化可读性

3)省下去找函数定义的麻烦

两个常用函数

filter()

用法：filter(function or None,iterable)

过滤器作用，filter有两个参数,第一个是一个函数或None,若是函数的话,则将第二个可迭代对象里的每个元素作为函数的参数来计算,把返回值为True的筛选出来,若是None的话,则直接将第二个参数中为True的值筛选出来.

>>>temp = filter(None,[1,0,False,True])
>>>list(temp)
[1,True]

#筛选奇数的过滤器
>>>def odd(x):
return x%2

>>>temp = filter(odd,range(10))
>>>list(temp)
[1,3,5,6,9]

与lambda语句结合

>>>list(filter(lambda x:x%2,range(10)))
[1,3,5,7,9]

map()

map代表映射,参数有两个:一个函数和一个可迭代序列,将序列的每一个元素作为函数的参数进行运算加工,直到每个都加工完成,返回加工后的元素构成的新序列

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