Vergleichszusammenfassung von Datencontainern für das grundlegende Erlernen von Python

Klassifizierung von Datencontainern

Datencontainer können einfach aus folgenden Perspektiven klassifiziert werden:

① Ob Indexindex unterstützt wird:
Unterstützt: Liste, Tupel, String – Sequenztyp
Nicht unterstützt: Set, Wörterbuch – Nicht-Sequenztyp
② Ob wiederholte Elemente unterstützt werden:
Unterstützt: Liste, Tupel, String – Sequenztyp
nicht unterstützt: Set, Wörterbuch - Nicht-Sequenztyp
③ Kann geändert werden:
Unterstützt: Liste, Menge, Wörterbuch
Nicht unterstützt: Tupel, Zeichenfolge

Vergleich der Datencontainerfunktionen

	Liste	Tupel	Zeichenfolge	versammeln	Wörterbuch
Anzahl der Elemente	Unterstützen Sie mehrere	Unterstützen Sie mehrere	Unterstützen Sie mehrere	Unterstützen Sie mehrere	Unterstützen Sie mehrere
Elementtyp	willkürlich	willkürlich	Nur Zeichen	willkürlich	Schlüssel: Wert Schlüssel: jeder Typ außer Wörterbuch Wert: jeder Typ
tiefgestellter Index	Unterstützung	Unterstützung	Unterstützung	nicht unterstützt	nicht unterstützt
Sich wiederholende Elemente	Unterstützung	Unterstützung	Unterstützung	nicht unterstützt	nicht unterstützt
Modifizierbarkeit	Unterstützung	nicht unterstützt	nicht unterstützt	Unterstützung	Unterstützung
Daten in Ordnung	Ja	Ja	Ja	NEIN	NEIN
Szenen, die verwendet werden sollen	Modifizierbare und wiederholbare Batch-Datenaufzeichnungsszenarien	Unveränderbare und wiederholbare Batch-Datenaufzeichnungsszenarien	Aufnahmeszene einer Zeichenfolge	Nicht wiederholbare Datenaufzeichnungsszenarien	Datenaufzeichnungsszenario zum Abrufen von Werten nach Schlüssel

Anwendungsszenarien

Basierend auf den Eigenschaften verschiedener Arten von Datencontainern lauten ihre Anwendungsszenarien wie folgt:

Liste: Ein Datenstapel, ein Speicherszenario, das geändert werden kann und wiederholbar ist.
Tupel: Ein Datenstapel, ein Speicherszenario, das nicht geändert werden kann und wiederholbar ist.
String: Ein Speicherszenario für eine Zeichenfolgenfolge. Set: Ein Stapel von Daten, ein Wörterbuch
deduplizierter Speicherszenarien.

Allgemeine Operationen für Datencontainer

Gemeinsame Operationen von Datencontainern – Traversierung

Obwohl jeder Datencontainer seine eigenen Merkmale aufweist, weisen sie auch einige gemeinsame Vorgänge auf.

Erstens in Bezug auf die Durchquerung:
①5 Arten von DatencontainernBeide unterstützen SchleifenTraverse
②Listen, Tupel und Strings unterstützen While-Schleifen, Sammlungen und Wörterbücher werden nicht unterstützt (Index kann nicht tiefgestellt werden)

Obwohl es verschiedene Formen der Durchquerung gibt, unterstützen sie alle Durchquerungsoperationen.

Beispiel:

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
new_list = []
i = 0
while i < len(my_list):
    if my_list[i] % 2 == 0:
        new_list.append(my_list[i])
    i += 1

print(f"偶数形成的新列表：{
      
      new_list}")

Operationsergebnis:

Neue Liste aus geraden Zahlen: [2, 4, 6, 8, 10]

Allgemeine statistische Funktionen von Datencontainern

Zusätzlich zur Gemeinsamkeit der Traversierung können Datencontainer viele funktionale Methoden gemeinsam nutzen.

① len (container) : zählt die Anzahl der
Elemente im Container ② max (container) : zählt das größte Element des Containers
③ min (container) : zählt das kleinste Element des Containers

Beispiel:

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
my_set = {
    
    1, 2, 3, 4, 5}
my_dict = {
    
    "key1": 1, "key2": 2, "key3": 3}

# len元素个数
print(f"列表 元素个数有：{
      
      len(my_list)}")
print(f"元组 元素个数有：{
      
      len(my_tuple)}")
print(f"字符串 元素个数有：{
      
      len(my_str)}")
print(f"集合 元素个数有：{
      
      len(my_set)}")
print(f"字典 元素个数有：{
      
      len(my_dict)}")

# max最大元素
print(f"列表 最大的元素是：{
      
      max(my_list)}")
print(f"元组 最大的元素是：{
      
      max(my_tuple)}")
print(f"字符串最大的元素是：{
      
      max(my_str)}")
print(f"集合 最大的元素是：{
      
      max(my_set)}")
print(f"字典 最大的元素是：{
      
      max(my_dict)}")

# min最小元素
print(f"列表 最小元素是：{
      
      min(my_list)}")
print(f"元组 最小元素是：{
      
      min(my_tuple)}")
print(f"字符串最小元素是：{
      
      min(my_str)}")
print(f"集合 最小元素是：{
      
      min(my_set)}")
print(f"字典 最小元素是：{
      
      min(my_dict)}")

Operationsergebnis:

Die Anzahl der Elemente in der Liste beträgt: 5
Die Anzahl der Elemente im Tupel beträgt: 5
Die Anzahl der Elemente in der Zeichenfolge beträgt: 7 Die
Anzahl der Elemente in der Sammlung beträgt: 5
Die Anzahl der Elemente im Wörterbuch beträgt: 3
Das größte Element der Liste ist: 5
Das größte Element des Tupels ist:5
Das größte Element der Zeichenfolge ist: g
Das größte Element der Menge ist: 5
Das größte Element des Wörterbuchs ist: key3
Das kleinste Element von Liste ist: 1 Das kleinste Element
des Tupels ist: 1
Das kleinste Element der Zeichenfolge ist: a
Das kleinste Element der Menge ist: 1
Das kleinste Element des Wörterbuchs ist: key1

Tipps : Tastenkombinationen: Umschalt+Alt+Maus ziehen: Sie können mehrere Zeilen mit denselben Positionsoptionen gleichzeitig zum Ersetzen und für andere Vorgänge auswählen.

Universelle Konvertierungsfunktionen für Container

Neben der Gemeinsamkeit der Indexindizierung ist auch eine universelle Typkonvertierung möglich.

① Liste (Container): Konvertieren Sie
in eine Liste . ② Str (Container): Konvertieren Sie
in einen String . ③ Tupel (Container): Konvertieren Sie den angegebenen Container in ein Tupel.
④ Set (Container): Konvertieren Sie den angegebenen Container für Sammlung

Beispiel:

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
my_set = {
    
    1, 2, 3, 4, 5}
my_dict = {
    
    "key1": 1, "key2": 2, "key3": 3}
# 类型转换：容器转列表
print(f"列表转列表的结果是：{
      
      list(my_list)}")
print(f"元组转列表的结果是：{
      
      list(my_tuple)}")
print(f"字符串转列表结果是：{
      
      list(my_str)}")
print(f"集合转列表的结果是：{
      
      list(my_set)}")
print(f"字典转列表的结果是：{
      
      list(my_dict)}")
# 类型转换：容器转元组
print(f"列表转元组的结果是：{
      
      tuple(my_list)}")
print(f"元组转元组的结果是：{
      
      tuple(my_tuple)}")
print(f"字符串元组表结果是：{
      
      tuple(my_str)}")
print(f"集合转元组的结果是：{
      
      tuple(my_set)}")
print(f"字典转元组的结果是：{
      
      tuple(my_dict)}")
# 类型转换：容器转字符串
print(f"列表转字符串的结果是：{
      
      str(my_list)}")
print(f"元组转字符串的结果是：{
      
      str(my_tuple)}")
print(f"字符串字符串表结果是：{
      
      str(my_str)}")
