Python语言基础（2）

5. 结构化数据和序列

Python拥有丰富的结构化的数据类型，这是Python语言的优势所在，掌握这些数据类型，也是学习Python最主要的任务。所谓“结构化数据”，就是把一组数据或对象，用一定的方式组合起来，可以更好地表达真实事物，可以更便捷地处理数据。

5.1 元组Tuple

5.1.1 元组的特征

元组Tuple是一组Python对象序列，三个特征：一维、定长、不可变。

元组内的元素可以是各种Python对象，可以是不同的数据类型。

元组常用于固定的数据组合，例如：12个星座的名称：('水瓶座','双鱼座'...)。

创建元组对象，最简单的方法就是一组用逗号隔开的数据，用圆括号包括起来（在不产生歧义的情况下，也可以不用括号）。

In [1]:

tup1 = 1, 2, 3
tup1

Out[1]:

(1, 2, 3)

In [2]:

tup1 = 1, 2, (3, 4)
tup1

Out[2]:

(1, 2, (3, 4))

用tuple()函数可以把大部分Python对象转为元组

In [3]:

tuple([4, 0, 2])

Out[3]:

(4, 0, 2)

In [4]:

tup2 = tuple('string')
tup2

Out[4]:

('s', 't', 'r', 'i', 'n', 'g')

读取元组的元素，方法与数组类似，就是用“方括号+序号”来读取。与Java等语言类似，Python的序列都是从0开始的

In [5]:

tup2[0]

Out[5]:

's'

元组的不变性，体现在元组创建后，不能再对已有的元素重新赋值，但已有的元素本身是可变的。

In [6]:

tup3 = 'abc', [1, 2], 59
tup3

Out[6]:

('abc', [1, 2], 59)

In [7]:

tup3[2] = 60

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-7-d63b5e6d6b0a> in <module>()
----> 1 tup3[2] = 60

TypeError: 'tuple' object does not support item assignment

In [8]:

tup3[1].append(3)
tup3

Out[8]:

('abc', [1, 2, 3], 59)

5.1.2 元组合并

用+加号连接几个不同的元组

In [9]:

tup1 + tup2 + tup3

Out[9]:

(1, 2, (3, 4), 's', 't', 'r', 'i', 'n', 'g', 'abc', [1, 2, 3], 59)

元组乘以一个整数，相当于连接了几个副本。

In [10]:

tup1 * 4

Out[10]:

(1, 2, (3, 4), 1, 2, (3, 4), 1, 2, (3, 4), 1, 2, (3, 4))

5.1.3 元组的长度

元组的长度就是元组中元素的个数。某个元素即使拥有很多子元素，也只能算一个元素。

In [11]:

tup = (1, 2, (3, 4), 'abc')
len(tup)

Out[11]:

4

5.1.4 统计元组中某个数值的个数

In [12]:

a = (1, 2, 2, 2, 3, (4, 2))
a.count(2)

Out[12]:

3

5.2 列表 List

5.2.1 列表的特征

列表List的组成方式与元组一样，但它的长度可变，内容也可以修改。

创建列表的方法，是用方括号包括一组用逗号隔开的元素。如下：

In [13]:

lst1 = [2, 3.14, True, 'abc', None]
lst1

Out[13]:

[2, 3.14, True, 'abc', None]

对已有的某个元素重新赋值。

In [14]:

lst1[1]='x'
lst1

Out[14]:

[2, 'x', True, 'abc', None]

5.2.2 列表增加和删除元素

在列表后面追加元素

In [15]:

lst1.append('end')
lst1

Out[15]:

[2, 'x', True, 'abc', None, 'end']

在某个中间位置插入元素

In [16]:

lst1.insert(2, 'word')
lst1

Out[16]:

[2, 'x', 'word', True, 'abc', None, 'end']

按位置标号删除元素。pop与insert互为逆运算

In [17]:

lst1.pop(2)
lst1

Out[17]:

[2, 'x', True, 'abc', None, 'end']

按元素的值删除元素。

思考：如果列表中，有多个值相同的元素，这时用remove方法按值删除，会得到什么结果？

In [18]:

lst1.remove('abc')
lst1

Out[18]:

[2, 'x', True, None, 'end']

用 in 判断列表中是否包含某数据

In [19]:

'end' in lst1

Out[19]:

True

5.2.3 列表合并

用 + 加号可以合并，形成一个新的列表，原列表的值不变。

In [20]:

lst1 + [7, 8, (2, 3)]

Out[20]:

