Tutorial:Programmieren mit Python/Variablen und Ausdrücke: Unterschied zwischen den Versionen

Aus KGS-Wiki
Keine Bearbeitungszusammenfassung
 
(4 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 1: Zeile 1:
{{../Navigation}}
== Variablen ==
== Variablen ==
Eine [[Variable (Informatik)|Variable]] ein Bezeichner, der eine [[Referenz]], also einen Verweis auf eine Stelle im Objektspeicher von [[Python (Programmiersprache)|Python]] enthält. Im Objektspeicher sind [[Objekt (Informatik)|Objekt]]e wie die Zahl 42, der Text “Hallo Welt” oder eine Liste mit den Elementen 1, 2 und 3 abgelegt.
Eine [[Variable (Informatik)|Variable]] ist ein Bezeichner, der eine [[Referenz]], also einen Verweis auf eine Stelle im Objektspeicher von [[Python (Programmiersprache)|Python]] enthält. Im Objektspeicher sind [[Objekt (Informatik)|Objekt]]e wie die Zahl 42, der Text “Hallo Welt” oder eine Liste mit den Elementen 1, 2 und 3 abgelegt.


=== Definition und Zuweisung ===
=== Definition und Zuweisung ===
Zeile 7: Zeile 8:
und kann den Wert dieser Variablen anschließend für weitere Berechnungen verwenden:
und kann den Wert dieser Variablen anschließend für weitere Berechnungen verwenden:
  <syntaxhighlight lang="python">bruttobetrag = nettobetrag * 1.19</syntaxhighlight>
  <syntaxhighlight lang="python">bruttobetrag = nettobetrag * 1.19</syntaxhighlight>
Die Syntax ist hier: ''Bezeichner'' <code>=</code> ''Ausdruck'', wobei der ''Bezeichner'' mit einem Buchstaben beginnen muss (bei Variablen üblicherweise ein Kleinbuchstabe) und hinter dem Gleichheitszeichen jeder beliebige [[Ausdruck]] stehen darf, der ein Ergebnis zurückliefert. Beispiele:
Die Syntax ist hier: ''Bezeichner'' {{Python|=}} ''Ausdruck'', wobei der ''Bezeichner'' mit einem Buchstaben beginnen muss (bei Variablen üblicherweise ein Kleinbuchstabe) und hinter dem Gleichheitszeichen jeder beliebige [[Ausdruck]] stehen darf, der ein Ergebnis zurückliefert. Beispiele:


* <code>adresse = 'Musterstr. 1, 12345 Musterstadt'</code>
* {{Python|adresse {{=}} 'Musterstr. 1, 12345 Musterstadt'}}
* <code>hoechstpunktzahl = 42</code>
* {{Python|hoechstpunktzahl {{=}} 42}}
* <code>c = math.sqrt(a**2 + b**2)</code>
* {{Python|c {{=}} math.sqrt(a**2 + b**2)}}
* <code>name = input('Bitte gib deinen Vornamen an')</code>
* {{Python|name {{=}} input('Bitte gib deinen Vornamen an')}}


Der Bezeichner sollte dabei möglichst aussagekräftig gewählt werden. Generische Variablenbezeichner wie "x" oder "variable" sollten möglichst vermieden werden.
Der Bezeichner sollte dabei möglichst aussagekräftig gewählt werden. Generische Variablenbezeichner wie {{Python|x}} oder {{Python|variable}} sollten möglichst vermieden werden.


Dass Variablen vor der Verwendung nicht definiert werden müssen, birgt das Risiko von [[Laufzeitfehler]]n, wenn man sich vertippt. Betrachten wir die folgenden Codebeispiele:
Dass Variablen vor der Verwendung nicht definiert werden müssen, birgt das Risiko von [[Laufzeitfehler]]n, wenn man sich vertippt. Betrachten wir die folgenden Codebeispiele:
Zeile 33: Zeile 34:
  <pre>Bitte geben Sie Ihre Größe in cm ein! 203
  <pre>Bitte geben Sie Ihre Größe in cm ein! 203
  Sie sind 203 m groß.</pre>
  Sie sind 203 m groß.</pre>
Was ist passiert? Das zweite Programm enthält in Zeile 2 einen Tippfehler: Statt <code>groesse</code> steht dort <code>greosse</code>. Der Python-Interpreter legt darum eine neue Variable namens <code>greosse</code> an und speichert darin den Wert <code>2.03</code>. Der Wert von <code>groesse</code> bleibt unverändert.
Was ist passiert? Das zweite Programm enthält in Zeile 2 einen Tippfehler: Statt {{Python|groesse}} steht dort {{Python|greosse}}. Der Python-Interpreter legt darum eine neue Variable namens {{Python|greosse}} an und speichert darin den Wert {{Python|2.03}}. Der Wert von {{Python|groesse}} bleibt unverändert.


== Datentypen ==
== Datentypen ==
Nicht mit allen Arten von Daten lassen sich die gleichen Operationen durchführen. Betrachten wir als Beispiel den Operator <code>*</code>:
Nicht mit allen Arten von Daten lassen sich die gleichen Operationen durchführen. Betrachten wir als Beispiel den Operator {{Python|*}}:
<pre>>>> 6 * 7
<syntaxhighlight lang="pycon">>>> 6 * 7
42
42
>>> 4 * 3.141592653587
>>> 4 * 3.141592653587
12.566370614348
12.566370614348
>>> 'kartoffel' * 'salat'
>>> 'kartoffel' * 'salat'
Traceback (most recent call last):
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
  File "<pyshell>", line 1, in <module>
TypeError: can't multiply sequence by non-int of type 'str'
TypeError: can't multiply sequence by non-int of type 'str'
>>> 2 * 'moin '
>>> 2 * 'moin '
'moin moin '
'moin moin '
>>> 2.5 * 'moin'
>>> 2.5 * 'moin'
Traceback (most recent call last):
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
  File "<pyshell>", line 1, in <module>
TypeError: can't multiply sequence by non-int of type 'float'
TypeError: can't multiply sequence by non-int of type 'float'
>>> 4 * [1,2,3]
>>> 4 * [1,2,3]
[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]</pre>
[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]</syntaxhighlight>
Mit dem <code>*</code>-Operator können Zahlen multipliziert und Zeichenketten vervielfältigt werden. Hier gibt es Unterschiede bezüglich der Datentypen der ''Operanden'' (d. h. der Werte bzw. Ausdrücke, die links und rechts des Operators stehen).
Mit dem {{Python|*}}-Operator können Zahlen multipliziert und Zeichenketten vervielfältigt werden. Hier gibt es Unterschiede bezüglich der Datentypen der ''Operanden'' (d. h. der Werte bzw. Ausdrücke, die links und rechts des Operators stehen).


Die wichtigsten elementaren [[Datentyp]]en in Python sind:
Die wichtigsten elementaren [[Datentyp]]en in Python sind:
{| class="wikitable"
 
!Typ
{{:Python (Programmiersprache)/Datentypen}}
!Erklärung
 
!Beispiele
Mit der eingebauten [[Unterprogramm#Funktion|Funktion]] {{Python|type}} kann in Python der Datentyp eines Objekts abgefragt werden, z. B.:
|-
<syntaxhighlight lang="pycon">
|<code>int</code>
|für ganze Zahlen (engl. ''integer numbers'')
|<code>0</code>, <code>42</code>, <code>3190701205</code>
|-
|<code>float</code>
|für [[Fließkommazahl|Dezimalzahlen]] (“Kommazahlen”, engl. ''floating-point numbers'')
|<code>0.5</code>, <code>42.0</code>, <code>3.141592</code>
|-
|<code>str</code>
|für beliebige [[String (Datentyp)|Zeichenketten]] (engl. ''strings'')
|<code>'Hello World'</code>, <code>'42'</code>, <code>'<nowiki>https://wiki.kah.gs'</nowiki></code>
|-
|<code>bool</code>
|für [[Wahrheitswert]]e (engl. ''boolean'')<ref>Logische Wahrheitswerte werden nach George Boole, einem Pionier der mathematischen Logik, auch als "boolesche Werte" bezeichnet (im Englischen "boolean").</ref>
|<code>True</code>, <code>False</code>
|}
Mit der eingebauten [[Unterprogramm#Funktion|Funktion]] <code>type</code> kann in Python der Datentyp eines Objekts abgefragt werden, z. B.:
<pre>
>>> groesse = 203
>>> groesse = 203
>>> type(groesse)
>>> type(groesse)
Zeile 85: Zeile 68:
>>> type(name)
>>> type(name)
<class 'str'>
<class 'str'>
</pre>
</syntaxhighlight>
=== Konvertierung von Datentypen ===
== Konvertierung von Datentypen ===
Mit den Funktionen <code>int</code>, <code>float</code>, <code>str</code> und <code>bool</code> können Objekte in andere Datentypen umgewandelt ("konvertiert") werden. Das wird als [[Type Casting]] bezeichnet (auf deutsch "Datentypumwandlung" oder kurz "Konvertierung"). Dabei können Daten verloren gehen, und es sind nicht alle Konvertierungen möglich. Zum Beispiel gehen bei der Konvertierung <code>int(25.95)</code> zwangsläufig die Nachkommastellen verloren, das Ergebnis ist die Ganzzahl <code>25</code>.<ref>Bei der Umwandlung von Dezimalzahlen mit Nachkommastellen in Ganzzahlen mit der Funktion <code>int</code> wird in Python zur Null hin gerundet (bei positiven Zahlen wird also abgerundet, bei negativen aufgerundet).</ref>
Mit den Funktionen {{Python|int}}, {{Python|float}}, {{Python|str}} und {{Python|bool}} können Objekte in andere Datentypen umgewandelt ("konvertiert") werden. Das wird als [[Type Casting]] bezeichnet (auf deutsch "Datentypumwandlung" oder kurz "Konvertierung"). Dabei können Daten verloren gehen, und es sind nicht alle Konvertierungen möglich. Zum Beispiel gehen bei der Konvertierung {{Python|int(25.95)}} zwangsläufig die Nachkommastellen verloren, das Ergebnis ist die Ganzzahl {{Python|25}}.<ref>Bei der Umwandlung von Dezimalzahlen mit Nachkommastellen in Ganzzahlen mit der Funktion {{Python|int}} wird in Python zur Null hin gerundet (bei positiven Zahlen wird also abgerundet, bei negativen aufgerundet).</ref>


Die folgende Tabelle zeigt anhand von Beispielen, welche Konvertierungen zwischen den vier elementaren Datentypen möglich sind und welche Ergebnisse wir erhalten:
Die folgende Tabelle zeigt anhand von Beispielen, welche Konvertierungen zwischen den vier elementaren Datentypen möglich sind und welche Ergebnisse wir erhalten:
{| class="wikitable"
{| class="wikitable"
!Argumentwert
!Argumentwert
!<code>int(x)</code>
!{{Python|int(x)}}
!<code>float(x)</code>
!{{Python|float(x)}}
!<code>str(x)</code>
!{{Python|str(x)}}
!<code>bool(x)</code>
!{{Python|bool(x)}}
|-
|-
|<code>x = 2</code>
|{{Python|x {{=}} 2}}
|<code>2</code>
|{{Python|2}}
|<code>2.0</code>
|{{Python|2.0}}
|<code>'2'</code>
|{{Python|'2'}}
|<code>True</code>
|{{Python|True}}
|-
|-
|<code>x = 2.7818</code>
|{{Python|x {{=}} 2.7818}}
|<code>2</code>
|{{Python|2}}
|<code>2.7818</code>
|{{Python|2.7818}}
|<code>'2.7818'</code>
|{{Python|'2.7818'}}
|<code>True</code>
|{{Python|True}}
|-
|-
|<code>x = 'zwei'</code>
|{{Python|x {{=}} 'zwei'}}
|Fehler
|Fehler
|Fehler
|Fehler
|<code>'zwei'</code>
|{{Python|'zwei'}}
|<code>True</code>
|{{Python|True}}
|-
|-
|<code>x = True</code>
|{{Python|x {{=}} True}}
|<code>1</code>
|{{Python|1}}
|<code>1.0</code>
|{{Python|1.0}}
|<code>'True'</code>
|{{Python|'True'}}
|<code>True</code>
|{{Python|True}}
|}
|}
{{Hinweis|Die Konvertierung von Zahlen oder Strings in Wahrheitswerte mit <code>bool</code> ergibt immer <code>True</code>, außer für die Werte <code>0</code>, <code>0.0</code> und den leeren String <code><nowiki>''</nowiki></code>.}}
{{Hinweis|Die Konvertierung von Zahlen oder Strings in Wahrheitswerte mit {{Python|bool}} ergibt immer {{Python|True}}, außer für die Werte {{Python|0}}, {{Python|0.0}} und den leeren String {{Python|''}}.}}


== Operatoren ==
== Operatoren ==


=== Mathematische Operatoren ===
=== Mathematische Operatoren ===
Mathematische Operatoren werden für Berechnungen mit numerischen Werten (Datentypen <code>int</code> und <code>float</code>) verwendet. Die Operanden (hier <code>x</code> und <code>y</code> genannt) sind numerische Werte oder Ausdrücke, die numerische Werte ergeben. Die Berechnungsergebnisse sind ebenfalls numerische Werte.
Mathematische Operatoren werden für Berechnungen mit numerischen Werten (Datentypen {{Python|int}} und {{Python|float}}) verwendet. Die Operanden (hier {{Python|x}} und {{Python|y}} genannt) sind numerische Werte oder Ausdrücke, die numerische Werte ergeben. Die Berechnungsergebnisse sind ebenfalls numerische Werte.
{| class="wikitable"
{| class="wikitable"
!Operator
!Operator
Zeile 133: Zeile 116:
!in Scratch
!in Scratch
|-
|-
|<code>x + y</code>
|{{Python|x + y}}
|Addition
|Addition
|
|
| <sb>()+()</sb>
| <sb>()+()</sb>
|-
|-
|<code>x - y</code>
|{{Python|x - y}}
|Subtraktion
|Subtraktion
|
|
| <sb>()-()</sb>
| <sb>()-()</sb>
|-
|-
|<code>x * y</code>
|{{Python|x * y}}
|Multiplikation
|Multiplikation
|
|
| <sb>()*()</sb>
| <sb>()*()</sb>
|-
|-
|<code>x / y</code>
|{{Python|x / y}}
|Division
|Division
|Liefert immer einen Wert vom Datentyp <code>float</code> als Ergebnis zurück, auch wenn das Ergebnis ganzzahlig ist.
|Liefert immer einen Wert vom Datentyp {{Python|float}} als Ergebnis zurück, auch wenn das Ergebnis ganzzahlig ist.
Beispiel: <code>4 / 2</code> → <code>2.0</code>
Beispiel: {{Python|4 / 2}} → {{Python|2.0}}
| <sb>()/()</sb>
| <sb>()/()</sb>
|-
|-
|<code>x // y</code>
|{{Python|x // y}}
|Ganzzahlige Division
|Ganzzahlige Division
|Liefert immer einen Wert vom Datentyp <code>int</code> zurück, ggf. wird das Ergebnis also konvertiert.
|Liefert immer einen Wert vom Datentyp {{Python|int}} zurück, ggf. wird das Ergebnis also konvertiert.
Beispiel: <code>x // y</code> ergibt dasselbe wie <code>int(x / y)</code>
Beispiel: {{Python|x // y}} ergibt dasselbe wie {{Python|int(x / y)}}
| <sb>[abrunden v] von (()/())</sb>
| <sb>[abrunden v] von (()/())</sb>
|-
|-
|<code>x % y</code>
|{{Python|x % y}}
|Modulo
|Modulo
|Berechnet den Rest, der bei der ganzzahligen Division von x durch y übrigbleibt.
|Berechnet den Rest, der bei der ganzzahligen Division von x durch y übrigbleibt.
Beispiel: <code>10 % 3</code> → <code>1</code>
Beispiel: {{Python|10 % 3}} → {{Python|1}}
| <sb>() mod ()</sb>
| <sb>() mod ()</sb>
|-
|-
|<code>x ** y</code>
|{{Python|x ** y}}
|Potenz
|Potenz
|Berechnet <math>x^y</math> (“x hoch y”), also die y-fache Multiplikation von x.
|Berechnet <math>x^y</math> (<q>x hoch y</q>), also die y-fache Multiplikation von x.
|siehe unten<ref>Es gibt für die Potenz mit beliebiger Basis keinen Block in Scratch, aber mit Hilfe der Exponentialfunktion und des natürlichen Logarithmus lässt sich die Potenz folgendermaßen umformen: <math>x^y=\mathrm{e}^{y \cdot\ln(x)}</math> und in Scratch umsetzen:  
|siehe unten<ref>Es gibt für die Potenz mit beliebiger Basis keinen Block in Scratch, aber mit Hilfe der Exponentialfunktion und des natürlichen Logarithmus lässt sich die Potenz folgendermaßen umformen: <math>x^y=\mathrm{e}^{y \cdot\ln(x)}</math> und in Scratch umsetzen:  
  <sb>[e^ v] von ((y) * ([ln v] von (x))</sb></ref>
  <sb>[e^ v] von ((y) * ([ln v] von (x))</sb></ref>
Zeile 174: Zeile 157:


=== Vergleichsoperatoren ===
=== Vergleichsoperatoren ===
Mit Vergleichsoperatoren können zwei Werte oder die Ergebnisse zweier Ausdrücke verglichen werden. Das Ergebnis ist ein Wahrheitswert <code>True</code> oder <code>False</code> (Ausdrücke mit einem Vergleichsoperatoren sind also ''logische Ausdrücke'').
Mit Vergleichsoperatoren können zwei Werte oder die Ergebnisse zweier Ausdrücke verglichen werden. Das Ergebnis ist ein Wahrheitswert {{Python|True}} oder {{Python|False}} (Ausdrücke mit einem Vergleichsoperatoren sind also ''logische Ausdrücke'').


Die Operanden können dabei verschiedene Datentypen haben, so lassen sich numerische Werte, Zeichenketten und auch andere Objekte miteinander vergleichen. In den folgenden Beispielen stehen <code>x</code> und <code>y</code> also für Werte beliebiger Datentypen (z. B. <code>int</code>, <code>float</code> oder <code>str</code>).
Die Operanden können dabei verschiedene Datentypen haben, so lassen sich numerische Werte, Zeichenketten und auch andere Objekte miteinander vergleichen. In den folgenden Beispielen stehen {{Python|x}} und {{Python|y}} also für Werte beliebiger Datentypen (z. B. {{Python|int}}, {{Python|float}} oder {{Python|str}}).
{| class="wikitable"
{| class="wikitable"
!Operator
!Operator
Zeile 183: Zeile 166:
!in Scratch
!in Scratch
|-
|-
|<code>x&nbsp;==&nbsp;y</code>
|{{Python|x {{=}}{{=}} y}}
|Gleichheit
|Gleichheit
|Achtung: In Python wird ein doppeltes Gleichheitszeichen zur Überprüfung der Gleichheit verwendet. Ein einfaches Gleichheitszeichen beschreibt dagegen eine Variablenzuweisung!
|Achtung: In Python wird ein doppeltes Gleichheitszeichen zur Überprüfung der Gleichheit verwendet. Ein einfaches Gleichheitszeichen beschreibt dagegen eine Variablenzuweisung!
| <sb>() = ()</sb>
| <sb>() = ()</sb>
|-
|-
|<code>x != y</code>
|{{Python|x !{{=}} y}}
|Ungleichheit
|Ungleichheit
|
|
|<sb>nicht <()=()></sb>
|<sb>nicht <()=()></sb>
|-
|-
|<code>x < y</code>
|{{Python|x < y}}
|Echt kleiner
|Echt kleiner
|
|
|<sb><()<()></sb>
|<sb><()<()></sb>
|-
|-
|<code>x <= y</code>
|{{Python|x <{{=}} y}}
|Kleiner oder gleich
|Kleiner oder gleich
|
|
|<sb>nicht <()>()></sb>
|<sb>nicht <()>()></sb>
|-
|-
|<code>x > y</code>
|{{Python|x > y}}
|Echt größer
|Echt größer
|
|
|<sb>()>()</sb>
|<sb>()>()</sb>
|-
|-
|<code>x >= y</code>
|{{Python|x >{{=}} y}}
|Größer oder gleich
|Größer oder gleich
|
|
Zeile 215: Zeile 198:


=== Logische Operatoren ===
=== Logische Operatoren ===
Logische Operatoren werden für Berechnungen mit Wahrheitswerten (Datentyp <code>bool</code>) verwendet, z. B. um mehrere Wahrheitswerte oder logische Ausdrücke zu verknüpfen. Das Berechnungsergebnis ist ebenfalls ein Wahrheitswert. In den folgenden Beispielen stehen <code>a</code> und <code>b</code> jeweils für Wahrheitswerte oder logische Ausdrücke.
Logische Operatoren werden für Berechnungen mit Wahrheitswerten (Datentyp {{Python|bool}}) verwendet, z. B. um mehrere Wahrheitswerte oder logische Ausdrücke zu verknüpfen. Das Berechnungsergebnis ist ebenfalls ein Wahrheitswert. In den folgenden Beispielen stehen {{Python|a}} und {{Python|b}} jeweils für Wahrheitswerte oder logische Ausdrücke.
{| class="wikitable"
{| class="wikitable"
!Operator
!Operator
Zeile 221: Zeile 204:
!in Scratch
!in Scratch
|-
|-
|<code>not a</code>
|{{Python|not a}}
|Logisches NICHT (“Negation”): <code>not a</code> ist genau dann <code>True</code>, wenn <code>a</code> zu <code>False</code> ausgewertet wird.
|Logisches NICHT (<q>Negation</q>): {{Python|not a}} ist genau dann {{Python|True}}, wenn {{Python|a}} zu {{Python|False}} ausgewertet wird.
|<sb>nicht <></sb>
|<sb>nicht <></sb>
|-
|-
|<code>a and b</code>
|{{Python|a and b}}
|Logisches UND: <code>a and b</code> ist genau dann <code>True</code>, wenn sowohl <code>a</code> als auch <code>b</code> zu <code>True</code> ausgewertet werden.
|Logisches UND: {{Python|a and b}} ist genau dann {{Python|True}}, wenn sowohl {{Python|a}} als auch {{Python|b}} zu {{Python|True}} ausgewertet werden.
|<sb><> und <></sb>
|<sb><> und <></sb>
|-
|-
|<code>a or b</code>
|{{Python|a or b}}
|Logisches ODER: <code>a and b</code> ist genau dann <code>True</code>, wenn <code>a</code>, <code>b</code> oder beide zu <code>True</code> ausgewertet werden.
|Logisches ODER: {{Python|a and b}} ist genau dann {{Python|True}}, wenn {{Python|a}}, {{Python|b}} oder beide zu {{Python|True}} ausgewertet werden.
|<sb><> oder <></sb>
|<sb><> oder <></sb>
|}
|}
==== Exkurs: Fortgeschrittenere Verwendung von logischen Operatoren ====
==== Exkurs: Fortgeschrittenere Verwendung von logischen Operatoren ====


Die Verwendung der logischen Operatoren ist in Python nicht auf Wahrheitswerte als Operanden beschränkt. <code>4 or 5</code> ist in Python ebenfalls ein zulässiger Ausdruck. Streng genommen arbeiten die Operatoren <code>and</code> und <code>or</code> anders als oben beschrieben. Die Python-Dokumentation definiert den <code>and</code>-Operator folgendermaßen:
Die Verwendung der logischen Operatoren ist in Python nicht auf Wahrheitswerte als Operanden beschränkt. {{Python|4 or 5}} ist in Python ebenfalls ein zulässiger Ausdruck. Streng genommen arbeiten die Operatoren {{Python|and}} und {{Python|or}} anders als oben beschrieben. Die Python-Dokumentation definiert den {{Python|and}}-Operator folgendermaßen:
<blockquote>if ''x'' is false, then ''x'', else ''y''<ref>[https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not Python-Dokumentation {{Flagge|GBFRESBRJPCNKRTR}}]</ref></blockquote>
<blockquote cite="Python-Dokumentation">if ''x'' is false, then ''x'', else ''y''<ref>[https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not Python-Dokumentation {{Flagge|GBFRESBRJPCNKRTR}}]</ref></blockquote>
Die Auswertung von <code>a</code> and <code>b</code> ergibt also den Wert von <code>a</code>, falls dieser Wert als Wahrheitswert interpretiert <code>False</code> ergeben würde, anderenfalls den Wert von <code>b</code>.
Die Auswertung von {{Python|a}} and {{Python|b}} ergibt also den Wert von {{Python|a}}, falls dieser Wert als Wahrheitswert interpretiert {{Python|False}} ergeben würde, anderenfalls den Wert von {{Python|b}}.


Als <code>False</code> werden unter anderem die Zahlen <code>0</code> und <code>0.0</code>, sowie der leere String <code><nowiki>''</nowiki></code> interpretiert.
Als {{Python|False}} werden unter anderem die Zahlen {{Python|0}} und {{Python|0.0}}, sowie der leere String {{Python|''}} interpretiert.


Der Operator <code>or</code> wird in der Python-Dokumentation definiert durch:
Der Operator {{Python|or}} wird in der Python-Dokumentation definiert durch:
<blockquote>if ''x'' is false, then ''y'', else ''x''<ref>[https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not Python-Dokumentation {{Flagge|GBFRESBRJPCNKRTR}}]</ref></blockquote>
<blockquote cite="Python-Dokumentation">if ''x'' is false, then ''y'', else ''x''<ref>[https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not Python-Dokumentation {{Flagge|GBFRESBRJPCNKRTR}}]</ref></blockquote>
Die Auswertung von <code>a</code> and <code>b</code> ergibt also den Wert von <code>b</code>, falls dieser Wert als Wahrheitswert interpretiert <code>False</code> ergeben würde, anderenfalls den Wert von <code>a</code>.
Die Auswertung von {{Python|a}} and {{Python|b}} ergibt also den Wert von {{Python|b}}, falls dieser Wert als Wahrheitswert interpretiert {{Python|False}} ergeben würde, anderenfalls den Wert von {{Python|a}}.


Als Beispiel: Wir fragen einen String ab und möchten diesen, falls er leer ist, in der Ausgabe durch einen Standardwert ersetzen:
{{Beispiel|1≈Wir fragen einen String ab und möchten diesen, falls er leer ist, in der Ausgabe durch einen Standardwert ersetzen:
<syntaxhighlight lang="python" line>
<syntaxhighlight lang="python" line>
name = input('Bitte sag mir deinen Namen!')
name = input('Bitte sag mir deinen Namen!')
Zeile 251: Zeile 234:
</syntaxhighlight>
</syntaxhighlight>
Dieses Programm begrüßt die Person, die es verwendet, also entweder namentlich, falls sie einen Namen eingibt, oder als "Anonym", falls nichts eingegeben wird.
Dieses Programm begrüßt die Person, die es verwendet, also entweder namentlich, falls sie einen Namen eingibt, oder als "Anonym", falls nichts eingegeben wird.
}}


=== Operatoren für Zeichenketten ===
=== Operatoren für Zeichenketten ===
Die folgenden Operatoren sind zum Arbeiten mit Zeichenketten (Datentyp <code>str</code>) hilfreich. In der Regel ist der Ergebniswert ebenfalls eine Zeichenkette (Ausnahme: Für den Operator <code>in</code> ist das Ergebnis ein Wahrheitswert). In den folgenden Beispielen stehen <code>s</code> und <code>t</code> jeweils für Zeichenketten und <code>n</code> für eine ganze Zahl.
Die folgenden Operatoren sind zum Arbeiten mit Zeichenketten (Datentyp {{Python|str}}) hilfreich. In der Regel ist der Ergebniswert ebenfalls eine Zeichenkette (Ausnahme: Für den Operator {{Python|in}} ist das Ergebnis ein Wahrheitswert). In den folgenden Beispielen stehen {{Python|s}} und {{Python|t}} jeweils für Zeichenketten und {{Python|n}} für eine ganze Zahl.
{| class="wikitable"
{| class="wikitable"
!Operation
!Operation
Zeile 259: Zeile 243:
!in Scratch
!in Scratch
|-
|-
|<code>s + t</code>
|{{Python|s + t}}
|Aneinanderhängen (“Konkatenation”)
|Aneinanderhängen (“Konkatenation”)
Beispiel: <code>'Flens' + 'burg'</code> → <code>'Flensburg'</code>
Beispiel: {{Python|'Flens' + 'burg'}} → {{Python|'Flensburg'}}
|<sb>verbinde () und ()</sb>
|<sb>verbinde () und ()</sb>
|-
|-
|<code>n * s</code>
|{{Python|n * s}}
|Vervielfältigung
|Vervielfältigung
Beispiel: <code>3 * 'Ho'</code> → <code>'HoHoHo'</code>
Beispiel: {{Python|3 * 'Ho'}} → {{Python|'HoHoHo'}}
|
|
|-
|-
|<code>s in t</code>
|{{Python|s in t}}
|Ist der Teilstring <code>t</code> in <code>s</code> enthalten?
|Ist der Teilstring {{Python|t}} in {{Python|s}} enthalten?
Beispiel: <code>'sum' in 'Husum'</code> → <code>True</code>
Beispiel: {{Python|'sum' in 'Husum'}} → {{Python|True}}
| <sb>() enthält ()</sb>
| <sb>() enthält ()</sb>
|-
|-
|<code>s[n]</code>
|{{Python|s[n]}}
|Zeichen an der Position <code>n</code> im String <code>s</code>
|Zeichen an der Position {{Python|n}} im String {{Python|s}}
Beispiel: <code>'Rendsburg'[1]</code> → <code>'e'</code>
Beispiel: {{Python|'Rendsburg'[1]}} → {{Python|'e'}}
Achtung: In Python wird von 0 an gezählt, in Scratch von 1 an!
Achtung: In Python wird von 0 an gezählt, in Scratch von 1 an!
| <sb>Zeichen () von ()</sb>
| <sb>Zeichen () von ()</sb>
|-
|-
|<code>len(s)</code>
|{{Python|len(s)}}
|Länge des Strings <code>s</code>
|Länge des Strings {{Python|s}}
Beispiel: <code>len('Kiel')</code> → <code>4</code>
Beispiel: {{Python|len('Kiel')}} → {{Python|4}}
| <sb>Länge von ()</sb>
| <sb>Länge von ()</sb>
|}
|}
Zeile 288: Zeile 272:
== Fußnoten ==
== Fußnoten ==
<references/>
<references/>
{{DEFAULTSORT:1. Variablen_und_Ausdrücke}}

Aktuelle Version vom 7. Oktober 2024, 06:24 Uhr

Variablen

Eine Variable ist ein Bezeichner, der eine Referenz, also einen Verweis auf eine Stelle im Objektspeicher von Python enthält. Im Objektspeicher sind Objekte wie die Zahl 42, der Text “Hallo Welt” oder eine Liste mit den Elementen 1, 2 und 3 abgelegt.

Definition und Zuweisung

Anders als in Scratch oder vielen anderen Programmiersprachen müssen Variablen in Python vor der Verwendung nicht definiert werden. Man weist ihnen einfach einen Wert zu, etwa: 

nettobetrag = 16.80

und kann den Wert dieser Variablen anschließend für weitere Berechnungen verwenden: 

bruttobetrag = nettobetrag * 1.19

Die Syntax ist hier: Bezeichner Python code Ausdruck, wobei der Bezeichner mit einem Buchstaben beginnen muss (bei Variablen üblicherweise ein Kleinbuchstabe) und hinter dem Gleichheitszeichen jeder beliebige Ausdruck stehen darf, der ein Ergebnis zurückliefert. Beispiele:

  • adresse = 'Musterstr. 1, 12345 Musterstadt'
  • hoechstpunktzahl = 42
  • c = math.sqrt(a**2 + b**2)
  • name = input('Bitte gib deinen Vornamen an')

Der Bezeichner sollte dabei möglichst aussagekräftig gewählt werden. Generische Variablenbezeichner wie x oder variable sollten möglichst vermieden werden.

Dass Variablen vor der Verwendung nicht definiert werden müssen, birgt das Risiko von Laufzeitfehlern, wenn man sich vertippt. Betrachten wir die folgenden Codebeispiele: 

groesse = int(input('Bitte geben Sie Ihre Größe in cm ein! '))
groesse = groesse / 100
print('Sie sind ' + str(groesse) + ' m groß.')

und 

groesse = int(input('Bitte geben Sie Ihre Größe in cm ein! '))
greosse = groesse / 100
print('Sie sind ' + str(groesse) + ' m groß.')

Wird das erste Programm gestartet, so erhalten wir die folgende Ausgabe im Konsolenfenster: 

Bitte geben Sie Ihre Größe in cm ein! 203
 Sie sind 2.03 m groß.

Zur Erklärung: Das Programm pausiert nach der ersten Ausgabe (“Bitte geben Sie Ihre Größe in cm ein!”) und wartet, bis wir eine Eingabe in die Konsole eingeben und mit der Eingabetaste bestätigen. In diesem Fall haben wir die Zahl 203 eingegeben.

Wird das zweite Programm ausgeführt, erzeugt es die folgende Ausgabe in der Konsolenfenster (auch hier geben wir wieder 203 ein): 

Bitte geben Sie Ihre Größe in cm ein! 203
 Sie sind 203 m groß.

Was ist passiert? Das zweite Programm enthält in Zeile 2 einen Tippfehler: Statt groesse steht dort greosse. Der Python-Interpreter legt darum eine neue Variable namens greosse an und speichert darin den Wert 2.03. Der Wert von groesse bleibt unverändert.

Datentypen

Nicht mit allen Arten von Daten lassen sich die gleichen Operationen durchführen. Betrachten wir als Beispiel den Operator *: 

>>> 6 * 7
42
>>> 4 * 3.141592653587
12.566370614348
>>> 'kartoffel' * 'salat'
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
TypeError: can't multiply sequence by non-int of type 'str'
>>> 2 * 'moin '
'moin moin '
>>> 2.5 * 'moin'
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
TypeError: can't multiply sequence by non-int of type 'float'
>>> 4 * [1,2,3]
[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]

Mit dem *-Operator können Zahlen multipliziert und Zeichenketten vervielfältigt werden. Hier gibt es Unterschiede bezüglich der Datentypen der Operanden (d. h. der Werte bzw. Ausdrücke, die links und rechts des Operators stehen).

Die wichtigsten elementaren Datentypen in Python sind:

Datentypen in Python
Typ Erklärung Beispiele
int für ganze Zahlen (engl. integer numbers) 0, 42, 3190701205
float für Dezimalzahlen (“Kommazahlen”, engl. floating-point numbers) 0.5, 42.0, 3.141592
str für beliebige Zeichenketten (engl. strings) 'Hello World', '42', 'https://wiki.kah.gs'
bool für Wahrheitswerte (engl. boolean)[P 1] True, False
  1. ↑ Logische Wahrheitswerte werden nach George Boole, einem Pionier der mathematischen Logik, auch als "boolesche Werte" bezeichnet (im Englischen "boolean").

Mit der eingebauten Funktion type kann in Python der Datentyp eines Objekts abgefragt werden, z. B.: 

>>> groesse = 203
>>> type(groesse)
<class 'int'>
>>> name = 'Max Mustermann'
>>> type(name)
<class 'str'>

Konvertierung von Datentypen =

Mit den Funktionen int, float, str und bool können Objekte in andere Datentypen umgewandelt ("konvertiert") werden. Das wird als Type Casting bezeichnet (auf deutsch "Datentypumwandlung" oder kurz "Konvertierung"). Dabei können Daten verloren gehen, und es sind nicht alle Konvertierungen möglich. Zum Beispiel gehen bei der Konvertierung int(25.95) zwangsläufig die Nachkommastellen verloren, das Ergebnis ist die Ganzzahl 25.[1]

Die folgende Tabelle zeigt anhand von Beispielen, welche Konvertierungen zwischen den vier elementaren Datentypen möglich sind und welche Ergebnisse wir erhalten:

Argumentwert int(x) float(x) str(x) bool(x)
x = 2 2 2.0 '2' True
x = 2.7818 2 2.7818 '2.7818' True
x = 'zwei' Fehler Fehler 'zwei' True
x = True 1 1.0 'True' True
👉
Hinweis

Die Konvertierung von Zahlen oder Strings in Wahrheitswerte mit bool ergibt immer True, außer für die Werte 0, 0.0 und den leeren String ''.

Operatoren

Mathematische Operatoren

Mathematische Operatoren werden für Berechnungen mit numerischen Werten (Datentypen int und float) verwendet. Die Operanden (hier x und y genannt) sind numerische Werte oder Ausdrücke, die numerische Werte ergeben. Die Berechnungsergebnisse sind ebenfalls numerische Werte.

Operator Bezeichnung Beschreibung in Scratch
x + y Addition ()+()
x - y Subtraktion ()-()
x * y Multiplikation ()*()
x / y Division Liefert immer einen Wert vom Datentyp float als Ergebnis zurück, auch wenn das Ergebnis ganzzahlig ist.

Beispiel: 4 / 2 → 2.0

()/()
x // y Ganzzahlige Division Liefert immer einen Wert vom Datentyp int zurück, ggf. wird das Ergebnis also konvertiert.

Beispiel: x // y ergibt dasselbe wie int(x / y)

[abrunden v] von (()/())
x % y Modulo Berechnet den Rest, der bei der ganzzahligen Division von x durch y übrigbleibt.

Beispiel: 10 % 3 → 1

() mod ()
x ** y Potenz Berechnet (x hoch y), also die y-fache Multiplikation von x. siehe unten[2]

Vergleichsoperatoren

Mit Vergleichsoperatoren können zwei Werte oder die Ergebnisse zweier Ausdrücke verglichen werden. Das Ergebnis ist ein Wahrheitswert True oder False (Ausdrücke mit einem Vergleichsoperatoren sind also logische Ausdrücke).

Die Operanden können dabei verschiedene Datentypen haben, so lassen sich numerische Werte, Zeichenketten und auch andere Objekte miteinander vergleichen. In den folgenden Beispielen stehen x und y also für Werte beliebiger Datentypen (z. B. int, float oder str).

Operator Bezeichnung Hinweis in Scratch
x == y Gleichheit Achtung: In Python wird ein doppeltes Gleichheitszeichen zur Überprüfung der Gleichheit verwendet. Ein einfaches Gleichheitszeichen beschreibt dagegen eine Variablenzuweisung! () = ()
x != y Ungleichheit nicht <()=()>
x < y Echt kleiner <()<()>
x <= y Kleiner oder gleich nicht <()>()>
x > y Echt größer ()>()
x >= y Größer oder gleich nicht <()<()>

Logische Operatoren

Logische Operatoren werden für Berechnungen mit Wahrheitswerten (Datentyp bool) verwendet, z. B. um mehrere Wahrheitswerte oder logische Ausdrücke zu verknüpfen. Das Berechnungsergebnis ist ebenfalls ein Wahrheitswert. In den folgenden Beispielen stehen a und b jeweils für Wahrheitswerte oder logische Ausdrücke.

Operator Beschreibung in Scratch
not a Logisches NICHT (Negation): not a ist genau dann True, wenn a zu False ausgewertet wird. nicht <>
a and b Logisches UND: a and b ist genau dann True, wenn sowohl a als auch b zu True ausgewertet werden. <> und <>
a or b Logisches ODER: a and b ist genau dann True, wenn a, b oder beide zu True ausgewertet werden. <> oder <>

 Exkurs: Fortgeschrittenere Verwendung von logischen Operatoren

Die Verwendung der logischen Operatoren ist in Python nicht auf Wahrheitswerte als Operanden beschränkt. 4 or 5 ist in Python ebenfalls ein zulässiger Ausdruck. Streng genommen arbeiten die Operatoren and und or anders als oben beschrieben. Die Python-Dokumentation definiert den and-Operator folgendermaßen:

if x is false, then x, else y[3]

Die Auswertung von a and b ergibt also den Wert von a, falls dieser Wert als Wahrheitswert interpretiert False ergeben würde, anderenfalls den Wert von b.

Als False werden unter anderem die Zahlen 0 und 0.0, sowie der leere String '' interpretiert.

Der Operator or wird in der Python-Dokumentation definiert durch:

if x is false, then y, else x[4]

Die Auswertung von a and b ergibt also den Wert von b, falls dieser Wert als Wahrheitswert interpretiert False ergeben würde, anderenfalls den Wert von a.

💬
Beispiel

1≈Wir fragen einen String ab und möchten diesen, falls er leer ist, in der Ausgabe durch einen Standardwert ersetzen: 

name = input('Bitte sag mir deinen Namen!')
print('Hallo, ' + (name or 'Anonym'))

Dieses Programm begrüßt die Person, die es verwendet, also entweder namentlich, falls sie einen Namen eingibt, oder als "Anonym", falls nichts eingegeben wird.

Operatoren für Zeichenketten

Die folgenden Operatoren sind zum Arbeiten mit Zeichenketten (Datentyp str) hilfreich. In der Regel ist der Ergebniswert ebenfalls eine Zeichenkette (Ausnahme: Für den Operator in ist das Ergebnis ein Wahrheitswert). In den folgenden Beispielen stehen s und t jeweils für Zeichenketten und n für eine ganze Zahl.

Operation Bedeutung in Scratch
s + t Aneinanderhängen (“Konkatenation”)

Beispiel: 'Flens' + 'burg' → 'Flensburg'

verbinde () und ()
n * s Vervielfältigung

Beispiel: 3 * 'Ho' → 'HoHoHo'

s in t Ist der Teilstring t in s enthalten?

Beispiel: 'sum' in 'Husum' → True

() enthält ()
s[n] Zeichen an der Position n im String s

Beispiel: 'Rendsburg'[1] → 'e' Achtung: In Python wird von 0 an gezählt, in Scratch von 1 an!

Zeichen () von ()
len(s) Länge des Strings s

Beispiel: len('Kiel') → 4

Länge von ()

Fußnoten

  1. ↑ Bei der Umwandlung von Dezimalzahlen mit Nachkommastellen in Ganzzahlen mit der Funktion int wird in Python zur Null hin gerundet (bei positiven Zahlen wird also abgerundet, bei negativen aufgerundet).
  2. ↑ Es gibt für die Potenz mit beliebiger Basis keinen Block in Scratch, aber mit Hilfe der Exponentialfunktion und des natürlichen Logarithmus lässt sich die Potenz folgendermaßen umformen: und in Scratch umsetzen: [e^ v] von ((y) * ([ln v] von (x))
  3. ↑ Python-Dokumentation 🇬🇧🇫🇷🇪🇸🇧🇷🇯🇵🇨🇳🇰🇷🇹🇷
  4. ↑ Python-Dokumentation 🇬🇧🇫🇷🇪🇸🇧🇷🇯🇵🇨🇳🇰🇷🇹🇷
Abgerufen von „https://wiki.kah.gs/index.php?title=Tutorial:Programmieren_mit_Python/Variablen_und_Ausdrücke&oldid=6565“