Zertifizierte Programmiererin Anja Vogel

Vorbereitung auf das PCAP Zertifikat

Im Unterschied zu PHP, C++ und vielen anderen Programmiersprachen werden keine Klammern, sondern Doppelpunkte und Einrückungen verwendet. Falsche Einrückung führt z.B. zu IndentationError: unexpected indent. Ein Semikolon am Zeilende führt nicht zu einem Fehler, wird aber in der Regel weg gelassen. Übliche Dateiendung: .py.

In Python ist alles ein Objekt und erbt von object. Objekte sind Instanzen von Klassen, die Attribute und Methoden haben, auf welche mit der Punktnotation zugegriffen werden kann.

Die Standard ASCII Zeichenkodierung definiert nur 128 Zeichen (Zahlen, Groß-, Kleinbuchstaben und drum herum Zeichen)! Pro Zeichen werden 8 Bit verwendet. UNICODE ist in der Lage, praktisch alle von Menschen verwendete Alphabete zu kodieren. UTF ist die Abkürzung für Unicode Transformation Format.

Main

if __name__ == "__main__":
    main()

Besonderheiten bei der Zuordnung

Datentypen sind hier gut beschrieben. Wichtig finde ich, dass es kein Null gibt, sondern None, True und False werden Großgeschrieben.

x, X = "x", "X"
print(x) # x
print(X) # X

x = y = z = 1
print(f"{x} {y} {z}") # 1 1 1

colors = ["red", "black"]
c1, c2 = colors
print(c1) # red
print(c2) # black

Casting

bool(...)  # class 'bool'
int(...)   # <class 'int'>
float(...) # <class 'float'>
str(...)   # <class 'str'>

list(...)  # <class 'list'> (s.u. Map)
tuple(...) # <class 'tuple'>
set(...)   # <class 'set'>

bytearray(...)       # <class 'bytearray'>
print(bytearray(2))  # bytearray(b'\x00\x00')

print(type(...))

Formatierung

print(int("123")) # 123
int("abc")  # ValueError
int('12.0') # ValueError

x = 1.235
print(f"Wert: {x:.2f}")              # Wert: 1.24
print(f"Wert: {round(x, 2)}")        # Wert: 1.24

y = "1.235"
print(f"Wert: {float(y):.2f}")       # Wert: 1.24
print(f"Wert: {round(float(y), 2)}") # Wert: 1.24

print(float("1.235")) # 1.235
print(float("1,235")) # ValueError: could not convert string to float: '1,235'

print("123".zfill(5)) # 00123 <= zeros on the left

Zeichen / ASCII code

Ein codepoint ist eine Zahl, die einem Zeichen zugeordnet wurde:

print(ord('0')) # 48
print(ord('A')) # 65
print(ord('a')) # 97

print(chr(48)) # 0
print(chr(65)) # A
print(chr(97)) # a

Strings

print('10:00'.isdigit()) # False
print('2025'.isdigit()) # True

print('UTF8'.isalpha()) # False
print('Yes'.isalpha()) # True

print(''.isspace()) # False
print(' '.isspace()) # True
print('\n'.isspace()) # True

print("Suche".endswith("e")) # True
print("Suche".endswith("E")) # False

print("eA coder".capitalize())  # Ea coder 
print(".EA coder.".strip("."))  # EA coder
print(".EA coder.".lstrip(".")) # EA coder. 
print(".EA coder.".rstrip(".")) # .EA coder

Vergleich

Reihenfolge: Zahlen, Groß-, Kleinbuchstaben

print('Toast' < 'test')     # True: T < t
print('1000' < 'TEST')      # True: 1 < T
print('1000' < '200')       # True: 1 < 2
print('alpha' < 'alphabet') # True: '' < b (alpha ist gleich)

Wiederholung

text = 'Hallo '
print(text + text + text) # Hallo Hallo Hallo
print(text * 3)           # Hallo Hallo Hallo
text *= 3
print(text)               # Hallo Hallo Hallo

Suchen, Trennen und Manipulieren

Suchen und Ersetzen:

print("Suche".find("S"))         #  0
print("Suche".find("s"))         # -1

print("Suche".index("S"))        # 0
print("Suche".index("s"))        # ValueError

print('Suche'.replace('u', 'a')) # Sache

if "lerne" in "Ich lerne Python":
    print("Ja")                  # Ja

print("Suche für mich ein Wort".partition("Suche")) 
# ('', 'Suche', ' für mich ein Wort')

print("Suche für mich ein Wort".partition("mich")) 
# ('Suche für ', 'mich', ' ein Wort')

print("Suche für mich ein Wort".partition("Wort"))
# ('Suche für mich ein ', 'Wort', '')

Trennen und Verbinden:

print(".Suche..".split("."))    # ['', 'Suche', '', '']
print(".Suche..".strip("."))    # Suche
print(".".join("Suche"))        # S.u.c.h.e

