Articles
Inleiding tot Python
Basisprincipes van Python

Basisprincipes van Python

In dit artikel worden de basisprincipes van Python uitgelegd.

YouTube Video

"Hello World!" Uitvoeren 

1print("Hello World!")

Variabelen in Python

In Python zijn variabelen benoemde opslagruimtes voor het bewaren en gebruiken van gegevens en informatie binnen een programma. Variabelen kunnen verschillende gegevenstypes bevatten en indien nodig opnieuw worden toegewezen. Hieronder bieden we enkele voorbeeldcodes om het basisgebruik van variabelen in Python te demonstreren.

 1# 1. Assigning values to variables
 2# Integer type variable
 3age = 25
 4print("Age:", age)  # Output: Age: 25
 5
 6# Floating-point type variable
 7height = 175.5
 8print("Height:", height, "cm")  # Output: Height: 175.5 cm
 9
10# String type variable
11name = "John"
12print("Name:", name)  # Output: Name: John
13
14# Boolean type variable
15is_student = True
16print("Are you a student?", is_student)  # Output: Are you a student? True
17
18# 2. Assigning values to multiple variables simultaneously
19# You can assign multiple variables at once
20x, y, z = 5, 10, 15
21print("x =", x, ", y =", y, ", z =", z)  # Output: x = 5 , y = 10 , z = 15
22
23# 3. Updating the value of a variable
24# The value of a variable can be updated by reassignment
25age = 26
26print("Updated age:", age)  # Output: Updated age: 26
27
28# 4. Updating multiple variables at once
29# Example of swapping values between variables
30a, b = 1, 2
31a, b = b, a
32print("a =", a, ", b =", b)  # Output: a = 2 , b = 1
33
34# 5. Type conversion
35# Type conversion allows operations between different types
36count = "5"  # String "5"
37count = int(count)  # Convert to integer type
38print("Handling count as an integer:", count * 2)  # Output: Handling count as an integer: 10
39
40# Conversion to floating-point number
41pi_approx = "3.14"
42pi_approx = float(pi_approx)
43print("Approximation of pi:", pi_approx)  # Output: Approximation of pi: 3.14

Zoals te zien is, kunnen variabelen in Python flexibel worden gebruikt. Variabelen kunnen worden gebruikt zonder hun type te specificeren en kunnen indien nodig opnieuw worden toegewezen. Bovendien maakt typeconversie het eenvoudig om tussen verschillende gegevenstypes te schakelen.

Gegevenstypes in Python

Python heeft verschillende basisgegevenstypes. Hieronder geven we uitleg en voorbeeldcodes voor elk type.

Geheel getal type

Het type geheel getal wordt gebruikt om hele getallen zonder een decimaal punt te verwerken.

1# Example of integer type
2x = 10
3print(x)        # Output: 10
4print(type(x))  # Output: <class 'int'>

Kommagetal type

Het kommagetal type wordt gebruikt om getallen met een decimaal punt te verwerken.

1# Floating Point Number Example
2y = 3.14
3print(y)        # Output: 3.14
4print(type(y))  # Output: float

String type

Het stringtype vertegenwoordigt een reeks tekens. Strings kunnen worden ingesloten in enkele aanhalingstekens ' of dubbele aanhalingstekens ".

1# Example of String
2s = "Hello, World!"
3print(s)        # Output: Hello, World!
4print(type(s))  # Output: <class 'str'>

Booleaantype

Het booleaantype heeft twee waarden: waar (True) en onwaar (False).

1# Example of Boolean
2b = True
3print(b)        # Output: True
4print(type(b))  # Output: <class 'bool'>

Lijsttype

Het lijsttype is een wijzigbare reeks die meerdere elementen kan opslaan, en de elementen kunnen verschillende datatypen hebben.

1# Example of List
2lst = [1, 2, 3, "four", 5.0]
3print(lst)        # Output: [1, 2, 3, 'four', 5.0]
4print(type(lst))  # Output: <class 'list'>

Toupletype

Een tuple is een reeks die meerdere elementen kan bevatten, en de inhoud ervan kan niet worden gewijzigd wanneer deze eenmaal is gemaakt.

1# Example of Tuple
2tup = (1, "two", 3.0)
3print(tup)        # Output: (1, 'two', 3.0)
4print(type(tup))  # Output: <class 'tuple'>

Woordenboektype

Het woordenboektype is een collectie die sleutel-waardeparen bevat. Sleutels moeten uniek zijn.

1# Example of Dictionary
2dct = {"one": 1, "two": 2, "three": 3}
3print(dct)        # Output: {'one': 1, 'two': 2, 'three': 3}
4print(type(dct))  # Output: <class 'dict'>

Settype

Het settype is een collectie die unieke elementen bevat. Duplicatieve waarden kunnen niet worden opgenomen.

