codestory

Die Anleitung zu Python Lists

  1. Python List
  2. Die Elemete der Liste zugreifen
  3. Die Aktualisierung der Liste
  4. Die Elemente in der Liste löschen
  5. Die Operatoren
  6. Die betreffenden Funktionen von List
  7. Die Methode von Liste

1. Python List

Im Python ist List das meiste flexible Datenstyp. Sie ist eine Sequence von Elemente, die Sie die Elemente in die Liste zu löschen oder einzufügen und gleichzeitig die Elemente zu scheiden (slice)
Um eine Liste zu schreiben sollen Sie ein Element in der Zeichen [ ] legen und durch das Komma trennen. Die Elemente in der Liste werden vom links nach rechts ab 0 gemarkiert
listExample.py
fruitList = ["apple", "apricot", "banana","coconut", "lemen"]

otherList = [100, "one", "two", 3]


print ("Fruit List:")

print (fruitList)

print (" --------------------------- ")


print ("Other List:")
 

print (otherList)
Output:
Fruit List:
['apple', 'apricot', 'banana', 'coconut', 'lemen']
 ---------------------------
Other List:
[100, 'one', 'two', 3]

2. Die Elemete der Liste zugreifen

Die Elemente zugreifen
benutzen Sie die Schleife for um in die Elemente der Liste zuzugreifen
accessElementExample.py
fruitList = ["apple", "apricot", "banana", "coconut", "lemen", "plum", "pear"]

for fruit in fruitList :
    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 Elemente der Liste durch die Index zugreifen. Die Elemente der Liste werden vom links nach rechts ab 0 gemarkiert
indexAccessExample.py
fruitList = ["apple", "apricot", "banana", "coconut", "lemen", "plum", "pear"] 
print ( fruitList )

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

for i in range (0, len(fruitList) ) : 
    print ("Element at ", i, "= ", fruitList[i] )
    
# Eine Sub-Liste enthaltet die Elemente von Index 1 bis  4 (1, 2, 3)
subList = fruitList[1: 4]    

# ['apricot', 'banana', 'coconut']
print ("Sub List [1:4] ", subList )
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 List [1:4]  ['apricot', 'banana', 'coconut']
Sie können in die Elemente der Liste nach der negativen Index zugreifen. Die Elemente werden vom rechts nach links mit der Wert -1, -2, ... gemarkiert
indexAccessExample2.py
fruitList = ["apple", "apricot", "banana", "coconut", "lemen", "plum", "pear"]

print ( fruitList )
print ("Element count: ", len(fruitList) ) 
print ("fruitList[-1]: ", fruitList[-1])
print ("fruitList[-2]: ", fruitList[-2])  
subList1 = fruitList[-4: ]
print ("\n")
print ("Sub List fruitList[-4: ] ")
print (subList1) 
subList2  = fruitList[-4:-2]
print ("\n")
print ("Sub List fruitList[-4:-2] ")
print (subList2)
Output:
['apple', 'apricot', 'banana', 'coconut', 'lemen', 'plum', 'pear']
Element count: 7
fruitList[-1]:  pear
fruitList[-2]:  plum  

Sub List fruitList[-4: ]  
['coconut', 'lemen', 'plum', 'pear']

Sub List fruitList[-4:-2]  
['coconut', 'lemen']

3. Die Aktualisierung der Liste

Das folgende Beispiel ist die Aktualisierung der Liste nach Index
updateListExample.py
years = [1991,1995, 1992] 
print ("Years: ", years) 
print ("Set years[1] = 2000")

years[1] = 2000

print ("Years: ", years) 
print ( years ) 

print ("Append element 2015, 2016 to list") 
# Ein Element am Ende der Liste einfügen (append) 
years.append( 2015  )
years.append( 2016  )  
print ("Years: ", years)
Output:
Years: [1991, 1995, 1992]
Set years[1] = 2000
Years: [1991, 2000, 1992]
[1991, 2000, 1992]
Append element 2015, 2016 to list
Years: [1991, 2000, 1992, 2015, 2016]
Sie können die Wert für eine Slice der Elemente aktualisieren. Das ist der Weg, damit Sie mehre Element einmal aktualisieren
Eine Slice ist einige Elemente, deren Stelle nebeneinander in einer Liste ist
sliceUpdateExample.py
years =  [ 1990 ,  1991 ,  1992 ,  1993 ,  1994 ,  1995 ,  1996 ]
print ("Years: ", years)
print ("Update Slice: years[1:5] = [2000, 2001]")

