30 smarta Python-tricks för bättre kod med exempel

Efterfrågan på Python-kunskaper har ökat de senaste åren. För att hjälpa dig att utveckla dina Python-kunskaper har vi samlat 30 smarta Python-tricks som du kan använda för att förbättra din kod. Försök att lära dig ett om dagen i 30 dagar och kolla in vårt inlägg om bästa praxis i Python för att säkerställa att din kod håller toppklass. 

Om dina Python-kunskaper behöver slipas kan du också vässa dem med vår Python Skill Track.

Tricks för sekvenser och datastrukturer

#1 Slicing

a = "Hello World!"
print(a[::-1])

"""
!dlroW olleH
"""

Slicing är en funktion i Python som bygger på indexering och låter dig komma åt en delmängd av en sekvens. Ett index är helt enkelt positionen för ett element i en sekvens. Om sekvenstypen är muterbar kan du använda slicing för att extrahera och ändra data. 

Obs: Vi kan också använda slicing på en omuterbar sekvens, men att försöka ändra slicen kommer att utlösa en TypeError. 

Formatet för slicing är: sequence[start:stop:step]. Om inga värden anges i parametrarna start, stop och step används standardvärden. Standardvärdena är: 

• "start" är 0 
• "stop" är sekvensens längd
• "step" är 1 om inget anges. 

När du anger sequence[start:stop] returneras elementen från startindex upp till stop - 1 (stop-indexet inkluderas inte). 

Vi kan också använda negativa index, vilket kan användas för att vända sekvensen. Till exempel, i en lista med 4 element är index 0 även index -4, och sista index är även -1. I kodexemplet ovan tillämpades detta på step-parametern. Därför skrevs strängen ut baklänges, från slutet av sekvensen till index 0.   

#2 In-place-byte / samtidig tilldelning

a = 10
b = 5
print(f"First: {a, b}")

"""
First: (10, 5)
"""

a, b = b, a + 2
print(f"Second: {a, b}")

"""
Second: (5, 12)
"""

Om din första tanke var att värdet på b skulle bli 7 i stället för 12 har du gått i fällan med in-place-byte. 

I Python kan vi packa upp iterabler till variabler i en enda tilldelning med automatisk uppackning. Till exempel: 

a, b, c = [1, 2, 3]
print(a)
print(b)
print(c)

"""
1
2
3
"""

Vi kan också samla flera värden i en enda variabel med * – detta Python-trick kallas packning. Nedan är ett exempel på packning.  

a, *b = 1, 2, 3
print(a, b)
"""
1 [2, 3]
"""

Kombinationen av automatisk packning och uppackning ger en teknik som kallas samtidig tilldelning. Vi kan använda samtidig tilldelning för att tilldela en serie värden till en serie variabler.

#3 Lista vs. tuples 

import sys

a = [1, 2, 3, 4, 5]
b = (1, 2, 3, 4, 5)

print(f"List size: {sys.getsizeof(a)} bytes")
print(f"Tuple size: {sys.getsizeof(b)} bytes")

"""
List size: 52 bytes
Tuple size: 40 bytes
"""

De flesta Python-programmerare känner till datastrukturen lista. Samma sak kan inte sägas om tuples. Båda är iterabler, tillåter indexering och kan lagra heterogena datatyper. Men det finns situationer där en tuple kan vara att föredra framför en lista. 

För det första är listor muterbara, vilket betyder att vi kan ändra dem som vi vill: 

a = [1,2,3,4,5]
a[2] = 8
print(a)

"""
[1,2,8,4,5]
"""

Tuples, å andra sidan, är omuterbara, vilket betyder att försök att ändra dem utlöser en TypeError. 

Av denna anledning är tuples mer minneseffektiva eftersom Python kan allokera exakt den minnesmängd som krävs för datan. I en lista måste extra minne allokeras ifall vi utökar den – detta kallas dynamisk minnesallokering. 

Kort sagt: I scenarier där du inte vill att datan ska ändras bör en tuple föredras framför en lista av minnesskäl. Tuples är också snabbare än listor. 

Lär dig mer om Pythons datastrukturer i denna tutorial. 

#4 Generatorer

a = [x * 2 for x in range(10)]
b = (x * 2 for x in range(10))

print(a)
print(b)

"""
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
<generator object <genexpr> at 0x7f61f8808b50>
"""

