Python基础 6》数据类型_列表（List）

一、列表的定义

列表是一个有序且可变的数据容器。在Python中，使用[]进行编写。

列表中每一个元素的数据类型是没有限制的，可以是任意的数据类型，例如：字符串、数字、布尔、列表、字典等。

"""
列表的定义
- 列表是Python中最基本的数据结构
- 列表中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
- 列表可以进行的操作包括索引，切片，加，乘，检查成员。
- 此外，Python已经内置确定列表的长度以及确定最大和最小的元素的方法。
- 列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
- 列表的数据项不需要具有相同的类型
- 列表是可变类型的数据
- 列表是序列类型的数据# 定义列表变量.
变量名称 = [元素1, 元素2, 元素3, 元素4 ....]
# 定义一个空列表
变量名称 = []
变量名称 = list()# 列表中可以存储任意类型的元素
# 列表中可以存储相同的元素
# 列表中的元素可以是列表
"""
# 列表可以同时存放多个、多种数据类型的数据，列表中每个子元素用`逗号`分割。
course = ["Python", "Java", "Go", "HTML", "JavaScript", {"name": "xuan"}, (1, 2, 3), [1, 2, 3], {1, 2, 3}]
print(course)l = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
print(l, type(l))print(list("Python"))  # ['P', 'y', 't', 'h', 'o', 'n']
print(list((1, 2, 3)))  # [1, 2, 3]
print(list({1, 2, 3}))  # [1, 2, 3]
# 列表在强制转换字典的时候默认转换出来的是字典的键
print(list({"name": "Python", "age": 18}))  # ['name', 'age']
# 强调 : 列表转换成字符串以后再转换会列表是没办法转回列表的！
data_list = [1, 2, 3]
data_str = str(data_list)  # '[1, 2, 3]'
print(data_str)  # [1, 2, 3]
data_str_list = list(data_str)
print(data_str_list)  # ['[', '1', ',', ' ', '2', ',', ' ', '3', ']']

列表的特点：

1. 可以容纳多个元素：
2. 32位平台（Python）下 List 上限容纳 $2^{31}-1$个元素。
3. 64位平台（Python）下 List 上限容纳 $2^{63}-1$个元素。
4. 可以容纳不同数据类型的数据
5. 列表是有序的
6. 列表允许数据是重复的
7. 列表里面的元素是可变的，因为是可变数据类型

二、列表的值操作

1.列表的取值

"""
列表的取值
- 列表的取值和字符串的取值类似
- 列表的索引从0开始
- 列表的索引可以是负数
- 列表的索引可以是切片有两种方式：
1. 使用索引取值
2. 使用切片取值
"""

1.1.列表的下标（索引）

列表的下标和字符串的类似。

• 正向索引：从 0 开始，从左向右。
• 负向索引：从 -1 开始，从右向左。

"""
列表的取值
- 列表的取值和字符串的取值类似
- 列表的索引从0开始
- 列表的索引可以是负数
- 列表的索引可以是切片有两种方式：
1. 使用索引取值
2. 使用切片取值
"""
# 列表的下标（索引）
# 列表的下标（索引）和字符串的下标（索引）一样
l = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]print(l[0])
print(l[1])
print(l[2])
print(l[-1])
print(l[-2])
print(l[-3])# 如果列表的索引超出了范围会报错
# print(l[6])  # IndexError: list index out of range# 在嵌套的列表中, 列表的下标会取出下标对应的元素整体, 而不是取出对应元素的部分.
stu_info = [['zhangsan', '男', 18],['lisi', '男', 17],['wangwu', '女', 19],
]
print(stu_info[0])  # ['zhangsan', '男', 18]

1.2.列表的切片

"""
列表的切片操作
- 列表的切片和字符串的切片类似
- 列表的切片操作返回的是一个新的列表
- 列表的切片操作不会改变原有的列表列表的切片语法：[start:end:step]
- start:起始索引
- end:结束索引
- step:步长，默认为1
"""# 列表的切片操作
l = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
print(l[0:3])  # ['Python', 'C++', 'Java']
print(l[0:5:2])  # ['Python', 'Java', 'Ruby']
print(l[-3:])  # ['PHP', 'Ruby', 'MATLAB']
print(l[-5:-1])  # ['C++', 'Java', 'PHP', 'Ruby']
# 列表元素反转
print(l[::-1])  # ['MATLAB', 'Ruby', 'PHP', 'Java', 'C++', 'Python']

