Python-setup: de definitieve gids

Voor developers maakt een goed ingerichte werkplek het ontwikkelwerk een stuk prettiger. Denk aan het installeren en configureren van de juiste tools en het opzetten van alles wat je helpt om het beste uit jezelf te halen tijdens het bouwen van software. Data scientists vormen daarop geen uitzondering: een goede setup is cruciaal om unieke software te maken, van visualisatietools tot ingestieprocessen. In deze tutorial leggen we de basis uit van een computer-setup voor data science, maar de gids is ook nuttig voor iedereen die software wil ontwikkelen met de programmeertaal Python. Aan de slag!

Scope

Python is beschikbaar voor een breed scala aan besturingssystemen. Deze tutorial laat enkele snippets zien die zijn uitgevoerd op Linux Ubuntu, maar ze zijn grotendeels toepasbaar op andere UNIX-systemen en macOS. Voor MS Windows zijn er ook kleine verschillen; die noemen we wanneer ze relevant zijn.

Python: het kernstuk

tl;dr Gebruik de Python 3-implementatie van de officiële website

De Python-interpreter zien als het kernstuk voor applicatieontwikkeling in deze taal ligt voor de hand. Toch kun je vastlopen bij het kiezen van de beste Python-interpreter. Bovendien heb je misschien gelezen over twee verschillende versies van de taal; de juiste versie en interpreter kiezen is de eerste belangrijke beslissing.

Python, Anaconda, Jython, WinPython, IronPython... te veel slangen voor één kooi

Door de populariteit van de taal zijn er veel implementaties van de interpreter. Sommige kun je direct installeren op je computer, andere zitten nog in een vroege ontwikkelfase en zijn vooral aan te raden voor de makers zelf of dappere programmeurs. De officiële Python-wiki lijst enkele beschikbare interpreters met hun specifieke eigenschappen ten opzichte van andere implementaties. Zoals we in deze tutorial zullen zien, bevat de Python-distributie op de officiële website alles wat je nodig hebt om met je Python-programma’s te beginnen, zonder functies te missen die andere implementaties bieden.

Python2 of Python3? Welke versie moet je gebruiken?

Hoewel Python 3 tien jaar geleden is uitgebracht, verliep de overgang van Python 2 naar de nieuwste versie niet zonder slag of stoot. Een van de belangrijkste oorzaken van de trage adoptie waren syntaxverschillen waardoor bestaande libraries niet beschikbaar waren voor de nieuwste versie. Zoals je zult merken bij het ontwikkelen met Python, is de beschikbaarheid van libraries voor allerlei doeleinden een van de grootste krachten van deze taal. In de tussentijd zijn tools en libraries zoals 2to3 en six ontwikkeld om de kloof te dichten en de migratie te vereenvoudigen. Ten tijde van het schrijven van deze tutorial is het overgrote deel van de libraries beschikbaar voor Python 3, waardoor de keuze nu vrij eenvoudig is: Python 3. Bovendien loopt de levenscyclus van Python 2 in 2020 af. Er zijn zelfs plannen voor een Celebration of Life-party tijdens PyCon 2020. Twijfel dus niet om mee te vieren en Python 2 te bedanken voor wat het voor jou en je software heeft betekend!

Python installeren op je computer

De Python-interpreter is breed beschikbaar voor de meeste besturingssystemen, en sommige leveren zelfs pakketten mee om de installatie te vereenvoudigen. Op Ubuntu zijn Python2 en Python3 zelfs standaard tegelijk aanwezig op desktopomgevingen. Houd er rekening mee dat de alias python nog steeds naar Python 2 verwijst in plaats van 3, of definieer een alias in je ~/.bashrc-bestand als je dat handig vindt. Zoals hierboven genoemd, is de verwachting dat er in de komende jaren nog maar één Python-versie geïnstalleerd zal zijn. Mijn aanbeveling is om de meest recente Python-versie te installeren. Als je al Python 3 hebt, controleer dan of de versie hoger is dan 3.5. Heb je een oudere versie, upgrade dan en profiteer van de nieuwste taalfeatures.

