列表（List）

合集 - python(99)

1.python基础之注释2023-06-272.python语言学习路线（基础）2023-06-263.python源码结构2023-06-264.python发展史及python应用场景2023-06-265.变量2023-06-286.bug及debug2023-06-297.常见数据类型及其转换2023-06-308.字符串格式化2023-06-309.转义符2023-06-3010.字符串在货币、日期、精度的处理2023-07-0111.字符编解码2023-07-0112.字符编解码及其相互转换2023-07-0113.内置函数-help-帮助文档2023-07-0114.内置函数print-输出2023-07-0315.内置函数input2023-07-0316.运算符2023-07-0417.int的缓存策略（特别容易混）2023-07-0418.判断语句2023-07-0419.random模块2023-07-0420.判断语句+ random的应用-剪刀石头布游戏2023-07-0421.三元运算符（if else的简写）2023-07-0422.循环语句-while2023-07-0523.循环语句-while-练习题2023-07-0524.循环语句for循环2023-07-0525.循环语句 + else2023-07-0526.字符串类str2023-07-0627.正则在字符串中的简单应用2023-07-06

28.列表（List）2023-07-07

29.列表list的sort方法的坑2023-07-0730.列表综合应用-8个教室随机分配到3个教室2023-07-0831.元组2023-07-0832.自动组包 & 自动解包2023-07-0833.字典2023-07-0834.集合2023-07-0835.公共操作2023-07-0836.公共操作-推导式（集合、列表、字典）2023-07-0837.函数定义、调用、闭包2023-07-0838.拆包和交换变量值2023-07-0939.函数的变量作用域、返回值、参数2023-07-0940.函数递归2023-07-0941.匿名函数（lambda表达式）012023-07-0942.内置函数abs2023-07-0943.内置函数round2023-07-0944.内置函数abs022023-07-0945.高阶函数2023-07-0946.内置高阶函数map2023-07-0947.内置高阶函数reduce2023-07-0948.内置函数reduce2023-07-0949.学生管理系统-函数&循环&运算符综合练习2023-07-0950.文件操作之语法2023-07-1051.文件操作2-最佳实践2023-07-1152.文件操作之seek2023-07-1153.文件及文件夹操作2023-07-1154.面向对象基本概念2023-07-1255.面向对象之类、对象的定义2023-07-1256.添加和获取对象属性2023-07-1257.面向对象之魔法方法2023-07-1258.魔法函数 __repr__() 和 __str__()的区别2023-07-1259.魔法方法__len__2023-07-1260.魔法方法之__getitem__(self, key)、__setitem__(self, key, value) 和 __delitem__(self, key) 2023-07-1261.魔法方法之__iter__(self) && __next__(self)2023-07-1762.TypeError: iter() returned non-iterator of type 'MyIterable'2023-07-1763.魔法方法之__contains__()2023-07-1764.魔法方法之__call__2023-07-1765.魔法方法之__getattr__(), __setattr__(), 和 __delattr__2023-07-1866.__eq__(), __lt__(), 和 __gt__() 2023-07-1867.案例：烤地瓜2023-07-1868.案例：给房子置办家具2023-07-1969.继承2023-07-1970.继承之子类复用父类的属性、方法2023-07-1971.继承的分类2023-07-1972.MRO2023-07-1973.继承之子类重写父类同名属性和方法2023-07-1974.⼦类调⽤⽗类的同名⽅法和属性2023-07-1975.私有属性&&方法的定义&访问限制2023-07-1976.setter&getter方法访问私有属性2023-07-2077.__mro__属性2023-07-2078.python 面向对象3大特征详解2023-07-2079. 类属性和实例属性2023-07-2180.类属性和实例属性最佳实践2023-07-2181.类方法2023-07-2182.静态方法2023-07-2183.异常基础2023-07-2184.多组异常处理基础2023-07-2285.多组异常处理2023-07-2286.使用Python内置的错误信息2023-07-2287.捕获所有异常2023-07-2288.手动抛异常（raise）2023-07-2289.try-except-else-finally2023-07-2290.断言assert在异常中应用2023-07-2291.自定义异常类2023-07-2292.模块2023-07-2393.常见的5种模块导入2023-07-2394.模块的定位顺序2023-07-2395.__all__变量限制、明确导入范围2023-07-2396.包2023-07-2397.时间模块datetime2023-07-2398.多任务编程之并发、并行概念2023-07-2399.进程实现多任务（进程概念、单进程、多进程执行多任务）2023-07-23

收起

说明

在Python中，列表是一种有序、可变的数据类型，用于存储多个元素。

