Python – Kombinationen bis zu K verketten

Gruppenverkettung bis K bedeutet die Verkettung von Elementen in einer Gruppe oder Sequenz, bis eine bestimmte Bedingung erfüllt ist. In Python können wir verschiedene Methoden verwenden, um die Gruppenverkettung bis K zu implementieren, z. B. die Verwendung von Schleifen und Akkumulatoren, die Verwendung der Funktion itertools.groupby() und die Verwendung regulärer Ausdrücke. In diesem Artikel werden wir alle diese Methoden verwenden und untersuchen, um eine Gruppenverkettung bis K zu erreichen oder eine bestimmte Bedingung zu erfüllen.

Methode 1: Schleifen und Akkumulatoren verwenden

Diese Methode verwendet Schleifen und Akkumulatoren, um Elemente zu gruppieren, bis der Zielwert K erreicht ist. Es durchläuft die Liste und sammelt Elemente in temporären Gruppen, bis K gefunden wird. Sobald K angetroffen wird, wird es zu einer Zeichenfolge zusammengefasst und der Ergebnisliste hinzugefügt. Abschließend werden die verbleibenden Elemente der Gruppe an die resultierende Liste angehängt.

Grammatik

list_name.append(element)

Hier ist die Funktion append() eine Listenmethode, mit der Elemente am Ende der Liste hinzugefügt werden. Es ändert die ursprüngliche Liste, indem es die angegebenen Elemente als neue Elemente zur ursprünglichen Liste hinzufügt.

Beispiel

Im folgenden Beispiel akzeptiert die Funktion group_concatenate_till_k eine Listenliste und den Zielwert K. Es initialisiert ein leeres Listenergebnis, um die gruppierten Elemente zu speichern, und eine leere Listengruppe, um Elemente zu akkumulieren, bis K angetroffen wird. Durchlaufen Sie jedes Element in der Liste. Wenn die Terme gleich K sind, werden die Elemente in der Gruppe zu einer Zeichenfolge verkettet und an das Ergebnis angehängt. Anschließend wird die Gruppe auf eine leere Liste zurückgesetzt. Wenn das Element nicht gleich K ist, fügen Sie das Element der Gruppe hinzu.

Abschließend werden alle verbleibenden Elemente in der Gruppe an das Ergebnis angehängt und das Ergebnis zurückgegeben.

def group_concatenate_till_k(lst, K):
    result = []
    group = []
    for item in lst:
        if item == K:
            result.append(''.join(group))
            group = []
        else:
            group.append(item)
    result.append(''.join(group))
    return result

# Example usage
lst = ['a', 'b', 'c', '', 'd', 'e', '', '', 'f']
K = ''
output = group_concatenate_till_k(lst, K)
print(output)

Ausgabe

['abc', 'de', 'f']

Methode 2: Verwenden Sie itertools.groupby()

Bei dieser Methode wird die Groupby-Funktion des Itertools-Moduls verwendet, um aufeinanderfolgende Elemente basierend auf einer bestimmten Bedingung zu gruppieren. Durch Angabe der Bedingung über die Lambda-Funktion wird die Liste in Gruppen aufgeteilt, die kein K enthalten. Die Elemente in jeder Gruppe werden zu einer Zeichenfolge verkettet und der resultierenden Liste hinzugefügt.

Grammatik

list_name.append(element)

Hier ist die Funktion append() eine Listenmethode, mit der Elemente am Ende der Liste hinzugefügt werden. Es ändert die ursprüngliche Liste, indem es die angegebenen Elemente als neue Elemente zur ursprünglichen Liste hinzufügt.

itertools.groupby(iterable, key=None)

Hier akzeptiert die Methode groupby() ein iterierbares Objekt als Eingabe und eine optionale Schlüsselfunktion. Es gibt einen Iterator zurück, der ein Tupel bestehend aus aufeinanderfolgenden Schlüsseln und generiert. Zur Bestimmung der Kriterien für die Gruppierung werden Schlüsselfunktionen verwendet.

