Dansk Python kursus for begyndere

Dansk Python kursus
Dansk Python kursus for begyndere

En trainingsdokumentation for Python-begyndere, anvendt i kombination med Youtube-tutorials: https://www.youtube.com/watch?v=mVK7CA_boPs&list=PLLcc4qZcySTRAyFWka3PliUB009aVWKxn

Video nr. 1: Grundlæggende matematiske operationer

# "plus" - uden variabler
5+5
10
# "minus" - med variabler
x = 4
y = 3
x-y
1
# multiplikation med variabler; resultat gemt i ny variabel "z"
x = 4
y = 2
z = x*y
print(z) # print er en funktion (også kaldet metode) som udskriver resultater i konsolen
8
# division 
print(8/10)
0.8
# kæde af operationer
print(4*5 + 5 - 4*5/4)
20.0

Video nr. 2: Grundlæggende logiske operationer (logiske tests)

# "mindre end" logisk test
3 < 4
True
# "mindre eller lig med" logisk test
4 <= 4
True
# "lig med"
4 == 4
True
# "IKKE lig med"
4 != 5
True
# "IKKE lig med"
4 != 4
False
# "eller"-operation
(4 < 3) or (4 < 5)
True
# "og"-operation
(4 < 3) and (4 < 5)
False
# logiske tests kan udføres med alle former for objekter, ikke kun numeriske tal; her er et eksempel med text
"text a" == "text b"
False
"text a" == "text a"
True
# "IKKE"-operation
not 4 < 3
True

Video nr. 3: Tekst-operationer i Python

# tekst-stykker kan forbindes med + tegnet
"Hello" + " World!"
'Hello World!'
# eller, man kan bruge et komma
print("Hello","World!")
Hello World!
# tekster kan gemmes i variabler
x = "Hello" + " World!"
# med ""-tegnene viser Python, at datatypen er "string"
x
'Hello World!'
# ""-tegnene vil blive vist i konsolen -  når vi overgiver vores tekst-variabel til konsolen uden at bruge print-metoden
print(x)
Hello World!
# ... det gælder også når vi ikke først skriver teksten til en variabel
print("Hello World!")
Hello World!
# hvis vi vil printe over flere linjer kan vi benytte print metoden for hver linje
print("Hello World!")
print("ny sætning")
Hello World!
ny sætning
# eller vi kan skrive \n i teksten; \n betyder "ny linje"
print("Hello World!\nny sætning")
Hello World
ny sætning
# tekst i Python har sin egen dataype - "string"; denne datatype har sine egne metoder (mere om det i en senere video)
x = "Hello"
x = x.replace("e","a")
print(x)
Hallo
# tabular splittelse af tekst-stykker kan gøres ved at skrive "\t" i teksten
print("Hello \t\t\tWorld!")
Hello 			World!

Video nr. 4: Grundlæggende Python datatyper – int, float, str, list, tuple, dict, bool, complex

# integer - hele tal
isinstance(1,int)
True
isinstance(1.0,int)
False
isinstance(2/2,int)
False
isinstance(int(3/2),int)
True
int(3/2)
1
# float - decimaltal
isinstance(2.3,float)
True
# complex
isinstance(2.13j,complex)
True
# boolean - digital data type / bit
isinstance(False,bool)
True
bool(0)
False
bool(1)
True
bool(1728394)
True
# string - text
isinstance("abc",str)
True
isinstance(123,str)
False
isinstance(str(123),str)
True
# list - en liste som forskellige datatyper kan gemmes i
[1,2,3]
[1, 2, 3]
[1,1.2,"abc"]
[1, 1.2, 'abc']
x_liste = ["a","b",123]
# første indlæg i listen
x_liste[0]
'a'
# sidste indlæg i listen
x_liste[-1]
123
# sidste indlæg i lidste kunne vi også bare have fået ved at skrive det korrekte index-nr.
x_liste[-1] == x_liste[2]
True
# du kan gemme en liste som et element i en liste (dvs. lister kan være indlæg i lister)
x_2dliste = [["a","b"],[1,2,3,4]]
x_2dliste[1][2]
3
# tuple - en datatype som minder om lister, men hvor elementerne ikke kan slettes eller ændres
x_tuple = (1,2,[1,2],"a")
x_tuple[2]
[1, 2]
# hvis jeg vil ændre et element i en tuple vil Python give mig en fejl: "tuple object does not support item assignment"
x_tuple[2] = "b"
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-25-02306efcc09d> in <module>()
      1 # hvis jeg vil ændre et element i en tuple vil Python give mig en fejl: "tuple object does not support item assignment"
