Moduler och Pythons standardbibliotek

Efter den här lektionen kan du dela upp din Python-kod i egna moduler, använda inbyggda bibliotek som math och random, samt förstå hur namnrymder förhindrar namnkonflikter i din kod.

Vad är en modul och standardbiblioteket?

När ett programmeringsprojekt växer blir det snabbt svårt att hålla all kod i en enda fil. En modul i Python är helt enkelt en fil med Python-kod (med filändelsen `.py`) som innehåller funktioner, variabler och klasser som du kan återanvända i andra filer.

Python levereras med ett omfattande standardbibliotek ("batteries included"). Det innebär att du får tillgång till hundratals färdiga moduler för allt från matematik och slumptal till filhantering och nätverk – helt utan att behöva installera någonting extra.

För att använda en modul använder du nyckelordet `import`. När du importerar en modul skapas en namnrymd (namespace). Namnrymden fungerar som en kapsel som förhindrar att funktioner i moduler krockar med dina egna funktioner.

Exempel på import:

python

import math

Vi når funktioner via modulens namn och en punkt:

resultat = math.sqrt(25)

print(resultat) # Skriver ut 5.0

Genom att använda `math.sqrt` talar vi om för Python att vi vill använda funktionen `sqrt` som ligger inuti modulen `math`.

Matematiska beräkningar med math-modulen

Modulen `math` innehåller avancerade matematiska funktioner och konstanter som inte finns inbyggda i grundläggande Python.

Några vanliga konstanter:

• `math.pi`: Talet π (ca 3.14159)
• `math.e`: Eulers tal (ca 2.71828)

Några användbara funktioner:

• `math.sqrt(x)`: Kvadratroten ur x.
• `math.pow(x, y)`: Beräknar x upphöjt till y.
• `math.ceil(x)`: Avrundar uppåt till närmaste heltal.
• `math.floor(x)`: Avrundar nedåt till närmaste heltal.
• `math.sin(x)`, `math.cos(x)`: Trigonometriska funktioner (vinkeln anges i radianer).

Exempel på användning:

python

import math

radie = 5

areal = math.pi * math.pow(radie, 2)

print("Cirkelns area:", areal)

tal = 4.2

print(math.ceil(tal)) # Skriver ut 5

print(math.floor(tal)) # Skriver ut 4

Slumpmässighet med random-modulen

Modulen `random` används för att generera pseudoslumpmässiga tal och göra slumpmässiga val. Det är mycket användbart i spel, simuleringar och testning.

Vanliga funktioner i `random`:

1. `random.randint(a, b)`: Returnerar ett slumpmässigt heltal n sådant att a ≤ n ≤ b. Observera att både a och b ingår!

2. `random.random()`: Returnerar ett slumpmässigt flyttal mellan 0.0 och 1.0 (exklusive 1.0).

3. `random.choice(sekvens)`: Väljer ett slumpmässigt element från en lista eller sträng.

4. `random.shuffle(lista)`: Blandar elementen i en lista direkt på plats (modifierar originallistan).

Exempel:

python

import random

Simulera ett tärningskast (1-6)

tarning = random.randint(1, 6)

print(f"Du slog en {tarning}:a!")

Välja en slumpmässig frukt

frukter = ["äpple", "banan", "apelsin", "päron"]

vald = random.choice(frukter)

print(f"Slumpad frukt: {vald}")

Olika sätt att importera och Namnrymder

Det finns flera syntaxvarianter för att importera moduler och deras innehåll. Vilken variant du väljer påverkar hur du anropar koden och hur din namnrymd ser ut.

1. Vanlig import (`import math`)

Du måste skriva `math.pi`. Detta är det säkraste sättet eftersom det undviker namnkrockar.

2. Import av specifika delar (`from math import sqrt, pi`)

Importerar valda funktioner direkt till din nuvarande namnrymd. Du kan nu skriva `sqrt(16)` och `pi` direkt utan `math.`.

3. Import med alias (`import math as m`)

Ger modulen ett kortare namn. Du anropar sedan med `m.sqrt(16)`. Vanligt i dataanalys (t.ex. `import numpy as np`).

4. Import av allt (`from math import *`)

Importerar alla funktioner direkt. Avråds starkt! Det är lätt att du av misstag skriver över egna variabler eller funktioner med samma namn.