Python----Python基础（列表 list，切片，多维列表，相关函数，排序，元素的增加，元素的删除，元素的修改，元素的查找，列表的拷贝）

一、序列

序列是一种数据存储方式，用来存储一系列的数据。在内存中，序列就是一块用来存放多个值的连续的内存空间。

字符串和列表都是序列类型，一个字符串是一个字符序列，一个列表是任何元素的序列。 

序列中存储的是整数对象的地址，而不是整数对象的值。 

二、列表简介

1. 列表：用于存储任意数目、任意类型的数据集合。

2. 列表是内置可变序列，是包含多个元素的有序连续的内存空间。列表的标准语法格式：

   a = [10,20,30,40]

   其中，10,20,30,40这些称为：列表a的元素。

3. 列表中的元素可以各不相同，可以是任意类型。比如：

   a = [10,20,'abc',True]

4. Python的列表大小可变，根据需要随时增加或缩小。

   列表对象的常用方法汇总如下，方便大家学习和查阅。

特点:

        有序性: 列表中的元素是按照顺序存储的,可以通过索引访问到特定元素的值.

        可变性: 列表是一个可变的对象,里面的值可以通过函数进行增删改查操作.

        动态性: 列表是一个根据存储的数据,动态拓展的数据类型. 

三、列表的基本用法

3.1列表的创建

3.1.1、[]创建

 可以通过方括号 [] 来直接创建一个列表，里面可以包含任意类型的数据。

my_list = [1, 2, 3, 'a', 'b', 'c']

3.1.2、list()创建

 list() 函数可用于将其他可迭代对象（如元组、字典等）转换为列表。

my_list_from_tuple = list((1, 2, 3))  
my_list_from_string = list('abc')  # 结果: ['a', 'b', 'c']

3.1.3、range()创建整数列表

range() 函数可用于生成一个整数序列并结合 list() 来创建一个包含这些整数的列表。

my_list_range = list(range(1, 10))  # 结果: [1, 2, 3, 4, 5, 6, 7, 8, 9]

3.1.4、推导式生成列表

列表推导式是一种简洁的方法，用于根据现有列表或可迭代对象生成新的列表。 它可以将循环和条件判断结合，从而避免冗长的代码。

squared_list = [x**2 for x in range(1, 6)]  # 结果: [1, 4, 9, 16, 25]

3.2、列表切片操作

切片slice操作可以让我们快速提取子列表或修改。标准格式为：

[起始偏移量start:终止偏移量end:步长step]

典型操作(三个量为正数的情况)如下：

其他操作（三个量为负数）的情况： 

切片操作时，起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围，也不会报错。

起始偏移量小于0则会当做0，终止偏移量大于“长度-1”会被当成”长度-1”。

3.3、多维列表

3.3.1、二维列表

• 一维列表可以帮助我们存储一维、线性的数据。

• 二维列表可以帮助我们存储二维、表格的数据。例如下表的数据：

a = [
    ["小一",18,3000,"北京"],
    ["小二",19,2000,"上海"],
    ["小三",20,1000,"深圳"],
   ]
print(a)#[['小一', 18, 3000, '北京'], ['小二', 19, 2000, '上海'], ['小三', 20, 1000, '深圳']]

3.4、与列表有关的基本函数

3.4.1、列表的长度len()

使用 len() 函数可以获取列表中元素的数量。

my_list = [1, 2, 3, 'a']  
length = len(my_list)  # 结果: 4

3.4.2、最大值  max()

要找出列表中的最大值，可以使用 max()  函数。

my_list = [1, 5, 3, 9, 2]  
max_value = max(my_list)  # 结果: 9  

3.4.3、最小值  min()

要找出列表中的最小值，可以使用  min() 函数。

my_list = [1, 5, 3, 9, 2]  
min_value = min(my_list)  # 结果: 1

3.4.4、求和sum ()

对数值型列表的所有元素进行求和操作，对非数值型列表运算则会报错。

a = [3,10,20,15,9]
print(sum(a))#57

