strengbehandling og enkle beregninger - ntnu · 2016-01-14 · strengbehandling og enkle...

Strengbehandling og enkle beregninger Claus Schive, Institutt for informatikk og e-læring ved NTNU

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

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


# 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() #Gir 'trondheim symfoni

orkester'

if 'Ole' in ['anders', 'ole', 'per']:

print 'Fant navnet!' #Finner ikke navnet

https://docs.python.org/2/


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


(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('/') #Gir ['', 'usr', 'bin', 'env']

'Using the 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.


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:

https://docs.python.org/2/


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


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>


'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.


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:


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


# 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()


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:

https://docs.python.org/2/library/math.html


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


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

http://en.wikipedia.org/wiki/SciPy

http://continuum.io/downloads.html

https://www.enthought.com/downloads/

http://algorete.org/

strengbehandling og enkle beregninger - ntnu · 2016-01-14 · strengbehandling og enkle...

Documents