I Python kan antalet element i en lista eller tupel erhållas med hjälp av den inbyggda funktionen len(), och antalet element (antalet förekomster av varje element) kan erhållas med hjälp av metoden count().
Dessutom kan Counter-klassen i Pythons standardbiblioteks samlingar användas för att hämta elementen i ordning efter antalet förekomster.
I det här avsnittet kommer vi att diskutera följande
- Räkna det totala antalet element:
len() - Räkna antalet element (antalet förekomster av varje element):
count() - Användning.
collections.Counter - Elementen hämtas i den ordning de förekommer:
most_common() - Räkna antalet (typ) av icke överlappande element (unika element).
- Räkna antalet element som uppfyller villkoret.
Som ett konkret exempel förklaras dessutom följande med exempelkod.
- Räknar antalet förekomster av ett ord i en sträng.
- Räkna antalet förekomster av ett tecken i en sträng.
Exemplet är en lista, men samma behandling kan göras med tupler.
- Räkna det totala antalet element: len()
- Räkna antalet element (antalet förekomster av varje element): metoden count()
- Hur man använder collections.Counter
- Att få fram element i den ordning de förekommer: metoden most_common()
- Räkna antalet (typ) av icke överlappande element (unika element).
- Räkna antalet element som uppfyller villkoret.
- Räknar antalet förekomster av ett ord i en sträng.
- Räkna antalet förekomster av ett tecken i en sträng.
Räkna det totala antalet element: len()
Om du vill räkna det totala antalet element i en lista eller tupel använder du den inbyggda funktionen len().
l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
print(len(l))
# 7
Räkna antalet element (antalet förekomster av varje element): metoden count()
Om du vill räkna antalet element (antalet förekomster av varje element) använder du metoden count() för listor, tupler osv.
Om ett värde som inte finns som element skickas som argument returneras 0.
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
Om du vill få fram antalet förekomster av varje element på en gång är följande collection.Counter användbar.
Hur man använder collections.Counter
I Pythons standardbibliotek collections finns en klass Counter.
Counter() är en underklass till ordbokstypen dict, som har data i form av element som nycklar och förekomster som värden.
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
Om ett element anges som nyckel kan antalet element erhållas. Om ett värde som inte finns som element anges, returneras 0.
print(c['a'])
# 4
print(c['b'])
# 1
print(c['c'])
# 2
print(c['d'])
# 0
Du kan också använda metoder av ordbokstyp som keys(), values(), items() osv.
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)])
Dessa metoder returnerar objekt av typen dict_keys osv. De kan användas som de är om du vill köra ett for-uttalande. Om du vill konvertera dem till en lista använder du list().
Att få fram element i den ordning de förekommer: metoden most_common()
Counter har metoden most_common(), som returnerar en lista med tupler av formen (element, antal förekomster) sorterade efter antalet förekomster.
print(c.most_common())
# [('a', 4), ('c', 2), ('b', 1)]
Elementet med det högsta antalet förekomster kan erhållas genom att ange ett index, t.ex. [0] för det högsta antalet förekomster och [-1] för det lägsta antalet förekomster. Om du bara vill få fram elementen eller bara antalet förekomster kan du ange indexet ytterligare.
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
Om du vill sortera dem i fallande antal förekomster använder du snittet med ökningen inställd på -1.
print(c.most_common()[::-1])
# [('b', 1), ('c', 2), ('a', 4)]
Om argumentet n anges för metoden most_common() returneras endast de n element som har det högsta antalet förekomster. Om det utelämnas, återges alla element.
print(c.most_common(2))
# [('a', 4), ('c', 2)]
Om du vill ha en separat lista med element\occurrences ordnad efter antalet förekomster, i stället för en tupel av (element, antal förekomster), kan du dela upp den på följande sätt
values, counts = zip(*c.most_common())
print(values)
# ('a', 'c', 'b')
print(counts)
# (4, 2, 1)
Den inbyggda funktionen zip() används för att transponera en tvådimensionell lista (i det här fallet en lista med tupler) och sedan packa upp och extrahera den.
Räkna antalet (typ) av icke överlappande element (unika element).
Om du vill räkna hur många icke överlappande element (unika element) det finns i en lista eller tupel (hur många typer det finns) använder du Counter eller set() enligt beskrivningen ovan.
Antalet element i Counter-objektet är lika med antalet icke överlappande element i den ursprungliga listan, vilket kan erhållas med len().
l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
c = collections.Counter(l)
print(len(c))
# 3
Du kan också använda set(), konstruktören för set-typen set, vilket är enklare om du inte behöver ett Counter-objekt.
Uppsättningstypen är en datatyp som inte har dubbla element. Om du skickar en lista till set() ignoreras dubbla värden och returnerar ett objekt av typen set med endast unika värden som element. Antalet element av denna typ erhålls med len().
print(set(l))
# {'a', 'c', 'b'}
print(len(set(l)))
# 3
Räkna antalet element som uppfyller villkoret.
Om du vill räkna antalet element i en lista eller tupel som uppfyller ett visst villkor använder du listförståelsenotation eller generatoruttryck.
Som ett exempel kan du räkna antalet element med negativa värden för följande lista med tal
l = list(range(-5, 6))
print(l)
# [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
Om du tillämpar ett villkorligt uttryck på varje element i listförståelsenotationen får du en lista vars element är boolska booler (sant, falskt). Den booleska typen bool är en underklass till heltalstypen int, där sant behandlas som 1 och falskt som 0. Därför kan antalet sanna värden (antalet element som uppfyller villkoret) räknas genom att beräkna summan med sum().
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
Om vi ersätter [] i listförståelsen med () får vi ett generatoruttryck. List comprehension-notationen genererar en lista med alla element som behandlas, medan generatoruttrycket behandlar elementen sekventiellt och därför är mer minneseffektivt.
När generatoruttrycket är det enda argumentet kan () utelämnas, så det kan skrivas som i det senare fallet.
print(sum((i < 0 for i in l)))
# 5
print(sum(i < 0 for i in l))
# 5
Om du vill räkna antalet falska värden (antalet element som inte uppfyller villkoret) använder du not. Observera att > har högre prioritet än not (det beräknas först), så parenteserna () i (i < 0) i följande exempel är inte nödvändiga.
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
Naturligtvis kan villkoren i sig ändras.
print(sum(i >= 0 for i in l))
# 6
Några andra exempel visas nedan.
Exempel på hur man får fram antalet udda element i en lista med tal.
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
Exempel på ett villkor för en lista med strängar.
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
Counter används för att räkna baserat på antalet förekomster. items() hämtar en tupel av (element, antal förekomster), och antalet förekomster anger villkoret.
Nedan följer ett exempel på hur man extraherar element med två eller fler förekomster och räknar det totala antalet förekomster. I det här exemplet finns det fyra a:n och två c:n, vilket ger totalt sex.
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
Följande är ett exempel på hur man tar fram typer av element med två eller fler förekomster och räknar antalet förekomster. I det här exemplet finns det två typer, a och 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
Räknar antalet förekomster av ett ord i en sträng.
Som ett konkret exempel kan vi räkna antalet förekomster av ett ord i en sträng.
Ersätt först onödiga kommatecken och punkter med en tom sträng med metoden replace() och ta sedan bort dem. Använd sedan metoden split() för att skapa en lista som är separerad med mellanslag.
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']
Om du kan göra en lista kan du få reda på hur många gånger varje ord förekommer, vilka typer av ord som förekommer och most_common() i collections.Counter för att få reda på vilket ord som förekommer flest gånger.
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
Ovanstående är en mycket enkel process, så det är bättre att använda bibliotek som NLTK för mer komplex behandling av naturliga språk.
När det gäller japansk text kan split() inte heller användas för att dela upp texten eftersom det inte finns någon tydlig orddelning. Du kan till exempel använda Janome-biblioteket för att uppnå detta.
Räkna antalet förekomster av ett tecken i en sträng.
Eftersom strängar också är en sekvenstyp kan de användas med metoden count() eller skickas som argument till konstruktören av collections.Counter().
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})
Exempel på att hämta de fem mest frekvent förekommande tecknen.
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')
