Python搬砖之旅(4th day)：列表数据类型专题

Python搬砖之旅(4th day)：列表数据类型专题

第1章 列表的创建

列表是在Python编程过程中最常见的数据类型之一。列表是一组"有序的、可重复的元素集合"，也就是说，从数据结构角度看，Python 的列表是一个"长度可变"的、每一个元素顺序排列的"队列"，列表中的每一
个位置存放的都是数据对象的"指针"。

我们可以将不同数据类型的元素"有序"地存放在列表当中，元素与元素之间使用逗号","隔开。

>>> li = [123, 123.5, "hello", b'Python', [1, 2, 3]]
>>> li
[123, 123.5, 'hello', b'Python', [1, 2, 3]]
>>> id(li)
45716616
>>> id(li[0])
1745059104
>>> id(li[1])
29956880
>>> id(li[2])
45734128
>>> id(li[3])
37271792
>>> id(li[4])
45740552

列表创建之后，为什么其中的数据类型可以不一样呢？
因为列表中的每一个的元素，都是一个指针，指向不同的数据对象。我们使用id()函数分别查看li, li[0], li[1], li[2], li[3], li[4]在内存中的地址，发现其实这些元素在内存空间上都是"不连续"的，而正因为列表中包含了指向这些元素的"指针"，这些元素看起来才是"有序"的。下面使用一幅图来说明这个问题。

创建空列表的两种方法：
第1种，使用一对方括号。

li = []    #  创建一个空列表。
>>> 

第2种方法：调用list() 方法

li = list()

这两种方法的效果是一样的。

第2章 访问并修改列表元素

与字符串相似，列表也是通过index索引访问列表中的元素。

>>> li = [123, 123.5, "hello", b'Python', [1, 2, 3]]
>>> li[0]
123
>>> li[1]
123.5
>>> li[2]
'hello'
>>> li[3]
b'Python'
>>> li[4]
[1, 2, 3]
>>> li[-1]
[1, 2, 3]

注意：索引的数值不能超出列表的长度（列表中的元素个数）

与字符串不同的是，字符串是"不可修改"的序列，如果要修改字符串中的某个字符需要重新赋值；
但是，列表中的元素可以直接通过索引访问并修改元素。

>>> li = [123, 123.5, "hello", b'Python', [1, 2, 3]]
>>> li[-1] = [1, 2, 3, 4]     # 修改列表中最后一个元素
>>> li
[123, 123.5, 'hello', b'Python', [1, 2, 3, 4]]
>>> li[0], li[1] = li[1], li[0]    # 列表中前两个元素互换
>>> li
[123.5, 123, 'hello', b'Python', [1, 2, 3, 4]]

小练习：
li = [‘a’, ‘b’, ‘c’]， 将’a’ 改为 ‘A’。
答案：li[0] = ‘A’

第3章 遍历列表元素

列表的遍历有四种方式：
第1种方式：使用while循环

li = [123, 123.5, "hello", b'Python', [1, 2, 3]]
i = 0    # 设置索引从0开始
while i < len(li):
    print(li[i], end=" ")
    i += 1

第2种方式：使用迭代

li = [123, 123.5, "hello", b'Python', [1, 2, 3]]
for i in li:
    print(i, end=" ")

第3种方式：使用迭代+索引

li = [123, 123.5, "hello", b'Python', [1, 2, 3]]
for i in range(len(li)):
    print(li[i], end=" ")

第4种：使用enumerate()函数遍历
enumerate()函数可以将一个可迭代对象，如列表、元组或字符串组合成为一个索引序列，同时列出索引和元素值，一般与for 循环结合使用。

li = [123, 123.5, "hello", b'Python', [1, 2, 3]]
for i, value in enumerate(li):
    print(f'第{i}个索引对应的值是：{value}', end="\n")

第4章 增加列表元素

增加列表元素的方式有3种：
方法1：使用list.insert (index, obj)的方法，将数据对象obj插入到列表指定的位置上。

>>> li = [1, 2, 3]
>>> li.insert(0, "a")   # 把字符串"a"插入到列表的第一个位置
>>> li
['a', 1, 2, 3]

方法2：使用list.append(obj)的方法，将数据对象obj插入到列表的最后。

>>> li = [1, 2, 3]
>>> li.append("a")      # append()方法会把元素插入到列表末尾
>>> li
[1, 2, 3, 'a']

方法3： 使用list.extend() 方法，将两个列表的元素合并到一个列表中。

>>> li_1 = ["a", "b", "c"]
>>> li_2 = [1, 2, 3]
>>> li_1.extend(li_2)
>>> li_1
['a', 'b', 'c', 1, 2, 3]