Listkomprehensioner är det Pythoniska sättet att skapa en lista från en annan iterabel – det är mycket snabbare än en for-loop. Men vad händer om du av misstag byter hakparenteser [] till runda ()? Du får ett generatorobjekt.

I Python skapar runda parenteser med listkomprehensionslogik det som kallas ett generatorobjekt. Generatorer är en speciell typ av iterabel. Till skillnad från listor lagrar de inte sina element. I stället lagrar de instruktioner för att generera varje element i tur och ordning och det aktuella läget i iterationen.

Varje element genereras endast vid behov med en teknik som kallas lazy evaluation. Huvudfördelen med detta Python-tips med en generator är att det använder mindre minne eftersom hela sekvensen inte byggs upp på en gång. 

#5 Alias 

a = [1, 2, 3, 4 ,5]
b = a

# Change the 4th index in b
b[4] = 7

print(id(a))
print(id(b))
print(a) # Remember we did not explicitly make changes to a.

"""
15136008
15136008
[1, 2, 3, 4, 7]
"""

Python är ett objektorienterat programspråk – allt är ett objekt. Att tilldela ett objekt till en identifierare skapar därför en referens till objektet. 

När vi tilldelar en identifierare till en annan får vi två identifierare som refererar till samma objekt. Detta kallas alias. Ändringar i det ena aliaset påverkar det andra. Ibland är detta önskat beteende, men ofta överraskar det oss. 

Ett sätt att undvika det är att avstå från alias när du använder muterbara objekt. En annan lösning kan vara att skapa en klon av originalobjektet i stället för en referens. 

Det enklaste sättet att skapa en klon är att utnyttja slicing: 

b = a[:] 

Detta skapar en ny referens till ett listobjekt i identifieraren b. 

Du kan även använda andra lösningar, som att anropa list(a) när du tilldelar datan till en annan identifierare eller använda metoden copy(). 

#6 Operatorn ”not”

a = []
print(not a)

"""
True
"""

Vårt nästa Python-tips är det enklaste sättet att kontrollera om din datastruktur är tom genom att använda not-operatorn. Pythons inbyggda not är en logisk operator som returnerar True om uttrycket inte är sant, annars returnerar den False – den inverterar sanningsvärdet hos booleska uttryck och objekt.  

Ett annat sätt du kan se den användas är i en if-sats: 

if not a:
    # do something... 

När a är True returnerar not-operatorn False, och vice versa. 

Det kan vara lite klurigt att greppa, så testa själv.

Sträng- och utskriftstricks

#7 F-strängar

first_name = "John"
age = 19

print(f"Hi, I'm {first_name} and I'm {age} years old!")

"""
Hi, I'm John and I'm 19 years old!
"""

Ibland behöver vi formatera en sträng; Python 3.6 introducerade en smart funktion som kallas f-strängar för att förenkla detta. Det hjälper att förstå hur strängar formaterades innan den nya versionen för att uppskatta den nya metoden bättre. 

Så här brukade strängar formateras: 

first_name = "John"
age  = 19

print("Hi, I'm {} and I'm {} years old!".format(first_name, age))

"""
Hi, I'm John and I'm 19 years old!
"""

I grunden är det nya sättet snabbare, mer läsbart, mer koncist och svårare att göra fel.

En annan användning av f-strängar är att skriva ut ett variabelnamn tillsammans med dess värde. Detta introducerades i Python 3.8.

x = 10
y = 20
print(f"{x = }, {y = }")

"""
x = 10, y = 20
"""

Kolla in den här guiden om f-strängsformatering i Python för att lära dig mer. 

#8 Parametern ’end’ i print()

languages = ["english", "french", "spanish", "german", "twi"]
print(' '.join(languages))

"""
english french spanish german twi
"""

Det är ganska vanligt att använda print utan att definiera några av dess valfria parametrar. Följaktligen är många Pythonistas omedvetna om att du kan styra utskriften till viss del.

En valfri parameter vi kan ändra är end. Parametern end anger vad som ska visas i slutet av ett anrop till print. 

Standardvärdet för end är "\n" som säger åt Python att börja på en ny rad. I koden ovan ändrade vi det till ett mellanslag. Därför skrevs alla element i listan ut på samma rad.

#9 Lägga till i en tuple

a = (1, 2, [1, 2, 3])
a[2].append(4)
print(a)

"""
(1, 2, [1, 2, 3, 4])
"""