[2, 'x', True, None, 'end', 7, 8, (2, 3)]

用extend()方法，在原列表后追加多个元素。

In [21]:

lst1.extend([7, 8, (2, 3)])
lst1

Out[21]:

[2, 'x', True, None, 'end', 7, 8, (2, 3)]

5.2.4 列表的长度

与元组一样，列表的长度就是列表中元素的个数。

注意：如果列表中某个元素也是列表或其他结构化数据，在计算整个列表的长度时，这个列表元素也只能贡献一个长度。

In [22]:

len(lst1)

Out[22]:

8

5.2.5 排序

如果一个列表中都是数值（整数或浮点数）元素,或都是字符串元素时，可以用自带的sort()方法，对其元素进行排序。调用sort()方法排序不生成新的对象,而是取代了旧的对象。所以，如果要保留排序前的列表，可以先把列表赋值给另一个变量名后再排序。

默认情况下，sort()方法是按由小到大的顺序排序。

In [23]:

lst2 = [7, 2, 5, 1, 3]
lst2.sort()
lst2

Out[23]:

[1, 2, 3, 5, 7]

如果想要由大到小排序，可以指定参数 revers=True

In [24]:

lst2.sort(reverse=True)
lst2

Out[24]:

[7, 5, 3, 2, 1]

通过设置sort函数的参数，可以按特定的函数值排序。例如对一组字符串按长度进行排序：

In [25]:

lst3 = ['saw', 'small', 'He', 'foxes', 'six']
lst3.sort(key=len)
lst3

Out[25]:

['He', 'saw', 'six', 'small', 'foxes']

5.2.6 切片

切片（Slice），是指通过序号选取序列类型（数组、列表、元组等）的子集。

切片基本形式是： [ 起始序号 : 结束序号 ]

实际选中的元素序号为：起始序号、起始序号+1、...、结束序号-1

也就是说，起始序号元素是被选中的，而结束序号的元素没有被选中。

注意：Python的序列类型，元素序号都是从0开始的。

In [26]:

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

Out[26]:

[1, 2, 3, 4]

切片时，起始序号空缺表示从0开始，结束序号空缺时，表示直到序列结尾处。

In [27]:

lst4[:5]

Out[27]:

[0, 1, 2, 3, 4]

In [28]:

lst4[3:]

Out[28]:

[3, 4, 5, 6, 7]

“起始序号”和“结束序号”也可以为负数，负数表示从结尾开始切片。“-i”表示从结尾往前数第i个元素（这里从1开始数）,其作用效果等价于“序列长度 - i”。

In [29]:

len(lst4)

Out[29]:

8

In [30]:

lst4[-2:]

Out[30]:

[6, 7]

In [31]:

lst4[ len(lst4)-2 : ]

Out[31]:

[6, 7]

In [32]:

lst4[-6 : -2]

Out[32]:

[2, 3, 4, 5]

In [33]:

lst4[len(lst4)-6 : len(lst4)-2]

Out[33]:

[2, 3, 4, 5]

还可以在切片时，再用一个冒号和数字，表示取元素的步长，比如每隔一位取一个元素：

In [34]:

lst4[::2]

Out[34]:

[0, 2, 4, 6]

步长取负数，表示从切片的结尾处开始，按步长取元素。比如步长用-1，可以实现逆序

In [35]:

lst4[::-1]

Out[35]:

[7, 6, 5, 4, 3, 2, 1, 0]

5.3 字典

字典（dict）是Python重要的数据结构之一。字典的特征：

字典的元素是一个“key : value”（键 : 值）的组合。其中键和值可以是Python的各种对象。

创建字典用大括号{}把元素包含在内，元素间用逗号隔开，每个元素的key和value之间用冒号隔开。

字典的长度、内容都是是可变的

与列表不同，访问字典内元素的方法，不是用序号，而是用key

字典的键必须是“不可变”对象，比如：标量、字符串、元组等

In [36]:

dct1 = {'a' : 'hello', 'b' : [1, 2, 3, 4]}
dct1

Out[36]:

{'a': 'hello', 'b': [1, 2, 3, 4]}

In [37]:

dct1[0] = 'bye'   #这里不是表示第0个元素，而是键值为0
dct1

Out[37]:

{'a': 'hello', 'b': [1, 2, 3, 4], 0: 'bye'}

In [38]:

dct1['a'] = 'hi'
dct1

Out[38]:

{'a': 'hi', 'b': [1, 2, 3, 4], 0: 'bye'}

用 in 关键字判断字典中是否包含某个key

