Python __ 列表与元组
序列
在Python中,最基本的数据结构为序列(sequence)。
序列中的每个元素都有编号,即其位置或索引,其中第一个元素的索引为0,第二个元素的索引为1,依此类推。,用负索引表示序列末尾元素的位置。
序列包括:列表list,元组tuple和字符串str
通用的序列操作
有几种操作适用于所有序列:索引、迭代、切片、相加、相乘和成员资格检查
另外,Python还提供了一些内置函数,可用于确定序列的长度以及找出序列中最大和最小的元素。
索引
索引用来访问单个元素。
序列中的所有元素都有编号——从0开始递增。
使用负数索引时,Python将从右(即从最后一个元素)开始往左数,因此-1是最后一个元素的位置。
>>> str="Hello"
>>> print(str[0])
>>> print(str[-1])
>>> print("Hello"[-1])
H
o
o
如果函数调用返回一个序列,可直接对其执行索引操作。例如,如果你只想获取用户输入的
年份的第4位,可像下面这样做:
>>> fourth = input('Year: ')[3]
# 输入:2005
>>> fourth
'5'
切片
切片(slicing):用来访问特定范围内的元素。
可使用两个索引,并用冒号分隔:
第一个索引是包含的第一个元素的编号,但第二个索引是切片后余下的第一个元素的编号(也就是左闭右开)。
>>> tag = '<a href="http://www.python.org">Python web site</a>'
>>> tag[9:30]
'http://www.python.org'
>>> tag[32:-4]
'Python web site'
简写
执行切片操作时,如果切片结束于序列末尾,可省略第二个索引。
>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[-3:]
[8, 9, 10]
同样,如果切片始于序列开头,可省略第一个索引。
>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[:3]
[1, 2, 3]
要复制整个序列,可将两个索引都省略。
>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[:]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
步长
如果不指定,步长默认为1。
这意味着从一个元素移到下一个元素,因此切片包含起点和终点之间的所有元素。
可以显式地指定了步长,步长可以为正数,也可以为负数、即从右向左提取元素。
当然,步长不能为0,否则无法向前移动。
例如:
>>> numbers[0:10:2]
[1, 3, 5, 7, 9]
>>> numbers[3:6:3]
[4]
>>> numbers[8:3:-1]
[9, 8, 7, 6, 5]
显式地指定步长时,也可使用简写。
>>> numbers[::4]
[1, 5, 9]
序列相加
可使用加法运算符来拼接序列。
>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
>>> 'Hello,' + 'world!'
'Hello, world!'
>>> [1, 2, 3] + 'world!'
Traceback (innermost last):
File "<pyshell>", line 1, in ?
[1, 2, 3] + 'world!'
TypeError: can only concatenate list (not "string") to list
从错误消息可知,不能拼接列表和字符串,虽然它们都是序列。一般而言,不能拼接不同类
型的序列。
乘法
将序列与数x相乘时,将重复这个序列x次来创建一个新序列:
>>> 'python' * 5
'pythonpythonpythonpythonpython'
>>> [42] * 10
[42, 42, 42, 42, 42, 42, 42, 42, 42, 42]
None、空列表和初始化
空列表是使用不包含任何内容的两个方括号([])表示的。
如果要创建一个可包含10个元素的列表,但没有任何有用的内容,
一般使用是使用[0]*10
,这将创建一个包含10个零的列表。
在有些情况下,你可能想使用表示“什么都没有”的值,如表示还没有在列表中添加任何内容。在这种情况下,可使用None。(在Python中,None表示什么都没有。)
因此,要将列表的长度初始化为10,可像下面这样做:
>>> sequence = [None] * 10
>>> sequence
[None, None, None, None, None, None, None, None, None, None]
成员资格
要检查特定的值是否包含在序列中,可使用运算符in。
它检查是否满足指定的条件,并返回相应的值:满足时返回True,不满足时返回False。
使用示例:
>>> permissions = 'rw'
>>> 'w' in permissions
True
>>> 'x' in permissions
False
长度、最小值和最大值
内置函数len返回序列包含的元素个数,
min和max分别返回序列中最小和最大的元素
(可以直接将数作为实参,后两个样例)
>>> numbers = [100, 34, 678]
>>> len(numbers)
3
>>> max(numbers)
678
>>> min(numbers)
34
>>> max(2, 3)
3
>>> min(9, 3, 2, 5)
2
列表
不同于元组和字符串,列表是可变的,即可修改其内容。
因此,列表有很多特有的方法。
函数list()
函数list()可将任何序列(而不仅仅是字符串)转化为list
>>> list('Hello')
['H', 'e', 'l', 'l', 'o']
基本操作
1. 修改列表:给元素赋值
用索引表示法给特定位置的元素赋值,如x[1] = 2。
2. 删除元素
使用del语句即可从列表中删除元素。
>>> names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl']
>>> del names[2]
>>> names
['Alice', 'Beth', 'Dee-Dee', 'Earl']
通过切片增删改查
可以通过切片实现列表的增删改查
>>> name = list('Perl')
>>> name
['P', 'e', 'r', 'l']
>>> name[2:] = list('ar')
>>> name
['P', 'e', 'a', 'r']
通过切片赋值和分别给每个元素赋值不同是:
通过使用切片赋值,可将切片替换为长度与其不同的序列。
>>> 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]
上述代码与del numbers[1:4]等效。
列表方法
append 原地修改
方法append用于将一个对象附加到列表末尾。
clear
方法clear就地清空列表的内容。
copy
方法copy 复制列表。
常规复制只是将另一个名称关联到列表。(修改一个,另一个也改变)
使用copy方法是新建一个副本。(修改一个,另一个不变)这类似于使用a[:]或list(a),它们也都复制a。
# 常规
>>> a = [1, 2, 3]
>>> b = a
>>> b[1] = 4
>>> a
[1, 4, 3]
#copy
>>> a = [1, 2, 3]
>>> b = a.copy()
>>> b[1] = 4
>>> a
[1, 2, 3]
count
方法count计算指定的元素在列表中出现了多少次。
extend
方法extend让你能够同时将多个值附加到列表末尾,为此可将这些值组成的序列作为参数提
供给方法extend。换而言之,你可使用一个列表来扩展另一个列表。
虽然看起来类似于拼接,但存在一个重要差别:那就是将修改被扩展的序列(下面的a),在常规拼接中,情况是返回一个全新的序列。而extend函数吃就地修改。
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6]
index
方法index在列表中查找指定值第一次出现的索引。
insert
方法insert用于将一个对象插入列表。
和append不同,insert需要指定index。
pop
方法pop删除列表的最后一个元素,并返回这一元素。
pop是唯一既修改列表又返回一个非None值的列表方法。
- 到这里就可以使用列表模拟栈了
python没有实现栈。但是可以模拟出来
使用append来替代压入(push)
使用pop弹出
remove
方法remove用于删除第一个为指定值的元素。
>> x = ['to', 'be', 'or', 'not', 'to', 'be']
>>> x.remove('be')
>>> x
['to', 'or', 'not', 'to', 'be']
reverse
方法reverse按相反的顺序排列列表中的元素
sort
方法sort用于对列表就地排序。就地排序意味着对原来的列表进行修改,使其元素按顺序
排列,而不是返回排序后的列表的副本
如果想获取排序后的列表的副本:
只是将x赋给y是不可行的,因为这样x和y将指向同一个列表,需要使用copy。
最好使用函数sorted。
>>> x = [4, 6, 2, 1, 7, 9]
>>> y = sorted(x)
>>> x
[4, 6, 2, 1, 7, 9]
>>> y
[1, 2, 4, 6, 7, 9]
高级排序
方法sort接受两个可选参数:key和reverse。
参数key类似于参数cmp:你将其设置为一个用于排序的函数。然而,不会直接使用这个函数来判断一个元素是否比另一个元素小,而是使用它来为每个元素创建一个键,再根据这些键对元素进行排序。
因此,要根据长度对元素进行排序,可将参数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]
函数sorted也接受参数key和reverse,用法和sort一样。
元组tuple:不可修改的序列
与列表一样,元组也是序列,唯一的差别在于元组是不能修改的(字符串也不能修改)。
创建元组很简单,常见有三种方法:****
- 只要将一些值用逗号分隔,就能自动创建一个元组。
- 元组还可用圆括号括起(通常采用的做法)。
- 函数tuple():与list很像,它将一个序列作为参数,并将其转换为元组。如果参数已经是元组,就原封不动地返回它。
>>> 1, 2, 3
(1, 2, 3)
>>> (1, 2, 3)
(1, 2, 3)
空元组用两个不包含任何内容的圆括号表示。
>>> ()
()
但是对于创建只包含一个值的元组有点特殊:
虽然只有一个值,但是必须在它后面加上逗号。
>>> 42
42
>>> 42,
(42,)
>>> (42,)
(42,)
为何要熟悉元组?
原因有以下两个。
- 它们用作映射中的键(以及集合的成员),而列表不行。
- 有些内置函数和方法返回元组。
只要不尝试修改元组,与元组“打交道”通常意味着像处理列表一样处理它们(需要使用元组没有的index和count
等方法时例外)。