1# Example of Set
2st = {1, 2, 2, 3}
3print(st)        # Output: {1, 2, 3}
4print(type(st))  # Output: <class 'set'>

Deze datatypen zijn fundamentele typen die vaak worden gebruikt voor het verwerken van gegevens in Python. Door ze op de juiste manier te gebruiken, kunt u aan verschillende vereisten in uw programma's voldoen.

Python Overzicht

Python is een programmeertaal van hoog niveau, ontwikkeld door Guido van Rossum in 1991. De ontwerpfilosofie benadrukt 'eenvoud', 'duidelijkheid' en 'leesbaarheid', resulterend in code die intuïtief, gemakkelijk te schrijven en gemakkelijk te lezen is. Hieronder volgt een overzicht van de belangrijkste kenmerken van Python.

  1. Gemakkelijk te lezen en eenvoudig:

    • Met een duidelijke structuur en uitdrukkingen die dicht bij natuurlijke taal liggen, is het een eenvoudige taal om te leren voor beginners.
    • Blokken worden gedefinieerd met inspringen, wat de code automatisch opmaakt en de leesbaarheid vergroot.

  2. Rijke Bibliotheken en Frameworks:

    • Het heeft een uitgebreide standaardbibliotheek, waardoor veel taken eenvoudig kunnen worden uitgevoerd.
    • Er zijn gespecialiseerde bibliotheken en frameworks beschikbaar voor verschillende vakgebieden, zoals numerieke berekeningen (NumPy), data-analyse (Pandas), machine learning (scikit-learn, TensorFlow) en webontwikkeling (Django, Flask).

  3. Veelzijdigheid:

    • Python is geschikt als scripttaal en voor de ontwikkeling van volwaardige applicaties. Het wordt gebruikt in verschillende toepassingen zoals webapplicaties, desktopapplicaties, wetenschappelijke berekeningen, machine learning, data-analyse en IoT.

  4. Platformoverschrijdend:

    • Het is platformonafhankelijk en kan op veel besturingssystemen worden uitgevoerd, waaronder Windows, macOS en Linux.

  5. Open Source en Gemeenschap:

    • Python is een open-source project dat wordt ondersteund door een actieve gemeenschap. Hierdoor worden regelmatige updates, bibliotheekontwikkeling en ondersteuning geboden.

  6. Dynamisch Typen en Automatisch Geheugenbeheer:

    • Dynamisch typen maakt het declareren van variabeltypen overbodig, wat snellere ontwikkeling mogelijk maakt.
    • Garbage collection voert automatisch geheugenbeheer uit, waardoor geheugenbeheer eenvoudig wordt.

Met deze functies wordt Python op grote schaal gebruikt in verschillende vakgebieden, waaronder onderwijs, industrie en wetenschap.

Escape-tekens in Python

In Python worden escape-tekens gebruikt om specifieke besturingstekens of tekens met een speciale betekenis in strings op te nemen. Escape-tekens zijn speciale symbolen die worden gebruikt om specifieke betekenissen toe te voegen aan gewone strings. Laten we eens dieper ingaan op escape-tekens in Python.

Basisprincipes van escape-tekens

In Python worden escape-tekens gedefinieerd met behulp van een schuine streep (\). Escape-tekens geven specifiek gedrag aan binnen een gewone string. Zo staat \n voor een nieuwe regel, en \t staat voor een tabruimte.

U kunt een string met escape-tekens als volgt definiëren:.

1# Example of escape characters
2print("Hello\nWorld")  # A newline is inserted after "Hello"
3
4# Output:
5# Hello
6# World

Lijst met belangrijkste escape-tekens

De belangrijkste escape-tekens die in Python worden gebruikt, zijn als volgt:.

  • \\: Stelt een backslash zelf voor.
  • \': Voegt een enkele aanhalingsteken toe aan een string.
  • \": Voegt een dubbele aanhalingsteken toe aan een string.
  • \n: Nieuwe regel
  • \t: Tab
  • \r: Wagenretour
  • \b: Backspace
  • \f: Form feed
  • \a: Waarschuwingsgeluid (bel)
  • \v: Verticale tab
  • \N{name}: Teken op naam in de Unicode-database
  • \uXXXX: 16-bits Unicode-teken (gespecificeerd met 4 hexadecimale cijfers)
  • \UXXXXXXXX: 32-bits Unicode-teken (gespecificeerd met 8 hexadecimale cijfers)
  • \xXX: Teken gespecificeerd in hexadecimaal

Voorbeelden van Vaak Gebruikte Escape-tekens

Hier zijn enkele specifieke voorbeelden van hoe u escape-tekens kunt gebruiken.

Dubbele Aanhalingstekens en Enkele Aanhalingstekens

