Python基礎：序列

1、概述

序列類型（Sequence Types）相似於C中的數組，它是包含一組成員的連續列表，這些成員緊鄰排列，而且能夠經過序號（下標偏移量）訪問其中的一個或多個成員。序列類型的示意圖以下所示：

Python中最核心的序列類型共有3種：字符串（str和unicode）、列表（list）和元組（tuple）。

2、操做

序列類型支持的主要操做以下：

操做	說明
s[i]	s中第i個成員（從0開始）
s[i:j]	s中從i到j的切片
s[i:j:k]	s中從i到j的切片，步長爲k
s * n, n * s	s的n份（淺）拷貝的串聯
s + t	s與t的串聯
x in s	若是x是s的成員，爲True；不然，爲False
x not in s	若是x是s的成員，爲False；不然，爲True
enumerate(s)	返回一個enumerate對象，該對象生成由(i, s[i])組成的元組
len(s)	s的長度
list(iter)	把可迭代對象轉換爲列表
max(s)	s中的最大值
min(s)	s中的最小值
reversed(s)	返回一個迭代器，訪問該迭代器獲得的序列與s逆序
sorted(s)	返回一個列表，該列表是對s排序後的結果
str(obj)	把對象轉換爲字符串（對象的字符串表示）
sum(s[, start])	s中成員與start的總和（只能用於數值列表或數值元組，字符串用''.join(s)）
tuple(iter)	把可迭代對象轉換爲元組
unicode(obj)	把對象轉換爲Unicode字符串（使用默認編碼）
zip(s1, s2, ...)	返回一個列表：[(s1[0], s2[0], ...), (s1[1], s2[1], ...), ...]

以上操做的示例以下：

>>> s = 'abcedf'
>>> l = [0, 1, 2, 3, 4, 5]
>>> t = tuple(l)
>>> 
>>> s[0], l[0], t[0]
('a', 0, 0)
>>> s[2:5], l[2:5], t[2:5]
('ced', [2, 3, 4], (2, 3, 4))
>>> s[2:5:2], l[2:5:2], t[2:5:2]
('cd', [2, 4], (2, 4))
>>> s * 2, 2 * s
('abcedfabcedf', 'abcedfabcedf')
>>> list(s) + l
['a', 'b', 'c', 'e', 'd', 'f', 0, 1, 2, 3, 4, 5]
>>> 6 in l, 6 not in l
(False, True)
>>> 
>>> for i, x in enumerate(s):
...     print i, x
... 
0 a
1 b
2 c
3 e
4 d
5 f
>>> len(s), len(l), len(t)
(6, 6, 6)
>>> max(s), min(s)
('f', 'a')
>>> for x in reversed(t):
...     print x,
... 
5 4 3 2 1 0
>>> sorted([7, 4, 8, 0, 9])
[0, 4, 7, 8, 9]
>>> str(t)
'(0, 1, 2, 3, 4, 5)'
>>> unicode(l)
u'[0, 1, 2, 3, 4, 5]'
>>> sum(t), sum(t, 5)
(15, 20)
>>> zip(s, l, t)
[('a', 0, 0), ('b', 1, 1), ('c', 2, 2), ('e', 3, 3), ('d', 4, 4), ('f', 5, 5)]

3、切片

一、[]

「[]」用於訪問序列中的單個元素，如能夠用s[i]訪問序列s中的第i個元素，其中對i的取值範圍有如下限制：

• 若是i非負，則i必須在[0, N-1]範圍內，不然訪問會引起越界異常
• 若是i爲負，則i必須在[-N, -1]範圍內，不然訪問會引起越界異常

以上描述中，N=len(s)即序列的長度。

序列的 下標編號規則 參考『概述』一節中的「序列類型示意圖」，實際上，對於序列s而言：

• i非負時，Python使用s[i]去訪問序列
• i爲負時，Python使用s[N+i]去訪問序列

「[]」的操做示例以下：

