Detaillierte Erklärung von Python-Listen und Tupeln (ausführliche Erklärung mit Beispielen)

Dieser Artikel vermittelt Ihnen relevantes Wissen über Python, das hauptsächlich Probleme im Zusammenhang mit Listen und Tupeln für die Datenspeicherung erläutert. Ich hoffe, dass dies der Fall ist allen hilfreich sein.

Empfohlenes Lernen: Python-Lern-Tutorial

Vorwort

In unserer tatsächlichen Entwicklung müssen wir häufig einen Datensatz zur einfachen Verwendung speichern. Wenn Sie andere Sprachen gelernt haben, kennen Sie möglicherweise die Datenstruktur eines Arrays (Array), in der mehrere Daten gespeichert werden können, und Sie können auf Daten zugreifen, die über Array-Indizes abgerufen werden können. Wenn Sie ein Python-Entwickler sind, können Sie flexiblere Listen und Tupel zur Datenspeicherung verwenden. Lassen Sie uns zunächst kurz die grundlegende Verwendung von Listen und Tupeln verstehen.

Liste

Listen sind dynamisch, die Länge kann geändert werden und Elemente können nach Belieben hinzugefügt, geändert oder gelöscht werden.

Liste initialisieren

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]

Elemente hinzufügen

append: Ein Element am Ende der Liste hinzufügen

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

extend: Liste mit allen Elementen im iterierbaren Objekt erweitern

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

insert: Ein Element an der angegebenen Stelle einfügen Positionselement. Der erste Parameter ist der Index des einzufügenden Elements, daher fügt list_name.insert(0, x) den Kopf der Liste ein.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
# 注意捕捉错误

entfernt das Element

remove(x): Entfernt aus der Liste das erste Element, dessen Wert x ist. Wenn kein Wert zum Löschen vorhanden ist, wird eine Ausnahme ausgelöst.

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

queue.popleft()
print(queue)

pop: Entfernt das Element an der angegebenen Position in der Liste und gibt es zurück. Wenn keine Position angegeben ist, löscht pop() das letzte Element in der Liste und gibt es zurück.

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

del: ein Schlüsselwort in Python, das speziell zum Ausführen von Löschvorgängen verwendet wird. Es kann nicht nur die gesamte Liste löschen , Sie können auch bestimmte Elemente in der Liste löschen

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(): Alle Elemente in der Liste entfernen. Äquivalent zu 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: Beachten Sie hier den Unterschied zu del, clear ist zu löschen, del list_name ist zu löschen, der Speicher wird ebenfalls freigegeben

Ändern Sie Elemente

Ändern Sie eine einzelne Methode, die sein kann subskribiert

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)

Sie können einen Datensatz ändern, indem Sie ihn in Scheiben schneiden

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)

Abfrageelemente

index(x): Diese Methode wird verwendet, um die Position (d. h. den Index) zu finden, an der ein Element in der Liste erscheint. Wenn das Element nicht vorhanden ist, wird ein ValueError verursacht.

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

count(): Wird verwendet, um zu zählen, wie oft ein Element in der Liste erscheint

reverse: Kehrt das Element um

1
(1, 3)

copy: Gibt eine flache Kopie der Liste zurück, äquivalent zu a[:]

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

Python-Listenverwendungsszenarien

1 – Verwenden Sie Listen, um Stapel zu implementieren

Die Eigenschaft des Stapels (Stack) ist „last in first out“. Die Verwendung einer Liste ist sehr einfach zu implementieren. Um ein Element oben im Stapel hinzuzufügen, verwenden Sie append(). Um ein Element vom oberen Rand des Stapels zu entfernen, verwenden Sie pop() ohne Angabe eines Index.

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

2-Implementierungswarteschlange

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

Ergebnisse zurückgeben

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

🎜Listenverständnis🎜

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

🎜Zurückgeben🎜

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

🎜Tupel🎜🎜Tupel ist statisch, hat eine feste Größe, Elemente können nicht hinzugefügt, geändert oder gelöscht werden🎜 Tupel erstellen🎜🎜

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

🎜Ergebnis zurückgeben🎜

#   初始化一个相同元素的列表和元组使用情况
(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

🎜🎜Zugriffselement🎜🎜

(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

🎜Ergebnis zurückgeben🎜

(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öschen🎜

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)

🎜Unterschied zwischen Tupel und Liste🎜🎜Tupel ist statisch, Liste ist dynamisch🎜🎜Tupeländerung 🎜

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

🎜Listenänderung🎜

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

🎜Das ist möglich Finden Sie heraus, dass Tupel nicht geändert werden können. Hier möchte ich betonen, dass es für viele Anfänger schwierig ist, dies zu verstehen. l = l + (5,6) Warum kann es dann nicht geändert werden? Hier? Denken Sie daran, dass, obwohl es hier ausgeführt werden kann, ein neues Tupel erstellt wird. Zu diesem Zeitpunkt ist l nicht das ursprüngliche l. Sie können es nach der ID abfragen (oder wenn Sie l[0] = -1 ausführen, wird ein Fehler gemeldet). ) 🎜🎜Hier möchte ich noch ein paar Worte sagen: Statisch und dynamisch sind hier Listen, die Listenoperationen ausführen können (Hinzufügen, Löschen, Ändern). Bei normalem Betriebsverhalten bleibt ihre Speicheradresse unverändert (angezeigt von). id). Das hat etwas mit seiner Implementierung zu tun, aber das Tupel wird sich ändern, sodass sich das neue Tupel vom Original unterscheidet. Normalerweise wird Sie jemand (der Interviewer oder der Entwickler ist nicht vorsichtig) fragen: = ([1 ,2], 3, 4), Warum kann a[0].append(3) ausgeführt werden, id(a) bleibt jedoch unverändert? Dies liegt daran, dass das Element mit dem Index 0 eine Liste ist und die Liste geändert werden kann. 🎜🎜Listen benötigen mehr Speicher, Tupel benötigen weniger Speicher🎜rrreee🎜Ergebnisse zurückgeben🎜

列表初始化时候大小: 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教程

Das obige ist der detaillierte Inhalt vonDetaillierte Erklärung von Python-Listen und Tupeln (ausführliche Erklärung mit Beispielen). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!