----> 2 x_tuple[2] = "b"

TypeError: 'tuple' object does not support item assignment
# dictionary - "opslagsværk"
x_dict = {
    "noegle1" : "vaerdi1",
    "noegle2" : "vaerdi2"
}

print(x_dict)
{'noegle2': 'vaerdi2', 'noegle1': 'vaerdi1'}
x_dict["noegle1"]
'vaerdi1'
# derudover kan man i Python definere sine egne datayper, såkaldte abstrakte datatyper - mere om det i en senere video

Video nr. 5: Automatisk konvertering af datatyper

# automatisk konvertering foretages af Python, når f.eks. en beregning benytter datatyper som resultatet ikke kan gemmes i
integer_1 = 1
integer_2 = 2
resultat = integer_1 / integer_2
isinstance(resultat,int)
False
isinstance(resultat,float)
True
# her et andet eksempel hvor Python udfører implicit konverteri
resultat = False + 1
resultat
1
isinstance(resultat,int)
True
isinstance(resultat,bool)
False

Video nr. 6: Tvungen konvertering af datatyper

# hvis du ikke ønsker automatisk konvertering i tilfælde af beregninger e.l. skal du give Python besked herom
int(2/3)
0
int(3/2)
1
float(1)
1.0
str(20-2)
'18'
str(20-2) + "abc"
'18abc'
bool(False + 1)
True
str(20 + 1 + 2.1)+str("abc")+str(False)
'23.1abcFalse'

Video nr. 7: Funktioner i Python (“functions”)

# Vi kan skrive vores egne funktioner i Python; det gør det muligt at genbruge kode-stykker
def skriv_en_hilsen(navn, efternavn):
    hilsen = "Kære " + navn + " " + efternavn + ",\n" + "mange hilsner fra mig!"
    print("hilsen blev skrevet...")
    return hilsen
brev = skriv_en_hilsen("Linnart","Felkl")
hilsen blev skrevet...
print(brev)
Kære Linnart Felkl,
mange hilsner fra mig!

Video nr. 8: Sløjfer i Python – while & for “loops”

# sløjfer gør det muligt at gennemgå et stykke kode flere gange, indtil et bestemt kriterie ikke længere er opfyldt
# eksempel på en while-sløjfe ("while-loop") i Python
i = 1
while(i < 6):
    print(str(i)+". sløjfe-gennemgang")
    i +=1
1. sløjfe-gennemgang
2. sløjfe-gennemgang
3. sløjfe-gennemgang
4. sløjfe-gennemgang
5. sløjfe-gennemgang
# eksempel på en for-sløjfe ("for-loop") i Python; for-sløjfer kan f.eks. blive brugt til at gå gennem en liste med elementer
x_list = [1,2,5,6,10]
for i in x_list:
    print(i)
1
2
5
6
10

Video nr. 9: if-else strukturelementer i Python

# med "if" og "else" kan du strukturere din kode og udføre sektioner af dit program under bestemte betingelser
i = 3.1 
if i > 5:
    print("i er større end 5")
elif i > 4:
    print("i er større end 4 men ikke større end 5")
else:
    print("i er ikke større end 4...")
i er ikke større end 4...

Video nr. 10: Definition af egne klasser i Python

