Python: Python leren

Een uitgebreide Python-gids

👋 Welkom bij de Stackhero-documentatie!

Stackhero biedt een kant-en-klare Python cloud oplossing die tal van voordelen biedt, waaronder:

  • Implementeer uw applicatie in seconden met een eenvoudige git push.
  • Gebruik uw eigen domeinnaam en profiteer van de automatische configuratie van HTTPS-certificaten voor verbeterde beveiliging.
  • Geniet van gemoedsrust met automatische back-ups, updates met één klik, en eenvoudige, transparante en voorspelbare prijzen.
  • Krijg optimale prestaties en robuuste beveiliging dankzij een privé en dedicated VM.

Bespaar tijd en vereenvoudig uw leven: het kost slechts 5 minuten om de Python cloud hosting oplossing van Stackhero te proberen!

Deze gids biedt een overzicht van essentiële Python-concepten en -syntaxis. Het dient als een snelle opfrisser voor ervaren ontwikkelaars en een vriendelijke introductie voor beginners. Van basisgegevens tot geavanceerde functies, deze spiekbrief bevat onderwerpen zoals controleflow, functies, klassen, objecten en veelgebruikte modules. Houd het bij de hand als snelle referentie tijdens het werken aan Python-projecten. Houd er rekening mee dat Python een uitgebreid ecosysteem van bibliotheken en frameworks heeft, dus het verkennen van aanvullende bronnen en documentatie zal u helpen dieper in gespecialiseerde onderwerpen te duiken.

Veel plezier met coderen!

Introductie tot Python

Python is een veelzijdige, hoog-niveau programmeertaal gecreëerd door Guido van Rossum en voor het eerst uitgebracht in 1991. Het is populair vanwege zijn leesbaarheid en eenvoud, waardoor het een uitstekende keuze is voor zowel beginners als ervaren ontwikkelaars. Python wordt veel gebruikt in webontwikkeling, data-analyse, kunstmatige intelligentie, machine learning en automatisering, naast vele andere gebieden.

Enkele veelvoorkomende gebruiksscenario's voor Python zijn het bouwen van webapplicaties met frameworks zoals Django of Flask, het analyseren en visualiseren van data met bibliotheken zoals pandas en matplotlib, en het ontwikkelen van machine learning-modellen met tools zoals TensorFlow en scikit-learn.

De uitgebreide standaardbibliotheek van Python en het bloeiende ecosysteem van externe pakketten maken het een krachtige en flexibele taal voor het aanpakken van een breed scala aan programmeertaken.

Basisgegevens

De basisgegevens van Python omvatten gehele getallen (hele getallen), zwevende-kommagetallen (getallen met decimalen), booleans (waar/onwaar waarden) en strings (reeksen van tekens):

  • int: Geheel getal, bijv. 42
  • float: Zwevend-kommagetal, bijv. 3.14
  • bool: Boolean, bijv. True of False
  • str: String, bijv. "hello"

Voorbeeld:

integer = 42
floating_point = 3.14
boolean = True
string = "Hello, World!"

Veelvoorkomende datastructuren

Python biedt verschillende datastructuren om u te helpen gegevens efficiënt te organiseren, op te slaan en te manipuleren. De meest gebruikte zijn lijsten, tuples, woordenboeken en sets. Lijsten en tuples behouden een geordende reeks elementen, woordenboeken slaan sleutel-waardeparen op, en sets slaan unieke elementen op. Elke structuur heeft een reeks methoden die zijn afgestemd op specifieke gebruiksscenario's.

  • Lijst: my_list = [1, 2, 3, 4]
  • Tuple: my_tuple = (1, 2, 3, 4)
  • Woordenboek: my_dictionary = {'key1': 'value1', 'key2': 'value2'}
  • Set: my_set = {1, 2, 3, 4}

Lijsten