Om dubbele of enkele aanhalingstekens in een string op te nemen, gebruikt u escape-tekens.

 1# String containing double quotes
 2quote = "He said, \"Python is amazing!\""
 3print(quote)
 4
 5# String containing single quotes
 6single_quote = 'It\'s a beautiful day!'
 7print(single_quote)
 8
 9# Output:
10# He said, "Python is amazing!"
11# It's a beautiful day!

Nieuwe Regels en Tabs

Nieuwe regels en tabs worden vaak gebruikt om tekst op te maken.

 1# Example using newline
 2multiline_text = "First line\nSecond line"
 3print(multiline_text)
 4
 5# Example using tab
 6tabbed_text = "Column1\tColumn2\tColumn3"
 7print(tabbed_text)
 8
 9# Output:
10# First line
11# Second line
12# Column1	Column2	Column3

Unicode Escape-tekens

In Python worden Unicode-tekens weergegeven met \u of \U. Dit is vooral nuttig bij het verwerken van niet-Engelse tekens.

1# Example of Unicode escape
2japanese_text = "\u3053\u3093\u306B\u3061\u306F"  # Hello in Japanese
3print(japanese_text)
4# Output:
5# こんにちは(Hello in Japanese)

Voorzichtigheid bij Speciale Escape-tekens

Er zijn enkele voorzorgsmaatregelen om in gedachten te houden bij het gebruik van escape-tekens.

  1. Ruwe string: Als je een string met backslashes letterlijk wilt weergeven, zet dan een r voor de string.
1raw_string = r"C:\Users\name\Documents"
2print(raw_string)
3# Output:
4# C:\Users\name\Documents

In ruwe strings wordt de backslash niet geïnterpreteerd als een escape-teken en wordt deze als zodanig weergegeven.

  1. Gebruik van Unicode: Zorg ervoor dat de opgegeven hexadecimale codes correct zijn bij het gebruik van Unicode-escape-tekens. Onjuiste specificaties zullen resulteren in een onjuiste weergave van tekens.

Backslashes Escapen

Om een backslash zelf in een string op te nemen, gebruikt u dubbele backslashes.

1# Example containing backslash
2path = "C:\\Program Files\\Python"
3print(path)
4# Output:
5# C:\Program Files\Python

Geavanceerd Voorbeeld: Complexe Stringopmaak

Het is ook mogelijk om escape-tekens te combineren om complexe strings op te maken.

 1# Example of formatting a message
 2message = "Dear User,\n\n\tThank you for your inquiry.\n\tWe will get back to you shortly.\n\nBest Regards,\nCustomer Support"
 3print(message)
 4# Output:
 5# Dear User,
 6#
 7#     Thank you for your inquiry.
 8#     We will get back to you shortly.
 9#
10#     Best Regards,
11#     Customer Support

Samenvatting

De escape-tekens van Python zijn een krachtig hulpmiddel om specifieke controletekens of speciale tekens in strings op te nemen. Begrijpen hoe u ze gebruikt en ze op de juiste manier toepast waar nodig, maakt flexibelere stringverwerking mogelijk.

Python Versies

Laten we de belangrijkste Python-releases en hun kenmerken kort bekijken.

  1. Python 1.0 (1994)
1# Sample code that works in Python 1.0
2def greet(name):
3    print "Hello, " + name  # print was a statement
4
5greet("World")

De eerste officiële release. De basis-syntaxis en standaardbibliotheek van Python werden vastgesteld.

  1. Python 2.0 (2000)
1# Sample code that works in Python 2.0
2
3# List comprehension
4squares = [x * x for x in range(5)]
5print squares
6
7# Unicode string (u"...")
8greet = u"Hello"
9print greet

Belangrijke functies, zoals lijst-comprehensies, volledige garbage collection en het begin van Unicode-ondersteuning, werden toegevoegd. Python 2 werd lange tijd gebruikt, maar bereikte het einde van zijn ondersteuning in 2020.

  1. Python 3.0 (2008)
1# Sample code that works in Python 3.0
2
3# print is now a function
4print("Hello, world!")
5
6# Unicode text is handled natively
7message = "Hello"
8print(message)

Een grote update zonder achterwaartse compatibiliteit. print werd een functie, Unicode werd het standaard string-type, en gehele getallen werden verenigd, wat de consistentie en bruikbaarheid van Python aanzienlijk verbeterde. Python 3 is de huidige hoofdversie.

  1. Python 3.5 (2015)
1# Sample code that works in Python 3.5
2import asyncio
3
4async def say_hello():
5    await asyncio.sleep(1)
6    print("Hello, async world!")
7
8asyncio.run(say_hello())

De syntaxis async/await werd geïntroduceerd, waardoor het eenvoudiger werd om asynchrone programmering te schrijven.

  1. Python 3.6 (2016)
1# Sample code that works in Python 3.6
2
3name = "Alice"
4age = 30
5print(f"{name} is {age} years old.")  # f-string makes formatting simple

