return¶

Introduksjon¶

Denne uken skal vi jobbe med funksjoner i Python. La oss først se på de innebygde funksjonene i Python. Du finner en liste i Pythons dokumentasjon. Det er vel verdt å bli kjent med dokumentasjonen. Hvis du ikke kan en funksjon fra før, kan du søke den opp her og finne ut hva den gjør. Det er ikke nødvendig å lese alt dette nå, men å lese på de funksjonene du har bruk for. For nå kan det være lurt å lese på funksjonene len(), max(), min(), abs(), int(), str(), float(), round() og input().

Obs

Denne uken vil tilbakemeldingene være litt forskjellig fra tidligere ukene. I stedet for I/O tester på Codegrade-nettstedet, vil vi bruke pytest-tester som du kan kjøre selv på datamaskinen din før du laster opp til codegrade, eller kjøre som vanlig og lese resultater fra testene på Codegrade-nettstedet.

Om du vil kjøre testene selv før du laster opp, må du gjør det følgende:

Installere pytest: Skriv kommandoen python3 -m pip install -U pytest i terminalen (om det ikke fungerer, kan du også prøve å kjøre dette skriptet install.py). Du kan lese mer om pytest-modulen i pytest dokumentasjon.
Last ned testene i zip-filen uke_05_tests.zip. Lagre denne mappen i ukens oppgave og pakk ut. En bra struktur å bruke er én hovedmappe som heter uke_05 som inneholder all oppgavenefilene sammen med den test-mappen som inneholder alle tilsvarende testfiler.
Du kan kjøre alle testene samtidig fra hovedmappen din (f.eks. uke_05) med kommando i terminalen: python3 -m pytest eller du kan kjøre hver test individuelt, f.eks. test_1.py, med følgende kommando: python3 -m pytest test/test_1.py
Når vi kjører pytest vil du få litt mer informasjon enten med en gang i terminalen din eller på Codegrade hvis du velger å sjekke koden din på denne måten. Testene forteller deg hvilke testtilfeller som består, og hvilke som feiler. Ved feil vil testen gi deg litt informasjon om hvordan og hvor i koden feilen ligger. Du kan bruke denne informasjonen til å finne problemer i og forbedre koden din.

Eksempler¶

Eksempel 1¶

Funksjoner er veldig nyttige i programmering. Blant annet lar de deg gjenbruke kodeblokker for å redusere repetisjon og feil du kan gjøre mens du programmerer, fordi funksjoner gjør at man kan kjøre samme blokk med kode flere ganger, uten å måtte skrive den samme koden flere ganger. Her er et eksempel på kode hvor vi bruker funksjoner.

I koden ser du at vi ikke nødvendigvis må kalle funksjonene i samme rekkefølge som de er definert. Som argument kan en funksjon ta ingen verdier, én eller flere verdier, og verdier med blandede typer, f.eks. int og str, som vi ser nedenfor:

Last ned filen her: eksempel_1.py.

print("----------------------")
# Function that takes no input and always returns the same value
def always_12(): # funksjonsdefinisjon
    return 12 # returnverdien


print("always_12 function:")
print(always_12()) # funksjonskall (= bruk av funksjonen)
x = always_12() + 100  # funksjonskall blir erstattet med returnverdien
print(x)



print("----------------------")


# What if we want to add 2 to a given number?
print(4 + 2)
print(7 + 2)
print(1 + 2)

# We can do this easily with a function instead, with a single input argument (our given number)
def add_2(num):   # ubestemt funksjonsargument "num", blir fylt ut når vi bruker funksjonen
    return num + 2 # kan bruke num inni funksjonen, men er ikke definert utenfor


print("add_2 function:")
print(add_2(4))  # num blir sett til 4, og så erstattes funksjonskall med return-verdi
print(100 + add_2(7) + 900) # num blir sett til 7 og så erstattes funksjonskall med return-verdi


print("----------------------")


# multi-input function with only integers
def add_multiply(add, mult):
    return (2 + add) * mult


print("add_multiply function:")
print(add_multiply(2, 4))
n = 5
print(add_multiply(8, n))
print(add_multiply(n, n+n)) # funksjonsargumenter kan være hva som helt uttrykk



print("----------------------")

# multi-input function with mixed type inputs
def mixed(word, num, punct):
    result = f"{word}{punct} " * num
    return result


print("mixed type input function:")
print(mixed("Hello", 2, "!"))
print(mixed("What", 5, "?"))

Eksempel 2¶

