http://blog.csdn.net/pipisorry/article/details/39123103

函数的创建

当我们在Python里定义函数时发生了什么呢？

关键字def有两个功能：它可以创建一个函数对象，然后把这个函数对象赋值给一个变量（即我们的函数名）。

函数对象的属性

Python是面向对象的语言，在python中一切皆对象。函数属性以字典的形式存储的，键为属性名，值为属性内容。

函数的属性可以在定义函数时同时定义函数属性, 也可以在函数声明外定义函数属性。

可以通过句点标识符和直接赋值的方法为一个函数添加属性。
函数对象的 __dict__ 特殊属性包含了函数对象的属性和属性值。

print_header.category = 1和print_header.text = "some info"定义了两个函数属性。

通过print_header.__dict__可以查看函数属性。{'category': 1, 'text': 'some info'}

函数对象的code属性

所以，当我们编写：

def foo():

return "I'm foo!"

Python创造了一个新的函数对象。在这个函数对象里，我们可以看到字节码，元数（也就是参数数量）和一些与函数相关的其他东西。大多数这些东西存在于函数对象的__code__属性里。事实上，研究__code__是了解Python函数如何运行的最好办法。

例如，函数foo的元数是由foo.__code__.co_argcount获得，而字码节存在于foo.__code__.co_code中。

__code__对象的属性是只读，但是__code__属性本身不是！我们可以来做个恶作剧，在函数里进行“大脑移植”：

def foo():return "I'm foo!"def bar():return "I'm bar!"foo.__code__ = bar.__code__

现在，当我们运行foo()时，我们实际上运行的是被定义为bar的代码，然后我们会得到：

"I'm in bar!"

这可能不是你想要放进实际程序中的代码，但是它演示了__code__对象的一些功能。探索_code_对象是十分有趣的！

[Python function brain transplants]

皮皮blog

函数的参数

self参数

self在定义时需要定义，但是在调用时会自动传入。

self的名字并不是规定死的，但是最好还是按照约定是用self。self不必非写成self，可以是任意字符。

self总是指调用时的类的实例。self代表类的实例，而非类。

在继承时，传入的是哪个实例，就是那个传入的实例，而不是指定义了self的类的实例。

在描述符类中，self指的是描述符类的实例。

[一篇文章让你彻底搞清楚Python中self的含义]

python默认参数

python默认参数必须指向不变对象。

python默认参数使用不当，也会掉坑里：

错误使用示例1

先定义一个函数，传入一个list，添加一个END再返回：

def add_end(L=[]):L.append('END')return L

当你正常调用时，结果似乎不错：

>>> add_end([1, 2, 3])
[1, 2, 3, 'END']

当你使用默认参数调用时，一开始结果也是对的：

>>> add_end()
['END']

但是，再次调用add_end()时，结果就不对了：

>>> add_end()
['END', 'END']
>>> add_end()
['END', 'END', 'END']

很多初学者很疑惑，默认参数是[]，但是函数似乎每次都“记住了”上次添加了'END'后的list。

原因解释如下

Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。所以，定义默认参数要牢记一点：默认参数必须指向不变对象！

要修改上面的例子，我们可以用None这个不变对象来实现：

def add_end(L=None):if L is None:L = []L.append('END')return L

现在，无论调用多少次，都不会有问题：

>>> add_end()
['END']
>>> add_end()
['END']

错误使用示例2

def extendList(val, list = [ ]):

list.append(val)

return list

l1 = extendList(10)

l2 = extendList(123, [])

l3 = extendList('a')

print(l1, l2, l3)

结果是[10, 'a'], [123], [10, 'a']

修改正确：

def extend_list(val, list=None):

if not list:

list = []

list.append(val)

return list

这么理解吧，函数默认参数值为[]，在函数定义时就确定了，而名称list只是一个指向，初始时指向默认参数的值[]。
所以l1 = extendList(10)时，没有指定参数，则list指向并使用默认参数值[]，函数自执行完成默认参数变为[10]，l1指向默认参数值；
l2 = extendList(123, [])时，给定了参数[]，list指向用户给定的[](注意不是默认参数[])，所以l2很简单，就是[123]；
l3 = extendList('a')时，同样没有指定参数，则list指向并使用默认参数值[10]，函数执行完成默认参数变为[10, 'a']，所以l1和l2都指向新值[10, 'a']，这个也就是当前函数默认参数值。

函数传参是否会改变函数外参数的值

Python不允许程序员选择采用传值还是传引用。Python参数传递采用的肯定是“传对象引用”的方式。实际上，这种方式相当于传值和传引用的一种综合。如果函数收到的是一个可变对象（比如字典或者列表）的引用，就能修改对象的原始值——相当于通过“传引用”来传递对象。如果函数收到的是一个不可变对象（比如数字、字符或者元组）的引用，就不能直接修改原始对象——相当于通过“传值”来传递对象。

上面也就是说，当我们传的参数是int、字符串(string)、float、（数值型number）、元组（tuple) 时，无论函数中对其做什么操作，都不会改变函数外这个参数的值；

当传的是字典型(dictionary)、列表型(list)时，如果是重新对其进行赋值，则不会改变函数外参数的值，如果是对其进行操作，则会改变。即变量中存储的是引用 , 是指向真正内容的内存地址 , 对变量重新赋值 , 相当于修改了变量副本存储的内存地址 , 而这时的变量已经和函数体外的变量不是同一个了, 在函数体之外的变量 , 依旧存储的是原本的内存地址 , 其值自然没有发生改变。

示例

[]不能直接作为参数进行赋值操作，但是可以进行append操作。
a = []

def fun(b):
# b = [1, 2] # Parameter 'b' value is not used
b += [1, 2]
return b

fun(a)
print(a)

