python函数 - 函数创建，及函数属性和函数参数

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']，这个也就是当前函数默认参数值。

为什么要设计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是对象的一个浅拷贝。

#!/usr/bin/env python3
# coding=utf-8
def func(list1):
    list1 += [1]
list2 = [1,2,3]
func(list2)
print(list2)

[1,2,3,1]

皮皮blog

可变参数

位置参数：可变参数

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

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

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

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

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

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

def calc(*numbers): sum = 0 for n in numbers: sum = sum + n * n return 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

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

参数组合

在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)的形式调用它，无论它的参数是如何定义的。

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

ref: [函数的参数]

转载于:https://my.oschina.net/u/3579120/blog/1508587