years[1:5] = [ 2000 ,  2001 ]
print ("Years: ", years)
Output:
Years: [1990, 1991, 1992, 1993, 1994, 1995, 1996]
Update Slice: years[1:5] = [2000, 2001]
Years: [1990, 2000, 2001, 1995, 1996]

4. Die Elemente in der Liste löschen

Um ein oder mehre Elemente in einer Liste zu löschen, können Sie das Befehl del (del statement) oder die Methode remove() benutzen. Das folgende Beispiel benutzt del um ein oder mehre Elemente nach Index zu löschen
deleteElementExample.py
years =  [ 1990 ,  1991 ,  1992 ,  1993 ,  1994 ,  1995 ,  1996 ] 
print ("Years: ", years)  
print ("\n del years[6]") 
# Das Element in der Stelle mit Index = 6 löschen
del years[6] 
print ("Years: ", years)  
print ("\n del years[1:4]")

# Das Element in der Stelle mit Index = 1,2,3 löschen
del years[1:4]  
print ("Years: ", years)
Output:
Years: [1990, 1991, 1992, 1993, 1994, 1995, 1996]

 del years[6]
Years: [1990, 1991, 1992, 1993, 1994, 1995]

 del years[1:4]
Years: [1990, 1994, 1995]
Die Methode remove(value) entfernt das erste Element in der Liste, dessen Wert so gleich wie die Wert des Parameter ist. Die Methode kann eine Ausnahme werfen (throw exception) wenn keine Elemente zu entfernen gefunden werden
removeElementExample.py
years =  [ 1990 ,  1991 ,  1992 ,  1993 ,  1994 ,  1993 ,  1993 ]
print ("Years: ", years) 
print ("\n years.remove(1993)")

# Das erste Elemente mit der Wert von 1993 in die Liste entfernen
years.remove(1993)
print ("Years: ", years)
Output:
Years: [1990, 1991, 1992, 1993, 1994, 1993, 1993]

 years.remove(1993)
Years: [1990, 1991, 1992, 1994, 1993, 1993]

5. Die Operatoren

