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]
函数的参数
self参数
self在定义时需要定义,但是在调用时会自动传入。
self的名字并不是规定死的,但是最好还是按照约定是用self。self不必非写成self,可以是任意字符。
self总是指调用时的类的实例。self代表类的实例,而非类。
在继承时,传入的是哪个实例,就是那个传入的实例,而不是指定义了self的类的实例。
在描述符类中,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 = 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)的形式调用它,无论它的参数是如何定义的。
偏函数
[python模块 - functools模块:偏函数]
from:http://blog.csdn.net/pipisorry/article/details/39123103
ref: [函数的参数]