# vi kan definere vores egne klasser i Python, og dermed vores egne datatyper
# her er et eksempel på en klasse "Person", som vi definerer
class Person:
    # __init__ funktionen bruges senere når vi vil oprette objekter af klassen Person
    def __init__(self, alder, navn, adresse):
        self.alder = alder
        self.navn = navn
        self.adresse = adresse
    
    # udover __init__ giver vi klassen Person en funktion til at printe alder, navn og adresse
    def udgiv_data(self):
        print("alder: " + str(self.alder) + " navn: " + self.navn + " adresse: " + self.adresse)        
# vi kan nu oprette objekter af vores "Person" klasse
person1 = Person(28,"Jens","Samsøvej, Samsø (DK)")
# person1 er et objekt af typen "Person"; vi kan bruge "udgiv_data" funktionen for at udskrive hans personlige data
person1.udgiv_data()
alder: 28 navn: Jens adresse: Samsøvej, Samsø (DK)
# vi kan oprette flere forskellige objekt-instanser af datatypen "Person"
# ligesom med tekst eller tal kan vi gemme disse objektinstsanser i f.eks. en liste
person2 = Person(45,"Lisa","Bornholmsvej, Bornholm (DK)")
person3 = Person(12,"Simon","Københavnsvej, København (DK)")

# en liste med tre objektinstanser af datatypen "Person"
person_liste = [person1,person2,person3]

# en "for"-sløjfe for at printe alt indhold i person_liste listen
for i in person_liste:
    i.udgiv_data()
alder: 28 navn: Jens adresse: Samsøvej, Samsø (DK)
alder: 45 navn: Lisa adresse: Bornholmsvej, Bornholm (DK)
alder: 12 navn: Simon adresse: Københavnsvej, København (DK)
# vi kan ændre indholdet af objektinstanserne, f.eks. for person1
person1.navn = "..."
person1.alder = -1
person1.adresse = "..."
person1.udgiv_data()
alder: -1 navn: ... adresse: ...
# men det påvirker i dette tilfælde ikke person2 og person3
person2.udgiv_data()
person3.udgiv_data()
alder: 45 navn: Lisa adresse: Bornholmsvej, Bornholm (DK)
alder: 12 navn: Simon adresse: Københavnsvej, København (DK)
# der er en forksel mellem "instans-variabler" og "klasse-variabler"
# i første eksempel brugte vi "instans-variabler" til at beskrive indholdet af en person
# når vi skriver data til disse variabler er indholdet unikt for hver instans af klassen
# hvis vi vil have variabler som er ens for alle instanser af en klasse skal vi bruge "klasse-variabler"
class Dreng:
    # klasse-variabler
    koen = "M"
    
    # instans-variabler
    def __init__(self,alder,navn,adresse):
        self.alder = alder
        self.navn = navn
        self.adresse = adresse
# vi opretter to instanser af klassen "Dreng", og angiver derved alder, navn og adresse (dvs. alle instans-variabler)
dreng1 = Dreng(12,"Martin","Slagelsevej, Slagelse (DK)")
dreng2 = Dreng(10,"Dennis","Korsørvej, Korsør (DK)")
# begge har den samme klasse-variabel, nemlig "koen" (altså køn)
dreng1.koen == dreng2.koen
True
print(dreng1.koen)
M

Video nr. 11: Arvelighed af klasse-variabler og metoder i Python

# Klasser kan arve fra hinanden; børneklasser kan arve fra deres forældre, som igen kan arve fra deres forældre
class TopKlasse:
    type1 = "top klasse"
    def __init__(self):
        pass # pass betyder vi ikke vil udformulere funktionen, da vi ikke bruger den
    def hilsen(self):
        print("hejsa!")
    
class MellemKlasse(TopKlasse): #mellemklasse arver fra topklasse
    type2 = "mellem klasse"
    def __init__(self):
        pass
    
class UnderKlasse(MellemKlasse): #underklasse arver fra mellemklasse
    type3 = "under klasse"
    def __init__(self):
        pass
# lad os teste arveligheden af type1 og type2 (klassevariabler i dette tilfælde)
test = UnderKlasse()
print(test.type1)
print(test.type2)
print(test.type3)
top klasse
mellem klasse
under klasse
# det samme gælder for funktioner, eller i dette tilfælde "metoder"
# vi kalder funktioner for metoder når de tilhører en bestemt klasse
test.hilsen()
hejsa!

