数据容器——列表list

什么是数据容器？

python 中的数据容器：
一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
数据容器根据特点的不同，如：
·是否支持重复元素
·是否可以修改
·是否有序
分为5类，分别是：类表（list)、元组(tuple)、字符串(str)、集合(set)、字典(dict).

列表(list)

什么是列表？

列表内的每一个数据，称之为元素。
以[]作为标识
列表内每一个元素之间用,隔开
元素的数据类型没有任何限制，甚至元素也可以是列表，这样就定义了嵌套列表。

#基本语法：
# 定义列表字面量
#[元素1, 元素2, 元素3,元素4]

# 定义列表变量
# 变量名称=[元素1, 元素2, 元素3,元素4...]
name_list = ["yhz", "lr", "xmy", 666, True]
print(name_list) #print语句输入列表
print(type(name_list))

# 定义空列表
# 变量名称=[]
# 变量名称=list()
o_list = []
o_list = list()
print(o_list)
print(type(o_list))

# 定义一个嵌套的列表
my_list1 = ["小小",True,888] # 注意：列表可以一次存储多个数据，且可以为不同的数据类型
my_list2= ["小小", [4,5,6],True,888] # 注意：列表可以一次存储多个数据，且可以为不同的数据类型,还可嵌套列表。
my_list3= [[4,5,6],[7,5,3]] # 注意：列表可以一次存储多个数据，且可以为不同的数据类型,还可嵌套列表。
print(my_list1)
print(type(my_list1))
print(my_list2)
print(type(my_list2))
print(my_list3)
print(type(my_list3))

my_list1 = ["小小",True,888] # 注意：列表可以一次存储多个数据，且可以为不同的数据类型
my_list2= ["小小", [4,5,6],True,888] # 注意：列表可以一次存储多个数据，且可以为不同的数据类型,还可嵌套列表。
my_list3= [[4,5,6],[7,5,3]] # 双层嵌套列表
print(my_list1)
print(type(my_list1))
print(my_list2)
print(type(my_list2))
print(my_list3)
print(type(my_list3))

'''
运行结果：三个变量的类型都是列表（list)
['小小', True, 888]
<class 'list'>  
['小小', [4, 5, 6], True, 888]
<class 'list'>
[[4, 5, 6], [7, 5, 3]]
<class 'list'> '''

列表的下标索引

