Python数据容器——列表（list)

数据容器入门

Python中的数据容器：
一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素
每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

数据容器根据特点的不同，如：是否支持重复元素，是否可以修改，是否有序，等
分为5类，分别是：
列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)

数据容器：

1、List(列表)入门

1、list（列表）就是C语言里的数组。
在C语言中，数组的元素必须是相同类型的数据。
如果需要在一个数组中存储不同类型的数据，可以考虑使用结构体（Struct）或联合体（Union）来实现。结构体允许将不同类型的数据组合在一起，而联合体则允许共享同一块内存空间存储不同类型的数据。

但是Python不一样：

字面量：[元素1，元素2，元素3]

定义变量：变量名称 = [元素1，元素2，元素3]

定义空列表：

变量名称 = []     或      变量名称 = list()

元素可以是不同类型。例如：

list1 = ['Hello', 111, True]

2、列表可以嵌套：

list2 = [['Hello', 111, True], ['world', 222, False]]

3、可以使用列表的下标索引从列表中取出元素

list1 = ['Hello', 111, True]
print(list1[0]) # 输出Hello
print(List[-1]) # 反向索引，输出 True，从-1开始，依次递减  -1，-2……




list2 = [['Hello', 111, True], ['world', 222, False]]
print(list2[1])
print(list2[0][1])

"""
输出结果：
['world', 222, False]
111
"""

4、列表的常用方法（操作）

插入元素、删除元素、清空列表、修改元素、统计元素个数   等等功能，这些功能我们都称之为：列表的方法

在Python中，如果将函数定义为class(类)的成员，那么函数会称之为：方法

class Student:

    def add(self,x,y):
        return x+y

方法和函数功能一样，有传入参数，有返回值，只是方法的使用格式不同，函数与方法之间只有这一点不同：
函数的使用：num add(1,2)  #  def num (x,y): ……
方法的使用：student = Student() 

                      num = student.add(1,2)

列表内部提供了很多方法：注意：方法只能是小括号（）

