Level 1

In diesem Level werden wir unsere ersten Zeilen Python kennenlernen. Wir werden lernen, was ein integer, ein float, ein string ist, wie wir mit Python Text ausgeben und einlesen können, erste Berechnungen anstellen können, die Ergebnisse von Berechnungen in Variablen speichern und wie wir unseren Code kommentieren können.

Ausgabe


In [28]:
# Für die Standardausgabe benutzen wir die print() Funktion
print("Hallo Welt!")


Hallo Welt!

In [29]:
# Wir können mit Kommata getrennt auch mehrere Werte ausgeben:
print("foo", "bar")


foo bar

In [30]:
# Mit der help() Funktionen zeigen wir uns
# die Hilfe der print() Funktion an:
help(print)


Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.


In [31]:
# Ausgabe mit Seperatoren:
print("foo", "bar", sep="#")


foo#bar

In [32]:
# Ausgabe mit end-string:
print("foo", "bar", end="##\n")
print("test")


foo bar##
test

Einfache Operationen

Im Python Interpreter werden Kommandos zeilenweise eingegeben und vom Interpreter zeilenweise interpretiert und ausgeführt. Der Interpreter gibt dabei immer das Ergebnis (genauer den Rückgabewert des Ausdrucks) zurück. Das bedeutet, wir können den Interpreter benutzen um erste Berechnungen durchzuführen und die mathematischen Operatoren kennenlernen.


In [33]:
4 + 34


Out[33]:
38

Genauer betrachtet besteht die Zeile 4 + 34 aus zwei Literalen (4 und 34) und einem Operator (+), die kombiniert den Ausdruck ergeben. Ein Literal ist die direkte Darstellung eines Wertes. Operatoren verknüpfen Werte und geben Werte zurück. Bei den Werten im obigen Beispiel handelt es sich um Werte vom Typ integer. Diese stellen ganze Zahlen dar.