2.列表的添加

"""
列表的添加
- append() 方法用于在列表的末尾追加元素
- insert() 方法用于在列表的指定位置插入元素
- extend() 方法用于在列表的末尾追加另一个序列中的多个值（用新列表扩展原来的列表）列表的拼接：
- + 号用于拼接两个列表
- * 号用于重复列表
"""# 列表的添加
# append() 方法用于在列表的末尾追加元素
l = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
l.append("C#")
print(l)# insert() 方法用于在列表的指定位置插入元素
l.insert(1, "Go")
print(l)# extend() 方法用于在列表的末尾追加另一个序列中的多个值（用新列表扩展原来的列表）
# extend() 方法可以传入一个序列类型的数据，但是传入的序列类型的数据必须是可迭代的。
l.extend(["JavaScript", "HTML"])
print(l)
l.extend(("JavaScript1", "HTML1"))
print(l)
l.extend({"JavaScript2", "HTML2"})
print(l)
l.extend({"name": "Python", "age": 18})
print(l)#  列表的拼接
# + 号用于拼接两个列表
l1 = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
l2 = ["JavaScript", "HTML"]
print(l1 + l2)# * 号用于重复列表
print([1, 2, 3] * 2)

3.列表的修改

本质上是两种修改值的方法：

• 直接索引赋值-修改单个元素
• 切片赋值-修改连续元素

"""
列表的修改
通过索引获取到列表中的元素，然后重新赋值
列表的修改操作不会返回新的列表，而是在原有的列表上进行修改
"""# 列表的修改
# 直接索引赋值 - 修改单个元素
l = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
print(id(l), l)
l[0] = "Python3"
l[-1] = "MATLAB7"
print(id(l), l)# 切片赋值 - 修改连续元素或插入
numbers = [1, 2, 3, 4, 5]
print(id(numbers), numbers)
numbers[1:4] = [20, 30, 40]  # 替换索引1到3的元素
print(id(numbers), numbers)  # 输出: [1, 20, 30, 40, 5]
numbers[2:5:2] = [300, 500]  # 替换索引2和4的元素]
print(id(numbers), numbers)

4.列表的删除

"""
列表的删除
- remove()：删除指定的元素，如果有多个相同的元素，只会删除第一个
- pop()：删除指定索引的元素，如果不指定索引，默认删除最后一个元素
- clear()：清空列表
- del：删除列表或删除指定索引的元素
"""# 列表的删除
l = ["Python", "C++", "Java", "PHP", "Python", "Ruby", "MATLAB", "Python"]
#  remove()：删除指定的元素，如果有多个相同的元素，只会删除第一个
l.remove("Python")
print(l)# pop()：删除指定索引的元素，如果不指定索引，默认删除最后一个元素
# pop() 方法会返回被删除的元素
result = l.pop()
print(result, l)
result = l.pop(1)
print(result, l)# clear()：清空列表
l.clear()
print(l)my_list = [1, 2, 3]
# del：删除列表或删除指定索引的元素
del my_list[0]
print(my_list)

三、列表的遍历与推导式

1.列表的遍历

遍历就是依次取出列表中的元素:

1. 使用while循环获取下标取出.
2. 使用for循环取出.

"""
列表的遍历
- 使用for循环遍历列表
- 使用while循环遍历列表遍历方式：
1. 直接遍历列表的元素
2. 索引遍历列表的元素
3. 使用enumerate()函数遍历列表的索引和元素这三种方式不会产生新的对象，都是对原列表进行操作
"""#  列表的遍历
# 1. 直接遍历列表的元素
l1 = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
print(f"{'-' * 10}直接遍历列表的元素{'-' * 10}'")
for item in l1:print(item)#  2. 索引遍历列表的元素
l2 = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
print(f"{'-' * 10}索引遍历列表的元素{'-' * 10}'")
for i in range(len(l2)):l2[i] += "_new"print(l2[i])# 3. 使用enumerate()函数遍历列表的索引和元素
l3 = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
print(f"{'-' * 10}使用enumerate()函数遍历列表的索引和元素{'-' * 10}'")
for index, item in enumerate(l3):print(f"Index {index}: {item}")

