Python 序列类型 list，tuple，range 使用说明

Python 序列类型

Python 中存在很多的序列（Sequence）类型，比如str，bytes，list，tuple，range。其中列表list继承自MutableSequence，为可变序列，元组tuple和区域range继承自Sequence，为不可变序列。

Python list 类型

Python 中的列表list，可以通过[]来创建，[]中为列表的元素，元素之间使用,进行分隔。

除了[]，你还可以通过list类型的构造器来创建 Python 列表，他的形式如下。

list([iterable], /)

iterable 参数

iterable参数是一个迭代器对象，迭代器中的元素将依次包含在 Python 列表中。如果未指定该参数，则返回一个空列表。

另外，使用推导式可以让创建列表变得更为简单，语法格式为y for x in iterable，其中iterable为迭代器对象，x表示迭代器中的元素，y为一个表达式，一般会通过x产生新的值。

[1, 2, 3]
[1, 2, 3]
list((1, 2, 3))
[1, 2, 3]
[x + 100 for x in (1, 2, 3)]
[101, 102, 103]

对 Python 列表中的元素进行排序

使用 Python 的sorted函数，或列表对象的sort方法，可以对列表中的元素进行排序，两种方式的区别在于，sorted函数会将排序的结果作为新的列表返回。

sorted(iterable, /, *, key=None, reverse=False)
sort(*, key=None, reverse=False)

iterable 参数

iterable参数是一个迭代器对象，迭代器中的元素将参与排序。

key 参数

key参数是一个函数或方法，其参数表示序列中的元素，其返回值表示真正用于比较的内容，这对于复杂对象是有效的。假设列表的元素是Student类的实例，我们可以通过key参数指示按照其id进行排序。

reverse 参数

reverse参数默认为False，表示升序排序，如果为True，则表示降序排序。

l = ['a', 'A', 'c']
l.sort()
l
['A', 'a', 'c']
l = ['a', 'A', 'c']
l.sort(key=str.upper)
l
['a', 'A', 'c']

Python tuple 类型

Python 中的元组tuple，可以通过()来创建，()中为元组的元素，元素之间使用,进行分隔。与列表不同，元组在创建之后不能修改。

除了()，你还可以通过tuple类型的构造器来创建 Python 元组，他的形式如下。

tuple([iterable], /)

iterable 参数

iterable参数是一个迭代器对象，迭代器中的元素将依次包含在 Python 元组中。如果未指定该参数，则返回一个空元组。

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

Python range 类型

Python 中的区域range，并不像列表和元组一样包含具体的元素，range仅包含一些信息，用于描述一个有规律的整数序列，通常情况下这些整数会被用于循环。

要创建range对象，需要使用range类型的构造器，他具有以下两种形式。

range(stop, /)
range(start, stop, step=1, /)

start 参数

start参数表示整数序列中的第一个整数，默认为0。

stop 参数

stop参数用于限定序列最后一个整数的大小，如果step为正数，则最后一个整数需要小于stop，如果step为负数，则最后一个整数需要大于stop。

step 参数

step参数表示了序列中两个整数的间距大小，默认为1。如果设置为0，将引发异常ValueError。

对于 Python 3.3 以及更高的版本，上述三个参数start，stop和step，在成功创建range对象后，其信息将保留在对应的属性start，stop和step中。

[x for x in range(3)]
[0, 1, 2]
tuple(range(10, 3, -2))
(10, 8, 6, 4)
range(0) == range(0, 0, -3)
True

获取 Python 列表，元组，区域中的元素

使用索引和切片表达式，你可以轻松获取 Python 列表，元组，区域（range）的某个或某些元素，他们的书写方式有s[i]，s[i:j]，s[i:j:k]。

其中，i，j为元素的索引，用于界定切片的范围，i指示切片的开始位置，j指示切片的停止位置，停止位置的元素不会被包含在切片中，如果停止位置存在元素的话。k为步长，不能为0，未指定或为None时将作为1处理。

根据k的正负情况，i指示的位置应该在j指示位置的左边或右边，否则会返回一个空切片。当i，j未指定或为None时，切片会尝试包含序列两端的所有元素。

(1, 2, 3, 4, 5)[-1]
5
(1, 2, 3, 4, 5)[-2:1:-1]
(4, 3)
(1, 2, 3, 4, 5)[:]
(1, 2, 3, 4, 5)
(1, 2, 3, 4, 5)[100:-100:-2]
(5, 3, 1)

查找 Python 列表，元组，区域中的元素

对于元素的查找，Python 列表，元组，区域（range）提供了如下方法。

count方法用于获取指定元素在序列中出现的次数。

count(value, /)

value 参数

value参数为需要计算出现次数的元素。

index方法用于获取指定元素在序列中的索引，如果元素不存在，则将引发异常ValueError。

index(value[, start[, stop]], /)

value 参数

value参数为需要计算索引的元素。

start，stop 参数

start和stop参数用于序列的切片操作，如果value指定的元素不在切片范围内，则会引发异常ValueError。