In [34]:
print(3 + 4)  # Addition
print(4 - 6)  # Subtraktion
print(3 * 7)  # Multiplikation
print(3 // 2) # Ganzzahlige Division
print(3 % 2)  # Division mit Rest
print(3 / 2)  # Division
print(2 ** 4) # Potenz, alternativ pow(2, 4)
print(4 << 1) # Bitshift nach links, alternativ 4 * (2 ** 1)
print(4 >> 1) # Bitshift nach rechts, alternativ 4 // (2 ** 1)
print(5 ^ 1)  # bitweises XOR


7
-2
21
1
1
1.5
16
8
2
4

Oben sind die wichtigsten Operatoren für Werte des Integer Typs aufgelistet. Bemerkenswert ist, dass es drei Arten der Divison gibt: die ganzzahlige Division, die (ganzzahlige) Division mit Rest und die "normale" Division. Die ganzzahlige Division liefert ein abgerundetes Ergebnis als Integer, die Division mit Rest liefert den Rest der ganzzahligen Divison und die "normale" Division liefert einen Wert des Typen float.


In [35]:
print(4.5 + 3.8)


8.3

Ein float repräsentiert Fließkommazahlen. Dieselben Operatoren, die oben auf Integer angewandt wurden, können auch auf floats angewendet werden. Wichtig ist, dass dabei das Ergebnis stets vom Typ float ist.

Zum Umwandeln bieten die Typen Funktionen an, so kann ein Objekt mit der int() Funktion in einen integer und mit derfloat() Funktion in einen float umgewandelt werden. Beim Umwandeln eines integers in einen float gehen allerdings etwaige Nachkommastellen verloren.


In [36]:
print(int(3.5))
print(float(4))


3
4.0

Variablen

Readability counts. - Zen of Python

Variablen werden benutzt, um Werte für die spätere Wiederbenutzung zu speichern. Dabei zeigt die Variable lediglich auf einen Wert. Eine Variable hat dabei keinen festen Typ, nur die Werte


In [37]:
ham = 4
egg = 12
ham_price = 2.99
egg_price = 0.49
print(ham, egg)
print(ham_price, egg_price)
print()
print("ham: ", ham * ham_price)
print("egg: ", egg * egg_price)
summ = ham * ham_price + egg * egg_price
print("sum: ", summ)


4 12
2.99 0.49

ham:  11.96
egg:  5.88
sum:  17.84

Bei der Benennung von Variablen sollte darauf geachtet werden, kurze aber verständliche Variablennamen zu benutzen, da so klar ist wozu die Variable benutzt wird. Auf keinen Fall sollten Variablennamen wie l, O oder I benutzt werden, da diese, je nach Schriftart, wie 0 oder 1 aussehen können.


In [38]:
# den Typen eines Wertes können wir mit type() bestimmt werden:
print(type("a"))
print(type(2))
print(type(4.8))


<class 'str'>
<class 'int'>
<class 'float'>

Python besitzt eine streng dynamische Typisierung, das heißt:

  1. Eine Variable kann auf Werte verschiedenen Typs zeigen.
  2. Jedes Objekt hat einen Typ.

Bei jeder neuen Zuweisung wird der Wert einer Variable überschrieben, dabei kann sich der Typ des Werts ändern.


In [39]:
s = "String"
print(type(s))
s = 4
print(type(s))


<class 'str'>
<class 'int'>

Strings

Ein String ist eine Zeichenkette und wird repräsentiert Text. Ein String kann mit "" oder '' definiert werden.


In [40]:
hallo = 'Hallo Welt!'
text = "Programmieren mit Python."
print(hallo, text, sep="\n")


Hallo Welt!
Programmieren mit Python.

Strings sind allerdings nicht auf eine Zeile begrenzt. Multiline strings werden durch dreifache Anführungszeichen definiert.


In [41]:
multiline = """
Dies ist ein
mehrzeiliger
String
    mit Einrückung.
"""
print(multiline)


Dies ist ein
mehrzeiliger
String
    mit Einrückung.


In [42]:
# Strings können wir miteinander "addieren", man spricht auch von konkatinieren
foo = "foo"
bar = "bar"
foobar = foo + bar
print(foobar)


foobar

In [43]:
# Strings können wir auch "multiplizieren":
print(10*"#" + " foo " + 10*"#")


########## foo ##########

In [44]:
# len() liefert uns die Länge eines Objektes:
text = "Programmieren mit Python."
length = len(text)

print(text)
print(length*"*")
print(length)


Programmieren mit Python.
*************************
25

In [45]:
# mit der str() Funktion lassen sich Objekte in einen String umwandeln:
s = str(12)
print(s)


12

Eingabe

Die input()Funktion wird benutzt um Eingaben über die Standardeingabe zu erhalten. Dabei liefert die input()Funktion immer einen string.


In [46]:
eingabe = input("Bitte etwas eingeben: ")
print(eingabe)
print(type(eingabe))


Bitte etwas eingeben: foo
foo
<class 'str'>

Schlüsselwörter

Einige Begriffe sind integrale Bestandteile von Python und können daher nicht als Variablenname benutzt werden. Diese Schlüsselwörter variieren von Version zu Version. Eine Liste aller Schlüsselwörter können wir uns anzeigen lassen:


In [47]:
import keyword
print(keyword.kwlist)


['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

In [48]:
True = 0  # Anzahl an Versuchen


  File "<ipython-input-48-0cf028c02be4>", line 1
    True = 0  # Anzahl an Versuchen
                                   ^
SyntaxError: can't assign to keyword

Kommentare

If the implementation is hard to explain, it's a bad idea - Zen of Python

Kommentare dienen dazu den Quellcode für sich und andere lesbarer und verständlich zu machen. Kommentare können in Python mittels einer Raute (#) eingefügt werden. Dabei kann eine ganze Zeile zum Kommentar werden, oder ein Kommentar hinter einem Befehl eingefügt werden, dabei sollten wir vor der Raute zwei Leerzeichen Platz lassen.
Dabei sollten wir beachten, dass ein Kommentar nie beschreiben sollte, was der Code macht, sondern warum der Code etwas macht.


In [49]:
# Berechnen der Summe zweier Zahlen
sum1 = 5  # erster Summand
sum2 = 7  # zweiter Summand
print(sum1 + sum2)


12

Zen of Python

Der "Zen of Python" bietet einige Leitlinien, an denen sich Python als Sprache orientiert und an denen wir uns auch beim Programmieren mit Python orientieren können. In bisherigen Abschnitten wurden Teile bereits zitiert, unten sind einmal alle Punkte aufgelistet.


In [1]:
import this


The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

In [ ]: