Python-list的使用

介绍

Python3的list是一个有序的集合，可以容纳任意类型的对象，包括其他列表。列表是可变的，可以通过添加、删除和修改元素来修改它们。在Python中，列表用方括号括起来，其中的元素用逗号分隔。

以下是一些常用的列表操作：

1. 创建列表：可以通过将元素用逗号分隔放在方括号中来创建列表。例如：my_list = [1, 2, 3]

2. 访问列表元素：可以通过列表的索引访问元素，索引从0开始。例如：my_list[0]将返回第一个元素。

3. 修改列表元素：可以通过索引来修改列表中的元素。例如：my_list[0] = 4将第一个元素修改为4。

4. 添加元素到列表末尾：可以使用append()方法将元素添加到列表的末尾。例如：my_list.append(4)将4添加到列表末尾。

5. 在列表中插入元素：可以使用insert()方法在指定的索引位置插入元素。例如：my_list.insert(1, 'hello')将’hello’插入到列表的第二个位置。

6. 从列表中删除元素：可以使用remove()方法删除指定的元素。例如：my_list.remove(3)将列表中的第一个3删除。

7. 切片操作：可以使用切片操作来获取列表的一部分。例如：my_list[1:3]将返回第二个和第三个元素。

8. 列表长度：可以使用len()函数获取列表的长度。例如：len(my_list)将返回列表中元素的数量。

9. 迭代列表元素：可以使用for循环迭代列表中的每个元素。例如：for item in my_list:将遍历列表中的每个元素，并将其存储在变量item中。

10. 列表拼接：可以使用+运算符将两个列表拼接在一起。例如：new_list = my_list + [4, 5, 6]将创建一个新列表，其中包含my_list的所有元素以及[4, 5, 6]中的所有元素。

特点

容器类型 --python中内置的数据结构
list --列表
列表的三个特点 1.有序的项目集合 2.可变数据类型 3.存放任何数据类型

常用方法

下面是 Python 3 中常用的列表（List）方法：

• list.append(x)：在列表的末尾添加一个元素 x。
• list.extend(iterable)：在列表的末尾追加一个可迭代对象 iterable 中的所有元素。
• list.insert(i, x)：在列表的索引位置 i 处插入元素 x。
• list.remove(x)：从列表中删除第一个值为 x 的元素。如果没有找到，则抛出 ValueError 异常。
• list.pop([i])：从列表中删除并返回索引位置 i 处的元素。如果未指定索引位置，则默认为列表的最后一个元素。
• list.index(x[, start[, end]])：返回第一个值为 x 的元素的索引位置。如果未找到，则抛出 ValueError 异常。可以指定搜索范围的起始位置 start 和结束位置 end。
• list.count(x)：返回列表中值为 x 的元素的个数。
• list.sort(key=None, reverse=False)：对列表进行排序，可指定排序的键函数 key 和是否降序排列 reverse。
• list.reverse()：将列表中的元素反转。
• list.copy()：返回列表的浅复制，相当于 list[:]。

增加元素

##可以存放任何数据类型

lst = ["a",[1],print("你好")]
lst.append("aaa")                       ##往末尾增加
lst.insert(2,"***")                     ##指定位置插入值
lst.extend("1")                       ##在最后一个一个字符插入   必须要是可迭代对象

元素的修改、删除

del lst[1]                          ##只要能通过下标切片，就可以用del进行删除
lst.pop(2)                          ##不转参数就默认最后一个
lst.remove("a")                     ##指定元素删除
lst.clear()                         ##全部删除


lst=["a",1,2,3,4,5,6,7,]
print(lst)
print(lst[1:5])			#['a', 'a', 'b', 'c', 'd', 5, 6, 7]
lst[1:5]="abcd"   		##切片修改， 赋值对象需要是可迭代对象

统计类

lst=["a",1,2,3,4,5,66,7,]
print(len(lst))
print(lst.count("a")			#统计a元素出现的次数
print(lst.index(66))			#查看66元素的下标

list的复制

########copy属性
lst = ["a", 1, 2, 3, 4, 5, 6, 7, ]
lst2=[]
lst2=lst                                ##这样会让两个地址一样了
lst2[1]="******"
print(lst)
lst3=lst.copy()                         ##copy不会导致两者的地址相同了
lst3[0]="**********"
print(lst)
lst4=lst[:]                             ##也算拷贝，操作lst4，不会影响lst

列表的反转

lst = ["a","s","w"]
lst.reverse()							#列表翻转  ['w', 's', 'a']
print(lst)
lst1 = [5,3,8,7,2,1]
lst1.sort()								#列表排序  [1, 2, 3, 5, 7, 8]
print(lst1)

列表成员关系判断

lst = ["a","s","w"]
print("a"in lst)
print("a" not in lst)

列表的遍历

lst =["abc","aa","bb"]
for i in lst:
    print( i)

for k,v in enumerate(lst):                  ###返回下标和值
    print(f"{k}--{v}")

和go容器的切片区分

# 它的底层实现，数据+链表

lst =[1,2,3]
print(lst.__sizeof__())     #查看容量
for i in range(104):
    lst.append(i)

print(lst.__sizeof__())

##底层不共用，和go的切片区分
lst =[1,2,3,4,5]
lst2=lst[1:3]
lst2[0]=100
print(lst)

底层原理

Python3中的list是一种可变序列容器，它可以存储任意数量的元素，并且支持动态扩容和缩容。在Python3中，list底层的实现是基于数组和指针的方式。

具体来说，Python3中的list内部实现了一个数组对象，该数组对象用于存储元素。每个元素都是一个Python对象，它们在内存中是连续存储的。当我们向list中添加新元素时，如果数组已经满了，就会触发动态扩容的操作，这时Python会自动申请一块更大的内存空间，并将原数组中的元素复制到新的内存空间中。这样就能保证list能够随着元素数量的增加而不断扩容，从而不会因为元素数量的限制而导致程序崩溃。

同时，为了实现高效的插入和删除操作，list还维护了一个指向数组对象的指针。这个指针指向数组中的第一个元素，因此Python可以通过指针计算出任何一个元素在数组中的位置，并且可以非常快速地进行插入和删除操作。

需要注意的是，由于Python中的list可以存储任意类型的元素，因此list中的元素实际上是一个个指向对象的引用。这意味着，当我们对list中的元素进行操作时，实际上是对对象的引用进行操作。因此，如果一个对象被多个list所引用，那么对这个对象的操作会影响所有引用了该对象的list。