列表使用方括号[]来表示，其中的元素可以是任意类型，并且可以根据需要进行增删改查。

常用的操作就是创建、元素增删改查、复制、排序

其特点包括：

1. 有序性：列表中的元素按照其在列表中的位置进行存储，保持了元素的顺序（有下标，从0开始，根据下标访问，速度快）。

2. 可变性：列表是可变的，也就是说可以对列表中的元素进行修改、添加和删除操作。

3. 元素类型多样性：列表可以包含任意类型的元素，例如整数、浮点数、字符串、布尔值等。

4. 支持索引和切片：可以使用索引访问列表中的元素，还可以使用切片获取列表的子集。

5. 动态性：列表的长度可以根据需要进行动态调整，可以随时添加或删除元素。

6. 可嵌套性：列表中的元素可以是其他列表（嵌套列表），从而实现更复杂的数据结构。

7. 可迭代性：列表是可迭代的，可以通过循环遍历列表中的每个元素。

8. 重复性：列表允许存在相同的元素，即使它们位于不同的位置。

总的来说，Python列表是一种灵活、多功能的数据结构，适用于存储和处理各种类型的数据。列表的特点使得它成为Python编程中常用的数据容器之一。

 

常用语法及示例

'''
说明
在Python中，列表是一种有序、可变的数据类型，用于存储多个元素。

列表使用方括号[]来表示，其中的元素可以是任意类型，并且可以根据需要进行增删改查。

其特点包括：

    1. 有序性：列表中的元素按照其在列表中的位置进行存储，保持了元素的顺序（有下标，从0开始，根据下标访问，速度快）。

    2. 可变性：列表是可变的，也就是说可以对列表中的元素进行修改、添加和删除操作。

    3. 元素类型多样性：列表可以包含任意类型的元素，例如整数、浮点数、字符串、布尔值等。

    4. 支持索引和切片：可以使用索引访问列表中的元素，还可以使用切片获取列表的子集。

    5. 动态性：列表的长度可以根据需要进行动态调整，可以随时添加或删除元素。

    6. 可嵌套性：列表中的元素可以是其他列表（嵌套列表），从而实现更复杂的数据结构。

    7. 可迭代性：列表是可迭代的，可以通过循环遍历列表中的每个元素。

    8. 重复性：列表允许存在相同的元素，即使它们位于不同的位置。

总的来说，Python列表是一种灵活、多功能的数据结构，适用于存储和处理各种类型的数据。列表的特点使得它成为Python编程中常用的数据容器之一。
'''

# 1. 创建一个空列表
my_list = []

# 2. 创建一个有初始元素的列表: 其元素可以是任意类型哦，且可重复
my_list = [1, 2, '3', 4, 5, False]

# 3. 根据下标访问列表中的元素（记录列表是有序的，可通过索引访问的）
element_01 = my_list[0]
element_03 = my_list[2]
print(f"列表中第1个元素:{element_01},第3个元素:{element_03}")  # 输出: 列表中第1个元素:1,第3个元素:3

# 4 . 修改列表中的元素
my_list[0] = 666  # 把列表的第1个元素，设置为666

# 5. 列表的切片操作（获取部分元素）,生成一个新的列表，原列表不变。切片用法与字符串一致
new_list = my_list[1:4]
print(new_list, my_list)  # [2, '3', 4] [666, 2, '3', 4, 5, False]
print(type(new_list))  # <class 'list'>

new_list = my_list[::-1]
print(new_list)  # [False, 5, 4, '3', 2, 666]

print(my_list[:3])  # [666, 2, '3'],包括start，不包含end哦
print(my_list[2:])  # ['3', 4, 5, False]

# 6. 追加元素：在末尾追加
# 6.1 追加1个元素，这个元素也可以是列表，这样就是列表嵌套了
my_list.append(88)
print(my_list)  # [666, 2, '3', 4, 5, False, 88]

# 6.2 在末尾追加一个可迭代对象（如列表、元组、字符串等）
# another_list = [4, 5, 6]
# my_list.extend(another_list)
# print(my_list)  # Output: [666, 2, '3', 4, 5, False, 88, 4, 5, 6]
#
# my_list.extend('Allen')
# print(my_list)  # Output: [666, '3', 4, 5, False, 88, 4, 5, 6, 'A', 'l', 'l', 'e', 'n']

# 7. 在指定位置插入元素，原位置的元素往后移动，就是数据搬迁，影响性能哦
my_list.insert(2, 222)
print(my_list)  # [666, 2, 222, '3', 4, 5, False, 88]

