python中序列（列表list和元组tuple）的用法

数据结构是以某种方式（如通过编号）组合起来的数据元素的集合。再python中最基本的数据结构为序列（sequence）。序列中的元素是有序的，索引从0开始，用负索引表示序列末尾元素的位置。

python中常见的序列有两种：列表和元组。二者主要的不同点在于：列表是可以修改的，元组是不可修改的。因此元组适用于一下两种情况：① 出于某种考虑需要禁止修改序列的情形；② 将元组用作字典的键（不允许修改）。

1 通用的序列操作

   1.1 索引

序列中所有元素都有编号——从0开始递增。

>>> greeting = 'Hello'    
>>> greeting[0]     # 索引0指向第一个元素
'H'
>>> greeting[-1]    # 索引-1指向从后数第一个元素
'o'

注：字符串本质上是由字符组成的序列。

# 将以数指定年、月、日的日期打印出来
months = ['January', 'February', 'March', 'April', 'June',
          'July', 'August', 'September', 'October', 'November', 'December']

# 一个列表，其中包含数1-31对应的结尾
endings = ['st', 'nd', 'rd'] + 17 * ['th'] + ['st', 'nd', 'rd'] + 17 * ['th'] + ['st']

year = input('Year:')
month = input('Month(1-12):')
day = input('Day(1-31):')

month_number = int(month)
day_number = int(day)

# 表示月和日的数字-1才得到正确的索引
month_name = months[month_number - 1]
ordinal = day + endings[day_number - 1]

print(month_name + ' ' + ordinal + ',' + year)


/'''
运行结果：
Year:2018
Month(1-12):8
Day(1-31):6
September 6th,2018
'''/

   1.2 切片

除了使用索引来访问单个元素外，还可以使用切片（slicing）来访问特定范围内的元素。切片传入参数为两个索引和一个步长值，均用冒号隔开。例如：[m: n: d]则获取的是下标在[m, n-1)的元素从m开始每d个取出一个，不包含下标为n的元素。其中，若m不写则表示从头开始，若n不写则表示到序列结束，若d不写（第二个：也不写）默认步长为1。同样在此处，索引也可以为负值。

url = 'http://www.python.org'
domain1 = url[:]
domain2 = url[: -4]
domain3 = url[11:]
domain4 = url[11: -4]
domain5 = url[11: -4: 2]

print('Domain1 name:', domain1)
print('Domain2 name:', domain2)
print('Domain3 name:', domain3)
print('Domain4 name:', domain4)
print('Domain5 name:', domain5)


/'''
运行结果：
Domain1 name: http://www.python.org
Domain2 name: http://www.python
Domain3 name: python.org
Domain4 name: python
Domain5 name: pto
'''/

  1.3 序列相加

可以使用加法运算符将两个序列拼接起来，但不能拼接不同类型的序列。

>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
>>> 'Hello,' + 'world!'
'Hello,world!'

   1.4 乘法

将序列与某个数x相乘，则这个序列将重复x次创建出一个新的序列。

>>> 'python' * 5
'pythonpythonpythonpythonpython'
>>> [42] * 10
[42, 42, 42, 42, 42, 42, 42, 42, 42, 42]

sentence = "He's a very naughty boy!"

screen_width = 80
text_width = len(sentence)
box_width = text_width + 6
left_margin = (screen_width - box_width) // 2

print(' ' * left_margin + '+'   + '-' * (box_width - 2) +   '+')
print(' ' * left_margin + '|  ' + ' ' *    text_width   + '  |')
print(' ' * left_margin + '|  ' +           sentence    + '  |')
print(' ' * left_margin + '|  ' + ' ' *    text_width   + '  |')
print(' ' * left_margin + '+'   + '-' * (box_width - 2) +   '+')


/'''
运行结果：
                         +----------------------------+
                         |                            |
                         |  He's a very naughty boy!  |
                         |                            |
                         +----------------------------+
'''/

   1.5 成员资格

要检查特定的值是否包含在序列中，可使用运算符in，存在时返回True，否则返回False，因此这样的运算符称为布尔运算符。

>>> permissions = 'rw'
>>> 'w' in permissions
True
>>> 'x' in permissions
False
>>> users = ['mlh', 'foo', 'bar']
>>> input('Enter your user name:') in users
Enter your user name: mlh
True
>>> subject = '$$$ Get rich now!!! $$$'
>>> '$$$' in subject
True

2. 列表list

   2.1 list函数

将任何序列转为list

>>> list('Hello')
['H', 'e', 'l', 'l', 'o']

   2.2 修改列表：给元素赋值

通过索引表示法给特定位置的元素赋值。

>>> x = [1, 1, 1]
>>> x[1] = 2
>>> x
[1, 2, 1]

   2.3 删除元素

