codestory

Die Anleitung zu Python Tuples

  1. Python Tuples
  2. List vs Tuple
  3. Der Zugang in der Elemente von Tuples
  4. Tuples aktuellisieren
  5. Die Operators für  Tuples
  6. Die Funktion für Tuples
  7. Die Methode

1. Python Tuples

Im Python istTuples eine Sequence der Wert, die viele Elemente enthaltet. Sie ist grundsätzlich so gleich wie List . Aber anders mit List ist Tuples ein unveränderbares Datentyp (immutable). Alle Updates im Tuple erstellen eine neue Entität auf die Speicherung (memory)
Um eine Tuple zu schreiben, legen Sie die Elemente in der Anführungszeichen ( ) und trennen durch das Komma. Die Elemente in der Liste werden die Index ab 0 gemarkiert
tupleExample.py
fruitTuple = ("apple", "apricot", "banana","coconut", "lemen")
otherTuple = (100, "one", "two", 3)
print ("Fruit Tuple:")
print (fruitTuple)
print (" --------------------------- ")
print ("Other Tuple:")
print (otherTuple)
Output:
Fruit Tuple:
('apple', 'apricot', 'banana', 'coconut', 'lemen')
 ---------------------------
Other List:
(100, 'one', 'two', 3)

2. List vs Tuple

Mehr sehen
List und Tuple sind die Sequence der Elemente. Sie haben die folgenden Unterschiede
  • Bei dem Schreiben einer Liste benutzen Sie die Anführungszeichen [ ], inzwischen benutzen Sie die Anführzungszeichen ( ) wenn Sie eine Tuple schreiben.
# Das ist eine  Tuple.
aTuple = ("apple", "apricot", "banana")

# Das ist eine Liste
aList =  ["apple", "apricot", "banana"]
  • List ist das veränderbare Datentyp (mutable), Sie können die Methode wie append() benutzen um die Elemente in die Liste einzufügen oder die Methode remove() benutzen um die Elemente aus der Liste ohne die Erstellung einer anderen Entität auf der Speicherung zu löschen
listMemoryTest.py
list1 =  [1990, 1991, 1992] 
print ("list1: ", list1)

# Die Addresse vom list1 auf die Speicherung
list1Address = hex ( id(list1) ) 
print ("Address of list1: ", list1Address ) 
print ("\n")
print ("Append element 2001 to list1")

# Ein Element in list1 einfügen (append) 
list1.append(2001) 
print ("list1 (After append): ", list1)

# Die Addresse von list1 auf die Speicherung
list1Address = hex ( id(list1) ) 
print ("Address of list1 (After append): ", list1Address )
  • Tuple ist ein unveränderbares Objekt (immutable), sie hat keine Methode append(), remove(),.. wie die Liste . Sie können denken daran, dass einige Methode oder die Operatoren zur Update von Tuple benutzt werden. Aber die Tatsache liegt darin, sie basiert auf die originale Tuple zur Erstellung einer neuen Tuple
tupleMemoryTest.py
tuple1 =  (1990, 1991, 1992)

# Die Addresse von tuple1 auf die Speicherung.
tuple1Address = hex ( id(tuple1) ) 
print ("Address of tuple1: ", tuple1Address )

# Eine Tuple in tuple1 binden.
tuple1 = tuple1 + (2001, 2002)

# Die Addresse von tuple1 auf die Speicherun
tuple1Address = hex ( id(tuple1) )  
print ("Address of tuple1 (After concat): ", tuple1Address )
Output:
Address of tuple1: 0x9096751d80
Address of tuple1 (After concat): 0x9096778f10

3. Der Zugang in der Elemente von Tuples

Die Elemente zugreifen
Benutzen Sie die Schleife for um die Elemete von Tuple zuzugreifen
elementAccessExample.py
fruits = ("apple", "apricot", "banana", "coconut", "lemen", "plum", "pear")

for fruit in fruits :
    print ("Fruit: ", fruit)
