python数据类型-2-容器类型-列表-学习列表的新方法!

python数据类型-2-容器类型-列表

一.说明

在python数据类型系列文章中已经介绍了 基础数据类型，这篇文章我们来介绍容器类型，什么是容器类型？容器类型是指可以存储多个值的数据类型。容器类型可以用来组织和管理数据，使得在处理多个元素时更加方便。

list、tuple、range：序列类型

dict：字典 映射类型

set、frozenset：集合类型

二.List（列表）

1.定义

1.列表是一种有序的、可变的集合，可以包含重复的元素。

2.列表使用方括号 [] 来定义，元素之间用逗号 , 分隔。

2.特性

1.有序性：列表中的元素按照添加的顺序进行存储，因此可以通过索引访问。

2.可变性：可以在列表中添加、删除或修改元素，而不需要创建新的列表。

3.允许重复：列表可以包含重复的元素。

3.创建列表

# 使用方括号
my_list1 = [1, 2, 3, 'a', 'b']

# 使用 list() 函数
my_list2 = list((4, 5, 6))

# 使用 range() 函数 使用range() 注意前闭后开
my_list3 = list(range(0,10))

# 列表推导式
my_list4 = [x**2 for x in range(10)]

# 字符串创建列表
my_string = "apple,banana,cherry"
my_list5 = my_string.split(',')  # ['apple', 'banana', 'cherry']
result_comma1 = ','.join(my_list5) 
result_comma2 = '|'.join(my_list5)
print(result_comma1,result_comma2) #apple,banana,cherry apple|banana|cherry

# 使用切片操作创建列表的副本
original_list = [1, 2, 3]
my_list6 = original_list[:]  
print(id(original_list))
print(id(my_list6))
print(original_list is my_list6) #False 切片创建的是一个新的内存地址
print(original_list == my_list6) #True  切片创建与原来一样
#嵌套列表
my_list7 = [[1, 2], [3, 4], [5, 6]]  # 嵌套列表

在列表创建这里隐藏了一个知识点，就是字符串转列表和列表再转会字符串，我们会使用2个函数my_string.split(‘,’)和’,'.join(my_list5)

这个知识点在开发中很常用，也非常重要 所以我特意写出来。

4.获取列表元素

my_list1 = [1, 2, 3, 'a', 'b']
print(my_list1[0])  # 1
print(my_list1[3])  # 'a'
print(my_list1[-1])  # 'b'
nested_list = [[1, 2, 3], ['a', 'b', 'c']]
print(nested_list[0][1])  # 2

5.常用的操作和方法

my_list1 = [3, 2, 3,1, 'a', 'b']

#append()：在列表末尾添加一个元素
my_list1.append('c')

#insert(index, element)：在指定位置插入一个元素
my_list1.insert(2, 'x')  # 在索引 2 处插入 'x'

#删除元素
my_list1.remove('a') #删除第一个匹配的元素
last_item = my_list1.pop()  # 移除最后一个元素并返回删除的元素
print(last_item) # c
#修改元素：
my_list1[1] = 10

#切片：注意前闭后开原则
print(my_list1) #[3, 10, 'x', 3, 1, 'b']
sub_list = my_list1[1:4] 
print(sub_list) #[10, 'x', 3]

#排序
my_list2=[2, 1, 5, 3, 8, 3, 8, 9, 0]

# my_list2.sort()#就地排序列表
#print(my_list2)#[0, 1, 2, 3, 3, 5, 8, 8, 9]

a = sorted(my_list2)#返回一个新排序的列表
print(a) #[0, 1, 2, 3, 3, 5, 8, 8, 9]
print(my_list2) #[2, 1, 5, 3, 8, 3, 8, 9, 0]

#查找元素位置
my_list3 = ['s','a','d'] 
a = my_list3.index('a')
#z = my_list3.index('z') #报错
print(a) #1


#list 长度
b = my_list3.__len__() 
print(len(my_string)) #3
print(b) #3

#统计元素个数
my_list4 = ['s','a','d','s','d']
c =  my_list4.count('a')
d =  my_list4.count('z')
print(c,d) # 1 0

