Visual Studio Code for kjemikere#

Visual Studio Code, vanligvis kalt VS Code, er en populær og kraftig editor som kan brukes til både vanlige Python-programmer og Jupyter-notebooks. VS Code er et omfattende program, men du trenger i første omgang bare en liten del av funksjonaliteten. Målet med dette kapitlet er derfor ikke å gjøre deg til programvareutvikler. Målet er at du skal kunne åpne, kjøre, endre og organisere Python-kode på en trygg måte, slik at du kan konsentrere deg om kjemien.

Læringsutbytte

Etter å ha arbeidet med dette kapitlet, skal du kunne:

  1. åpne en arbeidsmappe og kjenne igjen de viktigste delene av VS Code

  2. velge riktig Python-miljø og riktig kjerne i en Jupyter-notebook

  3. opprette, lagre og kjøre en vanlig Python-fil (.py)

  4. opprette og arbeide med en Jupyter-notebook (.ipynb)

  5. kjøre hele programmer og enkeltceller på en kontrollert måte

  6. installere og importere vanlige Python-biblioteker

  7. organisere kode og data slik at relative filstier fungerer

  8. bruke feilmeldinger og noen enkle strategier til å finne feil

Hva du ikke trenger å lære nå

VS Code inneholder verktøy for blant annet versjonskontroll, automatiske tester, avansert feilsøking, fjernkjøring og utvikling av store programmer. Dette kan være nyttig senere, men er ikke nødvendig for å komme i gang med programmering i kjemi.

I første omgang trenger du hovedsakelig Explorer, Editor, Terminal, valg av Python interpreter og valg av kernel i notebooks.

Slik arbeider du med dette kapitlet#

Denne siden kan leses i nettleseren, men øvelsene skal gjøres i VS Code på din egen maskin. Hvis du leser nettsideversjonen, kan du laste ned notebookfila (.ipynb) fra nedlastingsmenyen øverst på siden. Lagre den i arbeidsmappa for emnet og åpne mappa i VS Code.

Du kan også følge instruksjonene på nettsida og opprette en ny notebook selv. Det viktigste er at du faktisk prøver handlingene underveis: velger miljø, lager filer, kjører kode og starter kernelen på nytt.

Hva er VS Code?#

VS Code er en editor som kan utvides med støtte for forskjellige programmeringsspråk og filtyper. Når vi installerer utvidelsene for Python og Jupyter, kan vi bruke VS Code til å:

  • skrive og kjøre Python-filer

  • åpne og kjøre Jupyter-notebooks

  • lese feilmeldinger i en integrert terminal

  • inspisere variabler, tabeller og grafer

  • få forslag til funksjonsnavn og dokumentasjon mens vi skriver

VS Code er ikke det samme som Visual Studio, selv om navnene likner. Det er VS Code vi skal bruke i dette emnet.

Editor og Python

VS Code er arbeidsflaten der du skriver og organiserer kode. Python er språket som tolker og utfører instruksjonene. Du trenger derfor både VS Code og en Python-installasjon.

Arbeidsflyten i emnet#

Vi skal hovedsakelig bruke to filtyper. Begge kan åpnes i VS Code.

Filtype

Hva inneholder den?

Typisk bruk i emnet

.py

Et sammenhengende Python-program

Grunnleggende programmering, oppgaver og programmer som skal kunne kjøres fra start til slutt

.ipynb

Tekst, kodeceller og resultater i samme dokument

Datahåndtering, visualisering, statistikk, numeriske undersøkelser og dokumentasjon av en analyse

Jupyter-notebook

En Jupyter-notebook er et dokument som kan inneholde både tekst, kjørbar programkode, tabeller, figurer og resultater. Filnavnet slutter på .ipynb.

1. Installer det du trenger#

VS Code og Python#

  1. Last ned og installer Visual Studio Code.

  2. Sørg for at du har en nyere versjon av Python 3. Det kan være Python installert direkte på maskinen, eller Python gjennom f.eks. Anaconda-distribusjonen.

  3. Åpne VS Code.

Utvidelser#

Klikk på Extensions-ikonet i venstre marg. Søk etter og installer disse to utvidelsene fra Microsoft:

  • Python

  • Jupyter

Python-utvidelsen gir blant annet støtte for å kjøre Python-filer og velge Python-miljø. Jupyter-utvidelsen gjør det mulig å opprette og kjøre notebooks. Du trenger ikke installere mange ekstra utvidelser nå.

Kontroller utgiveren

