Python学习笔记(六)：数据类型之 List

---

序列是 python 中最基本的数据类型。序列中的每个元素都分配一个索引，索引从 0 开始；

python 有六个序列的内置类型，最常见的是列表和元祖；

序列都可以进行的操作，包括索引、切片、加、乘、检查成员；

此外，python 已经内置确定序列的长度，以及确定最大和最小的元素的方法；

---

List（列表）  

• List（列表） 是 Python 中使用最频繁的数据类型。

• List 可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

• List 是写在方括号 [] 之间、用逗号分隔开的元素列表。

# 定义一个列表：列表中元素的类型可以不相同，元素之间用逗号分隔
list = ['abcd', 786 , 2.23, 'runoob', 70.2]

• 和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

• 列表截取的语法格式如下：索引值以 0 为开始值，-1 为从末尾的开始位置。

变量[头下标:尾下标]

• 加号（+） 是列表连接运算符，星号 （*） 是重复操作。如下实例：

# 列表中元素的类型可以不相同
list = ['abcd', 786 , 2.23, 'runoob', 70.2]
tinylist = [123, 'runoob']

print (list)            # 输出完整列表
print (list[0])         # 输出列表第一个元素
print (list[1:3])       # 从第二个开始输出到第三个元素
print (list[2:])        # 输出从第三个元素开始的所有元素
print (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 连接列表

输出结果：

• Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：

# 列表中元素的类型可以不相同
list = ['abcd', 786 , 2.23, 'runoob', 70.2]

# 获取列表中第 2 个元素到第 5 个元素，并且获取元素的步长为 2，即隔一个元素获取一个元素；
print(list[1:4:2])

输出结果：

• 与 Python 字符串不一样的是，列表中的元素是可以改变的：

# 列表中元素的类型可以不相同
list = ['abcd', 786 , 2.23, 'runoob', 70.2]

# 修改列表第一个元素的值
list[0] = 123

# 修改列表第 3 到第 5 个元素的值
list[2:4] = ["hello", 3.14, True]

# 输出列表的所有值
print(list)

输出结果：

• 可以使用 del 语句删除列表中的元素：

# 定义一个列表
list = ['how', 'are', 'you', 33]

print("原始列表 : ", list)
del list[2] # 删除列表的第三个元素
print("删除第三个元素：", list)

输出结果：

• 可以使用 in 和 not in 判断某个对象是否在列表中；

list1 = ["how", "are", "you"]

# 使用 in 和 not in 判断某个对象是否在列表中
print("how" in list1)       # True
print("hello" in list1)     # False
print("hello" not in list1) # True

 

 

Python 中列表（List）的内置方法：

1、list.appent(obj)：在列表末尾添加新的对象；该方法无返回值，但是会修改原来的列表；

list1 = ['how', 'are', 'you']
list2 = ["i", "am", "fine"]

list1.append("what?")       # 在列表的末尾添加字符串
print(list1)

list1.append(3.14)          # 在列表的末尾添加数字
print(list1)

# 在列表的末尾添加列表（新添加的列表作为原列表的一个元素，即嵌套）
list1.append(list2)
print(list1)

输出结果：

2、list.extend(seq)：该函数用于在列表末尾一次性追加另一个序列中的多个值；参数 seq 可以是列表、元组、集合、字典，如果是字典，则仅会将键（key）作为元素依次添加至原列表的末尾；该方法没有返回值，但是会在原列表中添加新的元素；

list1 = ["how", "are", "you"]   # 定义一个列表
tuple1 = ("i", "am", "fine")    # 定义一个元组
set1 = {"thank", "you"}         # 定义一个集合

# 将元组中的元素添加到列表中
list1.extend(tuple1)
print(list1)

# 将集合中的元素添加到列表中；
# 由于集合中的元素是无序的，所以添加的时候，thank 元素不一定在 you 元素前面；
list1.extend(set1)
print(list1)

print("============================")

# append() 方法和 extend() 方法的区别：
# 使用 append() 方法将 list2 添加到 list1 的末尾时，list2 整体是作为 list1 的一个元素（相当于嵌套）；
# 使用 extend() 方法将 list2 添加到 list1 的末尾时，是将 list2 中的所有元素追加到 list1 的末尾；
list1 = ["how", "are", "you"]
list2 = ["hello", "world", 123]

list1.append(list2)     # 使用 append() 方法将 list2 添加到 list1 的末尾
print(list1)

list1 = ["how", "are", "you"]
list1.extend(list2)     # 使用 extend() 方法将 list2 添加到 list1 的末尾
print(list1)

输出结果：

3、list.count(obj)：用于统计某个元素在列表中出现的次数；

4、list.index(x[, start[, end]])：从列表中查找指定元素第一次出现的位置；如果没有找到，则抛出异常；如果参数 start 和 end 存在，则表示在列表中指定的范围内查找；

list1 = ["how", "are", "you", "i", "am", "fine", "thank", "you"]

# 查看列表中元素 you 第一次出现的位置
print(list1.index("you"))

print(list1[7])

# 从列表中，元素索引为 3-7 的范围内，查找元素 you 第一次出现的位置：结果抛出异常，
# 可见，3-7 的范围，是左闭右开的，即 [3, 7)，包含索引为 3 的元素，但是不包含索引为 7 的元素；
print(list1.index("you", 3, 7))

输出结果：

5、list.insert(index, obj)：用于将指定对象插入到列表的指定位置；该函数无返回值，但是会修改原列表；

list1 = ["how", "are", "you"]

# 将字符串 hello 插入到列表中索引为 2 的位置
list1.insert(2, "hello")
print(list1)

# 将数值 3.14 插入到列表中索引为 3 的位置；
# 注意：此时的列表，已经包含了上面插入的 hello；
list1.insert(3, 3.14)
print(list1)

# 将 list2 插入到 list1 中索引为 2 的位置；
# 注意：此时 list2 是作为一个元素存在，即 list1列表 中嵌套 list2列表；
list2 = ["thank", "you"]
list1.insert(2, list2)
print(list1)

 输出结果：

6、list.pop([index=-1])：用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值；

index 为可选参数，表示要移除元素的索引值，不能超过列表总长度，默认为 index = -1，即移除最后一个元素。

list1 = ["how", "are", "you"]
print(list1.pop())  # 默认移除列表最后一个元素，并返回该元素
print(list1)        # 输出修改后的元素

list1 = ["how", "are", "you"]
print(list1.pop(1)) # 移除列表中索引为 1 的元素，并返回该元素
print(list1)        # 输出修改后的元素

输出结果：

7、list.remove(obj)：用于移除列表中某个元素的第一个匹配项；该方法没有返回值，但是会修改原列表；

list1 = ["how", "are", "you", "i", "am", "fine", "thank", "you"]

# 移除列表中的元素 you，如果有多个 you，只会移除第一个；
list1.remove("you") 
print(list1)

输出结果：

8、list.reverse()：用于对列表中的元素进行反向排序；该方法没有返回值，但是会修改原列表；

9、list.sort( key=None, reverse=False)：用于对列表中的元素进行排序；如果指定了参数，就根据参数表示的规则进行排序；

• key：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

  上面这句对 key 参数的解释是学习资料上写的，但是一开始完全看不懂是什么意思，于是查了一下其他资料，根据我自己的理解就是：因为排序只能使用一个具体的数值或者字符串去比较，但是如果列表中的元素不是一个具体的值，而是另一个集合或者元组等，那就不好进行比较了，比如 [(2, 2), (3, 4), (4, 1), (1, 3)] 这种列表中嵌套元组的情况，我们就没办法直接用列表的元素（元组）去进行比较；这时候就需要使用 key 这个参数了，这个参数可以是一个函数，并且这个函数有一个返回值，那么我们就可以使用这个函数的返回值去进行比较了。

• reverse：排序规则，默认为 False，表示正向排序（升序）；如果为 True，表示反向排序（即降序）；

list1 = ["how", "are", "you", "i", "am", "fine", "thank", "you"]

list1.reverse();    # 对列表中的元素进行反向排序
print(list1)        # 输出排序之后的列表

list1.sort()        # 对列表中的元素进行升序排序（默认情况）
print(list1)

list1.sort(reverse=True)   # 对列表中的元素进行降序排序
print(list1)

print("********************")

# 如果列表中的元素是另一个列表，或者元组等，那么就不能直接用列表的元素进行比较了；
list1 = [(2, 2), (3, 4), (4, 1), (1, 3)]

# 定义一个方法，接收一个元组，返回元组的第二个元素
def getSecond(element):
    return element[1]

# 表示将 list1 的元素（元组）传入 getSecond 方法，然后返回元组的第二个元素，
# 然后 list1 根据元组的第二个元素进行排序；
list1.sort(key=getSecond)
print(list1)

输出结果：

10、list.clear()：清空列表，类似于 del [:]；该方法没有返回值，但是会修改原列表；

11、list.copy()：复制列表，返回复制后的新列表；

list1 = ["how", "are", "you"]

print(list1.copy()) # 复制列表，返回复制后的新列表

list1.clear()       # 清空列表
print(list1)

输出结果：