2.列表的推导式

"""
列表推导式
- 列表推导式是一种简洁的创建列表的方式
- 列表推导式可以包含一个或多个for循环和if条件语句
- 列表推导式可以嵌套列表推导式的语法：
[expression for item in iterable]
[expression for item in iterable if condition]
[expression if condition else expression for item in iterable]
[expression for item in iterable for item in iterable]
等等
"""# 列表推导式
# 1. 简单列表推导式
l1 = [i for i in range(1, 10)]
print(l1)#  2. 带if条件的列表推导式
l2 = [i for i in range(1, 10) if i % 2 == 0]
print(l2)# 3. 带if-else条件的列表推导式
l3 = [i if i % 2 == 0 else i * 10 for i in range(1, 10)]
print(l3)# 4. 嵌套列表推导式
l4 = [i * j for i in range(1, 10) for j in range(1, 10)]
print(l4)# 5. 带if条件的嵌套列表推导式
l5 = [i * j for i in range(1, 10) for j in range(1, 10) if i % 2 == 0 and j % 2 == 0]
print(l5)# 6. 带if-else条件的嵌套列表推导式
l6 = [i * j if i % 2 == 0 and j % 2 == 0 else i + j for i in range(1, 10) for j in range(1, 10)]
print(l6)

四、列表常用的内置函数

"""
列表常用内置函数
【至于列表的增删操作，我这里就不写了，因为前面的小结中有涉及到】
1. 查询与统计
- index()：返回指定元素的索引
- count()：返回指定元素的个数
- len()：返回列表的长度
- in, not in：判断元素是否在列表中2. 排序与反转
- sort()：对列表进行排序, 默认升序, 可以指定reverse=True降序, 返回None
- reverse()：反转列表, 返回None
- sorted(iterable, key=None, reverse=False)：对列表进行排序, 返回一个新的列表
- reversed(iterable)：反转列表, 返回一个迭代器, 需要用list()函数转换成列表
【注意】
- 列表的sort()和reverse()方法会改变原有的列表
- 列表的sorted()和reversed()内置函数不会改变原有的列表, 而是返回一个新的列表。3. 拷贝与组合
- copy()：返回列表的浅拷贝
- +：组合两个列表
- *：重复列表4. 高级操作
- max(iterable)：返回列表中的最大值
- min(iterable)：返回列表中的最小值
- sum(iterable)：返回列表中所有元素的和
- any(iterable)：判断列表中是否有True
- all(iterable)：判断列表中是否都为True
- enumerate(iterable, start=0)：返回列表的索引和元素
- zip(*iterables)：将两个列表组合成元组
- filter(function, iterable)：过滤列表
- map(function, iterable)：对列表中的每个元素进行操作这些内置函数不会改变原有的列表，而是返回一个新的列表这里的高级操作会涉及到一个后面函数学习的内容，lambda表达式, 所以这里就简单提一下
"""

1.查询与统计

# 1. 查询与统计
print(f"{'-' * 10} 1. 查询与统计 {'-' * 10}")
l = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
print(l.index("Python"))  # 0
print(l.count("Python"))  # 1
print(len(l))  # 6
print("Python" in l)  # True
print("Python" not in l)  # False

2.排序与反转

# 2. 排序与反转
print(f"{'-' * 10} 2. 排序与反转 {'-' * 10}")
l = [1, 5, 3, 2, 4, 6, 68, 88, 168]
l.sort()
print(l, id(l))  # [1, 2, 3, 4, 5, 6, 68, 88, 168]
l.reverse()
print(l, id(l))  # [168, 88, 68, 6, 5, 4, 3, 2, 1]l2_sorted = sorted(l)
print(l2_sorted, id(l2_sorted))
l2_reversed = reversed(l)
print(l2_reversed, list(l2_reversed), id(l2_reversed))

3.拷贝与组合

