Python基础List

目录

列表List

列表函数max()和index()

统计元素的出现次数： 

 删除列表中的元素

定义一个元素全为0的9*10二维列表

 列表复制 

二、将字符列表转换为字符串

三、二维列表排序

四、列表和栈 

---

列表List

在Python中，如果你想要在一个for循环中遍历列表并同时获取每个元素的下标，你可以使用enumerate()函数。这个函数返回一个枚举对象，该对象产生一个元素（元组）序列，每个元组包含两个元素：一个是下标（索引），另一个是对应的值。

# 定义一个列表  
my_list = ['apple', 'banana', 'cherry', 'date']  
  
# 使用for循环和enumerate()函数同时获取下标和值  
for index, value in enumerate(my_list):  
    print(f'Index: {index}, Value: {value}')  
  
# 输出:  
# Index: 0, Value: apple  
# Index: 1, Value: banana  
# Index: 2, Value: cherry  
# Index: 3, Value: date

1.1 列表函数max()和index()

# 定义一个列表  
nums = [1, 3, 5, 7, 9, 2, 4, 6, 8]  
  
# 使用max()函数找到最大值  
max_value = max(nums)  
  
# 使用index()方法找到最大值的下标  
max_index = nums.index(max_value)  

1.2 统计元素的出现次数： 

• 使用Python的 collections.Counter 类，它提供了一个方便的接口来统计元素的出现次数：

from collections import Counter  
  
my_list = [1, 2, 2, 3, 2, 4, 2]  
  
# 使用Counter类直接统计元素出现次数  
counter = Counter(my_list)  
  
# 打印结果  
for element, count in counter.items():  
    print(f"元素 {element} 出现了 {count} 次。")

• 字典计数

my_list = [1, 2, 2, 3, 2, 4, 2]  
  
# 创建一个空字典作为计数器  
counter = {}  
  
# 遍历列表中的每个元素  
for element in my_list:  
    # 使用get方法获取元素在字典中的当前计数，默认为0  
    count = counter.get(element, 0)  
    # 更新字典中该元素的计数  
    counter[element] = count + 1  
  
# 打印结果  
for element, count in counter.items():  
    print(f"元素 {element} 出现了 {count} 次。")

 1.3 删除列表中的元素

以下是几种常用的方法：

• 使用 remove() 方法删除指定元素（如果元素存在多个，只删除第一个）：

my_list = [1, 2, 3, 4, 2, 5]  
my_list.remove(2)  # 删除第一个出现的2  
print(my_list)  # 输出: [1, 3, 4, 2, 5]

• 使用 pop() 方法删除指定索引的元素（如果不提供索引，默认删除最后一个元素）：

my_list = [1, 2, 3, 4, 5]  
my_list.pop(1)  # 删除索引为1的元素（即2）  
print(my_list)  # 输出: [1, 3, 4, 5]

• 使用 del 语句删除指定索引的元素或切片：

my_list = [1, 2, 3, 4, 5]  
del my_list[1]  # 删除索引为1的元素（即2）  
print(my_list)  # 输出: [1, 3, 4, 5]  
  
# 也可以删除一个切片  
del my_list[1:3]  # 删除索引1到2（不包含3）的元素  
print(my_list)  # 输出: [1, 5]

• 使用列表推导式（list comprehension）来创建一个新的列表，不包含要删除的元素：

my_list = [1, 2, 3, 4, 2, 5]  
my_list = [x for x in my_list if x != 2]  # 删除所有值为2的元素  
print(my_list)  # 输出: [1, 3, 4, 5]

5. 使用 filter() 函数和 lambda 表达式（这在某些情况下可能更冗长，但对于复杂条件很有用）：

my_list = [1, 2, 3, 4, 2, 5]  
my_list = list(filter(lambda x: x != 2, my_list))  # 删除所有值为2的元素  
print(my_list)  # 输出: [1, 3, 4, 5]

请注意，remove() 和 pop() 方法会就地修改列表（即不返回新列表，而是修改原始列表），而列表推导式和 filter() 会创建新的列表。如果你需要保留原始列表，请使用列表推导式或 filter()。

