03 python序列、列表、元组

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:-2]　　　　#步长可以是负数
[9, 7, 5]

>>> numbers[3:8:-2]　　　　#索引3的位置在索引8的左边
[]
>>> numbers[-2:5:-2]
[9, 7]

>>> numbers[5::-1]　　　　#步长为负时，省略第二索引，表示从右向左取到最后一个元素
[6, 5, 4, 3, 2, 1]
>>> numbers[:5:-1]　　　　#步长为负时，省略第一索引，表示从右向左，从第一个元素取
[10, 9, 8, 7]
>>> numbers[::-1]　　　　　#表示将序列逆序
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

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：它将一个序列作为参数，并将其转换为列表。

>>> h=list()　　　　#空列表
>>> h
[]

>>> 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，只copy第一层，即第一层相互独立，其他层不独立。

>>> a=[1,2,3,[4,5,6]]
>>> b=a[:]　　　　　　#第一种浅copy，三种浅copy效果相同
>>> c=a.copy()　　　   #第二种浅copy
>>> d=list(a)　　　　   #第三种浅copy

>>> c[0]='1'　　　　　 #改变第一层不影响其他列表
>>> a
[1, 2, 3, [4, 5, 6]]
>>> c
['1', 2, 3, [4, 5, 6]]

>>> c[3][0]='4'　　　　#改变其他层影响其他列表
>>> a
[1, 2, 3, ['4', 5, 6]]
>>> c
['1', 2, 3, ['4', 5, 6]]

• 深copy，生产一个完全独立的列表。

>>> import copy
>>> a=[1,2,3,[4,5,6]]
>>> c=copy.deepcopy(a)

>>> c[0]='1'　　　　#改变第一层不影响其他列表
>>> a
[1, 2, 3, [4, 5, 6]]
>>> c
['1', 2, 3, [4, 5, 6]]

