python列表

✳定义

列表 是可以存放任何数据，包括整型，浮点型，字符串，布尔型等，是常用的数据类型之一。

1.列表的创建

列表也是一个可迭代对象
1. 普通形式
        list = [1,2,3,4,5] ---整型列表
        list = ["a","b","c"] ---字符串列表
        list = [True,False,1>2,5<6]---布尔列表
2. 混合列表
		list = [1,2.5,"a",True]
3. 空列表
		list = []

• 从列表中获取数据(元素)

列表是有下标的，并且下标从0开始，元素是指列表中每个数据。

比如 list = [5,4,3,2,1] 里面有5个元素，但5的下标为0, 1的下标为4。

  ①：获取当个数据(元素)

语法：
	变量[下标] #获取下标所对应的值

例如：获取list列表中下标为1的元素：

list = [1, 2, 3]  # 下标/索引：0开始
print(list[1])

执行结果为：

2

 ②： 列表的遍历

列表的遍历是把列表里面的所有元素都获取1遍。

例如把[1,2,3,4,5]里面的元素都获取并输出一遍：

list = [1,2,3,4,5]
for i in list:
    print(i, end=" ")

执行结果为：

1 2 3 4 5 

解析：

 end=" "的作用是防止换行：因为print（）函数会在输出的末尾添加一个换行符（'\n'），使得每次调用print（）函数后，输出内容都会从新的一行开始。而当使用 end=" " 时，end=" "中的空格表示在输出内容的末尾添加一个空格而不是换行符。

    for i in range(5):
        print(i, end=" ")
    # 输出: 0 1 2 3 4
    # 输出连续的数字，每个数字后跟一个空格，而不是换行

③：交换数据 

 对指定下标的元素进行数据交换。

例如：

把[1, 2, 3, 4, 5]里面的下标为第2和第3的元素进行数据交换：

list = [1, 2, 3, 4, 5]  # 下标/索引：0开始
list[2], list[3] = list[3], list[2]
print(list)

执行结果：

[1, 2, 4, 3, 5]

 2.添加元素

添加元素的方法常用的有以下3个：

①：append()

说明：向列表中添加对象，并添加到末尾。

#语法： 变量.函数
n.append(对象)

例子：

list = [1, 2, 3]
list.append(4)
print(list)

输出

[1, 2, 3, 4]

需要注意的是，append() 方法只能添加一个元素，如果你尝试添加多个元素，它们会被视为一个单一的元素。 并且它不会返回一个新的列表，而是直接修改原列表。

例子：

# 创建一个空列表
empty_list = []
# 添加元素
empty_list.append(1)
empty_list.append("hello")
empty_list.append([1, 2, 3])

print(empty_list)  # 输出: [1, 'hello', [1, 2, 3]]

# 创建一个已有元素的列表
numbers = [1, 2, 3]
# 添加一个新元素
numbers.append(4)

print(numbers)  # 输出: [1, 2, 3, 4]

②：extend()

说明：用于将一个列表中的所有元素添加到另一个列表末尾的方法。

#语法： 变量.函数
n.extend(对象)

例子：

# 创建两个列表
a = [1, 2, 3]
b = [4, 5, 6]

# 使用 extend() 方法将 b 的元素添加到 a 的末尾
a.extend(b)

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

# extend() 也可以用于将字符串的每个字符添加到列表中
c = "hello"
a.extend(c)

print(a)  # 输出: [1, 2, 3, 4, 5, 6, 'h', 'e', 'l', 'l', 'o']

需要注意的是，extend() 方法不会返回一个新的列表，而是直接修改原列表。如果你传递给 extend() 方法的不是列表（比如一个整数或者一个字符串），则会引发 TypeError，因为该方法期望可迭代的对象作为参数。如果需要添加一个单独的元素到列表末尾，应该使用 append() 方法。

③：insert()

说明：用于将一个元素插入列表中的指定位置。

这个方法第一个参数是插入位置的索引，第二个参数是要插入的元素。如果指定的索引超过了列表的现有长度，元素将被添加到列表的末尾。

以下是insert()方法的基本用法：

my_list = [1, 2, 4, 5]
my_list.insert(2, 3)  # 在索引2的位置插入元素3
print(my_list)  # 输出: [1, 2, 3, 4, 5]

注意事项：

1. 如果第一个参数是负数，它表示从列表末尾开始计数的偏移量。