Output:
Fruit: apple
Fruit: apricot
Fruit: banana
Fruit: coconut
Fruit: lemen
Fruit: plum
Fruit: pear
Der Zugang durch die Index
Sie können in die Elementen von Tuple durch Index auch zugreifen. Die Elemente von Tuple werden die Index vom links nach rechts ab 0 gemarkiert
indexAccessExample.py
fruits = ("apple", "apricot", "banana", "coconut", "lemen", "plum", "pear") 
print ( fruits )

# Die Anzahl der Elemente
print ("Element count: ", len(fruits) ) 

for i in range (0, len(fruits) ) : 
    print ("Element at ", i, "= ", fruits[i] )
    
# Eine Sub-Tuple enthaltet die Elemente mit Index von 1 bis 4 (1, 2, 3)
subTuple = fruits[1: 4]    
# ('apricot', 'banana', 'coconut')
print ("Sub Tuple [1:4] ", subTuple )
Output:
('apple', 'apricot', 'banana', 'coconut', 'lemen', 'plum', 'pear')
Element count: 7
Element at 0 = apple
Element at 1 = apricot
Element at 2 = banana
Element at 3 = coconut
Element at 4 = lemen
Element at 5 = plum
Element at 6 = pear
Sub Tuple [1:4]  ('apricot', 'banana', 'coconut')
Sie können die Elemente von Tuple nach der negativen Index zugreifen. Die Elemente werden die Index vom rechts nach links mit der Wert von -1, -2, ... gemarkiert
indexAccessExample2.py
fruits = ("apple", "apricot", "banana", "coconut", "lemen", "plum", "pear")
print ( fruits )
print ("Element count: ", len(fruits) )

print ("fruits[-1]: ", fruits[-1])
print ("fruits[-2]: ", fruits[-2]) 
subTuple1 = fruits[-4: ]

print ("\n")
print ("Sub Tuple fruits[-4: ] ")
print (subTuple1) 
subTuple2  = fruits[-4:-2]
print ("\n")
print ("Sub Tuple fruits[-4:-2] ")
print (subTuple2)
Output:
('apple', 'apricot', 'banana', 'coconut', 'lemen', 'plum', 'pear')
Element count: 7
fruitList[-1]:  pear
fruitList[-2]:  plum  
 
Sub Tuple fruits[-4: ]  
('coconut', 'lemen', 'plum', 'pear')

Sub Tuple fruits[-4:-2]  
('coconut', 'lemen')

4. Tuples aktuellisieren

Achtung: Tuple ist unveränderbar (immutable), deshalb hat sie nur die Methode oder die Operatoren zum Zugang oder eine neue Tuple von den originalen Tuple erstellen
updateTupleExample.py
tuple1 = (1990, 1991, 1992) 
print ("tuple1: ", tuple1)  
print ("Concat (2001, 2002) to tuple1") 
 
tuple2 = tuple1 + (2001, 2002)  
print ("tuple2: ", tuple2)

# Eine Sub-Tuple enthaltet die Elemente mit der Index von 1 bis 4 (1,2,3)
tuple3 = tuple2[1:4] 
print ("tuple2[1:4]: ", tuple3)

# Eine Sub-Tuple enthaltet die Elemente mit der Index von 1 zur Ende
tuple4 = tuple2[1: ] 
print ("tuple2[1: ]: ", tuple4)
Output:
tuple1: (1990, 1991, 1992)
Concat (2001, 2002) to tuple1
tuple2: (1990, 1991, 1992, 2001, 2002)
tuple2[1:4]: (1991, 1992, 2001)
tuple2[1: ]: (1991, 1992, 2001, 2002)

5. Die Operators für  Tuples

Wie String hat Tuple 3 Operatoren +, * , in.
Der Operatoren
Die Bezeichnung
Zum Beispiel
+
Der Operator zur Bindung (concatenate) von 2 Tuple um eine neue Tuple zu erstellen
(1, 2, 3) + ("One","Two")
--> (1, 2, 3, "One", "Two")
*
Der Operator zur Bindung mehrer Kopien einer gleichen Tuple und erstellen eine neue Tuple một Tuple. Và tạo ra một Tuple mới
(1, 2) * 3
--> (1, 2, 1, 2, 1, 2)
in
Prüfen, ob ein Element in einer Tuple liegt oder nicht, das True oder falsch zurückgibt
"Abc" in ("One", "Abc")
--> True
tupleOperatorsExample.py
tuple1 = (1, 2, 3)
tuple2 = ("One", "Two")
print ("tuple1: ", tuple1)
print ("tuple2: ", tuple2)
print ("\n")