Det finnes mange utvidelser med liknende navn. Kontroller at utvidelsene Python og Jupyter er utgitt av Microsoft.

En rask kontroll#

Åpne Command Palette med Ctrl+Shift+P i Windows og Linux eller Cmd+Shift+P på macOS. Begynn å skrive Python:. Dersom du får opp kommandoer som Python: Select Interpreter, er Python-utvidelsen aktiv.

Søk deretter etter Jupyter:. Dersom du blant annet finner en kommando for å opprette en ny notebook, er Jupyter-utvidelsen aktiv.

Hvis kommandoene ikke vises, bør du først kontrollere at utvidelsene er installert og aktivert. Det kan også hjelpe å lukke og åpne VS Code etter installasjonen.

2. Opprett og åpne en arbeidsmappe#

Lag en mappe på datamaskinen med et tydelig navn, for eksempel IN-KJM1900. Velg deretter File → Open Folder i VS Code og åpne denne mappa.

Det er bedre å åpne hele arbeidsmappa enn å dobbeltklikke på én enkelt kodefil. Når VS Code kjenner arbeidsmappa, blir det lettere å:

  • finne kode- og datafiler i Explorer

  • huske hvilket Python-miljø som hører til arbeidet

  • bruke relative filstier

  • opprette undermapper for ulike deler av emnet

En enkel mappestruktur kan etter hvert se slik ut:

COURSE_NAME/
├── basic_programming/
│   ├── first_program.py
│   └── exercises.py
├── data_handling/
│   ├── first_notebook.ipynb
│   └── data/
│       └── uvvis.csv
└── figures/

Arbeidsmappe

Arbeidsmappa er den øverste mappa for arbeidet ditt. VS Code bruker den som utgangspunkt når programmet skal finne filer, innstillinger og Python-miljø.

3. Finn fram i VS Code#

Når du har åpnet ei mappe, ser du flere områder i vinduet.

Område

Hvor finner du det?

Hva bruker vi det til?

Activity Bar

Ikonene lengst til venstre

Bytte mellom Explorer, søk og utvidelser

Explorer

Sidepanelet til venstre

Se, åpne, opprette og organisere filer og mapper

Editor

Det store feltet i midten

Skrive kode og arbeide med notebooks

Panel

Vanligvis nederst

Vise Terminal, feilmeldinger og andre resultater

Status Bar

Nederst i vinduet

Vise blant annet valgt Python-miljø

Du kan flytte og skjule mange av disse områdene. Hvis skjermen din ser litt annerledes ut enn beskrivelsen, betyr det derfor ikke nødvendigvis at noe er galt.

Command Palette#

Command Palette er en søkbar liste over kommandoer i VS Code. I stedet for å huske hvor alle valgene ligger i menyene, kan du åpne paletten og søke etter det du vil gjøre. Noen av de viktigste kommandoene i dette kapitlet er:

  • Python: Select Interpreter

  • Python: Create Environment

  • Create: New Jupyter Notebook

  • Developer: Reload Window

Du trenger ikke huske kommandoene ordrett. Skriv noen få relevante ord og velg fra lista.

Workspace Trust#

Første gang du åpner ei mappe, kan VS Code spørre om du stoler på innholdet. Python-kode og notebooks kan i prinsippet inneholde skadelige instruksjoner. Velg derfor bare Trust når mappa inneholder filer du har laget selv eller fått fra en kilde du stoler på, for eksempel emnets offisielle materiale.

Hvis VS Code står i Restricted Mode, kan kjøring av notebook-celler og enkelte andre funksjoner være sperret. Kontroller Workspace Trust dersom riktige utvidelser og riktig kernel er valgt, men cellene likevel ikke kan kjøres.

Noen få nyttige hurtigtaster#

Handling

Windows/Linux

macOS

Åpne Command Palette

Ctrl+Shift+P

Cmd+Shift+P

Lagre

Ctrl+S

Cmd+S

Kjør valgt linje eller notebook-celle

Shift+Enter

Shift+Enter

Kommenter eller fjern kommentar

Ctrl+/

Cmd+/

Søk i åpen fil

Ctrl+F

Cmd+F

Hurtigtaster er nyttige, men ikke nødvendige. De samme handlingene finnes også i menyer eller knapper.

4. Python-miljø, interpreter og kernel#

Dette er den delen av oppsettet som skaper flest problemer for nye brukere. Begrepene er enklere enn de først kan virke.

Python-interpreter

En interpreter er Python-programmet som leser og kjører koden din. Datamaskinen kan ha flere Python-interpretere installert samtidig.

