一、概述

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

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

Python中有哪些函数:

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

关于内置函数, 参考:

http://python.usyiyi.cn/python_278/library/functions.html

http://www.cnblogs.com/huangweimin/p/5619633.html

二、自定义函数

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

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

1、普通函数

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

//解释器遇到def函数语句,在内置中创建函数对象,函数名指向这个函数对象

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

函数可以传参数,关键字参数、默认参数、收集参数

1、关键字参数

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

结果:
I am zhang age 25  
  • 形式参数可以说就是摆设,需要传实际的参数进去,它们是对应的关系
  • 先在内存中创建'zhang',25,然后将形式参数name,age分别指向它们
  • 如果不传参数会抛出异常TypeError
  • 函数的参数不是变量, 而是一种传值引用

2、默认参数

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
  • 默认参数相当于一个初始的参数,不能是不可变的对象
  • 如果不传默认参数,则使用默认参数,如果传相当于覆盖修改
  • 默认参数一定要放到最后面,可以有多个

3、收集参数 *args、**kwargs

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)
  • 说明*args构造的一个空tuple来装传过来的参数,如果要传一个列表或者元组需要在前面添加*抵消掉原来的tuple
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'}
  • 说明**kwargs是用空{}来装参数,它只接受key=value形式的传参,否则会抛出错误TypeError,返回一个字典的形式(key不需要加引号)
  • 如果要传一个字典,需要在前面添加**

4、收集参数(就是*args、**kwargs的混用)

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'}
  • 收集参数*args、**kwargs可以混用,比较灵活,注意它们也有对应的关系,不能反着传

3、函数的返回值

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

1、函数执行遇到了return就不会往下面执行

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

2、return与print

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

//函数的return应该使用return而不是print

3、函数只能return一种对象,这也是函数的限制

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

//在adds()函数中,用return貌似返回int和dict两个对象,但是实际得到的是一个元组对象,说明return构造的是一个tuple对象返回调用的结果

4、函数的作用域

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

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

1、函数内的变量不能被外部引用,除非global声明

def func():
  x = 10
  print x
func()
10           

print x
NameError: name 'x' is not defined   #异常

如果global声明则可以调用:

def func():
  global x
  x = 10
  print x
func()
10           #结果

print x      #可以引用
10

2、全局与局部如冲突,局部优先,只作用在函数里面

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

如果添加global声明,则修改全局:

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

3、内层函数优先

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

4、内层函数找不到再找外层函数

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

5、内层、外层函数都没有,找全局的

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

三、lambda、map、filter、reduce

1、lambda

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

特点:

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

用法:

"lambda" [parameter_list]: expression
parameter_list: 参数列表
expression: 表达式

1、简单的def函数可以用lambda表示

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

def func2(a):
	return a * 10
print func2(10)
结果:
100

用lambda表达式可以写成:

restult1 = lambda x,y: x + y           #x,y是形式参数
restult2 = lambda x: x * 10            #x是形式参数
print restult1(10,20)
30
print restult2(10)
100
  • 和函数一样,x,y可以看成是一个形式参数,可以传参

2、传默认参数、动态参数(*args,**kwagrs),默认参数也要放到最后面

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

动态参数*args

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)

传动态参数**kwargs

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'}
  • lambda函数传参和普通函数是一样的,*args、**kwargs分别构造的是空元组、空字典来装参数

3、def 声明函数是将函数名指向函数对象,而lamdba不是

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]

1、给li列表中所有的元素加10返回一新的list

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

也可以用lambda表示:

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

2、map接收多个序列

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]
  • map函数遍历序列做为参数传给一个函数经过处理,返回一个新的列表。序列可以有个,可以是list和tuple  
  • map是高阶函数,一个函数作为参数传给另一函数

3、filter

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

参考

用法: filter(function or None, sequence)

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

1、filter函数从li列表中每取一个元素应用到func,进行筛选,得出符合条件的元素

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]
  • 如果li是字符串返回的也是字符串、如果是元组返回的也是元组

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.

reduce

计算1*2*3*4*5

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

也可以指定初始值initial

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

PS: 所以reduce函数就是从序列中拿出两个元素作用到函数中进行累积操作

总结:

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

 

