文章目录
  1. 1. Python数据结构的类型
    1. 1.1. List(列表)
      1. 1.1.1. 列表的构建
      2. 1.1.2. 列表的索引
      3. 1.1.3. 列表的切片
      4. 1.1.4. 列表的串联
      5. 1.1.5. 列表的赋值
    2. 1.2. Tuple(元组)
      1. 1.2.1. 元组的构建
      2. 1.2.2. 元组的索引与切片
      3. 1.2.3. 元组的串联
      4. 1.2.4. 元组的特殊语法

这几天闲着无事,准备着手总结一些Python常用的数据结构,我们知道,一个程序里面必然会有数据的存在,同样的一个或几个数据要组织起来,可以有不同的组织方式,也就是不同的存储方式。不同的组织方式就是不同的结构,我们把这些数据组织在一起的结构称之为数据的结构,也叫做数据结构。Python中数据的组织方式叫做Python的数据结构。

Python数据结构的类型

Python作为一门日趋流行且壮大的编程语言,所拥有的数据类型是相当丰富的,因而可见它的数据结构也是非常多的,其中,Python中系统自己定义好的,不需要我们自己去定义的数据结构叫做Python的内置数据结构,比如列表、元组等,而有些数据组织方式,Python系统里面没有直接定义,需要我们自己去定义实现这些数据的组织方式,这些数据组织方式称为Python的扩展数据结构,比如栈、队列等。

List(列表)

List(列表) 是 Python 中使用最频繁的数据类型。
列表是写在方括号之间、用逗号分隔开的元素列表。列表中元素的类型可以不相同:

列表的构建

1
2
3
>>> a = ['apple', 100, 200, 'pear']
>>> print(a)
['apple', 100, 200, 'pear']

列表同样可以被索引和切片(所谓的索引和切片就是可以进行查找和截取相应的内容),列表被切片后返回一个包含所需元素的新列表。

列表的索引

1
2
3
>>> a = ['apple', 100, 200, 'pear']
>>> print(a[2])
200

注意:在Python的列表中,起始位置是从0开始的,a[2]实际输出的数据是列表中第3个数据

列表的切片

1
2
3
>>> a = ['apple', 100, 200, 'pear']
>>> print(a[0:2])
['apple', 100]

列表的串联

此外列表还支持串联操作,使用+操作符:

1
2
3
>>> a = [1, 2, 3, 4, 5]
>>> a + [6, 7, 8]
[1, 2, 3, 4, 5, 6, 7, 8]

列表的赋值

对于强大的Python来说,在Python的列表中的元素是可以改变的:

1
2
3
4
5
6
7
8
>>> a = [1, 2, 3, 4, 5, 6]
>>> a[0] = 9
>>> a[2:5] = [13, 14, 15]
>>> a
[9, 2, 13, 14, 15, 6]
>>> a[2:5] = [] # 删除此段列表
>>> a
[9, 2, 6]

此外List还内置了有很多方法,例如append()、pop()等等。如下表所示:

方法 描述
list.append(x) 把一个元素添加到列表的结尾,相当于 a[len(a):] = [x]。
list.extend(L) 通过添加指定列表的所有元素来扩充列表,相当于 a[len(a):] = L。
list.insert(i, x) 在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引,例如 a.insert(0, x) 会插入到整个列表之前,而 a.insert(len(a), x) 相当于 a.append(x) 。
list.remove(x) 删除列表中值为 x 的第一个元素。如果没有这样的元素,就会返回一个错误。
list.pop([i]) 从列表的指定位置删除元素,并将其返回。如果没有指定索引,a.pop()返回最后一个元素。元素随即从列表中被删除。(方法中 i 两边的方括号表示这个参数是可选的,而不是要求你输入一对方括号,你会经常在 Python 库参考手册中遇到这样的标记。)
list.clear() 移除列表中的所有项,等于del a[:]。
list.index(x) 返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
list.count(x) 返回 x 在列表中出现的次数。
list.sort() 对列表中的元素进行排序。
list.reverse() 倒排列表中的元素。
list.copy() 返回列表的浅复制,等于a[:]。

下面是表格中大部分方法的实例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.25, 333, -1, 333, 1, 1234.5, 333]
>>> a.index(333)
1
>>> a.remove(333)
>>> a
[66.25, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.25]
>>> a.sort()
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]

注意:

  1. List写在方括号之间,元素用逗号隔开。
  2. 和字符串一样,list可以被索引和切片。
  3. List可以使用+操作符进行拼接。
  4. List中的元素是可以改变的。

Tuple(元组)

元组(tuple)与列表类似,不同之处在于元组的元素不能修改。元组写在小括号里,元素之间用逗号隔开。

元组的构建

元组中的元素类型也可以不相同:

1
2
3
>>> a = ('apple', 100, 200, 'pear')
>>> print(a, type(a), len(a))
('apple', 100, 200, 'pear') <class 'tuple'> 4

元组的索引与切片

元组与列表类似,可以被索引且下标索引从0开始,也可以进行截取/切片(看上面,这里不再赘述)。

1
2
3
4
>>> tup = (1, 2, 3, 4, 5, 6)
>>> print(tup[0], tup[1:5])
1 (2, 3, 4, 5)
>>> tup[0] = 11 # 修改元组元素的操作是非法的

虽然tuple的元素不可改变,但它可以包含可变的对象,比如list列表。

元组的串联

此外,元组也支持用+操作符:

1
2
3
>>> tup1, tup2 = (1, 2, 3), (4, 5, 6)
>>> print(tup1+tup2)
(1, 2, 3, 4, 5, 6)

元组的特殊语法

构造包含0个或1个元素的tuple是个特殊的问题,所以有一些额外的语法规则:

1
2
tup1 = () # 空元组
tup2 = (20,) # 一个元素,需要在元素后添加逗号

string、list和tuple都属于sequence(序列)。

注意:

  1. 与字符串一样,元组的元素不能修改。
  2. 元组也可以被索引和切片,方法一样。
  3. 注意构造包含0或1个元素的元组的特殊语法规则。
  4. 元组也可以使用+操作符进行拼接。

文章出自:Krzer http://www.krzer.com/版权所有。本站文章除注明出处外,皆为作者原创文章,可自由引用,但请注明来源。

文章目录
  1. 1. Python数据结构的类型
    1. 1.1. List(列表)
      1. 1.1.1. 列表的构建
      2. 1.1.2. 列表的索引
      3. 1.1.3. 列表的切片
      4. 1.1.4. 列表的串联
      5. 1.1.5. 列表的赋值
    2. 1.2. Tuple(元组)
      1. 1.2.1. 元组的构建
      2. 1.2.2. 元组的索引与切片
      3. 1.2.3. 元组的串联
      4. 1.2.4. 元组的特殊语法