「Python编程基础」第5章：列表

在这里插入图片描述

文章目录

一、为什么要有列表？
二、列表语法
三、用索引获取列表中的单个值
四、利用切片取得子列表
五、利用len()函数，获取列表的长度
六、利用索引改变列表中的值
七、列表的连接和复制
八、用del语句删除列表中的值
九、有了列表后，真香
十、列表的遍历
十一、in 和 not in操作符
十二、列表中还有哪些内置函数？
- index() 返回指定数据所在位置的下标
- count() 返回统计指定数据在当前列表中出现的次数
- pop() 默认删除列表最后一个元素，并返回被删除列表元素内容
- remove() 移除列表中某个数据的第一个匹配项
- clear() 清空列表
- append() 列表结尾追加数据
- extend() 列表结尾追加数据，如果数据是一个序列，则将这个序列的数据，逐一添加到列表
- insert() 指定位置新增数据
- reverse() 逆置数据
- sort() 排序
- copy() 复制
十三、元组
十四、利用list()和tuple()函数来转换类型
练习题
小练习源码

一、为什么要有列表？

我们之前的教程中已经提到基础的数据类型，比如”字符串、数值、布尔“等。现在我们要学习更为高阶、复杂的数据类型。

Python中的复杂数据类型，不仅仅有列表，还有 元组、字典、集合 。

那他们的区别在哪？

基础的数据类型，通过学习和代码，我们了解到，它们只能存储「单个数据」。

复杂的数据类型，通过本章学习，你会发现，他们能欧存储包含多个「基础数据」的数据集合，让存储和操作数据变得更简单。

二、列表语法

num_list = [1, 2, 3]
str_list = ["Kevin", "Tom", "Jack"]
all_type_list = ["Kevin", 6, "Jack", True, False, 13.1111, None]
list_in_list = [[[1, 2, 3], ["Kevin", "Tom", "Jack"]], [True, False, 13.1111, None]]

print(num_list)
print(str_list)
print(all_type_list)
print(list_in_list)

代码运行结果：

[1, 2, 3]
['Kevin', 'Tom', 'Jack']
['Kevin', 6, 'Jack', True, False, 13.1111, None]
[[[1, 2, 3], ['Kevin', 'Tom', 'Jack']], [True, False, 13.1111, None]]

我们不难发现，列表内可以存储 任意类型数据，甚至是多个列表的嵌套，当然仅仅是因为我们只学到列表 。

三、用索引获取列表中的单个值

str_list = ["Kevin", "Tom", "Jack"]
print(str_list[0])
print(str_list[1])
print(str_list[2])
print(str_list[-1])

代码运行结果：

Kevin
Tom
Jack
Jack

我们发现：

列表的最后一个数据，可以通过「最大索引」或负数索引「-1」来获取！

那如果是嵌套列表呢？

比如下面这个代码，我们想获取到“Kevin”。

list_in_list = [[[1, 2, 3], ["Kevin", "Tom", "Jack"]], [True, False, 13.1111, None]]

print(list_in_list[0][1][0])

代码运行结果：

Kevin

我们会发现，嵌套列表取值并没有初学者说的那么难。

只是根据索引，一直在向内取值。

现在我们来点小练习。（小练习的参考代码，可以看末尾。）

"""
我有3只猫，分别叫“KK,JJ,LL”，
今天早上，我给它们都说了声“早安，某某某”！
"""

四、利用切片取得子列表

索引可以取得列表中某个单个字，而切片可以获取到列表中多个值，结果是一个新的列表。

切片是利用一对括号来表示它的起始和结束，中间由一个冒号来分分隔。

str_list = ["Kevin", "Tom", "Jack", "CC"]
child_list = str_list[1:3]
print(child_list)

代码运行结果：

['Tom', 'Jack']

五、利用len()函数，获取列表的长度

我们在利用一个函数“len()”来看看列表的长度。

str_list = ["Kevin", "Tom", "Jack", "CC"]
print(len(str_list))
child_list = str_list[1:3]
print(child_list)

代码运行结果：

4
['Tom', 'Jack']

