KB » Computer » Python programmeren

Python programmeren

    Tweeten

Introductie

Je kan zien welke versie Python je hebt door op de commandoregel python -V in te tikken.

Maar je kan het ook gewoon zien door python te starten.

Help-informatie

Als je niet meer precies weet hoe een bepaald commando werkt tik je in: help('commandonaam'), bv. help('print'), gevolgd door Enter

Aanroepen van Python

Als je een stuk code uit een andere file wilt gebruiken in een interactief Python-programma, geef je optie -i mee:
python -i functions.py

In dit geval zijn bv. gedefiniëerde classes uit functions.py beschikbaar.

Integrated Development Environment (IDE)

Het is handig om Python in een grafische omgeving te kunnen gebruiken, en daarvoor zijn er o.a. de volgende 2 mogelijkheden:

Werken met Pycharm

Pycharm kan je hier downloaden.

Maak een nieuw project met klikken op File - New Project, en dan achter Location een map te kiezen waar het project heen moet, en een naam voor het project. Er wordt dan een "virtual environment" aangemaakt (kan even duren).

Klik dan op File - New - Python Package, en voer een naam voor het package in.

Klik dan op File - New - Python File, en voer een naam in.

Je kan nu programmacode intikken. Als je klaar bent moet je nog een configuratiebestand aanmaken.

Klik op het pijltje naar beneden, rechts op de 2e regel onder de titelbalk, en dan op Edit Configurations. Klik op het plus-teken in de linkerbovenhoek, en dan op Python. Voer een naam in achter Name, selecteer achter Script Path bij welke Python-file de configuratie hoort.

Daarna kan je evt. de code verder aanpassen, of het programma uitvoeren door op de groene pijl te klikken.

Bij het invoeren van code kan je zien of een regel niet deugt doordat er dan een rood uitroepteken aan het einde van de regel verschijnt. Je kan dat bv. simpel testen door een ongeldige naam voor een variabele te gebruiken:
a$b=3

Package management

De website voor packages is https://pypi.python.org/pypi.

Installeren van een package doe je met pip install package-name

Met pip list zie je alle packages die er op het systeem geïnstalleerd zijn.

Met pip show package-name zie je gegevens over een specifiek package.

Je kan zoeken naar packages met pip search search-term

Compiler en linker

Declaraties

Variabelen

In Python heb je geen typedeclaraties, dus je kan gewoon zeggen:

a = 10 b = 20.34

Constantes

Booleans

0 is de waarde false, net als de empty string, "", alle andere waarden zijn true.

Er is een functie bool, die de boolean waarde van iets oplevert. Dus print(bool(3)) drukt False af.

Operators

Complexe operators

Conditional operator

Functies

Ingebouwde functies

Zoeken binnen een string (find)

Minimum (min) of maximum (max)

Resultaat is het kleinste of grootste van een willekeurig aantal parameters.

Absolute waarde van een getal (abs)

Type van een parameter (type)

Control statements

If statement

De code die wordt uitgevoerd als de conditie na 'if' waar is, wordt in Python (i.t.t. veel andere programmeertalen) niet aangegeven door een of ander soort haakjes, maar door indentation (inspringen van de kantlijn). Aangeraden wordt om dit met 4 spaties te doen, hoewel minder geloof ik wel is toegestaan.

Algemene structuur van het if statement:

if condition1: statements1 elif condition2: statements2 else: statements3

Let op de dubbele punt aan het eind van de 'if'-regel en achter de 'else'.

Voorbeeld:

if 10 > 9: print("Waar") else: print("Onwaar") print("Dit wordt altijd afgedrukt")

De laatste regel wordt altijd afgedrukt omdat de regel niet ingesprongen is. Dus valt hij buiten het if-statement.

For statement

Een simpele for loop ziet er als volgt uit:

for variable in collection: statements

Met collection bedoel ik een string, een list, een tuple of een dictionary.

Een dictionary is natuurlijk een beetje een speciaal geval. De variabele na 'for' heeft in dat geval betrekking op de keys.

Voorbeeld (veronderstel dat je personen hebt met hun gewicht):

d = {'Jan': 89, 'Henk': 70, 'Kees': 99} for k in d: print(k + " " + str(d[k]))

De uitvoer zal zijn:

Jan 89 Henk 70 Kees 99

Maar je kan ook het volgende doen:

for k,v in d.items(): print(k) print(v)

Je kan met 'for' ook door 2 lists tegelijkertijd gaan. De operatie stopt dan bij de kortste van de 2 lists. Het gaat als volgt:

lst1 = [1, 2, 3, 4] lst2 = [5, 6, 7, 8, 9, 10] for x, y in zip(lst1, lst2): statements