Vi vet redan att tuples är omuterbara – se Python-tricket #3 Lista vs. Tuples. Försök att ändra en tuple skulle kasta en TypeError. Men om du ser en tuple som en sekvens av namn bundna till objekt som inte kan bytas ut, kan du se det annorlunda.

De två första elementen i vår tuple är heltal – de är omuterbara. Det sista elementet är en lista, ett muterbart objekt i Python.

Om vi betraktar vår lista som bara ett annat namn i en sekvens med en bindning till ett objekt som inte kan bytas ut, inser vi att listan fortfarande kan ändras inifrån tuplen.

Skulle vi rekommendera att göra detta i praktiken? Troligen inte, men det är bra att känna till!

#10 Slå ihop ordböcker

a = {"a": 1, "b": 2}
b = {"c": 3, "d": 4}

a_and_b = a | b
print(a_and_b)

"""
{"a": 1, "b": 2, "c": 3, "d": 4}
"""

I Python 3.9 och senare är det möjligt att slå ihop ordböcker med | (bitvis OR). Det finns inte så mycket mer att säga om just detta Python-trick än att det är en betydligt mer läsbar lösning! 

Kodstil och syntaxtricks

#11 Ternär operator / villkorsuttryck 

condition = True
name = "John" if condition else "Doe"

print(name)

"""
John
"""

I koden ovan ser du det som kallas en ternär operator – den kallas också villkorsuttryck. Vi använder ternära operatorer för att utvärdera saker baserat på om ett villkor är True eller False.

Ett annat sätt vi hade kunnat skriva vår kod är så här:

condition = True
if condition:
    name = "John"
else:
    name = "Doe"

print(name)
"""
John
"""

Även om båda kodavsnitten ger samma resultat, lägg märke till hur den ternära operatorn låter oss skriva mycket kortare och tydligare kod. Det är vad Pythonistas skulle kalla ett mer ”Pythoniskt” sätt att skriva kod. 

#12 Ta bort dubletter från listor

a = [1, 1, 2, 3, 4, 5, 5, 5, 6, 7, 2, 2]
print(list(set(a)))

"""
[1, 2, 3, 4, 5, 6, 7]
"""

Det enklaste sättet att ta bort dubbletter från en lista är att konvertera listan till en mängd (set) och sedan tillbaka till en lista om du vill.

Baserat på muterbarhet är set och listor ganska lika i Python. Vi kan lägga till och ta bort element från båda datastrukturerna som vi vill, men de är ändå väldigt olika.

Listor är ordnade, nollindexerade och muterbara. Set är oordnade och oindexerade. Elementen i ett set måste vara av en omuterbar typ, även om setet i sig är muterbart – försök att hämta ett element via index eller ändra ett element ger ett fel.

En annan viktig skillnad mellan set och listor är att set inte kan innehålla dubbletter. Det är detta som hjälpte oss att ta bort dubbletter från vår lista.

#13 Ensamt understreck 

>>> print(_)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>

>>> 1 + 2
3

>>> print(_)
3

Understreck (_) är en giltig identifierare i Python, så det går att använda det för att referera till ett objekt. Men understrecket har också en annan uppgift: att lagra resultatet av den senaste utvärderingen.

Dokumentationen säger att ”den interaktiva tolken gör resultatet av den senaste utvärderingen tillgängligt i variabeln _. (Det lagras i builtins-modulen, tillsammans med inbyggda funktioner som print).”

Eftersom vi inte hade tilldelat understrecket något objekt innan vi anropade det på första raden fick vi ett fel. Men när vi beräknade resultatet av 1 + 2 lagrade tolken resultatet i identifieraren _ åt oss. 

#14 Understreck för att ignorera värden

for _ in range(100):
    print("The index doesn't matter")

"""
The index doesn't matter
The index doesn't matter
...
"""

I Python-tips #13 såg vi att den interaktiva tolken gör senaste resultatet tillgängligt i identifieraren (_), men det är inte dess enda användningsområde.

Vi kan också använda det för att representera objekt vi inte bryr oss om eller inte kommer att använda senare i programmet. Detta är viktigt eftersom användning av en identifierare i stället för ett understreck (_) kommer att ge ett F841-fel när vi lintar vårt program. Ett F841-fel betyder helt enkelt att ett lokalt variabelnamn har tilldelats men inte använts i programmet, vilket anses vara dålig praxis.

#15 Avslutande understreck

list_ = [0, 1, 2, 3, 4]
global_ = "Hi there" 