Lijsten zijn veranderlijke, geordende collecties van elementen. Ze staan duplicaten toe en kunnen elementen van verschillende gegevenstypen bevatten, inclusief andere lijsten, tuples, woordenboeken of sets. U kunt eenvoudig elementen toevoegen, bijwerken en verwijderen. Lijsten worden gedefinieerd binnen vierkante haken [] met elementen gescheiden door komma's.

Belangrijke punten over lijsten:

  1. Veranderlijk en geordend
  2. Staan dubbele elementen toe
  3. Behouden de volgorde waarin elementen worden toegevoegd
  4. Ondersteunen meerdere gegevenstypen
  5. Bieden bewerkingen voor het toevoegen, bijwerken en verwijderen van elementen

Lijsten worden vaak gebruikt wanneer u een dynamische en aanpasbare verzameling items nodig heeft.

Voorbeelden:

# Maak een lijst
my_list = [1, 2, 3, 4, 5]

# Toegang tot elementen
print(my_list[0])  # Uitvoer: 1
print(my_list[-1])  # Uitvoer: 5

# Voeg elementen toe
my_list.append(6)
print(my_list)  # Uitvoer: [1, 2, 3, 4, 5, 6]

# Werk elementen bij
my_list[0] = 0
print(my_list)  # Uitvoer: [0, 2, 3, 4, 5, 6]

# Verwijder elementen
del my_list[0]
print(my_list)  # Uitvoer: [2, 3, 4, 5, 6]

Woordenboeken

Woordenboeken zijn veranderlijke, ongeordende collecties van sleutel-waardeparen. Elke sleutel moet uniek zijn, en u kunt deze sleutels gebruiken om toegang te krijgen tot hun bijbehorende waarden. Net als lijsten kunnen woordenboeken elementen van verschillende gegevenstypen opslaan, inclusief geneste collecties. Ze worden gedefinieerd binnen accolades {} met sleutel-waardeparen gescheiden door komma's, en sleutels en waarden gescheiden door een dubbele punt.

Belangrijke punten over woordenboeken:

  1. Veranderlijke en ongeordende collectie
  2. Bestaat uit sleutel-waardeparen met unieke sleutels
  3. Toegang tot waarden met behulp van sleutels
  4. Opslaan van verschillende gegevenstypen

Woordenboeken zijn ideaal voor taken waarbij u opzoekingen moet uitvoeren, zoals configuratie-instellingen of frequentietellingen.

Voorbeelden:

# Maak een woordenboek
my_dictionary = {'a': 1, 'b': 2, 'c': 3}

# Toegang tot elementen
print(my_dictionary['a'])  # Uitvoer: 1

# Voeg elementen toe
my_dictionary['d'] = 4
print(my_dictionary)  # Uitvoer: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

# Werk elementen bij
my_dictionary['a'] = 0
print(my_dictionary)  # Uitvoer: {'a': 0, 'b': 2, 'c': 3, 'd': 4}

# Verwijder elementen
del my_dictionary['a']
print(my_dictionary)  # Uitvoer: {'b': 2, 'c': 3, 'd': 4}

Tuples

Tuples zijn onveranderlijke, geordende collecties van elementen. Ze werken net als lijsten, behalve dat zodra een tuple is gemaakt, de elementen niet kunnen worden gewijzigd, toegevoegd of verwijderd. Tuples worden gedefinieerd met behulp van haakjes () met elementen gescheiden door komma's.

Belangrijke punten over tuples:

  1. Onveranderlijke en geordende collectie
  2. Ondersteunen meerdere gegevenstypen
  3. Structuur van vaste grootte

Tuples zijn nuttig wanneer u een onveranderlijke collectie nodig heeft, of wanneer u de collectie als een woordenboeksleutel wilt gebruiken.

Voorbeeld:

# Maak een tuple
my_tuple = (1, 2, 3, 4, 5)

# Toegang tot elementen
print(my_tuple[0])  # Uitvoer: 1
print(my_tuple[-1])  # Uitvoer: 5

# Opmerking: Tuples zijn onveranderlijk

Sets