$ python --version
Python 3.5.2

Voor Windows-gebruikers is het installeren van de Python-interpreter ook eenvoudig. De officiële downloadpagina biedt een installer waarmee je de interpreter in een paar klikken instelt.

Projectafhankelijkheden beheren met pip

Voor basale ontwikkeling is de Python-interpreter alles wat je nodig hebt om te beginnen met coderen. De Python-bundel wordt geleverd met de interpreter en enkele hulpmiddelen om het beheer van applicaties te vereenvoudigen. Een van die tools is pip, bedoeld om third-party libraries te installeren die zijn opgeslagen op PyPI (Python Package Index) of andere openbare of private repositories.

Ons eerste Python-project: Jupyter Notebooks

Denk aan ons eerste data science-project: een Jupyter-notebook die data schoonmaakt en prachtige visualisaties presenteert. De eerste library die je nodig hebt om met notebooks te werken is Jupyter. Jupyter installeren is zo simpel als:

$ pip install --user jupyter

Let op: de optie --user installeert de library alleen voor de gebruiker die het commando uitvoert. Systeemwijd installeren kan door deze optie weg te laten, maar dat vereist mogelijk verhoogde rechten. Naast installeren kun je met pip ook libraries downloaden, de huidige configuratie opvragen, libraries updaten en een library verwijderen als je die niet meer nodig hebt. In de tabel hieronder staan enkele handige commando’s om je applicatiebehoeften te beheren:

We komen later terug op de bovenstaande commando’s om projectafhankelijkheden te beheren. Onthoud voorlopig dat pip de dependency manager is voor je applicatie. Tot slot is het goed om te weten dat pip niet alleen de aangevraagde libraries installeert, maar ook hun afhankelijkheden. Je hoeft dus geen complexe installatieprocedures te doorlopen. pip install is the way to go!

Virtual environments: isoleer de instellingen van je project

Stel, terwijl je aan je notebooks-project werkt, ontdek je een nieuwe, glanzende library met functies die je wilt uitproberen voordat je die definitief opneemt in je projectconfiguratie. Deze library vereist een andere versie van Jupyter Notebooks. Je hebt dan de volgende opties:

• Installeer het nieuwe pakket zonder de afhankelijkheden. De library zal waarschijnlijk niet goed werken tenzij je de code aanpast.
• Installeer het nieuwe pakket mét afhankelijkheden. Je huidige project wordt beïnvloed, waardoor je de configuratie moet upgraden en mogelijk wijzigingen moet doorvoeren om alles werkend te houden.

Dit soort scenario’s kan zich voordoen als je aan twee projecten tegelijk werkt. Denk eens aan complexere situaties waarin je aan meer dan twee projecten werkt, of meerdere Python-applicaties hebt die afhankelijk zijn van een library die je ongewijzigd nodig hebt. Dat kan een flinke hoofdpijn worden. Gelukkig biedt Python een mechanisme om de configuratie van projecten te isoleren van andere projecten of applicaties: virtual environments. Ze bestonden al in Python 2 naast andere isolatiemechanismen, maar sinds versie 3.6 zijn ze een ingebouwd pakket (het is aan te raden minstens deze versie te gebruiken!). Oudere Python 3-versies kunnen de library installeren met pip als volgt:

$ pip install -U venv

Voor wie Python 2 gebruikt (tenzij je liever upgrade): de library heet virtualenv en kun je op dezelfde manier installeren.

$ pip install -U virtualenv

Ontwikkelaars op Ubuntu kunnen virtualenv ook als systeempakket installeren met apt-get:

$ sudo apt-get install python3-venv

Een nieuwe virtual environment maken is eenvoudig. Typ in de command line het volgende om een nieuwe virtual environment aan te maken in de map new_venv.

$ python -m venv new_venv

Tip: voer het bovenstaande commando uit vanuit je werkmap. Zo heb je een self-contained map met je broncode en de virtual environment waarin de libraries van je applicatie worden opgeslagen. Zodra de virtual environment is aangemaakt, kun je geïsoleerd gaan werken door het script activate te laden in new_venv/bin/activate.