In [39]:

'b' in dct1

Out[39]:

True

In [40]:

0 in dct1

Out[40]:

True

5.3.1 删除和添加元素

用del关键字或pop()方法删除字典的元素，它们的区别是，pop()方法除了删除元素之外，还返回了被删除的值。

In [41]:

dct1[5] = 'some value'
dct1['one'] = '某个数值'
dct1

Out[41]:

{'a': 'hi', 'b': [1, 2, 3, 4], 0: 'bye', 5: 'some value', 'one': '某个数值'}

In [42]:

del dct1[5]
ret = dct1.pop('one')
ret

Out[42]:

'某个数值'

In [43]:

dct1

Out[43]:

{'a': 'hi', 'b': [1, 2, 3, 4], 0: 'bye'}

用update()方法对字典增加新元素，或修改原有键的值

In [44]:

dct1.update({'b' : 'new value', 'c' : 12})
dct1

Out[44]:

{'a': 'hi', 'b': 'new value', 0: 'bye', 'c': 12}

5.3.2 获取所有键或值

用字典自带的keys()和values()方法，可以分别获得字典的所有键和值。需要注意的是，这里获取的键和值都是数据集合，一般要再用一个for循环结构才能获得某个键和值。

In [45]:

dct1.keys()

Out[45]:

dict_keys(['a', 'b', 0, 'c'])

In [46]:

dct1.values()

Out[46]:

dict_values(['hi', 'new value', 'bye', 12])

In [47]:

for v in dct1.values():
    print(v)

hi
new value
bye
12

5.3.3 从列表创建字典

将两个列表中的元素两两配对地组成一个字典,一个列表的元素成为字典的key，另一个列表的元素成为value。

这里可以使用Python内置的zip()函数。

In [48]:

lst1 = [0, 1, 2, 3]
lst2 = ['one', 'two', 'three']

dct2 = dict(zip(lst1, lst2))
dct2

Out[48]:

{0: 'one', 1: 'two', 2: 'three'}

5.4 集合Set

集合Set与数学中的集合概念一样，由一组不重复的对象组成。可以看作没有值只有键的字典。集合的特征：

集合内的元素可以是各种Python对象，但不能重复

集合内的元素是无序的，不能像list那样用序号访问元素,也不能切片操作

创建一个集合，可以用set()函数，或用大括号把元素包括起来即可。

In [49]:

set1 = {'hello', 1, 4.1}
set1

Out[49]:

{1, 'hello', 4.1}

以下例子中可以看出集合元素的唯一性特点

In [50]:

set2 = set([2, 2, 2, 1, 3, 3])
set2

Out[50]:

{1, 2, 3}

集合增加或删除元素。如果把一批对象加进集合中，实际上集合只会吸收那些新的对象，其他重复的对象被忽略掉。

In [51]:

set1.add('abc')
set1

Out[51]:

{1, 'hello', 4.1, 'abc'}

In [52]:

set1.add('hello')
set1

Out[52]:

{1, 'hello', 4.1, 'abc'}

In [53]:

set1.remove('abc')
set1

Out[53]:

{1, 'hello', 4.1}

集合之间可以进行交、并、差等运算，与我们在数学中的集合概念完全一样。

In [54]:

set1 | set2  # 并集

Out[54]:

{1, 2, 'hello', 4.1, 3}

In [55]:

set1 & set2  # 交集

Out[55]:

{1}

In [56]:

set1 - set2  # 差

Out[56]:

{'hello', 4.1}

In [57]:

set1 ^ set2  # 异或（对称差）

Out[57]:

{2, 3, 4.1, 'hello'}

判断两个集合之间是否子集或超集

In [58]:

set3 = {1, 2}
set3.issubset(set2)

Out[58]:

True

In [59]:

set2.issuperset(set3)

Out[59]:

True

集合的无序性

In [60]:

{1, 2, 3} == {3, 2, 1}

Out[60]:

True

5.5 元组、列表、字典、集合的遍历

对于本章所学习的元组、列表、字典和集合这几个结构化数据来说，遍历是最常用的操作，而且它们的遍历方法基本一致，就是用for循环实现。

元组的遍历

In [61]:

for element in tup1:
    print(element)

1
2
(3, 4)

In [62]:

for element in lst1:
    print(element)
    

0
1
2
3

In [63]:

for element in dct1:
    print(element)

a
b
0
c

In [64]:

for element in dct1.values():
    print(element)

hi
new value
bye
12

In [65]:

for element in set1:
    print(element)

1
hello
4.1