Video nr. 12: Arvelighed af instans-variabler i Python

# Vi har set at klassevariabler og metoder kan arves af børneklasser; men hvar er med instans-variabler?
class AKlasse:
    def __init__(self,navn):
        self.navn = navn
class BKlasse(AKlasse): # arver fra AKlasse
    def __init__(self,alder):
        self.alder=alder
class CKlasse(BKlasse): # arver fra BKlasse
    def __init__(self,adresse):
        self.adresse = adresse
# fungerer nedenstående stykke Python-kode?
cklasse1 = CKlasse("Hans",22,"Jyllandsvej 13")
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-3-5743bdbd75d7> in <module>()
      1 # fungerer nedenstående stykke Python-kode?
----> 2 cklasse1 = CKlasse("Hans",22,"Jyllandsvej 13")

TypeError: __init__() takes 2 positional arguments but 4 were given
# svaret er nej! hvis vi vil sikre arvelighed af instans-variabler, skal vi selv sørge for det
class AKlasse:
    def __init__(self,navn):
        self.navn = navn
class BKlasse(AKlasse):
    def __init__(self,navn,alder):
        AKlasse.__init__(self,navn)
        self.alder = alder
class CKlasse(BKlasse):
    def __init__(self,navn,alder,adresse):
        BKlasse.__init__(self,navn,alder)
        self.adresse = adresse

# test/bevis: nu "forarves" instans-variabler
cklasse1 = CKlasse("Hans",22,"Jyllandsvej 13")
print(cklasse1.navn + ", " + str(cklasse1.alder) + ", " + cklasse1.adresse)
Hans, 22, Jyllandsvej 13

Video nr. 13: Forskellen mellem lokale og globale variabler i Python

# I Python er der forskel på lokale og globale variabler
globalVar = "dette er en tekst gemt i en global variabel"

def opret_lokalVar():
    lokalVar = "dette er en tekst gemt i en global variabel"

# kald opret_lokalVar
opret_lokalVar()
# kan vi printe globalVar?
print(globalVar)
dette er en tekst gemt i en global variabel
# kan vi printe lokalVar?
print(lokalVar)
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-16-1183413c0fd5> in <module>()
      1 # kan vi printe lokalVar?
----> 2 print(lokalVar)

NameError: name 'lokalVar' is not defined
# vi kan definere globale variabler indenfor f.eks. funktioner, ved at skrive "global"
def opret_globalVar2():
    global globalVar2 
    globalVar2 = "dette er også en global variabel"
    
# kald opret_globalVar2
opret_globalVar2()

# kan vi printe globalVar2, som funktionen har oprettet?
print(globalVar2)
dette er også en global variabel

Video nr. 14: Python liste-funktioner (append, extend, pop, remove, clear, index, sort, reverse, count, copy)

