💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken
Python-Listen sind vielseitige Datenstrukturen, die es Entwicklern ermöglichen, Sammlungen von Elementen effizient zu speichern und zu verwalten. In diesem Tutorial werden verschiedene Techniken zum Füllen von Listen mit Werten untersucht, um Programmierern die wesentlichen Fähigkeiten zu vermitteln, um Listen in der Python-Programmierung zu erstellen, zu befüllen und zu manipulieren.
Eine Python-Liste ist eine vielseitige, geordnete Sammlung von Elementen, die mehrere Elemente unterschiedlicher Typen speichern kann. Listen sind veränderlich (mutable), was bedeutet, dass Sie Elemente nach der Erstellung ändern, hinzufügen oder entfernen können.
Listen werden entweder mit eckigen Klammern [] oder dem list()-Konstruktor erstellt:
## Creating lists
fruits = ['apple', 'banana', 'cherry']
numbers = [1, 2, 3, 4, 5]
mixed_list = [1, 'hello', True, 3.14]
empty_list = []| Eigenschaft | Beschreibung |
|---|---|
| Geordnet | Die Elemente behalten die Reihenfolge bei, in der sie eingefügt wurden |
| Veränderlich | Kann nach der Erstellung geändert werden |
| Indiziert | Die Elemente können über ihren Index zugegriffen werden |
| Heterogen | Kann Elemente unterschiedlicher Datentypen enthalten |
## Accessing elements
fruits = ['apple', 'banana', 'cherry']
print(fruits[0]) ## First element
print(fruits[-1]) ## Last element
## Modifying elements
fruits[1] = 'grape'
## Adding elements
fruits.append('orange')
fruits.insert(1, 'mango')
## Removing elements
fruits.remove('apple')
del fruits[1]fruits = ['apple', 'banana', 'cherry']
## Getting list length
print(len(fruits)) ## 3
## Checking membership
print('banana' in fruits) ## True
print('grape' not in fruits) ## Truenumbers = [0, 1, 2, 3, 4, 5]
## Slicing
print(numbers[1:4]) ## [1, 2, 3]
print(numbers[:3]) ## [0, 1, 2]
print(numbers[3:]) ## [3, 4, 5]LabEx empfiehlt, diese Konzepte zu üben, um eine solide Grundlage für die Manipulation von Python-Listen aufzubauen.
## Direct initialization
fruits = ['apple', 'banana', 'cherry']
numbers = [0, 1, 2, 3, 4]## Repeating elements
zeros = [0] * 5 ## [0, 0, 0, 0, 0]
repeated_list = ['x'] * 3 ## ['x', 'x', 'x']## Adding single elements
fruits = []
fruits.append('apple')
fruits.append('banana')
## Result: ['apple', 'banana']## Adding multiple elements
numbers = [1, 2, 3]
numbers.extend([4, 5, 6])
## Result: [1, 2, 3, 4, 5, 6]## Inserting at specific index
colors = ['red', 'blue']
colors.insert(1, 'green')
## Result: ['red', 'green', 'blue']## Creating lists with range
numbers = list(range(5)) ## [0, 1, 2, 3, 4]
even_numbers = list(range(0, 10, 2)) ## [0, 2, 4, 6, 8]## Creating lists with default values
size = 5
default_list = [None] * size
matrix = [[0 for _ in range(3)] for _ in range(3)]| Methode | Zweck | Leistung | Flexibilität |
|---|---|---|---|
| Literal | Direkte Initialisierung | Am schnellsten | Niedrig |
| Multiplikation | Wiederholung von Elementen | Schnell | Mittel |
| append() | Hinzufügen einzelner Elemente | Mäßig | Hoch |
| extend() | Hinzufügen mehrerer Elemente | Gut | Hoch |
| Listen-Abstraktion (List Comprehension) | Komplexe Erzeugung | Flexibel | Sehr hoch |
## Efficient list filling
## Prefer list comprehension for complex scenarios
squares = [x**2 for x in range(10)]
## Avoid repeated list modifications
## Use extend or list comprehension insteadLabEx empfiehlt, diese Methoden zu meistern, um effizienteren Python-Code zu schreiben.
Die Listen-Abstraktion (List Comprehension) ist eine kompakte und leistungsstarke Methode, um Listen in Python zu erstellen. Sie ermöglicht es Ihnen, Listen in einer einzigen Codezeile zu generieren, zu transformieren und zu filtern.
## Basic list comprehension structure
new_list = [expression for item in iterable]
## Example: Creating a list of squares
squares = [x**2 for x in range(10)]
## Result: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]## Converting strings to uppercase
names = ['alice', 'bob', 'charlie']
uppercase_names = [name.upper() for name in names]
## Result: ['ALICE', 'BOB', 'CHARLIE']## Filtering even numbers
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = [num for num in numbers if num % 2 == 0]
## Result: [2, 4, 6, 8, 10]## Nested conditions
result = [x*y for x in range(3) for y in range(3) if x!= y]
## Equivalent to nested loops with condition| Methode | Lesbarkeit | Leistung | Komplexität |
|---|---|---|---|
| Listen-Abstraktion (List Comprehension) | Hoch | Schnell | Einfach |
| Herkömmlicher Loop | Mittel | Langsamer | Ausführlicher |
| map()-Funktion | Niedrig | Mäßig | Komplex |
## Creating a 3x3 matrix
matrix = [[i*j for j in range(3)] for i in range(3)]
## Result: [[0, 0, 0], [0, 1, 2], [0, 2, 4]]## Ternary operation in comprehension
numbers = [1, 2, 3, 4, 5]
classified = ['even' if num % 2 == 0 else 'odd' for num in numbers]
## Result: ['odd', 'even', 'odd', 'even', 'odd']## Benchmark: List Comprehension vs Traditional Loop
import timeit
## List comprehension
def comp_method():
return [x**2 for x in range(1000)]
## Traditional loop
def loop_method():
result = []
for x in range(1000):
result.append(x**2)
return resultLabEx empfiehlt, die Listen-Abstraktion zu üben, um mehr Pythonic Code zu schreiben.
Das Verständnis verschiedener Methoden zum Füllen von Python-Listen ist für eine effektive Datenverarbeitung von entscheidender Bedeutung. Indem Entwickler die Techniken zur Listeninitialisierung, die Listen-Abstraktion (List Comprehension) und verschiedene Füllstrategien beherrschen, können sie beim Umgang mit Listen-Datenstrukturen in Python kompakteren, lesbareren und effizienteren Code schreiben.