我们发现切片的取值规律：
1. 括号内的第1个数字，表示列表的下标起始位置。
2. 括号内的第2个数字，表示获取到列表长度的结束位置。

注意：

很多初学者，会很容易将下标的概念和长度混淆。

六、利用索引改变列表中的值

既然索引可以获取值，那么我们同样可以利用这一途径，改变列表中的这个值。

str_list = ["Kevin", "Tom", "Jack", "CC"]
str_list[1] = "测试划水老师傅"
print(str_list)

代码运行结果：

['Kevin', '测试划水老师傅', 'Jack', 'CC']

七、列表的连接和复制

列表的连接其实和字符串的连接是一样的。

str_list = ["Kevin", "Tom", "Jack", "CC"]
num_list = [1, 2, 3, 4, 5]
new_list = str_list + num_list
print(new_list)

代码运行结果：

['Kevin', 'Tom', 'Jack', 'CC', 1, 2, 3, 4, 5]

这样操作之后，我们发现，我们没有改变原有的列表数据，而是将新的连接列表，赋值给一个新的变量。

当然，你也可以用已有变量接收，只不过这样，会修改原有列表数据，我不太建议这样操作。

再来说说复制，其实估计大家已经明白复制怎么操作了。

str_list = ["Kevin", "Tom", "Jack", "CC"]
copy_list = str_list * 3
print(copy_list)

代码运行结果：

['Kevin', 'Tom', 'Jack', 'CC', 'Kevin', 'Tom', 'Jack', 'CC', 'Kevin', 'Tom', 'Jack', 'CC']

八、用del语句删除列表中的值

删除这里，我们就需要用到刚才学到的下标知识，其实就是删除下标对应的值，来看看代码。

str_list = ["Kevin", "Tom", "Jack", "CC"]
del str_list[0]
print(str_list)

代码运行结果：

['Tom', 'Jack', 'CC']

我们发现，这样的操作，会让源数据发生改变，所以谨慎操作。

九、有了列表后，真香

还记得我们学习列标签的变量存储吗？

比如，我们要保存我们目前都有哪些offer，你也许会这样创建变量，编写代码。

offer_1 = "A公司offer"
offer_2 = "B公司offer"
offer_3 = "C公司offer"
offer_4 = "D公司offer"

但是你不觉得累吗？如果你又有了新的offer，那不得再命名一个offer_5？

我们来写一个小程序，可以记录我们当前都拿到哪些offer，你会发现，这个程序好麻烦，还不如手动记录！

print("输入你第1个offer名称：")
offer_1 = input()
print("输入你第2个offer名称：")
offer_2 = input()
print("输入你第3个offer名称：")
offer_3 = input()
print("输入你第4个offer名称：")
offer_4 = input()
print("现在我都有哪些公司的offer？")
print(f"我现在已经有：{offer_1}、{offer_2}、{offer_3}、{offer_4}")

代码运行结果：

输入你第1个offer名称：
A公司offer
输入你第2个offer名称：
B公司offer
输入你第3个offer名称：
C公司offer
输入你第4个offer名称：
D公司offer
现在我都有哪些公司的offer？
我现在已经有：A公司offer、B公司offer、C公司offer、D公司offer

如果没有学习列标签，我们会这样写，那学习列表之后，我们尝试将代码优化一下，使用单个变量来记录，并且当我拿到新offer后，也能正常输入，不需要在去定义变量。

offer_list = []
while True:
    offer_name = input("请输入你的offer名称：")
    if offer_name == "":  # 不输入任何内容，程序退出
        break
    offer_list = offer_list + [offer_name]
print(f'我现在已有offer如下：')
for offer in offer_list:
    print(offer)

代码运行结果：

请输入你的offer名称：A公司offer
请输入你的offer名称：B公司offer
请输入你的offer名称：C公司offer
请输入你的offer名称：D公司offer
请输入你的offer名称：
我现在已有offer如下：
A公司offer
B公司offer
C公司offer
D公司offer

你细细的品，假设数据有100个呢？

十、列表的遍历

刚才我们已经用了for循环获取列表中的所有值，我们在重点介绍下，关于列表的两种常用遍历方法。