Fortsatt från de två senaste tricken om understreckets (_) användning: ett annat syfte är att undvika konflikter med Python-nyckelord. 

PEP 8 nämner att ett avslutande understreck (_) bör ”användas enligt konvention för att undvika konflikter med Python-nyckelord.” Det står också att ”det är i allmänhet bättre att lägga till ett avslutande understreck än att använda en förkortning eller förvanskning. Alltså är list_ bättre än lst.”

#16 Inledande understreck

class Example:
    def __init__(self):
        self._internal = 2
        self.external = 20

Du ser ofta att erfarna Python-programmerare sätter ett understreck före ett identifierar- eller metodnamn – och med god anledning.

Understrecket före en identifierare eller metod har en dold innebörd: denna variabel eller metod är endast avsedd för internt bruk. I grunden är det en brasklapp till andra programmerare som definieras i PEP 8 men inte upprätthålls av Python. Därför är inledande understreck en svag markör.

Till skillnad från Java har Python inte en stark åtskillnad mellan privata och publika variabler. Med andra ord har det bara mening för att Python-communityt har kommit överens om det. Deras förekomst påverkar inte programmets beteende.

#17 Understreck som visuell separator

Här är sista tipset om understreck; Hittills har vi täckt tre olika användningsområden, men du kan läsa mer i vår tutorial om underskårets roll (_) i Python. 

number = 1_500_000
print(number)

"""
15000000
"""

Ett annat sätt att använda understrecket är som visuell avskiljare för siffergruppering i heltals-, flyttals- och komplexa tal-litteraler – detta introducerades i Python 3.6. 

Tanken var att underlätta läsbarheten för långa litteraler, eller litteraler vars värde tydligt bör delas upp i delar – du kan läsa mer i PEP 515.

Kodstil och syntaxtricks

#18 __name__ == ”__main__” 

if __name__ == "__main__":
    print("Read on to understand what is going on when you do this.")

"""
print("Read on to understand what is going on when you do this.")
"""

Det är stor chans att du sett denna syntax i flera Python-program; Python använder ett särskilt namn, "__main__", och sätter det till identifieraren __name__ om Python-filen som körs är huvudprogrammet.

Om vi importerar modulen som visas i skärmbilden till en annan modul (Python-fil) och kör den filen, blir uttrycket i vår kod falskt. Detta eftersom när vi importerar från en annan modul sätts identifieraren __name__ till modulens namn (Python-filen). 

#19 Metoden ’setdefault’ 

import pprint

text = "It's the first of April. It's still cold in the UK. But I'm going to the museum so it should be a wonderful day"

counts = {}
for word in text.split():
    counts.setdefault(word, 0)
    counts[word] += 1

pprint.pprint(counts)

"""
{'April.': 1,
'But': 1,
"I'm": 1,
"It's": 2,
'UK.': 1,
'a': 1,
'be': 1,
'cold': 1,
'day': 1,
'first': 1,
'going': 1,
'in': 1,
'it': 1,
'museum': 1,
'of': 1,
'should': 1,
'so': 1,
'still': 1,
'the': 3,
'to': 1,
'wonderful': 1}
"""

Du kanske vill sätta ett värde för olika nycklar i en ordbok. Till exempel när du spårar ordantal i en korpus. Det vanliga sättet att göra detta är så här: 

1. Kontrollera om nyckeln finns i ordboken
2. Om den gör det, öka värdet med 1.
3. Om inte, lägg till den och sätt värdet till 1.

Så här ser det ut i kod:

counts = {}
for word in text.split():
    if word in counts:
        counts[word] += 1
    else:
      counts[word] = 1

Ett mer koncist sätt är att använda metoden setdefault() på din ordbok.

Det första argumentet till metoden är nyckeln vi vill kontrollera. Det andra argumentet är värdet som sätts om nyckeln inte redan finns i ordboken – om nyckeln finns returnerar metoden nyckelns värde. Därmed ändras det inte.

Tricks för programstruktur

#20 Matcha regex

import re

number = re.compile(r"(0)?(\+44)?\d{10}")
num_1 = number.search("My number is +447999999999")
num_2 = number.search("My number is 07999999999")

print(num_1.group())
print(num_2.group())

"""
'+447999999999'
'07999999999'
"""

Reguljära uttryck låter dig ange ett textmönster att söka efter; De flesta vet att vi kan söka med CTRL + F (Windows), men om du inte vet exakt vad du söker efter, hur ska du hitta det? Svaret är att söka efter mönster.  