# 3. 拷贝与组合
# 列表中浅拷贝的三种方式,创建了一个新的对象,但是值还是原来的值。
# 1. list.copy()
# 2. list[:]
# 3. copy.copy(list)
print(f"{'-' * 10} 3. 拷贝与组合 {'-' * 10}")
l = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
l_copy = l.copy()
l2_copy = l[:]
l3_copy = copy.copy(l)
print(l_copy, id(l_copy))
print(l2_copy, id(l2_copy))
print(l3_copy, id(l3_copy))# 列表的组合
#  +：组合两个列表
l1 = [1, 2, 3]
l2 = [4, 5, 6]
l3 = l1 + l2
print(l3)# *：重复列表
l1 = [1, 2]
l2 = l1 * 3
print(l2)

4.高级操作【配合可迭代对象使用】

"""
高级操作
- max(iterable)：返回列表中的最大值
- min(iterable)：返回列表中的最小值
- sum(iterable)：返回列表中所有元素的和
- any(iterable)：判断列表中是否有True
- all(iterable)：判断列表中是否都为True
- enumerate(iterable, start=0)：返回列表的索引和元素
- zip(*iterables)：将两个列表组合成元组
- filter(function, iterable)：过滤列表
- map(function, iterable)：对列表中的每个元素进行操作
"""
# 高级操作
# 1. max(iterable)：返回列表中的最大值
print(f"{'-' * 10} 1. max(iterable) {'-' * 10}")
l = [1, 5, 3, 2, 4, 6, 68, 88, 168]
print(max(l))  # 168# 2. min(iterable)：返回列表中的最小值
print(f"{'-' * 10} 2. min(iterable) {'-' * 10}")
print(min(l))  # 1# 3. sum(iterable)：返回列表中所有元素的和
print(f"{'-' * 10} 3. sum(iterable) {'-' * 10}")
print(sum(l))  # 348
print(sum(range(1, 101)))  # 5050# 4. any(iterable)：判断列表中是否有True
print(f"{'-' * 10} 4. any(iterable) {'-' * 10}")
print(any([0, 1, 2, 3]))  # True
print(any([0, False, None]))  # False# 5. all(iterable)：判断列表中是否都为True
print(f"{'-' * 10} 5. all(iterable) {'-' * 10}")
print(all([0, 1, 2, 3]))  # False
print(all([1, 2, 3]))  # True# 6. enumerate(iterable, start=0)：返回列表的索引和元素
print(f"{'-' * 10} 6. enumerate(iterable) {'-' * 10}")
for index, value in enumerate(l):print(f"Index: {index}, {value}")# 7. zip(*iterables)：将两个列表组合成元组
print(f"{'-' * 10} 7. zip(*iterables) {'-' * 10}")
l1 = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
l2 = [1, 2, 3, 4, 5, 6]
for item in zip(l1, l2):print(item)# 上面是zip操作的是两个长度相同的列表，如果两个列表长度不同呢？
# 如果两个列表长度不同，那么zip操作会以最短的那个列表为准【取较短的列表的长度】
print(f"{'-' * 10} 7. zip(*iterables)-长度不同 {'-' * 10}")
l1 = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
l2 = [1, 2, 3, 4, 5]
for item in zip(l1, l2):print(item)# 当你需要以最长的可迭代对象为准，并为较短的对象填充默认值时，可以使用itertools.zip_longest()
print(f"{'-' * 10} 7. zip(*iterables)-长度不同, 以最长的为准 {'-' * 10}")
import itertools
l1 = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
l2 = [1, 2, 3, 4, 5]
for item in itertools.zip_longest(l1, l2, fillvalue=None):print(item)#  8. filter(iterable, function)：过滤列表
print(f"{'-' * 10} 8. filter(iterable, function) {'-' * 10}")
l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 过滤出偶数
print(list(filter(lambda x: x % 2 == 0, l)))  # [2, 4, 6, 8, 10]# 9. map(function, iterable)：对列表中的每个元素进行操作
print(f"{'-' * 10} 9. map(function, iterable) {'-' * 10}")
print(list(map(lambda x: x ** 2, l)))  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

五、列表中的坑

1. 在循环中移除元素可能会导致意想不到的结果. 例如. 当移除元素时列表的长度会改变，这可能会导致跳过某些元素。