I dette eksempelet skal vi bruke flere funksjoner sammen for å bestille kaffe og kjeks. Først en funksjon for å si hallo, og så en ny funksjon for å bestille mat.

Legg merke til at den tredje funksjonen make_order kaller de andre funksjonene med ulike argumenter, og bruker resultatene.

Kan du tegne flyten til programmet, dvs. hvilke linjer blir utført i hvilken rekkefølge når programmet kjører?

Last ned filen her: eksempel_2a.py.

print("--------------------------------------")


def hello(name):
    """Greet a person nicely"""
    text = f"Hello, {name}!"
    return text


print("Print result of hello function with Alice as input:")
print(hello("Alice"))

print("--------------------------------------")

# can you draw the program flow for this function?
def order(food, number):
    """Make an order of one type of food"""
    if number == 1:
        return f"{number} {food}"
    else:
        return f"{number} {food}s"


print("Print result of order function with food: coffee and number: 1 as inputs:")
print(order("coffee", 1))
print("--------------------------------------")
print("Print result of order function with food: coffee and number: 3 as inputs:")
print(order("coffee", 3))

print("--------------------------------------")


def make_order(name, coffee_number, cookie_number):
    """Make an order of coffee and cookies"""
    greeting = hello(name)
    coffee_order = order("coffee", coffee_number)
    cookie_order = order("cookie", cookie_number)

    return f"{greeting}\nCan I have {coffee_order} and {cookie_order}, please?"


print("Lets call make_order(2, 10) to order 2 coffees and 10 cookies from Alice:")
print(make_order("Alice", 2, 10))

Skjønner du hvordan resultatet fra de andre funskjonene gjenbrukes?