"""
1.while循环遍历
"""
name_list = ["测试划水老师傅","Python","Java"]
i = 0
while i < len(name_list):
    print(name_list[i])
    i += 1

"""
2.for循环遍历
"""
name_list = ["测试划水老师傅","Python","Java"]
for i in name_list:
    print(i)

两种遍历方式，实现的结果是一样的。

测试划水老师傅
Python
Java

有同学会问：

遍历列表时，我还想知道值所在的下标是多少！我该怎么办？

很简单，我们学会使用一个函数enumerate()，就能很轻松解决这个需求。

name_list = ["测试划水老师傅","Python","Java"]
for index, value in enumerate(name_list):
    print(f"下标为{index}的值是：{value}")

代码运行结果：

下标为0的值是：测试划水老师傅
下标为1的值是：Python
下标为2的值是：Java

十一、in 和 not in操作符

字面意思，in表示这个值在列表中，not in表示这个值不在列表中。

name_list = ["测试划水老师傅","Python","Java"]
print("Python" in name_list)
print("Python" not in name_list)

代码运行结果：

True
False

求值结果是一个“布尔值”。

十二、列表中还有哪些内置函数？

index() 返回指定数据所在位置的下标

# 语法：列表序列.index(数据,开始位置下标,结束位置下标)

name_list = ["Kevin","Tom","Jack"]
print(name_list.index('Tom',0,2))
print(name_list.index('Kevin'))
print(name_list.index('Kevin_1111'))

"""代码运行结果：
1
0
Traceback (most recent call last):
  File "E:/giteespace/python/基础知识/列表.py", line 13, in <module>
    print(name_list.index('Kevin_1111'))
ValueError: 'Kevin_1111' is not in list
"""

count() 返回统计指定数据在当前列表中出现的次数

name_list = ["Kevin","Tom","Jack"]
print(name_list.count("Kevin"))
print(name_list.count("kevin"))
print(name_list.count("Bob"))

"""代码运行结果：
1
0
0
"""

pop() 默认删除列表最后一个元素，并返回被删除列表元素内容

name_list = ["测试划水老师傅","Python","Java"]
pop_name_one = name_list.pop()
print(name_list)
print(pop_name_one)

pop_name_two = name_list.pop(0)
print(name_list)
print(pop_name_two)


"""代码运行结果:
['测试划水老师傅', 'Python']
Java
['Python']
测试划水老师傅
"""

remove() 移除列表中某个数据的第一个匹配项

name_list = ["测试划水老师傅","Python","Java"]
remove_one = name_list.remove("Java")
print(name_list)

"""代码运行结果:
['测试划水老师傅', 'Python']
"""

clear() 清空列表

name_list = ["测试划水老师傅","Python","Java"]
name_list.clear()
print(name_list)

"""代码运行结果:
[]
"""

append() 列表结尾追加数据

name_list = ["Kevin","Tom","Jack"]
new_name_list = name_list.append("Bob")
print(name_list)
print(new_name_list)

#注意，append会修改原有列表数据
"""代码运行结果:
['Kevin', 'Tom', 'Jack', 'Bob']
None
"""

extend() 列表结尾追加数据，如果数据是一个序列，则将这个序列的数据，逐一添加到列表

name_list = ["Kevin","Tom","Jack"]
new_name_list = name_list.extend("Bob")
print(name_list)
print(new_name_list)
name_list.extend(["AA","BB"])
print(name_list)

#注意：
#1. extend会修改原有列表数据
#2. 会将序列的额数据，注意添加到列表，下方显示字符串、列表添加后的结果    


"""代码运行结果:
['Kevin', 'Tom', 'Jack', 'B', 'o', 'b']
None
['Kevin', 'Tom', 'Jack', 'B', 'o', 'b', 'AA', 'BB']
"""

insert() 指定位置新增数据

name_list = ["Kevin","Tom","Jack"]
new_name_list = name_list.insert(0,"Bob")
print(name_list)
print(new_name_list)

#注意：
#1. insert会修改原有列表数据    


"""代码运行结果:
['Bob', 'Kevin', 'Tom', 'Jack']
None
"""

reverse() 逆置数据

id = [1,2,4,4,5,1]
id.reverse()
print(id)

