Moduler i Python
I Python så används variabler för att lagra värden. Dessa värden kan vara siffror, strängar eller bools. I Python finns även funktioner, vilka består av kodblock som används för att skapa, manipulera och returnera data. Variabler och funktioner har diskuterats i föregående kapitel. En modul, å andra sidan, är en samling av funktioner.
Moduler används för att organisera koden. Allteftersom koden blir mer invecklad och antalet funktioner växer så är det lämpligt att gruppera funktionerna i moduler. Modulerar tenderar ha en hierarkisk struktur. Det är lätt att skapa moduler. En modul är helt enkelt ett Python-script som består av flera funktioner.
Du skapar en modul genom att programmera flera funktioner och spara koden som en fil med ändelsen .py.
Vi ska nu skapa en enkel modul som endast innehåller en enda funktion och därefter anropa funktionen i modulen. Skapa en ny .py fil och spara den som summan.py. Skriv följande rader:
# Funktion med två argument (produkt1 och produkt2)
# Funktionen beräknar summan av produkterna och returnerar värdet
def min_summa(produkt1, produkt2):
total = produkt1+produkt2
print("Summan är beräknad")
return total
För att aktivera denna modulen och använda dess funktioner från andra program så skriver man:
# Importera modulen, vilket ger tillgång till alla funktioner i modulen import summa # Använd funktionen "min_summa" i modulen "summa" summa.min_summa(100, 100)
För att detta skall fungera skall filen summan.py finnas i samma mapp som det befintliga Python-scriptet är sparat. Observera att man skriver modulens namn följt av punkt och därefter funktionens namn. I exemplet ovan blir det summa.min_summa(100, 100).
Det finns ett alternativ till import, nämligen from. Med denna funktionen kan man aktivera enskilda funktioner i en modul. För att aktivera funktionen min_summa i summa.py skriver man som följer:
from summa import min_summa
Med denna raden importerar man funktionen min_summa från summa.py. Man kan importera flera funktioner samtidigt genom att separera de med kommatecken, enligt följande:
from biblioteket import funktion1, funktion2, funktion3
Man kan aktivera alla funktioner med from genom att använda * enligt följande:
from summa import *
Ovanstående är ekvivalent med:
import summa
Inbyggda moduler i Python
Det finns många inbyggda moduler som innehåller en lång rad värdefulla funktioner.
random
Modulen random används för att generera slumpmässiga siffror. Detta är mycket vanligt vid både data science och webbutveckling. Inte minst används detta för att utveckla och testa kod. Det kan också användas för att göra faktiska beräkningar och simuleringar. Inom webbutveckling kan random-modulen användas exempelvis för att generera slumpmässiga lösenord.
För att skapa en slumpmässig heltal använder vi randint. Exempel följer:
import random # Välj ett slumpmässigt värde mellan 1 och 10 random.randint(1, 10)
För att generera en slumpmässig siffra så kan du använda random.random() som genererar en slumpmässig siffra mellan 0 och 1. Vill du ha en slumpmässig siffra mellan 0 och 100 så multiplicerar du bara värdet med 100, enligt följande:
random.random()*100
Du kan också välja ett slumpmässigt nummer ur en lista. Detta görs med funktionen choice i modulen random. Exempel följer:
min_lista = list(range(0,1000)) random.choice(min_lista) ny_lista = [1, 8, True, 77, "Maria", 482, "Johanna"] random.choice(ny_lista)
math
Med math får du tillgång till vanliga matematiska konstanter.
import math math.pi # Pi, 3.14... math.e # Eulers nummer, 2.71... math.degrees(2) # 2 radianer = 114.59 grader math.radians(60) # 60 grader = 1.04 radianer math.sin(2) # sinus av 2 radianer math.cos(0.5) # cosinus av 0.5 radianer math.tan(0.23) # tangens av 0.23 radianer math.factorial(5) #1 * 2 * 3 * 4 * 5 = 120 math.sqrt(49) #kvadratrot av 49 = 7
datetime
Denna modulen innehåller funktioner som används för att hantera datum. Följande bibliotek kan åberopas för att hantera datum och tider:
import datetime from datetime import date import time
Låt oss ta några exempel:
time.time() # Returnerar antal sekudner sedan 1970-01-01 date.fromtimestamp(123456789) # Konverterar antal sekunder sedan 1970-01-01 till aktuellt datum date.fromordinal(10000) # Returnerar datum vid 10000 dagar sedan 1970-01-01
os
Denna funktionen är viktig. os står för operative system och låter dig kommunicera med operativsystemet (Mac, Windows, Linux). Flera viktiga exempel följer:
import os
# Vilket är vårt nuvarande "working directory?"
# "working directory" är mappen där vi har våra filer
os.getcwd()
# Ändra working directory till mappen "min_mapp" på skrivbordet
os.chdir("/Users/David/Desktop/min_mapp")
# Visa alla filer i min working directory
os.listdir('.')
Det finns många fler inbyggda moduler som du kan utforska på Python.org.
Klasser, objekt och objektorienterad programmering i Python
Python är ett objektorienterat språk, vilket innebär att tonvikten i programmeringen ligger på objekten som skapas och manipuleras.
Ett objekt är en modul med fördefinierade funktioner och/eller variabler. Funktioner som ingår i ett objekt kallas metoder (eng. methods) och variablerna kallas attribut (eng. attributes).
Man skapar objekt genom att specificera en klass, vilket är en ritning på objektet. Klassen definierar objektets attribut (variabler) och metoder (funktioner).
Klassen definierar också relationen mellan variabler och funktioner.
Klasser förklaras enklast med ett konkret exempel. Ponera att vi bygger ett bibliotek med information om sjukdomar. Varje sjukdom skall ges ett namn, information om vilket organsystem som är drabbat samt information om huruvida sjukdomen är dödlig eller inte. Vi kan specificera klassen som följer:
class Sjukdom: # Använd versal i klassnamnet
def __init__(self, sjukdomen, organsystem, behandling, fatal):
self.sjukdomen = sjukdomen
self.organsystem = organsystem
self.behandling = behandling
self.fatal = fatal
def specifikation(self): # Metod
print("Sjukdom: ", self.sjukdomen)
print("Organsystem som drabbas: ", self.organsystem)
print("Behandling: ", self.behandling)
print("Fatal (ja/nej): ", self.fatal)
strupcancer = Sjukdom("Cancer, matstrupen", "Matstrupen", "Kirurgi och kemoterapi", "Ja")
strupcancer.specifikation()
# Resultat:
# Sjukdom: Cancer, matstrupen
# Organsystem som drabbas: Matstrupen
# Behandling: Kirurgi och kemoterapi
# Fatal (ja/nej): Ja
Objektet strupcancer kommer nu få klassen Sjukdom. Alla sjukdomar som definieras kommer ärva sina egenskaper från klassen Sjukdom. I ovanstående exempel har klassen Sjukdom två metoder. Den första metoden är __init__ och den andra är specifikation. Observera att metoden __init__ innehåller argumentet self. __init__ är den inledande metoden i klassen Sjukdom. I den metoden definieras de variabler som skall sparas i objektet som skapas. I metoden __init__ definieras totalt 4 attribut (variabler) och dessa föregås av self för att tydliggöra att dessa attribut tillhör en klass.
Det finns flera fördelar med att programmera på detta viset. För att illustrera detta tar vi ett exempel med en valutaomvandlare. Vi skapar en klass som kallas Valuta och den har ett attribut i första metoden (__init__), nämligen kronor. I andra metoden använder vi värdet från kronor för att omvandla kronor till dollar, pund och rubel. Vi testar sedan att omvandla 100 kronor.
class Valuta: # Använd versal i klassnamnet
def __init__(self, kronor):
self.kronor = kronor
def omvandla(self): # Metod
print("Kronor: ", self.kronor) # skriver ut antal kronor
print("Dollar: ", self.kronor*8) # dollar = ronor multiplicerat med 8
print("Pund: ", self.kronor*12) # pund = kronor multiplicerat med 8
print("Rubel: ", self.kronor/10) # en rubel är en tiondel av en krona
mitt_konto = Valuta(100)
mitt_konto.omvandla()
# Resultat:
# Kronor: 100
# Dollar: 800
# Pund: 1200
# Rubel: 10.0
Fördelen med detta upplägget är att man enkelt kan lägga till fler valutaomvandlingar genom att lägga till fler print() i metoden omvandla.