Eksempelene her bruker også «docstrings» (documentation strings). Dette er teksten som står inne i trippel-quotes """ helt i begynnelsen av en funksjon. Docstrings forklarer hva funksjonen gjør og hvordan den kan brukes av andre programmer. Prøv for eksempel å holde musen over funksjonsnavnene i VScode.

Her er et annet eksempel der vi bruker en funksjon som argument til en annen. eksempel_2b.py.

# Change recipe to call for measurement in grams instead of cups
print("--------------------------------------")
print("An American recipe calls for 2 cups of flour. How much is this in grams?")

# first function
def cups_to_grams(cups):
    return cups * 136


# second function
def flour_text(grams):
    statement_grams = f"This recipe calls for {grams}g of flour"
    return statement_grams


# chaining first and second function together:
# order of function evaluation:
# 1. the argument is evaluated first (2),
# 2. then cups_to_grams(),
# 3. then flour_text()
chained_output = flour_text(cups_to_grams(2))

print(chained_output)

Hvordan brukes den første funskjonen i den andre funksjonen? Tegn programmflytet.

Eksempel 3¶

Funksjoner kan også brukes for å gjøre matematiske beregninger. Mange ganger vil man gjøre samme beregning flere ganger. Da er det lurt å plassere koden for beregningen i en funksjon som man siden kan kalle flere ganger. Om man vil gjøre flere ulike beregninger etter hverandre kan man dessuten gjøre det. Her er et eksempel på kode hvor vi bruker funksjoner for å regne ut lengden til hypotenusen i en rettvinklet trekant og gjennomsnittet av tre tall.

Last ned filen her: eksempel_3.py.

# Her henter vi en funksjon for å regne ut kvadratrøtter
from math import sqrt

# extract common text so a varaible
def hypotenus(katet_1, katet_2):
    """Beregn hypotenusen fra to kateter"""
    hyp = sqrt(katet_1 ** 2 + katet_2 ** 2)
    return hyp


common_text = "Lengden av hypotenusen på den rettvinklete trekanten med katetlengdene"
print(common_text, "4 og 1 er", hypotenus(4, 1))

a = 3
b = 4
print(f"{common_text} {a} og {b} er {hypotenus(a, b)}")

c = 7
d = 2
print(f"{common_text} {c} og {d} er {hypotenus(c, d)}")


def middelverdi(a, b, c):
    """Beregn middelverdi av tre tall"""
    mv = (a + b + c) / 3
    return mv


# Kan du skrive om de neste linjene med en ny funksjon 
# slikt at det blir mindre repetisjon?
print(f"Middelverdien av tallene 17, 3 og 25 er {middelverdi(17, 3, 25)}")
print(f"Middelverdien av tallene 24, 72 og 13 er {middelverdi(24, 72, 13)}")
resultat = middelverdi(92, 64, 89)
print(f"Middelverdien av tallene 92, 64 og 89 er {resultat}")


# Vi kan bruke disse funksjoner (middelverdi og hypotenus) sammen
mv_hyp = middelverdi(hypotenus(4, 1), hypotenus(3, 4), hypotenus(7, 2))
print(f"Middelverdien av hypotenusene ovenfor er {mv_hyp}")

Kjør koden. Ble outputen hva du hadde ventet deg? Kan du lage noen funksjoner til, for å unngå repetisjonen i print-linjene?

Eksempel 4¶

I dette eksempelet bruker vi en funksjon for en beregning og en funksjon for å lage en streng. Vi beregner og printer andregradspolynomer.

Last ned filen her: eksempel_4.py.

def poly_string(a, b, c):
    """Create a string representation ax^2 + bx + c"""
    return f"{a} x^2 + {b} x + {c}"


def poly_value(a, b, c, x):
    """Calculate the value of ax^2 + bx + c at the point x"""
    square = a * x ** 2
    linear = b * x
    const = c
    return square + linear + const


def pretty(a, b, c, x):
    """Calculate and print a quadratic polynomial"""
    poly = poly_string(a, b, c)
    value = poly_value(a, b, c, x)
    return f"The value of {poly} for x = {x} is {value}"


print(pretty(2, 7, 3, 3))
print(pretty(4, 5, 2, 9))

Her brukes return i poly_string(). Prøv å endre koden slik at poly_string() printer strengen, i steden for å bruke return. Hva skjer?

Eksempel 5¶

Det er mulig å definere en funksjon i Python uten å bruke return. Da returnerer Python verdien None i bakgrunnen. Husk at om du vil gi verdien fra en funksjon til en annen funksjon må du bruke return.

Last ned filen her: eksempel_5.py.

# Difference in assigning a variable vs printing a variable

print("----------------")
x = 50

print("================")
y = print(50)

print("----------------")

print(f"The value of x is: {x}")
print(f"The value of y is: {y}")

Hva er forskjellen på x og y?

Hvis vi skal bruke 50 igjen senere i programmet, burde vi se på x eller y?

Eksempel 6¶

Funksjoner uten return (de har return-verdien None) brukes ofte for å gruppere instrukser som hører sammen, og skal gjenbrukes flere ganger. Nå kan vi endre på ting på ett sted og få den endringen med på alle steder der funksjonen er brukt. Om vi hadde kopiert instruksjonene flere ganger uten å bruke en funksjon måtte vi fikset hver enkel kopi.

Last ned filen her: eksempel_6.py.

# Functions can also be used to keep related instructions together
# allowing them to be reused consistently, e.g. to make "drawings"
def ascii_wave():
    """Print an ascii wave"""
    print("\\" * 40)
    print("/" * 40)
    print("\\" * 40)


def ascii_cat():
    """Print an ascii cat"""
    print(" /\_/\\")
    print("( o.o )")
    print(" > ^ <")


def ascii_cube():
    """Print an ascii cube"""
    print("+------+.")
    print("|`.    | `.")
    print("|  `+--+---+")
    print("|   |  |   |")
    print("+---+--+.  |")
    print(" `. |    `.|")
    print("   `+------+")


def ascii_castle():
    """Print an ascii castle"""
    print(" _   |~  _")
    print("[_]--'--[_]")
    print('|\'|""`""|\'|')
    print("| | /^\\ | |")
    print("|_|_|I|_|_|")


print()
print("Here is a cat:")
ascii_cat()

print()
print("Here are two cats:")
ascii_cat()
ascii_cat()

print()
print("We can also print a castle:")
ascii_castle()


print()
print("Or a cat on a wave:")
ascii_cat()
ascii_wave()

Kjør koden. Hvorfor blir ikke ascii_cube() skrevet ut?

Obs

Noen steder i koden er det brukt en ekstra \. Se for eksempel på ascii_castle(). Her står det \' noen steder, men når vi kjører programmet printes ikke \. Dette er fordi \ er en så kalt ’escape character’. Vi kan bruke \ før tegn som ellers ville ha noen annen betydning i en streng. For eksempel, om vi ikke hadde brukt \ før ' ville Python trodd at strengen var slutt ved ' og vi hadde fått en feilmelding (prøv gjerne). Men når vi putter \ før ' sier vi til Python at vi ikke mener at strengen er slutt her, uten at Python skal printe tegnet '. Siden \ er et spesielt tegn på denne måten må vi bruke \ før \ om vi vil at Python skal lese strengen som tegnet \ og ikke som en escape character. Det er derfor det står \\ på alle steder hvor vi vil printe \. Du kan lese mer om escape characters her, og her er en liste med eksempler på alle escape characters i Python 3.

Eksempel 7¶

Her er eksempler på de mange måtene vi kan bruke funksjoner til å tegne enkle eller kompleksere former i turtle-modulen.

Eksperimenter med å justere verdiene til de forskjellige variablene for å se hvordan dette endrer tegningen din for hvilken funksjon du velger å kalle.

Last ned filen her: eksempel_turtle.py.

from math import sin, cos
import turtle as t

t.speed(0)  # adjust speed of turtle, 0 is fastest, 1 is slowest
t.hideturtle()

# single shape
def square(sidelength):
    for i in range(4):
        t.forward(sidelength)
        t.right(90)


def star(num_points, sidelength):
    ext_angle = 180 - (180 / num_points)
    for i in range(num_points + 1):
        t.forward(sidelength)
        t.right(ext_angle)


def triangle(sidelength):
    for i in range(3):
        t.forward(sidelength)
        t.left(120)


# chained function to draw many shapes
def many_squares(num_of_shapes):
    for i in range(num_of_shapes):
        t.setheading(5 * i)  # rotate by 5 degrees further with each iteration
        square(80)  # draw square in rotated position


def spiral_squares(num_of_shapes, sidelength):
    for i in range(num_of_shapes):
        t.setx(0)
        t.sety(0)
        t.setheading(5 * i)  # rotate by 5 degrees further with each iteration
        square(sidelength)  # draw square in rotated position
        sidelength += 5


def spiral_stars(num_of_shapes, sidelength):
    t.color("violet", "light blue")
    t.begin_fill()
    for i in range(num_of_shapes):
        t.setx(0)
        t.sety(0)
        t.setheading(5 * i)
        star(5, sidelength)
        sidelength += 5
    t.end_fill()


# draw more complex shape
def trefoil():  # amplitude, angular displacement
    t.screensize(400, 400, "#005744")  # set background color
    t.pensize(3)  # set width of pen stroke

    # experiment with changing these variables - how does the drawing change?
    s = 0
    a = 80
    k = 3
    r = 40
    linework = "#019879"

    # draw expanding trefoil
    t.penup()
    for i in range(0, 1500):
        t.color(linework)
        s += 0.01
        a += 0.05

        x = a * cos(k * s) * cos(s)
        y = a * cos(k * s) * sin(s)

        t.goto(x, y)
        t.pendown()

    # draw circle
    t.penup()
    for i in range(0, 620):
        t.color(linework)
        s += 0.01
        x = r * cos(s)
        y = r * sin(s)

        t.goto(x, y)
        t.pendown()


#### CALL FUNCTION ###

# many_squares(60)
# spiral_stars(60, 5)
trefoil()

t.done()

Eksempel 8¶

Her er et eksempel på hva som skjer om man ikke bruker return i funksjoner.

Hva om vi vil lagre resultatet i en variabel? For eksempel, hvis vi vil huske navnet fra tidligere funksjon hello kan vi lagre resultatet i myName. I eksempelet er det to funksjoner: hello1 og hello2. hello1 bruker print() mens, hello2 bruker return i slutten av funskjonen.

Last ned filen her: eksempel_8.py.

# Function using print()
def hello_printed(name):
    """Greet a person nicely"""
    text = f"Hello, {name}! How are you?"
    print(text)
    print("you do not see me until this function is called")


myName_1 = hello_printed("Ola")
print(f"hello_printed gives us: {myName_1}")  # Why does this give None?

# Same function, but using return statement instead to store the result of the function
def hello_ret(name):
    """Greet a person nicely"""
    text = f"Hello {name}! How are you?"
    return text


myName_2 = hello_ret("Ola")
print(f"hello_ret gives us: {myName_2}")

Kjør koden. Hva er forskjellen på hello1 og hello2? Hva lagres i myName?

Det er ikke vanlig å ha med print() i en funksjon som skal regne ut noe. Returner verdien eller en streng i steden for. Da kan brukeren til funksjonen bestemme om det skal printes noe eller om verdien skal gjenbrukes på en annen måte.

Eksempel 9¶

Last ned filen her: eksempel_9.py.

def avstand(tall_1, tall_2):
    """Regn ut avstand mellom to tall"""
    avst = abs(tall_1 - tall_2)
    print(avst)


def den_er_feil():
    """Denne funksjonen skulle ikke kjøre, men det fungerer uansett?"""
    abc = 5
    return xyz  # forventer NameError... her


print("vvvvvvvvvvvvvvvv")

avst_1 = avstand(14, -9)
avst_2 = avstand(-36, 23)

print("Avstanden mellom tallene 14 og -9 er", avst_1)
print("Avstanden mellom tallene -36 og 23 er", avst_2)

print("Den største av disse avstandene er", max(avst_1, avst_2))

print("^^^^^^^^^^^^^^^^")

Når du prøver å kjøre koden får du en feilmelding.

Se på det vanlige outputet før feilmeldingen: hvorfor ser det slik ut?
Hvorfor får du error når du kjører koden?
Hvorfor blir ikke den siste raden skrevet ut?
Endre koden slik at den kjører.
Hvorfor fikk du ingen feilmelding fra den_er_feil()-funksjonen?

Oppgaver¶

I disse oppgavene skal du lage og bruke funksjoner.

Advarsel

Ikke bruk input() i koden din, fordi da vil autotestene ikke kjøre.

Oppgave 1¶

Obs

Oppgave 1 består av fem deler. Skriv alle funksjoner til de fem delene (a-e) i én felles fil: uke_05_oppg_1.py

I filen uke_05_oppg_1.py, skriv en funksjon

def multiply_5_plus_2(my_number):
    # din kode her
Funksjonen skal

ta et argument (av typen int),

multiplisere dette med 5 og legg til 2,

returnere resultatet. Det er ikke nødvendig å printe ut resultatet.

For eksempel skal multiply_5_plus_2(4) returnere verdien 22.

Nå skal vi prøve et likt problem som oppgave 1, men denne tiden med typen str. Skriv en funksjon

def make_excited(text):
    # din kode her
Funksjonen skal

ta et argument (av typen str),

legge til en "!" til slutten av ordet eller frasen,

returnere resultatet.

Ikke ta input fra brukeren, bare lag funksjonen. Om du vil sjekke den, kan du f.eks printe den med ulike argumenter.

make_excited("I love programming") skal returnere strengen "I love programming!"

Skriv en funksjon som heter

def name_age(name, gender, age):
    # din kode her
Funksjonen skal ta tre argumenter:

navnet til en person,

personens kjønn og

personens alder.

Navnet og kjønn er en str og alderen er int.

Funksjonen skal returnere en streng med setningen "... er ... og er ... år gammel." For eksempel skal name_age("Ola", "kvinne", 7) returnere strengen "Ola er kvinne og er 7 år gammel."

Skriv en funksjon som heter my_math(). Funksjonen skal ta to argumenter \(x\) og \(y\) og skal returnere \(x^2 + 2y\).
```
def my_math(x, y):
    # din kode her
```
For eksempel skal my_math(2, 2) returnere verdien 8.
I denne delen skal vi bruke med min() og max() for å identifisere den yngre av to mennesker. Skriv en funksjon
```
def hvem_yngre(person1, age1, person2, age2):
    # din kode her
```
som tar som input fire argumenter: navnet på første personen (string), alderen på første personen (int), navnet på andre personen (string), alderen på andre personen (int).

Funksjonen bestemmer hvem som er yngre og returnerer en setning som angir navn og alder på den yngre personen, vist i det følgende eksempelet: hvem_yngst("Ola", 43, "Katrine", 23) skal returnere strengen "Katrine er 23 år og er yngre."

Vi ser bort fra tilfellet der begge har lik alder.

Oppgave 2¶

I denne oppgaven skal vi dra tilbake til uke_02 der vi laget en ramme rundt et haiku. Denne gangen vil vi skrive dette som en funksjon, og vi skal ikke bruke print() i funksjonen.

I filen uke_05_oppg_2.py, skriv en funksjon som heter draw_haiku_frame() som tar de tre radene i en haiku som tre argumenter og returnerer en streng med hele haikuen med høyrejustering og med en ramme av «@» runt.

For eksempel, om vi printer resultatet av draw_haiku_frame("What a pleasure to", "Right justify a haiku", "As an exercise") skal vi få følgende output:

@@@@@@@@@@@@@@@@@@@@@@@@@
@    What a pleasure to @
@ Right justify a haiku @
@        As an exercise @
@@@@@@@@@@@@@@@@@@@@@@@@@

Obs

TIPPS: Som vi gjorde sist, kan du bruke len() og max() til å finne lengden av den lengste raden. Så printer du hver rad med så mange mellomrom før raden som det er forskjell mellom den raden og den lengste raden i haikuen, husk å printe en rad med @ før og etter haikuen og husk å printe @ i starten og slutten av hver rad med tekst. Hvor mange tegn lengre må toppen og bunnen av rammen være enn den lengste raden i haikuen?

Oppgave 3 - pH-verdier¶

Begrepet \(pH\) er en forkortelse for potensialet til hydrogen. pH er en måleenhet som representerer konsentrasjonen av hydrogenioner i en løsning.

En løsning med hydr.-konsentrasjon \(0.1\frac{\mathrm{mol}}{\mathrm{L}}\) har pH-verdien \(1\),
En løsning med hydr.-konsentrasjon \(0.01\frac{\mathrm{mol}}{\mathrm{L}}\) har pH-verdien \(2\),
En løsning med hydr.-konsentrasjon \(0.001\frac{\mathrm{mol}}{\mathrm{L}}\) har pH-verdien \(3\), osv…

Om vi kaller konsentrasjonen for \([H^+]\), beregnes pH-verdien med følgende ligning:

\[pH = -log_{10}\,[H^+]\]

pH-skalaen beskriver surheten til løsningen: sur, nøytral eller basisk. En løsning med pH mindre enn 7 er en syre, nøyaktig 7 er en nøytral løsning og over 7 er en base.

I filen uke_05_oppg_3.py skal du definere følgende funksjonene:

pH_from_conc() skal ta som input et tall som er konsentrasjonen av hydrogenioner i en løsning (vi antar at enhet er \(\frac{\mathrm{mol}}{\mathrm{L}}\)) og skal returnere pH til løsningen som float.

For eksempel, en \(0.20\frac{\mathrm{mol}}{\mathrm{L}}\) HCl-løsning har en pH av 0.6989.

from math import log10 # du må inkludere denne linjen for å importere pythons-loggfunksjonen

def pH_from_conc(conc):
   # din kode her

Den andre funksjonen skal hete find_acidity(), og bør ta som input en konsentrasjons-verdi og returnere dens surhet som string: enten acidic, neutral eller basic. TIPS: Gjenbruk din første funksjon i denne funksjonen.

def find_acidity(conc):
   # din kode her

Oppgave 4¶

Den Hydrostatiske Balansen - Del I

Trykket (P) i atmosfæren og i det indre hav kan i en første tilnærming beskrives som hydrostatisk. Trykket (i enheten Pascal), som en partikkel plassert på en dybde \(z\) i havet er utsatt for gis av følgende formel:

\[P = \rho \cdot g \cdot z\]

hvor \(\rho\) er vanndensiteten (med enheten \(\text{kg} \cdot \text{m}^{-3}\)), \(g\) er tyngdekraftens akselerasjon (med enheten \(\text{m} \cdot \text{s}^{-2}\)) og \(z\) er partikkelens dybde (med enheten \(\text{m}\)). SI-enheten for trykk er Pascal \([\text{Pa}]\), men i meteorologi og oceangrafi blir dokk trykk vanligvis presentert i enheten decibar \([\text{dbar}]\). Disse to henger sammen ifølge formelen: \(1\,\text{Pa} = 10^{-4}\,\text{dbar}\).

I filen uke_05_oppg_4.py skriv en funksjon som heter hyd_pres() og som beregner trykket på en gitt dybde i enheten \(\text{dbar}\). Argumentene til funksjonen skal være: en densitetsverdi (\(\rho\)), tyngdekraftens akselerasjon (\(g\)) og dybden (\(z\)). Se koden nedenfor for en oversikt over hvordan du kan nærme deg dette problemet.

def hyd_pres(density, g, z):
   # din kode her

   # første, beregne trykk i Pascal (Pa)
   # deretter, konvertere trykk i Pascal (Pa) til trykket i dbar
   return # trykket i dbar

For eksempel, om vi bruker densiteten \(\rho = 1025\,\text{kg} \cdot \text{m}^{-3}\) og tyngdeakselerasjonen \(g = 10\,\text{m} \cdot \text{s}^{-2}\) så er trykket \(102.5\, \text{dbar}\) på dybde \(100\, \text{m}\). Det betyr altså at hyd_pres(1025,10,100) skal returnere verdien 102.5.

Pytest-filer¶

Pytest-filene vi bruker på Codegrade: uke_05_tests.zip