Till exempel följer brittiska nummer ett liknande mönster: de har en nolla i början plus tio siffror, eller +44 i stället för noll och tio siffror – det senare indikerar internationellt format. 

Reguljära uttryck sparar mycket tid. Om vi skulle koda regler för att fånga fallen i vår bild i stället för regex kan det ta 10+ rader kod. 

Att lära sig hur reguljära uttryck fungerar är viktigt även om du inte skriver kod. De flesta moderna textredigerare och ordbehandlare låter dig använda reguljära uttryck i sök- och ersätt-funktioner.

#21 Regex-pipe

import re

heros = re.compile(r"Super(man|woman|human)")

h1 = heros.search("This will find Superman")
h2 =  heros.search("This will find Superwoman")
h3 = heros.search("This will find Superhuman")

print(h1.group())
print(h2.group())
print(h3.group())

"""
Superman
Superwoman
Superhuman
"""

Reguljära uttryck har ett specialtecken som kallas pipe (|) som låter dig matcha ett av flera uttryck, och de kan användas var som helst. Detta är superpraktiskt när du har flera liknande mönster.

Till exempel har ”Superman”, ”Superwoman” och ”Superhuman” alla samma prefix. Du kan därför använda pipe för att behålla den återkommande delen av mönstret och variera de delar som behöver vara olika. Återigen sparar det värdefull tid.

Varning: om alla uttryck du vill matcha förekommer i samma text, returneras den första förekomsten som matchar – d.v.s. ”An example text containing Superwoman, Superman, Superhuman” skulle returnera Superwoman.

#22 Parametern ’sep’ i print()

day = "04"
month = "10"
year = "2022"

print(day, month, year)
print(day, month, year, sep = "")
print(day, month, year, sep = ".")

"""
04 10 2022
04/10/2022
04.10.2022
"""

Antalet Python-programmerare som inte känner till print()-funktionens fulla möjligheter är skrämmande; Om ”Hello World” var ditt första program var print() sannolikt en av de första inbyggda funktionerna du gick igenom när du lärde dig Python. Vi använder print() för att visa formaterade meddelanden på skärmen, men funktionen kan mycket mer. 

I koden ovan visar vi olika sätt att visa vårt formaterade meddelande. Parametern sep är ett valfritt argument i print() som låter oss ange hur objekt ska separeras om vi inkluderar fler än ett. 

Standard är att separera dem med ett mellanslag, men vi har ändrat detta i våra utskrifter – ett där sep är satt till "" och ett annat där sep är satt till ".".

#23 Lambda-funktioner 

def square(num:int) -> int:
    return num ** 2

print(f"Function call: {square(4)}")
"""
Function call: 16
"""

square_lambda = lambda x: x**2
print(f"Lambda function: {square_lambda(4)}")
"""
Lambda functional: 16
"""

Lambda-funktioner tar dig till mer intermediära–avancerade saker du kan göra med Python – lär dig Intermediate Python med denna kurs. De ser komplicerade ut vid första anblick, men är ganska enkla.

I vårt exempel använde vi bara ett argument, men vi hade kunnat använda flera om vi velat:

square = lambda a, b: a ** b
print(f"Lambda function: {square(4, 2)}")
"""
16
"""

I korthet tillåter nyckelordet lambda oss att skapa små, begränsade, anonyma funktioner på en rad. De beter sig som vanliga funktioner deklarerade med def-nyckelordet, förutom att dessa funktioner inte har något namn.

#24 Metoden ’swapcase’

string = "SoMe RaNDoM sTriNg"
print(string.swapcase())

"""
sOmE rAndOm StRInG
"""

Metoden swapcase() används på en sträng för att byta versaler till gemener och tvärtom i en enda kodrad. Det finns inte många användningsfall för swapcase(), men det är bra att känna till.

#25 Metoden ’isalnum’

password = "ABCabc123"
print(password.isalnum())

"""
True
"""

Anta att vi skapar ett program där användare måste ange ett lösenord, men det måste innehålla en kombination av siffror och bokstäver. Vi kan göra detta på en rad kod genom att anropa isalnum() på strängen.

