Vill du skriva elegant och kompakt Python-kod? Här presenteras en samling praktiska Python-enradskoder för att utföra vanliga uppgifter.
Om du är nybörjare inom Python-programmering kommer du att spendera tid på att förstå grundläggande datastrukturer som listor och strängar. Vissa operationer på dessa strukturer kan utföras med korta, enradiga kodsnuttar.
Som programmerare bör du prioritera kodens läsbarhet och underhållbarhet framför att korta ner koden. Dock erbjuder Python möjligheten att skapa enradskoder som följer goda kodningsmetoder.
I den här artikeln kommer vi att fokusera på enradskoder för grundläggande bearbetning av listor och strängar i Python.
Låt oss börja!
Skapa en lista med siffror
Det enklaste sättet att generera en lista med siffror är genom att använda funktionen `range()`. Denna funktion returnerar ett range-objekt som kan omvandlas till en lista. Anropet `range(num)` ger en sekvens från 0 till `num-1`.
>>> siffror = list(range(10)) >>> siffror [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Mer om användning av `range()`-funktionen
Du kan också använda `range()`-funktionen med ett valfritt stegvärde. Anropet `range(start, slut, steg)` ger sekvensen `start`, `start + steg`, `start + 2*steg`, och så vidare. Det sista värdet blir `start + k*steg` så att `(start + k*steg) < slut` och `(start + (k+1)*steg) > slut`.
Hitta det största och minsta värdet i en lista
För att hitta det maximala och minimala elementet i en lista kan du använda de inbyggda funktionerna `max()` och `min()`.
>>> min_varde, max_varde = min(siffror), max(siffror) >>> min_varde 0 >>> max_varde 9
📑 Notera om multipel tilldelning
Lägg märke till att vi har tilldelat värden till både `min_varde` och `max_varde` i en enda tilldelningssats. Python stöder denna typ av multipel tilldelning. Detta kan vara användbart när man packar upp itererbara objekt och tilldelar värden till flera variabler samtidigt.
Ta bort dubbletter från en lista
En annan vanlig operation är att avlägsna dubbletter från listor i Python. Detta är användbart när man bara behöver arbeta med unika värden. Det enklaste sättet att uppnå detta är att konvertera listan till en mängd (set).
En mängd är en inbyggd datastruktur där alla element är unika och hashbara.
>>> siffror1 = [2,4,7,9,7,10]
I `siffror1` förekommer elementet 7 två gånger. Genom att omvandla den till en mängd tas dubbletten (7) bort, och vi får en samling med unika värden.
Eftersom vi fortfarande vill arbeta med en lista, konverterar vi tillbaka mängden till en lista. Denna operation kan utföras med följande enradskod:
>>> siffror1 = list(set(siffror1)) >>> siffror1 [2, 4, 7, 9, 10]
📒 För att lära dig mer om andra metoder för att avlägsna dubbletter från listor i Python, se den här guiden.
Räkna förekomster i en lista
För att räkna antalet gånger ett element förekommer i en lista kan du använda den inbyggda metoden `count()`. Anropet `list.count(elt)` returnerar antalet gånger `elt` förekommer i listan.
>>> siffror [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Här förekommer 7 en gång i listan `siffror`, så `count()`-metoden returnerar 1.
>>> siffror.count(7) 1
Kontrollera om alla element i listan uppfyller ett villkor
För att verifiera om alla element i en lista uppfyller ett visst villkor, kan du använda Pythons inbyggda funktion `all()`.
Funktionen `all()` tar en itererbar som argument och returnerar `True` om alla element i den itererbara utvärderas till `True` (eller är sanna).
Här vill vi kontrollera om alla element i listan `siffror2` är udda.
>>> siffror2 = [3,4,7,11,21,67,12]
Vi kan använda listomfattning för att skapa en lista med booleska värden och sedan skicka denna lista som argument till `all()`-funktionen.
Här kommer `num%2!=0` att vara `False` för elementen 4 och 12 som är jämna. Därför innehåller listan med booleska värden, som skapas med listomfattning, `False` (och `all(list)` returnerar `False`).
>>> all([num%2!=0 for num in siffror2]) False
💡 Notera att `all([])` (all(en tom itererbar) returnerar `True`.
Kontrollera om något element i listan uppfyller ett villkor
För att kontrollera om något element i en lista uppfyller ett villkor kan du använda funktionen `any()`. `any(lista)` returnerar `True` om minst ett element utvärderas till `True`.
>>> siffror2 = [3,4,7,11,21,67,12]
Som i föregående exempel använder vi listomfattning för att få en lista med booleska värden. Sifferlistan innehåller jämna tal. Så `any()`-funktionen returnerar `True`.
>>> any([num%2 for num in siffror2]) True
Vända en sträng
I Python är strängar oföränderliga, så när du vill vända en sträng kan du bara skapa en omvänd kopia av strängen. Det finns två vanliga metoder – som båda kan skrivas som Python-enradskoder – med hjälp av strängskivning och inbyggda funktioner.
Använda strängskivning
Strängskivning med negativa värden på steget returnerar en del av strängen från slutet. Syntaxen är `sträng[start:stop:step]`. Så vad returneras om vi sätter steget till -1 och ignorerar start- och stoppindexen?
Den returnerar en kopia av strängen, med början från slutet av strängen – och inkluderar varje tecken.
>>> sträng1[::-1] 'olleh'
Använda funktionen `reversed()`
Den inbyggda funktionen `reversed()` returnerar en omvänd iterator över en sekvens.
>>> reversed(sträng1) <reversed object at 0x008BAF70> >>> for char in sträng1: ... print(char) ... h e l l o
Du kan använda den tillsammans med `join()`-metoden som visas:
>>> ''.join(reversed(sträng1)) 'olleh'
Konvertera en sträng till en lista med tecken
Anta att vi vill dela upp en sträng till en lista med tecken. Vi kan göra det med hjälp av listomfattning.
>>> sträng1 = 'hello'
Listomfattning är en av de mest kraftfulla enradskoderna i Python.
📒 Lär dig mer om listomfattning i Python.
Vi itererar genom strängen och samlar in varje tecken.
>>> chars = [char for char in sträng1] >>> chars ['h', 'e', 'l', 'l', 'o']
För att dela upp en längre sträng i en lista med strängar vid varje förekomst av blanksteg kan du använda metoden `split()`.
>>> sträng2 = 'hello world' >>> sträng2.split() ['hello', 'world']
Extrahera siffror från en sträng
Vi har redan sett hur man använder listomfattning för att dela upp en sträng i en lista med tecken. I det exemplet samlade vi in alla tecken genom att iterera genom strängen.
Här måste vi iterera genom strängen och endast samla in siffrorna. Hur gör vi det?
- Vi kan ange ett filtreringsvillkor i listomfattningsuttrycket med metoden `isdigit()`.
- `c.isdigit()` returnerar `True` om `c` är en siffra; annars returneras `False`.
>>> sträng3 = 'python3' >>> siffror = [c for c in sträng3 if c.isdigit()] >>> siffror ['3']
Kontrollera om en sträng börjar med en specifik delsträng
För att kontrollera om en sträng börjar med en specifik delsträng kan du använda strängmetoden `startswith()`. Anropet `sträng1.startswith(delsträng)` returnerar `True` om `sträng1` börjar med `delsträng`. Annars returneras `False`.
Här är ett par exempel:
>>> sträng4 = 'coding'
>>> sträng4.startswith('co')
True
>>> sträng5 = 'python'
>>> sträng5.startswith('co')
False
Kontrollera om en sträng slutar med en specifik delsträng
Som du kanske anar kan du använda metoden `endswith()` för att kontrollera om en sträng slutar med en given delsträng.
>>> sträng5 = 'python'
>>> sträng5.endswith('on')
True
Vi kan också använda strängmetoden i ett listomfattningsuttryck för att få `slutar_med`, en lista med booleska värden.
>>> strängar = ['python','neon','nano','silicon']
>>> slutar_med = [str.endswith('on') for str in strängar]
>>> slutar_med
[True, True, False, True]
Sammanfoga element i en lista till en sträng
Vi har redan sett hur man delar upp en sträng i en lista med tecken. Hur gör vi nu den omvända operationen – att sammanfoga elementen i en lista till en sträng?
För att göra detta kan du använda strängmetoden `join()` med syntaxen: `separator.join(lista)`.
Vi vill bara kombinera elementen i listan till en enda sträng; vi behöver ingen separator. Så vi sätter separatorn till en tom sträng.
>>> lista_1 = ['p','y','t','h','o','n','3'] >>> ''.join(lista_1) 'python3'
Skapa en Python-ordbok
Precis som listomfattningar kan hjälpa oss att skapa nya listor från befintliga itererbara objekt, kan ordboksomfattningar hjälpa oss att skapa nya ordböcker från befintliga itererbara objekt.
Python-ordboksomfattningar är kraftfulla enradskoder som kan hjälpa till att skapa en ordbok i farten.
Här har vi `namn`, en lista med strängar.
>>> namn = ['Joe','Amy','Jake','Florence']
Vi skapar `namn_d`, en ordbok som innehåller namnsträngar som nycklar och längden på strängarna som värde.
>>> namn_d = {name:len(name) for name in namn}
>>> namn_d
{'Joe': 3, 'Amy': 3, 'Jake': 4, 'Florence': 8}
Villkorligt tilldela värden till variabler
Ibland kan du behöva tilldela värden till variabler beroende på ett specifikt villkor.
Till exempel kan du läsa in användarinmatning, säg en persons ålder. Beroende på det inlästa värdet kan du avgöra om personen får delta i en fest eller inte.
För att utföra denna villkorliga tilldelning i Python kan du skriva följande enradskod med den ternära operatorn.
>>> ålder = 21 >>> tillåten = True if ålder >= 18 else False >>> tillåten True
🔖 Lär dig mer om den ternära operatorn i Python.
Generera alla permutationer
Permutation refererar till en möjlig ordning av elementen i en grupp. Om det finns n unika element i en grupp finns det n! möjliga sätt att ordna dem – och därmed n! permutationer.
Låt oss använda följande lista med bokstäver:
>>> bokstäver = ['a','b','c']
Du kan använda `permutations` från modulen `itertools` för att generera alla möjliga permutationer av den givna itererbara.
>>> bokstäver_p = permutations(bokstäver) >>> bokstäver_p <itertools.permutations object at 0x0127AF50>
Som vi ser, genom att använda `permutations(iterable)` returneras ett permutationsobjekt som vi kan iterera igenom med en for-loop:
>>> for p in bokstäver_p:
... print(p)
...
('a', 'b', 'c')
('a', 'c', 'b')
('b', 'a', 'c')
('b', 'c', 'a')
('c', 'a', 'b')
('c', 'b', 'a')
Men vi kan skriva om det som ett enradsuttryck genom att konvertera permutationsobjektet till en lista:
>>> bokstäver_p = list(permutations(bokstäver))
>>> bokstäver_p
[('a', 'b', 'c'), ('a', 'c', 'b'), ('b', 'a', 'c'), ('b', 'c', 'a'), ('c', 'a', 'b'), ('c', 'b', 'a')]
Här finns tre unika element, och det finns 3! = 6 möjliga permutationer.
Generera delmängder av en lista
Ibland kan du behöva skapa alla möjliga delmängder av en viss storlek från en lista eller andra itererbara objekt. Låt oss använda listan med bokstäver och få alla underlistor med storlek 2.
För att göra det kan vi använda `combinations` från modulen `itertools`, så här:
>>> from itertools import combinations
>>> bokstäver_2 = list(combinations(bokstäver,2))
>>> bokstäver_2
[('a', 'b'), ('a', 'c'), ('b', 'c')]
Slutsats
I den här handledningen gick vi igenom praktiska Python-enradskoder för att utföra vanliga operationer på listor och strängar. Vi har också lärt oss om Python-listor och ordboksomfattningar och hur man använder dem i kombination med inbyggda funktioner för att utföra önskade uppgifter.
Som ett nästa steg, kolla in den här listan över nybörjarvänliga Python-projekt.