注意：
append()方法与extend()方法的区别：
append()方法是将对象整体作为一个元素加入列表；而extend()方法是将另一个列表的所有元素与原来的列表合，原列表的内存地址不会发生变化。
提问：
li_1 = [“1”, “2”, “3”]，li_2 = [“4”, “5”, “6”]
那么，li_1.append(li_2) 与 li_1.extend(li_2)的结果分别是什么？
答案：

>>> li_1 = ["1", "2", "3"]
>>> li_2 = ["4", "5", "6"]
>>> li_1.append(li_2)   # append()方法是将对象整体作为一个元素加入列表
>>> print(li_1)
['1', '2', '3', ['4', '5', '6']]
>>> li_1 = ["1", "2", "3"]
>>> li_2 = ["4", "5", "6"]
>>> li_1.extend(li_2)
>>> print(li_1)         # extend()方法是将另一个列表的所有元素与原来的列表合并
['1', '2', '3', '4', '5', '6']

第5章 删除列表元素

删除列表元素有3种方法。
方法1：使用del li[index]的方法

>>> li = [123, 123.5, "hello", b'Python', [1, 2, 3]]
>>> del li[0]
>>> li
[123.5, 'hello', b'Python', [1, 2, 3]]
>>> del li
>>> li
Traceback (most recent call last):
  File "<pyshell#24>", line 1, in <module>
    li
NameError: name 'li' is not defined

说明：
1，使用del 语句，会对列表造成永久性的改变，会将索引对应的元素从列表中删除‘
2，直接使用del + 列表名的方式，会永久性删除该列表。

方法2：
使用list.remove(value)的方式。

>>> li = [123, 123.5, "hello", b'Python', [1, 2, 3]]
>>> li.remove(123)
>>> li
[123.5, 'hello', b'Python', [1, 2, 3]]
>>> li.remove('China')
Traceback (most recent call last):
  File "<pyshell#29>", line 1, in <module>
    li.remove('China')
ValueError: list.remove(x): x not in list

说明：
1，使用remove()方法，会对列表造成永久性的改变，会将值所对应的元素从列表中删除‘；
2，删除不存在于列表中的值会报错。

方法3：
使用list.pop(index)的方式

>>> li = [123, 123.5, "hello", b'Python', [1, 2, 3]]
>>> li.pop()
[1, 2, 3]
>>> li
[123, 123.5, 'hello', b'Python']
>>> li.pop(0)
123
>>> li
[123.5, 'hello', b'Python']

说明：
1，使用pop()方法，会对列表造成永久性的改变，会将索引所对应的元素从列表中删除‘并返回该值；
2，pop()方法默认删除并返回列表中最后一个元素，使用索引后删除并返回索引对应的值。

第6章 列表的运算符

同字符串一样，列表可以使用"+“实现字符串的拼接，用”*"实现字符串的序列复制。
用in 和 not in 判断元素是否存在于列表当中。

>>> li_1, li_2 = ["a", "b", "c"], [1, 2, 3]
>>> print(li_1 + li_2)    # + 运算符实现列表元素的拼接
['a', 'b', 'c', 1, 2, 3]
>>> print(li_1 * 2)       # * 运算符实现列表元素的复制
['a', 'b', 'c', 'a', 'b', 'c']
>>> print('a' in li_1)    # in 运算符判断元素是否属于列表
True
>>> print(2 not in li_2)  # not in 运算符判断元素是否不属于列表
False

注意："+" 运算符的功能等同于list.extend()方法，但是推荐使用"+" 运算符，可以获得更直观的效果和更高的运行效率。

第7章 列表的常用内置函数

len() : 返回列表的长度，即列表中包含的元素个数；
max() : 返回列表中的元素最大值；
min()： 返回列表中的元素最小值。
count() ： 返回元素在列表中出现的次数
index(value)：从列表中找出value第一个匹配项的索引位置
copy() ： 复制列表
clear() ： 清空列表

>>> li = [1, 1, 2, 2, 2, 4, 3, 5]
>>> print(len(li))    # 计算列表长度
8
>>> print(min(li))    # 求列表中的最小值
1
>>> print(max(li))    # 求列表中的最大值
5
>>> print(li.count(2))   # 求列表中元素出现的次数
3
>>> print(li.index(2))   # 求元素在列表中首次出现的位置
2
>>> li_2 = li.copy()     # 复制列表
>>> li_2
[1, 1, 2, 2, 2, 4, 3, 5]
>>> li_2.clear()         # 清除列表
>>> li_2
[]

注意：列表中元素比较大小，
1，字符串与字符串之间比较转为ASCII码比较；
2，字符串与数字之间不可以比较，否则会报错。