方法	功能或注意点
查找：  列表名.index(元素)	查找指定元素在列表的下标 如果找不到，报错ValueError
修改：列表名[下标] = 值	是重新赋值，“列表名[下标] = 值”中的值会替换原来的值
插入： 列表名.insert(下标，元素）	是在指定的地方插入指定的元素，“列表名.index(下标，元素）”就是在该下标下插入该元素。 需要注意的是： 1、这里是insert，不是index。 2、插入后，后面的元素会后移，而不是被替换掉。 3、是小括号，不是中括号。
追加： 单个元素： 列表名.append(元素） 列表名.extend(其他数据容器）	append()是将指定元素追加到列表的尾部。 extend()是将其他数据容器的内容取出，依次追加到列表尾部。
通过指定下标来删除： 1、del  列表名[下标] 2、列表名.pop(下标) 通过指定元素来删除： 列表名.remove(元素)	通过指定元素来删除时，是删除某元素在列表中的第一个匹配项 删除所有匹配项，见下面的示例代码。
清空列表： 列表名.clear()	结果：[]
统计某元素在列表内的数量： 列表名.count(元素）	不可以查询到表中表的内容。
统计列表长度 len(列表名）

例如：

# 查询方法
list1 = ["Hello", "World", "!"]
index = list1.index("Hello")
print(index)
# 输出结果：0 （这表明是正向的索引）

list2 = [["Hello", 111, True], ['world', 222, False]]
index = list2.index("Hello")
print(index)
# 输出：ValueError: 'Hello' is not in list
'''
要查找的元素 "Hello" 是一个字符串，
而列表中的元素是嵌套列表。
在这种情况下，需要使用循环来遍历列表
并检查子列表中的元素。
否则会报错。
修正后：↓
'''
for i in range(len(list2)):
    if "Hello" in list2[i]:
        index = i
        break
print(index)
# 输出结果：0

# 修改元素值
list1 = ["Hello", "World", "!"]
list1[1] = "Python"  # 正向下标
list1[-1] = "~"   # 反向下标
print(list1)
# 输出结果：['Hello', 'Python', '~']

# 插入元素值
list1 = ["Hello", "World", "!"]
list1.insert(1,"Python")
list1.insert(-1, "~")
print(list1)
# 输出结果：['Hello', 'Python', 'World', '~', '!']

# 追加元素
list1 = ["Hello", "World", "!"]
list1.append("~")
print(list1)
# 输出结果：['Hello', 'World', '!', '~']

list2 = [1, 2, 3]
list2.append([4, 5, 6])
# list2.append(7, 8) #这个会报错，只能追加单个元素的方法
print(list2)
# 输出结果：[1, 2, 3, [4, 5, 6]]

list2.extend(list1)  # 追加其他数据容器
print(list2)
# 输出结果：[1, 2, 3, [4, 5, 6], 'Hello', 'World', '!', '~']

# 通过指定下标来删除元素
list1 = ["Hello", "World", "!"]
list2 = [1, 2, 3]

del list1[0]
element = list2.pop(0)  # 用element来接受删点的元素

print(list1)  # 输出结果：['World', '!']
print(list2)  # 输出结果：[2, 3]
print(element)  # 输出结果：1

# 通过指定元素来删除
list3 = [1, 1, 2, 3]
list3.remove(1)
print(list3)  # 输出结果：[1, 2, 3]

# 清空列表
list3 = [1, 1, 2, 3]
list3.clear()
print(list3)  # 输出结果：[]

# 统计元素1的个数
list3 = [1, 1, 2, 3]
count = list3.count(1)
print(count)  # 输出结果：2

# 统计列表长度
print(len(list3))  # 输出结果：4

# 综合训练
list5 =[21, 25, 21, 23, 22, 20]

list5.append(31)  # 追加一个数字31到列表的尾部
list5.extend([29, 33, 30])  # 追加一个新列表[29,33,30]到列表的尾部
num1 = list5[0]  # 取出第一个元素（应是：21）
num2 = list5[-1]  # 取出最后一个元素（应是：30）
index = list5.index(31)  # 查找元素31所在的位置

print(f"追加一个数字31到列表的尾部后的list5是:{list5}")
print(f"追加一个新列表[29,33,30]到列表的尾部后list5是:{list5}")
print(f"取出的第一个元素是: {num1}")
print(f"取出最后一个元素是: {num2}")
print(f"元素31所在的位置是: {index}")

"""
输出结果：
追加一个数字31到列表的尾部后的list5是:[21, 25, 21, 23, 22, 20, 31, 29, 
33, 30]
追加一个新列表[29,33,30]到列表的尾部后list5是:[21, 25, 21, 23, 22, 20,
 31, 29, 33, 30]
取出的第一个元素是: 21
取出最后一个元素是: 30
元素31所在的位置是: 6
"""

删除列表中所有与指定元素相等的元素：
1、可以使用循环和条件语句来遍历列表并删除元素。一种常见的方法是使用列表推导式。
下面是一个例子：

my_list = [1, 2, 3, 2, 4, 2, 5]
element_to_remove = 2  # 删除列表中所有的2

my_list = [x for x in my_list if x != element_to_remove]

print(my_list)

上面的代码中，我们有一个列表`my_list`，其中包含一些整数。我们想要删除所有与指定元素`element_to_remove`相等的元素。使用列表推导式，我们创建了一个新列表，其中包含所有不等于`element_to_remove`的元素。通过重新赋值给`my_list`，我们将原来列表中的所有匹配元素都删除了。最后，我们打印输出列表的结果，可以看到所有与指定元素相等的元素已经被删除了。

2、如果要修改原列表而不是创建一个新列表，可以使用`while`循环来遍历列表，使用`remove()`方法删除匹配元素，直到列表中不再存在这个元素。例如：

my_list = [1, 2, 3, 2, 4, 2, 5]
element_to_remove = 2

while element_to_remove in my_list:
    my_list.remove(element_to_remove)

print(my_list)

在这个例子中，我们通过不断地调用`remove()`方法来删除匹配元素，直到列表中不再存在与指定元素相等的元素。最终，我们打印输出列表的结果，可以看到匹配元素已经全部被删除了。

2、1ist(列表)的遍历

列表的遍历有两种：使用while循环，遍历列表的元素和使用for循环，遍历列表的元素。

while循环：

index = 0

while index < len(列表名):

        元素 = 列表名[index]

        其他处理……

        index += 1  #最关键的一步，千万别忘记。

除了while:循环外，Python中还有另外一种循环形式：for循环。
对比while,for循环更加适合对列表等数据容器进行遍历。

for 临时变量 in 数据容器:

        对临时变量进行处理

for循环中，会把取出的变量赋值给临时变量

# 通过while来完成列表的遍历
list3 = [1, 1, 2, 3]
print("列表的元素值是:", end=" ")

index = 0  # 从0下标开始遍历
while index < len(list3):
    element = list3[index]  # 取出index下标对应的元素
    print(element, end=" ")
    index += 1  # 千万别忘了这一点，循环的关键；python里不支持index++
#  输出结果：列表的元素值是: 1 1 2 3
print()

# 通过for来完成列表的遍历
for element in list3:
    print(f"列表的元素有:{element}")

"""
输出结果：
列表的元素有:1
列表的元素有:1
列表的元素有:2
列表的元素有:3
"""

两者之间比较：
while循环和for循环，都是循环语句，但细节不同：
·在循环控制上：
while循环可以自定循环条件，并自行控制
for循环不可以自定循环条件，只可以一个个从容器内取出数据

·在无限循环上：
while循环可以通过条件控制做到无限循环
for循环理论上不可以，因为被遍历的容器容量不是无限的

在使用场景上：
while循环适用于任何想要循环的场景
for循环适用于逾历数据容器的场景或简单的固定次数循环场景​​​​​​​

3、函数与方法 

在Python中，方法（method）与函数（function）是类似但又有一些区别的概念。函数是一段封装了一组操作的可重复使用的代码块。它可以接受零个或多个参数，并且可以返回一个结果。函数可以通过`def`关键字来定义，并且可以在需要时被调用。例如：

def greet(name):
    print("Hello, " + name + "!")
    
greet("Alice")

在这个例子中，`greet`函数接受一个参数`name`，并打印出问候语。调用`greet("Alice")`会输出`Hello, Alice!`。

方法是一个对象的行为，通常与特定的对象关联。对象可以是Python中的内置类型（如字符串、列表等）或用户定义的类的实例。方法可以通过对象的名称和`.`运算符来调用。例如：

s = "hello"
print(s.upper())

在这个例子中，字符串对象`s`具有一个名为`upper`的方法。`upper`方法将字符串中的所有字母转换为大写，并返回转换后的结果。调用`s.upper()`会输出`HELLO`。

方法与函数的主要区别在于：方法必须通过某个对象进行调用，而函数则可以直接调用。方法与对象之间是绑定的，它们可以访问并操作对象的属性和状态。而函数则是独立存在的，它们没有绑定到特定的对象。此外，方法的定义通常是在类中，而函数的定义可以是全局的。

4、列表推导式（list comprehension）

列表推导式是Python中一种简洁的语法，用于生成新的列表。它提供了一种方便的方式来根据现有列表或其他可迭代对象的元素，通过应用条件或操作来创建新的列表。

列表推导式的一般语法如下：

new_list = [expression for item in iterable if condition]

其中，`expression`是一个表达式，定义了新列表中每个元素的计算方式；`item`是迭代过程中的临时变量，可以使用任意名称；`iterable`是一个可迭代对象，如列表、元组或其他可迭代的数据结构；`condition`是一个可选的条件，用于过滤元素。

通过列表推导式，我们可以对现有的列表进行筛选、转换或组合，从而一行代码就生成一个新的列表。这种简洁的语法特性在处理列表数据时非常有用，可以使代码更简洁、易读和高效。以下是几个示例：

# 生成一个由1到5的平方组成的新列表
squares = [x**2 for x in range(1, 6)]  # [1, 4, 9, 16, 25]
# 筛选出列表中大于10的元素
numbers = [1, 5, 12, 9, 8, 15]
filtered_numbers = [x for x in numbers if x > 10]  # [12, 15]
# 将列表中的字符串元素转换为大写形式
words = ["hello", "world", "python"]
uppercase_words = [word.upper() for word in words]  
# ["HELLO", "WORLD", "PYTHON"]

请注意，虽然列表推导式在简单情况下使用非常方便，但在处理大型和复杂的数据集时，可能需要考虑使用其他更加灵活和可读性更好的方法。

这种方式相对简洁，但需要注意的是，它创建了一个新的列表，而不是修改原来的列表。如果要在原地修改列表，可以使用循环和条件语句的方式来遍历列表并删除元素。​​​​​​​