序列类型概述

序列类型有列表，元组，range，字符串，字节串等。之所以称为序列类型，因为它们中的元素是按顺序排列的，可以使用下标索引或切片取值。

a = [1,2,3]
b = 1,2,3
c = range(1,4)
d = '123'
e = b'123'
a[0],b[0],c[0],d[0],e[0]

(1, 1, 1, '1', 49)

chr(49) # 字节串索引取到的是 Unicode 码位值

'1'

序列类型又分为可变和不可变两种，列表是可变序列类型，元组，range，字符串，字节串是不可变序列类型。不可变序列类型普遍实现而可变序列类型未实现的唯一操作就是对 hash() 内置函数的支持。

这种支持允许不可变类型，例如元组被用作字典的键，以及存储在集合中。

尝试对包含有不可哈希值的不可变序列进行哈希运算将会导致 TypeError。

hash((1,2)), hash('12')

(-3550055125485641917, -480100434937186025)

{(1,2), '12'}

{(1, 2), '12'}

{([1,2],3),4}

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-10-b847264454c5> in <module>
----> 1 {([1,2],3),4}


TypeError: unhashable type: 'list'

可变序列类型，可以就地进行元素的增、删、改，而不可变序列类型不可以，有时看起来像，但其实是创建了新对象：

a, b = [1,2], (1,2)
print(id(a),id(b))
a += [3] # 将元素 3 加入列表中，相当于 a.extend([3])
b += (3,) # 将元组 b 与元组 (3,) 拼接赋值给 b
print(a,b)
print(id(a), id(b))

2058115879744 2058115232576
[1, 2, 3] (1, 2, 3)
2058115879744 2058115884416
jupyter附件

range 对象

range 对象是一个整数等差数列，用内置函数 range() 构造得到，类型是 range：

type(range(3))

range

range(-1,5,2)

range(-1, 5, 2)

range 通常用于在 for 循环中循环指定的次数：

for i in range(3):
    print('重要的事情说三遍')

重要的事情说三遍
重要的事情说三遍
重要的事情说三遍

range 对象可以指定起始值（默认 0），结束值（不包含），和等差数列的公差（默认 1）。

指定一个大于 0 的值则默认从 0 开始，公差为 1，到指定值之前一个整数结束：

list(range(5))

[0, 1, 2, 3, 4]

因为公差默认为 1，指定一个小于等于 0 的值则得到空 range：

list(range(-5))

[]

起始值，结束值，公差都指定，则得到相应等差数列：

list(range(1,5))

[1, 2, 3, 4]

list(range(1,-5,-1))

[1, 0, -1, -2, -3, -4]

range 类型相比常规 list 或 tuple，优势在于一个 range 对象总是占用固定的（较小）内存，不论其所表示的范围有多大。因为 range 类型只保存了 start, stop 和 step 值，并会根据需要计算具体单项或子范围的值。

除了拆包可以使用操作符*，range 对象不可以像列表，元组等一样，使用 +，*，+=，*=进行拼接或重复：

(*range(3),)

(0, 1, 2)

序列索引和切片

序列类型都可以使用下标进行索引或切片取值，这是序列类型通用操作。可变序列类型比较特殊，例如列表，可以利用索引或切片进行元素增、删、改，详见 列表的索引和切片。

下标从前往后，则以 0 开始，从后往前，则从 -1 开始，双向索引：

('a', 'b', 'c', 'd')
  0    1    2    3
 -4   -3   -2   -1

下标索引，直接取出对应索引下的值，超出范围则报错：

a = [1,2,3,4]
a[10]

---------------------------------------------------------------------------

IndexError                                Traceback (most recent call last)

<ipython-input-18-5680bb375980> in <module>
      1 a = [1,2,3,4]
----> 2 a[10]


IndexError: list index out of range

a = [1,2,3,4]
a[0], a[-2]

(1, 3)

下标切片取值规则：[起始:结束:步长]，不包含结束。

  • 没有指定起始，则默认为 0；
  • 没有指定结束则默认到最后一个元素结束；
  • 下标可以双向混合使用；
  • 没有指定步长，则默认为 1；
  • 步长为负数，则反向取值，-1 开始。
a = [1,2,3,4,5,6,7]
a[:3]

[1, 2, 3]

a = [1,2,3,4,5,6,7]
a[3:]

[4, 5, 6, 7]

a = [1,2,3,4,5,6,7]
a[1:-3], a[-6:4]

([2, 3, 4], [2, 3, 4])

a = [1,2,3,4,5,6,7]
a[::2]

[1, 3, 5, 7]

a = [1,2,3,4,5,6,7]
a[::-2] # 默认 -1 开始取

[7, 5, 3, 1]

a = [1,2,3,4,5,6,7]
a[0:7:-2]

[]

a = [1,2,3,4,5,6,7]
a[-1:0:-2]

[7, 5, 3]

切片范围可以无限大，范围内没有元素，则得到空的容器：

a = [1,2,3,4,5,6,7]
a[5:100], a[1:1], a[5:-10]

([6, 7], [], [])

序列通用操作

序列类型有许多通用的操作，在各个知识点都有详细的介绍，下面将他们综合起来比较。

序列类型都可以使用操作符 + 进行拼接，使用 += 拼接并赋值（range 除外），但对于可变序列类型，使用 += 是原地修改：

a = [1,2]
print(id(a))
a += [3,4]
id(a), a

2612604344328


(2612604344328, [1, 2, 3, 4])

'12'+'34', [1,2]+[3,4], (1,2)+(3,4)

('1234', [1, 2, 3, 4], (1, 2, 3, 4))

序列类型都可以使用操作符 * 进行重复并拼接，使用 *= 拼接并赋值（range 除外），但对于可变序列类型，使用 *= 是原地修改：

'1'*2, 2*[1], (1,)*2

('11', [1, 1], (1, 1))

a = [1]
print(id(a))
a *= 2
id(a), a

2612603190024


(2612603190024, [1, 1])

序列类型都可以使用 * 进行拆包，拆包之后需要包含在列表，元组，集合中，或用于函数传参：

[*(1,2)], (*[1,2],), {*range(1,3)}

([1, 2], (1, 2), {1, 2})

print(*'123')

1 2 3

序列类型都可以使用索引或切片操作取值，但对于可变序列类型，还可以使用索引或切片操作进行内容的增、删、改：

a = '1234'
b = [1,2,3,4]
c = (1,2,3,4)
d = range(1,5)
a[0], b[0], c[0], d[0]

('1', 1, 1, 1)

a[1:3], b[1:3], c[1:3], d[1:3]

('23', [2, 3], (2, 3), range(2, 4))

b[1:3] = 'abc'
b

[1, 'a', 'b', 'c', 4]

序列类型都有方法 index 和 count，但字符串和字节串的 count 方法可以指定范围（具体详见各知识点的方法）：

'1234'.index('23'),\
[1,2,3,4].index(2),\
range(1,4).index(2)

(1, 1, 1)

'1231'.count('1',1,3),\
(1,2,3,1).count(1)

(0, 2)