第8章 列表的切片

同字符串一样，我们可以对列表进行切片。
切片的语法格式是：list[start : stop : step]
当start起点位置是列表首位时，start 可以忽略；当end终点位置是len(list)+1时，即取到列表最后一位时，stop 可以省略；当步长为1时，step可以省略。

同字符串一样，列表中元素的位置按从左向右的顺序，从0开始依次向后；
逆向位置排列是从最后一个元素的位置-1开始，向前依次递减；
切片的索引发生错误并不会报错，而是会返回空字符串。

>>> li = [123, 123.5, "hello", b'Python', [1, 2, 3]]
>>> li[:]   # 该方法相当于li[0:len(li)+1:1]
[123, 123.5, 'hello', b'Python', [1, 2, 3]]
>>> li[::2] # 该方法相当于li[0:len(li)+1:2]
[123, 'hello', [1, 2, 3]]
>>> li[1::2] # 该方法相当于li[1:len(li)+1:2]
[123.5, b'Python']
>>> li[::-1] # 该方法相当于li[-1:-6:-1]
[[1, 2, 3], b'Python', 'hello', 123.5, 123]
>>> li[::-2] # 该方法相当于li[-1:-6:-2]
[[1, 2, 3], 'hello', 123]
>>> li[-2::-2]  # 该方法相当于li[-2:-6:-2]
[b'Python', 123.5]

需要注意的是，
1，切片的方向与步长方向应一致，否则会返回空字符串。
2，修改列表的切片会影响列表本身。

第9章 列表的排序

列表的排序：
升序排列：使用list.sort()方法或sorted(list)方法
降序排列：使用list.sort(reverse=True)方法

>>> li = [32, 77, 64, 27, 55, 96, 13]
>>> li.sort()   # sort()方法会永久改变列表中元素的顺序
>>> li
[13, 27, 32, 55, 64, 77, 96]

>>> li = [32, 77, 64, 27, 55, 96, 13]
>>> print(sorted(li))   # sorted()方法是一个临时性方法，不会永久改变列表中元素的顺序
[13, 27, 32, 55, 64, 77, 96]
>>> print(li)
[32, 77, 64, 27, 55, 96, 13]

>>> li.sort(reverse = True)   # 实现列表的降序排列需要使用参数reverse=True
>>> li
[96, 77, 64, 55, 32, 27, 13]

注意：
1，sort()方法会永久改变列表中元素的顺序。
2，sorted()方法是一个临时性方法，不会永久改变列表中元素的顺序。
3，实现列表的降序排列需要使用参数reverse=True。

第10章 列表的转置

实现列表的转置有3种方法：
方法1：使用切片。注意，切片只是在列表的副本上操作，并不会影响列表本身。

>>> li = [32, 77, 64, 27, 55, 96, 13]
>>> print(li[::-1]) 
[13, 96, 55, 27, 64, 77, 32]
>>> print(li)
[32, 77, 64, 27, 55, 96, 13]

方法2：使用list.reverse()方法。注意，reverse()方法会永久改变列表中元素的顺序。

>>> li = [32, 77, 64, 27, 55, 96, 13]
>>> li.reverse()   # reverse()方法会永久地改变列表中元素的顺序
>>> print(li)
[13, 96, 55, 27, 64, 77, 32]
>>> print(li.reverse()) # reverse()方法不返回值
None

方法3：使用reversed(list)方法。注意，reversed方法是一个临时性的方法，不会改变列表本身。

>>> li = [32, 77, 64, 27, 55, 96, 13]
>>> print(reversed(li))   # reversed()方法不能直接使用，需要转化为列表才可以使用
<list_reverseiterator object at 0x0000000002BCD4A8>
>>> li_2 = list(reversed(li))
>>> print(li_2)    # 强制类型转化为列表
[13, 96, 55, 27, 64, 77, 32]
>>> print(li)
[32, 77, 64, 27, 55, 96, 13]

第11章 列表的嵌套

列表中包含的元素仍然是列表，通常称为列表的嵌套。嵌套的层数也称之为列表的维度。
比如下面这个列表就是一个典型的二维列表，我们可以通过索引的方式来访问子列表中的元素。
观察下列代码，学习使用迭代和索引的方法访问二维列表中的元素。

li = [[1, 2, 3],[1.1, 2.2, 3.3],["a", "b", "c"]]
# 获得第二个子列表中1.1这个元素
print(li[1][0])
# 遍历二维列表
# 方法1：迭代
for list_item in li:
    for item in list_item:
        print(item, end=" ")
print()
# 方法2：使用索引
for i in range(len(li)):
    for j in range(len(li[i])):
        print(li[i][j], end=" ")