利用Python进行数据分析_01_内建数据结构、函数及文件（1）

1.1 数据结构和序列

1.1.1 元组

元组是一种固定长度、不可变的python对象序列。

In [1]: tup = 4, 5, 6

In [2]: tup
Out[2]: (4, 5, 6)

可以生成元素是元组的元组

In [3]: nested_tup = (4, 5, 6), (7, 8)

In [4]: nested_tup
Out[4]: ((4, 5, 6), (7, 8))

tuple函数可以将任意序列或迭代器转换为元组

In [5]: tuple([4, 0, 2])
Out[5]: (4, 0, 2)

In [6]: tup = tuple('string')

In [7]: tup
Out[7]: ('s', 't', 'r', 'i', 'n', 'g')

元组的元素可以通过中括号[ ]来获取，python中的序列索引是从0开始的

In [9]: tup[0]
Out[9]: 's'

虽然对象元组中储存的对象其自身是可变的，但是元组一旦创建，各个位置上的对象都是无法被修改的。

In [10]: tup = tuple(['foo', [1, 2], True])

In [11]: tup[2] = False
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-11-b89d0c4ae599> in <module>
----> 1 tup[2] = False

TypeError: 'tuple' object does not support item assignment

如果一个元组中的一个对象是可变的，例如列表，可以在内部进行修改

In [12]: tup[1].append(3)

In [13]: tup
Out[13]: ('foo', [1, 2, 3], True)

可以使用 + 来连接元组生成更长的元组

In [14]: (4, None, 'foo') + (6, 0) + ('bar',)
Out[14]: (4, None, 'foo', 6, 0, 'bar')

1.1.1.1 元组拆包

如果想要将元组型的表达式赋值给变量， python会对等号右边的值进行拆包

In [15]: tup = (4, 5, 6)

In [16]: a, b, c = tup

In [17]: b
Out[17]: 5

即使是嵌套元组也可以拆包

In [18]: tup = 1, 2, (3, 4)

In [19]: a, b, (c, d) = tup

In [20]: c
Out[20]: 3

拆包的一个常用的场景就是遍历元组或列表组成的序列

In [21]: seq = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]

In [22]: for a, b, c in seq:
    ...:     print('a = {0}, b = {1}, c = {2}'.format(a, b, c))
a = 1, b = 2, c = 3
a = 4, b = 5, c = 6
a = 7, b = 8, c = 9

python中有一些更为高级的元组拆包功能，如*rest语法，用于函数调用时获取任意长度的位置参数列表

In [23]: values = 1, 2, 3, 4, 5

In [24]: a, b, *rest = values

In [25]: a, b
Out[25]: (1, 2)

In [26]: rest
Out[26]: [3, 4, 5]

rest部分有时是想要丢弃的数据，rest这个变量名本身并没有特殊意义，为了方便通常使用下划线_来表示不想要的变量

In [27]: a, b, *_ =  values

1.1.1.2 元组方法

由于元组的内容和长度是无法改变的，它的实例方法很少。一个常见的有用方法是count（列表也可用），用于计量某个数值在元组中出现的次数

In [28]: a = (1, 2, 2, 2, 4, 3, 2)

In [29]: a.count(2)
Out[29]: 4

利用Python进行数据分析_01_内建数据结构、函数及文件（1）

猜你喜欢