Metoden kontrollerar om alla tecken är alfabetiska (A–Za–z) och numeriska (0–9). Ett mellanslag eller symbol (!#%$&? etc.) returnerar False.

#26 Undantagshantering

def get_ration(x:int, y:int) -> int:
    try:
        ratio = x/y
    except ZeroDivisionError:
        y = y + 1
        ratio = x/y
    return ratio

print(get_ration(x=400, y=0))

"""
400.0
"""

Python-program avslutas när de stöter på ett fel.

Ibland vill vi inte ha detta beteende, till exempel när en slutanvändare interagerar med vår kod. Hur illa vore det om koden avslutades i förtid i ett sådant fall?

Det finns några olika tankeskolor om hur man hanterar undantag. De flesta Python-programmerare omfamnar vanligtvis tanken att det är lättare att be om förlåtelse än om tillåtelse. Det betyder att de hellre fångar ett kastat fel genom att tillhandahålla omgivande kontext som kan hantera undantaget. Tanken bakom detta är att det inte är någon idé att lägga tid på att försöka skydda mot alla möjliga undantagsfall.

Men detta gäller bara när det finns en mekanism för att hantera problemet efter att det uppstått.

#27 Identifiera skillnader i listor

list_1 = [1, 3, 5, 7, 8]
list_2 = [1, 2, 3, 4, 5, 6, 7, 8, 9]

solution_1 = list(set(list_2) - set(list_1))
solution_2 = list(set(list_1) ^ set(list_2))
solution_3 = list(set(list_1).symmetric_difference(set(list_2)))

print(f"Solution 1: {solution_1}")
print(f"Solution 2: {solution_2}")
print(f"Solution 3: {solution_3}")

"""
Solution 1: [9, 2, 4, 6]
Solution 2: [2, 4, 6, 9]
Solution 3: [2, 4, 6, 9]
"""

Här är tre olika metoder för att jämföra skillnaderna mellan två listor i Python. 

Obs: Om du inte vet med säkerhet att list_1 är en delmängd av list_2, så är lösning 1 inte samma som de två andra.

#28 Args & kwargs

def some_function(*args, **kwargs):
    print(f"Args: {args}")
    print(f"Kwargs: {kwargs}")

some_function(1, 2, 3,  a=4, b=5, c=6)

"""
Args: (1, 2, 3)
Kwargs: {'a': 4, 'b': 5, 'c': 6}
"""

Vi använder *args och **kwargs som parametrar till en funktion när vi inte vet hur många variabler vår funktion ska förvänta sig. 

Parametern *args låter oss skicka ett variabelt antal parametrar till en funktion när de inte är nyckelordade (d.v.s. parametrarna vi skickar kräver inget associerat namn). Å andra sidan gör parametern **kwargs att vi kan skicka ett godtyckligt antal nyckelordade parametrar till en funktion.

I själva verket är orden *args och **kwargs inte så magiska: magin ligger i asteriskerna (*). Det betyder att vi hade kunnat använda vilket ord som helst efter asterisken, men användningen av args och kwargs är praxis och är etablerad bland Python-utvecklare. 

#29 Ellips

print(...)

"""
Ellipsis
"""

def some_function():
    ...

# Alternative solution
def another_function():
    pass

Ellipsen är ett Python-objekt som kan anropas genom tre punkter (...) eller genom att anropa objektet i sig (Ellipsis).

Den mest kända användningen är för åtkomst och slicing av flerdimensionella arrayer i NumPy, till exempel:

import numpy as np

arr = np.array([[2,3], [1,2], [9,8]])

print(arr[...,0])
"""
[2 1 9]
"""
print(arr[...])

"""
[[2 3]
[1 2]
[9 8]]
"""

Men en annan användning av Ellipsis är som platshållare i en icke-implementerad funktion. 

Det betyder att du kan använda Ellipsis, ..., eller pass, och alla är giltiga.

#30 Listkomprehension

even_numbers = [x for x in range(10) if x % 2 == 0 and x != 0]
print(even_numbers)

"""
[2, 4, 6, 8]
"""

Vårt sista Python-trick är listkomprehensioner, som är ett elegant sätt att skapa en lista från en annan sekvens. De låter dig utföra avancerad logik och filtrering som vi gjort i koden ovan.

Det finns andra sätt att uppnå samma mål; till exempel hade vi kunnat använda en lambda-funktion så här:

even_numbers = list(filter(lambda x: x % 2 ==0 and x != 0, range(10)))
print(even_numbers)
"""
[0, 2, 4, 6, 8]
"""

Men många Pythonistas skulle hävda att denna lösning är betydligt mindre läsbar än listkomprehensionen.