2. insert() 方法会移动指定索引及其后面的元素，为新元素腾出空间。

示例：

# 示例1：在列表的开始插入元素
my_list = [1, 2, 3, 4]
my_list.insert(0, 0)
print(my_list)  # 输出: [0, 1, 2, 3, 4]

# 示例2：在列表的末尾插入元素
my_list.insert(len(my_list), 5)
print(my_list)  # 输出: [0, 1, 2, 3, 4, 5]

# 示例3：在列表的中间插入元素
my_list.insert(2, 2.5)
print(my_list)  # 输出: [0, 1, 2.5, 2, 3, 4, 5]

# 示例4：使用负索引插入元素
my_list.insert(-1, 6)
print(my_list)  # 输出: [0, 1, 2.5, 2, 3, 4, 6, 5]

insert() 方法是会改变原列表，而不会创建一个新的列表。

 

3.删除元素

①：del

del 语句用于删除变量或者列表、字典等数据结构中的元素。

1.删除整个变量：

a = 1
del a

执行上述代码后，变量a被删除，如果再尝试打印a，将会抛出NameError，因为a已经不存在了。

2.删除列表中的元素：

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

3.删除字典中的键值对：

my_dict = {'a': 1, 'b': 2, 'c': 3}
del my_dict['b']  # 删除键为'b'的键值对
print(my_dict)  # 输出: {'a': 1, 'c': 3}

4.删除切片：

my_list = [1, 2, 3, 4, 5]
del my_list[1:3]  # 删除索引从1到2（不包括3）的切片
print(my_list)  # 输出: [1, 4, 5]

5.删除整个列表或字典：
 

my_list = [1, 2, 3]
my_dict = {'a': 1, 'b': 2}
del my_list
del my_dict
# 尝试打印将抛出错误，因为变量已经被删除

使用del时需要注意以下几点：

• del语句是同步的，也就是说，它立即删除指定的变量或元素。
• 使用del删除的是变量的引用，而不是数据本身。如果其他变量引用了同一数据，那么这些变量仍然可以访问该数据。
• 删除不存在的变量或元素将导致NameError或IndexError等错误。

②：remove()

remove() 方法通常应用于列表（list）对象，用于删除列表中指定的元素。

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

注意事项：

1. remove() 方法仅适用于列表，不能用于删除字典中的元素。

2. remove() 方法删除的是列表中第一次出现的指定元素。如果有多个相同的元素，只有第一个会被删除。

3. 如果列表中没有找到指定的元素，remove() 方法将抛出 ValueError。

示例：

# 示例1：删除列表中的元素
my_list = ['a', 'b', 'c', 'd']
my_list.remove('b')
print(my_list)  # 输出: ['a', 'c', 'd']

# 示例2：尝试删除不存在的元素
my_list = ['a', 'b', 'c']
try:
    my_list.remove('d')  # 'd' 不在列表中
except ValueError as e:
    print("错误:", e)  # 输出: 错误: list.remove(x): x not in list

# 示例3：删除列表中的第一个元素
my_list = [1, 2, 3, 4]
my_list.remove(my_list[0])
print(my_list)  # 输出: [2, 3, 4]

如果你想删除列表中的所有特定元素，你可能需要使用循环：
 

my_list = [1, 2, 3, 2, 4, 2]
while 2 in my_list:
    my_list.remove(2)
print(my_list)  # 输出: [1, 3, 4]

或者使用列表推导式：

my_list = [1, 2, 3, 2, 4, 2]
my_list = [x for x in my_list if x != 2]
print(my_list)  # 输出: [1, 3, 4]

 

③：clear()

说明：clear()方法用于清空列表中的所有元素，即将列表变为空列表。

该方法不返回任何值，它会直接修改原列表。

示例：

my_list = [1, 2, 3, 4, 5]
    my_list.clear()  # 清空列表
    print(my_list)  # 输出: []

解析：

使用clear()方法后，列表my_list中的所有元素都会被移除，列表长度变为0。

注意：clear()方法不同于将列表设置为一个新的空列表（my_list = []），后者会创建一个新的空列表，并重新分配变量my_list指向它，而原来的列表对象仍然存在于内存中（如果还有其他变量引用它的话）。

clear()方法则是直接在原有的列表对象上操作，将其内容清空。这意味着，如果其他变量也引用了这个列表，使用clear()后，这些变量看到的列表也会是空的。

