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...
Industriingeniør som gerne beskæftiger sig med optimering, simulation og matematisk modellering i R, SQL, VBA og Python
Leave a Reply