Geformatteerde stringliterals (f-strings) werden toegevoegd, wat het formatteren van strings handiger maakte. Bovendien werden typehints uitgebreid.

  1. Python 3.7 (2018)
 1# Sample code that works in Python 3.7
 2
 3from dataclasses import dataclass
 4
 5@dataclass
 6class Person:
 7    name: str
 8    age: int
 9
10p = Person("Bob", 25)
11print(p)

Dataklassen werden geïntroduceerd, waardoor het eenvoudiger werd om struct-achtige klassen te definiëren. Ondersteuning voor async/await werd ook verbeterd.

  1. Python 3.8 (2019)
1# Sample code that works in Python 3.8
2
3# Assignment inside an expression
4if (n := len("hello")) > 3:
5    print(f"Length is {n}")

De Walrus-operator (:=) werd toegevoegd, waardoor toewijzingsexpressies mogelijk werden. Alleen-positieparameters werden ook geïntroduceerd, wat de flexibiliteit in functieargumenten verbeterde.

  1. Python 3.9 (2020)
1# Sample code that works in Python 3.9
2
3a = {"x": 1}
4b = {"y": 2}
5c = a | b  # merge two dicts
6print(c)   # {'x': 1, 'y': 2}

Verbeteringen aan typehints en de toevoeging van een samenvoegoperator (|) voor lijsten en woordenboeken werden doorgevoerd. De standaardbibliotheek werd ook opnieuw georganiseerd.

  1. Python 3.10 (2021)
 1# Sample code that works in Python 3.10
 2
 3def handle(value):
 4    match value:
 5        case 1:
 6            return "One"
 7        case 2:
 8            return "Two"
 9        case _:
10            return "Other"
11
12print(handle(2))

Pattern matching werd toegevoegd, waardoor krachtigere voorwaardelijke statements mogelijk werden. Foutmeldingen werden verbeterd en het typesysteem werd verder versterkt.

  1. Python 3.11 (2022)
1# Sample code that works in Python 3.11
2
3# Improved performance (up to 25% faster in general)
4# More informative error messages
5try:
6    eval("1/0")
7except ZeroDivisionError as e:
8    print(f"Caught an error: {e}")
**Aanzienlijke prestatieverbeteringen** werden doorgevoerd, resulterend in snellere uitvoering in vergelijking met eerdere versies. Bovendien werden verbeteringen aangebracht aan uitzonderingsafhandeling en typecontrole.
  1. Python 3.12 (2023)
 1# Sample code that works in Python 3.12
 2
 3# Automatically shows exception chains with detailed traceback
 4def f():
 5    raise ValueError("Something went wrong")
 6
 7def g():
 8    try:
 9        f()
10    except Exception:
11        raise RuntimeError("Higher level error")  # Automatically chained
12
13try:
14    g()
15except Exception as e:
16    import traceback
17    traceback.print_exception(type(e), e, e.__traceback__)
Foutmeldingen zijn verder verbeterd en de prestaties zijn verhoogd. Bovendien wordt uitzondering-chaining automatisch weergegeven, wat meer gedetailleerd debuggen mogelijk maakt. Nieuwe syntaxisfuncties en verbeteringen aan de standaardbibliotheek zijn ook toegevoegd, wat de productiviteit van ontwikkelaars verhoogt.
    • Python 3,13 (2024) *
 1# Sample code that works in Python 3.13
 2
 3# Using the new 'except*' syntax for handling multiple exceptions in parallel
 4import asyncio
 5
 6async def raise_errors():
 7    raise ExceptionGroup("Multiple errors", [
 8        ValueError("Invalid value"),
 9        TypeError("Wrong type"),
10    ])
11
12async def main():
13    try:
14        await raise_errors()
15    except* ValueError as e:
16        print("Caught ValueError(s):", e.exceptions)
17    except* TypeError as e:
18        print("Caught TypeError(s):", e.exceptions)
19
20asyncio.run(main())

In Python 3.13 zijn de syntaxis "ExceptionGroup" en "met uitzondering van*" verder verfijnd, waardoor meerdere uitzonderingen bij asynchrone verwerking parallel kunnen worden opgevangen. Dit maakt debuggen en foutafhandeling in toepassingen die parallelle verwerking gebruiken of intuïtiever en krachtiger. Bovendien hebben verbeteringen in het type hints en updates van de standaardbibliotheek de onderhoudbaarheid en expressiviteit verbeterd.

Python versie 3 is voortdurend in ontwikkeling, met de nieuwste versies met prestaties verbeteringen, verbeteringen aan het type systeem, en nieuwe functies.

Je kunt het bovenstaande artikel volgen met Visual Studio Code op ons YouTube-kanaal. Bekijk ook het YouTube-kanaal.

YouTube Video