list

日常用法
__add__        x.__add__(y) <==> x+y
__class__       list() -> new list list(sequence) -> new list initialized from sequence's items
__contains__      x.__contains__(y) <==> y in x
__delattr__      x.__delattr__('name') <==> del x.name
__delitem__      x.__delitem__(y) <==> del x[y]
__delslice__       x.__delslice__(i, j) <==> del x[i:j] Use of negative indices is not supported.
__eq__       x.__eq__(y) <==> x==y
__ge__       x.__ge__(y) <==> x>=y
__getattribute__      x.__getattribute__('name') <==> x.name
__getitem__       x.__getitem__(y) <==> x[y]
__getslice__       x.__getslice__(i, j) <==> x[i:j] Use of negative indices is not supported.
__gt__     x.__gt__(y) <==> x>y
__hash__   x.__hash__() <==> hash(x)
__iadd__   x.__iadd__(y) <==> x+=y
__imul__   x.__imul__(y) <==> x*=y
__init__   x.__init__(...) initializes x; see x.__class__.__doc__ for signature
__iter__   x.__iter__() <==> iter(x)
__le__     x.__le__(y) <==> x<=y
__len__    x.__len__() <==> len(x)
__lt__     x.__lt__(y) <==> x__mul__    x.__mul__(n) <==> x*n
__ne__     x.__ne__(y) <==> x!=y
__new__    T.__new__(S, ...) -> a new object with type S, a subtype of T
__reduce__     helper for pickle
__reduce_ex__      helper for pickle
__repr__        x.__repr__() <==> repr(x)
__reversed__     L.__reversed__() -- return a reverse iterator over the list
__rmul__        x.__rmul__(n) <==> n*x
__setattr__       x.__setattr__('name', value) <==> x.name = value
__setitem__     x.__setitem__(i, y) <==> x[i]=y
__setslice__      x.__setslice__(i, j, y) <==> x[i:j]=y Use of negative indices is not supported.
__str__         x.__str__() <==> str(x)
append     L.append(object) -- append object to end
count      L.count(value) -> integer -- return number of occurrences of value
extend     L.extend(iterable) -- extend list by appending elements from the iterable
index      L.index(value, [start, [stop]]) -> integer -- return first index of value
insert     L.insert(index, object) -- insert object before index
pop        L.pop([index]) -> item -- remove and return item at index (default last)
remove     L.remove(value) -- remove first occurrence of value
reverse    L.reverse() -- reverse *IN PLACE*
sort       L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*; cmp(x, y) -> -1, 0, 1
 
list 的分片(slice)
>>> li
['a', 'b', 'mpilgrim', 'z', 'example']
>>> li[1:3] 
['b', 'mpilgrim']
>>> li[1:-1] 
['b', 'mpilgrim', 'z']
>>> li[0:3] 
['a', 'b', 'mpilgrim']
 
总的原则是“左包括，右不包括”
 
Slice简写
 
>>> li
['a', 'b', 'mpilgrim', 'z', 'example']
>>> li[:3] 
['a', 'b', 'mpilgrim']
>>> li[3:] 
['z', 'example']
>>> li[:] 
['a', 'b', 'mpilgrim', 'z', 'example']
 
extend与append的区别

>>> li = ['a', 'b', 'c']
>>> li.extend(['d', 'e', 'f'])
>>> li
['a', 'b', 'c', 'd', 'e', 'f']
>>> len(li)
6
>>> li[-1]
'f'
>>> li = ['a', 'b', 'c']
>>> li.append(['d', 'e', 'f'])
>>> li
['a', 'b', 'c', ['d', 'e', 'f']]
>>> len(li)
4
>>> li[-1]
['d', 'e', 'f']


从 list 中删除元素

>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']
>>> li.remove("new")
>>> li
['a', 'b', 'mpilgrim', 'example', 'new', 'two', 'elements']
>>> li.pop()
'elements'
>>> li
['a', 'b', 'mpilgrim', 'example', 'new', 'two']

remove仅仅删除一个值的首次出现

pop 是一个有趣的东西。它会做两件事: 删除 list 的最后一个元素, 然后返回删除元素的值。请注意, 这与 li[-1] 不同, 后者返回一个值但不改变 list 本身。也不同于 li.remove(value), 后者改变 list 但并不返回值。

 List 运算符

>>> li = ['a', 'b', 'mpilgrim']
>>> li = li + ['example', 'new']
>>> li
['a', 'b', 'mpilgrim', 'example', 'new']
>>> li += ['two']
>>> li
['a', 'b', 'mpilgrim', 'example', 'new', 'two']
>>> li = [1, 2] * 3
>>> li
[1, 2, 1, 2, 1, 2]

* 运算符可以作为一个重复器作用于 list。 li = [1, 2] * 3 等同于 li = [1, 2] + [1, 2] + [1, 2], 即将三个 list 连接成一个。

 连接List

>>> params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}
>>> ["%s=%s" % (k, v) for k, v in params.items()]
['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
>>> ";".join(["%s=%s" % (k, v) for k, v in params.items()])
'server=mpilgrim;uid=sa;database=master;pwd=secret'

";" 本身就是一个对象, 在调用它的 join 方法.

字符串与list互相转化

>>> li = 'server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
>>> s = ";".join(li)
>>> s
'server=mpilgrim;uid=sa;database=master;pwd=secret'
>>> s.split(";")
['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
>>> s.split(";", 1)
['server=mpilgrim', 'uid=sa;database=master;pwd=secret']

split 与 join 正好相反, 它将一个字符串分割成多元素 list。split 接受一个可选的第二个参数, 它是要分割的次数。

anystring.split(delimiter, 1) 是一个有用的用法, 在想要搜索一个子串, 然后处理字串前面的东西 (即 list 中第一个元素) 和其后的东西 (即 list 中第二个元素) 时, 可以使用这个用法。

list过滤

语法：[mapping-expression for element in source-list if filter-expression]

>>> li = ["a", "mpilgrim", "foo", "b", "c", "b", "d", "d"]
>>> [elem for elem in li if len(elem) > 1]
['mpilgrim', 'foo']
>>> [elem for elem in li if elem != "b"]
['a', 'mpilgrim', 'foo', 'c', 'd', 'd']
>>> [elem for elem in li if li.count(elem) == 1]
['a', 'mpilgrim', 'foo', 'c']

count 是一个列表方法，返回某个值在列表中出现的次数。