Python基础(7)

Python

函数是一个能完成特定功能的代码块，可在程序中重复使用，减少程序的代码量和提高程序的执行效率。在python中函数定义语法如下：

def  function_name(arg1,arg2[,…]):
    statement
         [return value]

返回值不是必须的，如果没有return语句，则Python默认返回值None。

>>> def hello():
...     print 'Hello World!'
...
>>> res = hello()
Hello World!
>>> res
>>> print res
None
>>> type(res)
<type 'NoneType'>
>>>

Python函数没有声明和定义的区分。

python函数能返回多个值？

>>> def foo():
...     return 1,'123',[1,'a']
>>> res = foo()
>>> print res
(1, '123', [1, 'a'])
>>> res
(1, '123', [1, 'a'])
>>> type(res)
<type 'tuple'>
>>>

Python看起来能返回多个返回值，但其实是一个元组，因为元组在语法上不需要一定带上圆括号。

所以表面上看上去是返回了多个值，实际上上述代码是组包和解包的过程，元组使用逗号打包，序列通过放置几个逗号分隔的目标到语句的左边来解包。

函数也是对象，可以被引用，可以作为函数的参数，可以作为容器对象的元素，如List, Dictionary等。

>>> def func():
...     print 'call func.'
...
>>> def foo(func):
...     func()
...
>>> foo(func)
call func.
>>>

函数参数：
参数的传递规则如下：

p 参数的传递是通过把对象赋值给局部的名字。

赋值在Python中就意味着引用。函数中的参数与调用者共同引用的同一个对象。

p 在函数内部中给参数赋值不会影响调用者。

p 在函数内部修改可变类型的参数会影响到调用者。

参数的行为可以与C语言进行类比：

p 不可变类型的参数的行为就像C语言的“by value”方式。

如参数是整数，字符串

p 可变类型的参数的行为就像C语言的“by pointer”方式。

如参数是列表

参数匹配的模式：

p 位置：位置匹配，从左到右

p 关键字：根据参数名进行匹配

p 可变参数：匹配任意多的参数

p 默认值：提供参数的默认值

Syntax Location Interpretation
func(value) Caller Normal argument: matched by position
func(name=value) Caller Keyword argument: matched by name
def func(name) Function Normal argument: matches any by position or name
def func(name=value) Function Default argument value, if not passed in the call
def func(*name) Function Matches remaining positional args (in a tuple)
def func(**name) Function Matches remaining positional args (in a dictionary)

规则：

p 默认参数必须在非默认参数之后

p 在单个函数定义中，只能使用一个tuple参数（*ARG）和一个字典参数（**ARG）

p tuple参数必须在位置参数和默认参数之后

p 字典参数必须在最后定义

python函数是否支持重载？

重载(overload)的特点：

1、参数类型不同

2、参数个数不同

Python的动态类型+可变参数，天然就支持了重载的特性，而且不需要像C++那样去定义多个同名函数。动态类型的特性还让python函数具备了C++中函数模板的功能。

lambda表达式/匿名函数：

lambda [arg1[, arg2, … argN]]: expression

注意：表达式与参数以及lambda都必须在同一行。lambda 函数可以接收任意多个参数（包括可选参数）并且返回单个表达式的值。lambda 函数不能包含命令，包含的表达式不能超过一个。不要试图向 lambda 函数中塞入太多的东西；如果你需要更复杂的东西，应该定义一个普通函数，然后想让它多长就多长。

>>> foo = lambda x,y:x+y
>>> foo(1,3)
4
>>> (lambda x,y:x+y)(5,4)
9
>>>

内嵌函数：在函数内部定义函数

在函数体内创建另外一个函数是合法的，内部函数整个函数体都在外部函数的作用域内，除了在函数体内，任何地方都不能对其进行调用

>>> def foo():
...     def inner():
...         print 'call inner.'
...     print 'call foo'
...     inner()
...
>>> foo()
call foo
call inner.
>>>