'python 2.7学习笔记(2)'

发表于 | 分类于 | 阅读次数：

[TOC]

函数

abs(x) 求绝对值的函数

cmp(x,y) 比较函数，如果x<y，返回-1，如果x==y，返回0，如果x>y，返回1

定义函数 def

定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

1
2
3
4
5
def myabs(x):
    if x>0:
        return x
    else:
        return -x

空函数 占位符
如果想定义一个什么事也不做的空函数，可以用pass语句

1
2
def nop():
    pass

返回多个值

1
2
3
4
5
6
import math

def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny
1
2
3
>>> x, y = move(100, 100, 60, math.pi / 6)
>>> print x, y
151.961524227 70.0

但其实这只是一种假象，Python函数返回的仍然是单一值tuple

1
2
3
>>> r = move(100, 100, 60, math.pi / 6)
>>> print r
(151.96152422706632, 70.0)

参数问题

默认参数 必须指向不变对象
1
2
3
4
5
6
7
8
9
10
11
def power(x,n=2):
    s=1
    while n>0:
        n=n-1
        s=s*x
    return s
    
>>> power(5)
25
>>> power(5, 2)
25

设置默认参数时，有几点要注意：
一是必选参数在前，默认参数在后，否则Python的解释器会报错（思考一下为什么默认参数不能放在必选参数前面）；
二是如何设置默认参数。当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。

可变参数

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

1
2
3
4
5
def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

1
2
3
4
>>> calc(1, 2)
5
>>> calc()
0

如果参数是list或者tuple的话，可以在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去

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

关键字参数

允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

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

1
2
3
4
5
6
>>> person('Michael', 30)
name: Michael age: 30 other: {}
>>> 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'}

如果先组装出一个dict，我们可以通过如下方式传入参数

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

参数组合

以上四种参数，可以单一使用，也可以组合使用，但是参数定义的顺序必须如下：必选参数，默认参数，可变参数，关键字参数

1
2
def func(a,b,c=0,*args,**kw):
    print 'a=',a,'b=',b,'c=',c,'args=',args,'kw = ',kw
1
2
3
4
5
6
7
8
>>> 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}
1
2
3
4
>>> args = (1, 2, 3, 4)
>>> kw = {'x': 99}
>>> func(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'x': 99}

递归函数

1
2
3
4
5
def fact(n):
    if n==1:
        return 1
    else:
        return n*fact(n-1)

使用递归函数要注意防止栈溢出。函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

解决递归调用栈溢出的方法是通过 尾递归 优化
尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

1
2
3
4
5
6
7
8
def fact(n):
    fact_item(n,1)

def fact_item(num,ret):
    if num==1:
        return ret
    else:
        return fact_item(num-1,ret*num)

注意：Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。