1. No category

Avdeling for informatikk og e-læring, Høgskolen i Sør-Trøndelag
Strengbehandling og enkle beregninger
Claus Schive
Lærestoffet er utviklet for faget IFUD1050 Programmering med Python
Man har mulighet til å gjøre mange ting med tekststrenger. De viktigste metodene i Python er beskrevet i
leksjonen. Programmeringsspråket gir også meget gode muligheter til å formattering av tekst og utskrift og har
flere metoder til å operere på lister. Betingede kontrollstrukturer og løkker brukes også i Python for å ta
beslutninger for å utføre situasjonsbetingede handlinger og gå igjennom sekvenser av data. Math-modulen i
python gir flere avanserte mattefunksjoner(kvadratrot, cosinus, sinus) som ikke er med fra standard.
1.
TEKSTSTRENGER– GRUNNLEGGENDE STRENGOPERASJONER ............................................. 2
2.
TESTING, SØKING OG MANIPULERING AV TEKSTSTRENGER ................................................ 3
3.
FORMATTERING.................................................................................................................................. 5
4.
BETINGEDE KONTROLLSTRUKTURER.......................................................................................... 7
5.
LØKKER................................................................................................................................................. 8
6.
LISTEMETODER OG NOEN INNEBYGDE FUNKSJONER ............................................................ 9
7.
MER OM FUNKSJONER .................................................................................................................... 11
8.
BRUK AV MODULENE MATH OG RANDOM ................................................................................. 13
9.
NUMPY OG SCIPY ............................................................................................................................. 15
Opphavsrett: Forfatter og Stiftelsen TISIP
Strengbehandling og enkle beregninger
side 2 av 15
1. Tekststrenger – grunnleggende strengoperasjoner
Man har mulighet til å gjøre mange ting med tekststrenger. De viktigste metodene er
beskrevet i her. Tekststrenger er sekvenser, og mange av funksjonene/metodene tilsvarer de
for lister og tupler. På samme måte som for lister, kan man få ut deler av strengen ved å bruke
indeks og skiving (slice). Strenger i Python er såkalt "immutable", noe som gjør at når den
først er opprettet så kan du egentlig ikke endre på den. Men istedenfor må du opprette nye
strenger, basert på den originale.
Konkatinering av strenger
Konkatinering er å sette sammen to strenger til en. Man kan bruke operatoren + . Nedenfor
følger noen eksempler på konkatinering:
navn = fornavn + etternavn
evt. += hvis du har en variabel hvor du samler opp tekst
F.eks. setning += nytt_ord Hvis du skal sette et tall inn i en streng kan man bruke
str( ) -funksjonen som konverterer tall til tekst
F.eks. respons = ’Du har ’ + str(saldo) + ’kroner på kontoen’
Slicing av strenger
I Python , er en " slice " en undergruppe av en liste eller en streng variabel som man får ved å
definere en start og /eller slutt indeks på variable og returnere verdiene innenfor dette
området. Den returnerte undergruppe omfatter start indeksverdien , men ikke sluttverdien.
Man kan bruke slice metoden på flere ulike datatyper , tall og lister.
For å bruke slice metoden, må du først opprette og initialisere en variabel å skjære. Deretter
brukes hakeparenteser for å indikere enten en posisjon til å starte slicing , avslutte slicing,
eller begge deler. I eksempelet " testen [ 03:05 ] " for å skjære en variabel kalt
" testen ", starter man på den tredje posisjonen og ender på indeksen før den femte posisjon
. Man kan også skrive " testen [ 3 : ] " for å skjære i den tredje posisjonen og returnere
alt etterpå , eller skrive " testen [ : 5 ] " for å returnere alt opp til femte posisjon.
Man kan bruke slice metoden på flere ulike typer data og få forskjellige resultater . For
eksempel , hvis du har en streng variabel " alph " som inneholder bokstavene i alfabetet i
rekkefølge, skrive " alph [ 01:05 ] " returnerer delstrengen ' BCDE . ' Hvis du har en liste
over strenger eller heltall kalt " lst , " skrive " lst [ 01:03 ] "så returnerer den andre og
tredje element i listen . Her følger flere eksempler på hva man kan gjøre med tekststrenger:
#Strengoperasjoner - noen eksempler
tekst = 'Hallo'
print tekst # Gir 'Hallo'
# Setter sammen to strenger
print tekst + 'verden' #Gir Halloverden
Opphavsrett: Forfatter og Stiftelsen TISIP
Strengbehandling og enkle beregninger
side 3 av 15
# En annen måte å sette sammen to strenger. Kommaet gir et ekstra
mellomrom.
print tekst, 'verden' #Gir Hallo verden
# Når man skal sette sammen en streng og et tall, NB! sett str()
rundt tallet.
print tekst + str(10) # Hvis du skal sette sammen en streng og et
tall, husk å sette str() rundt tallet.
# Skriver ut lengden til strengen.
print len(tekst) #Gir 5
#På samme måte som for lister, kan man få ut deler av strengen ved å
bruke indeks og skiving (slice).
tekst= 'Dette er en test'
tekst[0] # Gir 'D'
tekst[14] # Gir 's'
#For å få tilgang til enkelttegn i en streng ved bruk av for løkke
month = 'August'
month[3] #Gir u
for character in month:
print (character)#Gir August-skrevet ut loddrett med et tegn på
hver linje
2. Testing, søking og manipulering av tekststrenger
Strenger har mange metoder. Noen av dem er svært nyttig (for eksempel del og join), mens
andre blir brukt sjeldnere (for eksempel istitle eller capitalize). Fordi det er så mange metoder,
er det bare noen av de mest nyttige som er beskrevet her. For full referanse, se vedlegg B i
læreboken eller dokumentasjonen på https://docs.python.org/2/ for flere detaljer.
lower
Denne metoden returnerer en versjon av strengen i små bokstaver. Dette kan være nyttig hvis
man ønsker å skrive kode som er "case-insensitiv" -dvs kode som ignorerer forskjellen
mellom store og små bokstaver. For eksempel, hvis man ønsker å sjekke om et brukernavn er
funnet i en liste.
'Trondheim Symfoni Orkester'.lower()
orkester'
#Gir 'trondheim symfoni
if 'Ole' in ['anders', 'ole', 'per']:
print 'Fant navnet!' #Finner ikke navnet
Opphavsrett: Forfatter og Stiftelsen TISIP
Strengbehandling og enkle beregninger
side 4 av 15
En løsning på dette er å konvertere alle navnene til små bokstaver både når du lagrer og søker.
Koden vil se omtrent slik ut:
name = 'Ole'
names = ['anders', 'ole', 'per']
if name.lower() in names:
print 'Fant navnet!' #Gir Fant navnet
strip
Metoden returnerer en streng hvor mellomrom på venstre og høyre (men ikke internt) har blitt
strippet (fjernet). Strip kan være nyttig når man sammenligner input med lagrede verdier.
Strip kan kun utføres i endene, så de interne tegnene kan ikke fjernes. Nedenfor følger noen
eksempler på hvordan metoden kan brukes:
names = ['Anders', 'Ole', 'Per']
name = 'Ole'
if name.strip() in names: print 'Fant det!'
#Gir Fant det
Strip kan kun utføres i endene, så her fjernes ikke de interne tegnene:
'*** SPAM * for * everyone!!! ***'.strip(' *!')
#Gir 'SPAM * for * everyone'
replace
Denne metoden returnerer en streng hvor alle forekomster av én streng er erstattet av en
annen. Metodens styrke ligger i at det kan utføre flere utskiftninger samtidig.
'Der er en test'.replace('er', 'var') #Gir Dvar var en test
join
Joiner en svært viktig streng metode. Join er det motsatte av split, og brukes til å få med
elementene i en sekvens. Som man kan se, må de sekvenselementer som skal settes sammen
alle være strenger :
sep = '+'
seq = ['1', '2', '3', '4', '5']
print sep.join(seq) # Gir 1+2+3+4+5
dirs = ' ', 'usr', 'bin', 'env'
print 'C:' + '\\'.join(dirs) #Gir C:\usr\bin\env
Å splitte opp en streng
En meget viktig streng metode er split som er det motsatte av join. Den brukes til å dele en
streng i en sekvens. Merk at hvis man ikke har noen skilletegn å sende som argument til
metoden split, er standard å splitte på alle kjøringer av sammenhengende blanke tegn
Opphavsrett: Forfatter og Stiftelsen TISIP
Strengbehandling og enkle beregninger
side 5 av 15
(mellomrom, tabulator, linjeskift, og så videre). Nedenfor følger noen eksempler på hvordan
metoden kan brukes:
'1+2+3+4+5'.split('+')
#Gir ['1', '2', '3', '4', '5']
'/usr/bin/env'.split('/')
'Using
the
#Gir ['', 'usr', 'bin', 'env']
default'.split()
#Gir ['Using', 'the', 'default']
3. Formattering
I Python brukes % operatør til å formatere tekststrenger. Man kaller format% verdier, der
formatet er en streng, og verdier er en eller flere verdier. Tegnet % markerer begynnelsen av
konverteringen.
Videre har man konverteringsflagg (valgfrie). Disse kan være enten være
- (minustegn) som angir venstre justering innen feltet
+ (plusstegn) som betyr skriv alltid tegn (+ eller −)
0 (null) som betyr fyll med nuller i stedet for mellomrom
Feltets bredde er antall tegn som skal brukes, inkludert de som går til å skrive et minustegn
("-") ,("."), desimaltegn etc. Etter at feltet er formatert, fylles det ut med mellomrom ("␣")
eller nuller ("0"). Minimum feltbredde er valgfritt. Den konverterte strengen vil være minst
dette bred. Disse to parametere er to heltall hvor bredde er først, deretter presisjon, adskilt
med en . (punktum). Begge er valgfritt, men hvis du ønsker å ha bare presisjonen, må du også
inkludere . (punktum).
Presisjonen er antall sifre etter desimaltegnet, 2 eller (for tekststrengen) maksimalt antall tegn
som skal tas fra strengen. Før bredde- og presisjons tall, kan du sette et "flagg", som enten kan
være null, pluss, minus, eller blank. Her følger noen eksempler på formatteringer:
Figur 1. Eksempler på formattering.
Opphavsrett: Forfatter og Stiftelsen TISIP
Strengbehandling og enkle beregninger
side 6 av 15
Følgende er de vanligste konverteringer. De forekommer i de fleste programmeringsspråk. Se
dokumentasjonen https://docs.python.org/2/ for flere tegn og detaljer.
Tegn
Argument type;
Konvertering
d, i
Heltall, skrevet i desimal (radix 10) med minustegn (-) for negative tall
x, o
Heltall, skrevet ut som heksadesimale (radix 16) eller oktale (radix 8)
f
Float skrevet på form [-] d.ddd. Med mindre annet er oppgitt, er det brukt 6
plasser etter desimaltegnet
e
Float skrevet som [-] d.ddde ± dd, dvs. 3.142e + 01 for å skrive 3142 · 1001 (dvs.
31.42).
g
Float, som f eller e avhengig av hvor mange som er konvertert
s
Streng
%
%-tegn; ingen argument å konvertere
Nedenfor følger (Escape-karaktererer) spesialtegn som kan skrives inn i tekststrenger som
gjør spesielle operasjoner:
\n Gir linjeskift
\t Hopper til neste tabulator
\’ Skriver ut tegnet ’
\” Skriver ut tegnet ”
\\ Skriver ut tegnet \
I eksempelet nedenfor brukes * width for å formatere en tabell med frukt priser, hvor bruker
legger inn den totale bredden på tabellen:
Opphavsrett: Forfatter og Stiftelsen TISIP
Strengbehandling og enkle beregninger
side 7 av 15
Figur 2. Eksempel på formattering av en prisliste.
4. Betingede kontrollstrukturer
Betingede kontrollstrukturer trenger vi for å ta beslutninger for å utføre situasjonsbetingede
handlinger. I Python har man en hvis-setning (if-statement) som utgjør dens betingede
kontrollstruktur. Hvis en betingelse er tilfredsstilt, utføres handling (en eller flere kodelinjer)
ellers utføres den ikke.
if omsetning > 2000:
bonus = 100
print("Bonus er oppnådd!")
Man kan også utføre andre instruksjoner ved å legge dem i en else-blokk. Et if-else uttrykk vil
kjøre en blokk av kode hvis betingelsen er sann (True) – og en annen blokk av kode hvis
betingelsen er usann (False). Et if-else uttrykk brukes for å velge mellom to alternative
handlinger / kodeblokker. Ofte kaller man dette for en hvis-så-ellers-struktur:
if omsetning > 2000:
# Betingelsen er sann
print("Bonus er oppnådd!")
else:
# Betingelsen er usann
print("Bonus er ikke oppnådd!")
Om man vil utføre flere tester, kan man bruke elif, en sammentrekning av else og if, som
sjekker en ny betingelse om den første ikke ble oppfylt:
if (omsetning >= 2000): bonus = 100
elif(omsetning >= 1500): bonus = 75
elif(omsetning >= 1000): bonus = 50
else: bonus = 25
Opphavsrett: Forfatter og Stiftelsen TISIP
Strengbehandling og enkle beregninger
side 8 av 15
Kun en av betingelsene vil slå til i eksemplet ovenfor. Man kan også bruke nøsting av if –
setninger, men det kan fort bli uoversiktlig. Bruk av elif gir bedre oversikt og mer lesbar
kode.
5. Løkker
I tillegg til betingede kontrollstrukturer har vi to typer løkker. Den ene er en betinget
løkke(while-løkker), som likner på if, men utføres flere ganger, og en løkke for å gå gjennom
lister og andre sekvensielle data.
Det er nyttig å kunne gjenta en del av et program flere ganger, uten å skrive det samme mange
ganger. Til dette bruker man løkker
while-løkker
while-løkker brukes for å gjenta en oppgave mange ganger til en betingelse (ikke lenger) er
oppfylt. Det er en fordel å bruke while-løkker ved gjentagelse av kode hvor man ikke helt vet
hvor mange ganger koden skal gjentas. Den generelle syntaksen er som følger:
while betingelse :
<oppgave som gjentas>
Koden her deklarerer og instansierer en variabel x med verdi 0. Løkken gjør at x blir skrevet
ut etterfulgt av et linjeskift, for deretter å bli økt med 1. Den vil kjøres 10 ganger.
while x < 10:
print x
x = x + 1
Validering av input ved hjelp av løkker
Ofte ønsker man å sikre seg at riktig verdier på input fra brukeren før programmet går videre.
Det kan man gjøre ved hjelp av while-løkke:
alder = int(input("Hvor gammel er du? "))
while (alder < 0 or alder > 100):
print("Feil: Alder må være mellom 0 og 100!")
alder = int(input("Hvor gammel er du? "))
print("Takk for den!!!")
for-løkker
for-løkke brukes vanligvis for å gjenta en oppgave et kjent antall ganger. Hvis man skal gjenta
en ”kodesnutt” et bestemt antall ganger, bruker man en for-løkke. En fordel å bruke hvis man
skal gjøre noe med alle elementene i ei liste eller en tabell. Den generelle syntaksen er som
følger:
for i in liste :
<oppgave som gjentas>
Opphavsrett: Forfatter og Stiftelsen TISIP
Strengbehandling og enkle beregninger
side 9 av 15
'liste' kan her for eksempel erstattes med range(10), som vil generere en liste fra 0 til 9.
Her gjøres akkurat det samme som i while-løkken i eksempelet ovenfor. Tellevariabelen er
innlemmet i løkken.
for i in range(10) :
print 1
En for-løkke kan også kjøres på en variabel som inneholder en liste av verdier. Følgende
eksempel skriver ut navnene til skjerm i rekkefølge:
navneliste=[’Ole’,’Per’,’Oline’,’Anna’,’Frida’]
for navn in navneliste:
print (navn)
En for-løkke kan iterere (gå igjennom) ei liste av alle typer verdier (strenger, heltall, flyttall,
sannhetsverdier osv. En løkke inne i en annen løkke kalles nøstede løkker. Noen fenomener er
av en slik art at man trenger en hierarkisk gjennomkjøring av løkke. Tid er et godt eksempel
der man teller først 60 sekunder, før man øker minutt med 1 osv.
Utskrift av tid som nøstede løkker:
for t in range(24):
for m in range(60):
for s in range(60):
print(t,":",m,":",s)
6. Listemetoder og noen innebygde funksjoner
Man kan også gå igjennom en liste element for element (iterere) ved å bruke ei for-løkke på
følgende format:
for element in liste:
print(element) # Eller gjør noe annet med element
liste er navnet på variabelen som inneholder en liste og element er en variabel som får verdien
av hvert element i lista.
Indeksering
Indeks er et tall som spesifiserer et elements posisjon i en liste. Det gir tilgang til de enkelte
elementer i en listen. Indeksen til det første elementet er 0, det andre 1, og det n-te elementet
er n-1 Negative indekser identifiserer posisjoner relativt til listens slutt.  Indeksen -1
identifiser det siste elementet, -2 det nest siste osv.
Funksjonen len
Funksjonen len returnerer lengden til en sekvens, som for eksempel lengden av en liste
size = len(my_list) returnerer antallet elementer i listen, slik at det siste elementet er
len(list)-1 ettersom indeks starter på 0 og ikke 1. Man kan bruke dette til å hindre en
IndexError-exception når man itererer gjennom en liste i en løkke.
Opphavsrett: Forfatter og Stiftelsen TISIP
Strengbehandling og enkle beregninger
side 10 av 15
Konkatinere lister
Å konkatinere, dvs. å føye to ting sammen kan gjøres ved å bruke operatoren +. De to listene
lstA =[1,2,3,4,5] og lstB=[2,4,6,8,10] kan konkatineres slik at
lstC=lstA+lstB
# gir [1,2,3,4,5,2,4,6,8,10]
Den utvidede operatoren += kan også brukes til å konkatinere lister (legge til element(er) til
lista). lstA=[1,2,3] lstA+=[4] # Gir lstA=[1,2,3,4] dvs. det samme som
lstA = lstA +[4].
Man kan endre på innhold på deler av lister ved hjelp av slice på følgene format:
liste[start:slutt:inkrement] = […]. Hvis start ikke er spesifisert, brukes 0 som
startindeks og hvis slutten ikke spesifiseres brukes len(list) som sluttindeks. Slicing-uttrykk
kan inneholde stegverdier og negative indekser, som er relative til listens slutt. Se eksempler
under:
Figur 3. Eksempler på operasjoner på lister.
Noen nyttige metoder og innebygde funksjoner
En metode er en funksjon som er tett koplet til et eller annet objekt, det være seg en liste, et
tall, en streng, eller hva som helst. Generelt kaller man en metode slik:
object.method (argumenter)
Som man kan se, ser en metode ut som et funksjonskall, bortsett fra at objektet er satt før
metodenavnet, med en prikk som skiller dem. Lister har flere metoder som lar deg undersøke
eller endre innholdet. Se eksempler under:
Opphavsrett: Forfatter og Stiftelsen TISIP
Strengbehandling og enkle beregninger
side 11 av 15
Figur 4. Eksempler på metoder som kan brukes på lister
7. Mer om funksjoner
Når vi ønsker å utføre samme operasjon flere ganger er det nyttig å definere en funksjon.
Funksjonen kan ta et antall parametre som input og returnere en resultatverdi. Parametre er
variabler som blir sendt til en funksjon når funksjonen blir kalt opp. Når man definerer/lager
en funksjon bruker man det reserverte ordet def. All koden i funksjonen (kroppen) skrives i
innrykk. Man avslutter med return (når noe skal returneres)
Det er flere fordeler med å dele opp et program i funksjoner:
Koden blir enklere å lese og forstå (mer logisk), enklere med gjenbruk av kode og testing og
debugging. I tillegg er det raskere å utvikle når man bruker funksjoner da kode som trengs i
flere deler av systemet kan brukes flere ganger. En funksjon lages ved å skrive definisjonen
av funksjonen:
def funksjons_navn ():
kode
kode
etc.
Første linje kalles funksjonshode: Markerer starten på funksjon med det reserverte ordet def,
fulgt av navnet på funksjonen, parenteser og et kolon. Resten av koden kalles ei kodeblokk
som hører til funksjonen. Kodeblokken må skrives med innrykk. Funksjoner kjøres helt
uavhengig av hovedprogrammet. En funksjon er som en miniatyr program som noen
parametere er gitt til - det da driver seg selv, og deretter returnerer en verdi.
Hovedprogrammet ser bare den returnerte verdien. Her følger et eksempel på en funksjon som
summerer to gitte tall:
# summerer to gitte tall
Opphavsrett: Forfatter og Stiftelsen TISIP
Strengbehandling og enkle beregninger
side 12 av 15
# definerer funksjonen
def add(x, y):
"""Denne funksjonen summerer to tall"""
return x + y
tall1 = input('Enter first number: ')
tall2 = input('Enter second number: ')
print(tall1,"+",tall2,"=", add(tall1,tall2))
I Python kan en funksjon returnere flere verdier, spesifisert etter return-uttrykket, atskilt av
kommaer på følgende format: return uttrykk1, uttrykk2, etc. Ved kall trenger du en variabel
på venstresiden av = for hver returnert verdi:
def get_name():
first_name=input("First name? ")
last_name=input("Last name? ")
return first_name,last_name
Her følger et eksempel med 3 verdier:
def setning(ord_1, ord_2, ord_3):
print "Setningen blir: " + ord_1 + ord_2 + ord_3
return ord_1 + ord_2 + ord_3
Man kan også ha boolsk funksjon, dvs. funksjoner som returnerer enten True eller False.
Typiske bruksområder for slike funksjoner er ved testing av et kriterium for beslutninger
(if…, while…), forenkle sjekk av inndata for gyldighet , spørre om verdier og bare godta
enkelte verdier ved å returnere True hvis inndata er en av disse. Her følger et lite program
hvor man har flere funksjoner:
# Definisjon av funksjonen lager_oslo
def lager_oslo():
antall = 1000
# Variabelen antall kun for lager_oslo()
print('Lagert i Oslo', antall,'varetyper')
# Definisjon av funksjonen lager_narvik
def lager_narvik():
antall = 2000
# Variabelen antall kun for lager_narvik()
print('Lageret i Narvik har',antall,'varetyper')
# Kall av funksjonen
def main():
lager_oslo()
lager_narvik()
main()
Opphavsrett: Forfatter og Stiftelsen TISIP
Strengbehandling og enkle beregninger
side 13 av 15
8. Bruk av modulene math og random
Python inneholder en rekke moduler og biblioteker som kan importeres til et program noe
som gir fleksibilitet i hvordan man kan gjennomføre programmet. For eksempel , for
programmer som krever matematikk , kan du importere og bruke en rekke biblioteker
innenfor Python . Hovedbiblioteket for matematiske funksjoner i Python er kjent som math.
Import og bruk av denne modulen er grei. Ved bruk av modulen:
#Import av pakke(modul)
import math
#Kalle funksjon, for eksempel
y=math.sin(x)
# Bruke konstant, for eksempel
omkr=2*math.pi*r
Math-modulen i python gir deg mer avanserte mattefunksjoner(kvadratrot, cosinus, sinus)
som ikke er med fra standard og matematiske konstanter som f.eks. pi og e. For en oversikt
over funksjonene i math se: https://docs.python.org/2/library/math.html I figur 5. følger noen
eksempler på bruk av math:
Opphavsrett: Forfatter og Stiftelsen TISIP
Strengbehandling og enkle beregninger
side 14 av 15
Figur 5. Eksempler på bruk av modulen math.
Buk av modulen random
Random-modulen i python er biblioteksfunksjoner for generering av tilfeldige tall. Mulige
bruksområder kan være spill og simuleringer og f.eks. statistiske analyser. Her er flere
eksempel på hvordan metoden kan brukes
from random import *
print random() #Gir et vilkårlig tall mellom 0 og 1:
0.024762749258158245
print randint(1,100) #tilfeldig heltall [fra,til]
L = [7, 3, 8, 5, 6]
choice(L)
print choice(L)
# liste med navn
Opphavsrett: Forfatter og Stiftelsen TISIP
Strengbehandling og enkle beregninger
side 15 av 15
liste = ['Pierre', 'Paul', 'Jacques']
print choice(liste)
9. Numpy og Scipy
Numpy
I tillegg til de tradisjonelle matematiske verktøy tilgjengelig i Python, finnes det en annen
modul kalt NumPy som man kan bruke til spesielle beregninger. NumPy er en
utvidelse/bibliotek til Python som gir tilgang til matriser og multidimensjonelle tabeller, og
støtte for disse samt et stort bibliotek med høy nivå matematiske funksjoner. NumPy er
opensource, og har vært i utvikling siden 2006. Store deler av NumPy er skrevet i C som gjør
at det er raskere en vanlig Python. Vi kommer ikke til å bruke NumPy i dette kurset. Det er
vanlig å installere NumPy som en del av en større “Scientific Computing” pakke. Man vil da
installere NumPy som en del av en samling andre relaterte verktøy.
SciPy
SciPy er et åpent kildekode Python bibliotek som brukes av forskere, analytikere, og
ingeniører til vitenskapelig og teknisk databehandling. SciPy inneholder moduler for
optimalisering, lineær algebra, integrasjon, interpolering, signal og bildebehandling, ODE
løsere og andre oppgaver som er vanlig i vitenskap og engineering.
SciPy er også et utviklingsmiljø, som inneholder blant annet SciPy og NumPy bibliotekene, i
tillegg til ipython, matplotlib, pandas med mer. SciPy bruker de multidimensjonelle tabellene
fra NumPy som datastruktur, og implementerer en egen generisk variant av de forskjellige
metodene (lineær algebra, fourier transjormasjoner og generering av pseudorandom tall) som
man også har i NumPy. I tillegg er det mange metoder i SciPy som ikke finnes i NumPy.
Fagområder som kan ha nytte av å bruke SciPy er: lineær algebra, signalprosessering,
datainnsamling og beregeningsorientert geometri.
Vi kommer ikke til å bruke SciPy i dette kurset, men hvis man er interessert kan man finne
mer informasjon om SciPy her: http://en.wikipedia.org/wiki/SciPy
Hvis man ønsker å teste ut NumPy eller SciPy anbefales det at man installerer hele samlingen
av programmer og verktøy via en distribusjon. De fleste distribusjoner er "last ned og kjør
installer”, og så er man igang. Her følger link til tre varianter som har installasjonsfiler for
Mac, Linux og Windows plattformen.
Anaconda: http://continuum.io/downloads.html
Entought: https://www.enthought.com/downloads/
Algorete Loopy: http://algorete.org
Opphavsrett: Forfatter og Stiftelsen TISIP