Python基础三. 函数、lambda、filter、map、reduce

一、概述

函数, 就是用一些语句组织起来实现一组特定的功能, 用来重复调用.

函数的作用及意义：最大化的重用代码和最小化的代码冗余以及对流程的分解.

Python中有哪些函数:

• 内建的函数
• 第三方模块中的函数
• 自定义的函数

关于内置函数, 参考:

二、自定义函数

• def语句声明, 函数也是一个对象, 函数名指向这个函数对象.
• 函数可以传参, 位置参数、默认参数、收集参数 (形式参数、实际参数)
• 函数用return将调用的的结果对象返回,  并且代表函数的结束
• 自定义的函数不要和内置的对象冲突
• 函数没有被调用不会执行
• 理解作用域和命名空间, LEGB原则

//牢记: 函数也是一个对象，函数名只不过是指向函数对象的变量名

1、普通函数

def sayHi():                # 声明函数
	print 'Hello python'    # 函数体
print sayHi
sayHi()                      # 执行函数
结果:
<function sayHi at 0x00000000025209E8>    #函 数就是一对象，返回在内存中的地址
Hello python

2、函数传参 (形式参数、实际参数)

def func(name,age):              # 定义形式参数
	print 'I am',name,'age',age
func('zhang', 25)                 # 传参，实际参数，对应关系
结果:
I am zhang age 25　　

def func(name,age=19):              # age是默认参数
	print 'I am',name,'age',age
func('zhang')
func('li',age=21)  # 直接修改默认参数
func(name='wang',21)    # 同理
结果:
I am zhang age 19
I am li age 21
I am wang age 21

number = (1,2,3,4,5)
def func(*args):                   # 定义收集参数
	print args
func()                             # 不传参数调用
func(1,2)                          # 传参
func('abcdefg')                    # 传字符串参数
func('zhang','li','zhao')          #
func(number)                       # 传一个序列
func(*number)                      # 传*序列
结果:
()                                 # 返回一个空()，说明*args的方式是构造一元组来装传过来的参数
(1, 2)
('abcdefg',)
('zhang', 'li', 'zhao')
((1, 2, 3, 4, 5),)
(1, 2, 3, 4, 5)

dic = {"key1":"value1","key2":"value2"}
def func(**kwargs):
	print kwargs
func()           # 返回空{}，说明**kwargs构造的是一个空的{}来装参数
func(key1='value1',key2='value2')
func(**dic)
结果:
{}
{'key2': 'value2', 'key1': 'value1'}
{'key2': 'value2', 'key1': 'value1'}

t1= (1,2,3)
dic = {'key1':'value1','key2':'value2'}
def func(*args,**kwagrs):
	print args,kwagrs
func()
func(1,2,3)
func(key1='value1',key2='value2')
func(1,2,3,key1='value1',key2='value2')
func(*t1,**dic)
结果:
() {}
(1, 2, 3) {}
() {'key2': 'value2', 'key1': 'value1'}
(1, 2, 3) {'key2': 'value2', 'key1': 'value1'}
(1, 2, 3) {'key2': 'value2', 'key1': 'value1'}

3、函数的返回值

• 函数的返回值用return, 默认是None
• 函数遇到了return就不会执行后面的语句，代表函数的结束
• 函数只能return一种对象, 其实就是个tuple

def adds(x,y):
	return x+y
	print 'done'      	#不会执行
reslut = adds(10, 20)
print reslut
结果:
30

def adds(x,y):
	b = x+y
	print b
reslut = adds(10, 20)
print reslut
结果:
30
None                  # 没有retrun，默认返回None
def adds(x,y):
	b = x+y
	return b
reslut = adds(10, 20)
print reslut
结果:
30

>>> def adds():
...     return 1,{}
...
>>> adds()
(1, {})

4、函数的作用域

函数有自己的命名空间，即作用域:

• 函数的内部变量不能被外部引用，除非global声明
• 函数外部的变量能够被函数引用
• LEGB原则，本地变量---上层函数---全局---内置

def func():
　　x = 10
　　print x
func()
10           
print x
NameError: name 'x' is not defined   #异常

def func():
　　global x
　　x = 10
　　print x
func()
10           #结果
print x      #可以引用
10

a = 11
def fun1():
    a = 10
    print a
fun1()
print a
结果:
10
11              #注意并没有修改全局的变量a

a = 11
def fun1():
    global a
    a = 10
    print a
fun1()
print a
结果:
10
10

def func1():
　　a = 10
　　def func2():
　　　　a = 11   #先找内层的a
　　　　print a
　　func2()
func1()
结果:
11

a = 1
def func3():
　　a = 10
　　def func4():
	print a   #内层函数找不到再找外层函数