Sets zijn veranderlijke, ongeordende collecties die unieke elementen opslaan. Ze verwijderen automatisch duplicaten en behouden geen volgorde. Sets kunnen elementen van verschillende gegevenstypen bevatten, met uitzondering van veranderlijke typen zoals lijsten en woordenboeken. Ze kunnen worden gedefinieerd met behulp van accolades {} of de set() constructor.

Belangrijke punten over sets:

  1. Veranderlijk en ongeordend
  2. Sla alleen unieke elementen op, automatisch duplicaten verwijderen
  3. Sluit veranderlijke typen uit (zoals lijsten en woordenboeken)

Sets zijn ideaal voor lidmaatschapstesten, deduplicatie en het uitvoeren van setbewerkingen zoals unie, doorsnede en verschil.

# Maak een set
my_set = {1, 2, 3, 4, 5}

# Controleer lidmaatschap
print(1 in my_set)  # Uitvoer: True

# Voeg een element toe
my_set.add(6)
print(my_set)  # Uitvoer: {1, 2, 3, 4, 5, 6}

# Werk bij door een element te verwijderen en een ander toe te voegen
my_set.remove(1)
my_set.add(0)
print(my_set)  # Uitvoer: {0, 2, 3, 4, 5, 6}

# Verwijder een element
my_set.remove(0)
print(my_set)  # Uitvoer: {2, 3, 4, 5, 6}

Voorwaardelijke instructies: if, elif, else

Voorwaardelijke instructies stellen u in staat om code uit te voeren op basis van of een voorwaarde waar of onwaar is.

if condition1:
  # doe iets
elif condition2:
  # doe iets anders
else:
  # doe een andere zaak

Voorbeeld:

x = 42

if x > 50:
  print("x is groter dan 50")
elif x < 50:
  print("x is kleiner dan 50")
else:
  print("x is gelijk aan 50")

for-lus

for-lussen itereren over een reeks, zoals een lijst of een bereik, en voeren een codeblok uit voor elk element.

Voorbeeld:

for i in range(5):
  print(i)

while-lus

while-lussen voeren een codeblok uit zolang een gespecificeerde voorwaarde waar is.

Voorbeeld:

i = 0
while i < 5:
  print(i)
  i += 1

Functies

Functies kapselen code in herbruikbare blokken die invoer (argumenten) kunnen accepteren en uitvoer kunnen retourneren. Ze worden gedefinieerd met behulp van het def-sleutelwoord en kunnen worden aangeroepen met hun naam.

def function_name(argument1, argument2=default_value):
  # doe iets
  return result

Voorbeeld:

def add(a, b):
  return a + b

result = add(3, 4)
print(result)  # Uitvoer: 7

Lambda-functies

Lambda-functies, ook wel anonieme functies genoemd, zijn beknopte functies met één expressie die worden gemaakt met behulp van het lambda-sleutelwoord. Ze worden vaak gebruikt voor korte bewerkingen, vaak als argumenten voor functies zoals map(), filter(), of sorted().

lambda arguments: expression

Voorbeeld:

add = lambda a, b: a + b
result = add(3, 4)
print(result)  # Uitvoer: 7

Lijstbegrippen

Lijstbegrippen stellen u in staat om lijsten te maken in één leesbare regel door een expressie te combineren met een lus en een optionele voorwaarde. Ze zijn uitstekend voor het transformeren of filteren van gegevens.

new_list = [expression for item in iterable if condition]

Voorbeeld:

squares = [x * x for x in range(1, 6)]
print(squares)  # Uitvoer: [1, 4, 9, 16, 25]

Foutafhandeling

Foutafhandeling stelt uw programma in staat om runtime-fouten op een elegante manier te beheren. Python biedt de try, except, en finally-blokken om uitzonderingen op te vangen en te behandelen, zodat uw programma soepel kan doorgaan of afsluiten.

try:
    # code die een uitzondering kan veroorzaken
except ExceptionType as error_variable:
    # behandel de uitzondering