Python-miljø

Et Python-miljø består av en Python-interpreter og bibliotekene som er installert sammen med den. Ett miljø kan for eksempel inneholde NumPy og Pandas, mens et annet ikke gjør det.

Kernel

En kernel er prosessen som kjører kodecellene i en Jupyter-notebook. For en Python-notebook velger vi vanligvis et av Python-miljøene våre som kernel.

I en .py-fil må du altså velge riktig interpreter. I en .ipynb-fil må du velge riktig kernel. I praksis bør begge peke til det samme Python-miljøet for emnet.

Et vanlig problem

Hvis import numpy fungerer i én fil, men gir feil i en annen, bruker filene ofte forskjellige Python-miljøer. Kontroller valgt interpreter eller kernel før du installerer biblioteket på nytt.

Opprett et miljø for emnet#

Hvis du ikke har fått et ferdig miljø eller en egen installasjonsoppskrift, kan du opprette et lokalt miljø i arbeidsmappa:

  1. Åpne Command Palette.

  2. Velg Python: Create Environment.

  3. Velg Venv.

  4. Velg Python-versjonen du har installert.

  5. Vent til VS Code har opprettet mappa .venv.

  6. Kontroller at dette miljøet er valgt nederst i Status Bar. Hvis ikke, bruk Python: Select Interpreter og velg miljøet som inneholder .venv.

En slik .venv-mappe er et avgrenset miljø for akkurat denne arbeidsmappa. Det reduserer risikoen for at bibliotekene til forskjellige emner og prosjekter kommer i konflikt.

Hvis du bruker Anaconda eller Miniconda

Dersom emnet har gitt deg et miljø med Anaconda (Conda-miljø), skal du normalt velge dette med Python: Select Interpreter i stedet for å opprette et ekstra .venv-miljø. Du trenger ikke bruke begge systemene samtidig.

Installer biblioteker i riktig miljø#

Velg Terminal → New Terminal. Når riktig miljø er valgt, vil VS Code vanligvis aktivere det automatisk i en ny terminal. Navnet på miljøet, for eksempel (.venv), vises ofte først på kommandolinja.

Bibliotekene vi bruker mye, kan installeres med:

python -m pip install numpy matplotlib pandas scipy seaborn sympy

Kommandoen python -m pip ber den valgte Python-interpreteren om å bruke sin egen pakkeinstallerer. Det gjør det mindre sannsynlig at bibliotekene blir installert i et annet miljø enn det du faktisk bruker.

Ikke installer på nytt med en gang

Hvis en import feiler, kontroller først interpreter eller kernel. ModuleNotFoundError skyldes ofte at riktig bibliotek finnes i et annet miljø, ikke at det mangler helt på maskinen.

5. Lag og kjør en Python-fil#

Vi begynner med et vanlig Python-program.

  1. Klikk på New File i Explorer.

  2. Kall fila first_program.py. Endelsen .py forteller VS Code at fila inneholder Python-kode.

  3. Skriv eller lim inn programmet nedenfor.

  4. Lagre fila.

Programmet regner ut stoffmengden NaCl fra masse og molar masse.

mass_g = 2.922
molar_mass_g_mol = 58.44
amount_mol = mass_g / molar_mass_g_mol

print(f"Amount of NaCl: {amount_mol:.3f} mol")

Kjør hele programmet#

Når first_program.py er åpen, klikker du på den trekantede knappen Run Python File in Terminal øverst til høyre i editoren. VS Code lagrer og kjører da fila med den valgte interpreteren. Resultatet vises i Terminal nederst.

Du kan også høyreklikke i editoren og velge Run Python File in Terminal. Når du arbeider med et sammenhengende program, bør du med jevne mellomrom kjøre hele fila fra start. Da oppdager du om programmet er avhengig av variabler som bare finnes fordi du tidligere har kjørt noen enkeltlinjer.

Kjør deler av programmet#

Marker én eller flere linjer og trykk Shift+Enter. Koden sendes da til en interaktiv Python-terminal. Dette er nyttig når du vil prøve en liten beregning uten å kjøre hele programmet.

Den interaktive terminalen husker variabler du allerede har laget. Det er praktisk, men kan også skjule feil. Hvis programmet bare virker etter at du har kjørt linjene i en bestemt, tilfeldig rekkefølge, bør du kjøre hele fila på nytt.

Celler i en .py-fil#

Hvis du liker å arbeide med mindre deler av et program, kan du markere celler i en vanlig Python-fil med # %%. VS Code viser da en Run Cell-knapp over hver del. Dette kan være en fin overgang mellom vanlige Python-filer og notebooks.

# %%
temperatures_C = [20, 30, 40, 50]
temperatures_K = [temperature + 273.15 for temperature in temperatures_C]

# %%
print(temperatures_K)

Underveisoppgave

  1. Lag first_program.py i din egen arbeidsmappe.

  2. Kjør hele fila og kontroller at stoffmengden blir 0,050 mol.

  3. Endre massen til 5,844 g og kjør programmet på nytt.

  4. Marker bare beregningslinja og kjør den med Shift+Enter. Hvor vises resultatet?

  5. Del programmet inn i to celler med # %%: én for variablene og én for beregning og utskrift.

6. Lag og kjør en Jupyter-notebook#

Opprett nå en notebook i Explorer og kall den first_notebook.ipynb. Du kan også bruke Command Palette og velge Create: New Jupyter Notebook, men husk å lagre notebooken i arbeidsmappa.

Øverst til høyre i notebooken finner du Select Kernel eller navnet på en kernel som allerede er valgt. Klikk der og velg Python-miljøet du opprettet for emnet. Hvis du bruker .venv, skal filstien eller navnet til dette miljøet være synlig i valget.

Interpreter og kernel skal vanligvis samsvare

Interpreteren du bruker til .py-filene, og kernelen du bruker til .ipynb-filene, bør vanligvis komme fra det samme Python-miljøet. Da har du tilgang til de samme bibliotekene i begge filtypene.

En notebook inneholder to celletyper vi skal bruke mye:

Celletype

Innhold

Code

Python-kode som kan kjøres

Markdown

Forklaringer, overskrifter, likninger og faglige tolkninger

Du kan legge til celler med knappene + Code og + Markdown. Shift+Enter kjører den aktive cella og flytter fokuset videre. Dersom det ikke finnes en celle nedenfor, opprettes en ny.

Et kjemisk eksempel i en notebook#

Programmet nedenfor bruker en enkel førsteordensmodell til å beregne hvordan konsentrasjonen av en reaktant avtar med tiden:

\[c(t)=c_0e^{-kt}\]

Kjør cella med Shift+Enter. Figuren vises rett under cella.

import numpy as np
import matplotlib.pyplot as plt

time_s = np.linspace(0, 120, 100)
initial_concentration_M = 0.100
rate_constant_s = 0.025
concentration_M = initial_concentration_M * np.exp(-rate_constant_s * time_s)

plt.plot(time_s, concentration_M)
plt.xlabel("Time (s)")
plt.ylabel("Concentration (mol/L)")
plt.title("First-order reaction")
plt.grid(alpha=0.3)
plt.show()

Underveisoppgave

  1. Endre rate_constant_s fra 0.025 til 0.050 og kjør cella på nytt.

  2. Legg inn en Markdown-celle under figuren og forklar med én eller to setninger hva den endrede fartskonstanten gjør med reaksjonsforløpet.

  3. Endre startkonsentrasjonen. Hvilken del av grafen endres, og hvilken del beholder samme form?

  4. Bruk Restart og deretter Run All i notebook-verktøylinja. Kontroller at notebooken fortsatt kan kjøres fra start til slutt.

Kernelen husker det du har kjørt#

Når du kjører en kodecelle, lagrer kernelen variablene i minnet. En senere celle kan derfor bruke variabler fra en tidligere celle. Dette gjør det enkelt å bygge opp en analyse trinn for trinn.

Men celler kan også kjøres i en annen rekkefølge enn de står i. Da kan notebooken vise et resultat som ikke kan gjenskapes når en annen person åpner den. En god notebook skal derfor kunne kjøres ovenfra og ned.

Bruk denne rutinen regelmessig:

  1. Lagre notebooken.

  2. Start kernelen på nytt med Restart.

  3. Kjør alle cellene fra toppen med Run All.

  4. Kontroller den første feilen dersom kjøringen stopper.

Reproduserbar notebook

En reproduserbar notebook kan kjøres fra første til siste celle i riktig rekkefølge og gi de forventede resultatene uten skjulte mellomtrinn.

7. Undersøk variabler og data#

Notebooks er spesielt nyttige når vi arbeider med måledata. Cella nedenfor lager en liten tabell med konsentrasjoner og absorbansverdier.

import pandas as pd

measurements = pd.DataFrame({
    "concentration_uM": [0, 10, 20, 30, 40],
    "absorbance": [0.003, 0.118, 0.244, 0.357, 0.482],
})

