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

Efterfrågan på kunskaper i Python-kodning har ökat de senaste åren. För att hjälpa dig att utveckla dina färdigheter i Python-programmering har vi sammanställt 30 coola Python-tricks som du kan använda för att förbättra din kod. Försök lära dig ett om dagen de kommande 30 dagarna, och kolla in vårt inlägg om bästa praxis i Python för att se till att din kod håller toppklass. 

Om dina Python-kunskaper behöver vässas kan du också finslipa dem med vår färdighetsväg Python Programming.

Trick för sekvenser och datastrukturer

#1 Skivning (slicing)

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

"""
!dlroW olleH
"""

Skivning ä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 skivning för att extrahera och ändra data. 

Obs: Vi kan också använda skivning på en omuterbar sekvens, men att försöka ändra skivan kommer att ge ett TypeError. 

Formatet för hur skivor implementeras ä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 som standard 0 
• "stop" är som standard sekvensens längd
• "step" är som standard 1 om det inte anges. 

När du anger sequence[start:stop] returneras elementen från startindex upp till stop - 1 (stop-indexet ingår 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 också index -4, och det sista indexet är också -1. I exempelkoden ovan tillämpades detta på sekvensens parameter step. Följaktligen skrevs strängen ut baklänges, från slutet av sekvensen till index 0.   

#2 In-place-byte / simultan 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 iterabla objekt 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 upphov till en teknik som kallas simultan tilldelning. Vi kan använda simultan tilldelning för att tilldela en serie värden till en serie variabler.

#3 Lista vs. tupler 

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 listor. Samma sak kan inte sägas om tupler. Båda är iterabla, tillåter indexering och lagring av heterogena datatyper. Men det finns situationer där en tuple kan vara att föredra framför en lista. 

Först och främst ä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]
"""

Tupler, å andra sidan, är omuterbara, vilket innebär att försök att ändra dem ger ett TypeError. 

Av den anledningen är tupler mer minnes­effektiva eftersom Python kan allokera rätt minnesblock för datat. I en lista måste extra minne allokeras ifall vi skulle utöka den – detta kallas dynamisk minnesallokering. 

TLDR; I scenarier där du inte vill att datat ska ändras bör en tuple föredras framför en lista av minnesskäl. Tupler är också snabbare än listor. 

Lär dig mer om Pythons datastrukturer i den här guiden. 

#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 att använda en for-loop. Men vad händer om du råkar byta klammer från [] till ()? Du får ett generatorobjekt.

I Python skapar runda parenteser med listkomprehensionslogik det som kallas ett generatorobjekt. Generatorer är en särskild sorts iterabla. Till skillnad från listor lagrar de inte sina element. I stället lagrar de instruktioner för att generera varje element i ordning och det aktuella tillståndet för iterationerna.

Varje element genereras bara på begäran genom 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 programmeringssprå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 aliasing. Ändringar i ett alias 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 aliasing 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 skivning: 

b = a[:] 

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

Du kan hitta många andra lösningar, som att anropa list(a) när du tilldelar datat 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 en datastruktur är tom genom att använda operatorn not. Pythons inbyggda not är en logisk operator som returnerar True om uttrycket inte är sant, annars returnerar den False – den inverterar sanningsvärdet för 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 kommer operatorn not att returnera False, och vice versa. 

Det kan vara lite klurigt att få in i tänket, så prova själv.

Trick för strängar och utskrift

#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 bra funktion som kallas f-strängar för att förenkla detta. Det hjälper att förstå hur strängar formaterades före den nya versionen för att bättre uppskatta den nya metoden. 

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 att formatera snabbare, mer lättläst, 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 funktionen print()

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

"""
english french spanish german twi
"""

Det är ganska vanligt att använda ett print-anrop utan att ange några 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 print-anrop. 

Standardvärdet för end är "\n" vilket talar om för Python att börja på en ny rad. I koden ovan ändrade vi det till ett blanksteg. Därför skrevs alla element i vår lista 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 tupler är omuterbara – se Python-trick #3 Lista vs. tupler. Att försöka ändra tillståndet hos en tuple skulle ge ett TypeError. Men om du tänker på en tuple som en sekvens av namn med bindningar till objekt som inte kan ändras, kan du se det annorlunda.

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

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

Skulle vi rekommendera att du gör detta i praktiken? Förmodligen inte, men det är en sådan där bra-sak-att-veta!

#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 mer än att det är en mycket mer lättläst lösning! 

Kodstil och syntaxtrick

#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 kunde ha skrivit vår kod på är följande:

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

print(name)
"""
John
"""

Även om båda kodblocken ger samma resultat, lägg märke till hur den ternära varianten låter oss skriva mycket kortare och tydligare kod. Det är vad Pythonistas skulle kalla det mer ”pythonska” sättet att skriva kod. 

#12 Ta bort dubbletter 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 (och tillbaka till en lista om du vill).

Utifrån muterbarhet är mängder 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å mycket olika.

Listor är ordnade, nollindexerade och muterbara. Mängder är oordnade och oindexerade. Elementen i en mängd måste vara av en omuterbar typ, även om själva mängden är muterbar – att försöka hämta ett element via ett index eller ändra ett element ger ett fel.

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

#13 Fristående underscore 

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

>>> 1 + 2
3

>>> print(_)
3

Underscore (_) är en giltig identifierare i Python, så det går att använda den för att referera till ett objekt. Men underscore har också ett annat jobb: 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 _. (Den lagras i modulen builtins, tillsammans med inbyggda funktioner som print).”

Eftersom vi inte tilldelade underscore något objekt innan vi anropade den på första raden fick vi ett fel. När vi däremot beräknade resultatet av 1 + 2 lagrade den interaktiva tolken resultatet i identifieraren _ åt oss. 

#14 Underscore 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 det senaste resultatet tillgängligt i identifieraren underscore (_), men det är inte dess enda användningsfall.

Vi kan också använda den 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 underscore (_) kommer att ge ett F841-fel när vi lintar vårt program. Ett F841-fel anger helt enkelt att ett lokalt variabelnamn har tilldelats men inte använts i programmet, vilket är en dålig praxis.

#15 Eftersläpande underscore

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

Fortsätter vi på underscorens (_) olika användningar: ett annat syfte är att undvika konflikter med Python-nyckelord. 

PEP 8 nämner att en eftersläpande underscore (_) 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 en enda eftersläpande underscore än att använda en förkortning eller förvanskning. Så list_ är bättre än lst.”

#16 Inledande underscore

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

Du kommer ofta att märka att erfarna Python-programmerare tenderar att sätta ett underscore före en identifierare eller metodnamn – och av goda skäl.

Underscore före en identifierare eller metod har en underförstådd betydelse: denna variabel eller metod är endast avsedd för internt bruk. I grunden är det en disclaimer till andra programmerare som definierats i PEP 8 men inte upprätthålls av Python. Därför är inledande underscores en svag indikator.

Till skillnad från Java har Python ingen stark åtskillnad mellan privata och publika variabler. Med andra ord har det bara betydelse eftersom Python-gemenskapen har kommit överens om det. Deras närvaro påverkar inte beteendet i dina program.

#17 Underscore som visuell avskiljare

Här är det sista tipset om underscores; Hittills har vi täckt tre olika användningsfall, men du kan läsa mer i vår guide om underscorens (_) roll i Python. 

number = 1_500_000
print(number)

"""
15000000
"""

Ett annat sätt vi kan använda underscore är som en visuell avskiljare för siffergruppering i heltal, flyttal och komplexa tal – 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 syntaxtrick

#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 har sett den här syntaxen i flera Python-program; Python använder ett särskilt namn som heter "__main__" och sätter det på en identifierare som heter __name__ om Python-filen som körs är huvudprogrammet.

Om vi väljer att importera modulen som visas i skärmbilden till en annan modul (Python-fil) och köra 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 antal förekomster av ord i en korpus. Det vanliga sättet att göra detta är: 

1. Kontrollera om nyckeln finns i ordboken
2. Om den finns, öka värdet med 1.
3. Om den inte finns, 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 att göra detta är att använda metoden setdefault() på ditt ordboksobjekt.

Det första argumentet till metoden är nyckeln vi vill kontrollera. Det andra argumentet är värdet som ska sättas om nyckeln inte redan finns i ordboken – om nyckeln finns returnerar metoden nyckelns värde. Det ändras alltså inte.

Trick 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 hittar du det då? Svaret är att söka efter mönster.  

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

Reguljära uttryck sparar mycket tid. Om vi skulle koda regler för att fånga instanserna i vår bild i stället för regex, skulle det kunna 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 funktionen sök och ersätt.

#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 alltså utnyttja pipe för att behålla den del av mönstret som återkommer och bara ändra delarna som behöver vara olika. Återigen sparar du värdefull tid.

Var uppmärksam på fallgropen: 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 funktionen 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 kapacitet är skrämmande; Om ”Hello World” var ditt första program var print() troligen 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 det finns mycket mer i print()-funktionen. 

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 blanksteg, men vi har ändrat detta i våra utskrifter – en där sep är satt till "" och en annan 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 mellan/avancerade saker du kan göra med Python – lär dig Intermediate Python med den här kursen. 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å ett strängobjekt för att låta oss byta versaler till gemener och vice versa 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, och det måste ha en kombination av siffror och bokstäver. Vi kan göra detta i en enda rad genom att anropa isalnum() på stränginstansen.

Metoden kontrollerar om alla tecken är alfabetiska (A-Za-z) och numeriska (0-9). Ett blanksteg eller en 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 avbryts 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 inte om vår kod avslutades i förtid i ett sådant fall?

Det finns några tankeskolor om hur man hanterar undantagsfall. De flesta Python-programmerare omfamnar typiskt tanken att det är lättare att be om förlåtelse än att be om lov. Det betyder att de hellre fångar ett uppkommet fel genom att ge omgivande kontext som kan hantera undantaget. Tanken bakom detta är att det inte är någon idé att slösa tid på att försöka skydda sig mot alla olika undantagsfall.

Men detta gäller bara när det finns en mekanism för att hantera problemet efter att det inträffat.

#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 skillnaden mellan två listor i Python. 

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

#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 inte ett associerat namn). Parametern **kwargs låter oss skicka ett godtyckligt antal nyckelordade parametrar till en funktion.

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

#29 Ellipsen

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 självt (Ellipsis).

Den mest kända användningen är för åtkomst och skivning 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 Ellipsen är som platshållare i en oimplementerad 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 listkomprehension, 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 den lösningen är mycket mindre lättläst än listkomprehensionen.