1、序列

1.1、什么是序列

• 数据结构是以某种方式（如通过编号）组合起来的数据元素（如数、字符乃至其他数据结构）集合。在Python中，最基本的数据结构为序列（sequence）。
• 序列中的每个元素都有编号，即其位置或索引，其中第一个元素的索引为0。用负索引表示序列末尾元素的位置。
• 序列包含三种：列表、元组、字符串。
• 容器：

序列：（如列表和元组）在序列中，每个元素都有编号

• • • 列表：可以修改的序列
    • 元组: 不可以修改的序列
    • 字符串：不可以修改的序列

映射：（如字典）在映射中，每个元素都有名称（也叫键）

• 序列还可包含其他序列。

>>> edward = [‘Edward Gumby‘, 42]
>>> john = [‘John Smith‘, 50]
>>> database = [edward, john]
>>> database
[[‘Edward Gumby‘, 42], [‘John Smith‘, 50]]

• 内置函数len、min和max很有用，其中函数len返回序列包含的元素个数，而min和max分别返回序列中最小和最大的元素

1.2、序列的基本操作

索引、切片、相加、相乘和成员资格检查。

1、索引

• 使用索引来访问单个元素
• 序列中的所有元素都有编号——从0开始递增。

>>> greeting = ‘Hello‘
>>> greeting[0]
‘H‘

• 用负数索引时，Python将从右（即从最后一个元素）开始往左数，因此-1是最后一个元素的位置。

>>> greeting[-1]
‘o‘

• 对于字符串字面量（以及其他的序列字面量），可直接对其执行索引操作，无需先将其赋给变量。

>>> ‘Hello‘[1]
‘e‘

• 如果函数调用返回一个序列，可直接对其执行索引操作。

>>> fourth = input(‘Year: ‘)[-4]
Year: 2005
>>> fourth
‘2‘

2、切片

• 使用切片（slicing）来访问特定范围内的元素，可使用两个索引，并用冒号分隔。
• 第一个索引指定的元素包含在切片内，但第二个索引指定的元素不包含在切片内。
• 对序列执行切片操作时，返回的切片都是副本。

>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[3:6] 
[4, 5, 6]