1.4 定义一个元素全为0的9*10二维列表

# 定义一个9*10的二维列表，元素初始化为0
my_list = [[0 for _ in range(10)] for _ in range(9)]

 1.5 列表复制 

1. 使用赋值操作符（=）

注意：这实际上是将一个列表的引用赋值给另一个变量，而不是创建一个新的列表。如果你之后修改了其中一个列表，另一个也会受到影响（因为它们实际上引用的是同一个列表）。

list1 = [1, 2, 3]  
list2 = list1  # list2 和 list1 引用同一个列表

2. 使用切片（[:]）

这是创建列表副本的最常用方法。使用切片操作可以创建一个新的列表，其中包含原始列表的所有元素。

list1 = [1, 2, 3]  
list2 = list1[:]  # list2 是 list1 的一个副本

1.6 深拷贝/ 浅拷贝 

当你执行res.append(path)时，你实际上是将path列表的引用添加到了res列表中。这意味着res列表中的最后一个元素与path列表指向的是同一个对象。因此，如果你修改了path列表，那么res列表中的对应元素也会发生变化，因为它们实际上是指向同一个列表对象。

res, path = [], [1, 2] 
  
# 直接添加引用  
res.append(path)  
print(res)  # 输出: [[1, 2]]  
  
# 修改path  
path.append(3)  
print(res)  # 输出: [[1, 2, 3]]，因为res中的列表和path是同一个对象  
  
# 重新初始化  
res, path = [], [1, 2]  
  
# 添加浅拷贝  
res.append(list(path))  
print(res)  # 输出: [[1, 2]]  
  
# 修改path  
path.append(3)  
print(res)  # 输出: [[1, 2]]，因为res中的列表是path的一个独立拷贝

二、将字符列表转换为字符串

 ''表示连接列表元素时使用的分隔符。因为我们不需要分隔符，所以使用了空字符串。join方法会将列表中的每个元素连接在一起，并返回一个字符串。

my_list = ['a', 'p', 'p', 'l','e']
my_string = ''.join(my_list)
print(my_string)

数字123转换为列表 [‘1’，‘2’，‘3’]

num = 123  
# 转换为字符串，然后利用空字符串作为分隔符来分割它，最终通过list()转换回列表  
num_list = list(str(num))  
print(num_list)  # 输出: ['1', '2', '3']

将列表[‘1’，‘2’，‘3’]转换为int 123 

num_list = ['1', '2', '3']  
# 使用join方法将列表中的字符串元素合并为一个单独的字符串  
num_str = ''.join(num_list)  
# 将合并后的字符串转换为整数  
num_int = int(num_str)  
  
print(num_int)  # 输出: 123

三、二维列表排序

1. 根据每个区间的结束值（x[1]）对 intervals 进行排序。如果两个区间的结束值相同，那么它们的相对顺序在排序后保持不变

intervals = [[1, 3], [5, 8], [2, 6], [4, 7]]

intervals.sort(key=lambda x: x[1])

print(intervals) # 输出: [[1, 3], [2, 6], [4, 7], [5, 8]]

2. 根据区间的第一个值进行排序，并且在第一个值相等的情况下，第二个值较小的排在后面（即降序排序第二个值）

intervals = [[1, 3], [5, 8], [2, 6], [1, 7], [4, 7]]  
  
# 使用元组作为key，首先根据第一个值排序，然后在第一个值相等时根据第二个值的负数排序（即降序）  
intervals_sorted = sorted(intervals, key=lambda x: (x[0], -x[1]))  
  
print(intervals_sorted)  # 输出: [[1, 7], [1, 3], [2, 6], [4, 7], [5, 8]]

要按降序对列表进行排序，你需要将sort()方法的reverse参数设置为True 

my_list = [3, 1, 4, 1, 5, 9, 2]  
my_list.sort(reverse=True)  
print(my_list)  # 输出: [9, 5, 4, 3, 2, 1, 1]

四、列表和栈 

stack = [1, 2, 3]

# 出栈
stack.pop()

# 入栈
stack.append(元素)

# 栈顶元素，不出栈
stack[-1]

Python 列表(List) | 菜鸟教程 (runoob.com)