python 之列表类型

python中的列表类型有list、tuple、set三种，但这里千万不可以忽略str，在python中str被理解为一种特殊的列表。

python中一切皆对象，列表支持包括字符，数字，字符串甚至可以是嵌套类型等所有的python对象。

Python 的列表与C语言中的数组访问方法相同，通过偏移地址访问。

基础篇

1、list

list 是列表类型中最为常用的类型，除此之外还有tuple和set，list中的元素是有序可重复的。

L = [1, 2, 3, 4] #初始化

L.append(x) #在列表尾部追加单个对象x，使用多个参数会引起异常
L.count(x) #返回对象x在列表中出现的次数
L.extend(L1) #将列表L1中的表项添加到列表中，返回None
L.Index(x) #返回列表中匹配对象x的第一个列表项的索引，无匹配元素时产生异常
L.insert(i, x) #在索引为i的元素前插入对象x，如list.insert(0,x)在第一项前插入对象，返回None
L.pop(x) #删除列表中索引为x的表项，并返回该表项的值，若未指定索引，pop返回列表最后一项
L.remove(x) #删除列表中匹配对象x的第一个元素，匹配元素时产生异常，返回None
L.reverse() #颠倒列表元素的顺序
L.sort() #对列表排序，返回none，bisect模块可用于排序列表项的添加和删除  

 

2、tuple

tuple在python中称为元组，tuple是不变的，这里说的不变，指的是tuple里面每个索引执行的对象地址不变（tuple内非基本类型对象可以改变，但是改变的只是该对象的内容，tuple指向该对象的指针不变）。

t = (1, 2, 3, 4) #初始化

t.count(x)  #计算x元素的个数
t.index(x)   #查找x所在的位置，从左往右

 

3、set

set称为集合，是一个无序不重复元素集, 内部以hash映射的方式存储， 基本功能包括关系测试和消除重复元素。
集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算。

并集、交集、差集和对称差集:

s1 = set([1, 2, 3])
s2 = set([2, 3, 4])

s1 | s2   #并集，即 set([1, 2, 3, 4])
s1 & s2   #交集，即 set([2, 3])
s1 - s2   #差集，即 set([1, ])
s1 ^ s2   #对称差集，存在于S1或S2但不同时存在，即 set([1, 4])

 

其他基本操作：

s.add(x) #当x不存在于s时增加x
s.remove(x) #当x存在于s时删除，否者引起异常
s.discard(x) #当x存在于s时删除
s.update(t)  #s |= t 增加另一个序列的所有元素
s.clear() #删除s中的所有元素
s.issubset(t)  #s <= t 是否 s 中的每一个元素都在 t 中    
s.issuperset(t)  #s >= t 是否 t 中的每一个元素都在 s 中    
s.union(t)  #s | t 返回一个新的 set 包含 s 和 t 中的每一个元素   
s.intersection(t)  #s & t 返回一个新的 set 包含 s 和 t 中的公共元素  
s.difference(t) #s - t 返回一个新的 set 包含 s 中有但是 t 中没有的元素  
s.symmetric_difference(t)  #s ^ t 返回一个新的 set 包含 s 和 t 中不重复的元素  
s.copy()  #返回 set “s”的一个浅复制  

 

4、list、tuple、set的一些公共操作

len(l)  #长度
x in l#x是否存在于列表
x not in l#x是否不存在于列表
max(l) #最大值，当列表中的元素可比较
min(l)  #最小值，当列表中的元素可比较

list(l)   #将任一列表类型强制转换，下同
tuple(l)
set(l)

 

进阶篇

接下来的内容只要以list作为例子，讲解列表中一些高级技巧。

1、列表遍历（list、set、tuple、str ）

普通遍历

 

>>> for x in range(5):
...     print x
0
1
2
3
4

 

带下标遍历

>>> l = [1, 2, 3, 4, 5]   
>>> for index, x in enumerate(l): 
...     print index, x
0 1
1 2
2 3
3 4
4 5

 

2、切片（list、tuple、str ）

字符串、列表、元组(set除外)在python中都符合“序列”这一特征，只要符合这一特征的变量我们都可以用切片(slice)去存取它们的任意部分。我们可以把序列想像成一个队列，可能需要前面三位、后面三位、或从第三位后的四位、或隔一个取一个等，我们用切片操作符来实现上述要求。

 