(1）简写

• 如果切片结束于序列末尾，可省略第二个索引。

>>> numbers[-3:]
[8, 9, 10]

• 如果切片始于序列开头，可省略第一个索引。

>>> numbers[:3]
[1, 2, 3]

• 要复制整个序列，可将两个索引都省略。

>>> numbers[:]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

(2）步长

• [开始索引：结束索引：步长]

>>> numbers[0:10:2]
[1, 3, 5, 7, 9]

• 显式地指定步长时，也可以使用简写。

>>> numbers[::4]
[1, 5, 9]

• 步长不能为0，否则无法向前移动，但可以为负数，即从右向左提取元素。
• 步长为负数时，第一个索引必须比第二个索引大，第一个索引依然包含在内，而第二个索引不包含在内。
• 步长为正数时，它从起点移到终点，而步长为负数时，它从终点移到起点。　　

>>> numbers[8:3:-1]
[9, 8, 7, 6, 5]
>>> numbers[10:0:-2]
[10, 8, 6, 4, 2]
>>> numbers[0:10:-2]
[]
>>> numbers[::-2]
[10, 8, 6, 4, 2]
>>> numbers[5::-2]
[6, 4, 2]
>>> numbers[:5:-2]
[10, 8]

3、序列相加

• 可使用加法运算符来拼接序列。

>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
>>> ‘Hello,‘ + ‘world!‘　　#字符串拼接，”+“号每出现一次就会在内存中重新开辟一块空间
‘Hello,world!‘

• 不能拼接列表和字符串，虽然它们都是序列。一般而言，不能拼接不同类型的序列。

>>> [1, 2, 3] + ‘world!‘
Traceback (most recent call last):
    File "<pyshell#2>", line 1, in <module>
        [1, 2, 3] + ‘world!‘
TypeError: can only concatenate list (not "str") to list

4、乘法

• 将序列与数n相乘时，将重复这个序列n次来创建一个新序列

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

• None、空列表和初始化

空列表是使用不包含任何内容的两个方括号（[]）表示的。
在Python中，None表示什么都没有。
列表的长度初始化为10，可像下面这样做：
>>> sequence = [None] * 10
>>> sequence
[None, None, None, None, None, None, None, None, None, None]

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

• 在较早的Python版本中，成员资格检查只能检测字符是否包含在字符串中，但现在可使用运算符in来检查指定的字符串是否为另一个字符串的子串。

>>> ‘py‘ in ‘python‘
True
>>> ‘Py‘ in ‘python‘　　#区分大小写
False

2、列表，可以修改的序列

• 列表不同于元组和字符串的地方——列表是可变的，即可修改其内容。
• 空列表是使用不包含任何内容的两个方括号（[]）表示的。
• 列表的切片是列表。

2.1、创建列表

>>> []　　　　  #空列表
[]
>>> [1]　　　　#有一个元素的列表
[1]
>>> [1,2,3]　　 #有多个元素的列表
[1, 2, 3]

>>>name_list=[‘alex‘, ‘seven‘, ‘eric‘]
[‘alex‘, ‘seven‘, ‘eric‘]

• 函数list：它将一个序列作为参数，并将其转换为列表。

>>> hi=list(‘Hello‘)
>>> hi
[‘H‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘]

>>> name_list=list([‘alex‘, ‘seven‘, ‘eric‘])
>>> name_list
[‘alex‘, ‘seven‘, ‘eric‘]

>>> num=list((1,2,3))
>>> num
[1, 2, 3]

2.2、基本的列表操作

可对列表执行所有的标准序列操作，如索引、切片、拼接和相乘

1、修改列表：给元素赋值

• 修改列表很容易，但不是使用类似于x = 2这样的赋值语句，而是使用索引表示法给特定位置的元素赋值，如x[1] = 2。

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

• 不能给不存在的元素赋值，因此如果列表的长度为3，就不能给索引大于2的元素赋值。

>>> x[3]=4
Traceback (most recent call last):
    File "<pyshell#3>", line 1, in <module>
        x[3]=4
IndexError: list assignment index out of range

2、给切片赋值

• 通过使用切片赋值，可将切片替换为长度与其不同的序列。

x[m:n] = [任意长度的序列]

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

>>> name[1:4] =[]　　　　#给切片赋值一个空序列，相当于删除切片中的元素
>>> name
[‘P‘, ‘o‘, ‘n‘]

• 使用切片赋值还可在不替换原有元素的情况下插入新元素。

x[m:m] = [任意长度的序列]

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

3、删除元素

• 从列表中删除元素，只需使用del语句即可。

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

>>> del names[1:3]
>>> names
[‘Alice‘, ‘Earl‘]

2.3、列表方法

• n:索引，x：对象

1、clear()

• 方法clear就地清空列表的内容。修改原列表，不返回任何值。

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

• 类似于切片赋值语句lst[:] = []。

2、copy()深浅

• 方法copy复制列表,创建了一个副本。
• 浅copy

>>> a = [1,2,3]
>>> b = a　　　　　　#a和b指向同一个内存空间
>>> b[1] = 4
>>> a
[1, 4, 3]
>>> b
[1, 4, 3]

• 深copy

>>> c = [4,5,6]
>>> d = c.copy()　　　#类似于使用a[:]或list(a)，它们也都复制a。
>>> d[1] = 7
>>> c
[4, 5, 6]
>>> d
[4, 7, 6]

3、count()

• 方法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

4、index()

• 方法index在列表中查找指定值第一次出现的索引。enumerate

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

>>> knights.index(‘herring‘)
Traceback (most recent call last):
    File "<pyshell#39>", line 1, in <module>
        knights.index(‘herring‘)
ValueError: ‘herring‘ is not in list

5、pop(n)

• 方法pop从列表中删除一个元素（末尾为最后一个元素），并返回这一元素。修改原列表，返回被删除的元素。
• pop是唯一既修改列表又返回一个非None值的列表方法。默认最后一个
• 使用pop可实现一种常见的数据结构——栈（stack）。后进先出（LIFO）。

>>> x = [1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x.pop()
9
>>> x
[1, 2, 3, 4, 5, 6, 7, 8]
>>> x.pop()
8
>>> x
[1, 2, 3, 4, 5, 6, 7]
>>> x.pop(2)
3
>>> x
[1, 2, 4, 5, 6, 7, 8]

6、append(x)

• 方法append用于将一个对象附加到列表末尾。修改原列表，不返回任何值。

• 方法extend让你能够同时将多个值附加到列表末尾，使用一个列表来扩展另一个列表。修改原列表，不返回任何值。

9、remove(元素)

• 方法remove用于删除第一个为指定值的元素。修改原列表，不返回任何值。

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

>>> x.remove(‘bee‘)
Traceback (most recent call last):
    File "<pyshell#3>", line 1, in <module>
        x.remove(‘bee‘)
ValueError: list.remove(x): x not in list

10、reverse()

• 方法reverse按相反的顺序排列列表中的元素。修改原列表，不返回任何值。

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

11、sort()

• 方法sort用于对列表就地排序。修改原列表，不返回任何值。

>>> x = [4, 6, 2, 1, 7, 9]
>>> x.sort()
>>> x
[1, 2, 4, 6, 7, 9]

• 方法sort接受两个可选参数：key和reverse。
  • 参数key，将其设置为一个用于排序的函数。根据函数为每个元素创建的键进行排序。要根据长度对元素进行排序，可将参数key设置为函数len。

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

• • 参数reverse，只需将其指定为一个真值（True或False），以指出是否要按相反的顺序对列表进行排序。

>>> x = [4, 6, 2, 1, 7, 9]
>>> x.sort(reverse=True)
>>> x
[9, 7, 6, 4, 2, 1]

3、元组：不可修改的序列

• 元组语法很简单，只要将一些值用逗号分隔，就能自动创建一个元组。（逗号至关重要）
• 元组还可用圆括号括起（这也是通常采用的做法）。
• 空元组用两个不包含任何内容的圆括号表示。()
• 只有一个元素的元组，必须在它后面加上逗号。(1,)
• 函数tuple的工作原理与list很像：它将一个序列作为参数，并将其转换为元组。
• 元组的切片是元组

3.1、创建元组

>>> ()　　　　 #空元组
()
>>> 1,　　　　#有一个元素的元组
(1,)
>>> 1,2,3　　  #有多个元素的元组
(1, 2, 3)
>>> (1,2,3)
(1, 2, 3)

• 函数tuple：它将一个序列作为参数，并将其转换为元组

>>> tuple(‘abc‘)
(‘a‘, ‘b‘, ‘c‘)

>>> tuple([1, 2, 3])
(1, 2, 3)

>>> tuple((1, 2, 3))
(1, 2, 3)

3.2、为何要熟悉元组呢？

• 它们用作映射中的键（以及集合的成员），而列表不行。
• 有些内置函数和方法返回元组。只要不尝试修改元组，对元组的操作与列表一样（需要使用元组没有的index和count等方法时例外）。