In Python können Sie die Gesamtzahl der Elemente in einer Liste oder einem Tupel mit der integrierten Funktion len() und die Anzahl der Vorkommen eines Elements mit der Methode count() umfassen.
Darüber hinaus kann die Counter-Klasse der Standardbibliothekssammlungen used Werden, um die Anzahl der Vorkommen jedes Elements auf einmal zu zählen.
Dieser Artikel hat folgenden Inhalt.
- Zählen Sie die Gesamtzahl der Elemente:
len() - Zählen Sie die Anzahl der Vorkommen eines Elements:
count() - Verwendung von Sammlungen.Counter
- Holen Sie sich die häufigsten Elemente:
most_common() - Zähle einzigartige Elemente
- Zähle Elemente, die sterben Bedingungen erfüllen
- Zählen Sie die Anzahl der Vorkommen eines Wortes in einer Kette
- Zählen Sie die Anzahl der Vorkommen eines Zeichens in einer Zeichenfolge
Im following Beispielcode Werden Listen used, Tupel can jedoch auf sterben same weise verarbeitet Werden.
Zählen Sie die Gesamtzahl der Elemente:len()
Sie können die Gesamtzahl der Elemente in einer Liste mit der eingebauten Funktion len() umfassen.
l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
print(len(l))
# 7
Zählen Sie die Anzahl der Vorkommen eines Elements:count()
Sie können die Anzahl der Vorkommen eines Elements in einer Liste mit der Methode count() umfassen.
Wird ein nicht vorhandenes Element übergeben, wird 0 zurückgegeben.
l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
print(l.count('a'))
# 4
print(l.count('b'))
# 1
print(l.count('c'))
# 2
print(l.count('d'))
# 0
collections.Counter, das im Folgenden erklärt WIRD, ist nützlich, WENN SIE sterben Anzahl der Vorkommen jedes Elements auf einmal zählen möchten.
Verwendung von Sammlungen.Counter
Die Counter-Klasse WIRD in den Sammlungen der Standardbibliothek bereitgestellt.
Counter-Objekt wird erstellt, indem eine Liste an collections.Counter() übergeben wird.
Counter ist eine Unterklasse des Wörterbuchs dict, das Elemente als Schlüssel und ihre Zählwerte als Werte hat.
import collections
l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
c = collections.Counter(l)
print(c)
# Counter({'a': 4, 'c': 2, 'b': 1})
print(type(c))
# <class 'collections.Counter'>
print(issubclass(type(c), dict))
# True
Indem Sie ein Element angeben, können Sie seine Anzahl erhalten. Wenn ein nicht vorhandenes Element angegeben wird, wird 0 zurückgegeben.
print(c['a'])
# 4
print(c['b'])
# 1
print(c['c'])
# 2
print(c['d'])
# 0
Sie können auch dict-Methoden wie keys(), values() und items() verwenden.
print(c.keys())
# dict_keys(['a', 'b', 'c'])
print(c.values())
# dict_values([4, 1, 2])
print(c.items())
# dict_items([('a', 4), ('b', 1), ('c', 2)])
Diese Methoden-Objekte geben vom Typ dict_keys usw. zurück. Sie können sie einfach verwenden, wenn Sie die For-Schleife verwenden möchten. Wenn Sie es in Eine Liste umwandeln möchten, verwenden Sie list().
Holen Sie sich die häufigsten Elemente:most_common()
Counter hat eine most_common()-Methode, sterben eine Liste von Tupeln von (Element, Anzahl) sortiert nach Anzahl zurückgibt.
print(c.most_common())
# [('a', 4), ('c', 2), ('b', 1)]
Sie können den mit der höchsten Anzahl von Vorkommen erhalten, indem Sie den Index als [0] angeben, den mit der niedrigsten als [-1] und so weiter. Wenn Sie nur die Elemente oder nur die Anzahl erhalten möchten, geben Sie einfach den Index dahinter an.
print(c.most_common()[0])
# ('a', 4)
print(c.most_common()[-1])
# ('b', 1)
print(c.most_common()[0][0])
# a
print(c.most_common()[0][1])
# 4
Wenn Sie nach abnehmender Anzahl sortieren möchten, verwenden Sie Slices mit einem auf -1 eingestellten Inkrement.
print(c.most_common()[::-1])
# [('b', 1), ('c', 2), ('a', 4)]
Wenn für die Methode most_common() das Argument n angegeben WIRD, werden nur die n Elemente mit den meisten Vorkommen zurückgegeben. Wenn es weggelassen WIRD, Werden alle Elemente zurückgegeben.
print(c.most_common(2))
# [('a', 4), ('c', 2)]
Wenn SIE anstelle eines Tupels von (element, count) eine separate Liste von Elementen und ihrer Anzahl nach der Anzahl ihrer Vorkommen geordnet möchten, can SIE Folgendes tun.
values, counts = zip(*c.most_common())
print(values)
# ('a', 'c', 'b')
print(counts)
# (4, 2, 1)
Es used sterben eingebaute Funktion zip(), um Eine 2D-Liste (in diesem Fall Eine Liste von Tupeln) zu transponieren und sie zu entpacken und zu extrahieren. Nichts finden Sie in den folgenden Artikeln.
Zähle einzigartige Elemente
Wenn Sie eindeutige Elemente in Einer Liste oder Einem Tupel umfassen möchten, verwenden Sie Counter oder set().
Die Anzahl der Elemente im Counter-Objekt entspricht der Anzahl der eindeutigen Elemente in der ursprünglichen Liste. Es kann mit len() abgerufen werden.
l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
c = collections.Counter(l)
print(len(c))
# 3
Sie können auch set verwenden. Wenn Sie kein Counter-Objekt benötigen, ist es einfacher, set zu verwenden.
set ist ein Datentyp, der keine doppelten Elemente hat, und set() gibt ein set-Objekt mit eindeutigen Werten zurück, wenn eine Liste übergeben wird. Die Anzahl der Elemente im Set erhältst du mit len().
print(set(l))
# {'a', 'c', 'b'}
print(len(set(l)))
# 3
Weitere Informationen zum Überprüfen, Entfernen und Extrahieren doppelter Elemente in einer Liste FINDEN SIE in den following Artikeln.
Zähle Elemente, die sterben Bedingungen erfüllen
Um die Anzahl der Elemente in Einer Liste oder Einem Tupel zu umfassen, sterben Eine bestimmte Bedingung erfüllen, verwenden SIE Listenverständnisse oder Generatorausdrücke.
Zählen Sie beispielsweise die Anzahl der Elemente mit negativen Werten für die folgende Liste.
l = list(range(-5, 6))
print(l)
# [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
Das Anwenden eines bedingten Ausdrucks auf jedes Element mit Listenverständnis gibt eine Liste zurück, deren Elemente vom Typ bool (Wahr, Falsch) sind.
Der boolesche Typ bool ist eine Unterklasse des Integer-Typs int. True wird als 1 und False als 0 behandelt. Sie können die Anzahl von True (die Anzahl der Elemente, die Bedingung erfüllen) mit sum() umfassen.
print([i < 0 for i in l])
# [True, True, True, True, True, False, False, False, False, False, False]
print(sum([i < 0 for i in l]))
# 5
Wenn [] in der Liste Comprehensions durch () ersetzt WIRD, WIRD es zum Generatorausdruck. Wenn ein Generatorausdruck das einzige Argument ist, kann () weggelassen werden.
print(sum((i < 0 for i in l)))
# 5
print(sum(i < 0 for i in l))
# 5
Verwenden Sie nicht, wenn Sie die Anzahl von False umfassen möchten (die Anzahl der Elemente, die Bedingung nicht erfüllen).
print([not (i < 0) for i in l])
# [False, False, False, False, False, True, True, True, True, True, True]
print(sum(not (i < 0) for i in l))
# 6
Natürlich können Sie die Bedingungen ändern.
print(sum(i >= 0 for i in l))
# 6
Einige andere Beispiele sind unten gezeigt.
Zählen Sie die Anzahl der ungeraden Elemente für eine Liste von Zahlen.
print([i % 2 == 1 for i in l])
# [True, False, True, False, True, False, True, False, True, False, True]
print(sum(i % 2 == 1 for i in l))
# 6
Beispiele für eine Liste von Streichern:
l = ['apple', 'orange', 'banana']
print([s.endswith('e') for s in l])
# [True, True, False]
print(sum(s.endswith('e') for s in l))
# 2
Verwenden Sie Sammlungen.Zähler, um die Anzahl der Vorkommen als Bedingung festzulegen.
Im Folgenden finden Sie ein Beispiel für das Extrahieren von Elementen mit zwei oder mehr Vorkommen und das Zählen ihrer Gesamtzahl. In diesem Beispiel gibt es vier a und zwei c, also insgesamt sechs.
l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
c = collections.Counter(l)
print(c.items())
# dict_items([('a', 4), ('b', 1), ('c', 2)])
print([i for i in l if c[i] >= 2])
# ['a', 'a', 'a', 'a', 'c', 'c']
print([i[1] for i in c.items() if i[1] >= 2])
# [4, 2]
print(sum(i[1] for i in c.items() if i[1] >= 2))
# 6
Im Folgenden finden Sie ein Beispiel für das Extrahieren der Werte von Elementen mit zwei oder mehr Vorkommen und das Zählen ihrer Anzahl. In diesem Beispiel gibt es zwei Werte, a und c.
print([i[0] for i in c.items() if i[1] >= 2])
# ['a', 'c']
print([i[1] >= 2 for i in c.items()])
# [True, False, True]
print(sum(i[1] >= 2 for i in c.items()))
# 2
Zählen Sie die Anzahl der Vorkommen eines Wortes in einer Kette
Lassen Sie uns als spezifisches Beispiel die Anzahl der Wortvorkommen in einer Zeichenfolge umfassen.
Erstens unnötig, und . Werden mit der Methode replace() durch einen leeren String ersetzt und entfernt. Verwenden Sie dann die Methode split(), um eine durch Leerzeichen getrennte Liste zu erstellen.
s = 'government of the people, by the people, for the people.'
s_remove = s.replace(',', '').replace('.', '')
print(s_remove)
# government of the people by the people for the people
word_list = s_remove.split()
print(word_list)
# ['government', 'of', 'the', 'people', 'by', 'the', 'people', 'for', 'the', 'people']
If SIE Eine Liste erstellen, can SIE die Anzahl der Vorkommen usw. wie in den vorherigen Beispielen erhalten.
print(word_list.count('people'))
# 3
print(len(set(word_list)))
# 6
c = collections.Counter(word_list)
print(c)
# Counter({'the': 3, 'people': 3, 'government': 1, 'of': 1, 'by': 1, 'for': 1})
print(c.most_common()[0][0])
# the
Das obige ist ein sehr einfacher Prozess, daher ist es für eine komplexe Verarbeitunger Sprache besser, eine Bibliothek wie NLTK zu verwenden.
Zählen Sie die Anzahl der Vorkommen eines Zeichens in einer Zeichenfolge
Sie können die Methode count() auch für Strings verwenden oder sie als Argument von collections.Counter() übergeben.
s = 'supercalifragilisticexpialidocious'
print(s.count('p'))
# 2
c = collections.Counter(s)
print(c)
# Counter({'i': 7, 's': 3, 'c': 3, 'a': 3, 'l': 3, 'u': 2, 'p': 2, 'e': 2, 'r': 2, 'o': 2, 'f': 1, 'g': 1, 't': 1, 'x': 1, 'd': 1})
Holen Sie sich sterben fünf am häufigsten vorkommenden Charaktere.
print(c.most_common(5))
# [('i', 7), ('s', 3), ('c', 3), ('a', 3), ('l', 3)]
values, counts = zip(*c.most_common(5))
print(values)
# ('i', 's', 'c', 'a', 'l')