# som tidligere nævnt er lister objekt-instanser af klassen "List"; klassen omfatter visse metoder
liste1 = []
# liste1 er en tom liste
print(liste1)
[]
# vi kan bruge metoden "append" for at tilføje indhold til denne liste
liste1.append("a")
print(liste1)
['a']
# som allerede vist kan vi tilføje forskellige datatyper til en liste
liste1.append(4)
print(liste1)
['a', 4]
# "append" tilføjer altså et nyt element i bagenden af listen; pop er en funktion som udgiver og fjerner et element
liste1.pop(0)
'a'
# efter "pop(0)" er første element i listen udgivet, men også fjernet fra listen
print(liste1)
[4]
# med "insert" kan vi tilføje et bestemt element et bestemt sted i listen
liste1.insert(0,"a")
print(liste1)
['a', 4]
# med extend kan vi tiføje flere elementer, ikke kun enkelte - de tilføjes forenden af listen
liste1.extend([2.0,2.3j,[1,2]])
print(liste1)
['a', 4, 2.0, 2.3j, [1, 2]]
# lister kan tilføjes lister, som vist foroven; sådan her kan du få et bestemt element fra en liste i en liste
liste1[4][0]
1
# ... og for at få andet element i liste [1,2] inden i liste1
liste1[4][1]
2
# insert kan bruges på listen i liste1
liste1[4].insert(0,0)
# lad os se om tallet "0" er tilføjet ved index 0 (første index) i listen ved index 4 i liste1
print(liste1)
print(liste1[4])
print(liste1[4][0])
['a', 4, 2.0, 2.3j, [0, 1, 2]]
[0, 1, 2]
0
# vi kan også bruge "pop" for at udgive og fjerne elementer fra lister indeni lister; index = -1 betyder "forenden"
liste1[4].pop(-1)
2
# lad os se liste1 nu
print(liste1)
['a', 4, 2.0, 2.3j, [0, 1]]
# hvis vi vil udgive bestemte elementer kan vi f.eks. benytte os af "fra_index:til_index" notationen
print(liste1[1:3])
[4, 2.0]
# vi kan slette hele indholdet af en liste med "clear"
liste1.clear()
print(liste1)
[]
# og vi kan bruge "remove" for at fjerne bestemte elementr med bestemt værdi fra listen; derved fjernes første match
liste1.extend(["a","b","c","a","d","a","e"])
liste1.remove("a")
print(liste1)
['b', 'c', 'a', 'd', 'a', 'e']
# med "index"-funktionen kan vi få index-nummer af første match i listen
liste1.index("a")
2
# med "count"-funktionen kan vi få antallet af matches
liste1.count("a")
2
# med "sort"-funktionen kan vi sortere (fra lav til høj)
liste1.sort()
print(liste1)
['a', 'a', 'b', 'c', 'd', 'e']
# med "reverse"-funktionen kan vi vende rækkefølgen i listen om
liste1.append("a")
liste1.reverse()
print(liste1)
['a', 'e', 'd', 'c', 'b', 'a', 'a']
# ved at kombinere "sort" og "reverse" kan vi sortere fra "HØJ til LAV"
liste1.sort()
liste1.reverse()
print(liste1)
['e', 'd', 'c', 'b', 'a', 'a', 'a']
# sidste funktion i denne tutorial er "copy"-funktionen, som laver en "overfladisk" kopi af en liste; men først, se her:
liste2 = liste1
liste2.append(3)
print(liste1)
['e', 'd', 'c', 'b', 'a', 'a', 'a', 3]
# hvis vi sætter liste2 = liste1, så vil alle ændringer af liste2 også ændre liste1 (fordi begge referer til samme data)
liste1.append(5)
print(liste2)
['e', 'd', 'c', 'b', 'a', 'a', 'a', 3, 5]
# ved brug af "copy" kan vi skabe en kopi som har sin egen data og reference; ændringer påvirker ikke det originale objekt
liste3 = liste1.copy()
liste3.clear()
print(liste3)
print(liste1)
print(liste2)
[]
['e', 'd', 'c', 'b', 'a', 'a', 'a', 3, 5]
['e', 'd', 'c', 'b', 'a', 'a', 'a', 3, 5]

Video nr. 15: Import af bibliotheker (“libraries”) i Python

# python filer kan importeres med "import" kommandoen; f.eks. kan følgende funktion gemmes i en fil og så importeres
def udskriv_noget():
    print("noget...")

# ovenstående funktion er gemt i python-filen test1.py og importeres
import test1

# test1 er nu et "modul", som vi kan anvende i vores program
test1.udskriv_noget()
noget...
# vi kan også give den importerede fil et nyt modul-navn, med "as" kommandoen
import test1 as t1
t1.udskriv_noget()
noget...
# vi kan også benytte os af "*"-wildcard, som gør det mulig at tiltale funktioner direkte
from test1 import *
udskriv_noget()
noget...

Leave a Reply

Skriv et svar

Din e-mailadresse vil ikke blive publiceret. Krævede felter er markeret med *

Close

Meta