Wie String hat List 3 Operatoren +, * , in.
Der Operator
Die Bezeichnung
Zum Beispiel
+
Der Operator ist für die Bindung (concatenate) 2 Liste um eine neue Liste zu erstellen
[1, 2, 3[ + ["One","Two"]
--> [1, 2, 3, "One", "Two"]
*
Der Operator ist für die Bindung mehrer Kopie einer gleichen Liste. Und eine neue Liste erstellen
[1, 2] * 3
--> [1, 2, 1, 2, 1, 2]
in
Prüfen, ob ein Element in der Liste liegt oder nicht. Das Rückgabesergebnis ist True oder false
"Abc" in ["One", "Abc"]
--> True
listOperatorsExample.py
list1 = [1, 2, 3] 
list2 = ["One", "Two"]

print ("list1: ", list1)
print ("list2: ", list2)
print ("\n")

list12 = list1 + list2
print ("list1 + list2: ", list12)

list2x3 = list2 * 3
print ("list2 * 3: ", list2x3)

hasThree = "Three" in list2
print ("'Three' in list2? ", hasThree)
Output:
list1: [1, 2, 3]
list2: ['One', 'Two']

list1 + list2: [1, 2, 3, 'One', 'Two']
list2 * 3: ['One', 'Two', 'One', 'Two', 'One', 'Two']
'Three' in list2? False

6. Die betreffenden Funktionen von List

Die Funktion
Die Bezeichnung
cmp(list1, list2)
Die Elemente der 2 Liste vergleichen. Die Funktion wird aus Python3 entfernt
len(list)
Die Anzahl der Liste zurückgeben
max(list)
Die Elemente in der Liste mit der maximalen Wert zurückgeben
min(list)
Die Elemente in der Liste mit der minimum Wert zurückgeben
list(seq)
Eine Tuple zur Liste umwandeln
listsFunctionExample.py
list1 = [1991, 1994, 1992] 
list2 = [1991, 1994, 2000, 1992]

print ("list1: ", list1)
print ("list2: ", list2)

# Die Anzahl der Elemente der Liste zurückgeben.
print ("len(list1): ", len(list1) )
print ("len(list2): ", len(list2) )

# Die größte Wert der Liste.
maxValue = max(list1) 
print ("Max value of list1: ", maxValue) 

# Die kleinste Wert der Liste
minValue = min(list1) 
print ("Min value of list1: ", minValue)

# Tuple
tuple3 = (2001, 2005, 2012) 
print ("tuple3: ", tuple3)

# Eine Tuple zur Liste umwandeln
list3 = list (tuple3) 
print ("list3: ", list3)
Output:
list1: [1991, 1994, 1992]
list2: [1991, 1994, 2000, 1992]
len(list1): 3
len(list2): 4
Max value of list1: 1994
Min value of list1: 1991
tuple3: (2001, 2005, 2012)
list3: [2001, 2005, 2012]
Wenn die Elemente einer Liste (list) das Nummer Typ ist, ist die Findung der kleinsten und größten Wert in der Liste leicht zu verstehen. Aber wenn die Liste das Typ von object enthaltet, werden sie nach dem default Grundsatz vom Python verglichen oder Sie müssen eine konkrete Regelung stellen.
Mehr sehen
  • Comparing and Sorting in Python

7. Die Methode von Liste

Die Methode
Die Bezeichnung
list.append(obj)
Ein Objekt in der Liste binden (append)
list.count(obj)
Die Anzahl der Auftreten des 'obj' in der Liste zurückgeben
list.extend(seq)
Die Inhalt einer Sequence und der Liste binden
list.index(obj)
Die kleinste Index in der Liste zurückgeben, der Wert ist obj.
list.insert(index, obj)
Ein Element in der Liste bei der Indexindex einfügen.
list.pop([index])
Wenn es den Parameter index hat, die Elemente in der Stelle von Index entfernen und zurückgeben. Umgekehrt das letzte Element der Liste entfernen und zurückgeben
list.remove(obj)
Das erste Element mit der Wert obj aus der Liste entfernen
list.reverse()
Die Elemente in der Liste reversen
list.sort(key=None, reverse=False)
Die Elemente nach dem Schlüssel in Parameter aufgliedern
Zum Beispiel
listMethodsExample.py
years =  [ 1990 ,  1991 ,  1992 ,  1993 ,  1993 ,  1993 ,  1994 ]
print ("Years: ", years)
print ("\n - Reverse the list")

# Die Liste reserven
years.reverse()
print ("Years (After reverse): ", years)

aTuple = (2001, 2002, 2003)

print ("\n - Extend: ", aTuple)
years.extend(aTuple)
print ("Years (After extends): ", years)
print ("\n - Append 3000")
years.append(3000)

print ("Years (After appends): ", years)

print ("\n - Remove 1993")
years.remove(1993)
print ("Years (After remove): ", years) 
 
print ("\n - years.pop()")

# Das letzte Element von der Liste entfernen
lastElement = years.pop()

print ("last element: ", lastElement) 
print ("\n") 
# Count 
print ("years.count(1993): ",years.count(1993) )
Output:
Years: [1990, 1991, 1992, 1993, 1993, 1993,1994]

 - Reverse the list
Years (After reverse): [1994, 1993, 1993, 1993, 1992, 1991, 1990]

 - Extend: (2001, 2002, 2003)
Years (After extends):  [1994, 1993, 1993, 1993, 1992, 1991, 1990, 2001, 2002, 2003]

 - Append 3000
Years (After appends):  [1994, 1993, 1993, 1993, 1992, 1991, 1990, 2001, 2002, 2003, 3000]

 - Remove 1993
Years (After remove):  [1994, 1993, 1993, 1992, 1991, 1990, 2001, 2002, 2003, 3000]

 - years.pop(2001)
last element:  3000

years.count(1993): 2
Mehr sehen
  • Comparing and Sorting in Python

Neueste Artikel

Show More