source new_venv/bin/activate
(new_venv) $ ...

Windows-gebruikers voeren het script activate uit in de map Scripts.

new_venv/Scripts/activate
(new_venv) $ ...

Let op: zodra de virtual environment is geladen, verandert de shellprompt en verschijnt de naam van de environment tussen haakjes. In een notendop bevat de virtual environment het volgende:

• Een python-interpreter: dezelfde als die waarmee de virtual environment is aangemaakt. Tenzij je de alias python aanpast, moet je expliciet python3 gebruiken, of zelfs python3.6 als je meerdere Python 3-versies hebt.
• De pip-package manager. De package manager installeert alle libraries in de map lib/pythonX.Y/site/packages. De interpreter gebruikt deze map om afhankelijkheden op te lossen.
• Scripts om te activeren/deactiveren. Hiermee laad je de projectomgeving en ga je daarna weer terug naar de standaardconfiguratie. Met de virtual environment actief kun je libraries installeren zoals:

$ pip install requests

Dit commando installeert de library requests in de virtual environment, waarna de interpreter in de map bin van de environment deze kan laden. Merk op dat er geen verhoogde rechten nodig waren om te installeren. Je kunt de installatie controleren met pip show (pip show requests) voor details over de geïnstalleerde library. Ben je klaar met werken aan een project, dan deactiveer je de virtual environment met het commando deactivate.

(new_venv) $ deactivate
$

Zo simpel, zo krachtig, zo handig. Virtual environments to the rescue! :D

TIP: De locatie waar pakketten worden geïnstalleerd, kun je controleren via de variabele sys.prefix. Probeer dit in een geladen environment en ook in de standaardconfiguratie.

>>> import sys
>>> print(sys.prefix)

Projectscaffolding: supereenvoudig met Cookiecutter!

Jij en de meesten van ons zijn begonnen met Python door een simpel script te schrijven (waarschijnlijk Hello World). Als we daarop voortbouwen met wat we hierboven hebben besproken, komen we tot de volgende werkstructuur:

• Een map die onze werkruimte bevat, met daarin
• Een map voor de virtual environment, en
• Een simpel script met je Hello World-applicatie.

Hoewel Python-projecten geen verplichte structuur hebben, is het aan te raden je code te structureren, samen met de testsuite en andere scripts of configuratiebestanden die je helpen tijdens de volledige ontwikkelcyclus. In de meest eenvoudige vorm kan een Python-werkruimte er zo uitzien:

$ tree -L 1
.
├── requirements.txt     ---> Project dependencies file
├── src                  ---> Source code goes here
├── tests                ---> Test code goes here
└── venv                 ---> Virtual environment files

We hadden het eerder in de sectie over pip al over het bestand requirements.txt. Dit bestand bevat de projectafhankelijkheden en kan gevuld worden met het commando pip freeze. De mappen src en tests bevatten de businesslogica en de bijbehorende tests. En de map venv (vaak zo genoemd) bevat de configuratie van de virtual environment.

Projectscaffolding maken op de makkelijke manier: Cookiecutter

Hoewel de hierboven geschetste aanpak voldoende kan zijn, wil je naarmate je skills groeien misschien een uitgebreidere scaffolding gebruiken met meer tools die het ontwikkelproces vergemakkelijken. Handmatig een Python-scaffolding opzetten is vaak tijdrovend. Een betere optie is een referentieproject te onderhouden en daar een kopie van te maken, waarbij je vervolgens enkele onderdelen vervangt. Dat kan werken, maar is foutgevoelig en kan tot inconsistenties leiden als je vergeet bepaalde resources goed in te stellen. Nieuwe projecten kun je eenvoudig opzetten met de tool cookiecutter. Deze tool neemt een projectsjabloon als input en maakt een kopie, waarbij bestandsnamen en inhoud worden vervangen op basis van invoer die aan de gebruiker wordt gevraagd. De tool is in Python geïmplementeerd en kan als pip-library worden geïnstalleerd.