Python基础三. 函数、lambda、filter、map、reduce的更多相关文章

  1. Python2.7学习笔记-定义函数、filter/map/reduce/lambda

    我把写的代码直接贴在下面了,注释的不是很仔细,主要是为了自己复习时方便查找,并不适合没有接触过python的人看,其实我也是初学者. #定义函数 def my_abs(x): if x>=0: ...

  2. [转]Python 中的 lambda,filter,map,reduce,apply

    1. lambda 1. 基本形式: 函数名=lambda args1,args2,...,argsn:expression与C语言中的宏定义类似 2. Code isodd = lambda x: ...

  3. filter,map,reduce,lambda(python3)

    1.filter filter(function,sequence) 对sequence中的item依次执行function(item),将执行的结果为True(符合函数判断)的item组成一个lis ...

  4. python filter map reduce

    filter(function, iterable): Construct a list from those elements of iterable for which function retu ...

  5. python基础——匿名函数

    python基础——匿名函数 当我们在传入函数时,有些时候,不需要显式地定义函数,直接传入匿名函数更方便.  在Python中,对匿名函数提供了有限支持.还是以map()函数为例,计算f(x)=x2时 ...

  6. python基础——返回函数

    python基础——返回函数 函数作为返回值 高阶函数除了可以接受函数作为参数外,还可以把函数作为结果值返回.  我们来实现一个可变参数的求和.通常情况下,求和的函数是这样定义的: def calc_ ...

  7. python基础——sorted()函数

    python基础——sorted()函数 排序算法 排序也是在程序中经常用到的算法.无论使用冒泡排序还是快速排序,排序的核心是比较两个元素的大小.如果是数字,我们可以直接比较,但如果是字符串或者两个d ...

  8. paip.提升效率---filter map reduce 的java 函数式编程实现

    #paip.提升效率---filter map reduce 的java 函数式编程实现 ======================================================= ...

  9. python基础——匿名函数及递归函数

    python基础--匿名函数及递归函数 1 匿名函数语法 匿名函数lambda x: x * x实际上就是: def f(x): return x * x 关键字lambda表示匿名函数,冒号前面的x ...

随机推荐

  1. NodeJs 开发微信公众号(五)真实环境部署

    在测试环境下开发完成代表着你离正式上线的目标不远了.接下来本章就主要谈一谈把测试环境的公众号升级为正式的公众号. 服务器和域名 目前为止我们只是在自己的电脑上完成了测试环境.真实的线上环境当然需要自己 ...

  2. JDBC的使用(一):引用外部jar;代码链接数据库

    一:引用外部jar 1.首先不jar文件放到项目下: 2.在Eclipse中,右键相应的项目--构建路径--配置构建路径--库--添加外部jar:选中-打开-应用-确定. 二:代码链接数据库 1.加载 ...

  3. AutoLayout - VFL

    其实很早就像整理出一份VFL的总结出来,觉得有很多东西可以写,但是真正去总结的时候发现,VFL也并没有很多东西,其实应该是在布局的过程中直接用VFL语句思考的过程比较难以形成,多数布局问题其实是在实际 ...

  4. Centos压缩与打包

    这个虽然是基础知识,但是有些东西就是这样,久了没用,就会忘记,而且之前有一个坏习惯就是不喜欢做笔记,以后学习了行东西一定要记录在博客,这样以后自己也能时不时的查看一下. 言归正传,在计算机的世界中,数 ...

  5. ajax之jsonp跨域请求

    前端ajax请求代码 后台php处理代码

  6. http 请求类

    1.httpclient请求类 代理demo:http://hc.apache.org/httpcomponents-client-4.3.x/httpclient/examples/org/apac ...

  7. 计算空间直线与平面的交点 (C#)

    public class NGlbVec3d    {// 三维点        public double x, y, z;        public NGlbVec3d()        {   ...

  8. MySql分类

    基础 数据类型宽度 查看字段长度 数据类型 运算符 函数 查询 插入 更新 删除 索引 自定义存储过程和函数 视图 触发器 权限管理 备份和恢复 日志 优化 复制

  9. dt.jar设计时rt.jar运行时

    很多人在初学Java的时候,都要配置环境变量.在配置CLASSPATH的时候,都会加上一个当前目录.,还有两个jar:dt.jar和tools.jar.其实好多人都不了解这两个jar的作用,尤其是dt ...

  10. js基础笔记

    <!DOCTYPE html><html lang="en"><head>        <meta charset="UTF- ...