text = "Ich lerne Python"
print(text.split())             # ['Ich', 'lerne', 'Python']  <= in Worte trennen
print(text.split()[::-1])       # ['Python', 'lerne', 'Ich']  <= reverse!
print(text.split()[::-1][0])    # Python                      <= erste Element

Teilstring (substring):

print('Python'[:2])     # Py     <= bis Position 2
print('Python'[1:2])    # y      <= Position 1
print('Python'[1:])     # ython  <= ab Position 1

Sortierung

print(sorted('Python')) 
# ['P', 'h', 'n', 'o', 't', 'y']

print(sorted('Python', reverse=True)) 
# ['y', 't', 'o', 'n', 'h', 'P']

Arrays

Arrays können in Python folgende Datentypen sein: List, Tuple, Set oder Dictionary.

List: [...]

ist geordnet, änderbar und erlaubt doppelte Einträge:

l = [3, "Hallo", True, 3]
print(l) 
# [3, 'Hallo', True, 3]

Tupel: (...)

ist geordnet und unveränderlich und erlaubt doppelte Einträge:

t = ("Stift", "Papier", "Schere", "Stift")
print(t) 
# ('Stift', 'Papier', 'Schere', 'Stift')

Set: {...}

ist ungeordnet, unveränderlich, unindiziert, hat keine doppelten Einträge und erlaubt Hinzufügen und Entfernen:

s = {True, 1, 0, False, None}
print(s) 
# {0, True, None}

Dictionary {... : ...}

ist änderbar und hat keine doppelten Einträge:

d = {
  "brand": "Mini",
  "brand": "Porsche",
  "year": 2000,
  "colors": ["Silber", "Schwarz"]
}
print(d) 
# {'brand': 'Porsche', 'year': 2000, 'colors': ['Silber', 'Schwarz']}

Werte aus Listen erhalten (unpacking):

colors = ['rot', 'gelb', 'orange'] 
color1, color2, color3 = colors

Liste filtern:

Als "function" wird hier eine anonyme Funktion s.u. übergeben und als "iterable" die zu filternde Liste:

numbers = [1, 2, 3]
result = list(filter(lambda x: x % 2 == 1, numbers))
print(result) # [1, 3]

Die Syntax ist: filter(function, iterable). Nach Ausschluss der geraden Zahlen wird das Filter-Objekt, ein Iterator, in eine Liste gecastet, um die Ergebnisse zu sehen: list(...).

Listen erzeugen ähnlich der Mengenschreibweise (List Comprehensions):

Quadrate aller geraden Zahlen kleiner 10 (0, 2, 4, 6, 8):

sq = [x*x for x in range(10) if x%2==0]
print(sq)     # [0, 4, 16, 36, 68]

Liste abarbeiten - Map:

Die Funktion map() führt eine bestimmte Funktion für jedes Element in einer Liste/Tupel/Set/Dictionary (iterable) aus. Das Element wird als Parameter an die Funktion gesendet. Beim Dictionary werden allerdings die Keys verwendet!

numbers = [2, 4, 6]                    # (2, 4, 6) {2, 4, 6}
square = lambda x: x ** 2              # x hoch 2
result = map(square, numbers)
print(list(result))                    # [4, 16, 36]

Die Syntax ist: map(function, iterable)

numbers = {0:2, 1:4, 2:6}              # Dictionary
square = lambda x: x ** 2              # x hoch 2
result = map(square, numbers.values()) # sonst [0, 1, 4]
print(list(result))                    # [4, 16, 36]

Schleifen

Einfache Schleifen werden mit range() erzeugt:

for i in range(3): #start=0,stop=3,step=1
    print(i) # 0,1,2

for i in range(1, 3): #start=1,stop=3,step=1
    print(i) # 1,2

for i in range(1, 3, 2): #start=1,stop=3,step=2
    print(i) # 1

print(range(3))      # range(0, 3)
print(len(range(3))) # 3

Schleifen mit Listen:

for x in [5, 2, 9]:
    print(x) # 5,2,9
            
numbers = ["one", "two", "three"]
for s in numbers:
    print(s) # one, two, three  
    
i = 0
while i < len(numbers):
    print(numbers[i]) # one, two, three 
    i += 1 

[print(c) for c in numbers] # one, two, three   
print(len(numbers))         # 3

Schleifen mit Dictionaries:

numbers = {1: "one", 2: "two", 3: "three"}
    
for s in numbers:
    print(s) # 1,2,3 = keys!
    print(numbers[s]) # values!
 
for s in numbers.values():
    print(s) # one, two, three
    
for key, value in numbers.items():
  pass # Schleifen dürfen nicht leer sein   


print(numbers)          # {1: 'one', 2: 'two', 3: 'three'}
print(numbers.keys())   # dict_keys([1, 2, 3])
print(numbers.values()) # dict_values(['one', 'two', 'three'])
print(len(numbers))     # 3

Schleifen mit Strings:

for x in "banana":
    print(x) # einzelne Buchstaben!

Funktionen

Funktionen werden mit def definiert:

def add(a, b=0):
    """Addition: a + b"""        # optionale Beschreibung, was die Funktion tut
    return a + b

Funktionen mit beliebig vielen Argumenten:

def multi(*values):
    print(values)
    
multi("eins", "zwei", 3, True)   # ('eins', 'zwei', 3, True)

Innere Funktion:

def tag(tg):
    tg2 = tg
    tg2 = tg[0] + '/' + tg[1:]
 
    def inner(str):             # Definition
        return tg + str + tg2
        
    return inner                # Rückgabe
 
b_tag = tag('<b>')   # b_tag ist die Funktion "inner"

print(b_tag('Text')) # <b>Text</b>

def outer():
    x = 1
    
    def inner():
        nonlocal x           # nicht lokale Variable x
        x += 1
        print(x, end = " ")  # Leerzeichen statt Zeilenende
        
    inner()
    inner()
 
outer() # 2 3

Anonyme Funktion:

Die Syntax ist: lambda arguments : expression

a = lambda x, y: x+y
print(a(5, 6))
# 11

OOP Objektorientierung

Unter Kapselung versteht man die Praxis, die internen Details eines Objekts zu verbergen und eine öffentliche Schnittstelle für die Interaktion mit dem Objekt bereitzustellen. Dies wird in Python mit zwei Unterstrichen __ vor einem Variablennamen erreicht.

Klassen Definition:

class Person:
    nr = 0                    # Klassenvariable

    def __init__(self, name): # Konstruktor, wird automatisch aufgerufen
        self.name = name      # Objektvariable
        Person.nr += 1

    def greet(self):
        print(f"Hi, ich bin {self.name}")
        
p1 = Person("Anna")    
p1.greet() # Hi, ich bin Anna

p2 = Person("Paula")    
p2.greet() # Hi, ich bin Paula

print(Person.nr, p1.nr, p1.name , p2.nr, p2.name) # 2 2 Anna 2 Paula

Vererbung:

Die neue abgeleitete Klasse wird als Unterklasse bezeichnet und die vorhandene Basisklasse wird als Oberklasse bezeichnet. Die Unterklasse erbt alle Eigenschaften und Methoden der Oberklasse und kann darüber hinaus eigene Eigenschaften und Methoden hinzufügen.

class Animal:
    pass
 
class Cat(Animal):
    pass
 
Garfield = Cat()

print(isinstance(Garfield, Animal)) # True
print(isinstance(Garfield, object)) # True

class Person:
    def __init__(self, name):               
        self.name = name                    # public ohne _

    def greet(self):
        print(f"Hi, ich bin {self.name}")

class Student(Person):
    def __init__(self, name, semester):         
        self._semester = semester           # protected durch _
        self.__semester = semester          # private durch __
        Person.__init__(self, name)
        
    def greet(self):
        print(f"Hi, ich bin {self.name} im {self.__semester} Semester.")
      
p = Student("Tanja", "dritten") 
   
p.greet()                       # Hi, ich bin Tanja im dritten Semester.

print(hasattr(p, '_semester'))  # True
print(p._semester)              # dritten

print(hasattr(p, '__semester')) # False
print(p.__semester)             # AttributeError!

Mehrfachvererbung:

class Person:
    def __init__(self, name):
        self.name = name

    def greet(self):
        print(f"Hi, ich bin {self.name}!")

class Studienfach:
    def __init__(self, name):
        self.name = name 

class Student(Person, Studienfach):
    def __init__(self, name, fach):
        Person.__init__(self, name)
        Studienfach.__init__(self, fach) # überschreibt name!

p = Student("Tom", "Medizin")    

p.greet()                         # Hi, ich bin Medizin!
print(isinstance(p, Student))     # True
print(isinstance(p, Studienfach)) # True
print(isinstance(p, Person))      # True
print(isinstance(p, Mensch))      # NameError: name 'Mensch' is not defined

Iterierbare Objekte (iterable):

class A():
    def __init__(self):
        self.s = 'abc'
        self.i = 0
 
    def __iter__(self):
        return self
 
    def __next__(self):
        if self.i == len(self.s):
            raise StopIteration
        
        v = self.s[self.i]
        self.i += 1
        return v
 
for a in A():
    print(a, end=" ")  # a b c

Exceptions

Der erste passende except Zweig und finally wird immer ausgeführt.

try:
    int("Test")
except ValueError as e:
    print("Fehler:", e)
except:
    print("Default exception!")
finally:
    print("Fertig")
    
# Fehler: invalid literal for int() with base 10: 'Test'
# Fertig

Eingaben bzw. ZeroDivisionError:

TypeError wird hier nicht geworfen, entwerder ZeroDivisionError bei einer 0 oder ValueError, wenn es keine ganze Zahl (ohne Punkt und Komma) ist.

try:
    num = int(input("Number:"))
    print(10/num)
except (ValueError, ZeroDivisionError):
    print("Fehler: bitte nur Zahlen über 0 eingeben!")

Exception mit Argumenten:

try:
    raise Exception(1,2,3,4,5,"error")
except Exception as e:
    print(e.args)
    
# (1, 2, 3, 4, 5, 'error')

Custom Exception:

class MyException(Exception):
    def __init__(self, msg):
        self.msg = msg

raise MyException("Bädö")    

# __main__.MyException: Bädö

BaseException:

Exeption fängt die meisten Fehler bereits ab, aber BaseException fängt zusätzlich SystemExit, KeyboardInterrupt und GeneratorExit ab. Durch KeyboardInterrupt wird auch das gewollte Beenden mit ^C abgefangen, wodurch das Programm hängen bleiben kann.

try:
    raise Exception
except BaseException:
    print("Base")
except Exception:
    print("Ex")

# Base

Assertion

Fehlerbehandlungen (Exeptions) sollten für Fehlerzustände geschrieben werden, welche man erwartet; Zusicherungen (Assertion) für Fehlerzustände, die niemals auftreten sollten.

try:
    assert 2 + 2 == 5, "Logischer Fehler"
except AssertionError as a:
    print(a) # Logischer Fehler

Dateien

Text lesen:

with open("file.txt") as f:       
    data = f.read()
    f.close()
print(data)

Das zweite Argument der Funktion open() beschreibt den Öffnungsmodus und ist standardmäßig auf "r" (Lesemodus) eingestellt. Ist die Datei nicht vorhanden, führt dies zum FileNotFoundError.

Wenn das zweite Argument von open() im Schreibmodus "w" und der Aufruf erfolgreich ist, geht der Inhalt der Datei verloren!

Mögliche Datei Modi: 'r', 'w', 'a', 'b', '+'. Dateien sollte immer geschlossen werden.

Text schreiben:

with open('file.txt', 'w') as f:
    f.write('Peace!')
 
with open('file.txt', 'r') as f:
    data = f.read()
 
with open('file.txt', 'wb') as f:
    f.write(data.encode())
 
with open('file.txt', 'rb') as f:
    data = f.read()
 
print(data) # b'Peace!'

Bilder einlesen bzw. Binary in bytearray:

try:
    stream = open("/pfad/Bild.jpg", "rb")
    image = bytearray(stream.read())
    stream.close()
except IOError:
    print("Oh no!")
else:
    print("OK!")

Packages

Pip ist das Paketinstallationsprogramm für Python. Mit pip (pip3) können Pakete aus dem Python Package Index (PyPI) und anderen Indizes installiert werden. Ab Python Version 3.4 ist PIP ist enthalten.

pip --version
pip install ...
pip list         # Installierte Pakete inkl. Version
pip uninstall ...
pip help

Mathematik Funktionen:

import math

x = -1.5
print(abs(x))        # 1.5 ohne math!
print(math.floor(x)) # -2
print(math.ceil(x))  # -1
print(math.trunc(x)) # -1
print(math.pi)       # 3.141592653589793
print(math.sin(math.radians(90))) # 1.0 = sinus von 90°

from math import e, exp, log

print(e)           # 2.718... 
print(pow(e, 1))   # 2.718... 
print(exp(log(e))) # 2.718...
print(pow(3, 3))     # 27
print(exp(3*log(3))) # 27
print(log(e, e))   # 1.0
print(exp(0))      # 1.0

Zufall:

import random

Obst = ['Äpfel', 'Birnen', 'Bananen', 'Kiwi']
random.shuffle(Obst)

print(Obst) # ['Birnen', 'Bananen', 'Kiwi', 'Äpfel']

from random import randrange, randint

print(randrange(0,1)) # 0 (0 bis 1 ohne 1!)
print(randint(0,1))   # 0 oder 1 - kein dritter Parameter!

Kalender:

import calendar

print(calendar.isleap(2026)) # False = nicht teilbar durch 400
print(calendar.isleap(2000)) # True  = teilbar durch 400

c = calendar.Calendar()
for weekday in c.iterweekdays():
    print(weekday, end = "|") # 0|1|2|3|4|5|6|

Betriebsystem:

import platform

print(platform.system())    # Linux
print(platform.version())   # ... Ubuntu ...
print(platform.processor()) # x86_64
print(platform.machine())   # x86_64

Externe Links

Python Referenz
PyPI (Python Packages)
PCAP Prüfung
ChatGPT
HTML