tuple12 = tuple1 + tuple2
print ("tuple1 + tuple2: ", tuple12)
tuple2x3 = tuple2 * 3
print ("tuple2 * 3: ", tuple2x3)
hasThree = "Three" in tuple2
print ("'Three' in tuple2? ", hasThree)
Output:
tuple1: (1, 2, 3)
tuple2: ('One', 'Two')

tuple1 + tuple2: (1, 2, 3, 'One', 'Two')
list2 * 3: ('One', 'Two', 'One', 'Two', 'One', 'Two')
'Three' in tuple2? False

6. Die Funktion für Tuples

Die Funktion
Die Bezeichnung
cmp(list1, list2)
Der Vergleich von der Elemente von 2 Tuple. Die Funktion wurde aus Python3 entfernt.
len(list)
Die Anzahl der Elemente von Liste zurückgeben
max(list)
Ein Element in Tuple mit der größten Wert zurückgeben
min(list)
Ein Element in Tuple mit der kleinsten Wert zurückgeben
tuple(seq)
Eine List zur Tuple umwandeln
tupleFunctionsExample.py
tuple1 = (1991, 1994, 1992)
tuple2 = (1991, 1994, 2000, 1992)
print ("tuple1: ", tuple1)
print ("tuple2: ", tuple2)

# Die Anzahl der Elemente in der Liste zurückgeben.
print ("len(tuple1): ", len(tuple1) )
print ("len(tuple2): ", len(tuple2) )

# Die höchste Wert in Tuple.
maxValue = max(tuple1)
print ("Max value of tuple1: ", maxValue)

# Die kleinste Wert in Tuple Tuple.
minValue = min(tuple1)
print ("Min value of tuple1: ", minValue)

# (all)
# List
list3 = [2001, 2005, 2012]
print ("list3: ", list3)

# Eine Liste zur Tuple umwandeln
tuple3 = tuple (list3)
print ("tuple3: ", tuple3)
Output:
tuple1: (1991, 1994, 1992)
tuple2: (1991, 1994, 2000, 1992)
len(tuple1): 3
len(tuple2): 4
Max value of tuple1: 1994
Min value of tuple1: 1991
list3: [2001, 2005, 2012]
tuple3: (2001, 2005, 2012)
Mehr sehen
  • Comparing and Sorting in Python

7. Die Methode

Die Methode
Die Bezeichnung
tuple.count(obj)
Das Auftretensmal von 'obj' in Tuple zurückgeben
tuple.index(obj, [start, [stop]])
Die kleinste Index in der Liste zurückgeben, die die Wert von obj hat. ValueError werden wenn nicht gefunden

Wenn es den Parameter start, stop, gibt, find nur ab die Index start zur stop (stop auschließend).
Zum Beispiel
tupleMethodsExample.py
years =  ( 1990 ,  1991 ,  1993 ,  1991 ,  1993 ,  1993 ,  1993 )
print ("Years: ", years)
print ("\n") 

# Die Anzahl der Auftreten von 1993 zurückgeben
print ("years.count(1993): ",years.count(1993) ) 

# Die Postion,wo 1993 auftritt, finden
print ("years.index(1993): ", years.index(1993) )

# Die Postion, wo 1993 auftritt finden, ab die Index 3
print ("years.index(1993, 3): ", years.index(1993, 3) )

# Die Postition wo 1993 auftritt finden, ab die Index 4 bis 5 (6 auschließend)
print ("years.index(1993, 4, 6): ", years.index(1993, 4, 6) )
Output:
Years: (1990, 1991, 1993, 1991, 1993, 1993, 1993)

years.count(1993): 4
years.index(1993): 2
years.index(1993, 3): 4
years.index(1993, 4, 6): 4
mehr sehen
  • Comparing and Sorting in Python

Neueste Artikel

Show More