一.列表定义

1.列表定义

#方法一:局部变量
judge=[]

#方法二:方法参数
candies:List[int]

#方法三:局部变量--main函数
matrix=[2,3,5,1,3]

#方法四:间接生成
matrix=[0 for i in range(4)]
print(matrix) //[0, 0, 0, 0]

#方法五:数组乘法
matrix=[0]*5
print(matrix) //[0, 0, 0, 0, 0]

2.定义空列表

# 定义空列表
new_list = []

3.定义非空列表

# 定义一个列表 list
my_list = ["programming", "itcast", "python"]
print(my_list)

4.查询列表的类型

# 定义一个列表 list
my_list = ["programming", "itcast", "python"]
print(type(my_list))

5.类型不同的列表

my_list = ["programming", 666, True]
print(my_list)
print(type(my_list))

6.嵌套列表

# 定义一个嵌套的列表
my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))

7.列表的函数

• index 获取元素的下标
• insert 插入一个元素
• append 追加一个元素
• extend 追加一个列表
• del 删除指定位置元素
• pop 删除指定位置元素
• remove 删除元素
• clear 清空列表
• count 统计个数
• len 列表长度
• reverse 反转列表
• enumerate 迭代返回下标和数据

二.列表的取值

1.正序取数

# 通过下标索引取出对应位置的数据
my_list = ["Tom", "Lily", "Rose"]
# 列表[下标索引], 从前向后从0开始，每次+1，  从后向前从-1开始，每次-1
print(my_list[0])
print(my_list[1])
print(my_list[2])

# 错误示范；通过下标索引取数据，一定不要超出范围
# print(my_list[3])

2.嵌套列表元素

# 取出嵌套列表的元素
my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list[1][1])

3.取出最后一个

# 取出最后一个元素（应是：30）
num2 = mylist[-1]
print(f"从列表中取出来最后一个元素，应该是30，实际上是：{num2}")

4.倒序取数

# 通过下标索引取出数据（倒序取出）
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])

5.index 函数

mylist = ["itcast", "programming", "python"]
# 查找某元素在列表内的下标索引
index = mylist.index("programming")
print(f"programming在列表中的下标索引值是：{index}")

# 如果被查找的元素不存在，会报错
# index = mylist.index("hello")
# print(f"hello在列表中的下标索引值是：{index}")

三.列表的新增

1.insert 函数

# 在指定下标位置插入新元素
mylist.insert(1, "best")
print(f"列表插入元素后，结果是：{mylist}")

2.append 函数

# 4. 在列表的尾部追加单个新元素
mylist.append("python程序员")
print(f"列表在追加了元素后，结果是：{mylist}")

3.extend 函数

# 在列表的尾部追加一批新元素
mylist2 = [1, 2, 3]
mylist.extend(mylist2)
print(f"列表在追加了一个新的列表后，结果是：{mylist}")

4.append 和 extend 区别

在 Python 中，如果你想要将一个列表（loads["data"]["list"]）中的所有元素添加到另一个列表（res["data"]["list"]）中，你应该使用extend方法而不是append。append方法会将整个列表作为单个元素添加到另一个列表中，而extend方法会将列表中的每个元素逐个添加到另一个列表中。

四.列表的删除

1.del 函数

mylist = ["itcast", "programming", "python"]
# del 列表[下标]
del mylist[2]
print(f"列表删除元素后结果是：{mylist}")

2.pop 函数

# 列表.pop(下标)
mylist = ["itcast", "programming", "python"]
element = mylist.pop(2)
print(f"通过pop方法取出元素后列表内容：{mylist}, 取出的元素是：{element}")

3.remove 函数

# 删除某元素在列表中的第一个匹配项
mylist = ["itcast", "programming", "itcast", "programming", "python"]
mylist.remove("programming")
print(f"通过remove方法移除元素后，列表的结果是：{mylist}")

4.删除所有指定元素

删除所有为programming的元素:

可以使用列表推导式和条件语句来移除列表中所有值为"programming"的元素。以下是示例代码：

my_list = ["programming", "hello", "world", "programming", "python"]
new_list = [x for x in my_list if x != "programming"]
print(new_list)

在上面的代码中，我们首先定义了一个名为 my_list 的列表，其中包含了一些元素，其中包括了一些值为"programming"的元素。然后，我们使用列表推导式和条件语句来创建一个新的列表 new_list，其中包含了所有值不为"programming"的元素。最后，我们打印输出了新的列表 new_list。

运行上面的代码，输出结果为：

['hello', 'world', 'python']

