Die Anleitung zu Python Lists
View more Tutorials:
Folge uns auf unserer fanpage, um jedes Mal benachrichtigt zu werden, wenn es neue Artikel gibt.
Facebook
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]
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']
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]
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]
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
| 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
| 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