>>> c[3][0]='4'　　   #改变其他层也不影响其他列表
>>> a
[1, 2, 3, [4, 5, 6]]
>>> c
['1', 2, 3, ['4', 5, 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用于将一个对象附加到列表末尾。修改原列表，不返回任何值。

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

7、extend(x)

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

• 与将列表赋给切片效果相同，但可读性不高

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a[len(a):] = b
>>> a
[1, 2, 3, 4, 5, 6] 

8、insert

• 方法insert用于将一个对象插入列表。

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

• 与extend一样，也可使用切片赋值来获得与insert一样的效果。

>>> numbers = [1, 2, 3, 5, 6, 7]
>>> numbers[3:3] = ['four']
>>> numbers
[1, 2, 3, 'four', 5, 6, 7]

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 = [5, 1, 3, 2]
>>> x.reverse()
>>> x
[2, 3, 1, 5]

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]

###升序
num = [9,4, 6, 2, 1, 7, 9,8]
for i in range(len(num)):
    for j in range(i+1,len(num)):
        if num[i] > num[j]:
            num[i],num[j] = num[j],num[i]
print(num)
###降序
num = [9,4, 6, 2, 1, 7, 9,8]
for i in range(len(num)):
    for j in range(i+1,len(num)):
        if num[i] < num[j]:
            num[i],num[j] = num[j],num[i]
print(num)

2.4、列表方法附录

• 列表常用的内置函数

len(seq)：返回序列的长度。
max(args)：返回序列或一组参数中的最大值。
min(args)：返回序列和一组参数中的最小值。
reversed(seq)：让你能够反向迭代序列。
sorted(seq)：返回一个有序列表，其中包含指定序列中的所有元素。
enumerate(iterable)：迭代iterable中所有项的(index,item)。可提供关键字参数start，以便不从开头开始迭代。
list(seq)：将序列转换为列表。

2.5、列表总结

1、查看列表

>>> hh1 = ['a', 'b', 'c', 1, 2, 3 , 'a', 3, 'a']
>>> hh1[1]　　　　　　　　#索引
'b'
>>> hh1[1:3]　　　　　　　　#切片
['b', 'c']
>>> hh1.count('a')　　　　#查看元素出现的次数
3
>>> hh1.index(3)　　　　　　#查看元素第一次出现的索引（从左向右）
5
>>> 'a' in hh1　　　　　　#查看某元素是否在列表中
True

2、添加列表元素

>>> hh2 = [1,'a']

>>> hh2.append(45)　　　　　　#向列表尾部添加一个元素
>>> hh2
[1, 'a', 45]

>>> hh2.insert(1,'heng')　　　#向列表指定位置添加一个元素
>>> hh2
[1, 'heng', 'a', 45]

>>> hh2[1:1] = [1, 2]　　　　#向列表指定位置添加一个或多个元素　　
>>> hh2
[1, 1, 2, 'heng', 'a', 45]

>>> a = ['mai','heng']　　　　#用另一个列表扩展列表
>>> hh2.extend(a)
>>> hh2
[1, 1, 2, 'heng', 'a', 45, 'mai', 'heng']

###列表拼接
>>> a =[1, 2, 3]
>>> b =[4, 5, 6]
>>> c = a + b　　　　#加号（+）拼接
>>> a
[1, 2, 3]
>>> b
[4, 5, 6]
>>> c
[1, 2, 3, 4, 5, 6]
>>> d = a * 3　　　　#乘号（*）拼接
>>> d
[1, 2, 3, 1, 2, 3, 1, 2, 3]

3、修改列表

>>> hh3 = ['a', 'b', 'c']

>>> hh3[1]=2　　　　　　　　　　#替换一个元素
>>> hh3
['a', 2, 'c']

>>> hh3[1:2] = ['x', 'y']　　#替换一个或多个元素
>>> hh3
['a', 'x', 'y', 'c']

 4、删除列表元素、删除列表

>>> hh4 = ['a', 'b', 'c', 1, 2, 3 , 'a', 3, 'a']

>>> hh4.remove('a')　　　　#删除第一个指定元素（从左向右）
>>> hh4
['b', 'c', 1, 2, 3, 'a', 3, 'a']

>>> hh4.pop()　　　　　　#删除最后一个元素，并返回该元素
'a'
>>> hh4
['b', 'c', 1, 2, 3, 'a', 3]
>>> hh4.pop()
3
>>> hh4
['b', 'c', 1, 2, 3, 'a']

>>> hh4.pop(2)　　　　　　#删除指定索引的元素，并返回该元素　　　　
1
>>> hh4
['b', 'c', 2, 3, 'a']

>>> del hh4[2]　　　　　　#删除指定索引的元素
>>> hh4
['b', 'c', 3, 'a']
>>> hh4.clear()　　　　　　#清空列表
>>> hh4
[]
>>> del hh4　　　　　　　　#删除列表的名称及引用
>>> hh4
Traceback (most recent call last):
  File "<pyshell#70>", line 1, in <module>
    hh4
NameError: name 'hh4' is not defined

 5、列表元素排序

>>> hh5 = [1, 4 ,2, 8]　　　　#正序排序
>>> hh5.sort()
>>> hh5
[1, 2, 4, 8]
>>> hh5 = ['e', 'a', 'g']
>>> hh5.sort()
>>> hh5
['a', 'e', 'g']

>>> hh5 = [1, 4 ,2, 8]　　　　#逆序排序
>>> hh5.reverse()
>>> hh5
[8, 2, 4, 1]
>>> hh5 = ['e', 'a', 'g']
>>> hh5.reverse()
>>> hh5
['g', 'a', 'e']

6、身份判断

>>> hh6 = [1, 2, 3]
>>> type(hh6) is list　　#判断对象是否是列表
True
>>> hh6 = 'hengha'
>>> type(hh6) is list
False

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

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

3.1、创建元组

>>> ()　　　　 #空元组
()
>>> 1,　　　　 #只有一个元素的元组，必须加上逗号
(1,)
>>> 1,2,3　　  #有多个元素的元组
(1, 2, 3)
>>> (1,2,3)　　#加上小括号    
(1, 2, 3)

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

>>> h=tuple()　　　　#空元组
>>> h
()

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

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

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

3.2、元组的方法

• 只有2个方法，一个是count，一个是index。
• 常用的内置函数

max(args)：返回序列或一组参数中的最大值。
min(args)：返回序列和一组参数中的最小值。
sum(seq[, start]) 计算数字序列中所有元素的总和，再加上可选参数start的值（默认为零），然后返回结果
len(seq)：返回序列的长度。
sorted(seq)：返回一个有序列表，其中包含指定序列中的所有元素。
tuple(seq)：将序列转换为元组

3.3、为何要熟悉元组呢？

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