print(f"集合转字符串的结果是：{
      
      str(my_set)}")
print(f"字典转字符串的结果是：{
      
      str(my_dict)}")
# 类型转换：容器转集合
print(f"列表转集合的结果是：{
      
      set(my_list)}")
print(f"元组转集合的结果是：{
      
      set(my_tuple)}")
print(f"字符串集合表结果是：{
      
      set(my_str)}")
print(f"集合转集合的结果是：{
      
      set(my_set)}")
print(f"字典转集合的结果是：{
      
      set(my_dict)}")

Operationsergebnis:

Das Ergebnis der Konvertierung einer Liste in eine Liste ist: [1, 2, 3, 4, 5]
Das Ergebnis der Konvertierung eines Tupels in eine Liste ist: [1, 2, 3, 4, 5]
Das Ergebnis der Konvertierung einer Zeichenfolge zu einer Liste ist: ['a', ' b', 'c', 'd', 'e', ​​​​'f', 'g'] Das Ergebnis der Konvertierung der Menge in eine Liste ist: [1
, 2, 3, 4, 5]
Das Ergebnis der Konvertierung des Wörterbuchs in eine Liste ist: [' key1', 'key2', 'key3']
Das Ergebnis der Konvertierung der Liste in ein Tupel ist: (1, 2, 3, 4, 5)
Das Ergebnis der Konvertierung von Tupel in Tupel ist: (1, 2, 3, 4, 5)
Das Ergebnis der String-Tupeltabelle ist: ('a', 'b', 'c', 'd', 'e' , ​​'f', 'g') Das Ergebnis des Setzens auf Tupel ist: (1, 2
, 3, 4, 5)
Das Ergebnis der Konvertierung des Wörterbuchs in Tupel ist: ('key1', 'key2', 'key3 ')
Das Ergebnis der Konvertierung einer Liste in einen String ist: [1, 2, 3, 4, 5]
Tupel zu Zeichen Das Ergebnis eines Strings ist: (1, 2, 3, 4, 5)
Das Ergebnis einer String-String-Tabelle ist:
Das Ergebnis der Konvertierung des abcdefg-Sets in einen String ist: {1, 2, 3, 4, 5}
Das Ergebnis der Konvertierung des Wörterbuchs in einen String ist: {'key1': 1, 'key2': 2, 'key3': 3}
Das Ergebnis der Konvertierung der Liste in die Menge ist: {1, 2, 3, 4, 5}
Das Ergebnis der Konvertierung des Tupels in die Menge ist: {1, 2, 3, 4, 5}
Das Ergebnis der Konvertierung einer Zeichenfolge zu einer Menge ist: {'d', 'f', 'b', 'e', ​​​​'g', 'c', 'a'} Das Ergebnis der Konvertierung einer Menge in eine Menge ist: {1
, 2, 3, 4, 5}
Das Ergebnis der Konvertierung des Wörterbuchs in einen Satz ist: {'key3', 'key2', 'key1'}

Universelle Sortierfunktion für Behälter

Syntax:
sorted(container, [reverse=True]): Sortiert den angegebenen Container

Beachten Sie, dass Sie nach dem Sortieren ein Listenobjekt erhalten und das Wörterbuch seinen Wert verliert .

Beispiel:

# 进行容器的排序
my_list = [3, 5, 4, 1, 2]
my_tuple = (3, 5, 4, 1, 2)
my_str = "abcdefg"
my_set = {
    
    3, 5, 4, 1, 2}
my_dict = {
    
    "key1": 1, "key3": 3, "key2": 2}
# 正向排序
print(f"列表正向排序结果是：{
      
      sorted(my_list)}")
print(f"元组正向排序结果是：{
      
      sorted(my_tuple)}")
print(f"字符串正向排序结果是：{
      
      sorted(my_str)}")
print(f"集合正向排序结果是：{
      
      sorted(my_set)}")
print(f"字典正向排序结果是：{
      
      sorted(my_dict)}")
# 反向排序
print(f"列表反向排序结果是：{
      
      sorted(my_list, reverse=True)}")
