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

我们以自定义一个求绝对值的 my_abs 函数为例：

def my_abs(x):
    if x >= 0:
        return x    else:
        return -x

请注意，函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。因此，函数内部通过条件判断和循环可以实现非常复杂的逻辑。

如果没有return语句，函数执行完毕后也会返回结果，只是结果为 None。

return None可以简写为return。

通过例子:

def toUppers(L):
    return [x.upper() for x in L if isinstance(x, str)]
print toUppers(['Hello', 'world', 101])

参考答案:

L = [ x*(x+1) for x in range(1,101,2)]
print L

dict内部是无序的，不能用dict存储有序的集合。

加号是相同类型的输出，逗号是不同类型可以一起输出。所以可以用加号的一定可以用逗号，可以用逗号不一定可以用加号

Python之递归函数

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

举个例子，我们来计算阶乘 n! = 1 * 2 * 3 * ... * n，用函数 fact(n)表示，可以看出：

fact(n) = n! = 1 * 2 * 3 * ... * (n-1) * n = (n-1)! * n = fact(n-1) * n

所以，fact(n)可以表示为 n * fact(n-1)，只有n=1时需要特殊处理。

于是，fact(n)用递归的方式写出来就是：

def fact(n):     if n==1:         return 1     return n * fact(n - 1)

上面就是一个递归函数。可以试试：

>>> fact(1) 1 >>> fact(5) 120 >>> fact(100) 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000L

如果我们计算fact(5)，可以根据函数定义看到计算过程如下：

===> fact(5) ===> 5 * fact(4) ===> 5 * (4 * fact(3)) ===> 5 * (4 * (3 * fact(2))) ===> 5 * (4 * (3 * (2 * fact(1)))) ===> 5 * (4 * (3 * (2 * 1))) ===> 5 * (4 * (3 * 2)) ===> 5 * (4 * 6) ===> 5 * 24 ===> 120

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

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

Python函数之返回多值

函数可以返回多个值吗？答案是肯定的。

比如在游戏中经常需要从一个点移动到另一个点，给出坐标、位移和角度，就可以计算出新的坐标：

# math包提供了sin()和 cos()函数，我们先用import引用它：

import math def move(x, y, step, angle):     nx = x + step * math.cos(angle)     ny = y - step * math.sin(angle)     return nx, ny

这样我们就可以同时获得返回值：

>>> x, y = move(100, 100, 60, math.pi / 6) >>> print x, y 151.961524227 70.0

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

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

用print打印返回结果，原来返回值是一个tuple！

但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。

任务

一元二次方程的定义是：ax² + bx + c = 0

请编写一个函数，返回一元二次方程的两个解。

注意：Python的math包提供了sqrt()函数用于计算平方根。

• ?不会了怎么办

• 请参考求根公式：x = (-b±√(b²-4ac)) / 2a

  参考代码:

  import math def quadratic_equation(a, b, c):     t = math.sqrt(b * b - 4 * a * c)     return (-b + t) / (2 * a),( -b - t )/ (2 * a) print quadratic_equation(2, 3, 0) print quadratic_equation(1, -6, 5)

 参考答案:

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 74 }
sum =0.0
for item in d.items():
    sum+=item[1]
    print item[0]+':' , item[1]
print 'average:',sum/len(d)

参考答案:

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 74 }
sum = 0.0;
for score in d.values():
    sum += score;
print sum/len(d)

定义可变参数的目的是为了简化调用

如果想要传入任意个参数的话需要定义一个可变参数'*args',python将传入的一组参数组装成一个tuple传递给可变参数，在函数内部直接把变量args看作一个tuple就可以了

L = ['Adam', 'Lisa', 'Bart']
L.insert(0,L[2])
L[2]=L.pop(1)

Python中不使用临时变量替换元素

例子:

L = ['Adam', 'Lisa', 'Bart', 'Paul']
for t in enumerate(L):
    print t
    
for index, name in enumerate(L):
    print index, '-', name

结果:

(0, 'Adam')
(1, 'Lisa')
(2, 'Bart')
(3, 'Paul')
0 - Adam
1 - Lisa
2 - Bart
3 - Paul

结论:

可见，索引迭代也不是真的按索引访问，而是由 enumerate() 函数自动把每个元素变成 (index, element) 这样的tuple，再迭代，就同时获得了索引和元素本身。

参考答案:

L = ['Adam', 'Lisa', 'Bart', 'Paul']

for t in zip(range(1, len(L)+1), L):
    print t[0], '-', t[1]