3.4.5、reversed()返回迭代器 

内置函数reversed()也支持进行逆序排列，与列表对象reverse()方法不同的是，内置函数reversed()不对原列表做任何修改，只是返回一个逆序排列的迭代器对象。

a = [20,10,30,40]
c = reversed(a)
print(a)#[20, 10, 30, 40]
print(c)#<list_reverseiterator object at 0x00000200B48C1AB0>
print(list(c))#[40, 30, 10, 20]

3.4.6、enumerate函数 

python语法中支持 enumerate 函数,可以为遍历列表的时候添加上序列;

语法:

        for index, value in enumrate(list):

                 # 循环语句 index : 序号 value 值

        python语言中enumrate标记出来的序列是可以不从0开始的

        for index, value in enumrate(list, start=val)

                # 循环语句 index : 序号 value 值 表示的序列从val这个开始的。

# 定义一个列表:
lst1 = [True, 1, 2, 3, "hello world", 'CPP', False]

# 目标: 遍历列表lst1
for index, value in enumerate(lst1):
    print(f"{index} = {value}")  
# 0 = True
# 1 = 1
# 2 = 2
# 3 = 3
# 4 = hello world
# 5 = CPP
# 6 = False

3.5、列表的排序

可以使用 sort() 方法或 sorted() 函数对列表进行排序。

3.5.1、sort()函数

就地排序，会修改原列表

a = [3, 1, 4, 2, 5]  
a.sort()
print(a)#[1, 2, 3, 4, 5]

a = [3, 1, 4, 2, 5]  
a.sort(reverse=True)
print(a)#[5, 4, 3, 2, 1]

3.5.2、 sorted() 函数

返回一个新列表，不改变原列表

original_list = [3, 1, 4, 1, 5]  
sorted_list = sorted(original_list)  # 结果: [1, 1, 3, 4, 5]

3.6、列表元素的增加

当列表增加和删除元素时，列表会自动进行内存管理，大大减少了程序员的负担。但这个特点涉及列表元素的大量移动，效率较低。

⚠️除非必要，我们一般只在列表的尾部添加元素或删除元素，这会大大提高列表的操作效率。

3.6.1、append()方法

append() 方法原地修改列表对象，是真正的列表尾部添加新的元素，速度快，推荐使用。

a = [20,40]
a.append(80)
print(a)    #结果：[20, 40, 80]

3.6.2、+运算符操作

并不是真正的尾部添加元素，而是创建新的列表对象；将原列表的元素和新列表的元素依次复制到新的列表对象中。这样，会涉及大量的复制操作，对于操作大量元素不建议使用。

a = [20,40]
print(id(a))#2202078878784
a = a+[50]
print(id(a))#2202072910144
#两次地址不一样，创建了新的对象

3.6.3、extend()方法

将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象。

a = [20,40]
print(id(a))#2202080495808
b = [50,60]
a.extend(b)   #原对象修改
print(id(a))#2202080495808
a = a+b     #产生新对象
print(id(a))#2202079492032

3.6.4、insert()插入元素

使用insert()方法可以将指定的元素插入到列表对象的任意制定位置。这样会让插入位置后面所有的元素进行移动，会影响处理速度。涉及大量元素时，尽量避免使用。类似发生这种移动的函数还有：remove()、pop()、del()，它们在删除非尾部元素时也会发生操作位置后面元素的移动。

a = [10,20,30]
a.insert(2,100)
print(a)   #结果：[10, 20, 100, 30]

3.6.5、*乘法扩展

使用乘法扩展列表，生成一个新列表，新列表元素是原列表元素的多次重复。

a = ['s',100]
b = a*3
print(a) #结果：['s', 100]
print(b) #结果：['s', 100, 's', 100, 's', 100]

3.7、列表元素的删除

3.7.1、del()方法

del 删除元素

使用方式:

        del list[index]

        ps: del删除的时候如果没有给出下标,会删除掉整个的列表;

                删除的下标不存在,则也会直接报错.

