python列表

python列表

一、使用列表的好处

1. 灵活性：列表可以包含不同类型的数据，例如整数、浮点数、字符串、其他列表等。这种灵活性使得列表可以很容易地适应不同的数据需求。

2. 易于使用：Python的列表功能丰富且易于使用。例如，你可以使用简单的语法来创建列表、添加元素、删除元素等。

3. 支持索引和切片：列表支持索引和切片，这使得访问、插入和修改列表中的元素非常方便。

4. 支持迭代：列表是可迭代的，这意味着你可以使用for循环来遍历列表中的所有元素。

5. 内置方法：Python的列表提供了很多内置方法，例如**append()、remove()、sort()**等，这些方法可以极大地简化数据处理任务。

6. 与其他数据结构兼容：列表可以很容易地转换为其他数据结构，例如元组、集合和字典。

7. 内存效率：列表在存储大量数据时非常高效，因为它们可以动态地分配内存。

8. 支持动态修改：你可以在任何时候向列表中添加或删除元素，这使得列表非常适合于需要动态修改数据的情况。

9. 支持排序和搜索：Python的列表提供了内置的排序和搜索功能，这使得处理大量数据时非常方便。

   • 排序：Python的sort()函数可以对列表进行排序。默认情况下，这将以升序排序列表，但也可以通过添加参数进行降序排序。j降序：.sort(reverse=True)

   # 创建一个列表  
   numbers = [5, 1, 9, 3, 7]  
   # 对列表进行排序  
   numbers.sort()  
   print(numbers)  # 输出：[1, 3, 5, 7, 9]  默认升序
     
   # 对列表进行降序排序    # reverse=True
   numbers.sort(reverse=True)  
   print(numbers)  # 输出：[9, 7, 5, 3, 1]
   

   • 搜索：Python的in关键字可以用来检查一个元素是否在列表中。

   # 创建一个列表  
   fruits = ['apple', 'banana', 'cherry']  
   # 检查一个元素是否在列表中  
   if 'banana' in fruits:  
       print("Banana is in the list")  # 输出：Banana is in the list
   

   此外，也可以使用index()方法找到特定元素的索引，如果元素不存在则抛出ValueError。

   # 创建一个列表  
   fruits = ['apple', 'banana', 'cherry']  
   # 找到'banana'的索引  
   print(fruits.index('banana'))  # 输出：1
   

   如果想要找出一个元素如果不存在于列表中，不抛出错误，而是返回一个特殊值（比如-1），你可以使用try/except结构：

   # 创建一个列表  
   fruits = ['apple', 'banana', 'cherry']  
   # 尝试找到'mango'的索引，如果找不到就返回-1  
   try:  
       print(fruits.index('mango'))  
   except ValueError:  
       print(-1)  # 输出：-1
   

10. 支持多维列表：Python的列表可以包含其他列表，这使得它们可以很容易地用于表示多维数据。

二、列表的定义方式

在Python中，列表是一种有序的数据集合，可以包含任意类型的数据项。列表的定义方式如下：

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

列表中的元素可以是任何类型的数据，例如字符串、浮点数、布尔值、列表、元组等等。这里是一些例子：

# 包含字符串的列表  
my_strings = ["apple", "banana", "cherry"]  
  
# 包含浮点数的列表  
my_floats = [1.1, 2.2, 3.3, 4.4]  
  
# 包含布尔值的列表  
my_bools = [True, False, True, False, True]  
  
# 包含列表的列表（嵌套列表）  
my_nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]  
  
# 包含元组的列表  
my_tuples = [(1, "apple"), (2, "banana"), (3, "cherry")]

在Python中，列表是非常灵活的数据结构，可以用于各种数据处理和操作。

三、内置方法

Python列表（list）是一种非常灵活且功能强大的数据结构，它支持许多内置方法，以下是一些常用的例子：

1. ⭐️append(x): 在列表末尾添加一个元素。

list1 = [1, 2, 3]  
list1.append(4)  
print(list1)  # 输出：[1, 2, 3, 4]

2. ⭐️extend(L): 将另一个列表的所有元素添加到列表末尾。

list1 = [1, 2, 3]  
list1.extend([4, 5])  
print(list1)  # 输出：[1, 2, 3, 4, 5]

3. ⭐️insert(index, x): 在指定位置插入一个元素。

list1 = [1, 2, 3]  
list1.insert(1, 'a')  
print(list1)  # 输出：[1, 'a', 2, 3]

4. ⭐️remove(x): 从列表中删除第一个出现的指定元素。

list1 = [1, 2, 3]  
list1.remove(2)  
print(list1)  # 输出：[1, 3]

5. ⭐️pop(index): 删除并返回指定位置的元素。如果没有提供索引，则删除并返回列表的最后一个元素。

list1 = [1, 2, 3]  
list1.pop(1)  
print(list1)  # 输出：[1, 3]

6. ⭐️clear(): 删除列表中的所有元素。

list1 = [1, 2, 3]  
list1.clear()  
print(list1)  # 输出：[]

7. index(x[, start[, end]]): 返回列表中第一个出现指定元素的索引。如果元素在列表中多次出现，则返回第一个出现的索引。还可以指定搜索的起始和结束位置。

list1 = [1, 2, 3, 2]  
print(list1.index(2))  # 输出：1  
print(list1.index(2, 2))  # 输出：3

