Deze lezing gaat over de modules en pakketten in Python.
Ze zijn een manier om je code in de vorm van bestanden te organiseren en zijn erg belangrijk als je webapplicaties wilt bouwen met Python
Modules
Een module in Python is in feite een bestand met wat python-code die we gebruiken om onze code in bestanden te ordenen. Zie het als secties in een supermarkt. Als je naar een supermarkt gaat, zijn er verschillende secties voor fruit, groenten, schoonmaakmiddelen etc. Je ziet niet één sectie met alle producten.
Het is hetzelfde concept in programmeren. In plaats van al onze code met alle functies en klassen in main.py te schrijven, splitsen we onze code op in meerdere bestanden. Elk bestand wordt een module genoemd. Hiermee is niet alleen onze code beter georganiseerd en gestructureerd, maar hebben we ook de mogelijkheid om onze code opnieuw te gebruiken. Laten we het bekijken door middel van een voorbeeld.
Laten we twee functies definiëren voor het omrekenen van gewicht van ponden naar kilogrammen en vice versa.
def lbs_to_kg(weight):
return weight * 0.45
def kg_to_lbs(weight):
return weight / 0.45
Nu kunnen we deze twee functies nemen en ze in een aparte module met de naam "converters" plaatsen, en dan kan het worden geïmporteerd in elk programma dat deze converterfuncties nodig heeft. Laat me je laten zien hoe je dit kunt doen.
Laten we ons projectpaneel openen en met de rechtermuisknop op het project klikken en een nieuw bestand toevoegen. We gaan dit bestand "Converters.py" noemen.
Kopieer nu de code uit het standaardbestand en plak deze in de "Converters.py".
Hiermee hebben we onze hoofdmodule opgeruimd en is deze niet opgeblazen met verschillende functies. Naarmate we meer functies met klassen schrijven, plaatsen we ze in de bijbehorende modules. Een module moet alle gerelateerde functies en klassen bevatten. Nu willen we de converters-module importeren in onze app-module. Om dit te doen, schrijf import converters
bovenaan zonder de extensie ".py".
We hebben toegang tot de leden van een module door een puntoperator te gebruiken die vergelijkbaar is met methoden.
Laten we 70 kg omrekenen naar ponden:
Er is ook een andere syntaxis voor het importeren van modules. In plaats van de hele module te importeren, kunnen we specifieke functies uit die module importeren. We kunnen typen from Converters import
en druk op "control + spatie" om de lijst met beschikbare functies weer te geven. Hiermee kunnen we deze functie direct aanroepen.
Oefening
Hier is je oefening.
Dit hangt samen met een oefening uit de lezing waar we bespraken “voor loops” waar we een programma hebben geschreven om het grootste aantal uit een lijst te achterhalen
numbers = [8, 3, 6, 10, 5]
max = numbers[0]
for number in numbers:
if number > max:
max = number
print(max)
Deze code heeft momenteel geen organisatie. We hebben geen functies of modules en het programma is in één bestand geschreven. Dat is oké voor kleine programma's, maar naarmate je programma's groeien, moet je je code goed indelen in klassen en modules. Daarom, als onderdeel van deze oefening, wil ik dat je een functie schrijft, noem deze find_max
. Deze functie zou een lijst moeten aannemen en het grootste getal in die lijst moeten retourneren. Ga je gang en plaats deze functie in een aparte module, pak hem hier uit en plaats hem in een module met de naam utils
. Deze module zou een aantal hulpprogramma's moeten bevatten. Importeer de utils
module in de huidige module en bel find_max
functie. Haal ten slotte het resultaat op en druk het af op de terminal.
Deze oefening is een beetje uitdagend, maar gemakkelijk te doen.
Oplossing
Begin met het definiëren van een functie find_max
en voeg een parameter met de naam getallen toe. Schrijf binnen deze functie het algoritme voor het vinden van het grootste getal in een lijst.
def find_max(numbers):
max = numbers[0]
for number in numbers:
if number > max:
max = number
return max
Sla deze code op in een bestand "utils.py" als module.
Terug naar ons hoofdprogramma, importeert u de module met een van de twee syntaxis en voert u eenvoudig de logica uit.
Eén ding, waar ik uw aandacht op moet vestigen, is het ondermijnde max
. De reden daarvoor is de max
is een ingebouwde functie in Python en we zijn deze aan het herdefiniëren. Dit is dus een waarschuwing van de Python-compiler dat we max niet langer als ingebouwde functie kunnen gebruiken.
Ingebouwde modules in Python
Python wordt geleverd met een standaardbibliotheek die verschillende modules bevat voor veelvoorkomende taken zoals het verzenden van e-mails, werken met datum en tijd, het genereren van willekeurige waarden en wachtwoorden enzovoort. Er zijn al zoveel modules ingebouwd in Python, wat betekent dat er al veel functionaliteit is die we kunnen hergebruiken. U vindt deze modules hier.
Pakketten
Pakketten zijn in feite een andere manier om onze code bovenop de modules te organiseren. Een echt project kan honderden of zelfs duizenden modules bevatten en na verloop van tijd zal onze directory vol raken met zoveel bestanden. Daarom is het een betere benadering om gerelateerde modules in een pakket te organiseren, waardoor het pakket een container wordt voor meerdere modules.
Er wordt een nieuwe map aan het project toegevoegd en alle gerelateerde modules worden aan die map toegevoegd. Denk bijvoorbeeld aan een winkelcentrum. Er zijn verschillende secties voor heren-, dames- en kinderkleding in een winkelcentrum die als pakketten zijn. Elke sectie heeft verschillende gebieden voor verschillende soorten producten zoals schoenen, t-shirts en jassen. Zie deze als modules.
Laten we eens kijken hoe we pakketten in Python kunnen maken en gebruiken.
Voeg eerst een nieuwe map toe vanuit het projectpaneel. Laten we het "e-commerce" noemen. Dit pakket bevat alle modules met betrekking tot een eCommerce-applicatie.
Het is nog steeds een lege map en om het naar een pakket te converteren, moeten we er een speciaal bestand in maken. Voeg een nieuw python-bestand toe aan deze map en noem dat bestand "__init__". Het is een speciale conventie in Python en wanneer de Python-interpreter een bestand met deze naam in een map ziet, behandelt hij deze map als een pakket.
We hebben ook een alternatieve en beknopte methode om een pakket te maken. Klik met de rechtermuisknop op het projectpaneel en maak een Python-pakket uit de lijst. Noem het "eCommerce" en dat is alles. Het zal automatisch een map maken met een Python-bestand met de naam "__init__".
Laten we nu een module in het pakket maken en deze "verzending" noemen. Laten we in deze module een eenvoudige functie maken voor het berekenen van verzendkosten.
def calc_shipping():
print("calc_shipping")
Om toegang te krijgen tot deze functie in onze hoofdmodule, moeten we deze openen via het e-commercepakket. We hebben weer twee methoden om deze module te importeren.
Bij de eerste methode kunnen we de hele module importeren en vervolgens onafhankelijk een functie als volgt aanroepen:
import eCommerce.shipping
eCommerce.shipping.calc_shipping()
Bij deze benadering vereist het aanroepen van een van de functies naar deze module echter het voorvoegsel met eCommerce.shipping.
Dat is erg uitgebreid. Dus als we met pakketten werken, gebruiken we vaak de tweede benadering en gebruiken we de from
verklaring.
from eCommerce.shipping import calc_shipping
calc_shipping()
Als u meerdere functies in één module heeft, kunt u ze allemaal op één regel importeren door komma's ertussen te gebruiken. Laten we zeggen dat er een andere functie is voor het berekenen van belasting in onze verzendmodule. Dat wordt als volgt geïmporteerd:
from eCommerce.shipping import calc_shipping, calc_tax
U kunt ook afzonderlijke modules importeren en functies in een later stadium in het programma laten oproepen. Laten we de moduleverzending importeren en vervolgens een puntoperator gebruiken om de functie aan te roepen calc_shipping.
from eCommerce import shipping
shipping.calc_shipping()
Inpakken!
Pakketten en modules zijn uiterst belangrijk in Python. Vooral als je wilt werken met een framework zoals Django dat wordt gebruikt voor het bouwen Webapplicaties met Python. Tijdens een andere Python-cursus gaan we Django onderzoeken.
Dit was de laatste conventionele lezing in deze reeks. De volgende lezing zal afwijken van ons gebruikelijke formaat en we zullen enkele belangrijke use-cases in Python leren. Dat markeert het einde van deze serie en we gaan verder met onze volgende Python-serie. Blijf daarvoor op de hoogte.
Laat een reactie achter