递归函数 ------- 在函数内部可以调用自身本身的函数
定义一个计算阶乘的函数fact(n)：
|
1
2
3
4
|
fact(n) = n!
= 1 x 2 x 3 x ... x (n-1) x n
= (n-1)! x n
= fact(n-1) x n
|
函数可以写为：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
>>> def fact(n):
if n==1:
return 1
return n*fact(n-1)
>>> fact(1)
1>>>fact(5)
120>>> fact(100)
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000 |
如果我们计算 fact(5)，可以根据函数定义看到计算过程如下：
|
1
2
3
4
5
6
7
8
9
10
|
===> 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(1000)：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
>>> fact(1000)
Traceback (most recent call last): File "<pyshell#40>", line 1, in <module>
fact(1000)
File "<pyshell#33>", line 4, in fact
return n*fact(n-1)
File "<pyshell#33>", line 4, in fact
return n*fact(n-1)
File "<pyshell#33>", line 4, in fact
return n*fact(n-1)
。。。
File "<pyshell#33>", line 4, in fact
return n*fact(n-1)
File "<pyshell#33>", line 2, in fact
if n==1:
RuntimeError: maximum recursion depth exceeded in comparison
|
切片
取一个list或tuple的部分元素：
（1）：
直接通过索引取值
|
1
2
3
|
>>> l=['xaioming','zhangsan','wangwu','xiaoxin','xaiohua']
>>> [l[0],l[1],l[2]]
['xaioming', 'zhangsan', 'wangwu']
|
（2）：
通过循环取值
|
1
2
3
4
|
>>> r=[]
>>> n=3
>>> for i in range(n):
r.append(l[i])
|
|
1
2
|
>>> r['xaioming', 'zhangsan', 'wangwu']
|
（3）：
通过切片：
|
1
2
|
>>> l[0:3]
['xaioming', 'zhangsan', 'wangwu']
|
l[0:3] 表示从索引0开始，知道索引3为止，但不包括索引3.即索引0,1,2，正好是3个元素。
如果第一个索引是0，还可以省略：
|
1
2
|
>>> l[:3]
['xaioming', 'zhangsan', 'wangwu']
|
也可以从索引1开始，取出2个元素出来：
|
1
2
|
>>> l[1:3]
['zhangsan', 'wangwu']
|
也可以倒数切片：
|
1
2
|
>>> l[-1]
'xaiohua' |
|
1
2
|
>>> l[-2:]
['xiaoxin', 'xaiohua']
|
创建一个0-99的数列：
|
1
2
3
|
>>> L = list(range(100))
>>> L[0, 1, 2, 3, ..., 99]
|
取前十个元素：
|
1
2
|
>>> L[:10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
后十个元素：
|
1
2
|
>>> L[-10:]
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
|
前11-20：
|
1
2
|
>>> L[11:20]
[11, 12, 13, 14, 15, 16, 17, 18, 19]
|
前10个数，，每两个取一个：
|
1
2
|
>>> L[0:10:2]
[0, 2, 4, 6, 8]
|
所有数，每5个取一个：
|
1
2
3
4
|
>>> L[0:100:5]
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]
>>> L[::5]
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]
|
|
1
2
|
>>> L[:][0, 1, 2, 3, ..., 99]
|
tuple也是一种list ，只是tuple不可变。tuple也可以切片：
|
1
2
|
>>> (0,1,2,3,4,5)[:3]
(0, 1, 2)
|
字符串 ‘xxxxx’也可以看做一个list，每个元素就是一个字符。因此，字符串也可以切片
|
1
2
3
4
|
>>> 'ABCDEFGHIKLMNOPQRST'[:3]
'ABC'>>> 'ABCDEFGHIKLMNOPQRST'[::2]
'ACEGILNPRT' |
迭代
给定一个list或tuple，我们通过for循环来遍历这个list或tuple，这种遍历我们称为 迭代(lteration)。
Python的for循环不仅可以用在list或tuple上，还可以作用在其他可迭代对象上。
list这种数据类型虽然有下标，但很多其他数据类型是没有下标的，但是，只要是可迭代对象，无论有无下标，都可以迭代，比如dict就可以迭代：
|
1
2
3
4
5
6
7
|
>>> d = {'a':1,'b':2,'c':3}
>>> for key in d:
print(key)
cba |
因为dict的储存不是按照list的方式顺序排列，所以，迭代出的结果顺序很可能不一样。
默认情况下，dict 迭代的是 key 。如果要迭代 value，可以用
|
1
|
for value in d.values()
|
如果要同时迭代key和value，可以用
|
1
|
for k,v in d.items()
|
由于字符串也是可迭代对象。因此，也可以作用与 for 循环:
|
1
2
3
4
5
6
7
|
>>> for ch in 'ABC':
print(ch)
ABC |
如何判断一个对象是可迭代对象呢？方法是通过collections模块的Iterable类型判断：
|
1
2
3
4
5
6
7
|
>>> from collections import Iterable
>>> isinstance('abc',Iterable)
True>>> isinstance([1,2,3],Iterable)
True>>> isinstance(123,Iterable)
False |
如果要对list实现类似于 c 语言 那样的下标循环怎么办？Python内置的 enumerate 函数 可以把一个list变成索引-元素对，这样就可以在 for 循环中同时迭代索引和元素本身：
|
1
2
3
4
5
6
|
>>> for i,value in enumerate(['A','B','C']):
print(i,value)
0 A
1 B
2 C
|
上面的for循环里，同时引用了两个变量，在Python里是很常见的，比如下面的代码：
|
1
2
3
4
5
6
|
>>> for x,y in [(1,1),(2,2),(3,3)]:
print(x,y)
1 1
2 2
3 3
|