《python核心编程》：6--列表

列表为容器存储，可变类型，顺序访问。

列表中的元素可以为任意对象，而且各个元素可以为不同对象。

创建列表

>>> a = []
>>> a
[]                                                # 空列表
>>> b = [1,2,'ab',a]
>>> b
[1, 2, 'ab', []]                                  # 列表元素可以为不同对象
>>> list('fxxkGFW')
['f', 'x', 'x', 'k', 'G', 'F', 'W']               # 可以用工厂函数list来创建列表
>>> list(('hi', 'ha'))                            # 将一个元组创建为列表
['hi', 'ha']
>>>

访问与更新列表

切片方式访问。

删除列表

>>> b = [1, 2, 'ab', a]
>>> del b[3]                               # 删除列表元素
>>> b
[1, 2, 'ab']
>>> del b                                  # 删除列表
>>> b
Traceback (most recent call last):
  File "", line 1, in <module>
NameError: name 'b' is not defined
>>>

操作符

标准类型操作符

关系操作符，逻辑操作符

序列类型操作符

切片操作符（[],[:]） 成员关系（in，not in） 连接操作符（+） 重复操作符（*）

>>> a = [3.2, 1.3j, ['a', 223], 3e-10]
>>> a
[3.2000000000000002, 1.3j, ['a', 223], 3e-10]
>>> 'a' in a
False
>>> 'a' in a[2]                    # 成员关系操作，判断元素是否在列表中
True
>>> a+a[2]                       # 连接操作符+， 连接两个列表
[3.2000000000000002, 1.3j, ['a', 223], 3e-10, 'a', 223]
>>> a                              # 上面的连接操作没有改变a的值
[3.2000000000000002, 1.3j, ['a', 223], 3e-10]
>>> a+'hello'                    # 连接操作只能在同类型中进行
Traceback (most recent call last):
  File "", line 1, in <module>
TypeError: can only concatenate list (not "str") to list
>>> [3,'a'] * 3                    # 重复操作符，性质与连接操作符类似
[3, 'a', 3, 'a', 3, 'a']

列表类型操作符，列表解析

Python中没有专用于列表的操作符。

内建函数

标准类型内建函数

cmp()

列表的元素可以包含任意类型的对象，因此比较操作比较复杂。

1：对两个列表的元素进行比较

2：若两个元素类型相同，则比较其值，结果不等，则返回结果

3：若两个元素类型不同，则检测是否都为数字

   i）是，则按数字比较的规则比较

  ii）一个为数字，则非数字的元素“大”，（数字是“最小的”）

 iii）都不为数字，则比较两个元素的类型的名字，即比较两个名字的字符串

4：如果一个列表首先达到末尾，则另一个列表“大”

5：如果所有元素都比较完，而且每个元素都相等，则两个列表相等，返回0.

序列类型内建函数

len() : 返回列表元素个数

min(), max()：返回最小和最大的元素

sorted()：将列表元素排序后输出，并不改变原列表    返回列表

reversed()：将列表中元素逆序输出，并不改变原列表    返回迭代器

numerate()：返回迭代器

zip()：返回列表

sum()

list(), tuple()

列表类型的内建方法  （突然觉得这里用内建方法的说法会更准确）

此即列表的方法了，用object.attribute的方式访问。

可以用dir(obj)的方法来查看相应对象的方法和属性

list.append(obj)                  像列表中添加元素

list.count(obj)                   返回对象obj在列表中出现的次数

list.extend(seq)                  将一个序列seq添加到列表中

list.index(obj, i=0,j=len(list))  返回list[k] == obj的k值，即obj在list中的位置。

list.insert(index, obj)           在index的位置插入对象obj

list.pop(index=-1)                删除并返回指定位置的对象，默认为最后一个。

list.remove(obj)                  删除对象obj

list.reverse()                    原地翻转列表

list.sort(cmp=None,key=None,reverse=False) 以指定方式排序列表成员

书上有两个例子，用列表来实现堆栈和列表。我简单写了个，如下：

     

#!/usr/bin/env python

def push(stack, obj):
    stack.append(obj);

def pop(stack):
    if not isempty(stack):
        return stack.pop()
    else:
        print "pop: stack empty!"

def isempty(stack):
    return not bool(stack)

def test_stack():
    stack = []
    push(stack, 1);
    push(stack, 2);
    print stack
    pop(stack)
    print stack
    print pop(stack)
    print isempty(stack)

def enQueue(queue, obj):
    queue.append(obj)

def delQueue(queue):
    if not isemptyQ(queue):
        return queue.pop(0);
    else:
        print "delQueue: queue empty!"

def isemptyQ(queue):
    return not bool(queue)

def testQueue():
    queue = []
    enQueue(queue, 'a')
    enQueue(queue, 'b')
    enQueue(queue, 'c')
    print queue
    print delQueue(queue)
    print isemptyQ(queue)

if __name__ == '__main__':
    test_stack()
    print 'queue\n'
    testQueue()

写这玩意还是要有实例，每次应该加个完整的程序进来。   

这书到是挺好，各种操作符，各种内建函数都区分的很清楚。以前没发现。