>>> s = 'abcdef' # N=len(s)等於6，所以非負i的範圍[0, 5]，負i的範圍[-6, -1]
>>> 
>>> s[0] # 0非負，且0在[0, 5]範圍內
'a'
>>> 
>>> s[6] # 0非負，但6>5，越界異常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range
>>> 
>>> s[-1] # -1爲負，且-1在[-6, -1]範圍內
'f'
>>> 
>>> s[-7] # -7爲負，但-7<-6，越界異常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

二、[:]和[::]

「[:]」和「[::]」用於訪問序列中的多個元素（又稱切片，slice），由於在功能上「[:]」徹底能夠看做是「[::1]」（即步長爲1）的簡寫，因此理解「[::]」是掌握切片操做的關鍵。

切片s[i:j:k]是一個子序列，它由序列s中下標在 [i, j)（左閉右開區間）範圍內的一些成員構成，這些成員的下標分別爲i, i+k, i+2*k, ...。

在切片操做中，i、j、k的取值有如下特色（具體細節能夠參考 Python2.7.5源碼 的Python-2.7.5/Objects/sliceobject.c中的PySlice_GetIndicesEx函數）：

• k不能爲0；省略k或k爲None時，令k=1
• k爲正時
  • 若是省略i或i爲None，則令i=0
  • 若是省略j或j爲None，則令j=N
  • 若是i爲負，則令i=i+N，此時若是i仍然爲負，則令i=0；j相似
  • 若是i大於等於N，則令i=N；j相似
• k爲負時
  • 若是省略i或i爲None，則令i=N-1
  • 若是省略j或j爲None，則令j=-1
  • 若是i爲負，則令i=i+N，此時若是i仍然爲負，則令i=-1；j相似
  • 若是i大於等於N，則令i=N-1；j相似

特別地，通過上述計算後，若是i、j、k的最終取值知足如下狀況，則切片s[i:j:k]對應的子序列爲空：

• k爲正，且i大於等於j
• k爲負，且i小於等於j

「[:]」和「[::]」的操做示例以下：

>>> s = 'abcdef' # N=len(s)等於6

# 1. 省略k或k爲None時，k=1
>>> s[0:4], s[0:4:None], s[0:4:1]
('abcd', 'abcd', 'abcd')

# 2. k爲正時
>>> s[:2] # 省略i時，令i=0，所以s[:2]等價於s[0:2]
'ab'
>>> s[2:] # 省略j時，令j=N，所以s[2:]等價於s[2:6]
'cdef'
>>> s[2:-1] # j爲負時，令j=-1+N，所以s[2:-1]等價於s[2:5]
'cde'
>>> s[2:-10] # j爲負時，j=-10+N等於-4仍然爲負，令j=0，所以s[2:-10]等價於s[2:0]
''
>>> s[10:2] # i大於N時，令i=N，所以s[10:2]等價於s[6:2]
''

# 3. k爲負時
>>> s[:2:-1] # 省略i時，令i=N-1，所以s[:2:-1]等價於s[5:2:-1]
'fed'
>>> s[2::-1] # 省略j時，令j=-1，所以s[2::-1]的成員爲s[2]、s[1]、s[0]，但不等價於s[2:-1:-1]
'cba'
>>> s[2:-1:-1] # j爲負時，令j=-1+N，所以s[2:-1:-1]等價於s[2:5:-1]
''
>>> s[2:-10:-1] # j爲負時，j=-10+N等於-4仍然爲負，令j=-1，所以s[2:-10:-1]等價於s[2::-1]
'cba'
>>> s[10:2:-1] # i大於N時，令i=N-1，所以s[10:2:-1]等價於s[5:2:-1]
'fed'

>>> s, s[:], s[0:6], s[::], s[0:6:None], s[0:6:1] # 序列s的各類等價表示
('abcdef', 'abcdef', 'abcdef', 'abcdef', 'abcdef', 'abcdef')
>>> 
>>> s[::-1] # 序列s的逆序表示
'fedcba'