finally:
    # code die moet worden uitgevoerd ongeacht of er een uitzondering is opgetreden

Voorbeeld:

try:
  result = 10 / 0
except ZeroDivisionError:
  print("Kan niet delen door nul!")

Klassen en objecten

Klassen definiëren blauwdrukken voor het maken van objecten in objectgeoriënteerd programmeren (OOP). Objecten zijn instanties van een klasse met attributen (gegevens) en methoden (functies) die specifieke taken uitvoeren. OOP bevordert gestructureerde, herbruikbare en onderhoudbare code.

class ClassName:
  def __init__(self, attribute1, attribute2):
    self.attribute1 = attribute1
    self.attribute2 = attribute2

  def method_name(self, argument1):
    # doe iets
    return result

Voorbeeld:

class Dog:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def bark(self):
    print("Woef!")

# Maak een instantie van Dog
dog1 = Dog("Buddy", 3)
dog1.bark()  # Uitvoer: Woef!

Modules importeren

Modules zijn aparte bestanden die Python-code bevatten, zoals functies, klassen of variabelen. Het importeren van modules stelt u in staat om de functionaliteit van uw programma uit te breiden door gebruik te maken van externe bibliotheken en frameworks.

import module_name
from module_name import specific_function_or_class

Voorbeeld:

import math
print(math.sqrt(16))  # Uitvoer: 4.0

Bestands-I/O

Bestandsinvoer/-uitvoer (I/O) omvat het lezen van en schrijven naar bestanden in Python. Dit is essentieel bij het werken met gegevensopslag en -ophaling.

Een bestand lezen

with open('filename.txt', 'r') as file:
  content = file.read()

Naar een bestand schrijven

with open('filename.txt', 'w') as file:
  file.write('inhoud om naar het bestand te schrijven')

Contextmanagers

Contextmanagers helpen bij het beheren van bronnen, zoals bestanden of netwerkverbindingen, en zorgen ervoor dat ze correct worden verkregen en vrijgegeven. Het gebruik van een contextmanager zorgt ervoor dat uw code schoner en fouttoleranter is.

with resource as alias:
  # gebruik resource als alias

Voorbeeld:

with open('file.txt', 'r') as file:
  content = file.read()
  print(content)  # Uitvoer: Hello, World!

Decorators

Decorators stellen u in staat om het gedrag van functies of klassen uit te breiden of te wijzigen zonder hun broncode te wijzigen. Ze omhullen een andere functie en voegen functionaliteit toe vóór of na de uitvoering van de omhulde functie.

def decorator_function(func):
  def wrapper(*args, **kwargs):
    # doe iets voordat de functie wordt aangeroepen
    result = func(*args, **kwargs)
    # doe iets nadat de functie is aangeroepen
    return result
  return wrapper

@decorator_function
def my_function():
  # doe iets

Voorbeelden:

def greet_decorator(func):
  def wrapper(name):
    return "Hello, " + func(name) + "!"
  return wrapper

@greet_decorator
def get_name(name):
  return name

print(get_name("John"))  # Uitvoer: Hello, John!

Itertools-module

De itertools-module biedt functies voor het maken en werken met iterators. Het omvat oneindige iterators (zoals count, cycle en repeat), eindige iterators (zoals accumulate, chain, compress), en combinatorische iterators (zoals product, permutations en combinations).

Voorbeeld:

import itertools

for i in itertools.count(5, 5):
  if i > 20:
    break
  print(i)  # Uitvoer: 5, 10, 15, 20

Collections-module

De collections-module biedt gespecialiseerde containergegevens die uw programma's kunnen verbeteren.

from collections import namedtuple, defaultdict, Counter, deque

Voorbeelden:

from collections import namedtuple, deque, Counter, OrderedDict, defaultdict

# namedtuple
Person = namedtuple('Person', 'name age')
person1 = Person("Alice", 30)
print(person1.name, person1.age)  # Uitvoer: Alice 30

