Python
funksjoner

 

Etter å ha lært om datatyper, tilordning, datastrukturer, betingelser, valg og løkker er du nå istand til å skrive alle typer programmer.

 

Eller?

Det som kommer nå vil hjelpe deg til å skrive bedre programmer, mer oversiktlige og med mindre feil.

 

Du vil få bedre kontroll på programutviklingen, og det vil bli lettere å snakke med andre om dine dataprogrammer.

Abstraksjoner

Pr. def.

Abstraksjon er noe som bare er tenkt og ikke-sanselig, som mangler konkret og sansbar virkelighet. Se abstrahere.

Abstraksjon:

Tjønneland, Eivind. (2018, 26. november). abstraksjon.
I Store norske leksikon. Hentet 28. oktober 2019 fra https://snl.no/abstraksjon

Pr. def.

Abstrahere betyr å sammenfatte enkeltfenomener under ett begrep idet man ser bort fra avvikende detaljer.

 

 

Abstrahere:

Tjønneland, Eivind. (2018, 26. november). abstrahere.
I Store norske leksikon. Hentet 28. oktober 2019 fra https://snl.no/abstrahere

In software engineering and computer science, abstraction is:

  • the process of removing physical, spatial, or temporal details or attributes in the study of objects or systems in order to more closely attend to other details of interest; it is also very similar in nature to the process of generalization;
     
  • the abstract concept-objects which are created by keeping common features or attributes to various concrete objects or systems of study — the result of the process of abstraction.

Abstraction (computer science):

Abstraction, in general, is a fundamental concept to computer science and software development.

 

The process of abstraction can also be referred to as modeling and is closely related to the concepts of theory and design.

 

Models can also be considered types of abstractions per their generalization of aspects of reality.

Abstraction (computer science), forts.:

Abstraction (computer science)
Wikipedia. Hentet 28. oktober 2019 fra
https://en.wikipedia.org/wiki/Abstraction_(computer_science)

Programmering, eller rettere hele prosessen med programutvikling, handler om å finne gode abstraksjoner:

 

- variabler (skjuler detaljer om en dataverdi og  lagringsmetode)

- datastrukturer (skjuler detaljer om enkelt-verdier)

- funksjoner (skjuler detaljer om programforløp)

 

Felles for disse tre typene er at vi som progammerere gir de navn.
Det er viktig å finne gode, beskrivende navn.

Hva er en funksjon?

 

Halterman, Ch. 6, Using Functions:

 

            A function is a unit of reusable code.

 

Alternativet til å bruke funksjoner er å gjenta kode hvis samme kode behøves flere steder.

 

Kan lett føre til feil ved at det blir ulik kode på hvert sted.

 

# Beregner euklidisk avstand mellom to punkt

def euclidDistance(p1, p2):
    x_dist = p2[0] - p1[0]
    y_dist = p2[1] - p1[1]
    hypotenuse = math.sqrt(x_dist**2 + y_dist**2)
    return hypotenuse
# Bruk av funksjon

punktsky = [(0, 0), (10, 23), (5, 19)]

print("Avstanden mellom 1. og 2. punkt er:")
print(euclidDistance(punktsky[0], punktsky[1]))

print("Avstanden mellom 2. og 3. punkt er:")
print(euclidDistance(punktsky[1], punktsky[2]))

Analyse av punktsky (simulering):

 

  1. Trekker tilfeldige tall og lager et datasett av disse
  2. Beregne nærmeste nabo-avstander
  3. Beregne gjennomsnittlig nærmeste nabo-avstand
  4. Lage plott av datasettet
# Trekker tilfeldige tall og lager datasett av disse
pointcloud = createRandomPoints(n, mu, sigma)

# Beregner nærmeste nabo-avstander (Nearest Neighbour)
pointcloud_NN = NN(pointclou)

# Beregner gjennomsnittlig nærmeste nabo-avstand
pointcloud_mean_NN = mean_NN(pointcloud_NN)

# Henter ut X- og Y-verder fra datasettene
X, Y = make_XY(pointcloud)

make_plot(X, Y)

print(pointcloud_mean_NN)
# Funksjon for å lage et datasett ved simulering - 
# trekking av tilfeldige tall fra normalfordeling
#
# n: antall punkt som skal genereres
# mu: forventning
# sigma: standardavvik

def createRandomPoints(n, mu, sigma):
    S = {}
    for i in range(1, n + 1):
        x = random.normalvariate(mu,sigma)
        y = random.normalvariate(mu,sigma)
        S[i] = x, y
    return S
# Beregner nærmeste nabo-avstand for alle punkter 
# innbyrdes i datasettet

def NN(P, infinity):
    D = {}
    for i in P:
        dMin = infinity
        for j in P:
            if i is not j:
                d = euclidDistance(P[i], P[j])
                if d < dMin:
                    dMin = d
                    D[i] = dMin
    return D
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# Beregner gjennomsnittlig nærmeste nabo-avstand
#
# D: Dictionary med nærmeste nabo-avstander

def mean_NN(D):
    n = len(D)
    sum_distances = 0
    for i in D:
        sum_distances += D[i]
    return sum_distances/n
# Lager lister med X- og Y-koordinater for plotting (hver akse for seg)
# 
# P: Datasett bestående av punkter med X- og Y-verdier

def make_XY(P):
    X = []
    Y = []
    for i in P:
        X.append(P[i][0])
        Y.append(P[i][1])
    return X, Y
# Lager plot av punktsky
#
# X: X-verdier
# Y: Y-verdier

def makePlot(XS, YS):
    
    pylab.plot(XS, YS, 'o')
    pylab.axis([0, 100, 0, 100])
    pylab.grid(True)
    pylab.xlabel("x-coordinate")
    pylab.ylabel("y-coordinate")
        
    pylab.show()
# Importerer hjelpefunksjoner

import math
import random
import pylab
# Definerer konstanter

infinity = 2**100 # Stort tall
# - setter inn verdier for variabler som brukes ved simulering

n = 50      # Antall punkt

mu = 50     # Forventet gjennomsnittlig verdi
sigma = 15  # Standardavvik
# - kaller simuleringsfunksjoner
# - lager datastrukturene som brukes ved plotting
# - kaller plottefunksjon

# Trekker tilfeldige tall og lager datasett av disse
pointcloud = createRandomPoints(n, mu, sigma)

# Beregner nærmeste nabo-avstander
pointcloud_NN = NN(pointcloud, infinity)

# Beregner gjennomsnittlig nærmeste nabo-avstand
pointcloud_mean_NN = mean_NN(pointcloud_NN)

# Henter ut X- og Y-verder fra datasettene
X, Y = make_XY(pointcloud)

make_plot(X, Y)

print("Gjennomsnittlig nærmeste-nabo-avstand: ", pointcloud_mean_NN)

Mer om funksjoner:

 

- Udacity-kurset

 

- Lærebok (Halterman):

      Ch. 6: Using Functions

      Ch. 7: Writing Functions