Python – Leren programmeren – deel 2

In de vorige post hebben we gelezen wat Python is, wat de programmeertaal inhoud en wat de beperkingen van Python zijn. Ook hebben we een ontwikkelomgeving opgezet en kunnen we starten met het ontwikkelen van Python applicaties. In deze post gaan we dan ook de basisbeginselen van de Python syntax bespreken.

De eerste stapjes in Python

Allereerst gaan we de eerste “logische” syntax eigenschappen van Python code bekijken.

Comments

Elke goede code bestaat uit comments ofwel opmerkingen. Deze opmerkingen vertellen wat er op een bepaald moment in de code gebeurt of waarom een bepaalde beslissing genomen is. Veel scripts beginnen ook met een algemene comment waarin de schrijver van de code vermeld wordt.

Comments kunnen op 2 manieren aangegeven worden:
1 – Comments van 1 lijn groot kunnen gemaakt worden door het voorvoegsel “#” (net zoals in Bash)
2 – Comments die meerdere lijnen groot zijn worden gemaakt door het “commentblock” te starten met 3 komma’s en ook af te sluiten met 3 komma’s.

#Deze comment past op 1 regel

"""
Deze
comment
is
meerdere
lijnen
groot
"""

Quotes

In bovenstaande voorbeeld zien we 3 dubbele quotes. Dit mogen ook 3 enkele quotes zijn. In Python maakt het namelijk helemaal niet uit of je dubbele of enkele quotes gebruikt.

Hello World

De eerste applicatie die iedere programmeur schrijft als deze start met programmeren in een nieuwe programmeertaal is de “Hello World” applicatie. Ofwel, een applicatie die de regel “Hello World” print. Het “print” commando is in tegenstelling tot Python 2.x een functie geworden waardoor de manier van aanroepen veranderd is. Namelijk tussen haakjes en met quotes. Dus als volgt:

print(“Hello World”)

Python print aan het einde altijd een extra witregel mee. Om deze te verwijderen gebruik je de “end” toevoeging:

print("Hello World" , end="")

Op deze manier kun je de regel ook eindigen met een spatie of een andere tekenreeks zoals b.v. een ;

print("Hello World" , end=";")

Variabele

Een variabele in Python is een geheugenlocatie waar waardes opgeslagen kunnen worden. Een variabele wordt aangegeven tussen quotes en met een = teken. Dus:

naam="jarno"
print(naam)

Let op, een variabele mag beginnen met alles behalve een nummer. Zo is “naam1” en “_naam_1” geldig maar “1_naam” niet.

2 variabelen samenvoegen werkt als volgt:

naam="Jarno"
achternaam="Baselier"
 
print(naam + " " +achternaam)

We zien dus dat we nu de variabelen scheiden d.m.v. het + teken en dat we een spatie maken doordat we 2 quotes ertussen zetten met een spatie.

Variabelen kunnen gevuld worden met alle 5 standaard data typen die Python ondersteund. Dus: numbers, strings, lists, tuple en dictionary.

Data typen

Zoals hierboven al vermeld ondersteund Python 5 default data typen. Alle 5 deze data types hebben hun eigen eigenschappen en voordelen. Ik zal ze even toelichten:

Data type “Numbers”

Numbers zijn nummers. Dus geen letters of speciale karakters maar gewoon nummers. Het number object wordt aangemaakt zodra er een numerieke waarde wordt toegewezen. Numerieke waarden hoeven niet tussen quotes geplaatst te worden.

getal=12
print(getal)

Numerieke waarde die door een spatie gescheiden worden moeten wel met quotes gedefinieerd worden (en zijn dus een string en geen number value).

getal="12 11 10"
print(getal)

Number data types kennen de volgende subtypen:

Int (plain integer)
Numerieke waarde welke altijd een rond getal vormt. Dus zonder k punten. B.v. 110, 20, 33 etc.

Long (long integer)
Dit zijn lange integers hebben dezelfde beperkingen als normale integers maar kunnen onbeperkt lang zijn. De voorwaarde is wel dat ze afgesloten worden met de letter L (hoofdletter of kleine letter). B.v. 12345678900987654321L

Float (floating point numbers)
Float numbers representeren decimale getallen en deelgetallen. Deze getallen kunnen dus wel met een punt gescheiden worden. Ook kunnen Floats als wetenschappelijke notitie geschreven worden waarbij de E of e “de macht van” betekend. B.v. 0,0 en -32.000 of 32.3+e12.

Complex (complex numbers)
Complex numbers worden geschreven in het formaat “a + bJ”. Een complex getal bestaat dus uit een geordend paar “Floats” met a + b, waarbij a en b de reële getallen (floats) zijn en de j de denkbeeldige eenheid. Een Complex eindigt dus altijd met de hoofdletter of kleine letter “J”. B.v. 4.53e-7J of 45.J