# deque
dq = deque([1, 2, 3, 4, 5])
dq.append(6)
dq.appendleft(0)
print(dq)  # Uitvoer: deque([0, 1, 2, 3, 4, 5, 6])

# Counter
count = Counter("hello world")
print(count)  # Uitvoer: Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})

# OrderedDict
od = OrderedDict()
od['a'] = 1
od['b'] = 2
od['c'] = 3
print(od)  # Uitvoer: OrderedDict([('a', 1), ('b', 2), ('c', 3)])

# defaultdict
dd = defaultdict(int)
dd['a'] += 1
dd['b'] += 2
print(dd)  # Uitvoer: defaultdict(<class 'int'>, {'a': 1, 'b': 2})

Reguliere expressies

Reguliere expressies maken krachtige tekstverwerking en -manipulatie mogelijk. De re-module biedt functies zoals match, search, findall, finditer, split en sub.

Voorbeeld:

import re

pattern = r'\d+'
result = re.findall(pattern, "There are 10 cats and 5 dogs.")
print(result)  # Uitvoer: ['10', '5']

Datums en tijden

Werken met datums en tijden is een veelvoorkomende vereiste, vooral voor data-analyse of planningsopdrachten. De datetime-module biedt klassen en functies om te werken met datums, tijden en intervallen.

import datetime

# datetime, date, time, timedelta, timezone

Voorbeelden:

from datetime import datetime, timedelta

# Huidige datum en tijd
current_time = datetime.now()
print("Huidige datum en tijd:", current_time)

# Aangepaste datum en tijd
custom_date = datetime(2022, 12, 31, 23, 59, 59)
print("Aangepaste datum en tijd:", custom_date)

# Converteer string naar datetime
date_str = "2023-01-01 00:00:00"
date_obj = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
print("String naar datetime:", date_obj)

# Converteer datetime naar string
date_str2 = date_obj.strftime("%Y-%m-%d %H:%M:%S")
print("Datetime naar string:", date_str2)

# Datum- en tijdrekenkunde
one_day = timedelta(days=1)
yesterday = current_time - one_day
tomorrow = current_time + one_day
print("Gisteren:", yesterday)
print("Morgen:", tomorrow)

Lijstsnijden

Lijstsnijden stelt u in staat om een deel van een lijst of een ander sequentietype te extraheren door begin-, eind- en optionele stapwaarden op te geven. Deze functie is zeer nuttig voor het extraheren van subsequenties.

my_list[start:end:step]

Voorbeeld:

my_list = [0, 1, 2, 3, 4, 5]
sub_list = my_list[1:4]
print(sub_list)  # Uitvoer: [1, 2, 3]

Stringformattering

Stringformattering is het proces van het combineren van statische tekst met dynamische waarden. Python biedt verschillende formatteringsmethoden, waaronder %-formattering, de str.format()-methode, en f-strings (Python 3.6+), waarmee u eenvoudig geformatteerde strings kunt genereren.

%-formattering

print("Hello, %s" % name)

str.format

print("Hello, {}".format(name))

f-strings (Python 3.6+)

print(f"Hello, {name}")

Voorbeeld:

name = "John"
age = 30
formatted_string = f"My name is {name} and I am {age} years old."
print(formatted_string)  # Uitvoer: My name is John and I am 30 years old.

Command-line argumenten

Command-line argumenten stellen u in staat om invoerwaarden door te geven aan een Python-script wanneer u het vanaf de opdrachtregel uitvoert. De sys.argv-lijst biedt toegang tot deze argumenten, waardoor het eenvoudig is om ze te parseren en te gebruiken binnen uw script.

import sys

arguments = sys.argv

Voorbeeld:

# Sla deze code op in een bestand genaamd "cmd_args.py"
# Voer uit met: python cmd_args.py Alice
# Verwachte uitvoer: Hello, Alice!
import sys

if len(sys.argv) > 1:
  print(f"Hello, {sys.argv[1]}!")
else:
  print("Geen argumenten opgegeven.")

Other articles for Python