#反转
e = my_list4.reverse()
print(my_list4) #['d', 's', 'd', 'a', 's']
print(e) #None 没有返回值

# 清空
f = my_list4.clear()
print(my_list4) # []
print(f) #None 没有返回值

#拼接
my_list4 = [1,2,3]
my_list5 = [4,5,6]
my_list6 = my_list4.extend(my_list5)
print("my_list4",my_list4) # my_list4 [1, 2, 3, 4, 5, 6]
print("my_list5",my_list5) # my_list5 [4, 5, 6]
print("my_list6",my_list6) # my_list6 None

my_list4 = [1,2,3,3]
my_list5 = [3,4,5,6]
my_list7 = my_list4 + my_list5
print(my_list7) #[1, 2, 3, 3, 3, 4, 5, 6]

#切片
my_list7 = [4,5,6,9]
my_list8 = my_list7[::]
my_list9 = my_list7

print(my_list7) #[4, 5, 6, 9]
print(my_list8) #[4, 5, 6, 9]
print(my_list9) #[4, 5, 6, 9]
print(my_list7 is my_list9) # True
print(my_list7 is my_list8) # False
print(my_list7 == my_list8) # True

这里面有几个细节需要注意的地方，我一一点出来！

1.排序

1.list.sort() 方法没有返回值；

2.list.sort() 方法会导致list被改变

3.sorted(my_list2) 有返回值 返回值为排序后的值

4.sorted(my_list2) 方法 不改变原my_list2的值

2.前闭后开原则

1.sub_list = my_list1[1:4] 切片中前闭后开原则 python中在处理范围、切片 基本都是这个原则

#切片
my_list1 = [3, 10, 'x', 3, 1, 'b']
sub_list = my_list1[1:4] 
print(sub_list) #[10, 'x', 3]
#范围
for i in range(0, 5):
    print(i)  # 输出: 0, 1, 2, 3, 4
    
    

那么这么设计的原因是什么？或者说为啥大多数编程语言都是这样设计的？我讲的是大多数，也有语言会专门设计 前闭后闭 的方法

方便计算：使用这种方式可以更容易地进行数学和逻辑操作。例如，处理区间的长度时，结束值不包含使得区间的大小计算更加直观。

避免重复：在进行多个区间的操作时，可以有效避免元素的重复。例如，如果你要将多个区间拼接在一起，使用前闭后开原则可以确保区间的端点不会重叠。

与整数序列的一致性：Python 中的许多操作（如 range 和切片）与数组或列表的索引操作一致，从而保持一致性和可预测性。

3.查找元素报错，那么替代方案呢？

my_list3 = ['s','a','d'] 
a = my_list3.index('a')
#z = my_list3.index('z') #报错
print(a) #1

针对这种容易报错的要特别注意，在现实开发中 这种方法基本废了，反正我是不会用 而采用替代方法

‘z’ in my_list3 当然遇到必须要这么做的 可以采用Python中断言 try-except 等N种方案

这里要提一句 技术是死的人是活的，技术不够 方法来凑！

my_list3 = ['s','a','d'] 
a = my_list3.index('a')
#z = my_list3.index('z') #报错
print(a) #1

print('a' in my_list3) #True
print('z' in my_list3) #False
print(bool(my_list3.count('z'))) #False

4.这些方法有没有返回值？

f = my_list4.clear() #没有返回值
my_list6 = my_list4.extend(my_list5) #没有返回值
e = my_list4.reverse() #没有返回值
d = my_list5.sort() #方法没有返回值

三.总结

为啥有的大佬很厉害！我觉得除了勤奋以为最重要的是学习思想，比如 当我们学习数据类型时，要对每种方法除了学习以外 还要对方法进行维度概况，这就是为啥 针对列表我写了这么多！

针对列表学习我对列表的方法总结维度如下：

1.方法有没有返回值？

2.方法有没有改变原列表？

3.方法会不会出现报错情况？

4.有没有参数，参数是什么？

这一系列我要一个个细致的写清楚，所以针对列表，我们就讲到，有讲的不足地方，欢迎大家补充，我来更新！

创作不易，喜欢的话点点关注 点点赞，再次_感谢！