Data type “Strings”
Een string is een aaneengesloten reeks karakters tussen aanhalingstekens / quotes. Deelverzamelingen van strings kunnen worden gemaakt met een zogenaamde “slice operator” ([] en [:]) waarbij de index start met 0.

Een voorbeeld string is:

string="Deze regel is een string"
print(string)

De output van een string wanneer er een deelverzameling (index referentie) wordt gebruikt ziet er zo uit:

string="Deze regel is een string"
print(string[0])

Nog een voorbeeld:

De output van een string wanneer er een deelverzameling (index referentie) wordt gebruikt ziet er zo uit:

string="Deze regel is een string"
print(string[0:10])

Om pas v.a. het 10e karakter te starten eindig je met een dubbele punt zonder achtervoegsel:

string="Deze regel is een string"
print(string[10:])

We kennen nog meer symbolen in een string waaronder en + teken en de asterisk *. De + voegt tekenreeksen samen en de asterisk is het herhalingssymbool:

Het herhalingssymbool werkt als volgt:

string="Deze regel is een string"
print(string * 2)

Het + symbool kun je als volgt gebruiken:

string="Deze regel is een string"
print(string + "!!!!!!")

Gecombineerd:

string="Deze regel is een string"
print(string[0:10] * 2 + "!!!!!!")

Data type “Lists”
Een list in Python is eigenlijk een uitgebreide variabele. Een list wordt gevuld met verschillende waardes die gescheiden worden door een komma. Deze lijst staat tussen brackets []. Een List kan vergeleken worden met een array in bash of C. Het enige verschil is dat alle items in de list van een ander datatype kunnen zijn.

De waardes in een lijst kunnen net als bij strings bewerkt worden met de [], [:]. * en + operators.

Een voorbeeld:

list1 =["item1", "item2", "item3", "item4", "item5"]
list2 =[1000, 2000]
print(list1)

Het eerste item in de lijst krijgt de indexwaarde 0, het 2e item krijgt waarde 1 etc.

list1 =["item1", "item2", "item3", "item4", "item5"]
list2 =[1000, 2000]
print(list1[2])

Nog een voorbeeld:

list1 =["item1", "item2", "item3", "item4", "item5"]
list2 =[1000, 2000]
print(list1[2:4])

En nu met de herhaal operator (asterisk):

list1 =["item1", "item2", "item3", "item4", "item5"]
list2 =[1000, 2000]
print(list1[2:4] * 2)

En met de + operator:

list1 =["item1", "item2", "item3", "item4", "item5"]
list2 =[1000, 2000]
print(list1 + list2)

We kunnen ook items veranderen in een lijst. Dit doen we door het ID nummer van het item aan te roepen en te veranderen:

list1 =["item1", "item2", "item3", "item4", "item5"]
list2 =[1000, 2000]
list1[0] = "item100"
print(list1)

We kunnen ook andere lijsten gebruiken in een lijst:

list1 =["item1", "item2", "item3", "item4", "item5"]
list2 =[1000, 2000, list1]
print(list2)

Het verwijderen van een item uit de lijst werkt als volgt:

list1 =["item1", "item2", "item3", "item4", "item5"]
list2 =[1000, 2000, list1]
list1.remove("item5")
list2.remove(2000)
print(list2)

Een item toevoegen aan een lijst werkt op de volgende manier:

list1 =["item1", "item2", "item3", "item4", "item5"]
list2 =[1000, 2000, list1]
list1.append ("item6")
print(list1)

En we kunnen waardes toevoegen op een bepaalde positie. De overige waardes schuiven dan op en veranderen ook van positie ID.

list1 =["item1", "item2", "item3", "item4", "item5"]
list2 =[1000, 2000, list1]
list1.insert (0, "item100")
print(list1)

Data type “Tuple”
Een “Tuple” lijkt heel erg op een lijst. Het grote verschil tussen een tuple en een list is dat een tuple een “read-only” list is. De waardes in een lijst kunnen veranderd worden. De waardes in een tuple zijn vast en onveranderbaar.

Lists worden gemaakt tussen brackets [] en tuples tussen haakjes (). Hier een voorbeeld van een tuple welke in gebruik identiek is aan de list.

tuple1 =("item1", "item2", "item3", "item4", "item5")
tuple2 =(1000, 2000)
print(tuple1 + tuple2)

Data type “Dictionary”
Een Dictionary is een ander data type welke ook weer erg lijkt op een list. Een dictionary bestaat uit een lijst met sleutels en waardes. Bijvoorbeeld:
Naam: Jarno
Achternaam: Baselier
Leefdtijd: 16 🙂