示例：

    # 示例1：使用clear()清空列表
    my_list = [1, 2, 3, 4, 5]
    another_list = my_list
    my_list.clear()
    print(my_list)  # 输出: []
    print(another_list)  # 输出: []
    
    # 示例2：将列表设置为新的空列表
    my_list = [1, 2, 3, 4, 5]
    another_list = my_list
    my_list = []
    print(my_list)  # 输出: []
    print(another_list)  # 输出: [1, 2, 3, 4, 5]

在示例2中，another_list仍然引用了原始的列表对象，因此即使my_list被重新赋值为一个新的空列表，another_list的内容仍然保持不变。

 

④：pop()

pop() 方法用于从列表中移除一个元素，并且返回该元素。

说明：默认情况下，pop()方法移除并返回列表中的最后一个元素，但也可以指定一个索引来移除特定位置的元素。

 示例：

# 移除并返回列表中的最后一个元素
    my_list = [1, 2, 3, 4, 5]
    popped_element = my_list.pop()
    print(popped_element)  # 输出: 5
    print(my_list)         # 输出: [1, 2, 3, 4]
    
    # 移除并返回指定索引的元素
    my_list = [1, 2, 3, 4, 5]
    popped_element = my_list.pop(1)  # 移除索引为1的元素
    print(popped_element)  # 输出: 2
    print(my_list)         # 输出: [1, 3, 4, 5]

如果指定的索引超出了列表的范围，pop() 方法将抛出一个IndexError。

示例：

# 初始化列表
    my_list = [1, 2, 3, 4, 5]
    
    # 移除最后一个元素
    print(my_list.pop())  # 输出: 5
    
    # 移除索引为2的元素
    print(my_list.pop(2))  # 输出: 3
    
    # 移除第一个元素
    print(my_list.pop(0))  # 输出: 1
    
    # 此时列表为 [2, 4]
    print(my_list)  # 输出: [2, 4]
    
    # 尝试移除不存在的索引
    try:
        print(my_list.pop(10))  # 这里会抛出IndexError
    except IndexError as e:
        print("索引超出范围:", e)  # 输出: 索引超出范围: pop index out of range