示例2

def get(s1, s2):
s1 = s1 + "haha"
s2 = "haha"

s1 = "abc"
s2 = "abc"
print(s1, s2)
get(s1, s2)
print(s1, s2)
# abc abc
# abc abc
可以看出，没有发生变化

为什么要设计str、None这样的不变对象呢？

因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。

此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有。我们在编写程序时，如果可以设计一个不变对象，那就尽量设计成不变对象。

函数普通参数及可迭代参数

需要明白的一点是python中“没有指针，但是所有对象均为指针”。

python 函数的参数传递：

不可变类型：类似 c++ 的值传递，如整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型：类似 c++ 的引用传递，如列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

如果参数是python可变类型list，dict等等（同c++数组），传入的相当于是指针地址，所以函数外的list也会变。

python函数参数如果传递的是元组（同c++结构体），则为值传递！

在C语言中，我们见到语句int a=8；这句话的意思是创建了一个对象a，a的值赋值为8。如果我们接下来写一句int b=a；实际上是创建了一个对象b，然后把a对象的值复制给b，注意是把a对应的值，不是a本身。如果要取得a本身的地址，需要用&a。

但是，在python中，以程序

import copy
a = [1, 2, 3, 4, ['a', 'b']] #原始对象
b = a #赋值，传对象的引用
c = copy.copy(a) #对象拷贝，浅拷贝
d = copy.deepcopy(a) #对象拷贝，深拷贝

为例，实际上先创建了一个对象 [1, 2, 3, 4, ['a', 'b']] ，然后把这个对象的地址赋值给a，语句b=a，可以看作b是a的一个别名。而c是对象的一个浅拷贝。

可变参数

位置参数：可变参数

在Python函数中，还可以定义可变参数。顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。

我们以数学题为例子，给定一组数字a，b，c……，请计算a2 + b2 + c2 + ……。

要定义出这个函数，我们必须确定输入的参数。由于参数个数不确定，我们首先想到可以把a，b，c……作为一个list或tuple传进来，这样，函数可以定义如下：

def calc(numbers):sum = 0for n in numbers:sum = sum + n * nreturn sum

但是调用的时候，需要先组装出一个list或tuple：>>> calc([1, 2, 3])

把函数的参数改为可变参数

def calc(*numbers):sum = 0for n in numbers:sum = sum + n * nreturn sum

定义可变参数和定义list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数：

>>> calc(1, 2)
>>> calc()

如果已经有一个list或者tuple，要调用一个可变参数怎么办？可以这样做：

>>> nums = [1, 2, 3]
>>> calc(nums[0], nums[1], nums[2])
14

使用 * 进行解构

这种写法当然是可行的，问题是太繁琐，所以Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去(而不是仅仅当成是一个list参数)：走接把一个数组带入，在带入时使用 * 进行解构。但要注意的是，不定长度的参数args在传递给函数时，需要先转换成元组tuple。这意味着，如果你将一个生成器作为参数带入到函数中，生成器将会先遍历一遍，转换为元组。这可能会消耗大量内存

>>> nums = [1, 2, 3]
>>> calc(*nums)
14

关键字参数

关键字参数可提高代码可读性
可以通过关键字参数给函数提供默认值
便于扩充函数参数

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。请看示例：

def person(name, age, **kw):print 'name:', name, 'age:', age, 'other:', kw

函数person除了必选参数name和age外，还接受关键字参数kw。在调用该函数时，可以只传入必选参数，也可以传入任意个数的关键字参数：

>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

关键字参数扩展函数的功能示例

比如，在person函数里，我们保证能接收到name和age这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。

和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去：

>>> kw = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, city=kw['city'], job=kw['job'])
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

当然，上面复杂的调用可以用简化的写法：

>>> kw = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **kw)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

定义只能使用关键字参数的函数

普通的方式，在调用时不会强制要求使用关键字参数

使用 Python3 中强制关键字参数的方式
# 定义一个方法，它的作用是遍历一个数组，找出等于(或不等于)目标元素的 index
def get_indexs(array, *, target='', judge=True):
    for index, item in enumerate(array):
        if judge and item == target:
            yield index
        elif not judge and item != target:
            yield index

array = [1, 2, 3, 4, 1]
# 这样可行
result = get_indexs(array, target=1, judge=True)
print(list(result)) # [0, 4]
# 也可以忽略有默认值的参数
result = get_indexs(array, target=1)
print(list(result)) # [0, 4]
# 但不指定关键字参数则报错
get_indexs(array, 1, True)
# TypeError: get_indexs() takes 1 positional argument but 3 were given

使用 Python2 中强制关键字参数的方式

# 定义一个方法，它的作用是遍历一个数组，找出等于(或不等于)目标元素的 index
# 使用 **kwargs，代表接收关键字参数，函数内的 kwargs 则是一个字典，传入的关键字参数作为键值对的形式存在
def get_indexs(array, **kwargs):
    target = kwargs.pop('target', '')
    judge = kwargs.pop('judge', True)
    for index, item in enumerate(array):
        if judge and item == target:
            yield index
        elif not judge and item != target:
            yield index

参数组合

在Python中定义函数，可以用必选参数、默认参数、可变参数和关键字参数，这4种参数都可以一起使用，或者只用其中某些。

请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数和关键字参数。

比如定义一个函数，包含上述4种参数：

def func(a, b, c=0, *args, **kw):print 'a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw

在函数调用的时候，Python解释器自动按照参数位置和参数名把对应的参数传进去。

>>> func(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
>>> func(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> func(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> func(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}

最神奇的是通过一个tuple和dict，你也可以调用该函数：

>>> args = (1, 2, 3, 4)
>>> kw = {'x': 99}
>>> func(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'x': 99}

所以，对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。