$ pip install -U cookiecutter

Onthoud: de optie -U installeert de tool in je gebruikersruimte. Je kunt die overslaan, maar dan moet je installeren als root (of via sudo). Voor Ubuntu is de tool ook beschikbaar als pakket dat je met apt-get kunt installeren

$ sudo apt-get install cookiecutter

In de eenvoudigste vorm roep je cookiecutter aan als volgt:

$ cookiecutter <TEMPLATE_LOCATION>

De locatie van sjablonen kan lokaal zijn, of als een GIT-URL worden opgegeven. Dat laatste is handig voor developers en organisaties die hun projectsjablonen willen onderhouden en doorontwikkelen.

Om te begrijpen hoe cookiecutter werkt, bekijk een voorbeeldproject voor cookiecutter. Het kernbestand van dit en elk ander cookiecutter-project heet cookiecutter.json en bevat de waarden die de gebruiker moet opgeven om de werkruimte te creëren. Dit bestand is in JSON-formaat en bevat een dictionary met key-valueparen, waarbij de waarden de standaard zijn als de gebruiker invoer overslaat.

{
    "full_name": "Steven Loria",
    "email": "sloria1@gmail.com",
    "github_username": "sloria",
    "project_name": "My Flask App",
    "app_name": "myflaskapp",
    "project_short_description": "A flasky app.",
    "use_pipenv": ["no", "yes"]
}

Op basis van de ingevoerde waarden vervangt cookiecutter in het sjabloon de bestand- en mapnamen die dubbele accolades {{...}} bevatten.

Wie eigen archetypes wil maken, kan het best starten met een cookiecutter-project en daarin alles opnemen wat waardevol is voor app-ontwikkeling. Kun je niet wachten om met een nieuw project te beginnen, dan zijn er tal van cookiecutter-projecten beschikbaar die je direct kunt instantiëren. Op zoek naar een cookiecutter die bij je past? Probeer deze cookiecutter-zoekmachine! Goed nieuws: de tool is niet alleen bedoeld voor Python-scaffoldings, maar is generiek voor andere projecttypen!

Alles bij elkaar: een ontwikkelcyclus voor je project

Nu de concepten packagebeheer, virtual environments en projectscaffolding zijn geïntroduceerd, kunnen we ze combineren en toelichten hoe je je computer kunt inrichten na het volgen van deze tutorial:

1. Gebruik Python 3 als je interpreter. Nog beter: begin met Python 3.6.
2. Maak een nieuw project aan, waarin je Python-modules en afhankelijkheden worden opgeslagen.
   • Maak eenvoudig een nieuw project met cookiecutter en een sjabloon naar keuze.
3. Maak een nieuwe virtual environment in de applicatiemap en activeer die zodra je klaar bent om te coderen.
4. Schrijf de beste app van je leven en gebruik third-party libraries als dat nodig is.
   • Vergeet niet de afhankelijkheden vast te leggen in een requirements.txt-bestand met het commando pip freeze.
5. [Optioneel] Upload je project naar een CVS-systeem zoals Git. Upload de inhoud van de virtual environment niet. Je kunt die altijd opnieuw creëren zoals hieronder uitgelegd.

Als de code en het dependencies-bestand zijn opgeslagen, kun je de projectstructuur als volgt eenvoudig reproduceren:

1. Kopieer de code en het dependencies-bestand naar een werkmap (Git-gebruikers kunnen de repository clonen).
2. Maak een nieuwe virtual environment in de applicatiemap en activeer die om de afhankelijkheden te installeren.
3. Installeer de afhankelijkheden met pip install -r requirements.txt.
4. Werk aan verbeteringen of fixes voor je project. Vergeet niet nieuwe afhankelijkheden in het requirements-bestand te zetten met pip freeze.

Nog één ding voordat we afronden. Hoewel we geen IDE’s hebben genoemd voor het coderen in Python, ben je vrij om te kiezen en die naar wens aan te passen.

Happy Python coding!

Wil je meer leren over Python, volg dan DataCamp’s gratis cursus Intro to Python for Data Science.