# 03 列表的下标索引
'''
我们如何从列表中取出特定位置的数据呢？可以使用下标索引
列表的每一个元素，都有顺序编号，我们称之为下标索引。列表[下标]即可取出。嵌套列表同样支持下标索引。
从前向后，从 0 开始，依次递增，0,1,2,3…；
从后向前，从 -1 开始，依次递减，-1,-2,-3…。
# 语法：列表[下标索引]

# 语法：列表[下标索引]
name_list=["Tom","Jony","Rose","Moore"]
print(name_list[0])  # 运行结果：
print(name_list[1])  # 运行结果：
print(name_list[2])  # 运行结果：
print(name_list[3])  # 运行结果：

# 从前向后，从 0 开始，依次递增，0,1,2,3…；
name_list=["Tom","Jony","Rose","Moore"]
print(name_list[0])  # 运行结果：Tom
print(name_list[1])  # 运行结果：Jony
print(name_list[2])  # 运行结果：Rose
print(name_list[3])  # 运行结果：Moore
#print(name_list[4])  # 运行结果：IndexError: list index out of range 超出下标的允许范围了。

# 从后向前，从 -1 开始，依次递减，-1,-2,-3…。
name_list=["Tom","Jony","Rose","Moore"]
print(name_list[-1])  # 运行结果：Moore
print(name_list[-2])  # 运行结果：Rose
print(name_list[-3])  # 运行结果：Jony
print(name_list[-4])  # 运行结果：Tom

# 列表是嵌套的列表，同样支持下标索引，需要写2层下标索引，⚠️一定要记得编号从0开始
my_list=[[1,4,6],[7,9,10]]
print(my_list[0][0])  # 运行结果：1
print(my_list[0][1])  # 运行结果：4
print(my_list[0][2])  # 运行结果：6
print(my_list[1][0])  # 运行结果：7
print(my_list[1][1])  # 运行结果：9
print(my_list[1][2])  # 运行结果：10

列表的常用操作（方法）

列表除了可以：

·定义

·使用下标索引获取值

还可以提供其他功能：  

·插入元素

·删除元素

·清空列表

·修改元素

·统计元素个数 等等功能，这些功能我们都称之为：列表的方法

函数VS方法：

'''函数 vs. 方法
函数是一个封装的代码单元，可以提供特定功能。
而在 Python 中，如果将函数定义为 class（类）的成员，那么函数就会被称为：方法。'''
# 函数
def add(x, y):
  return x + y

# 方法
class Student:
  def add(self, x, y): # def 定义在class函数的里面
    return x + y
# 方法和函数功能一样，有传入参数，有返回值，只是方法的使用格式不同。
# 函数的使用：num = add(1, 2)
# 方法的使用：
student = Student() # 首先获得class的类对象—student
num = student.add(1, 2)  # 通过“·”，引出后面的功能

1、列表的查询功能（方法）

功能：查找某指定元素在列表的下标，如果找不到，报错ValueError。
语法：列表.index(元素)
index就是列表对象（变量）内置的方法（函数）。

# 定义一个列表
mylist=["it","is,","king"]
index=mylist.index("it")
print(f"it在列表中的下标索引值是：{index}") # 运行结果：it在列表中的下标索引值是：0
#index=mylist.index("hello")
#print(f"it在列表中的下标索引值是：{index}") # 报错；ValueError: 'hello' is not in list

2、修改功能

功能：修改特定位置（索引）的元素值，可对指定下标的值进行重新赋值。
语法：列表[下标] = 值
可以使用上述语法，直接对指定下标（正向、反向下标均可）的值进行：重新赋值（修改）

# 正向下标
my_list=[1,2,3]
my_list[0]=6 # 指定列表下标为0中，发现其元素值为1，修改为6
print(my_list)  # 运行结果中:[6, 2, 3]

# 正向下标
my_list=[1,2,3]
my_list[-3]=9 # 把列表中的-3下标对应的元素值，修改为9
print(my_list)  # 运行结果中:[9, 2, 3]

3、插入功能

功能：在指定下标，位置后面插入指定元素。
语法：列表.insert(下标, 元素),在指定的下标位置，插入指定的元素。

my_list_1=[1,2,3]
my_list_1.insert(1,"love") 
print(f"插入数据后：{my_list_1}") # 运行结果：插入数据后：[1, 'love', 2, 3]

3、追加元素

功能：将指定元素追加到列表尾部。
语法：
列表.append(元素)（追加一个）；
列表.extend(其他数据容器)（将其他数据容器中的内容取出，依次追加到列表尾部）

my_list_2=[1,2,3,4]
my_list_2.append("78")
print(f"列表，追加尾部数据后，变为：{my_list_2}")  # 运行结果：列表，追加尾部数据后，变为：[1, 2, 3, 4, '78']
my_list_3=[1,2,3,4]
my_list_3.append([7,7,7])
my_list_4=[1,2,3,4]
my_list_4.extend([5,5,5,]) # extend 追加一批元素
print(f"列表，追加尾部数据后，变为：{my_list_3}")  #列表，追加尾部数据后，变为：[1, 2, 3, 4, [7, 7, 7]]
print(f"列表，追加尾部数据后，变为：{my_list_4}")  #列表，追加尾部数据后，变为：[1, 2, 3, 4, 5, 5, 5]

4、删除元素

语法：del 列表[下标]，列表.pop(下标)（取出元素并从列表中删除），列表.remove(元素)（删除某元素在列表中的第一个匹配项）

# 使用del关键字
mylist=["let's","go","ahead"]
del mylist[0]
print(f"列表删除元素后的结果是：{mylist}") # 列表删除元素后的结果是：['go', 'ahead']
# 使用列表.pop(下标)，方法,取出的元素可以重新定义变量保存。
mylist=["let's","go","ahead"]
element=mylist.pop(1)
print(f"通过pop方法，取出元素后，列表结果是：{mylist}，取出元素是：{element}") # 通过pop方法，取出元素后，列表结果是：["let's", 'ahead'],取出元素是：go


# 删除某元素在列表中的第一个匹配项
#语法：列表.remove(元素) #⚠️，这里是直接删除元素，且只删除重复元素中排序第一位的
my_list=["it","is","dog","it","is","cat",]
my_list.remove("it")
print(my_list) # 结果：['is', 'dog', 'it', 'is', 'cat']
# 如果想把第二个‘it“删除，那就需要再调用一次
my_list.remove("it")
print(my_list) # 结果：['is', 'dog', 'is', 'cat']

5、清空列表内容

语法：列表.clear()

my_list=[1,6,12,77]
my_list.clear()
print(f"列表被清空后的结果是：{my_list}") # 列表被清空后的结果是：[]

6、统计功能

·语法：列表.count(元素）

统计某一个元素在列表中的数量。

my_list=[1,1,1,2,2,4,5,7]
my_list.count(1)
print(f"列表中元素1一共有多少：{my_list.count(1)}个") # 列表中元素1一共有多少：3个

·语法：len(列表)

⚠️：len不是列表的一个方法，这是一个函数。统计列表中，一共有多少个元素。通过len(列表),可以得到一个int数字，表示列表内元素的数量

my_list=[1,1,1,2,2,4,5,7]
count=len(my_list)
print(f"列表中一共有多少元素：{len(my_list)}个") # 列表中一共有多少元素：8个
print(count,"个") # 运行结果：8 个

练习案例：常用功能练习

有一个列表，内容是[21,25,21,23,22,20],记录一批学生的年龄
请通过列表的功能（方法），对其进行以下操作：
1、定义这个列表，并用变量接受它；
2、追加一个数字31，到列表的尾部；
3、追加一个新列表[29,33,30]，到列表的尾部
4、取出第一个元素（应该是：21）；
5、取出最后一个元素（应该是：30）；
6、查找元素31，在列表中的下标位置

# 定义学生年龄的列表
age_list=[21,25,21,23,22,20]
print(age_list)
# 追加一个数字31，到列表的尾部
age_list.append(31)
print(age_list)
# 追加一个新列表[29,33,30]，到列表的尾部
age_list.extend([29,33,30,])
print(age_list)
# 取出第一个元素（应该是：21）
num1=age_list[0]
print(f"从列表中取出来的第一个元素，应该是21，实际是：{num1}")
# 取出最后一个元素（应该是：30）
num1=age_list[-1]
print(f"从列表中取出来的第一个元素，应该是30，实际是：{num1}")
# 查找元素31，在列表中的下标位置
index=age_list.index(31)
print(f"元素31在列表的下标位置是：{index}")
print(f"最后列表的内容是：{age_list}")

'''
练习案例运行结果：
[21, 25, 21, 23, 22, 20]
[21, 25, 21, 23, 22, 20, 31]
[21, 25, 21, 23, 22, 20, 31, 29, 33, 30]
从列表中取出来的第一个元素，应该是21，实际是：21
从列表中取出来的第一个元素，应该是30，实际是：30
元素31在列表的下标位置是：6
最后列表的内容是：[21, 25, 21, 23, 22, 20, 31, 29, 33, 30]