In een dictionary moeten de sleutels uniek zijn maar de waardes mogen zo vaak voorkomen dan nodig is. Een dictionary wordt aangegeven tussen accolades {}. Dus bijvoorbeeld:

dict1 ={"Naam" : "Jarno", "Achternaam" : "Baselier", "Leeftijd" : 16}
dict2 =(1000, 2000)
print(dict1)

Om echter alleen de naam op te vragen refereer je naar de sleutel:

dict1 ={"Naam" : "Jarno", "Achternaam" : "Baselier", "Leeftijd" : 16}
dict2 ={"waarde1":1000, "waarde2":2000}
print(dict1["Naam"])

Het opvragen van meerdere waardes uit de dictionary kan op meerdere manieren gebeuren. Zo kun je verschillende sleutel scheiden door een komma. Let op, Python print altijd een spatie tussen 2 opgevraagde waarden.

dict1 ={"Naam" : "Jarno", "Achternaam" : "Baselier", "Leeftijd" : 16}
dict2 ={"waarde1":1000, "waarde2":2000}
print(dict1["Naam"],dict1["Achternaam"])

Het toevoegen van een nieuwe waarde aan de dictionary werkt als volgt:

dict1 ={"Naam" : "Jarno", "Achternaam" : "Baselier", "Leeftijd" : 16}
dict2 ={"waarde1":1000, "waarde2":2000}
 
dict2["waarde3"] = 3000
 
print(dict2["waarde3"])

Verwijder een waarde uit de dictionary:

dict1 ={"Naam" : "Jarno", "Achternaam" : "Baselier", "Leeftijd" : 16}
dict2 ={"waarde1":1000, "waarde2":2000}
 
dict2["waarde3"] = 3000
del dict2['waarde3'];
 
print(dict2)

Data typen Converteren

Het kan voorkomen dat je tijdens het programmeren een data type wilt converteren in een ander datatype. Dit om bijvoorbeeld de waarde weer succesvol in een functie te kunnen gebruiken. Data conversie is in Python niet zo lastig als het lijkt.

Python kent namelijk diverse functies om data typen te converteren. Deze functies beginnen vrijwel altijd met het type waar naartoe geconverteerd wordt.

Om een integer naar een float te converteren gebruik je onderstaande voorbeeld waarbij je de integer tussen de haakjes plaatst:

float(100)

De waarde/float die eruit komt is dan “100.0”. Dit kan ook met een variabele:

integer=100
 
print(float(integer))
 
<div class="outputdiv">
<strong>==Output==</strong>  <em>100.0</em>
</div>

Andersom kunnen we een float ook naar een integer converteren:

float=100.1
 
print(int(float))

Een integer kunnen we ook converteren string. Bijvoorbeeld:

integer=100
 
print(str(integer))

Op dezelfde manier kun je ook lists, tupels en andere data typen converteren. Dit kan handig zijn omdat je soms geen integer kunt gebruiken. Neem als voorbeeld:

naam="Jarno" 	#Jarno is een string
leeftijd=16 	#16 is een integer

print("Van harte gefeliciteerd " + naam + "! Vandaag ben je " + leeftijd + " jaar geworden.")

We zien hier dat we de leeftijd niet op kunnen roepen omdat het een integer is welke we niet in een “string” print kunnen oproepen. Dus moet het als volgt:

naam="Jarno" 	#Jarno is een string
leeftijd=16 	#16 is een integer

print("Van harte gefeliciteerd " + naam + "! Vandaag ben je " + str(leeftijd) + " jaar geworden.")

Rekenen

Uiteraard kun je met Python ook berekeningen maken. Voor simpele sommen gebruik je de volgende notaties:
+ (optellen)
– (aftrekken)
/ (delen)
* (vermenigvuldigen)

Dus:

getal1=1
getal2=10
 
print(getal2/getal1)
print(getal1+getal2)
print(getal2-getal1)
print(getal1*getal2)
print(10/10)
print(5/2)

Er zijn nog meer operators die we kunnen gebruiken in berekeningen, zoals:

% (rest)
** (exponent / verheffen tot de macht)
~ (complement)
// (floor division)
& (AND)
^ (Exclusive OR – bitwise)
| (Regular OR – bitwise)
< (kleiner dan) > (groter dan)
<= (is gelijk aan OF kleiner dan) >= (is gelijk aan OF groter dan)
<> OF == OF != (is precies gelijk aan)

Let op. Vermenigvuldigen en delen gaat bij sommen VOOR optellen en aftrekken.

Einde post 2

Hoppa, that’s Python for ya! Niet zo moeilijk toch? Nu je de basis geleerd hebt gaan we in post 3 door met functies en imports.