可以看到，所有值为"programming"的元素都被成功移除了。

5.clear 函数

# 清空列表
mylist.clear()
print(f"列表被清空了，结果是：{mylist}")

五.列表的修改

1.修改元素值

mylist = ["itcast", "programming", "python"]
# 修改特定下标索引的值
mylist[0] = "教育"
print(f"列表被修改元素值后，结果是：{mylist}")

六.列表遍历

1.enumerate 函数

在 Python 中，enumerate是一个内置函数，用于将一个可迭代对象（如列表、元组、字符串等）组合为一个索引序列，同时列出数据和数据下标，常用于 for 循环中。

enumerate函数的语法如下：

enumerate(iterable, start=0)

其中，iterable是要枚举的可迭代对象，start是索引起始值，默认为 0。

以下是一个简单的示例，演示了如何使用enumerate函数：

fruits = ['apple', 'banana', 'orange']
for index, fruit in enumerate(fruits):
    print(index, fruit)

输出结果如下：

0 apple
1 banana
2 orange

在这个示例中，我们使用enumerate函数将一个列表fruits转换为一个索引序列。在每次迭代时，enumerate函数会返回一个元组，其中第一个元素是数据的索引，第二个元素是数据本身。我们可以使用两个变量index和fruit来接收这个元组，并打印出来。

2.range 函数

#方法四:间接生成
matrix=[0 for i in range(4)]
print(matrix) //[0, 0, 0, 0]

left = 0
for index in range(len(nums)):
    if nums[index] != val:
        nums[left] = nums[index]
        left += 1
return left

left = 0
for index in range(1, len(nums)):
    if nums[index] != val:
        nums[left] = nums[index]
        left += 1
return left

range(len(digits)-1, -1, -1)

这是一个倒序遍历列表 digits 的常用方式，它生成一个逆序的整数序列，用于反向遍历列表。具体来说，它生成了一个从 len(digits)-1 开始，到 -1 结束（不包括 -1），步长为 -1 的整数序列。

因为 Python 列表的索引是从 0 开始，所以 len(digits)-1 代表 digits 列表的最后一个元素的索引，-1 代表列表的第一个元素的索引。因此，这个序列包含了 digits 列表中所有的元素，且按照从后往前的顺序遍历。

在加一问题的解法中，我们需要从 digits 列表的最后一个元素开始加 1，如果加 1 后产生了进位，则需要继续向前进位。这个逆序的整数序列正好满足这个需求。

3.list 列表循环

def list_while_func():
    """
    使用while循环遍历列表的演示函数
    :return: None
    """
    mylist = ["教育", "python程序员", "Python"]
    # 循环控制变量：通过下标索引来控制，默认0
    # 每一次循环将下标苏姚
    index = 0
    while index < len(mylist):
        print(mylist[index])
        index += 1

# list_while_func()
def list_for_func():
    """
    使用for循环遍历列表的演示函数
    :return:
    """
    mylist = ["教育", "python程序员", "Python"]
    for e in mylist:
        print(e)


list_for_func()

4.偶数列表

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:
        new_list.append(my_list[i])
    i += 1

print(f"偶数形成的新列表：{new_list}")

七.列表切片

1.切片

# 对list进行切片，从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4]  # 步长默认是1，所以可以省略不写

2.list 列表切片

# 对list进行切片，从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4:3]      # 步长默认是1，所以可以省略不写
print(f"结果1：{result1}")

3.反向切片

# 对列表进行切片，从3开始，到1结束，步长-1
my_list = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list[3:1:-1]
print(f"结果5：{result5}")

八.其他函数

1.count 函数

# 9. 统计列表内某元素的数量
mylist = ["itcast", "programming", "itcast", "programming", "python"]
count = mylist.count("programming")
print(f"列表中programming的数量是：{count}")

2.len 函数

# 统计列表中全部的元素数量
mylist = ["itcast", "programming", "itcast", "programming", "python"]
count = len(mylist)
print(f"列表的元素数量总共有：{count}个")

3.reverse 函数

# 翻转list
mylist = ["itcast", "programming", "itcast", "programming", "python"]
mylist.reverse()
print(f"通过reverse方法翻转后，列表的结果是：{mylist}")

4.eval 函数

正确使用

values = eval('[9,10]')
print(f"values = {values},type = {type(values)}")

values = [9, 10],type = <class 'list'>

错误使用

print(eval([9,10]))

TypeError: eval() arg 1 must be a string, bytes or code object

5.栈

stack = [] #定义栈

stack[-1]   #取栈顶