['a', 'b', 'b'].count('b')
2
(1, 'a', 1.3).index('a')
1

获取 Python 列表，元组，区域中元素的个数

Python 中的函数len，可用于获取列表，元组，区域（range）的元素个数，比如，len(range(3))的运算结果为3。

判断 Python 列表，元组，区域中是否存在某个元素

使用x in s或x not in s，可以判断列表，元组，区域（range）中是否存在或不存在某个元素，x为需要判断的元素，s为序列对象。

1 in [0, 1, 2]
True
1 not in (0, 1, 2)
False

获取 Python 列表，元组，区域中的最大值和最小值

Python 中的函数max，min，可用于获取列表，元组，区域（range）中的最大值和最小值，比如，max([1,3,2])的运算结果为3，min((1,3,2))的运算结果为1。

反转 Python 列表，元组，区域

使用 Python 列表的reverse方法，可以将列表中的元素顺序反转，需要指出，这会直接影响原有列表，而不是产生新的列表对象。

如果你不希望影响原有列表，那么可以使用reversed函数，将反转的结果保存在迭代器中，然后通过迭代器创建一个新列表。或者，先使用copy方法对原有列表进行复制。

除了列表，reversed函数同样适用于元组和区域（range）。

l = [1, 2, 3]
l.reverse()
l
[3, 2, 1]
tuple(reversed((1, 2)))
(2, 1)

联接 Python 列表，元组，区域

在 Python 中，你可以使用+或*，对列表，元组，区域（range）进行联接或自我联接，他们的书写方式为s+t，s*n，n*s。其中s和t需要是类型相同的两个序列对象，否则会引发异常。n为自我联接的次数，大于1时才有实际效果，如果次数小于等于0，则会生成一个类型相同的空序列。

(1, 2) * 2
(1, 2, 1, 2)
(1, 2) * -1
()

t = ([],) * 2
t
([], [])
t[0].append(123)
t
([123], [123])

添加和插入 Python 列表元素

對於元素的添加和插入，Python 串列提供了如下方法。

append方法用于在列表的末尾添加元素。

insert方法用于在列表的某一位置插入元素。

append(object, /)
insert(index, object, /)

object 参数

object参数为需要添加或插入的元素。

index 参数

index参数是一个索引，该索引对应的位置将被插入元素。当index表示的索引无效时，元素会被添加至列表末尾。

l = []
l.append(1)
l.insert(0, 2)
l
[2, 1]

替换和删除 Python 列表中的元素

你可以使用之前讲述的切片表达式，来替换 Python 列表中的元素，他们的书写方式有s[i]=x，s[i:j]=t，s[i:j:k]=t。

其中，x为替换的新元素，t为包含新元素的迭代器，切片表达式对应的旧元素会被删除，新元素将在第一个旧元素的位置被依次添加。如果步长k最终未被视为1，则删除的旧元素和添加的新元素的个数必须相同，否则删除的旧元素和添加的新元素的个数不必相同。

使用del关键字或空的迭代器，你可以删除 Python 列表中的某个或切片包含的元素，他们的书写方式有del s[i]，del s[i:j]，del s[i:j:k]，s[i:j]=()，s[i:j]=[]等。

此外，列表的remove方法可用于删除指定的元素，删除操作仅执行一次。

列表的pop方法，同样可用于删除列表中指定索引位置的元素，但他会将被删除的元素作为返回值返回。

列表的clear方法可用于删除列表中的所有元素。

remove(value, /)

value 参数

value参数为需要被删除的元素，如果他不存在，则将引发异常ValueError。

pop(index=-1, /)

index 参数

index参数为需要删除并返回的元素的索引，默认为-1，也就是最后一个元素的索引。当index表示的索引无效时，将引发异常IndexError，这包括列表长度为0的情况。

l = [1, 2, 3, 4, 5, 6]
l[0:2] = ('a', 'b', 'c')
l
['a', 'b', 'c', 3, 4, 5, 6]
del l[-1:-5:-1]
l
['a', 'b', 'c']
l.remove('b')
l
['a', 'c']
l.pop(0)
'a'

复制 Python 列表

使用 Python 列表的copy方法，可以对列表进行复制，并产生一个新的列表，这种复制属于阴影复制，复制的列表与被复制的列表互不影响，但两个列表中的元素仍可能保持对同一对象的引用。

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

拓展 Python 列表

使用+=，*=，你可以进行拓展和自我拓展，他们的书写方式为s+=t，s*=n。其中s为序列对象，t为包含元素的迭代器对象。n为自我拓展的次数，大于1时才有实际效果，如果次数小于等于0，列表中的元素将被清空。

此外，列表的extend方法也可以实现列表的拓展，他的效果与s+=t一致。

extend(iterable, /)

iterable 参数

iterable参数是一个迭代器对象，迭代器中的元素将被依次添加至列表末尾。

l = [1, 2]
l += range(3, 9)
l
[1, 2, 3, 4, 5, 6, 7, 8]