"""代码运行结果:
[1, 5, 4, 4, 2, 1]
"""

sort() 排序

"""
3.列表.sort(key=None, reverse=False)
注意：reverse表示排序规则 reverse=True 降序； reverse=False 升序（默认）
"""
id_sort = [1,2,4,4,5,1]
id_sort.sort()
print(id_sort)

"""run:
[1, 1, 2, 4, 4, 5]
"""

id_sort_True = [1,2,4,4,5,1]
id_sort_True.sort(reverse = True)
print(id_sort_True)

"""代码运行结果:
[5, 4, 4, 2, 1, 1]
"""

copy() 复制

保留原始数据基础上，进行复制数据，一般原始数据不做操作

"""
1.列表.copy()
"""
name_list = ["测试划水老师傅","Python","Java"]
new_name_list = name_list.copy()
print(name_list)
print(new_name_list)

"""代码运行结果:
['测试划水老师傅', 'Python', 'Java']
['测试划水老师傅', 'Python', 'Java']
"""

十三、元组

元组与列表其实很相似，甚至它们的内置函数都一样，但只有2点不一样。

列表的括号是[]，元组是()。
元组像字符串一样，是不可变的。

那么什么是数据不可变？什么又是数据可变？

可变的：列表、集合、字典（可以进行更改，并且更改后物理地址不会发生改变）

不可变的：数字(整型、浮点数)、字符串、元组（不可以进行更改，更改后就是一个新的对象了，物理地址发生了变化）

# 列表 可变类型,append数据后，内存地址依然没有变化。
list_a = [10, 20]
list_b = list_a
print(f'list_b的值{list_b}')
print(f'list_a的内存地址{id(list_a)}')
print(f'list_b的内存地址{id(list_b)}')
list_a.append(30)
print(f'list_b的值{list_b}')
print(f'list_a的内存地址{id(list_a)}')
print(f'list_b的内存地址{id(list_b)}')
"""代码运行结果：
list_b的值[10, 20]
list_a的内存地址1873382598272
list_b的内存地址1873382598272
list_b的值[10, 20, 30]
list_a的内存地址1873382598272
list_b的内存地址1873382598272
"""

a = 10
b = a
print(f'a的值{a}')
print(f'a的内存地址{id(a)}')
print(f'b的内存地址{id(b)}')

a = 2
print(f'b的值{b}')
# 因为修改了a的数据，内存需要开辟新的地址存储
print(f'a的内存地址{id(a)}')
print(f'b的内存地址{id(b)}')
"""代码运行结果：
a的值10
a的内存地址3115119477264
b的内存地址3115119477264
b的值10
a的内存地址3115119477008
b的内存地址3115119477264
"""

十四、利用list()和tuple()函数来转换类型

我们已经学习了列表和元组，甚至知道元组是不可变类型，那当我就想要变可怎么办？

这时候我们需要将它的数据类型变更。

tuple_data = (1, 2, 3)
print(type(tuple_data))
change_list = list(tuple_data)
print(type(change_list))

"""代码运行结果：
<class 'tuple'>
<class 'list'>
"""

练习题

"""
练习题：
有三个办公室，8位老师，8个老师随机分配到3个办公室
1. 准备数据
    1.1 8位老师 -- 列表
    1.2 3个办公室 -- 列表嵌套
2. 分配老师到办公室
    *** 随机分配
    把老师的名字写入到办公室列表 -- 办公室列表追加老师数据
3. 验证是否分配成功
    打印办公室详细信息；每个办公室的人数和对应的老师名字
"""

"""
需求：
进入系统显示系统功能页面，功能列表如下：
1. 添加学员
2. 删除学员
3. 修改学员信息
4. 查询学员信息
5. 显示所有学员信息
6. 退出系统
系统共6个功能，用户根据自己需求选取。
"""

小练习源码

"""
我有3只猫，分别叫“KK,JJ,LL”，
今天早上，我给它们都说了声“早安，某某某”！
"""
cat_list = ['KK', 'JJ', 'LL']
print(f"早安,{cat_list[0]}!")
print(f"早安,{cat_list[1]}!")
print(f"早安,{cat_list[2]}!")