Beispiel

Im folgenden Beispiel akzeptiert die Funktion group_concatenate_till_k eine Listenliste und den Zielwert K. Es verwendet die Groupby-Funktion, um aufeinanderfolgende Elemente in der Liste basierend auf der Bedingung Lambda x: x != K zu gruppieren. Die Funktion „groupby“ gibt ein Schlüsselpaar (das Ergebnis der Bedingung) und einen Iterator der entsprechenden Gruppe zurück. Indem wir prüfen, ob der Schlüssel wahr ist, ermitteln wir die Gruppe, die kein K enthält, und verketten die Elemente zu einer Zeichenfolge. Die Zeichenfolge wird dann zur Ergebnisliste hinzugefügt.

from itertools import groupby

def group_concatenate_till_k(lst, K):
    result = []
    for key, group in groupby(lst, lambda x: x != K):
        if key:
            result.append(''.join(group))
    return result

# Example usage
lst = ['a', 'b', 'c', '', 'd', 'e', '', '', 'f']
K = ''
output = group_concatenate_till_k(lst, K)
print(output)

Ausgabe

['abc', 'de', 'f']

Methode 3: Verwenden Sie reguläre Ausdrücke

Bei dieser Methode werden reguläre Ausdrücke verwendet, um die Liste basierend auf einem Zielwert K in Gruppen zu unterteilen. Verwenden Sie zum Erstellen des Musters eine reguläre Ausdrucksfunktion und stellen Sie sicher, dass K nicht am Anfang der Gruppe steht. Verwenden Sie dann die Funktion re.split, um die verkettete Zeichenfolge basierend auf diesem Muster zu teilen, um die erforderlichen gruppierten Elemente zu erhalten.

Grammatik

result = re.split(pattern, string)

Hier akzeptiert die Funktion re.split aus dem re-Modul zwei Parameter: Muster und Zeichenfolge. Muster ist ein regulärer Ausdruck, der Aufteilungskriterien definiert, und Zeichenfolge ist die zu teilende Eingabezeichenfolge. Diese Funktion gibt eine Liste von Teilzeichenfolgen zurück, die durch die Teilungsoperation gemäß dem angegebenen Muster erstellt wurden.

Beispiel

Im folgenden Beispiel akzeptiert die Funktion group_concatenate_till_k eine Listenliste und den Zielwert K. Es erstellt ein reguläres Ausdrucksmuster, indem es den K-Wert maskiert und eine negative Lookahead-Assertion verwendet, um sicherzustellen, dass K nicht am Anfang einer Gruppe steht. Die verkettete Zeichenfolge wird dann basierend auf dem erstellten Muster mithilfe der Funktion re.split aufgeteilt. Die resultierende Liste mit den gruppierten Elementen wird als Ausgabe zurückgegeben.

import re

def group_concatenate_till_k(lst, K):
    pattern = f"(?!^{re.escape(K)}){re.escape(K)}"
    result = re.split(pattern, ''.join(lst))
    return result

# Example usage
lst = ['a', 'b', 'c', '', 'd', 'e', '', '', 'f']
K = ''
output = group_concatenate_till_k(lst, K)
print(output)

Ausgabe

['a', 'b', 'c', 'd', 'e', 'f', '']

Fazit

In diesem Artikel haben wir besprochen, wie man Elemente einer Liste oder Sequenz in Gruppen zusammenfügt, bis eine bestimmte Bedingung K erfüllt ist. Wir haben drei Ansätze untersucht: die Verwendung von Schleifen und Akkumulatoren, itertools.groupby() und reguläre Ausdrücke. Abhängig von Ihren Bedürfnissen und Vorlieben können Sie die Methode wählen, die am besten zu Ihrem spezifischen Anwendungsfall passt.

Das obige ist der detaillierte Inhalt vonPython – Kombinationen bis zu K verketten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!