När du hanterar itererbara objekt i Python, är det en vanlig uppgift att fastställa antalet element de innehåller. Utforska hur du kan utnyttja Pythons inbyggda `len()`-funktion för att erhålla längden på dessa objekt, och mycket mer.
Python tillhandahåller ett brett sortiment av inbyggda datastrukturer och metoder för att manipulera dem. Utöver detta finns det även praktiska inbyggda funktioner som underlättar arbetet med dessa strukturer. En sådan funktion är `len()`, vilken returnerar antalet element i en itererbar.
I den här handledningen kommer vi att granska hur man använder `len()`-funktionen med listor, tupler, strängar och andra datatyper. Vi kommer även att undersöka några typiska användningsområden.
Låt oss börja! 👩🏫
Syntax för Pythons `len()`-funktion
Här visas den grundläggande syntaxen för hur man använder `len()`-funktionen i Python:
len(itererbart)
Som du ser tar `len()`-funktionen en enda parameter, vilken måste vara ett giltigt itererbart objekt. Detta är ofta en lista, en tupel, eller en sträng, men kan även vara andra typer av objekt som kan itereras.
Användningen av `len()`-funktionen är alltså mycket enkel. Låt oss nu gå vidare och undersöka några konkreta exempel.
📑 Du kan köra kodexemplen i den här handledningen i en Python REPL för att öva samtidigt.
Använda `len()`-funktionen med itererbara objekt
Med sekvenser
Du kan använda `len()`-funktionen för att beräkna längden på sekvenser som listor, tupler och strängar.
Här är ett exempel:
>>> siffror = [9,3,6,1,2] >>> len(siffror) 5 >>> siffer_tupel = (9,3,6,1,2) >>> len(siffer_tupel) 5
När det gäller dessa datastrukturer som lagrar en sekvens, kommer du vanligtvis att komma åt elementen via deras index eller hämta en delsekvens efter behov.
Med andra samlingar
Du kan även använda `len()`-funktionen med andra Python-samlingar som set och ordböcker.
Dessa datastrukturer är oordnade samlingar. Även om du kanske inte är intresserad av den interna ordningen, kan det vara värdefullt att veta det totala antalet element i samlingen.
>>> siffer_set = set(siffror)
>>> len(siffer_set)
5
>>> priser = {'Anteckningsbok':5,'Pennfodral':7,'Bokmärken':3,'Pennor':1,'Markörer':8}
>>> len(priser)
5
Vanliga användningsområden för Pythons `len()`-funktion
Hittills har vi sett grundläggande exempel på hur man använder `len()`-funktionen för att få reda på antalet element i en itererbar. Låt oss nu titta på några praktiska tillämpningar.
#1. Användning i iteration med `for`-loopar
Pythons `for`-loop tillhandahåller ett sätt att iterera genom itererbara objekt med syntaxen `for element in itererbart`. Men om du vill komma åt indexet för varje element istället för själva elementet, eller både index och element, kan du använda `range()`-funktionen på följande vis:
>>> siffror = [9,2,4,7,8]
>>> for i in range(len(siffror)):
... print(f"Index {i}: {siffror[i]}")
Eftersom `range(N)` genererar en sekvens av heltal från 0 upp till `N – 1`, ger `range(len(siffror))` oss alla giltiga index att iterera igenom.
# Output Index 0: 9 Index 1: 2 Index 2: 4 Index 3: 7 Index 4: 8
Det rekommenderade Pythoniska sättet att komma åt både index och element är dock att använda `enumerate`-funktionen:
>>> siffror = [9,2,4,7,8]
>>> for idx, num in enumerate(siffror):
... print(f"Index {idx}: {num}")
# Output Index 0: 9 Index 1: 2 Index 2: 4 Index 3: 7 Index 4: 8
#2. Villkorlig loopning med `while`-loopar
Antag att du har en lista med siffror, `siffror`. Listmetoden `pop()` tar bort och returnerar det sista elementet i listan.
Så länge som längden på `siffror`-listan, `len(siffror)`, är större än noll, finns det minst ett element som kan tas bort.
>>> siffror = [9,2,4,7,8] >>> while len(siffror) > 0: ... print(siffror.pop())
# Output 8 7 4 2 9
Ovanstående exempel är ett mer explicit sätt att skriva följande:
>>> siffror = [9,2,4,7,8] >>> while siffror: ... print(siffror.pop())
`while siffror:` motsvarar villkoret ”så länge som `siffror`-listan inte är tom”.
#3. Kontrollera och validera längden på itererbara objekt
Ett annat vanligt användningsområde för `len()`-funktionen är att kontrollera och validera längden på olika itererbara objekt.
Här kontrollerar vi om ett användarnamn är en giltig sträng baserat på dess längd (beräknad med `len()`):
>>> användarnamn = "ett-annat-slumpmässigt-namn"
>>> if len(användarnamn) > 10:
... print("Användarnamnet är för långt; det får vara högst 10 tecken.")
... elif len(användarnamn) < 5:
... print("Användarnamnet är för kort; det ska vara minst 5 tecken långt.")
... else:
... print("Giltigt användarnamn!")
Användarnamnet är för långt; det får vara högst 10 tecken.
#4. List- och ordboksförståelse
List- och ordboksförståelse i Python erbjuder ett kompakt syntax för att generera nya itererbara objekt från befintliga. Vi kan använda inbyggda funktioner i ett förståendeuttryck.
Listförståelse
I denna listförståelse använder vi `len()`-funktionen för att erhålla längden på varje sträng i listan `språk`.
>>> språk = ['Python','C','Rust','JavaScript'] >>> längder_språk = [len(språk) for språk in språk] >>> längder_språk [6, 1, 4, 10]
Ordboksförståelse
I denna ordboksförståelse använder vi listan `språk` och funktionen `len()` för att skapa en ordbok:
>>> språk = ['Python','C','Rust','JavaScript']
>>> språk_längd = {språk:len(språk) for språk in språk}
>>> språk_längd
{'Python': 6, 'C': 1, 'Rust': 4, 'JavaScript': 10}
Här är nycklarna och värdena strängarna för språken respektive längden på språksträngarna.
#5. Nyckelparameter i anpassad sortering
Python har den inbyggda metoden `sort()` för att sortera Python-listor på plats, och `sorted()`-funktionen för att sortera listor och andra itererbara objekt.
I båda fallen kan du använda nyckelparametern för att anpassa sorteringen.
Här sorterar vi listan av språk baserat på längden på strängarna.
>>> språk = ['Python','C','Rust','JavaScript'] >>> språk.sort(key=len) >>> språk ['C', 'Rust', 'Python', 'JavaScript']
I kodsnutten nedan använder vi `sorted()`-funktionen för att erhålla en sorterad lista.
>>> språk = ['Hindi','Engelska','Tyska','Franska'] >>> sorted(språk, key=len) ['Hindi', 'Tyska', 'Franska', 'Engelska']
I det här exemplet har både ”tyska” och ”franska” 6 tecken vardera. Eftersom `sorted()`-funktionen utför stabil sortering bibehålls den ursprungliga ordningen inom listan.
#6. Längd på NumPy-arrayer
Du kan även använda `len()`-funktionen med andra datastrukturer som NumPy-arrayer.
>>> import numpy as np >>> np_array = np.array([3,4,6,9]) >>> type(np_array) <class 'numpy.ndarray'> >>> len(np_array) 4
I det här fallet är `np_array` en vektor med 4 element. Så `len(np_array)` returnerar 4, antalet element i arrayen.
En matris är en tvådimensionell array.
Betrakta följande exempel. `len(np_array)` är 2, vilket är antalet rader.
>>> matris = [[1,2,3],[4,5,6]]
>>> np_array = np.array(matris)
>>> np_array
array([[1, 2, 3],
[4, 5, 6]])
>>> len(np_array)
2
För att förstå, låt oss gå tillbaka till matrisen. Vi har en kapslad liststruktur där den yttre listan innehåller två inkapslade listor. `len()`-funktionen returnerar antalet objekt i en container (här två listor):
>>> help(len)
Help on built-in function len in module builtins:
len(obj, /)
Return the number of items in a container.
Men när du börjar arbeta med flerdimensionella arrayer, rekommenderas det att använda attributet `shape` istället.
>>> np_array.shape (2, 3)
Vanliga fallgropar att undvika när du använder Pythons `len()`-funktion
Avslutningsvis, låt oss gå igenom några vanliga fallgropar som du bör undvika när du använder `len`-funktionen i Python.
Använda `len()` med icke-itererbara datatyper
Vi vet att `len`-funktionen endast accepterar giltiga itererbara objekt som argument. Det betyder att om du anropar `len()`-funktionen med en icke-itererbar datatyp, kommer du att stöta på ett fel.
Sådana ogiltiga typer inkluderar grundläggande datatyper som heltal, flyttal och booleaner:
>>> len(2) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: object of type 'int' has no len() >>> len(True) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: object of type 'bool' has no len() >>> len(3.14) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: object of type 'float' has no len()
I Python är generatorer ett minneseffektivt alternativ för användningsområden som kräver sekvensgenerering. Generatorobjektet returnerar elementen i sekvensen – på begäran – ett element i taget. Men generatorobjekt har inte en inneboende längd.
Du kommer därför att få ett fel om du försöker beräkna längden på ett generatorobjekt:
>>> siffror_kvadrat = (i*i for i in range(10)) >>> siffror_kvadrat <generator object <genexpr> at 0x0157DBC0> >>> len(siffror_kvadrat) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: object of type 'generator' has no len()
Använda `len()` med tupler av längd ett
Om du endast infogar ett element i en tupel, kommer Python att tolka det som ett enskilt element och inte som en tupel.
Här är ett exempel:
>>> siffror = (1) >>> len(siffror) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: object of type 'int' has no len()
Så när du har en tupel med endast ett element, initialisera den i denna form: `tupel_namn = (element,)` så att det tolkas som en tupel:
>>> siffror = (1,) >>> len(siffror) 1
Sammanfattning
Här är en sammanfattning av det vi har behandlat i den här handledningen:
- Du kan ta reda på antalet element i vilket itererbart objekt som helst med hjälp av funktionen `len()` i Python. Syntaxen för att använda längdfunktionen är: `len(valfritt-giltigt-itererbart-objekt)`.
- Detta inkluderar sekvenser som listor, tupler och strängar, men även andra samlingar som ordböcker och set.
- Funktionen `len()` används ofta i loopar och listförståelser.
- Du kan också använda `len()` som nyckelparameter när du behöver anpassa sorteringen efter längd. Till exempel: att sortera en lista med strängar baserat på deras längd.
Nästa steg är att lära sig hur man använder Pythons `sum()`-funktion.