a = [100,200,888,300,400]
del a[2]
print(a)   #结果：[100,200,300,400]

3.7.2、pop()方法

pop: 将列表中指定位置的元素删除,如果没有给出位置,则默认删除尾部元素

使用方式:

        name.pop(index)

        ps: 如果pop给出的下标不存在;则也会直接报错。

a = [10,20,30,40,50]
b1 = a.pop()   #结果：b1=50
print(a,b1)  #结果：[10, 20, 30, 40]  50
b2 = a.pop(1)
print(a,b2)  #结果：[10, 30, 40],20

3.7.3、remove()方法

remove: 将列表中的元素进行删除

使用方式:

        list.remove(element)

        ps: 如果元素不存在; 则会直接报错

a = [10,20,30,40,50,20,30,20,30]
a.remove(20)  #[10, 30, 40, 50, 20, 30, 20, 30]
a.remove(100)  #报错：ValueError:list.remove(x): x not in list

3.7.4、claer()方法

claer(): 删除列表中的所有元素，使列表为空。

使用方式:

        list.clear(element)

a = [1, 2, 3]  
a.clear()  # 结果: []

3.8、列表元素的修改

3.8.1、直接通过索引修改

my_list = [1, 2, 3, 4]  
my_list[1] = 5  # 将索引1处的元素修改为5  
# 结果: [1, 5, 3, 4]

3.8.2、切片赋值

my_list = [1, 2, 3, 4]  
my_list[1:3] = [5, 6]  # 将索引1到2的元素替换为5和6  
# 结果: [1, 5, 6, 4]

3.8.3、使用循环修改元素

my_list = [1, 2, 3, 4]  
for i in range(len(my_list)):  
    my_list[i] *= 2  # 将列表中每个元素乘以2  
# 结果: [2, 4, 6, 8]

3.9、列表元素的查找

3.9.1、index()获得指定元素在列表中首次出现的索引

index()可以获取指定元素首次出现的索引位置。语法是：index(value,[start,[end]])。其中，start和end指定了搜索的范围。

a = [10,20,30,40,50,20,30,20,30]
a.index(20)  #结果：1
a.index(20,3) #结果：5   从索引位置3开始往后搜索的第一个20
a.index(30,5,7) #结果：6  从索引位置5到7这个区间，第一次出现30元素的位置

3.9.2、count()获得查找指定元素在列表中出现的次数

count()可以返回指定元素在列表中出现的次数。

a = [10,20,30,40,50,20,30,20,30]
print(a.count(20))#3

3.9.3、成员资格判断所要查找的元素是否在列表里面

判断列表中是否存在指定的元素，我们可以使用count()方法，返回0则表示不存在，返回大于0则表示存在。但是，一般我们会使用更加简洁的in，not in关键字来判断，直接返回True或False

a = [10,20,30,40,50,20,30,20,30]
print(20 in a)#True
print(100 not in a)#True
print(30 not in a)#False

3.10、列表的拷贝 

3.10.1、浅拷贝

3.10.1.1、使用 copy() 方法

列表对象自带的 copy() 方法可以进行浅拷贝。

original_list = [1, 2, 3]  
copied_list = original_list.copy()  # 使用 copy() 方法拷贝  
# 结果: copied_list 是 [1, 2, 3]

3.10.1.2、使用 copy 模块的 copy() 函数

对于内容较复杂的对象，可以使用标准库的 copy 模块中的 copy() 函数进行浅拷贝。

import copy  

original_list = [1, 2, [3, 4]]  
copied_list = copy.copy(original_list)  # 使用 copy 模块拷贝  
# 结果: copied_list 是 [1, 2, [3, 4]]

3.10.2、深拷贝

对于包含嵌套对象的列表，如果你希望复制这些嵌套对象，而不是引用它们，可以使用 copy 模块中的 deepcopy() 函数。 

import copy  

original_list = [1, 2, [3, 4]]  
deep_copied_list = copy.deepcopy(original_list)  # 深拷贝  
# 现在对 deep_copied_list 的修改不会影响 original_list

四、思维导图