Python数据容器之列表

数据容器：

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

数据容器：列表（list）

基本语法：

# 字面量
[元素1，元素2，元素3，元素4...]

# 定义变量
变量名称 = [元素1，元素2，元素3，元素4...]

# 定义空列表
变量名称 = []
变量名称 = list（）

列表内的每个数据，称之为元素
以[ ]作为标识
列表内每一个元素之间用 ‘,’ 隔开

列表可以一次存储多个数据，且可以为不同的数据类型，并且支持嵌套

name_list = ['dadw', 'dasdaw', 'dasdaw']
print(name_list)
print(type(name_list))
输出结果：
['dadw', 'dasdaw', 'dasdaw']
<class 'list'>

# 不同的数据类型 
my_list = ['dadw', 2323, True]
print(my_list)
print(type(my_list))
输出结果：
['dadw', 2323, True]
<class 'list'>

嵌套列表的定义

my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))
输出结果：
[[1, 2, 3], [4, 5, 6]]
<class 'list'>

列表的下标索引

列表中每一个元素，都有其位置下标索引，从前向后的方向，从0开始，一次递增
注意下标取值范围，超出范围会报错

name_list = ['dadw', 'dasdaw', 'dasdaw']
print(name_list[0])
print(name_list[1])
print(name_list[2])
print(type(name_list))
输出结果：
dadw
dasdaw
dasdaw
<class 'list'>

列表是嵌套列表，同样支持下标索引

my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list[0][1])
print(my_list[1][1])
print(type(my_list))
输出结果：
2
5
<class 'list'>

列表的常用操作

列表除了可以
定义
使用下标索引
还可以
修改元素
删除元素
清空列表
修改元素
统计元素个数

1.查找元素的下标
功能：查找指定元素在列表的下标，如果找不到，报错ValueError
语法：列表.index（元素）

my_list = [[1, 2, 3], [4, 5, 6]]
index = my_list[0].index(2)
print(f"列表中的下标是：{index}")
输出结果：
列表中的下标是：1

2.列表的修改功能
插入元素：
语法：列表.insert（下标，元素），在指定的下标位置，插入指定的元素

my_list = [[1, 2, 3], [4, 5, 6]]
index = my_list[0].index(2)
print(f"列表中的下标是：{index}")
my_list[1].insert(1, "sss")
print(my_list[1])
输出结果：
列表中的下标是：1
[4, 'sss', 5, 6]

追加元素：
语法：列表.append（元素），将指定元素，追加到列表的尾部

my_list = [[1, 2, 3], [4, 5, 6]]
my_list[0].append(2)
print(my_list[0])
输出结果：
[1, 2, 3, 2]

追加元素方式2：
语法：列表.extend（其他数据容器），将其他数据容器的内容取出，依次追加到列表尾部

my_list = [[1, 2, 3], [4, 5, 6]]
my_list[0].extend(my_list[1])
print(my_list[0])
输出结果：
[1, 2, 3, 4, 5, 6]

删除元素：
语法1：del列表[下标]
语法2：列表.pop（下标）

my_list = [[1, 2, 3], [4, 5, 6]]
my_list[0].extend(my_list[1])
print(my_list[0])
del my_list[0][2]
print(my_list[0])
my_list[0].pop(2)
print(my_list[0])
输出结果：
[1, 2, 3, 4, 5, 6]
[1, 2, 4, 5, 6]
[1, 2, 5, 6]

删除某元素在列表中的第一个匹配项
语法：列表.remove（元素）

# 删除了第一个与形参相同的元素
my_list = [1, 2, 2, 3]
my_list.remove(2)
print(my_list)
输出结果：
[1, 2, 3]

清空列表
语法：列表.clear（）

my_list = [1, 2, 2, 3]
my_list.remove(2)
print(my_list)
my_list.clear()
print(my_list)
输出结果：
[1, 2, 3]
[]

统计某元素在列表内的数量（在列表之内出现的次数）
语法：列表 .count（元素）

my_list = [1, 2, 2, 3]
print(my_list.count(2))
输出结果：
2

统计列表中有多少元素
语法：len（列表）
可以得到一个int数字，表示列表内的元素数量

my_list = [1, 2, 2, 3]
prit(len(my_list))
输出结果：
4

列表的优点：
可以容纳多个元素（上限为2**63-1）
可以容纳不同类型的元素
数据有序存储
允许重复数据存在
可以修改（增删查改）

列表案例

age_list = [21, 25, 21, 23, 22, 20]
print(age_list)
age_list.append(31)
print(age_list)
new_list = [29, 33, 30]
age_list.extend(new_list)
print(age_list)
print(age_list[0])

# 从列表里取出最后一个元素  列表最后一个元素的下标是-1
print(age_list[-1])
print(age_list[len(age_list) - 1])

print(age_list.index(31))
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
30
30
6
最后列表中的内容是[21, 25, 21, 23, 22, 20, 31, 29, 33, 30]

列表的循环遍历

while循环

index = 0 
while index < len(列表):
	元素 = 列表[index]
	对元素进行处理
	index += 1 
	

for循环语法：

for 临时变量 in 数据容器：
	对临时变量进行处理

for循环与while对比
for用于从容器内依次取出元素并处理，while用以任何需要循环的场景

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]


def while_func(num_list):
    new_list = []
    index = 0
    while index < len(num_list):
        if num_list[index] % 2 == 0:
            new_list.append(num_list[index])
        index += 1

    return new_list


new_list = while_func(my_list)
print(new_list)


def for_func(num_list):
    new_list = []
    for num in num_list:
        if num % 2 != 0:
            new_list.append(num)

    return new_list


new_list = for_func(my_list)
print(new_list)
输出结果：
[2, 4, 6, 8, 10]
[1, 3, 5, 7, 9]