Tuple ist ein unveränderlicher Datentyp in Python, der heterogene Datentypen speichern kann. Listen hingegen sind mehrere Datentypen, die heterogene Daten aufnehmen können. In diesem Artikel werden wir verschiedene Möglichkeiten untersuchen, um mithilfe funktionsbasierter Komponenten das erste Element aus einer Liste von Tupeln abzurufen. Wir werden verschiedene Methoden wie Schleifen, Listenverständnisse, Zip-Methoden usw. untersuchen.
Schleifen sind in fast allen Programmiersprachen übliche Anweisungen. Wir können auf das erste Element eines iterierbaren Objekts zugreifen, indem wir eine Schleifenanweisung zusammen mit der Indexeigenschaft eines iterierbaren Python-Objekts verwenden. Da wir in unserem Fall nur auf das erste Element zugreifen möchten, können wir in jeder Iteration die Indexnummer 0 verwenden.
Im folgenden Beispiel haben wir eine Funktion erstellt, die eine Liste als Eingabe zurückgibt und alle ersten Elemente der Liste in Form eines Listendatentyps zurückgibt. Unter der Funktion erstellen wir ein leeres Tupel und hängen bei jeder Iteration der Liste das erste Element der Tupelelemente an die initialisierte Liste an. Später haben wir ein Tupel erstellt und die Funktion aufgerufen, um das Ergebnis zu testen.
def get_first_element_using_loop(tuples_list):
first_elements = []
for tuple in tuples_list:
first_element = tuple[0]
first_elements.append(first_element)
return first_elements
t = [
('Apple', 5, True),
('Banana', 3, False),
('Orange', 2, True),
('Grape', 4, False),
('Mango', 6, True)
]
print(f"The first elements of the list are: {get_first_element_using_loop(t)}")
The first elements of the list are: ['Apple', 'Banana', 'Orange', 'Grape', 'Mango']
Listenverständnisse sind eine sehr praktische Möglichkeit, Ausdrücke und Anweisungen in Python zu kombinieren und zum Erstellen von Elementen in einer Liste zu verwenden. Abhängig von unseren Anforderungen können wir Indizierungsmethoden und for-Schleifen als bedingte Ausdrücke verwenden, um Elemente in der Liste zu erstellen.
Im folgenden Beispiel haben wir eine Funktion erstellt, die eine Liste akzeptiert und eine Liste zurückgibt, die alle ersten Elemente eines Tupels enthält. Wir verwenden die Listenverständnistechnik, um ein Listenelement mit dem Namen first_elements zu erstellen.
def get_first_element_using_comprehension(tuples_list):
first_elements = [tuple[0] for tuple in tuples_list]
return first_elements
t = [
('Apple', 5, True),
('Banana', 3, False),
('Orange', 2, True),
('Grape', 4, False),
('Mango', 6, True)
]
print(f"The first elements of the list are: {get_first_element_using_comprehension(t)}")
The first elements of the list are: ['Apple', 'Banana', 'Orange', 'Grape', 'Mango']
Map ist eine weitere wichtige integrierte Methode von Python. Die Map-Methode wendet eine Funktion auf alle Elemente des iterierbaren Objekts an. Es benötigt zwei Parameter, den Funktionsnamen und das iterierbare Objekt. Wir können die Lambda-Funktion und die Map-Methode verwenden, um auf das erste Element des Tupels in der Liste zuzugreifen.
Im folgenden Beispiel haben wir eine Funktion namens get_first_element_using_map erstellt, die eine Liste bestehend aus Tupelelementen nimmt und alle ersten Elemente der Tupelelemente der Liste zurückgibt. Wir verwenden die Map-Methode, um die Lambda-Funktion auf jedes Listenelement anzuwenden.
def get_first_element_using_map(tuples_list):
first_elements = list(map(lambda x: x[0], tuples_list))
return first_elements
t = [
('Lemon', 3, False),
('Strawberry', 7, True),
('Watermelon', 1, True),
('Pineapple', 4, False),
('Kiwi', 2, True)
]
print(f"The first elements of the list are: {get_first_element_using_map(t)}")
The first elements of the list are: ['Lemon', 'Strawberry', 'Watermelon', 'Pineapple', 'Kiwi']
Dies ist die knifflige Methode, alle ersten Elemente zu extrahieren. Zuerst können wir eine for-Schleife verwenden; als nächstes können wir die erste entpacken, indem wir einen Namen angeben. Wir können auch andere Elemente mit * angeben. Mithilfe des Listenverständnisses können wir alle Elemente an eine Liste anhängen.
for first_element, *_ in iterable:
# other codes
Hier geben wir das erste Element als first_element an. Beachten Sie, dass Sie ihm einen beliebigen Namen geben können. Als nächstes gibt „*_“ an, dass wir andere Elemente haben, diese uns aber nicht interessieren. „Iterierbar“ ist jedes iterierbare Objekt, beispielsweise eine Liste von Tupeln usw.
Im folgenden Code verwenden wir Pythons Listenverständnis- und Entpacktechniken. Hier benennen wir das erste Element jedes Tupelelements in der Liste first_element und hängen es an die Liste an. Die von uns erstellte Funktion ist eine nicht leere Funktion, die die resultierende Liste zurückgibt.
def get_first_element_using_unpacking(tuples_list):
first_elements = [first_element for first_element, *_ in tuples_list]
return first_elements
t = [
('Lemon', 3, False),
('Strawberry', 7, True),
('Watermelon', 1, True),
('Pineapple', 4, False),
('Kiwi', 2, True)
]
print(f"The first elements of the list are: {get_first_element_using_unpacking(t)}")
The first elements of the list are: ['Lemon', 'Strawberry', 'Watermelon', 'Pineapple', 'Kiwi']
Die zip()-Funktion in Python ist eine integrierte Funktion, die es Ihnen ermöglicht, mehrere iterierbare Objekte (wie Listen, Tupel oder Strings) in einem einzigen Tupel-Iterator zu kombinieren. Jedes von zip() generierte Tupel enthält das Element an der entsprechenden Position im Eingabe-Iterable sowie das Element selbst. Da der Rückgabewert eine Liste von Tupelelementen ist, können wir mit der Indexmethode auf das erste Element der Liste zugreifen.
Im folgenden Code erstellen wir eine nicht leere Funktion, die eine Liste als Argument verwendet und das erste Element in der Tupelliste zurückgibt. Wenn Sie das Ergebnis von list(zip(*tuples_list)) ausdrucken, erhalten Sie das folgende Ergebnis:
[('Zitrone', 'Erdbeere', 'Wassermelone', 'Ananas', 'Kiwi'), (3, 7, 1, 4, 2), (Falsch, Richtig, Richtig, Falsch, Richtig)]
Da wir nur das erste Element in der Liste haben möchten, verwenden wir die Indexmethode und setzen index=0.
def get_first_element_using_unpacking(tuples_list):
return list(zip(*tuples_list))[0]
t = [
('Lemon', 3, False),
('Strawberry', 7, True),
('Watermelon', 1, True),
('Pineapple', 4, False),
('Kiwi', 2, True)
]
print(f"The first elements of the list are: {get_first_element_using_unpacking(t)}")
The first elements of the list are: ('Lemon', 'Strawberry', 'Watermelon', 'Pineapple', 'Kiwi')
In diesem Artikel haben wir gelernt, wie man das erste Element einer Liste von Tupeln in Python erhält. In Python gibt es verschiedene Methoden, mit denen Aufgaben wie Schleifenmethoden, Listenverständnisse, Entpacken usw. ausgeführt werden können. Welche Methode die beste ist, hängt von der Nutzung und anderen Faktoren ab. Wir empfehlen den Lesern dringend, diese Konzepte auszuprobieren, um ein besseres Verständnis dieser Themen zu erlangen.
Das obige ist der detaillierte Inhalt vonWie erhalte ich das erste Element in einer Liste von Tupeln in Python?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