>>> l = [1, 2, 3, 4, 5]
>>> print l[1: 3]    #输出索引从1到3的元素
[2, 3]
>>> print l[1: ]      #输出索引从1到最后的元素，相当于l[1: len(l)]
[2, 3, 4, 5]
>>> print l[: 3]      #输出索引从开始到3的元素，相当于l[0: 3]
[1, 2, 3]
>>> print l[1: -3]   #输出索引1到倒数第三个之间的元素，元素个数小于3则报错。
[2]
>>> print l[0: len(l): 2] #以步进值为2输出元素
[1, 3, 5]
>>> print l[: : -1]          #以步进值为-1输出元素
[5, 4, 3, 2, 1]

 

3、列表解析（list、set、tuple、str ）

[expression for target1 in iterable1 [if condition1]...

                      for targetn in iterablen [if conditionn] ]

以上是列表解析的基本语法，其表示任意数量嵌套的for循环同时关联可选的if 测试，其中if 表示测试语句是可选的。

基本解析

>>> l = [1, 2, 3, 4, 5]
>>> [x for x in l] 
[1, 2, 3, 4, 5]

条件解析

>>> l = [1, 2, 3, 4, 5]
>>> [x for x in l if x%2 == 0] #当元素满足对2求余等于0 [2, 4]

嵌套解析

>>> [(x,y) for x in range(5) if x % 2==0 for y in range(5) if y % 2 ==1]
[(0, 1), (0, 3), (2, 1), (2, 3), (4, 1), (4, 3)]

 

>>> mat = [ (1, 2, 3),(4, 5, 6), (7, 8, 9)]
>>> [ [row[i] for row in mat] for i in range(3)]
[[1, 4, 7], [2, 5, 8], [3, 6, 9]]

 

4、列表排序(list)

当需要对一个列表排序时, 一般可以用 list.sort([cmp[, key[, reverse]]) 或者 sorted(iterable[, cmp[, key[, reverse]]])两种方式来实现。
其中:
cmp(e1, e2) 是带两个参数的比较函数, 返回值: 负数: e1 < e2, 0: e1 == e2, 正数: e1 > e2. 默认为 None, 即用内建的比较函数。
key 是带一个参数的函数, 用来为每个元素提取比较值. 默认为 None, 即直接比较每个元素。
reverse 是一个布尔值, 表示是否反转比较结果。

 

普通列表排序（适用于列表中所有元素都是可以比较的情况下）

 

>>> l = [1 , 2, 5, 4, 3]
>>> l.sort()     #直接排序
>>> print l
[1, 2, 3, 4, 5]

>>> sorted(l)  #通过内置函数sorted排序
[1, 2, 3, 4, 5]

 

按指定值排序

from operator import itemgetter, attrgetter

#元素为列表
>>> l = [('A', 'c', 3), ('C', 'b', 1), ('B', 'a', 2)]
>>> sorted(l, key=lambda x: x[0])
[('A', 'c', 3), ('B', 'a', 2), ('C', 'b', 1)]
#或者
>>> sorted(l, key=itemgetter(0))    
[('A', 'c', 3), ('B', 'a', 2), ('C', 'b', 1)]


#元素为字典
>>> l1 = [{'age': 3}, {'age': 1}, {'age': 2}]  
>>> sorted(l1, key=lambda x: x['age'])
[{'age': 1}, {'age': 2}, {'age': 3}]
#或者
>>> sorted(l1, key=itemgetter('age'))         
[{'age': 1}, {'age': 2}, {'age': 3}]

#注：以上的排序都可以通过l.sort()来相应实现

通过编写对比函数来实现

import datetime
from operator import itemgetter

#定义一个日期比较函数
def cmp_datetime(a, b):
    a_datetime = datetime.datetime.strptime(a, '%Y-%m-%d %H:%M:%S')
    b_datetime = datetime.datetime.strptime(b, '%Y-%m-%d %H:%M:%S')

    if a_datetime > b_datetime:
        return 1
    elif a_datetime < b_datetime:
        return -1
    else:
        return 0

l = []
l.append({'id': 2, 'create_time': '2010-1-8 11:00:20'})
l.append({'id': 3, 'create_time': '2010-3-10 11:00:20'})
l.append({'id': 1, 'create_time': '2010-1-1 11:00:20'})

print sorted(l, cmp=cmp_datetime, key=itemgetter('create_time'))
#[{'create_time': '2010-1-1 11:00:20', 'id': 1}, {'create_time': '2010-1-8 11:00:20', 'id': 2}, {'create_time': '2010-3-10 11:00:20', 'id': 3}]