Als er geen break bij de statements zit, zullen er 4 iteraties uitgevoerd worden.

While statement

while conditie: statements

Er gelden dezelfde principes als bij de if: aan het eind van de while-regel moet een dubbele punt staan, en de regels die bij de 'while' horen moeten inspringen.

Voorbeeld:

l = [] x = 0 while x < 6: l.append(x) x = x+1 print(l)

De uitvoer van dit stukje code is:
[0, 1, 2, 3, 4, 5]

Het break statement en het continue statement

break beëindigt de loop waar het in zit, en wel de "closest enclosing" loop (vanzelfsprekend).

Range

range(0,20) levert een class van type "range" met de getallen van 0 t/m 19 op.

print(range(0,20)) levert niets nuttigs op. Om de getallen te kunnen zien moet je de range typecast naar bv. een list: print(list(range(0,20))).

Het default beginpunt van een range is 0, dus ik had hierboven ook range(20) kunnen zeggen. Maar je kan ook een ander beginpunt nemen en de stapgrootte veranderen van 1 in iets anders, bv.: print(list(range(30,40,4))) levert de getallen 30, 34 en 38 op.

Invoer en uitvoer

Je kan om invoer vragen met de procedure input (heette in Python 2 nog raw_input).

Dus bv.: lname = input("What is your last name? ")

File openen voor I/O

Je opent een bestand met de ingebouwde functie open

Er zijn 4 verschillende modes waarmee je een bestand kunt openen: 'r' (read-only), 'w' (write-only), 'r+' (read and write) en 'a' (append).