进程已结束，退出代码为 0 
'''

列表的遍历

—while循环

既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。将容器内的元素按着顺序依次取出的行为，叫做：遍历、迭代。
· 如何遍历列表的元素呢？
可以使用前面学过的while循环
· 如何在循环中取出列表的元素呢？
使用列表[下标]的方式取出
·循环条件如何控制？
1、定义一个变量表示下标，从0开始；
2、循环条件为：下标值<列表的元素数量

# 演示list列表的循环，使用while和for循环2种方式
def list_while_func():
    """
    使用for循环遍历列表的演示函数
    :return: None
    """
    my_list=["明日","清梦","压星河"]
    # 循环控制变量通过下标索引来控制，默认为0
    # 每一次循环将下标索引变量+1
    # 循环条件：下标索引变量<列表的元素熟练

    # 定义一个变量来标记列表的下标
    index=0   # 初始值为0
    while index<len(my_list):
          # 通过index变量，获取对应下标的元素
          element=my_list[index]
          print(f"列表的元素：{element}")
          # ⚠️：将循环变量index，每一次循环都要+1
          index+=1
# 调用函数
list_while_func()
'''
运行结果：
列表的元素：明日
列表的元素：清梦
列表的元素：压星河
'''

—for循环

for循环更加适合对列表等数据容器进行遍历
语法：
for 临时变量 in 数据容器：
    对临时变量进行处理

表示，从容器内，依次取出元素并赋值到临时变量上。
每一次的循环中，我们可以对临时变量（元素）进行处理。

def list_for_func():
    """
    使用for循环遍历列表的演示函数
    :return: None
    """
    my_list=[1,2,3,4,5,6]
    # for 临时变量 in 数据容器：
    for element in my_list:
        print(f"列表的元素有：{element}")
# 调用函数
list_for_func()

'''
运行结果：
列表的元素有：1
列表的元素有：2
列表的元素有：3
列表的元素有：4
列表的元素有：5
列表的元素有：6
'''

while循环和for循环的对比

·在循环控制上：
  ·while循环可以自定循环条件，并执行控制
  ·for循环不可以自定循环条件，只可以一个个从容器内取出数据
·在无限循环上：
  ·while循环可以通过条件控制做到无限循环
  ·for循环理论上不可以，因为被遍历的容器容量不是无限的
·在使用场景上：
  ·while循环适用于任何想要循环的场景
  ·for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

练习案例：取出列表内的偶数

定义一个列表，内容是[1,2,3,4,5,6,7,8,9,10]
·遍历列表，取出列表内的偶数，并存入一个新的列表对象中
·分别使用while循环和for循环操作

提示；
1、通过if判断来确认偶数
2、通过列表的append方法，来增加元素。

# while循环
my_list = [1,2,3,4,5,6,7,8,9,10]
new_list = []
i = 0
while i < len(my_list): # 下标小于列表总数时，开始循环
    if my_list[i] % 2 == 0:  # % 表示取余数
        """
        当my_list[0]的对应元素是1，1%2的余数是1;
        当my_list[1]的对应元素是2，2%2的余数是0；添加到new_list中
        当my_list[2]的对应元素是3，3%2的余数是1；
        当my_list[3]的对应元素是4，4%2的余数是0；添加到new_list中
        当my_list[4]的对应元素是5，5%2的余数是1；
        当my_list[5]的对应元素是6，6%2的余数是0；添加到new_list中
        当my_list[6]的对应元素是7，7%2的余数是1；
        当my_list[7]的对应元素是8，8%2的余数是0；添加到new_list中
        当my_list[8]的对应元素是9，9%2的余数是1；
        当my_list[9]的对应元素是10，10%2的余数是0；添加到new_list中
        ......
        """
        new_list.append(my_list[i]) #  列表.append(元素)，在尾部追加元素
    i += 1
print(f"通过while循环，从列表{my_list}中取出偶数，组成新的列表{new_list}")

# for循环
new_list_2=[]
for i in my_list:
    if i % 2 == 0:
        new_list_2.append(i)
print(f"通过for循环，从列表{my_list}中取出偶数，组成新的列表{new_list_2}")


"""
运行结果：
通过while循环，从列表[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]中取出偶数，组成新的列表[2, 4, 6, 8, 10]
通过for循环，从列表[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]中取出偶数，组成新的列表[2, 4, 6, 8, 10]

进程已结束，退出代码为 0
"""