8. ⭐️count(x): 返回指定元素在列表中出现的次数。

list1 = [1, 2, 3, 2]  
print(list1.count(2))  # 输出：2

9. ⭐️reverse(): 反转列表中的元素。

list1 = [1, 2, 3]  
list1.reverse()  
print(list1)  # 输出：[3, 2, 1]

10. ⭐️sort([key[, reverse]]): 对列表中的元素进行排序。可以指定一个key函数来定制排序，还可以设置reverse参数为True来进行降序排序。

list1 = [3, 1, 4, 1, 5, 9]  
list1.sort()  
print(list1)  # 输出：[1, 1, 3, 4, 5, 9]

四、sort()和sorted()的区别

sort()和sorted()的区别主要有两点：

1. sort()是在原位重新排列列表，而sorted()是产生一个新的列表。这意味着sort()方法会直接修改原有的列表，而sorted()函数则会返回一个新的已排序的列表，原列表保持不变。

举例来说，假设有一个列表ls = [3, 1, 4, 1, 5, 9]，对其进行排序操作：

ls.sort()  
print(ls)  # 输出：[1, 1, 3, 4, 5, 9]

在这个例子中，ls经过sort()方法后，在原列表的基础上进行了排序，所以输出的ls是已经排序后的列表。

而使用sorted()函数对ls排序，会返回一个新的已排序列表，如下所示：

new_ls = sorted(ls)  
print(new_ls)  # 输出：[1, 1, 3, 4, 5, 9]  
print(ls)  # 输出：[3, 1, 4, 1, 5, 9]

在这个例子中，sorted()函数对ls进行排序后返回了一个新的列表new_ls，原列表ls并未改变。

2. sort()只能对列表进行排序，而sorted()可以用于所有可迭代的对象，包括列表、元组、字符串等。

例如，可以用sorted()对元组进行排序：

t = (3, 1, 4, 1, 5, 9)  
new_t = sorted(t)  
print(new_t)  # 输出：[1, 1, 3, 4, 5, 9]

在这个例子中，元组t经过sorted()函数处理后返回了一个新的已排序列表new_t。注意新列表new_t是一个列表类型，而不是元组类型。

五、常见的操作–增删改查/切片/推导式拼接

1. 创建列表：使用方括号[]来创建一个列表，可以包含任意类型的元素。例如：

# 定义一个列表  
my_list = ['apple', 'banana', 'cherry']  
print(my_list)  
# 输出：['apple', 'banana', 'cherry']

2. 访问元素：通过索引来访问列表中的元素。例如：

print(my_list[0])  # 输出：1  
print(my_list[3])  # 输出："apple"

3. 修改元素：通过索引来修改列表中的元素。例如：

my_list[0] = 100  
print(my_list)  # 输出：[100, 2, 3, "apple", "banana"]

4. 添加元素：使用append()方法在列表的末尾添加元素，或者使用insert()方法在指定位置插入元素。例如：

# 在列表末尾添加元素  
my_list.append('orange')  
print(my_list)  
# 输出：['apple', 'banana', 'cherry', 'orange']  
  
# 在特定位置插入元素  
my_list.insert(1, 'grape')  
print(my_list)  
# 输出：['apple', 'grape', 'banana', 'cherry', 'orange']

5. 删除元素：使用remove()方法删除列表中的第一个匹配的元素，或者使用pop()方法删除指定位置的元素。例如：

# 删除特定元素  
my_list.remove('banana')  
print(my_list)  
# 输出：['apple', 'grape', 'cherry', 'orange']  
  
# 根据索引删除元素  
del my_list[2]  
print(my_list)  
# 输出：['apple', 'grape', 'orange']

6. 列表切片：使用切片语法来访问列表的一部分。例如：

# 获取列表的子集，从索引1到2（不包括2）  
subset = my_list[1:2]  
print(subset)  
# 输出：['grape']

7. 循环遍历：使用for循环来遍历列表中的所有元素。例如：

for item in my_list:  
    print(item)

8. 列表推导式：使用列表推导式来快速创建一个新的列表。例如：

new_list = [i * 2 for i in my_list]  
print(new_list)  # 输出：[200, 6, "bananabanana", 8]

再如：

original_list = ['apple', 'banana', 'cherry', 'apricot', 'blueberry']  
filtered_list = [item for item in original_list if len(item) > 3]

# 创建一个新的列表，其中的元素是原列表中每个元素的平方  
squares = [x**2 for x in range(10)]  
print(squares)  
# 输出：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

9. 列表拼接：使用+操作符来拼接两个列表。例如：

other_list = [5, 6, 7]  
combined_list = my_list + other_list  
print(combined_list)  # 输出：["cherry", 100, 3, "banana", 4, 5, 6, 7]

六、循环遍历

1. 使用for循环

my_list = [1, 2, 3, 4, 5]  
  
for item in my_list:  
    print(item)

2. 使用while循环和索引

my_list = [1, 2, 3, 4, 5]  
i = 0  
  
while i < len(my_list):  
    print(my_list[i])  
    i += 1

3. 使用列表推导式

my_list = [1, 2, 3, 4, 5]  
  
[print(item) for item in my_list]

以上三种方法输出都为：

1  
2  
3  
4  
5