　　func4()
func3()

a = 1
def func3():
　　def func4():
	print a     #内层、外层都没有
　　func4()
func3()

三、lambda、map、filter、reduce

1、lambda

匿名函数就是没有名字的函数，lambda是匿名函数，可以实现简单的函数功能但作用有限

特点:

1. 只是一种表达式函数，简单实现函数的功能
2. 不需要函数名，本身也没有函数名，好处是有时候函数命名也不好管理
3. 自动返回结果returen
4. 同样可以传参数，收集参数、关键字参数、默认参数

用法:

def func1(a,b):
	return a + b
print func1(10,20)
结果:
30
def func2(a):
	return a * 10
print func2(10)
结果:
100

restult1 = lambda x,y: x + y           #x,y是形式参数
restult2 = lambda x: x * 10            #x是形式参数
print restult1(10,20)
30
print restult2(10)
100

func1 = lambda  arg2,arg1=10:arg2+arg1   #arg1是默认参数，放到后面
print func1(20)
30
print func1(20,20)
40

func1 = lambda  *args:args
print func1(1,2,3,4)       #传数字
print func1('abcdefg')     #传字符串
print func1((1,2,3,4))     #传tuple
print func1(*(1,2,3,4))   #传*tuple
结果:
(1, 2, 3, 4)
('abcdefg',)
((1, 2, 3, 4),)
(1, 2, 3, 4)

func2 = lambda **kwargs:kwargs
print func2()
print func2(key1="value1",key2="value2")
print func2(**{"key1":"value1","key2":"value2"})
结果:
{}
{'key2': 'value2', 'key1': 'value1'}
{'key2': 'value2', 'key1': 'value1'}

def func1():
	pass
print func1
func2 = lambda a:a+1
print func2
结果:
<function <lambda> at 0x00000000025C09E8>  #始终返回的是lambda对象
<function func1 at 0x00000000025C0A58>

2、map

接收两个参数,函数和可迭代的对象，将function应用于iterable对象的每一个元素，返回结果的列表

用法:  map(function, sequence[, sequence, ...]) -> list （返回list）

li = [11,22,33,44,55,66,77]

def func(args):
    return args + 10
reslut = map(func,li)      #map接收两个参数，一个函数，一个是列表，将里面中的每个元素作为参数传到func函数中最终得出结果
print reslut[21, 32, 43, 54, 65, 76, 87]

result = map(lambda a:a+10,li)
print result
[21, 32, 43, 54, 65, 76, 87]

li = [11,22,33,44,55,66,77]
li2 = [22,33,44,55,66,77,88]
result = map(lambda a,b:a+b,li,li2)
print result
[33, 55, 77, 99, 121, 143, 165]

3、filter

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

用法:　filter(function or None, sequence)

li = [11,23,18,44,55,21]

def func(*args):
    for i in args:
        if i > 22:
            return i
reslut = filter(func, li)  #从li中每取一个元素作为参数传给func，返回符合条件的元素.
print reslut
[23, 44, 55]

li = [11,23,18,44,55,21]
reslut = filter(lambda arg: arg > 22,li)
print reslut
[23, 44, 55]

4、reduce

归纳的意思，接受两个参数: 函数、序列型对象，从序列性的对象中拿出两个元素作作为参数传给函数，累积操作。返回一个值

用法: reduce(function, sequence[, initial]) -> value

• initial: 初始值

reduce(...)
    reduce(function, sequence[, initial]) -> value
Apply a function of two arguments cumulatively to the items of a sequence,
    from left to right, so as to reduce the sequence to a single value.
    For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
    ((((1+2)+3)+4)+5).  If initial is present, it is placed before the items
    of the sequence in the calculation, and serves as a default when the
    sequence is empty.

def func(x,y):
	return x * y
reslut = reduce(func, [1,2,3,4,5])
print reslut
120
等同于:
reslut1 = reduce(lambda x,y:x*y,[1,2,3,4,5])
print reslut1
120

reslut1 = reduce(lambda x,y:x*y,[2,2,3,4,5],10)
print reslut1
2400

总结:

1. 函数的种类，内置函数、第三方模块函数、自定义函数
2. def函数定义,函数名是函数对象的指向, 不要和内置函数冲突
3. 函数可以传参, 关键字、默认、收集参数,默认参数要放到最后面
4. 参数是函数的入口,return是函数的出口
5. 函数的return只能返回一种对象,就是tuple
6. 注意函数的作用域，全局与局部变量的关系,尽量不用使用全局变量
7. 函数调用应该用return而不是用print,return代表函数的结束,函数执行完后内部对象会被回收
8. 一个函数尽量只做一件事情