>>> names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl']
>>> del names[2]
>>> names
['Alice', 'Beth', 'Dee-Dee', 'Earl']

   2.4 给切片赋值

① 替换成长度于其不同的序列

>>> name = list('Perl')
>>> name[1:] = list('ython')
>>> name
['P', 'y', 't', 'h', 'o', 'n']

② 插入新元素

>>> numbers = [1, 5]
>>> numbers[1:1] = [2, 3, 4]
>>> numbers
[1, 2, 3, 4, 5]

③ 删除元素

>>> numbers = [1, 2, 3, 4, 5]
>>> numbers[1: 4] = []
>>> numbers
[1, 5]

   2.5 append追加

>>> lst = [1, 2, 3]
>>> lst.append(4)
>>> lst
[1, 2, 3, 4]

   2.6 clear清除列表

>>> lst = [1, 2, 3]
>>> lst.clear()
>>> lst
[]

   2.7 copy赋值列表

>>> a = [1, 2, 3]
>>> b = a.copy()
>>> b[1] = 4
>>> a
[1, 2, 3]
>>> b
[1, 4, 3]

   2.8 count统计指定元素出现次数

>>> ['to', 'be', 'or', 'not', 'to', 'be'].count('to')
2
>>> x = [[1, 2], 1, 1, [2, 1, [1, 2]]]
>>> x.count(1)
2
>>> x.count([1, 2])
1

   2.9 extend将多个值追加

# 使用一个列表进行扩展
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6]

# 返回一个新的序列，效率低
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a + b
[1, 2, 3, 4, 5, 6]
>>> a
[1, 2, 3]

   2.10 index查找指定值第一次出现的索引

>>> knights = ['We', 'are', 'the', 'knights', 'who', 'say', 'ni']
>>> knights.index('who')
4
>>> knights[4]
'who'

注：若查找不在列表中的值，将会报错

   2.11 insert插入新的元素

>>> numbers = [1, 2, 3, 5, 6, 7]
>>> numbers.insert(2, 'four')
>>> numbers
[1, 2, 3, 'four', 5, 6, 7]

   2.12 pop删除一个元素并返回该元素

>>> x = [1, 2, 3]
>>> x.pop()    # 无参情况下，删除最后一个
3
>>> x
[1, 2]
>>> x.pop(0)
1
>>> x
[2]

用该方法可以实现栈（stack），实现后进先出（LIFO）

   2.13 remove删除第一个为指定值的元素

>>> x = ['to', 'be', 'or', 'not', 'to', 'be']
>>> x.remove('be')
>>> x
['to', 'or', 'not', 'to', 'be']

注：只能删除列表中存在的元素，若删除一个列表不存在的元素会报错。

   2.14 reverse反序

>>> x = [1, 2, 3]
>>> x.reverse()
>>> x
[3, 2, 1]

   2.15 sort排序

# sort()排序，无返回值
>>> x = [4, 6, 2, 1, 7, 9]
>>> x.sort()    # 正序排序
>>> x
[1, 2, 4, 6, 7, 9]
>>> x.sort(reverse=True)    # 倒序排序
>>> x
[9, 7, 6, 4, 2, 1]

# sorted()排序，有返回值
>>> y = sorted(x)    # 正序排序
>>> y
[1, 2, 4, 6, 7, 9]
>>> x
[9, 7, 6, 4, 2, 1]

   2.16 高级排序

用关键字参数按名称指定，key的值为排序的函数值。不会直接使用这个函数来判断一个元素是否大于另一个元素，而是使它来为每一个元素创建一个键，在根据这些键对元素进行排序。下面的例子将根据长度对元素进行排序。

>>> x = ['aardvark', 'abalone', 'acme', 'add', 'aerate']
>>> x.sort(key=len)
>>> x
['add', 'acme', 'aerate', 'abalone', 'aardvark']

3 元组：不可修改的序列

其实元组和列表的性质相同，唯一的差别是不能修改。其语法是用（）括起，元素之间用“,”隔开；当只有一个值时，必须在最后加一个“,”。

和列表有list()函数一样，元素有tuple()函数，将其他序列转换为元组。

# 创建元组
>>> 1, 2, 3
(1, 2, 3)
>>> (1, 2, 3)
(1, 2, 3)
# 长度为一的元组
>>> 42
42
>>> 42,
(42, )
>>> (42, )
(42, )
>>> 3 * (40 + 2)
126
>>> 3 * (40 + 2, )
(42, 42, 42)
>>> tuple([1, 2, 3])    # 将列表转为元组
(1, 2, 3)
>>> tuple('abc')        # 将字符串转为元组
('a', 'b', 'c')
>>> x = 1, 2, 3
>>> x[1]                # 根据索引取值
2
>>> x[1:2]              # 切片
(1, 2)