Jedes Python-Objekt kann in einer Gruppe geordneter Werte in einer Python-Liste enthalten sein. Da es sich bei der Liste um eine veränderbare Datenstruktur in Python handelt, können wir die vorhandenen Werte in diesem Container hinzufügen, entfernen oder ändern. Im Gegensatz zu Mengen erlaubt die Liste zahlreiche Instanzen desselben Werts und behandelt jede als unterschiedliches Element. In diesem Tutorial erfahren Sie, wie Sie ein Listenobjekt in Python initialisieren.
Initialisieren Sie die Listen mit den eckigen Klammern
Die Verwendung einer eckigen Klammer ist eine Möglichkeit, eine Liste ohne Werte zu initialisieren, wenn wir in Python eine leere Liste ohne Werte erstellen möchten. Um eine Liste zu initialisieren, müssen wir nur ein Paar eckiger Klammern mit oder ohne Elementwerte angeben.
Code
# Python program to show how to initialize a list using square brackets # Initializing an empty list list_ = [] print('An empty list: ', list_) # Initializing a list with some values list_ = [1, 3, 5, 7] print('A non-Empty list: ', list_)
Ausgabe:
An empty list: [] A non-Empty list: [1, 3, 5, 7]
Verwenden der integrierten list()-Funktion zum Initialisieren einer Liste
Die Funktion list() von Python erstellt die Liste, ein iterierbares Objekt. Daher ist dies eine weitere Möglichkeit, eine leere Python-Liste ohne Daten in dieser Programmiersprache zu erstellen.
Ein Iteratorobjekt, eine Sequenz, die die Iteration ermöglicht, oder ein Container können alle iterierbar sein. Wenn keine Eingabe erfolgt, wird eine neue leere Liste erstellt.
Code
# Python program to show how to initialize a list using the built-in list function # Initializing an empty list list_ = list() print('An empty list: ', list_) # Initializing a non-empty list list_ = list([1, 2, 3]) print('A non-empty list: ', list_)
Ausgabe:
An empty list: [] A non-empty list: [1, 2, 3]
Die Methode mit eckigen Klammern wird der integrierten Funktion list() vorgezogen, da sie klarer und anschaulicher ist.
Verwenden von Listenverständnissen zum Initialisieren einer Liste
Wir können den Listenverständnisansatz verwenden, um die Standardparameter der Liste festzulegen. Es besteht aus einem in eckigen Klammern eingeschlossenen Ausdruck, einer for-Anweisung und einer optionalen if-Anweisung, die folgen kann oder nicht. Jedes Element, das wir zur Liste hinzufügen möchten, kann als Ausdruck geschrieben werden. Der Ausdruck wäre 0, wenn der Benutzer die Liste mit Nullen initialisiert hätte.
Das Listenverständnis ist ein eleganter, unkomplizierter und bekannter Ansatz zum Erstellen einer Liste auf der Grundlage eines Iterators.
Kartentyposkript
Code
# Python program to show how to initialize a list using list comprehension # Initializing a list list_ = [item for item in range(10)] print('The list was created using list comprehension: ', list_)
Ausgabe:
The list was created using list comprehension: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Diese Technik initialisiert Listen viel schneller als die for- und while-Schleifen von Python.
Initialisieren Sie eine Python-Liste mit dem *-Operator
Eine andere Möglichkeit, eine Liste in Python zu initialisieren, ist die Verwendung des *-Operators. Es erstellt eine Liste mit mehreren Werten. Die Syntax für die Verwendung dieses Operators lautet [Element] * n. Hier ist n die Häufigkeit, mit der wir das Element in der Liste wiederholen möchten.
Diese Methode hilft, wenn wir eine Liste vordefinierter Längen initialisieren möchten.
Code
# Python program to show how to use the * operator to initialize a list list_ = [5]*10 print (list)
Ausgabe:
[5, 5, 5, 5, 5, 5, 5, 5, 5]
Diese Methode ist sehr effizient und die schnellste Möglichkeit, eine Liste zu erstellen. Wir werden die von den Methoden benötigte Zeit später in diesem Tutorial vergleichen.
Der einzige Nachteil bei der Verwendung dieses Operators zum Initialisieren einer Python-Liste besteht darin, dass wir eine 2D-Liste erstellen müssen, da diese Methode nur eine flache Liste erstellt, d. h. ein einzelnes Listenobjekt erstellt und alle Indizes darauf verweisen Objekt, das sehr unpraktisch sein wird. Aus diesem Grund verwenden wir das Listenverständnis, wenn wir 2D-Listen erstellen müssen.
Verwenden einer for-Schleife und append()
Wir erstellen eine leere Liste und führen eine for-Schleife aus, um mithilfe der append()-Funktion der Liste Elemente hinzuzufügen.
Code
# Python program to show how to use a for loop to initialize a list arr = [] for i in range(1000): arr.append(0)
Verwenden einer While-Schleife zum Initialisieren einer Liste
Wir können eine While-Schleife genauso verwenden, wie wir eine For-Schleife zum Initialisieren einer Liste verwendet haben.
Code
# Python program to initialize a list using a while loop # Creating an empty list array = [] # Declaring counter variables i = 0 # Starting a while loop while(i <10): array.append(0) i +="1" print(array) < pre> <p> <strong>Output:</strong> </p> <pre> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] </pre> <h2>Time Complexity</h2> <p>Let us now see how long each of the described approaches will take. We will initialize a list of 100000 elements 1000 times. We will calculate the average time each method takes to perform this task.</p> <p> <strong>Code</strong> </p> <pre> # Python program to see the time taken by various methods to initialize a list # importing the time module to calculate the time taken by a chunk of code import time # initializing the lists for various methods forLoop = [] whileLoop = [] listComprehension = [] starOperator = [] # repeating the process of generating a list of 100000 elements 500 times # Then calculate the average time taken by the methods for i in range(1000): # starting time of the execution begin = time.time() # declaring an empty list list_ = [] # running a for loop and iterating it 100000 times for i in range(100000): list_.append(0) # stoping time of the execution end = time.time() forLoop.append(end - begin) # starting time of the execution begin = time.time() # declaring an empty list list_ = [] i = 0 # COunter variable # running a while loop and iterating it 100000 times while i <100000: 100000 list_.append(0) i +="1" end="time.time()" whileloop.append(end - begin) begin="time.time()" # using a list comprehension to initialize the for in range(100000)] listcomprehension.append(end astrick (*) operator * staroperator.append(end print('the average execution time of loop is: ', sum(forloop) 1000) while sum(whileloop) sum(listcomprehension) taken operator: sum(staroperator) < pre> <p> <strong>Output:</strong> </p> <pre> The average execution time of for loop is: 0.01166958212852478 The average execution time of the while loop is: 0.01916465663909912 The average execution time of list comprehension is: 0.005084690093994141 The average execution time was taken of * operator: 0.00028331947326660156 </pre> <p>We can see that for and while loops take almost the same execution time. However, for loop is a little better than the while loop.</p> <p>List comprehension shows much better performance than the for and while loops. It is 2-3 times faster than the loops. Thus, list comprehension is much more efficient than the append() function of the lists.</p> <p>The * operator has shown the best performance out of all the four methods.</p> <hr></100000:></pre></10):> Zeitkomplexität
Schauen wir uns nun an, wie lange jeder der beschriebenen Ansätze dauern wird. Wir werden eine Liste mit 100.000 Elementen 1.000 Mal initialisieren. Wir berechnen die durchschnittliche Zeit, die jede Methode benötigt, um diese Aufgabe auszuführen.
Code
# Python program to see the time taken by various methods to initialize a list # importing the time module to calculate the time taken by a chunk of code import time # initializing the lists for various methods forLoop = [] whileLoop = [] listComprehension = [] starOperator = [] # repeating the process of generating a list of 100000 elements 500 times # Then calculate the average time taken by the methods for i in range(1000): # starting time of the execution begin = time.time() # declaring an empty list list_ = [] # running a for loop and iterating it 100000 times for i in range(100000): list_.append(0) # stoping time of the execution end = time.time() forLoop.append(end - begin) # starting time of the execution begin = time.time() # declaring an empty list list_ = [] i = 0 # COunter variable # running a while loop and iterating it 100000 times while i <100000: 100000 list_.append(0) i +="1" end="time.time()" whileloop.append(end - begin) begin="time.time()" # using a list comprehension to initialize the for in range(100000)] listcomprehension.append(end astrick (*) operator * staroperator.append(end print(\'the average execution time of loop is: \', sum(forloop) 1000) while sum(whileloop) sum(listcomprehension) taken operator: sum(staroperator) < pre> <p> <strong>Output:</strong> </p> <pre> The average execution time of for loop is: 0.01166958212852478 The average execution time of the while loop is: 0.01916465663909912 The average execution time of list comprehension is: 0.005084690093994141 The average execution time was taken of * operator: 0.00028331947326660156 </pre> <p>We can see that for and while loops take almost the same execution time. However, for loop is a little better than the while loop.</p> <p>List comprehension shows much better performance than the for and while loops. It is 2-3 times faster than the loops. Thus, list comprehension is much more efficient than the append() function of the lists.</p> <p>The * operator has shown the best performance out of all the four methods.</p> <hr></100000:>
Wir können sehen, dass for- und while-Schleifen fast die gleiche Ausführungszeit benötigen. Allerdings ist die for-Schleife etwas besser als die while-Schleife.
Referenzdatentypen in Java
Das Listenverständnis zeigt eine viel bessere Leistung als die for- und while-Schleifen. Es ist 2-3 mal schneller als die Schleifen. Somit ist das Listenverständnis wesentlich effizienter als die append()-Funktion der Listen.
Der *-Operator hat von allen vier Methoden die beste Leistung gezeigt.