print(f"元组反向排序结果是：{
      
      sorted(my_tuple, reverse=True)}")
print(f"字符串反向排序结果是：{
      
      sorted(my_str, reverse=True)}")
print(f"集合反向排序结果是：{
      
      sorted(my_set, reverse=True)}")
print(f"字典反向排序结果是：{
      
      sorted(my_dict, reverse=True)}")

Operationsergebnis:

Das Ergebnis der Vorwärtssortierung der Liste ist: [1, 2, 3, 4, 5] Das
Ergebnis der Vorwärtssortierung des Tupels ist: [1, 2, 3, 4, 5]
Das Ergebnis der Vorwärtssortierung der Zeichenfolge ist: ['a', 'b', 'c', 'd', 'e', ​​​​'f', 'g'] Das Ergebnis der Vorwärtssortierung der Menge ist: [1
, 2, 3, 4, 5]
Das Ergebnis der Vorwärtssortierung des Wörterbuchs ist: [ 'key1', 'key2', 'key3']
Das Ergebnis der umgekehrten Sortierung der Liste ist: [5, 4, 3, 2, 1]
Das Ergebnis der umgekehrten Sortierung des Tupels ist: [5, 4, 3, 2, 1]
Zeichen Das Ergebnis der umgekehrten Sortierung der Zeichenfolge ist: ['g', 'f', 'e' , ​​'d', 'c', 'b', 'a'] Das Ergebnis der umgekehrten Sortierung der Menge ist: [5, 4, 3 , 2, 1] Das Ergebnis der umgekehrten Sortierung des
Wörterbuchs
ist : ['key3', 'key2', 'key1']

Übersicht über allgemeine Funktionen von Containern

Funktion	beschreiben
Generische for-Schleife	Durchlaufen Sie den Container (das Wörterbuch ist der Durchlaufschlüssel)
max	Das größte Element im Container
Mindest()	Das kleinste Element im Container
len()	Anzahl der Containerelemente
Liste()	In Liste konvertieren
Tupel()	In Tupel konvertieren
str()	In String konvertieren
Satz()	In Sammlung konvertieren
sortiert(Sequenz,[reverse=Ture])	Sortieren, reverse=True bedeutet absteigende Reihenfolge, um eine sortierte Liste zu erhalten

Erweiterung: String-Größenvergleich

ASCII-Codetabelle:

Im Programm haben alle Zeichen, die in Zeichenfolgen verwendet werden, wie zum Beispiel:
① Englische Wörter in Groß- und Kleinbuchstaben
② Zahlen
③ Sonderzeichen (!, \, |, @, #, Leerzeichen usw.)
ihre entsprechenden ASCII-Codetabellenwerte.

Jedes Zeichen kann dem vorherigen entsprechen: dem Codewert der Zahl
Der String-Vergleich basiert auf der Größe des Codewerts der Zahl.

String-Vergleich

1. Zeichenfolgen werden Stück für Stück verglichen , dh ein Bit wird verglichen.Solange eine Person größer ist, ist das Ganze größer, und es besteht keine Notwendigkeit, später zu vergleichen.
Beispiel: abc ist größer als ab, abd ist größer als abc.

2. Wie bestimmt man die Größe einzelner Zeichen?
Verwenden Sie die ASCII-Codetabelle, um die Codewertnummer zu ermitteln, die dem Zeichen entspricht, um die Größe zu bestimmen.

Beispiel:

# abc 比较abd
print(f"abd大于abc，结果：{
      
      'abd' > 'abc'}")
# a 比较ab
print(f"ab大于a，结果：{
      
      'ab' > 'a'}")
# a 比较A
print(f"a大于A，结果：{
      
      'a' > 'A'}")
# key1比较key2
print(f"key2大于key1，结果：{
      
      'key2' > 'key1'}")

Operationsergebnis:

abd ist größer als abc, Ergebnis: Wahr
ab ist größer als a, Ergebnis: Wahr
a ist größer als A, Ergebnis: Wahr
key2 ist größer als key1, Ergebnis: Wahr