measurements

Etter at cella er kjørt, kan du åpne Variables i notebook-verktøylinja. Der ser du variablene som finnes i kernelen. Tabeller kan ofte åpnes videre i Data Viewer, der du kan bla, sortere og undersøke verdiene.

Dette er et hjelpemiddel for å forstå dataene, ikke en erstatning for kode. Hvis du rydder eller endrer data manuelt i et eksternt vindu, blir endringen vanskeligere å dokumentere og gjenta. Selve datahåndteringen bør derfor skrives som kode i notebooken.

8. Mapper, datafiler og filstier#

Når vi begynner med datahåndtering, må programmet vite hvor datafila ligger. Den tryggeste arbeidsflyten er å ha notebooken og dataene i en tydelig prosjektmappe og bruke relative filstier.

Hvis notebooken ligger i tema2_data, og datafila ligger i undermappa data, kan fila leses slik:

import pandas as pd

measurements = pd.read_csv("data/uvvis.csv")

Denne stien betyr «gå inn i mappa data fra der programmet arbeider, og åpne uvvis.csv». Ikke skriv en lang sti som bare finnes på din egen maskin, for eksempel en sti som begynner med brukernavnet ditt. Da vil koden ofte slutte å virke når mappa flyttes eller deles med andre.

Cella nedenfor viser hvilken mappe Python bruker som nåværende arbeidsmappe.

from pathlib import Path

working_directory = Path.cwd()
print("Working directory:", working_directory)

Hvis Python ikke finner datafila

Kontroller disse tre tingene før du endrer koden mye:

  1. Er arbeidsmappa åpnet med File → Open Folder?

  2. Ligger datafila faktisk i mappa du oppgir?

  3. Er filnavn, store og små bokstaver og filendelse skrevet riktig?

Feilen FileNotFoundError betyr som regel at Python leter på feil sted eller etter et litt annet filnavn.

9. Når noe ikke virker#

Feilmeldinger er en normal del av programmering. Les først den nederste delen av feilmeldingen. Der står vanligvis feiltypen og en kort beskrivelse. Se deretter etter hvilken linje i din egen kode feilen peker på.

Feil eller problem

Vanlig forklaring

Hva kan du kontrollere?

NameError

Et variabelnavn finnes ikke

Stavefeil, store/små bokstaver eller en celle som ikke er kjørt

SyntaxError

Python forstår ikke skrivemåten

Manglende parentes, kolon, anførselstegn eller feil innrykk

ModuleNotFoundError

Biblioteket finnes ikke i aktivt miljø

Riktig interpreter/kernel før du installerer

FileNotFoundError

Python finner ikke datafila

Arbeidsmappe, relativ sti og nøyaktig filnavn

En notebook-celle kjører ikke

Kernel mangler eller har stoppet

Velg kernel eller bruk Restart

Røde eller gule streker under import

VS Code undersøker et annet miljø

Velg riktig interpreter og eventuelt last vinduet på nytt

Programmet gir et tall, men tallet virker galt

Koden kan være gyldig selv om modellen er feil

Enheter, inndata, fortegn, modell og rimelighetskontroll

En enkel strategi for feilsøking#

  1. Finn den første feilen, ikke den siste konsekvensen.

  2. Les feilmeldingens siste linje.

  3. Kontroller linja den peker på.

  4. Skriv ut mellomverdier med print, eller vis variabler i notebooken.

  5. Test en mindre del av koden.

  6. Start interpreter eller kernel på nytt og kjør fra toppen.

  7. Be om hjelp og vis både koden, hele feilmeldingen og hva du forventet skulle skje.

Kode som kjører, kan fortsatt være kjemisk feil

VS Code og Python kan oppdage feil syntaks og mange tekniske problemer. De oppdager vanligvis ikke at du har blandet gram og kilogram, brukt Celsius der modellen krever kelvin, gitt en konsentrasjon feil enhet eller valgt en modell utenfor gyldighetsområdet.

Når programmet kjører, begynner derfor den kjemiske kontrollen: Er enhetene konsistente? Har resultatet riktig størrelsesorden? Oppfører modellen seg rimelig når du endrer en parameter?

10. Dokumentasjon og KI som hjelp#

VS Code viser ofte forslag mens du skriver. Hvis du holder musepekeren over en funksjon, kan du få fram en kort beskrivelse og informasjon om argumentene. Dette gjør at du ikke trenger å huske alle kommandoer. Du kan også bruke dokumentasjon, medstudenter, undervisere og KI når du står fast.

