概念

函数：一组单独的代码逻辑块，可以有输入（称为参数），可以有输出（称为返回值）
过程：在python中等同于函数
方法：就是类中的函数

函数定义方法

def func_name(arglist):
    ''' func_doc'''
    func_suit

说明：

• 与C语言不同，python语言的函数没有声明和定义的区分
• 函数没有对返回值做定义，可以有以下三种情况
  1. 返回值个数为0个，即没有显示的return语句，则默认会返回None

     >>> def foo():
     ...     print("foo")
     ... 
     >>> ret = foo()
     foo
     >>> ret
     >>> type(ret)
     <class 'NoneType'>
     >>> 
     

  2. 返回值个数为1个，则表示返回的是一个对象obj

    ```python
    >>> def getList():
    ...     return [1, 2, 3]
    ... 
    >>> ret = getList()
    >>> ret
    [1, 2, 3]
    >>> type(ret)
    <class 'list'>
    >>> 
    ```
  

  3. 返回值个数大于1个，则返回的是一个tuple对象

    ```python
    >>> def getTuple():
    ...     return (1, 2, 3)
    ... 
    >>> def getTuple1():
    ...     return 1, 2, 3
    ... 
    >>> ret = getTuple()
    >>> ret1 = getTuple1()
    >>> ret, ret1
    ((1, 2, 3), (1, 2, 3))
    >>> type(ret), type(ret1)
    (<class 'tuple'>, <class 'tuple'>)
    >>> 
    ```
  

• 函数参数定义时没有类型信息，根据调用时传入的值进行分析

  >>> def max(a, b):
  ...     if a < b:
  ...         return -1
  ...     elif a == b:
  ...         return 0
  ...     else:
  ...         return 1
  ... 
  >>> ret = max(1, 2)
  >>> ret
  -1
  >>> ret = max('abc', 'a')
  >>> ret
  1
  >>>
  

• 类似go语言，python函数很像一等公民，可以直接赋值给另外一个变量

  >>> def foo():
  ...     print("foo")
  ... 
  >>> bar = foo
  >>> bar()
  foo
  >>> 
  

函数参数

参数传递

类似C/C++语言，python语言函数参数传递分为两种

• 不可变参数传递，类似于值传递，即函数体内对参数的修改不会影响实参本身，这类包含python的不可变对象：整数、字符串、元组等

  >>> num = 10
  >>> def foo(a):
  ...     a += 1
  ...     print(a)
  ... 
  >>> num
  10
  >>> foo(num)
  11
  >>> num
  10
  >>>
  

• 可变参数传递，类似于引用或者指针，与前者正好相反，这类包含python的可变对象：列表、字典等

  >>> list = [1, 2, 3]
  >>> def foo(a):
  ...     a.append([3, 4, 5])
  ...     print(a)
  ... 
  >>> list
  [1, 2, 3]
  >>> foo(list)
  [1, 2, 3, [3, 4, 5]]
  >>> list
  [1, 2, 3, [3, 4, 5]]
  >>>
  

默认参数

与其他高级语言类似，python也有默认参数特性，即在定义函数时，可以对右边参数赋值，如果调用时不传入对应位置的参数，则使用默认值

>>> def foo(a, b, c = 10):
...     print(a, b, c)
... 
>>> foo(1, 2)
1 2 10
>>> foo(1, 2, 3)
1 2 3
>>>

关键字参数

python语言此特性很有意思，可以在调用函数时，指定形参的名字进行赋值，这样参数的顺序可以不按形参的顺序来，如下

>>> def foo(a, b):
...     print("a = " + str(a) + ", b = " + str(b))
... 
>>> foo(b=1, a=2)
a = 2, b = 1
>>>

不定长参数

类似print函数，可以接收n个参数，n>=0
python语言通过元组和字典两种方式来实现

• 通过元组实现不定长参数，使用单*号

  def func(positionArgs, *tuple):
      func_suit
      
  >>> def foo(a, *bs):
  ...    for t in bs:
  ...        print(t)
  ...    print(a)
  ... 
  >>> foo(1)
  1
  >>> foo(1, 2, 3)
  2
  3
  1
  >>>
  

• 通过字典实现不定长参数，使用双*号

  def func(positionArgs, **dict):
      func_suit
      
  >>> def foo(a, **bs):
  ...     for key in bs.keys():
  ...         print("%s : %s" % (key, bs[key]))
  ...     print(a)
  ... 
  >>> foo(1, b=2, c=3)
  b : 2
  c : 3
  1
  >>>
  

lambda

python语言允许用lambda关键字创建匿名函数，定义如下

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

只有参数和函数体，没有函数名，所以也叫匿名函数
根据前面介绍，这种lambda函数可以赋值给一个变量，通过变量来调用，如下

>>> true = lambda :True
>>> type(true)
<class 'function'>
>>> true()
True
>>> add = lambda x, y: x+y
>>> add(1, 2)
3
>>>

闭包

在python语言中，函数可以嵌套定义，也即可以在一个函数中再定义另外一个函数（称为内部函数），如下

>>> def foo():
...     def bar():
...         print("foo.bar")
...     bar()
... 
>>> foo()
foo.bar
>>>

闭包：如果在一个内部函数里，对在外部作用域（非全局，如在外部函数中定义的）变量进行引用，那么这个内部函数就被称为闭包，如下

>>> def counter(start=0):
...     count = [start]
...     def inner():
...         count[0] += 1
...         return count[0]
...     return inner
... 
>>> c = counter()
>>> c()
1
>>> c()
2
>>>