# 8. 删除元素: 根据索引、元素删除（first）、删除整个列表、删除最后1个元素（根据下标删除）、清空列表
del my_list[1]  # 根据索引下标删除即删除数字2，第3个及其后面元素往前移位
print(my_list)  # [666, 222, '3', 4, 5, False, 88]

my_list.remove(222)  # 删除1个元素，从头开始，找到就删除，只删除第1个
print(my_list)  # [666, '3', 4, 5, False, 88]

# del my_list  # 删除列表，其实del想删谁，就在其后加一下即可

# pop()：删除指定下标的数据(默认为最后⼀个)，并返回该数据。
# deleted_element = my_list.pop()  # 88
# print(deleted_element)  # 88

# 清空列表 clear()
# my_list.clear()
# print(my_list)  # []

# 9. 获取列表的长度即元素个数
print(len(my_list))  # 6

# 10. 查找:语法 index(数据, 开始位置下标, 结束位置下标),返回元素的下标
print(my_list.index('3'))  # 1
# 可接口in关键字先判断是否在列表中，然后再获取其下标
# print(my_list.index('33'))  # 找不到，报错：ValueError: '33' is not in list

# 11. 计算元素在列表中的个数: count()
print(my_list.count('3'))  # 1

 

最佳实践

'''
列表的最佳实践:
    1. 使用列表推导式（List Comprehension）来简化列表创建过程
    2. 使用enumerate()函数在循环中同时获取索引和值
    3. 使用in关键字快速检查元素是否在列表中
    4. 使用list()函数将其他可迭代对象（如字符串、元组等）转换为列表

坑:
1. 不要修改正在进行循环的列表(尤其在多线程环境下)，可能会导致意外结果。

'''

# 1. 使用列表推导式（List Comprehension）来简化列表创建过程
my_list = [x for x in range(10)]  # 创建一个包含0到9的列表

# 2. 使用enumerate()函数在循环中同时获取索引和值
my_list = ['a', 'b', 'c']
for index, value in enumerate(my_list):
    print(index, value)

# 3. 使用in 或not in 关键字快速检查元素是否在列表中
my_list = ['apple', 'banana', 'orange']
if 'apple' in my_list:
    print("Apple is in the list.")

# 4. 使用list()函数将其他可迭代对象（如字符串、元组等）转换为列表
my_string = "Hello"
my_list = list(my_string)
print(my_list)  # Output: ['H', 'e', 'l', 'l', 'o']

# 5. 逆置：reverse() 或[::-1]
# new_list = my_list.reverse()
# print(new_list, my_list)  # None ['o', 'l', 'l', 'e', 'H'],这样会改变原列表

# 6. 排序:sort( key=None, reverse=False)  改变原列表
# reverse表示排序规则，reverse = True 降序， reverse = False 升序（默认）
sort_list =  [1, 3, 2, 4]
new_list = sort_list.sort()
print(new_list, sort_list)  # None [1, 2, 3, 4]  ,改变原列表

# my_list = ['C', 'a', 'B']
# my_list.sort(key=str.lower)
# print(my_list)  # Output: ['a', 'B', 'C']

# 7. copy方法即复制，浅拷贝
my_list = [1, 2, 3]
new_list = my_list.copy()

# 深拷贝使用copy模块
import copy

my_list2 = [[1, 2], [3, 4]]
new_list = copy.deepcopy(my_list2)



# 8. 循环
i = 0
while i < len(my_list):
    print(my_list[i])

# for-each
for element in my_list:
    print(element)

# 使用索引和range()函数来遍历列表，并在循环中访问每个元素
for i in range(len(my_list)):
    print(my_list[i])

# 如果需要同时访问列表中的索引和对应的元素，可以使用enumerate()函数
for index, item in enumerate(my_list):
    print(index, item)

# ----------------------------*** 坑 ** ------------------
# 1. 不要修改正在进行循环的列表，可能会导致意外结果
for item in my_list:
    my_list.remove(item)  # 错误：不要修改正在进行循环的列表

# 2. 注意使用切片时的边界条件，以避免越界错误。
my_list = [1, 2, 3, 4, 5]
print(my_list[5])  # 错误：索引超出范围 IndexError: list index out of range

# 3. 当比较两个列表是否相等时，要使用==运算符而不是is运算符
list1 = [1, 2, 3]
list2 = [1, 2, 3]
if list1 == list2:  # True：比较值相等
    print("Lists are equal.")

# 4. 不要滥用列表方法，如append()和extend()。在大量数据操作时，这些方法可能会导致性能下降
my_list = []
for i in range(1000000):
    my_list.append(i)  # 可能导致性能下降