Een van de meest eenvoudige manieren om een bestand te openen is
mijn_bestand = open("naam.extensie, "mode"), dus bv.:
naw = open("naw.txt", "r+")

Schrijven naar een bestand

De uitvoer naar een bestand is altijd in de vorm van strings.

Veronderstel dat je een bestand opent met
outfile = open("uitvoer.txt", "w")

Je maakt een lijst met
number_list = [1, 2, 3, 4, 5]

Dan kan je die lijst als volgt naar het bestand schrijven:

for item in number_list outfile.write(str(item)) outfile.close()

Lezen uit een bestand

In dit geval open je het bestand met
infile = open("uitvoer.txt", "r")

Daarna zou je het hele bestand als volgt kunnen afdrukken:
print(str(infile.read()), of
mydata = infile.read()
print(mydata)
(Je kan ook alleen als statement mydata intikken, maar dan krijg je de string tussen aanhalingstekens.)

Met de method readline() kan je een bestand ook regel voor regel lezen. Maar je kan ook een andere truc uithalen. Stel dat je invoerbestand een getal heeft op elke regel, kan je het volgende doen:
nummerlijst = invoer.read().splitlines()
De getallen belanden nu als strings in de lijst nummerlijst

Na schrijfoperaties is het belangrijk dat je een close() doet voor je er andere operaties (bv. lezen) op loslaat.

With as

Als je gebruik maakt van de with... as... constructie hoef je niet perse een close te doen tussen een schrijf- en leesoperatie. Zie bv. de volgende code:

with open("test.txt", "w") as write_file: write_file.write("Dit is een voorbeeld van het gebruik van with.. as") print() with open("test.txt", "r") as read_file: print(str(read_file.read()))

Denk om de ':' aan het eind van de with... as... regel!

Strings

Je kan de characters in een string benaderen alsof het een array is (waarbij de index van het 1e teken 0 is).

Dus als je als statement print("Groningen"[3]) doet, krijg je als uitvoer de letter 'n'.

Negatieve indexen zijn ook mogelijk: -1 levert de laatste 'n' op, -2 de 'e'.

Met '+'-tekens kan je meerdere strings aan elkaar knopen.

Je kan een substring uit een string halen door een begin-index en een eind-index op te geven, een zgn. slice. Daarbij is de eind-index exclusive, dus die telt niet mee. Als je na de dubbele punt niets zet krijg je de hele string vanaf de begin-index. Als je voor de dubbele punt niets zet begint de slice bij index 0.

Voorbeeld: print("Groningen"[1:6]) levert ronin op.

Tenslotte kan je tussen vierkante haken nog een derde getal toevoegen, de step. In dat geval wordt om de step tekens een teken uit de string gehaald.

Voorbeeld: "Groningen"[1:i:2] levert rnne op.

String methods

Een string is een object, met een o.a. een aantal methods.

Lower

"Henk".lower() levert henk op (en vanzelfsprekend is er ook een method upper().

Replace

string.replace(old, new, count) vervangt de string old door de string new

count geeft aan hoeveel keer de string vervangen moet worden. Als je geen aantal opgeeft wordt alles vervangen.

String functies

len("Henk") levert 4 op.

str("23") levert de string 23 op.

String formatting

Een beetje vergelijkbaar als in C++ kan je ook in Python werken met placeholders voor dingen die je in een string wilt stoppen.

Voorbeeld:

artist = "Radiohead" location = "Ziggo Dome" print("Welkom bij het concert van %s in %s", %(artist, location))

levert als output Welkom bij het concert van Radiohead in Ziggo Dome

Lists

Een list lijkt te zijn wat een array is in andere programmeertalen. Je kan bv. een list van getallen aanmaken met het statement numlist = [9, 13, 4, 8]
numlist[2] heeft dan de waarde 4

In tegenstelling tot strings, waar je geen waarden aan kan toewijzen, kan dat bij lists wel. Je zou dus kunnen zeggen numlist[2] = 11

List methods

Lengte van een list (len)

len(listname) geeft je het aantal elementen in de list.

Item toevoegen aan list (append)

Met listname.append(item) voeg je een element aan de list toe (aan het eind).

Item toevoegen aan list (insert)

Met listname.insert(index, item) voeg je een element aan de list toe (op de plek van de index).

Stel je hebt de list colors = ["green", "yellow", "orange"], en je voert colors.insert(1, "blue") uit, dan is de waarde van colors veranderd in ["green", "blue", "yellow", "orange"]

Item vinden (index)

Stel je hebt de list colors = ["green", "yellow", "orange"], en je wilt weten or orange er in zit, en zo ja, het hoeveelste element het is.

Dan doe je: result = colors.index("orange"), en je krijgt de waarde 2 terug.

Item verwijderen (pop)

Met variable_name = listname.pop() verwijder je het element aan het einde van de list (en het verwijderde item komt in variable_name)

Item verwijderen (remove)

Met listname.remove(itemname) verwijder je het element itemname

Sorteren van list (sort)

Met listname.sort() sorteer je de list.

Checken of item in list zit (in)

Met if value in listname:
krijg je de waarde true of false terug.

Dictionaries

Een dictionary bestaat uit een aantal paren, waarvan de 1e de key is, en de 2e de waarde. De waardes in de dictionary hoeven niet van hetzelfde type te zijn.

Je zou dus bv. een dictionary kunnen maken met gegevens over een persoon:
person = {'name': 'Henk', 'birthyear': 1956, 'city': 'Groningen'}

Er is geen volgorde in de dictionary, het is een afbeelding van keys op waardes. De manier om een waarde te benaderen is via de key: person['city'] levert de waarde 'Groningen' op.

Je kan als volgt waardes toevoegen aan een bestaande dictionary:
person['phone-number'] = 1234567

Dictionaries kan je nesten, d.w.z. de waarde in een key-value paar kan een nieuwe dictionary zijn. Een waarde binnen een dictionary-waarde benader je door een extra paar vierkante haken met daarin een key van de dictionary-waarde.

Methods

Keys

Van de dictionary person = {'name': 'Henk', 'birthyear': 1956, 'city': 'Groningen'} levert person.keys() het volgende op: dict_keys(['name', 'birthyear', 'city'])

Values

Deze method doet hetzelfde als keys, maar dan voor de waardes.

Items

Met dezelfde dictionary als in keys levert person.items() het volgende op: dict_items([('name', 'Henk'), ('birthyear', 1956), ('city', 'Groningen')])

Copy

Met deze method kan je een complete dictionary copiëren: person_copy = person.copy()

person_copy is nu ook een dictionary, compleet identiek aan person

Clear

Met deze method poets je de dictionary schoon: person.clear()

Methods

Een method definieer je met
def method_name(arguments):
gevolgd door de statements (ingesprongen met 4 spaties).

De method roep je aan met zijn naam, net als procedures in andere talen.

Als je wilt dat de method een waarde oplevert gebruik je het return statement.

Parameters

Bij de parameters heb je best veel flexibiliteit. Als je bv. een method definieert waarin de parameters worden opgeteld, kan je zowel getallen als strings als parameters meegeven. Maar niet 1 string en 1 getal (het getal wordt niet automatisch geconverteerd).

Ook kan je default waardes voor de parameters definieren, zodat je de method evt. zonder parameters (of met minder dan het maximale aantal) kan aanroepen. Bv.: def som(x=2, y=4):

Als je nu bij de call van som geen parameters opgeeft krijg je als resultaat 6.

Je kan ook gebruik maken van positionele parameters, waarbij je de namen van de parameters in de call opgeeft. Je kan dan een andere volgorde gebruiken dan in de definitie.

Je kan een method met een onbeperkt aantal parameters definieren m.b.v. een asterisk voor de naam van de parameters, bv.:
def maxnum(*args):

Classes

Alles in Python bestaat uit objects, en elk object is van een bepaalde class.

Hoe kan je te weten komen van welke class een object is? Door het volgende statement uit te voeren: print(type(object))

Je zou bv. eerst een string kunnen definiëren met
s = "Dit is een string"
en dan kijken wat de class is met
print(type('s'))

Classes hebben methods en properties (eigenschappen).

Definiëren van een class

class Auto(object):

Constructor

Elke class begint met het definiëren van de method __init__. Deze method heet de zng. constructor, en initialiseert variabelen e.d.

De constructor heeft altijd een 1e argument dat verwijst naar het object dat gecreëerd wordt, en evt. andere argumenten.
def __init__(self):

Instances

Zodra een class is gedefiniëerd kan je objecten (instances van de class) aanmaken:
auto1 = Auto()
Tussen haakje komen dan nog de evt. argumenten te staan self hoef je niet te noemen, maar refereert naar deze specifieke instance van de class.

Een iets uitgebreider voorbeeld:

class Auto(object): def __init__(self, type, model): self.type = type self.model = model auto1 = Auto('Volkswagen', 'Up') auto2 = Auto('Peugeot', '405') print(auto1.type) print(auto1.model)

Properties

Een class heeft naast methods ook properties. De class Auto zou bv. een property Wielen kunnen hebben, met als standaardwaarde 4.

Properties definiëer je meestal voor de methods binnen een class.

Als je een instance van een class maakt, en je verandert de waarde van een property van de class, dan geldt dat alleen voor die ene instance, en niet voor de class als geheel of voor andere instances.

Inheritance

Als je een nieuwe class maakt, zet je tussen haakjes achter de naam van de class object. Dat is omdat object de basis is van alle andere classes. De nieuwe class erft alle eigenschappen en methods van object, en kan er nieuwe bij definiëren. Dit heet inheritance.

Maar je kan ook zelf een nieuwe class definieren die erft van een al eerder door jou gedefiniëerde class. Een Volkswagen is een auto, en heeft een aantal generieke kenmerken en acties die bij auto's horen, maar misschien ook een paar unieke die alleen bij Volkswagens horen:
class VW(Auto):

De class waarvan je erft wordt ook wel de super-class, base class of parent class genoemd. De class die erft heet de child class.

Override

Als je inheritance gebruikt zou het kunnen zijn dat je niet alle methods net zo wilt gebruiken als in de parent class. In dat geval definiëer je in de child class een method met dezelfde naam, maar andere statements. Deze method zal dan in een instance van de child class de method uit de parent class overrulen (override).

Je zou bv. in de class Auto een method Rijden kunnen hebben, die alleen maar afdrukt "De auto rijdt".

In de class VW, die van Auto erft, zou je de afdrukregel kunnen veranderen in "De Volkswagen rijdt". Alle andere properties en methods zouden van Auto overgenomen worden, alleen de method Rijden zou anders werken.

In plaats van een complete override, kan je ook gebruikmaken van de method uit de parent class, en er iets aan toevoegen. Je kan de method uit de parent aanroepen met de ingebouwde functie super.

In het voorbeeld dat ik eerder gebruikte zou je in de class VW de volgende aanroep kunnen gebruiken:
super(VW, self).Rijden
Het gevolg is dat Rijden uit de class Auto wordt aangeroepen. De 2 parameters van super zijn hier trouwens niet echt nodig.

Een child class kan properties en methods van meerdere parents erven. Je kan een hele lijst van parent classes tussen haakjes zetten.

Objects

Zoals gezegd is een 'list' ook een object. Je kan als volgt een nieuw object van het list-type maken:
newlist = list()
newlist is dan een lege lijst.

Exceptions (fouten)

Exceptions treden op (to throw an exception) als er iets fout gaat in de code, bv. als je een element van een list benadert dat buiten het bereik ligt of als je een dictionary key gebruikt die niet gedefiniëerd is.

Hier vind je een lijst van alle exceptions in Python 3.

Exceptions zijn gewoon classes, dus je kan (voortbouwend op de ingebouwde exception classes) ook zelf exceptions definiëren. IndexError is bv. een class.

Als je een stuk code bestand wilt maken tegen fouten, zet je er de regel
try:
voor. Achter
except:
zet je dan de code die eventuele fouten afvangt.

Voorbeeld:

try: a = 10 b = 0 print(a/b) except: print("Fout opgetreden")

Je kan ook (verschillende) exceptions noemen, bv.:

try: print(10 / 0) print(3 + "aa") except ZeroDivisionError: print("Er wordt gedeeld door 0") except TypeError: print("Fout met types")

Je kan ook nog een andere tak toevoegen, nl.
else:

De code die daarna staat wordt dus alleen uitgevoerd als er geen exception was.

Tenslotte is er ook nog een tak die altijd wordt uitgevoerd:
finally:
Deze tak kan handig zijn als je bv. wat bestanden wilt sluiten, of andere aflsuitende activiteiten wilt doen.

Het is verstandig om altijd een specifiek type exception op te geven na de except.

Als je een exception wilt forceren, gebruik je het statement
raise Exception("tekst")

Modules

Vanzelfsprekend zijn er al heel veel standaarddingen in Python geschreven, in de vorm van modules (ook wel libraries genoemd). Je kan hier een lange lijst vinden.

Modules zijn gewone Python files. Er is bv. een module (math.py) met allerlei rekenfuncties (methods), maar ook bv. constantes (properties).

Voordat je een module kan gebruiken moet je hem importeren:
import modulenaam
Als je import math doet, kan je daarna refereren aan de property math.pi (de waarde pi). Of aan de method math.factorial.

Als je maar 1 functie uit de module importeert kan je ook dit doen:
from modulenaam import functienaam (en hetzelfde geldt natuurlijk ook voor properties).

Je zou bv. kunnen zeggen:
from math import pi, factorial
Als je daarna refereert aan de geïmporteerde dingen hoef je niet meer 'math.' er voor te zetten.

Packages

Packages zijn collecties van bij elkaar horende modules in dezelfde folder.

In de folder moet wel een speciale file zijn met de naam __init__.py

Als je in je programma modules uit je package wilt gebruiken, zeg je:
from package_name import module_name

Het is wel belangrijk dat de package folder binnen de folder zit waarin je het programma uitvoert.

Package manager

Het is vaak niet nodig om zelf alle code te schrijven. Maar naast de in Python ingebouwde modules zijn er ook kant-en-klare packages. Het vinden van dat soort packages gebeurt met de package manager (pip).

In de laatste versies (bv. >= 3.4) wordt pip automatisch geïnstalleerd. Je moet hem misschien nog wel upgraden.

Om pip te installeren download je de file get-pip.py, en voert die dan uit in Python.

Met het in Python ingebouwde commando dir kan je zien wat er in een package zit, bv.:
dir(requests)

Met pip list (buiten Python) kan je zien welke packages er geïnstalleerd zijn.

Voorbeeld

from urllib import request url = "http:\\" + input("Voer een URL in zonder http en de slashes: ") webpage = request.urlopen(url) data = webpage.read() savefile = input("Voer een bestandsnaam in om de web page in te op te slaan: ") fileobj = open(savefile, "w+") fileobj.write(data.decode('utf-8')) fileobj.close()

Logging van meldingen (waarschuwing, info, etc.)

Er is een standaardmodule voor het produceren van meldingen in een aantal categorieën: DEBUG, INFO, WARNING, ERROR en CRITICAL.

Je kan gebruik maken van de module door het statement import logging op te nemen.

Daarna kan je bv. logging.info("melding") in je code opnemen. Overigens worden standaard alleen de hoogste 3 categorieën afgedrukt, dus WARNING en hoger.

Je kan het logging level veranderen met een statement als dit:
logging.basicConfig(filename="test.log", level=logging.DEBUG)

Omdat DEBUG het laagste niveau is wordt nu alles gelogged. De uitvoer gaat naar test.log

Je kan ook de layout van de messages veranderen, bv. als volgt:
logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)

En als je de tijd wilt opnemen, doe je dat door %(asctime)s ook nog toe te voegen.

Als de layout van tijd en datum je niet aanstaan, kan je het volgende stuk toevoegen: datefmt='%m/%d/%Y %I:%M:%S %p' (%I staat voor 12-uur klok, i.t.t. %H, %p staat voor AM/PM).

Aandachtspunten

Troubleshooting

Syntax

In geval van syntaxfouten, kan je het beste eerst checken of alle haakjes (zowel de gewone, als de curly braces (zoals '}') in balans zijn.

Een andere, veel voorkomende, fout is het ontbreken van een ';' (semicolon, puntkomma) aan het eind van een statement.

Verder kan je checken of alle variabelen gedeclareerd zijn. Daarbij moet je bedenken dat C(++) case sensitive is!!!

    Tweeten
© Henk Dalmolen
Reageer via E-mail (dalmolen@xs4all.nl)

Deze pagina is voor het laatst gewijzigd op: 09-02-23 14:30:25