pop()`方法不仅限于移除列表元素，它也可以用于移除字典中的键值对，但用法略有不同。对于字典，pop()方法移除指定的键并返回对应的值。

 

4. 修改元素：

①：方法

变量[下标]=新值

例如：

list = [1, 2, 3, 4, 5]
list[2]=6
print(list)

执行结果： 

[1, 2, 6, 4, 5]

5.列表高级特性

     ①：切片操作

定义：就是把1个列表切分为多个列表，

语法：

变量[起始下标:结束下标]     #结束下标取不到

例如：

list = [1, 2, 3, 4, 5]
print(list[0:4])

#执行结果：
[1, 2, 3, 4]

注意：

①如果下标从0开始可以省略不写，例如 n = list[:4]
②如果结束下标取的是最后一个元素，可以省略不写，例如 n = list[3:]
③如果列表中的元素都要，开始和结束下标都可以省略，例如 n = list[:]
④n = list[:-1] 表示从0开始 - 倒数第二个元素（#结束下标取不到）

 

②：列表的进阶操作

 方法：
n = list[开始:结束:步长] ，这个方法既可以正向去操作列表，也可以反向去操作列表。

例如:

list = [1, 2, 3, 4, 5]
n = list[-1:-3:-1]
print(n)

执行结果：

[5, 4]

 

③：列表的操作符

1、比较运算符
列表之间进行比较，以相同下标进行比较，从小到大进行比较，如果值相同则比较下一组元素，如果不同直接出结果。
例如：

list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  # 下标/索引：0开始
list2 = [2, 3, 4, 6]
print(list < list2)  # True

执行结果：
True

2、逻辑运算符
逻辑运算符and not or 跟比较运算符相似，返回结果都是布尔值（True/False）。

3、拼接运算符
拼接运算符是 + ，常用来进行两个列表拼接。

例如：

list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  # 下标/索引：0开始
list2 = [2, 3, 4, 6]
print(list + list2)

执行结果：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 2, 3, 4, 6]

4、重复操作符
重复操作符为 * ，后面常跟数字，表示将列表里面的元素重复复制几遍。

例如：

list2 = [2, 3, 4, 6]
print(list2*2)

执行结果：
[2, 3, 4, 6, 2, 3, 4, 6]

5、成员关系操作符
成员关系操作符主要有 in和not in，用来判断元素是否在列表中，返回结果是布尔值。

例如：

list = [2, 3, 4, 6]
print(5 not in list)    #输出“5不在列表l中”这句话的真假

执行结果：
True    

④：列表的其他方法

 1、reverse()

将列表里面的所有元素进行翻转

例子：

list = [2, 3, 4, 6]
list .reverse()
print(list )

执行结果：
[6, 4, 3, 2]

 

2、copy()

说明：copy() 方法用于创建对象的浅拷贝。

浅拷贝意味着拷贝对象时，并不会复制对象内部引用的其他对象，而是仅仅复制对象本身及其包含的引用。因此，如果原始对象中有可变对象（例如列表或字典），那么浅拷贝后的对象和原始对象中这些可变对象的引用是相同的。

例子：

### 对于列表的浅拷贝：

    import copy
    
    original_list = [1, 2, [3, 4]]
    shallow_copied_list = copy.copy(original_list)
    
    # 修改原始列表中的不可变元素
    original_list[0] = 5
    print(original_list)         # 输出: [5, 2, [3, 4]]
    print(shallow_copied_list)   # 输出: [1, 2, [3, 4]]
    
    # 修改原始列表中的可变元素（列表）
    original_list[2][0] = 6
    print(original_list)         # 输出: [5, 2, [6, 4]]
    print(shallow_copied_list)   # 输出: [1, 2, [6, 4]]，因为可变元素的引用没有改变
    

 注意事项：

①:  对于不可变对象（如整数、浮点数、字符串和元组），浅拷贝会创建一个新的对象，与原始对象完全独立。
②：对于可变对象，浅拷贝仍然会保留对原始对象的引用，因此修改原始对象中的可变对象，也会影响到浅拷贝的对象。
③：如果需要创建一个对象的深拷贝（即复制对象以及对象包含的所有子对象），应该使用copy.deepcopy()方法。

 

3、index()

说明：index() 方法通常用于在序列（如字符串、列表、元组）中查找某个值的第一个出现位置。如果找到了这个值，index() 方法会返回该值的位置索引；如果没有找到，则会抛出一个 ValueError 异常。

示例：

### 字符串中的`index()`方法：

    s = "hello world"
    index_of_w = s.index('w')  # 返回 'w' 的索引
    print(index_of_w)  # 输出: 7
    

### 列表中的`index()`方法：

    list = [1, 2, 3, 4, 5]
    index_of_3 = list.index(3)  # 返回值为 3 的元素的索引
    print(index_of_3)  # 输出: 2
    

### 元组中的`index()`方法：

    tup = (1, 2, 3, 4, 5)
    index_of_4 = tup.index(4)  # 返回值为 4 的元素的索引
    print(index_of_4)  # 输出: 3

注意事项：

1.  index() 方法从序列的起始位置开始查找，直到找到第一个匹配的元素为止。
2.  索引是从0开始的，所以第一个元素的索引是0，第二个元素的索引是1，依此类推。
3.  如果要查找的值在序列中不存在，index()方法会抛出一个 ValueError 异常。为了避免异常，可以在调用index()之前先使用in操作符检查值是否存在于序列中。

示例：

#避免`ValueError`异常

    list = [1, 2, 3, 4, 5]
    
    # 安全地使用 index 方法
    if 3 in list:
        index_of_3 = list.index(3)
        print(index_of_3)  # 输出: 2
    else:
        print("数字3不在列表中")

通过这种方式，即使元素不存在于列表中，代码也不会抛出异常。

4、len()

len() 函数是Python中的一个内置函数，它用于返回对象（如字符串、列表、元组、集合、字典等）的长度。

 

5、sort()

sort() 方法是Python列表（list）类型的一个内置方法，它用于对列表中的元素进行排序。

sort() 方法会直接修改原列表（即原地排序），而不会创建一个新的列表。

基本使用方式：

### 默认排序（升序）：

    list = [5, 1, 4, 3, 2]
    list.sort()
    print(list)  # 输出: [1, 2, 3, 4, 5]
    

### 降序排序：

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

sort()方法还有一些可选参数，可以用来控制排序的规则：

①：reverse: 一个布尔值，如果设置为True，则列表会被降序排序，默认是False（升序排序）。

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

②：key: 一个函数，用来指定排序时比较的键值。这可以用来实现自定义的排序规则。

示例：

### 按字符串长度排序：

    list = ['banana', 'apple', 'cherry']
    list.sort(key=len)
    print(list)  # 输出: ['apple', 'banana', 'cherry']
    

注意：

*   列表中的元素需要是可比较的。如果列表中包含不同类型的元素，比如一个整数和一个字符串，那么排序时会抛出异常。
*   sort()方法没有返回值，它返回的是None。列表的排序是直接在原列表上进行的。
*   如果你需要一个排序后的列表副本而不改变原列表，可以使用sorted()函数。这个函数不会修改原列表，而是返回一个新的已排序的列表。

6、count()

count()方法用于计算列表中元素出现的次数。

基本使用方式：

 list = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
    count_of_3 = list.count(3)
    print(count_of_3)  # 输出: 3

count()方法的特点：

* count()方法接受一个参数，即你想要计数的元素。
* 它返回指定元素在列表中出现的次数。
* 如果列表中不存在该元素，则返回0。
* count()方法不会改变原列表。

示例：

### 计算列表中所有元素的出现次数：

    list = ['apple', 'banana', 'apple', 'cherry', 'banana', 'cherry']
    count_apple = list.count('apple')
    count_banana = list.count('banana')
    count_cherry = list.count('cherry')
    
    print(f"'apple' 出现次数: {count_apple}")  # 输出: 'apple' 出现次数: 2
    print(f"'banana' 出现次数: {count_banana}")  # 输出: 'banana' 出现次数: 2
    print(f"'cherry' 出现次数: {count_cherry}")  # 输出: 'cherry' 出现次数: 2
    

### 使用循环来计算列表中每个不同元素的计数：

    list = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
    
    unique_elements = set(list)  # 获取列表中所有不同的元素
    element_counts = {element: list.count(element) for element in unique_elements}
    
    print(element_counts)  # 输出: {1: 1, 2: 2, 3: 3, 4: 4}

使用set来获取列表中所有不同的元素，然后使用字典推导式来创建一个字典，其键是列表中的不同元素，值是它们出现的次数。这种方法虽然可以工作，但是效率不高，特别是对于大型列表，因为它会对列表中的每个元素调用`count()`方法，导致重复遍历整个列表。

6、冒泡排序法

算法：

1. 比较相邻的元素。如果第一个比第二个大（升序排序），就交换它们两个。
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后已经排序好的元素。
4. 重复步骤1~3，直到排序完成

例如：将列表[5,4,3,2,1]里面的所有元素用冒泡排序的思想进行从小到大排序。

l = [6, 5, 4, 3, 2, 1]
for i in range(0, len(l)-1):  # 0,5 #循环5大次  0，1，2，3，4
    for j in range(len(l) - 1 - i):  #优化代码引入i，减少循环次数。      
        if l[j] > l[j + 1]:
            l[j], l[j + 1] = l[j + 1], l[j]

print(l)

执行结果：

[1, 2, 3, 4, 5, 6]

7、选择排序

算法：

1. 从数组的未排序部分选择最小（或最大）的元素。
2. 将它与未排序部分的第一个元素交换位置。
3. 这样，未排序部分的第一个元素就是已排序部分的最后一个元素。
4. 移动数组的未排序部分的边界，即未排序部分减少一个元素，已排序部分增加一个元素。
5. 重复步骤1到4，直到未排序部分的元素个数为0。

8、二维列表  

定义：列表里面还能存放多个列表，由比如列表 [[1,2,3],[4,5,6],[7,8,9]] ，它是由两个维度的列表组成，1个维度是它本身，另一个维度是[1,2,3],[4,5,6],[7,8,9] 这三个列表，所以构成了二位列表。

语法：

变量[外层列表下标][内层列表的下标]

例如：

输出二位列表中的第一个列表里面的下标为1的元素:

l = [[1,2,3],[4,5,6],[7,8,9]]
print(l[0][1]) #2

执行结果为:

2

在这里我们可以看得出来，二位列表里面的外层列表也有下标，下标也是从0开始。

二维列表遍历：

l = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for i in l:
    for j in i:
        print(j)

执行结果：

1
2
3
4
5
6
7
8
9