KI kan være nyttig til å:

  • forklare en feilmelding med enklere ord

  • forklare hva en liten kodebit gjør

  • foreslå hvordan en oppgave kan deles i mindre trinn

  • vise hvordan en funksjon fra et bibliotek brukes

  • foreslå tester av en beregning

Men KI kjenner ikke nødvendigvis betingelsene i eksperimentet eller antakelsene i modellen. Be derfor helst om små, forståelige bidrag, og test dem i VS Code. Ikke godta en løsning bare fordi den kjører uten feil.

En god hjelpeforespørsel

Når du ber om hjelp, bør du oppgi:

  • hva programmet skal gjøre

  • den relevante kodebiten

  • hele feilmeldingen

  • hvilke enheter og kjemiske antakelser du bruker

  • hva du allerede har prøvd

Da blir det lettere å få hjelp som både er teknisk og kjemisk relevant.

11. Gode arbeidsvaner#

Noen få vaner gjør programmeringen mer oversiktlig og resultatene lettere å kontrollere:

  • Åpne prosjektmappa, ikke bare en løs fil.

  • Bruk beskrivende filnavn som titration_analysis.ipynb og reaction_rate.py.

  • Bruk gjerne små bokstaver og understrek i filnavn.

  • Hold originale data adskilt fra kode og figurer, for eksempel i mappene data og figures.

  • Ikke overskriv rådata når du rydder et datasett.

  • Skriv enheter i variabelnavn eller kommentarer når det er nyttig.

  • Lagre ofte.

  • Kjør hele .py-fila eller bruk Restart → Run All før du leverer en notebook.

  • Les gjennom både kode, figurer og faglige forklaringer som om en medstudent skulle gjenskape arbeidet.

Forslag til mappestruktur for en analyse

experiment/
├── analysis.ipynb
├── data/
│   └── raw_measurements.csv
└── figures/
    └── calibration_curve.png

Når bør du bruke .py, og når bør du bruke .ipynb?#

Det finnes ikke én filtype som alltid er best. Velg ut fra hva du skal gjøre.

Bruk helst .py når …

Bruk helst .ipynb når …

programmet skal kjøres samlet fra start til slutt

du utforsker data trinn for trinn

du trener på variabler, vilkår, løkker og funksjoner

du vil kombinere kode, figurer og faglige forklaringer

en analyse/simulering skal gjentas på mange filer

du dokumenterer valgene i én analyse

du vil bruke programmet som et verktøy flere ganger

du prøver ut modeller og sammenlikner resultater

I praksis kan de også kombineres. En notebook kan importere funksjoner fra en .py-fil, og en .py-fil kan deles inn i interaktive celler med # %%. Det viktigste er at arbeidsflyten er oversiktlig og kan gjentas.

Avsluttende oppgave: Kontroller arbeidsflyten#

Gjør denne oppgaven lokalt i VS Code. Når alle punktene virker, har du det viktigste oppsettet du trenger for resten av emnet.

  1. Åpne arbeidsmappa di for dette emnet i VS Code.

  2. Kontroller at Python- og Jupyter-utvidelsene fra Microsoft er installert.

  3. Velg Python-miljøet for emnet med Python: Select Interpreter.

  4. Lag en .py-fil som beregner konsentrasjonen når 0,025 mol stoff er løst i 0,500 L løsning. Skriv ut svaret med enhet.

  5. Kjør hele Python-fila i Terminal.

  6. Lag en notebook med én Markdown-celle som forklarer beregningen, og én kodecelle som utfører den.

  7. Velg det samme miljøet som kernel og kjør cella.

  8. Legg til en ny kodecelle som beregner konsentrasjonen for tre ulike stoffmengder.

  9. Start kernelen på nytt og kjør alle cellene fra toppen.

  10. Lagre begge filene med beskrivende navn.

Før du går videre

Du bør nå vite svaret på disse spørsmålene:

  • Hvilken mappe arbeider VS Code i?

  • Hvilken interpreter bruker .py-fila?

  • Hvilken kernel bruker notebooken?

  • Hvor vises output fra en Python-fil?

  • Hvor vises output fra en notebook-celle?

  • Hvordan kjører du alt fra start for å kontrollere at arbeidet kan gjentas?

Hvis du vil lese mer#

VS Code endres over tid, og enkelte knapper kan derfor flytte seg. Disse offisielle sidene blir oppdatert når programmet endres: