Explication détaillée des listes et tuples Python (explication détaillée avec exemples)

Cet article vous apporte des connaissances pertinentes sur python, qui présente principalement les problèmes liés aux listes et aux tuples. Vous pouvez utiliser des listes et des tuples flexibles pour le stockage de données. Commençons par comprendre brièvement l'utilisation de base des listes et des tuples. être utile à tout le monde.

Apprentissage recommandé : Tutoriel d'apprentissage Python

Avant-propos

Dans notre développement actuel, nous avons souvent besoin de stocker un ensemble de données pour une utilisation facile. Si vous avez étudié d'autres langages, vous connaissez peut-être la structure des données d'un tableau (Array), qui peut stocker plusieurs données, et l'accès aux données peut être obtenu via les indices du tableau. Si vous êtes un développeur Python, vous pouvez utiliser des listes et des tuples plus flexibles pour le stockage des données. Commençons par comprendre brièvement l'utilisation de base des listes et des tuples.

Liste

Les listes sont dynamiques, la longueur peut être modifiée et les éléments peuvent être ajoutés, modifiés ou supprimés à volonté.

Initialiser la liste

a = list()
b = []
# 可以通过range快速创建list
c = list(range(1,6))
print("a:", a)
print("b:", b)
print("c:", c)

# a: []
# b: []
# c: [1, 2, 3, 4, 5]

Ajouter des éléments

append : ajouter un élément à la fin de la liste

>>l = []
>>l.append("python")
>>l
['python']

extend : étendre la liste avec tous les éléments de l'objet itérable

>>l = ["python"]
>>t = ["java"]
>>l.extend(t)
>>l
['python', 'java']

insert : insérer un élément à l'endroit donné élément de position. Le premier paramètre est l'index de l'élément à insérer, donc list_name.insert(0, x) insère la tête de la liste.insert(0, x) 插入列表头部

>>l = ["python", "java"]
>>l.insert(1,"go")
>>l
['python', 'go', 'java']

删除元素

remove(x)：从列表中删除值为x的第一项。 如果没有需要删除的值，那就抛出异常

>>l = ["python", "java"]
>>l.remove("java")
>>l
['python']
>>l.remove("test")
Traceback (most recent call last):
  File "<input>", line 1, in <module>
ValueError: list.remove(x): x not in list

pop: 删除列表中给定位置的元素并返回它。如果没有给定位置，pop() 将会删除并返回列表中的最后一个元素

>>l = ["python", "java", "go"]
>>l.pop()
'go'
>>l
['python', 'java']
>>l.pop(1)
'java'
>>l.pop(1)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
IndexError: pop index out of range

del: Python 中的关键字，专门用来执行删除操作，它不仅可以删除整个列表，还可以删除列表中的某些元素

>>l = ["python", "java", "go", "js"]
>>del l[0:1]
>>l
['java', 'go', 'js']
>>del l[0]
>>l
['go', 'js']

clear(): 移除列表中的所有元素。等价于 del a[:]

>>l = ["python", "java", "go", "js"]
>>l.clear()
>>l
[]

ps： 这里注意和del 的区别， clear是清空， del list_name 是删除，内存也释放

修改元素

修改单个可以通过下标的方法

>>l = ["python", "go", "java"]
>>l[0] = "PYTHON"
>>l
['PYTHON', 'go', 'java']

修改一组数据可以通过切片的方式

>>l = ["python", "go", "java"]
>>l[0:2] = "PYTHON", "GO"
>>l
['PYTHON', 'GO', 'java']
>>l[0:2] = ["python", "go"]
>>l
['python', 'go', 'java']

查询元素

index(x) ：方法用来查找某个元素在列表中出现的位置（也就是索引），如果该元素不存在，则会导致 ValueError 错误

>>l
['python', 'go', 'java']
>>l.index("python")
0
>>l.index("python1")
Traceback (most recent call last):
  File "<input>", line 1, in <module>
ValueError: 'python1' is not in list

count() :用来统计某个元素在列表中出现的次数

>>l
['python', 'go', 'java']
>>l.count("PYTHON")
0
>>l.count("python")
1

其他操作

sort：对列表中的元素进行排序

>>l
['go', 'java', 'python']
>>l.sort(reverse=True)
>>l
['python', 'java', 'go']
>>l.sort()
>>l
['go', 'java', 'python']

reverse: 反转元素

>>l = [1,2,3,4,5]
>>l.reverse()
>>l
[5, 4, 3, 2, 1]

copy: 返回列表的一个浅拷贝，等价于 a[:]

>>l
[5, 4, 3, 2, 1]
>>a = l.copy()
>>a
[5, 4, 3, 2, 1]

python列表使用场景

1-使用列表实现栈

栈（stack)特点就是后进先出， 使用列表实现是非常容易的，要添加一个元素到堆栈的顶端，使用 append() 。要从堆栈顶部取出一个元素，使用 pop()

stack = []
stack.append(1)
stack.append(2)
stack.append(3)
stack.append(4)
stack.pop()
# 4
stack.pop()
# 3
stack.pop()
# 2
stack.pop()
# 1
# 注意捕捉错误

supprime l'élément

remove(x) : supprime de la liste le premier élément dont la valeur est x. S'il n'y a aucune valeur à supprimer, lancez une exception

from collections import deque
queue = deque(["python", "go", "java"])
queue.append("python")
queue.append("go")
print(queue)
queue.popleft()

queue.popleft()
print(queue)

pop : supprime l'élément à la position donnée dans la liste et le renvoie. Si aucune position n'est donnée, pop() supprimera et renverra le dernier élément de la liste

deque(['python', 'go', 'java', 'python', 'go'])
deque(['java', 'python', 'go'])

del : un mot-clé en Python spécifiquement utilisé pour effectuer des opérations de suppression. Il ne peut pas seulement supprimer la liste entière. , vous pouvez également supprimer certains éléments de la liste

a = [x ** 2 for x in range(10)]
b = [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]

# 嵌套列表推导式
matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
]
c = [[row[i] for row in matrix] for i in range(4)]
print("a:", a)
print("b:", b)
print("c:", c)

clear() : Supprime tous les éléments de la liste. Equivalent à del a[:]

a: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
b: [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
c: [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

ps : Notez ici la différence avec del, clear c'est effacer, del list_name c'est supprimer, la mémoire est également libérée

Modifier des éléments

Modifier une seule méthode qui peut être subscripted

a = 1, 2, 3
print("a", a)
b = (1, 2, 3)
print("b", b)
# 将字符串转换成元组
tup1 = tuple("hello")
print("将字符串转换成元组", tup1)

# 将列表转换成元组
list1 = ['Python', 'Java', 'C++', 'JavaScript']
tup2 = tuple(list1)
print("将列表转换成元组", tup2)

# 将字典转换成元组
dict1 = {'a': 100, 'b': 42, 'c': 9}
tup3 = tuple(dict1)
print("将字典转换成元组", tup3)

# 将区间转换成元组
range1 = range(1, 6)
tup4 = tuple(range1)
print("将区间转换成元组", tup4)

Vous pouvez modifier un ensemble de données en découpant

a (1, 2, 3)
b (1, 2, 3)
将字符串转换成元组 ('h', 'e', 'l', 'l', 'o')
将列表转换成元组 ('Python', 'Java', 'C++', 'JavaScript')
将字典转换成元组 ('a', 'b', 'c')
将区间转换成元组 (1, 2, 3, 4, 5)

Requête d'éléments

index(x) : Cette méthode est utilisée pour trouver la position (c'est-à-dire l'index) où un élément apparaît dans la liste. Si l'élément n'existe pas, cela provoquera ValueError

a = (1, 2, 3, 4, 5)
# 通过下标
print(a[0])
# 通过切片：a[start : end : step]
print(a[0:4:2])

count() : Utilisé pour compter le nombre de fois qu'un élément apparaît dans la liste

1
(1, 3)

Autres opérations

tri : Trier les éléments dans la liste

a = (1, 2, 3, 4, 5)
del a

reverse : inverser l'élément

l = (1,2,3,4)
id(l)
# 4497372488
l = l + (5,6)
id(l)
# 4494985832

copy : renvoie une copie superficielle de la liste, équivalente à a[:]

l = [1,2,3,4]
id(l)
# 4499169160
l = l + [5,6]
id(l)
# 4495787016

Scénarios d'utilisation de la liste Python

1-Utiliser des listes pour implémenter des piles🎜🎜 La caractéristique de stack (stack) est last in first out , l'utilisation d'une liste est très simple à implémenter. Pour ajouter un élément en haut de la pile, utilisez append() . Pour faire apparaître un élément du haut de la pile, utilisez pop() sans spécifier d'index. 🎜

list_t = []
print("列表初始化时候大小:", list_t.__sizeof__())
tuple_t = ()
print("元组初始化时候大小:", tuple_t.__sizeof__())

🎜2-File d'attente d'implémentation🎜

列表初始化时候大小: 40
元组初始化时候大小: 24

🎜Retour des résultats🎜

tuple_t = (1, 2)
print("元组hash值:", hash(tuple_t))
list_t = [1, 2]
print("列表hash值:", hash(list_t))

🎜Compréhension de la liste🎜

Traceback (most recent call last):
  File "/Users/linjian/MonitorCenter/MonitorCenter/apps/t6.py", line 4, in <module>
    print("列表hash值:", hash(list_t))
TypeError: unhashable type: 'list'
元组hash值: 3713081631934410656

🎜Return🎜

#   初始化一个相同元素的列表和元组使用情况
(djangoDemo) MonitorCenter % python -m timeit 'x=(1,2,3,4,5,6)'

100000000 loops, best of 3: 0.0103 usec per loop
(djangoDemo)  MonitorCenter % python -m timeit 'x=[1,2,3,4,5,6]'
10000000 loops, best of 3: 0.0514 usec per loop


#  元组和列表索引操作对比
(djangoDemo) MonitorCenter % python -m timeit 'x=(1,2,3,4,5,6)' 'y=x[3]'
10000000 loops, best of 3: 0.0267 usec per loop
(djangoDemo) MonitorCenter % python -m timeit 'x=(1,2,3,4,5,6)' 'y=x[3]'
10000000 loops, best of 3: 0.0265 usec per loop

🎜Tuple🎜🎜Tuple est statique, de taille fixe, les éléments ne peuvent pas être ajoutés, modifiés ou supprimés🎜 🎜🎜Créer un tuple 🎜🎜

(djangoDemo) MonitorCenter % python -m timeit 'x=list()'                
10000000 loops, best of 3: 0.087 usec per loop
(djangoDemo) MonitorCenter % python -m timeit 'x=[]'    
100000000 loops, best of 3: 0.0177 usec per loop

🎜Résultat de retour🎜

(djangoDemo) MonitorCenter % python -m timeit 'x = [1,2,3]' 'x*=3'
10000000 loops, best of 3: 0.0903 usec per loop
(djangoDemo) MonitorCenter % python -m timeit 'x = [1,2,3]' 'x = x * 3'
10000000 loops, best of 3: 0.104 usec per loop

🎜🎜Élément d'accès🎜🎜

list_1 = [1, 2, 3, 4]
list_2 = [1, 2, 3, 4]
list_3 = [1, 2, 3, 4]
list_4 = [1, 2, 3, 4]

for idx, item in enumerate(list_1):
    del item

for idx, item in enumerate(list_2):
    list_2.remove(item)

for idx, item in enumerate(list_3[:]):
    list_3.remove(item)

for idx, item in enumerate(list_4):
    list_4.pop(idx)

print("list_1", list_1)
print("list_2", list_2)
print("list_3", list_3)
print("list_4", list_4)

🎜Résultat de retour🎜

list_1 [1, 2, 3, 4]
list_2 [2, 4]
list_3 []
list_4 [2, 4]

🎜Supprimer🎜

give next element: 0
0 ---> 1
1      2
2      3
3      4
give next element: 1
0      2
1 ---> 3
2      4
give next element: 2
0      2
1      4

🎜Différence entre le tuple et la liste🎜🎜Le tuple est statique, la liste est dynamique🎜🎜Modification du tuple 🎜rrreee🎜Modification de la liste 🎜rrreee🎜Tu peux Découvrez à partir de ce qui précède que les tuples ne peuvent pas être modifiés. Ici, j'insiste sur le fait que de nombreux novices ont du mal à comprendre cela l = l + (5,6). Cela ne signifie-t-il pas que les tuples ne peuvent pas être modifiés, alors pourquoi peuvent-ils être modifiés ? ici? N'oubliez pas que même s'il peut être exécuté ici, il crée un nouveau tuple. À ce stade, l n'est pas le l d'origine. Vous pouvez l'interroger par identifiant (ou si vous exécutez l[0] = -1, une erreur sera signalée. ) 🎜🎜Ici, laissez-moi dire quelques mots de plus. Les listes statiques et dynamiques ici, en termes vernaculaires, sont des listes qui peuvent effectuer des opérations de liste (ajouter, supprimer, modifier). Dans des conditions de fonctionnement normales, son adresse mémoire reste inchangée (visualisée par). id). Cela a quelque chose à voir avec son implémentation, mais le tuple va changer, donc le nouveau tuple est différent de celui d'origine. Habituellement, quelqu'un (l'intervieweur ou le développeur ne fait pas attention) vous demandera un = ([1). ,2], 3, 4), Pourquoi a[0].append(3) peut-il être exécuté, mais id(a) reste inchangé ? C'est parce que l'élément avec 0 indice est une liste et que la liste peut être modifiée ? 🎜🎜Les listes nécessitent plus de mémoire, les tuples nécessitent moins de mémoire🎜rrreee🎜Renvoyer les résultats🎜

列表初始化时候大小: 40
元组初始化时候大小: 24

 看到结果有没有发现列表比元组大18字节，那么问题来了：这18字节是怎么来的？这是由于列表是动态的，它需要存储指针来指向对应的元素（占用 8 个字节）。另外，由于列表中元素可变，所以需要额外存储已经分配的长度大小（占用 8 个字节），这样才能实时追踪列表空间的使用情况。但是对于元组，情况就不同了，元组长度大小固定，且存储元素不可变，所以存储空间也是固定的。

列表不可被hash，元组可以被hash

tuple_t = (1, 2)
print("元组hash值:", hash(tuple_t))
list_t = [1, 2]
print("列表hash值:", hash(list_t))

执行结果

Traceback (most recent call last):
  File "/Users/linjian/MonitorCenter/MonitorCenter/apps/t6.py", line 4, in <module>
    print("列表hash值:", hash(list_t))
TypeError: unhashable type: 'list'
元组hash值: 3713081631934410656

从上面的结果可以发现元组是可以被hash，但列表却是不可以。如果基础扎实的应该会反应过来，python中hash需要满足是不可变类型的数据结构(字符串str、元组tuple、对象集objects)

执行效率

#   初始化一个相同元素的列表和元组使用情况
(djangoDemo) MonitorCenter % python -m timeit 'x=(1,2,3,4,5,6)'

100000000 loops, best of 3: 0.0103 usec per loop
(djangoDemo)  MonitorCenter % python -m timeit 'x=[1,2,3,4,5,6]'
10000000 loops, best of 3: 0.0514 usec per loop


#  元组和列表索引操作对比
(djangoDemo) MonitorCenter % python -m timeit 'x=(1,2,3,4,5,6)' 'y=x[3]'
10000000 loops, best of 3: 0.0267 usec per loop
(djangoDemo) MonitorCenter % python -m timeit 'x=(1,2,3,4,5,6)' 'y=x[3]'
10000000 loops, best of 3: 0.0265 usec per loop

 上面的运行结果显示： 元组初始化远快于列表  ，大概有五倍的差距，但是索引操作的时候速度没有多大差距

截止目前为止，我们可以简单总结列表和元组的区别有如下：

1. 元组使用tuple()或()初始化，列表使用list()或[]初始化
2. 元组是静态，而列表是动态
3. 列表需要更多内存，元组需要更少内存
4. 列表不可被hash，元组可以被hash
5. 元组初始化效率高于列表，但索引操作没有多大差距

元组和列表使用场景

再说使用场景前先讲一下，在python后台，对静态数据做一些资源缓存，通常因为垃圾回收机制的存在，一些变量不使用，python就会回收他们所占的内存，但是对于一些静态变量（比如说元组），当他们占用不大时候（长度1~20的元组），python会暂时缓存这部分内存，这样下次就可以不再向操作系统发出请求，分配内存资源，而是直接使用用缓存中之前的内存空间，这样大大加快了程序的运行速度。所以一般有时候数据量不大，我经常使用元组替代列表。到目前为止我们可以简单的总结出场景可以如下所示：

1. 如果数据不可变，我们就可以考虑使用元组，比如说性别类型，返回出去的城市信息等等
2. 如果数据可变，我们就考虑使用列表，比如说用户当天访问的网页等等

拓展知识

创建空的列表，是使用list()效率好还是[]？

(djangoDemo) MonitorCenter % python -m timeit 'x=list()'                
10000000 loops, best of 3: 0.087 usec per loop
(djangoDemo) MonitorCenter % python -m timeit 'x=[]'    
100000000 loops, best of 3: 0.0177 usec per loop

通过上面的测试可以知道是[]快。list()函数调用，python中函数调用会创建stack并且会进行参数检查，[]是一个内置C函数，可以直接调用，因此效率更高。

执行相乘操作时候，是 *= 效率好， 还是*？ 

(djangoDemo) MonitorCenter % python -m timeit 'x = [1,2,3]' 'x*=3'
10000000 loops, best of 3: 0.0903 usec per loop
(djangoDemo) MonitorCenter % python -m timeit 'x = [1,2,3]' 'x = x * 3'
10000000 loops, best of 3: 0.104 usec per loop

从结果可以看出是*效率会低点。*= 中会预分配，不足的时候扩容，但是* 会按照每次的量进行分配大小

为什么输出是这样的？

list_1 = [1, 2, 3, 4]
list_2 = [1, 2, 3, 4]
list_3 = [1, 2, 3, 4]
list_4 = [1, 2, 3, 4]

for idx, item in enumerate(list_1):
    del item

for idx, item in enumerate(list_2):
    list_2.remove(item)

for idx, item in enumerate(list_3[:]):
    list_3.remove(item)

for idx, item in enumerate(list_4):
    list_4.pop(idx)

print("list_1", list_1)
print("list_2", list_2)
print("list_3", list_3)
print("list_4", list_4)

结果

list_1 [1, 2, 3, 4]
list_2 [2, 4]
list_3 []
list_4 [2, 4]

 list_2为什么输出是[2,4]? 因为在第一次删除后，list_2变成了 [2,3,4], 然后在删除轮循到到第二个数据也就是3（大部分都以为是2，但是2从原来的下表2变为1），可以参看下面的

give next element: 0
0 ---> 1
1      2
2      3
3      4
give next element: 1
0      2
1 ---> 3
2      4
give next element: 2
0      2
1      4

list_3 为什么是[], 还记得之前我们说copy时候，copy等于[:]（浅拷贝），所以轮询的和删除的不是同一内存的数据。

list_4可以结合list_2思考，因为第一次删除，第二次删除是下标2，但是数据变了，下标2的数据不是原来的2，而是3

推荐学习：python教程

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!