Python -- 数据结构与包机制

列表

列表对象的方法：

• insert(i, x) —- 在指定位置插入一项。i是要在哪一个元素前面插入，用下标表示。
• append(x) —- 等价于a.insert(len(a), x)
• index(x) —- 在列表中查找值x然后返回第一个值为x的元素的下标。没有找到时出错。
• remove(x) —- 从列表中删去第一个值为x的元素，找不到时出错。
• sort() —- 对列表元素在原位排序。注意这个方法改变列表，而不是返回排序后的列表。
• reverse() —- 把列表元素反序。改变列表。
• count(x) —- 返回x在列表中出现的次数。

a = [66.6,32.3,456,456,789,12345.6]
print a.count(456),a.count(66.6),a.count(0)

a.insert(1,-1)
a.append(0)
print a
print a.count(0)

a.remove(0)
print a

a.reverse()
print a

a.sort()
print a

2 1 0
[66.6, -1, 32.3, 456, 456, 789, 12345.6, 0]
1
[66.6, -1, 32.3, 456, 456, 789, 12345.6]
[12345.6, 789, 456, 456, 32.3, -1, 66.6]
[-1, 32.3, 66.6, 456, 456, 789, 12345.6]

del

列表的remove()方法可以从列表中删去某个取值的项，我们还可以用del 语句来删除指定下标的项。也可以用del语句从列表中删除一个片断。

接上表a

del a[0]
print a

del a[2:4]
print a

del a

[32.3, 66.6, 456, 456, 789, 12345.6]
[32.3, 66.6, 789, 12345.6]

序表和序列

我们看到列表和字符串有许多共同点，例如，下标和片断运算。它们都属于序列数据类型。
现在还有一种标准的序列数据类型，称为序表（tuple）。
序表由一系列值用逗号分隔而成：

tup = 123,321,'hello','python'
print tup[0]
print tup
# 序表允许嵌套
up = tup,(1,2,3,4,5)
print up

123
(123, 321, 'hello', 'python')
((123, 321, 'hello', 'python'), (1, 2, 3, 4, 5))

序表有许多用处，例如，（x，y）坐标对，数据库中的职工纪录，等等。序表与字符串一样是不可变的：不允许对序表的某一项赋值。
生成序表时对0项或1项的序表有特殊的规定：空序表用一对空括号表示；只有一项的序表用一个之后面跟一个抖好表示（指把这个值放在括号内是不够的）。这样写不够美观，但很有效。
例：

empty = ()
singleton = 'python',
print len(empty)
print len(singleton)
print singleton

0
1
('python',)

还可以序表解包。序表解包要求等号左边的变量个数等于序表的长度。

a = ['apple','orange',99,42]
[a1,a2,a3,a4] = a

print a1,a2,a3,a4

字典

Python内置的另一个有用的数据类型是字典。和其他语言的字典用法一样。
注：列表不可以作为字典的键值使用。

函数程序设计工具

关于列表有三个非常有用的内置函数：filter(), map()和reduce()。

“filter(函数, 序列)”返回一个序列（尽可能与原来同类型），序列元素是原序列中由指定的函数筛选出来的那些，筛选规则是“函数(序列元素)=true”。filter()可以用来取出满足条件的子集。

“map(函数，序列)”对指定序列的每一项调用指定的函数，结果为返回值组成的列表。map() 可以对序列进行隐式循环。可以有多个序列作为自变量，这时指定的函数必须也有相同个数的自变量，函数从每个序列分别取出对应元素作为自变量进行调用（如果某个序列比其它的短则取出的值是None）。如果指定的函数是None，map()把它当成一个返回自己的自变量的恒同函数。在函数用None的情况下指定多个序列可以把多个序列搭配起来，比如“map(None, list1, list2)”可以把两个列表组合为一个成对值的列表。

“reduce(函数, 序列)”用来进行类似累加这样的操作，这里的函数是一个两个子变量的函数，reduce()先对序列的前两项调用函数得到一个结果，然后对结果和序列下一项调用函数得到一个新结果，如此进行到序列尾部。

例：

def func(x):
    return x % 2 != 0 and x % 3 != 0
print filter(func,range(2,40))
[5, 7, 11, 13, 17, 19, 23, 25, 29, 31, 35, 37]

def cube(x):
    return x*x*x
print map(cube,range(1,10))
[1, 8, 27, 64, 125, 216, 343, 512, 729]

seq = range(8)
def square(x):
    return x*x
print map(None,seq,map(square,seq))
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49)]

def add(x,y):
    return x+y
print reduce(add,range(1,10))
45

包机制

模块：模块是包含了Python定义和语句的文件。文件名由模块名加上后缀“.py”构成。模块中的定义可以导入其它模块或主模块。
例：

def fib(n):    # 输出小于n的Fibonacci序列 
    a, b = 0, 1 
    print a
    while b < n: 
        print b, 
        a, b = b, a+b 

在另外一个模块中要调用这个fib函数

import fibo
print fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 

除了可以导入一个模块外，我们还可以导入某个模块的具体函数

例如上面：

from fibo import fib
fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 

也可以导入模块中的全部方法

from fibo import *
fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 

module可以定义在包里面.Python定义包的方式稍微有点古怪,假设我们有一个parent文件夹,该文件夹有一个child子文件夹.child中有一个module fibo.py . 如何让Python知道这个文件层次结构?很简单,每个目录都放一个名为_init_.py 的文件.该文件内容可以为空.这个层次结构如下所示: 

    parent 
      --__init_.py
      --child
          -- __init_.py
          --fibo.py
    b.py

那么Python如何找到我们定义的module?在标准包sys中,path属性记录了Python的包路径.你可以将之打印出来:

import sys
print sys.path

通常我们可以将module的包路径放到环境变量PYTHONPATH中,该环境变量会自动添加到sys.path属性.另一种方便的方法是编程中直接指定我们的module路径到sys.path 中:

import sys
from fibo import fib
fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377