Python学习笔记——（1）Python的数据结构

1 概述

• Python的数据结构主要分为：列表（list）、数组（array）、元组（tuple）、集合（set）和字典（dict）
• 通常情况下这些都是基础知识，也有一些骚操作和黑科技，比较有意思

2 列表（list）

• 一种可以容纳不同数据类型元素的数组

2.1 列表的创建

a = []  # 这就创建了一个空列表

• 列表中可以包含数字、字符串等，还可以包含其他列表

2.2 列表索引

分为正向索引和负向索引，这个经常用到，所以重视

b[0]
b[1]  # 这样是正向索引
c[-1]  # 这样是选中c中的最后一个元素
c[-2][0]  # 这种情况一般出现在C列表中包含列表的情况，
# c[-2]代表c的倒数第二个元素，其本身是一个列表，
# c[-2][0]即代表c倒数第二个元素中的第一个元素。
# 例如：
c = [1, 12.4, "This is fantastic!", 23]
print(c[-2][0])
# 输出“T”

• 注意这里的字符串是一个字符数组，其也可以进行索引

2.3 列表的切片（重点）

1. a[1:5]选择a列表中的a[1]~a[4]5个元素
2. b[:2]选择b中前两个元素（即b[0], b[1]）
3. b[2:]选择b中后两个元素（即b[-2], b[-1]）
4. c[1::2]选择c中索引为奇数的元素
5. c[0::2]选择c中索引为偶数的元素

2.3.1 注意

• 中括号中的参数，用冒号分隔。第一个参数是起始位置，最后一个参数是结束位置
• 列表切片实行“左闭右开”原则，即得到的切片包含起始元素，但是不包含结束元素
• 第4、5条中，其实是省略了中间的结束元素，增加了第二个冒号后的第三元素，这个元素的意思是步长，即每隔2个数，切一次。默认步长为1.
• 参数中，起始如果是0可以省略；结束如果是最后，也可以省略；步长如果是1，可以省略。
• 切片后的列表和源列表是不同的列表，不会相互影响。

2.3.2 列表的复制和反转

• 如果直接用赋值表达式进行复制，如：

>>> a = ["I", "love", "Python"]
>>> b = a
# a的引用复制给b，在内存中其实是指向了用一个对象
>>> b is a
True
>>> id(a)
46381384
>>> id(b)
46381384
------
# 参考：【Python 中的比较：is 与 ==】https://www.cnblogs.com/kiko0o0/p/8135184.html

• 可以发现b和a的内存地址是相同的，它们指向同一块内存，因而 is 和 == 的结果都为True。
• 这样如果改变b中的值，a的值也会随之改变

---

• 但是如果利用切片进行复制就不会出现这种情况：

>>> b = [1,2,3,4]
>>> a = b[:]
>>> a is b
False
>>> a == b
True
>>> id(a), id(b)
(1936921175624, 1936921176648)

• 这里注意一下，python的节省内存的方式是非常牛逼的，比如，在我创建完上面a,b两个列表之后：

>>> a[0] is b[0]  # 值未改变的时候，元素中的内存是相同的
True
>>> a[0] = 10
>>> a[0] is b[0]  # 值改变之后，就会新建一个内存
False

---

• 言归正传：
• 复制：a = b[:]，其实还有一个方法：a = b.copy()
• 翻转：a = b[::-1]

2.4 列表的元素动态添加

2.4.1 append 在末尾添加元素

>>> a
[10, 2, 3, 4]
>>> a.append(5)
>>> a
[10, 2, 3, 4, 5]

2.4.2 extend 一次性添加多个元素

>>> a,b
([10, 2, 3, 4, 5], [1, 2, 3, 4])
>>> a.extend(b)  # 将b中的元素加入到a的末尾
>>> a
[10, 2, 3, 4, 5, 1, 2, 3, 4]
>>> a.append(b)  # 直接将b这个列表加入a的末尾
>>> a
[10, 2, 3, 4, 5, 1, 2, 3, 4, [1, 2, 3, 4]]

2.4.3 insert 插入

>>> b
[1, 2, 3, 4]
>>> b.insert(1, '1')
>>> b
[1, '1', 2, 3, 4]

2.5 列表的元素动态删除

2.5.1 clear 清空列表

• 这个方法和a = []等价

>>> a,d
([10, 2, 3, 4, 5, 1, 2, 3, 4, [1, '1', 2, 3, 4]], [10, 2, 3, 4, 5, 1, 2, 3, 4, [1, '1', 2, 3, 4]])
>>> a.clear()
>>> d = []
>>> a,d
([], [])

2.5.2 pop 将列表的最后元素删除，并作为返回值返回

>>> b
[1, '1', 2, 3, 4]
>>> b.pop()
4
>>> b
[1, '1', 2, 3]

2.5.3 remove 去除某个元素（第一次出现）

>>> a = [1,2,3,2,5]
>>> a.remove(2)
>>> a
[1, 3, 2, 5]
>>> a.remove(2)
>>> a
[1, 3, 5]

2.6 列表元素的原地复制和翻转

2.6.1 复制list.copy

• 在2.3.2小节提到过，对于列表的复制，可以直接用切片b = a[:]复制，也可以使用a.copy进行复制

>>> a = [1,2,3,4]
>>> b = a[:]
>>> c = a.copy()
>>> b,c
([1, 2, 3, 4], [1, 2, 3, 4])

2.6.2 原地翻转list.reverse

• 对于列表的翻转，在2.3.2小节提到的使用切片d = a[::-1]进行翻转。但是这种翻转是不会影响到a本身的值的。
• 使用原地翻转a.reverse可以实现对列表a本身的翻转。

>>> a
[1, 2, 3, 4]
>>> a.reverse()
>>> a
[4, 3, 2, 1]

3 数组（array）

• 仅支持一种数据类型的数组，其效率比列表要快，如果数组中仅有数字或字符串，建议使用这种数据结构。
• array数组具有和list列表的很多相同的方法，这里不再赘述
• 【注意】使用数组时需要先引入array库

>>> from array import array
>>> array_a = array('i', a)
>>> array_a
array('i', [4, 3, 2, 1])
>>> import sys
>>> sys.getsizeof(a), sys.getsizeof(array_a)  # 获取所占内存的大小
(96, 80)

4 元组（tuple）

• 元素不可变的列表，使用()包含元素
• 但是如果元组中嵌套了列表，可以改变列表中的内容，如：

>>> c = (1,2,3,4,a)
>>> c
(1, 2, 3, 4, [4, 3, 2, 1])
>>> c[4][0] = 1
>>> c
(1, 2, 3, 4, [1, 3, 2, 1])

5 集合（set）

• 无重复元素的列表，使用{}包含元素
• 相比于列表，集合查询元素的速度更快，更容易实现数学上对集合定义的交并补差等操作

>>> a = {'123', '456', '123'}
>>> a
{'123', '456'}

6 字典（dict）

• 拥有键（key）值（value）对的一种数据结构
• 在默认情况下会查找键而不会查找值，除非显式调用values()方法
• 索引也是对于键的索引，而不是在字典中的位置。

>>> d
{1: 'a', 2: 'b', 'c': 3}
>>> 'a' in d
False
>>> 'a' in d.values()
True
>>> d[1]
'a'
>>> d['c']
3

---

下一章：python中的遍历