Gitarre: CAGED-Skala D-Dur-Form

<mediawiki xmlns="http://www.mediawiki.org/xml/export-0.11/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.mediawiki.org/xml/export-0.11/ http://www.mediawiki.org/xml/export-0.11.xsd" version="0.11" xml:lang="de">
  <siteinfo>
    <sitename>Wikibooks</sitename>
    <dbname>dewikibooks</dbname>
    <base>https://de.wikibooks.org/wiki/Hauptseite</base>
    <generator>MediaWiki 1.47.0-wmf.24</generator>
    <case>first-letter</case>
    <namespaces>
      <namespace key="-2" case="first-letter">Medium</namespace>
      <namespace key="-1" case="first-letter">Spezial</namespace>
      <namespace key="0" case="first-letter" />
      <namespace key="1" case="first-letter">Diskussion</namespace>
      <namespace key="2" case="first-letter">Benutzer</namespace>
      <namespace key="3" case="first-letter">Benutzer Diskussion</namespace>
      <namespace key="4" case="first-letter">Wikibooks</namespace>
      <namespace key="5" case="first-letter">Wikibooks Diskussion</namespace>
      <namespace key="6" case="first-letter">Datei</namespace>
      <namespace key="7" case="first-letter">Datei Diskussion</namespace>
      <namespace key="8" case="first-letter">MediaWiki</namespace>
      <namespace key="9" case="first-letter">MediaWiki Diskussion</namespace>
      <namespace key="10" case="first-letter">Vorlage</namespace>
      <namespace key="11" case="first-letter">Vorlage Diskussion</namespace>
      <namespace key="12" case="first-letter">Hilfe</namespace>
      <namespace key="13" case="first-letter">Hilfe Diskussion</namespace>
      <namespace key="14" case="first-letter">Kategorie</namespace>
      <namespace key="15" case="first-letter">Kategorie Diskussion</namespace>
      <namespace key="102" case="first-letter">Regal</namespace>
      <namespace key="103" case="first-letter">Regal Diskussion</namespace>
      <namespace key="710" case="first-letter">TimedText</namespace>
      <namespace key="711" case="first-letter">TimedText talk</namespace>
      <namespace key="828" case="first-letter">Modul</namespace>
      <namespace key="829" case="first-letter">Modul Diskussion</namespace>
      <namespace key="1728" case="first-letter">Veranstaltung</namespace>
      <namespace key="1729" case="first-letter">Veranstaltung Diskussion</namespace>
    </namespaces>
  </siteinfo>
  <page>
    <title>Gitarre: CAGED-Skala D-Dur-Form</title>
    <ns>0</ns>
    <id>80780</id>
    <revision>
      <id>1092169</id>
      <parentid>1092158</parentid>
      <timestamp>2026-10-16T14:05:13Z</timestamp>
      <contributor>
        <username>Mjchael</username>
        <id>2222</id>
      </contributor>
      <comment>/* Übungsvorschlag */ link</comment>
      <origin>1092169</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="11430" sha1="jfu0x2eyie7fii723eok3j3j6pprj5t" xml:space="preserve">{{:Gitarre/ Navi|Sologitarre|

{{:Gitarre: Sologitarre/ Navi Improvisation in Dur und Moll}}|
img=Guitar 1.svg |bg=#F8f8f8|border=darkorange|color=dark|px=80|navi=Einführung in die Sologitarre}}

&lt;div class=&quot;noprint&gt;
&lt;small&gt;''Notitz wird nicht gedruckt!''&lt;/small&gt;
{{Notiz|Nein, du hast dich nicht verklickt! Wir beginnen mit der D-Form, wo sich der Lagewechsel des 3. Fingersatz noch nicht mit dem Lagewechsel zwischen der G-und H-Saite aufhebt. Wir folgen im Unterricht nicht der CAGED-Reihenfolge, sondern sinnigerweise dem Quintenzirkel.}}

&lt;/div&gt;
==Die D-Dur-Form==
{| border=&quot;1&quot; style=&quot;border-collapse:collapse&quot; cellpadding=&quot;3&quot;
! Intervalle || C-Dur-Tonleiter || Subdominante || Dominante
|- 
| [[Datei:Scala D-Typ.svg]] || [[Datei:C-Dur_Majorpattern_II.jpg]] || [[Image:Crd Form G.svg|150px]] || [[Image:Crd Form A Bb.svg|150px]]&lt;br&gt;&lt;small&gt;Hier ist A-Form stimmiger als Bb-Form.&lt;/small&gt;
|-
! Grundakkordform || Mollparallele || Subdominanten&amp;shy; parallele || Dominanten&amp;shy;parallele
|- 
| [[Image:Crd Form D.svg|150px]] || [[Image:Crd Form Bm7.svg|150px]]  || [[Image:Crd Form Em.svg|150px]] || [[Image:Crd Form Gm7.svg|150px]]&lt;br&gt;&lt;small&gt;eigentlich F#m7-Form&lt;/small&gt;
|}
;Zugrundeliegende Dur-Tonleiter
[[Datei:Scala D-Hm.svg|200px]]
;mit ihren Hauptakkorden
[[Datei:Crd D.svg|100px]] [[Datei:Crd G.svg|100px]] [[Datei:Crd A.svg|100px]] &lt;br&gt;
[[Datei:Crd Hm7 x20202.svg|100px]] [[Datei:Crd Em.svg|100px]] [[Datei:Crd Fism7 2x2222.svg|100px]] 

; Aufgabe:
Versuche die 6 Akkorde der Tonleiter in den Skalen zu entdecken. Sowohl die einfachen Akkorde in der D-Dur-Tonleiter, als auch die Barré-Formen in der Skala der D-Dur- bzw. Bm-Form.

=== G-Dur- bzw. E-Moll-Tonleiter  ===
;in der D-Dur- bzw. Bm-Moll-Form
[[Datei:Scala D-Typ.svg|mini|CAGED-Skala der D/Bm-Form im 4. und 5. Bund.]]

Die Skala beginnt mit dem dritten Fingersatz, der in den ersten übergeht. Der zweite Fingersatz am Schluss beginnt wegen dem Lagewechsel einen Bund später. Trotz der beiden Lagewechsel ist die Skala nicht ganz so schwer, wie andere Skalen mit Lagewechsel. 

&lt;score sound=&quot;1&quot; raw=&quot;1&quot;&gt;
\version &quot;2.20.0&quot;
\header {
  title = &quot;G-Dur- bzw. E-Moll-Tonleiter&quot;
  subtitle = &quot;in der D-Dur- bzw. Bm-Moll-Form.&quot;
  subsubtitle=&quot;reine Skala&quot;
}

Melody =  {
  \set Staff.midiInstrument = &quot;electric guitar (clean)&quot;
  \repeat volta 2 {  
    \stemUp
    \set TabStaff.minimumFret = #4
    \set TabStaff.restrainOpenStrings = ##t
 a,8 b, c-4 d-1 e-4 fis-1 g a |
 b8 c' d' e'-1 fis' g' a' b' |
 \break
 c''8 b' a' g' fis' e' d'-4 c' | 
 b8 a g fis-1 e-4 d-1 c-4 b, | a,1 |
 } 
 
}

Gitarre =  \Melody

\score {
  &lt;&lt;
    \new Voice  { 
      \clef &quot;treble_8&quot; \time 4/4  
      \tempo 4 = 100 \key g \major 
      \set Score.tempoHideNote = ##t
      \Gitarre 
    }
   \new TabStaff { \Gitarre }
  &gt;&gt;
  \layout { }
}
\score {
  &lt;&lt;
    \new Voice  { 
      \clef &quot;treble_8&quot; \time 4/4  
      \tempo 4 = 100 \key c \major 
      \unfoldRepeats \Gitarre 
    }
  &gt;&gt;
  \midi { }
}

\paper {
  indent=0\mm
  line-width=120\mm
  oddFooterMarkup=##f
  oddHeaderMarkup=##f
  % bookTitleMarkup=##f
  scoreTitleMarkup=##f
}
&lt;/score&gt;

== Eine II-V-I-Verbindung ==
Die ersten Teile kennst du schon aus den Vorübungen zum 3. Fingersatz. Um das Pattern voll zu bekommen wurden noch ein paar Töne hinzugefügt.
&lt;score sound=&quot;1&quot; raw=&quot;1&quot;&gt;
\version &quot;2.20.0&quot;
\header {
  title=&quot;G-Dur in der D-Form&quot;
  subtitle=&quot;Eine II-V-I-Verbindung&quot;
}
%% Diskant- bzw. Melodiesaiten
Diskant = \relative c {
  \set TabStaff.minimumFret = #4
  \set TabStaff.restrainOpenStrings = ##t
  \key g \major
  \repeat volta 2 {
    a8^\markup { \bold {Am7} } b c d-1 e-4 fis-1 g4 |
  fis8^\markup { \bold {D7} } e-4 d4-1 c8-4 b a4 |
  b8^\markup { \bold {G} } c d4-1 e8-4 
  fis-1  g4~| g1 | \break
  a8-4^\markup { \bold {Am7} } b c d-4 e-1 fis g4 |
  fis8^\markup { \bold {D7} } e-1 d4-4 c8 b a4 |
  b8^\markup { \bold {G} } c d4-4 e8-1 fis  g4~| g8 a b c b a g4 |

 % \bar &quot;|.&quot;
}}

%% Layout- bzw. Bildausgabe
\score {
  &lt;&lt;
    \new Voice  { 
      \clef &quot;treble_8&quot; 
      \time 4/4  
      \tempo 4 = 120 
      \set Score.tempoHideNote = ##t
      \Diskant 
    }
    \new TabStaff { \tabFullNotation \Diskant }
  &gt;&gt;
  \layout {}
}

%% Midiausgabe mit Wiederholungen, ohne Akkorde
\score {
  &lt;&lt;
    \unfoldRepeats {
      \new Staff  &lt;&lt;
        \tempo 4 = 120
        \time 4/4
        \set Staff.midiInstrument = #&quot;acoustic guitar (nylon)&quot;
        \clef &quot;G_8&quot;
        \Diskant
      &gt;&gt;
    }
  &gt;&gt;
  \midi {}
}
%% unterdrückt im raw=&quot;!&quot;-Modus das DinA4-Format.
\paper {
  indent=0\mm
  %% DinA4 = 210mm - 10mm Rand - 20mm Lochrand = 180mm
  line-width=180\mm
  oddFooterMarkup=##f
  oddHeaderMarkup=##f
  % bookTitleMarkup=##f
  scoreTitleMarkup=##f
}
&lt;/score&gt;

=== Quinten und Quarten ===
Quinten und Quarten bilden meist den Rahmenintervall eines Akkordes und sie werden beim Powerchord gebraucht. Nur der Tritonus (hier der Intervall zwischen C und Fis bei den Legato-Bögen) fällt etwas aus dem Rahmen.
&lt;score sound=&quot;1&quot; raw=&quot;1&quot;&gt;
\version &quot;2.20.0&quot;
\header {
  title=&quot;G-Dur in der D-Form&quot;
  subtitle=&quot;Quinten und Quarten&quot;
}
%% Diskant- bzw. Melodiesaiten
Diskant = \relative c' {
  \set TabStaff.minimumFret = #4
  \set TabStaff.restrainOpenStrings = ##t
  \key g \major
  \repeat volta 2 {
    c'8( fis,) b e, a d, 
    g c,( fis) b, e a, 
    d g, c( fis,) b e, 
    a d, g c,( fis) b,
    e a,~  a2
    a8 e' b fis'( c) g'
    d a' e b' fis( c')
    g d' a e' b fis'( 
    c) g' d a' e b' 
    fis( c')~ c2

 % \bar &quot;|.&quot;
}}

%% Layout- bzw. Bildausgabe
\score {
  &lt;&lt;
    \new Voice  { 
      \clef &quot;treble_8&quot; 
      \time 3/4  
      \tempo 4 = 120 
      \set Score.tempoHideNote = ##t
      \Diskant 
    }
    \new TabStaff { \tabFullNotation \Diskant }
  &gt;&gt;
  \layout {}
}

%% Midiausgabe mit Wiederholungen, ohne Akkorde
\score {
  &lt;&lt;
    \unfoldRepeats {
      \new Staff  &lt;&lt;
        \tempo 4 = 120
        \time 3/4
        \set Staff.midiInstrument = #&quot;acoustic guitar (nylon)&quot;
        \clef &quot;G_8&quot;
        \Diskant
      &gt;&gt;
    }
  &gt;&gt;
  \midi {}
}
%% unterdrückt im raw=&quot;!&quot;-Modus das DinA4-Format.
\paper {
  indent=0\mm
  %% DinA4 = 210mm - 10mm Rand - 20mm Lochrand = 180mm
  line-width=180\mm
  oddFooterMarkup=##f
  oddHeaderMarkup=##f
  % bookTitleMarkup=##f
  scoreTitleMarkup=##f
}
&lt;/score&gt;
=== Zwei vor einen zurück ===

&lt;score sound=&quot;1&quot; raw=&quot;1&quot;&gt;
\version &quot;2.20.0&quot;
\header {
  title=&quot;G-Dur in der D-Form&quot;
  subtitle=&quot;Zwei vor einen zurück&quot;
}
%% Diskant- bzw. Melodiesaiten
Diskant = \relative c' {
  \set TabStaff.minimumFret = #4
  \set TabStaff.restrainOpenStrings = ##t
  \key g \major
  \repeat volta 2 {
  a,8 b c b c d c d e d e fis | 
  e fis g fis g a g a b a b c |
  b c d c d e d e fis e fis g |
  fis g a g a b a b c b c4 | \break
  c8 b a b a g a g fis g fis e |
  fis e d e d c d c b c b a |
  b a g a g fis g fis e fis e d |
  e d c d c b c b a4.


 % \bar &quot;|.&quot; 
}}

%% Layout- bzw. Bildausgabe
\score {
  &lt;&lt;
    \new Voice  { 
      \clef &quot;treble_8&quot; 
      \time 6/8  
      \tempo 4 = 120 
      \set Score.tempoHideNote = ##t
      \Diskant 
    }
    \new TabStaff { \tabFullNotation \Diskant }
  &gt;&gt;
  \layout {}
}

%% Midiausgabe mit Wiederholungen, ohne Akkorde
\score {
  &lt;&lt;
    \unfoldRepeats {
      \new Staff  &lt;&lt;
        \tempo 4 = 120
        \time 3/4
        \set Staff.midiInstrument = #&quot;acoustic guitar (nylon)&quot;
        \clef &quot;G_8&quot;
        \Diskant
      &gt;&gt;
    }
  &gt;&gt;
  \midi {}
}
%% unterdrückt im raw=&quot;!&quot;-Modus das DinA4-Format.
\paper {
  indent=0\mm
  %% DinA4 = 210mm - 10mm Rand - 20mm Lochrand = 180mm
  line-width=180\mm
  oddFooterMarkup=##f
  oddHeaderMarkup=##f
  % bookTitleMarkup=##f
  scoreTitleMarkup=##f
}
&lt;/score&gt;
{{Todo|Attraktivere Übungen erstellen!|Mjchael|Sologitarre}}

== Quintfallsequenz==
{{Baustelle}}
Wir wandern Septim-Akkorde in Quinten herunter.
&lt;score sound=&quot;1&quot; raw=&quot;1&quot;&gt;
\version &quot;2.20.0&quot;
\header {
  title=&quot;G-Dur in der D-Form&quot;
  subtitle=&quot;Eine II-V-I-Verbindung&quot;
}
%% Diskant- bzw. Melodiesaiten
Diskant = {
 \set TabStaff.minimumFret = #4
 \set TabStaff.restrainOpenStrings = ##t
 \key g \major
 \repeat volta 2 {
  a'8^\markup { \bold {Am7} } 
  g' e' c'
  d'^\markup { \bold {D7} } 
  fis' a' c''
  b'8^\markup { \bold {Gj7} } 
  g' fis' d' 
  c'^\markup { \bold {Cj7} } 
  e' g' b'
  a'^\markup { \bold {&quot;F#m7b5&quot;} } 
  fis' e' c'
  b^\markup { \bold {Bm7} } 
  d' fis' a'
  b'^\markup { \bold {Em7} } 
  g' e' d'
  b^\markup { \bold {E7} } 
  d' e' gis'

  g'8^\markup { \bold {Am7} } 
  e' c' a
  fis^\markup { \bold {D7} } 
  a c' d'
  b8^\markup { \bold {Gj7} } 
  g fis d 
  c^\markup { \bold {Cj7} } 
  e g b
  a^\markup { \bold {&quot;F#m7b5&quot;} } 
  fis e c
  b,^\markup { \bold {Bm7} } 
  d fis a
  g^\markup { \bold {Em7} } 
  e d b,
  gis,^\markup { \bold {E7} } 
  b, d e gis


%% Am7 D7 Gj7 Cj7 - Fis°⁷ B7 Em7 E7

 % \bar &quot;|.&quot;
}}

%% Layout- bzw. Bildausgabe
\score {
  &lt;&lt;
    \new Voice  { 
      \clef &quot;treble_8&quot; 
      \time 4/4  
      \tempo 4 = 120 
      \set Score.tempoHideNote = ##t
      \Diskant 
    }
    \new TabStaff { \tabFullNotation \Diskant }
  &gt;&gt;
  \layout {}
}

%% Midiausgabe mit Wiederholungen, ohne Akkorde
\score {
  &lt;&lt;
    \unfoldRepeats {
      \new Staff  &lt;&lt;
        \tempo 4 = 120
        \time 4/4
        \set Staff.midiInstrument = #&quot;acoustic guitar (nylon)&quot;
        \clef &quot;G_8&quot;
        \Diskant
      &gt;&gt;
    }
  &gt;&gt;
  \midi {}
}
%% unterdrückt im raw=&quot;!&quot;-Modus das DinA4-Format.
\paper {
  indent=0\mm
  %% DinA4 = 210mm - 10mm Rand - 20mm Lochrand = 180mm
  line-width=180\mm
  oddFooterMarkup=##f
  oddHeaderMarkup=##f
  % bookTitleMarkup=##f
  scoreTitleMarkup=##f
}
&lt;/score&gt;

== Anwendung ==
Weder die D-Form, noch die Bm7-Form dürfte für dich als verschiebbare Akkordform geläufig sein. Von daher wird die Skala wohl nicht deine erste Wahl bei Stücken in Dur oder Moll sein. Der Akkord in der D-Form geht nicht unbedingt leicht von den Fingern. Zur Orientierung ist er daher nur bedingt geeignet. Es sei denn, die D-Form würde so liegen, dass man noch eine leere Saite im Bass ausnutzen kann. Das gelingt allerdings nur in wenigen Tonarten. 

Hier lohnt sich auch kein Ausflug in die Mollparallelen, denn die Moll-Parallele in der Bm7-Form wird eigentlich nur von den Jazzern angewandt.

Von daher wirst du am ehesten beim Wechseln von einer Nachbarskala (C- oder E|F-Form) in die D-Form hineinrutscht, was allerdings Stoff für eine der folgenden Lektionen sein wird.

== Übungsvorschlag ==
Verschiebe mal den D-Dur-Akkord zwei Bünde weiter. Wenn du die A- und die G-Saite auslässt (dämpfst) und nur die leere E-Saite im Bass hast, dann hast du einen E-Dur-Akkord. (E = 0xx454) Da wo der Ringfinger ist, da ist auch der Grundton (1) der E-Dur-Skala. Wandere davon die Skala abwärts.
*{{Youtube-Suche|axis+of+awesome+4+chords+with+song+titles|Awesome 4 Chords (Axis of Awesome)}}

Verschiebe mal den D-Dur-Akkord in den 7. Bund und du erhältst einen G/D (xx0787) Von dort aus arbeitest du dich jetzt rückwärts in die G-Dur-Tonleiter (D-Form), die vom 4. bis zum 8. Bund geht.
*{{Youtube-Suche|American+Pie+Don+McLean|American Pie (Don McLean)}}

* {{Youtube-Suche|Another+Four+Chords+Benny+Davis)|&quot;Another Four Chords&quot; von Benny Davis)}} (Millenium-Kadenz)

&lt;noinclude&gt;
{{Navigation zurückhochvor 
|zurücklink=Gitarre: CAGED-Stammtöne - Zweiter Fingersatz
|zurücktext=Stammtöne 2. Fingersatz 
|hochlink=#top
|hochtext=Hoch zum Seitenanfang
|vorlink=Gitarre: CAGED-Skala G-Dur-Form
|vortext=CAGED-Skala G-Dur-Form
}}
&lt;/noinclude&gt;</text>
      <sha1>jfu0x2eyie7fii723eok3j3j6pprj5t</sha1>
    </revision>
    <revision>
      <id>1092179</id>
      <parentid>1092169</parentid>
      <timestamp>2026-10-17T04:56:43Z</timestamp>
      <contributor>
        <username>Mjchael</username>
        <id>2222</id>
      </contributor>
      <comment>/* Quintfallsequenz */</comment>
      <origin>1092179</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="11475" sha1="l4rj4ffp52hna7taxn1r582pj87hsxr" xml:space="preserve">{{:Gitarre/ Navi|Sologitarre|

{{:Gitarre: Sologitarre/ Navi Improvisation in Dur und Moll}}|
img=Guitar 1.svg |bg=#F8f8f8|border=darkorange|color=dark|px=80|navi=Einführung in die Sologitarre}}

&lt;div class=&quot;noprint&gt;
&lt;small&gt;''Notitz wird nicht gedruckt!''&lt;/small&gt;
{{Notiz|Nein, du hast dich nicht verklickt! Wir beginnen mit der D-Form, wo sich der Lagewechsel des 3. Fingersatz noch nicht mit dem Lagewechsel zwischen der G-und H-Saite aufhebt. Wir folgen im Unterricht nicht der CAGED-Reihenfolge, sondern sinnigerweise dem Quintenzirkel.}}

&lt;/div&gt;
==Die D-Dur-Form==
{| border=&quot;1&quot; style=&quot;border-collapse:collapse&quot; cellpadding=&quot;3&quot;
! Intervalle || C-Dur-Tonleiter || Subdominante || Dominante
|- 
| [[Datei:Scala D-Typ.svg]] || [[Datei:C-Dur_Majorpattern_II.jpg]] || [[Image:Crd Form G.svg|150px]] || [[Image:Crd Form A Bb.svg|150px]]&lt;br&gt;&lt;small&gt;Hier ist A-Form stimmiger als Bb-Form.&lt;/small&gt;
|-
! Grundakkordform || Mollparallele || Subdominanten&amp;shy; parallele || Dominanten&amp;shy;parallele
|- 
| [[Image:Crd Form D.svg|150px]] || [[Image:Crd Form Bm7.svg|150px]]  || [[Image:Crd Form Em.svg|150px]] || [[Image:Crd Form Gm7.svg|150px]]&lt;br&gt;&lt;small&gt;eigentlich F#m7-Form&lt;/small&gt;
|}
;Zugrundeliegende Dur-Tonleiter
[[Datei:Scala D-Hm.svg|200px]]
;mit ihren Hauptakkorden
[[Datei:Crd D.svg|100px]] [[Datei:Crd G.svg|100px]] [[Datei:Crd A.svg|100px]] &lt;br&gt;
[[Datei:Crd Hm7 x20202.svg|100px]] [[Datei:Crd Em.svg|100px]] [[Datei:Crd Fism7 2x2222.svg|100px]] 

; Aufgabe:
Versuche die 6 Akkorde der Tonleiter in den Skalen zu entdecken. Sowohl die einfachen Akkorde in der D-Dur-Tonleiter, als auch die Barré-Formen in der Skala der D-Dur- bzw. Bm-Form.

=== G-Dur- bzw. E-Moll-Tonleiter  ===
;in der D-Dur- bzw. Bm-Moll-Form
[[Datei:Scala D-Typ.svg|mini|CAGED-Skala der D/Bm-Form im 4. und 5. Bund.]]

Die Skala beginnt mit dem dritten Fingersatz, der in den ersten übergeht. Der zweite Fingersatz am Schluss beginnt wegen dem Lagewechsel einen Bund später. Trotz der beiden Lagewechsel ist die Skala nicht ganz so schwer, wie andere Skalen mit Lagewechsel. 

&lt;score sound=&quot;1&quot; raw=&quot;1&quot;&gt;
\version &quot;2.20.0&quot;
\header {
  title = &quot;G-Dur- bzw. E-Moll-Tonleiter&quot;
  subtitle = &quot;in der D-Dur- bzw. Bm-Moll-Form.&quot;
  subsubtitle=&quot;reine Skala&quot;
}

Melody =  {
  \set Staff.midiInstrument = &quot;electric guitar (clean)&quot;
  \repeat volta 2 {  
    \stemUp
    \set TabStaff.minimumFret = #4
    \set TabStaff.restrainOpenStrings = ##t
 a,8 b, c-4 d-1 e-4 fis-1 g a |
 b8 c' d' e'-1 fis' g' a' b' |
 \break
 c''8 b' a' g' fis' e' d'-4 c' | 
 b8 a g fis-1 e-4 d-1 c-4 b, | a,1 |
 } 
 
}

Gitarre =  \Melody

\score {
  &lt;&lt;
    \new Voice  { 
      \clef &quot;treble_8&quot; \time 4/4  
      \tempo 4 = 100 \key g \major 
      \set Score.tempoHideNote = ##t
      \Gitarre 
    }
   \new TabStaff { \Gitarre }
  &gt;&gt;
  \layout { }
}
\score {
  &lt;&lt;
    \new Voice  { 
      \clef &quot;treble_8&quot; \time 4/4  
      \tempo 4 = 100 \key c \major 
      \unfoldRepeats \Gitarre 
    }
  &gt;&gt;
  \midi { }
}

\paper {
  indent=0\mm
  line-width=120\mm
  oddFooterMarkup=##f
  oddHeaderMarkup=##f
  % bookTitleMarkup=##f
  scoreTitleMarkup=##f
}
&lt;/score&gt;

== Eine II-V-I-Verbindung ==
Die ersten Teile kennst du schon aus den Vorübungen zum 3. Fingersatz. Um das Pattern voll zu bekommen wurden noch ein paar Töne hinzugefügt.
&lt;score sound=&quot;1&quot; raw=&quot;1&quot;&gt;
\version &quot;2.20.0&quot;
\header {
  title=&quot;G-Dur in der D-Form&quot;
  subtitle=&quot;Eine II-V-I-Verbindung&quot;
}
%% Diskant- bzw. Melodiesaiten
Diskant = \relative c {
  \set TabStaff.minimumFret = #4
  \set TabStaff.restrainOpenStrings = ##t
  \key g \major
  \repeat volta 2 {
    a8^\markup { \bold {Am7} } b c d-1 e-4 fis-1 g4 |
  fis8^\markup { \bold {D7} } e-4 d4-1 c8-4 b a4 |
  b8^\markup { \bold {G} } c d4-1 e8-4 
  fis-1  g4~| g1 | \break
  a8-4^\markup { \bold {Am7} } b c d-4 e-1 fis g4 |
  fis8^\markup { \bold {D7} } e-1 d4-4 c8 b a4 |
  b8^\markup { \bold {G} } c d4-4 e8-1 fis  g4~| g8 a b c b a g4 |

 % \bar &quot;|.&quot;
}}

%% Layout- bzw. Bildausgabe
\score {
  &lt;&lt;
    \new Voice  { 
      \clef &quot;treble_8&quot; 
      \time 4/4  
      \tempo 4 = 120 
      \set Score.tempoHideNote = ##t
      \Diskant 
    }
    \new TabStaff { \tabFullNotation \Diskant }
  &gt;&gt;
  \layout {}
}

%% Midiausgabe mit Wiederholungen, ohne Akkorde
\score {
  &lt;&lt;
    \unfoldRepeats {
      \new Staff  &lt;&lt;
        \tempo 4 = 120
        \time 4/4
        \set Staff.midiInstrument = #&quot;acoustic guitar (nylon)&quot;
        \clef &quot;G_8&quot;
        \Diskant
      &gt;&gt;
    }
  &gt;&gt;
  \midi {}
}
%% unterdrückt im raw=&quot;!&quot;-Modus das DinA4-Format.
\paper {
  indent=0\mm
  %% DinA4 = 210mm - 10mm Rand - 20mm Lochrand = 180mm
  line-width=180\mm
  oddFooterMarkup=##f
  oddHeaderMarkup=##f
  % bookTitleMarkup=##f
  scoreTitleMarkup=##f
}
&lt;/score&gt;

=== Quinten und Quarten ===
Quinten und Quarten bilden meist den Rahmenintervall eines Akkordes und sie werden beim Powerchord gebraucht. Nur der Tritonus (hier der Intervall zwischen C und Fis bei den Legato-Bögen) fällt etwas aus dem Rahmen.
&lt;score sound=&quot;1&quot; raw=&quot;1&quot;&gt;
\version &quot;2.20.0&quot;
\header {
  title=&quot;G-Dur in der D-Form&quot;
  subtitle=&quot;Quinten und Quarten&quot;
}
%% Diskant- bzw. Melodiesaiten
Diskant = \relative c' {
  \set TabStaff.minimumFret = #4
  \set TabStaff.restrainOpenStrings = ##t
  \key g \major
  \repeat volta 2 {
    c'8( fis,) b e, a d, 
    g c,( fis) b, e a, 
    d g, c( fis,) b e, 
    a d, g c,( fis) b,
    e a,~  a2
    a8 e' b fis'( c) g'
    d a' e b' fis( c')
    g d' a e' b fis'( 
    c) g' d a' e b' 
    fis( c')~ c2

 % \bar &quot;|.&quot;
}}

%% Layout- bzw. Bildausgabe
\score {
  &lt;&lt;
    \new Voice  { 
      \clef &quot;treble_8&quot; 
      \time 3/4  
      \tempo 4 = 120 
      \set Score.tempoHideNote = ##t
      \Diskant 
    }
    \new TabStaff { \tabFullNotation \Diskant }
  &gt;&gt;
  \layout {}
}

%% Midiausgabe mit Wiederholungen, ohne Akkorde
\score {
  &lt;&lt;
    \unfoldRepeats {
      \new Staff  &lt;&lt;
        \tempo 4 = 120
        \time 3/4
        \set Staff.midiInstrument = #&quot;acoustic guitar (nylon)&quot;
        \clef &quot;G_8&quot;
        \Diskant
      &gt;&gt;
    }
  &gt;&gt;
  \midi {}
}
%% unterdrückt im raw=&quot;!&quot;-Modus das DinA4-Format.
\paper {
  indent=0\mm
  %% DinA4 = 210mm - 10mm Rand - 20mm Lochrand = 180mm
  line-width=180\mm
  oddFooterMarkup=##f
  oddHeaderMarkup=##f
  % bookTitleMarkup=##f
  scoreTitleMarkup=##f
}
&lt;/score&gt;
=== Zwei vor einen zurück ===

&lt;score sound=&quot;1&quot; raw=&quot;1&quot;&gt;
\version &quot;2.20.0&quot;
\header {
  title=&quot;G-Dur in der D-Form&quot;
  subtitle=&quot;Zwei vor einen zurück&quot;
}
%% Diskant- bzw. Melodiesaiten
Diskant = \relative c' {
  \set TabStaff.minimumFret = #4
  \set TabStaff.restrainOpenStrings = ##t
  \key g \major
  \repeat volta 2 {
  a,8 b c b c d c d e d e fis | 
  e fis g fis g a g a b a b c |
  b c d c d e d e fis e fis g |
  fis g a g a b a b c b c4 | \break
  c8 b a b a g a g fis g fis e |
  fis e d e d c d c b c b a |
  b a g a g fis g fis e fis e d |
  e d c d c b c b a4.


 % \bar &quot;|.&quot; 
}}

%% Layout- bzw. Bildausgabe
\score {
  &lt;&lt;
    \new Voice  { 
      \clef &quot;treble_8&quot; 
      \time 6/8  
      \tempo 4 = 120 
      \set Score.tempoHideNote = ##t
      \Diskant 
    }
    \new TabStaff { \tabFullNotation \Diskant }
  &gt;&gt;
  \layout {}
}

%% Midiausgabe mit Wiederholungen, ohne Akkorde
\score {
  &lt;&lt;
    \unfoldRepeats {
      \new Staff  &lt;&lt;
        \tempo 4 = 120
        \time 3/4
        \set Staff.midiInstrument = #&quot;acoustic guitar (nylon)&quot;
        \clef &quot;G_8&quot;
        \Diskant
      &gt;&gt;
    }
  &gt;&gt;
  \midi {}
}
%% unterdrückt im raw=&quot;!&quot;-Modus das DinA4-Format.
\paper {
  indent=0\mm
  %% DinA4 = 210mm - 10mm Rand - 20mm Lochrand = 180mm
  line-width=180\mm
  oddFooterMarkup=##f
  oddHeaderMarkup=##f
  % bookTitleMarkup=##f
  scoreTitleMarkup=##f
}
&lt;/score&gt;
{{Todo|Attraktivere Übungen erstellen!|Mjchael|Sologitarre}}

== Quintfallsequenz==
{{Baustelle}}
Wir wandern Septim-Akkorde in Quinten herunter.
&lt;score sound=&quot;1&quot; raw=&quot;1&quot;&gt;
\version &quot;2.20.0&quot;
\header {
  title=&quot;G-Dur in der D-Form&quot;
  subtitle=&quot;Eine II-V-I-Verbindung&quot;
}
%% Diskant- bzw. Melodiesaiten
Diskant = {
 \set TabStaff.minimumFret = #4
 \set TabStaff.restrainOpenStrings = ##t
 \key g \major
 \repeat volta 2 {
  c'8^\markup { \bold {Am7} } 
  e' g' a'~2
  d'8^\markup { \bold {D7} } 
  fis' a' c''~2
  d'8^\markup { \bold {Gj7} } 
  fis' g' b'~2 
  c'8^\markup { \bold {Cj7} } 
  e' g' b'~2
  c'8^\markup { \bold {&quot;F#m7b5&quot;} } 
  e' fis' a'~2
  b8^\markup { \bold {Bm7} } 
  d' fis' a'~2
  b8^\markup { \bold {Em7} } 
  d' e' g'~2
  b8^\markup { \bold {E7} } 
  d' e' gis'~2

  a8^\markup { \bold {Am7} } 
  c' e' g'-2
  a8^\markup { \bold {D7} } 
  c' d' fis'~2
  g8^\markup { \bold {Gj7} } 
  b d' fis'~2 
  g8^\markup { \bold {Cj7} } 
  b c' e'~2
  fis8^\markup { \bold {&quot;F#m7b5&quot;} } 
  a c' e'~2
  fis8^\markup { \bold {Bm7} } 
  a b d'~2
  e8^\markup { \bold {Em7} } 
  g b d'~2
  e8^\markup { \bold {E7} } 
  gis b d'~2


%% Am7 D7 Gj7 Cj7 - Fis°⁷ B7 Em7 E7

 % \bar &quot;|.&quot;
}}

%% Layout- bzw. Bildausgabe
\score {
  &lt;&lt;
    \new Voice  { 
      \clef &quot;treble_8&quot; 
      \time 4/4  
      \tempo 4 = 120 
      \set Score.tempoHideNote = ##t
      \Diskant 
    }
    \new TabStaff { \tabFullNotation \Diskant }
  &gt;&gt;
  \layout {}
}

%% Midiausgabe mit Wiederholungen, ohne Akkorde
\score {
  &lt;&lt;
    \unfoldRepeats {
      \new Staff  &lt;&lt;
        \tempo 4 = 120
        \time 4/4
        \set Staff.midiInstrument = #&quot;acoustic guitar (nylon)&quot;
        \clef &quot;G_8&quot;
        \Diskant
      &gt;&gt;
    }
  &gt;&gt;
  \midi {}
}
%% unterdrückt im raw=&quot;!&quot;-Modus das DinA4-Format.
\paper {
  indent=0\mm
  %% DinA4 = 210mm - 10mm Rand - 20mm Lochrand = 180mm
  line-width=180\mm
  oddFooterMarkup=##f
  oddHeaderMarkup=##f
  % bookTitleMarkup=##f
  scoreTitleMarkup=##f
}
&lt;/score&gt;

== Anwendung ==
Weder die D-Form, noch die Bm7-Form dürfte für dich als verschiebbare Akkordform geläufig sein. Von daher wird die Skala wohl nicht deine erste Wahl bei Stücken in Dur oder Moll sein. Der Akkord in der D-Form geht nicht unbedingt leicht von den Fingern. Zur Orientierung ist er daher nur bedingt geeignet. Es sei denn, die D-Form würde so liegen, dass man noch eine leere Saite im Bass ausnutzen kann. Das gelingt allerdings nur in wenigen Tonarten. 

Hier lohnt sich auch kein Ausflug in die Mollparallelen, denn die Moll-Parallele in der Bm7-Form wird eigentlich nur von den Jazzern angewandt.

Von daher wirst du am ehesten beim Wechseln von einer Nachbarskala (C- oder E|F-Form) in die D-Form hineinrutscht, was allerdings Stoff für eine der folgenden Lektionen sein wird.

== Übungsvorschlag ==
Verschiebe mal den D-Dur-Akkord zwei Bünde weiter. Wenn du die A- und die G-Saite auslässt (dämpfst) und nur die leere E-Saite im Bass hast, dann hast du einen E-Dur-Akkord. (E = 0xx454) Da wo der Ringfinger ist, da ist auch der Grundton (1) der E-Dur-Skala. Wandere davon die Skala abwärts.
*{{Youtube-Suche|axis+of+awesome+4+chords+with+song+titles|Awesome 4 Chords (Axis of Awesome)}}

Verschiebe mal den D-Dur-Akkord in den 7. Bund und du erhältst einen G/D (xx0787) Von dort aus arbeitest du dich jetzt rückwärts in die G-Dur-Tonleiter (D-Form), die vom 4. bis zum 8. Bund geht.
*{{Youtube-Suche|American+Pie+Don+McLean|American Pie (Don McLean)}}

* {{Youtube-Suche|Another+Four+Chords+Benny+Davis)|&quot;Another Four Chords&quot; von Benny Davis)}} (Millenium-Kadenz)

&lt;noinclude&gt;
{{Navigation zurückhochvor 
|zurücklink=Gitarre: CAGED-Stammtöne - Zweiter Fingersatz
|zurücktext=Stammtöne 2. Fingersatz 
|hochlink=#top
|hochtext=Hoch zum Seitenanfang
|vorlink=Gitarre: CAGED-Skala G-Dur-Form
|vortext=CAGED-Skala G-Dur-Form
}}
&lt;/noinclude&gt;</text>
      <sha1>l4rj4ffp52hna7taxn1r582pj87hsxr</sha1>
    </revision>
  </page>
  <page>
    <title>Astronomie von der Frühgeschichte bis zur Neuzeit/ Mondzyklen</title>
    <ns>0</ns>
    <id>114818</id>
    <revision>
      <id>1092181</id>
      <parentid>1088822</parentid>
      <timestamp>2026-10-17T09:49:51Z</timestamp>
      <contributor>
        <username>Bautsch</username>
        <id>35687</id>
      </contributor>
      <comment>/* Siderischer Monat */ versus tropischer Monat</comment>
      <origin>1092181</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="121451" sha1="4n2ouaogm74nlzju5g9ckt2vz13vpbu" xml:space="preserve">[[Datei:Mondfinsternis.7.9.2025.20.46MESZ.Berlin.png|mini|rechts|hochkant=2|Ein bei Vollmond während einer Mondfinsternis im Kernschatten der Erde befindlicher Blutmond nach Mondaufgang von Berlin aus gesehen am 7. September 2025.]]

== Monat ==
Die Bezeichnung '''Monat''' stammt etymologisch von unserem Erdmond ab. Es handelt sich um ein Erbwort, das auf die seit dem 8.&amp;nbsp;Jahrhundert bezeugten althochdeutschen Formen ''mānōd'' beziehungsweise ''mānōth'' zurückgeht. Diese wiederum stammen vom indoeuropäischen Wort ''mēnōt'' ab, das sowohl ''Monat'' als auch ''Mond'' bedeuten kann.&lt;ref&gt;[https://indogermanisch.org/pokorny-etymologisches-woerterbuch/m%C4%93n%C5%8Dt_gen_m%C4%93neses_woraus_m%C4%93nes-_m%C4%93ns-_m%C4%93s-_m%C4%93n.htm mēnōt], Pokorny - Indogermanisches etymologisches Wörterbuch&lt;/ref&gt;

== Die Naturgeschichte von Plinius dem Älteren ==
'''Gaius Plinius Secundus''' (&quot;der Ältere&quot;) hat im ersten nachchristlichen Jahrhundert über den '''Mond''' geschrieben. Das neunte Kapitel des zweiten Buches aus dem ersten Band hat den Titel ''Von der Natur des Mondes''. Über den Mond schreibt Plinius Folgendes:&lt;ref name=&quot;Denso1764&quot;&gt;Plinius: ''Naturgeschichte'', erster Band, zweites Buch, neuntes Kapitel: ''Von der Natur des Mondes'', übersetzt von Johann Daniel Denso (1708–1795), Rostock und Greifswald, Anton Ferdinand Rösens Buchhandlung, 1764, in moderne deutsche Sprache gesetzt.&lt;/ref&gt;

&lt;blockquote&gt;
Aber alle diese [Wandelgestirne] übertrifft an Bewunderungswürdigkeit das Gestirn des '''Mondes''', das niedrigste, der Erde bekannteste, und zur Verminderung der Finsternis erfunden. Dieser hat durch seinen Wandel und veränderte Gestalt, da er beständig zu- und abnimmt, den Witz seiner Beobachter gequält, die es sich für einen Schimpf hielten, wenn man das nächste Gestirn nicht kennen sollte. Ja er ist auch in Spitzen gekrümmt, bald gerade halbgeteilt, bald in eine ganze Scheibe gebogen, bald, da er einem dunkeln Flecken ähnlich war, scheint er plötzlich hervor, und ist ist er ohne Grenzen rund und voll, ist gar nicht zu sehen. Bald scheint er die ganze Nacht durch, bald geht er spåt auf, und verstärkt noch bei Tage den Schein der Sonne. Er wird verfinstert, und lässt sich auch in der Verfinsterung noch sehen. Beim Ausgang des Monats sieht man ihn nicht, und man glaubt nicht, dass er alsdenn verfinstert werde.&lt;br/&gt;
Bald steht er niedrig, bald erhaben, und auch dies nicht auf eine Art. Bald steht er in der Höhe des Himmels, bald reicht er an die Berge: jetzt steht er hoch gegen Norden, bald tief gegen Süden herunter. Alles dies hat '''Endymion''' unter allen Menschen an ihm zuerst wahrgenommen, und deswegen ist die Sage, dass dieser in ihm verliebt gewesen sei. Wir sind wahrlich gegen diejenigen, welche uns zuerst bei diesem Himmelslicht durch ihre Arbeit und Sorge ein Licht aufgesteckt haben, nicht dankbar. Es ist ein wunderbares Verderben des menschlichen Witzes, dass wir ein Vergnügen daran finden, Blutvergießen und Mord in unsern Jahrbüchern aufzuzeichnen, damit die, welche die Welt nicht kennen, doch von unsern Lastern wissen mochten.&lt;br/&gt;
Doch aber da der Mond der Weltachse am nächsten steht, und also den engsten Umlauf hat, so durchlauft er in 27 und 1/3 Tag eben den Raum, welchen der höchste Stern des Saturns, wie gesagt ist, in dreißig Jahren zurücklegt. Hiernächst hält er sich in der Zusammenkunft mit der Sonne zwei Tage, wenn es am langsamsten geschieht, aus, und geht mit dem dreißigsten Tag zu seinen vorigen Abwechselungen wieder hervor. Ich weiß nicht, ob er nicht unter allen am Himmel der einzige Lehrmeister gewesen sei, dass man das Jahr in einen Raum von zwölf Monaten einteilen müsse, denn ebenso oft folgt er der Sonne, wenn sie zu einem neuen Zeichen zurückkehrt.&lt;br/&gt;
Er wird, wie die übrigen Sterne vom Sonnenlicht verdeckt. Denn wir sehen, dass er von derselben sein Licht gänzlich entlehne, und damit dergestalt leuchte, als wenn wir ihr zurückprallendes Licht in einem Wasser schweben sehen. Da er die Feuchtigkeit mit sanfterer und unvollkommener Kraft auflöst, auch wohl vermehrt, welche die Strahlen der Sonne verzehren. Hierher kommt es auch, dass man ihn in ungleichem Licht sieht, dass er alsdenn nur voll ist, wenn er der Sonne gerade gegenübersteht, in den übrigen Tagen nur so viel desselben, als er von jener empfängt, auf seiner Scheibe zeigt. Wenn er mit der Sonne zusammenkommt, kann man ihn nicht sehen, weil er uns die dunkle Seite zukehrt, und alles Geschöpfte dorthin, woher er es empfangen hat, wieder zurückwirft.&lt;br/&gt;
Es scheint außer Zweifel gesetzt zu sein, dass die Gestirne ihre Nahrung von der Feuchtigkeit der Erde haben. Denn er wird auf der einen Hälfte seiner Scheibe oft voller Flecken gesehen, weil er etwa noch nicht Kraft genug hat, mehr als ihm dienlich ist, an sich zu ziehen. Seine Flecken sind gewiss nichts anderes, als die mit der Feuchtigkeit von der Erde mit fortgerissenen Unreinigkeiten.&lt;br/&gt;
&lt;/blockquote&gt;
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

== Mondperioden ==
Die zu beobachtende scheinbare Mondbahn kann im Verlauf verschiedener Perioden durch zahlreiche '''Mondzyklen''' beschrieben werden. Die kürzesten Zyklen dauern ungefähr einen Monat im Sonnenkalender, sie längeren Mondzyklen können aber auch mehrere Jahre umfassen.

Der Mond hat ähnlich wie die Sonne einen scheinbaren Winkeldurchmesser von ungefähr 30&amp;nbsp;Bogenminuten beziehungsweise 0,5&amp;nbsp;Bogengrad. Dies entspricht bei Betrachtung des eigenen Fingers mit ausgestrecktem Arm in etwa einem Viertel der Fingerdicke.

===Synodischer Monat===
[[Datei:Courtenay.Mondsichel.P1033938.png|mini|Altlicht beim Morgenletzt des Mondes (heliakischer Aufgang) über dem östlichen Horizont auf Vancouver Island kurz nach der Tag-und-Nachtgleiche im September 2019.]]
[[Datei:Neulicht.37Tauri.P1138734.jpg|mini|Neulicht beim Abenderst des Mondes (akronychischer Untergang) über dem westlichen Horizont in Berlin Anfang Mai 2022.]]

Der synodische Monat ist durch den Verlauf der Elongation des Mondes in Bezug zur Sonne beschrieben.

Der Mond umrundet die Erde ungefähr zwölfmal schneller als die Erde die Sonne und benötigt für einen Umlauf einen Monat. Die einfachste Wahrnehmung des Mondlaufs ergibt sich durch die Beobachtung der Mondphasen beziehungsweise der Elongationen des Mondes. Der '''synodische Monat''' (altgriechisch ''σύνοδος'' (''synodos'') = ''Zusammentreffen'') beschreibt die Dauer zwischen zwei gleichen Mondphasen, also von Neumond zu Neumond beziehungsweise von Vollmond zu Vollmond. Hier wird gemeinhin das Zusammentreffen von Neumond und Sonne am Himmel als Referenzzeitpunkt betrachtet. Ein synodischer Monat dauert etwa 29,53&amp;nbsp;Tage, und zwölf synodische Monate dauern demzufolge rund 354,37&amp;nbsp;Tage - das sind gut fünfeinhalb Tage weniger als 360. Dieser Zyklus ist dies Basis für die gängigen Mondkalender (Lunarkalender) mit der gegenüber dem am Sonnenjahr orientierten Solarkalender um zirka 11&amp;nbsp;Tagen kürzeren Jahreslänge. Bei Lunisolarkalendern wird durchschnittlich alle drei Jahre ein dreizehnter synodischer Monat eingeschaltet, damit der Frühlingspunkt der Sonne ungefähr in der gleichen Jahreszeit bleibt.

→ Zur Zahl Zwölf siehe auch [[Quadriviale Kuriositäten‎/ Zahlen#Zur Zwölf|Exkurs '''Zur Zwölf''']].

[[Datei:Horusauge.Faltung.png|mini|rechts|hochkant=2|Das altägyptische Horusauge als Folge von Rechtecken mit jeweils der Hälfte der Fläche des Vorgängers in einem Rechteck mit dem Flächeninhalt eins.]]
[[Datei:Dendera_Deckenrelief_03.JPG|mini|hochkant=2|Deckenrelief im altägyptischen Tempel von Dendera mit der Darstellung von 15&amp;nbsp;Mondphasen von links (Neumond) nach rechts (Vollmond) mit den Göttern Junit, Sopdet-Tjenenet, Hor-Behdeti, Hathor, Nephthys, Harsiese, Isis, Osiris, Nut, Geb, Tefnut, Schu, Atum und Month. Im Vollmond vor dem Gott des Mondes Thot ist das von ihm geheilte linke Auge („Mondauge“) des Lichtgottes Horus dargestellt.]]

Die Ägypter haben ihre Kalender nicht mit einer Siebentagewoche, sondern sowohl mit einer Fünftagewoche als auch mit einer Zehntagewoche geführt. Damit besteht ein synodischer Monat auf weniger als einen halben Tag genau aus sechs Fünftagewochen beziehungsweise aus drei Zehntagewochen. Es wird in der Literatur manchmal darauf hingewiesen, dass das Verhältnis der Länge eines synodischen Monats zu dreißig vollen Tagen

:&lt;math&gt;\frac {29,530589 \text{d}} {30 \text{d}} = 0,984353&lt;/math&gt;

fast identisch mit dem folgenden Verhältnis ist (siehe auch Horusauge und Heqat in der altägyptischen Geschichte&lt;ref&gt;Donald Frazer: ''Hieroglyphs and Arithmetic of the Ancient Egyptian Scribes'', Kapitel 2.6.5 ''Hekat Fractions and Ro'', Xlibris Corporation, 2012, ISBN 9781469136462&lt;/ref&gt;):

:&lt;math&gt;\frac {1} {2} + \frac {1} {4} + \frac {1} {8} + \frac {1} {16} + \frac {1} {32} + \frac {1} {64}&lt;/math&gt;

:&lt;math&gt;= \frac {32} {64} + \frac {16} {64} + \frac {8} {64} + \frac {4} {64} + \frac {2} {64} + \frac {1} {64}&lt;/math&gt;

:&lt;math&gt;= \frac {63} {64} = \frac {2^6 - 1} {2^6} = 1 - 2^{-6} = 0,984375&lt;/math&gt;

Die Abweichung der beiden Verhältnisse beträgt nur 0,022&amp;nbsp;Promille. Erst nach rund 44700&amp;nbsp;Monaten oder 3700&amp;nbsp;Jahren hat sich diese Abweichung auf einen Tag aufsummiert.

Die verschiedenen Mondphasen waren für die Menschen schon immer sichtbar und konnten im Laufe eines synodischen Monats verfolgt werden. Es wird davon ausgegangen, dass zum Beispiel auch auf der Himmelsscheibe von Nebra mindestens eine Mondsichel dargestellt ist, eventuell auch der Vollmond und nach dem österreichischen Ur- und Frühgeschichtler '''Paul Gleirscher''' zusätzlich das Altlicht des Mondes:&lt;ref&gt;Paul Gleirscher: [https://dialnet.unirioja.es/servlet/articulo?codigo=4142096 Zum Bildprogramm der Himmelsscheibe von Nebra: Schiff oder Sichel?], Germania: Anzeiger der Römisch-Germanischen Kommission des Deutschen Archäologischen Instituts, Band 85, Nummer 1, ISSN 0016-8874, Seiten 23 bis 33, 2007&lt;/ref&gt;

&lt;gallery caption=&quot;Verschiedene möglicherweise auf der Himmelsscheibe von Nebra dargestellte Mondphasen&quot; perrow=&quot;2&quot; widths=&quot;300&quot; heights=&quot;300&quot;&gt;
Vollmond.P1080516.jpg|Ein im Dezember um Mitternacht fast im Zenit stehender, sehr heller Vollmond.
Zunehmende.Mondsichel.png|Ein zunehmender Mond drei Tage nach Neumond beim akronychischen Untergang am westlichen Abendhimmel drei Wochen vor der Tag-und-Nacht-Gleiche im Herbst. Die rötliche Färbung entstand genauso wie bei der untergehenden Sonne durch die Rayleigh-Streuung in der Erdatmosphäre.
Altlicht.3.Nov.2021.P1116624.jpg|Das Altlicht eines abnehmenden Mondes (Morgenletzt, vier Prozent beleuchtet) beim heliakischen Aufgang am südöstlichen Morgenhimmel der nördlichen Hemisphäre während der bürgerlichen Dämmerung einen Monat nach der Tag-und-Nacht-Gleiche im Herbst mit Erdschein.
Nebra_Scheibe_Modell.jpg|Vollständig rekonstruiertes Modell der bronzenen und mit Gold tauschierten Himmelsscheibe von Nebra.
&lt;/gallery&gt;

===Siderischer Monat===
Der '''siderische Monat''' ist durch den Verlauf der ekliptikalen Länge des Mondes in Bezug zum Frühlingspunkt einer astronomischen Epoche definiert und beschreibt die Zeitspanne, nach der der Mond die gleiche ekliptikale Länge erreicht hat. Da sich er Frühlingspunkt gegenüber dem Fixsternhimmel entlang der Ekliptiklinie verschiebt, ist der siderische Monat vom '''tropischen Monat''' zu unterscheiden. Letzterer bezieht sich ebenfalls auf den Frühlingspunkt des aktuellen Datums, also nicht den, der zu einem bereits vergangenen Referenzzeitpunkt des Datums einer bestimmten astronomischen Epoche gegolten hat. Zur Zeit wird hierfür meist die Julianische Standardepoche J2000.0 verwendet, die sich auf die Uhrzeit 11:58:55,8 UTC am 1. Januar 2000 um bezieht. Bezogen auf diese Standardepoche dauert der tropische Monat 27,32158&amp;nbsp;Tage. Durch die langsame gegenläufige Wanderung des Frühlingspunkts besteht ein kleiner Unterschied zwischen tropischem und siderischem Monat, der mit 27,32166&amp;nbsp;Tage geringfügig länger ist. Die Differenz von 0,00008&amp;nbsp;Tagen entspricht einer Abweichung von von lediglich sieben Sekunden. Dies bedeutet, dass der Mond den aktuellen Frühlingspunkt nach einer Umrundung der Erde sieben Sekunden früher erreicht als einen Stern (lateinisch ''sideris'' = ''des Sterns'') der sich am Anfang der Umrundung noch beim alten Frühlingspunkt befunden hatte.

Es kann auch die Zeitspanne betrachtet werden, in der der Mond in Bezug auf den Fixsternhimmel entlang der Ekliptik wieder an einer beliebigen gleichen Stelle erscheint. Dies ist also auch die Dauer zwischen zwei aufeinanderfolgenden Erscheinungen des Mondes im '''Goldenen Tor der Ekliptik''', da dessen Lage durch Sterne des Fixsternhimmels bei einer bestimmten ekliptikalen Länge bestimmt ist.

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der_Ekliptik|Exkurs '''Das Goldene Tor der Ekliptik''']].

Die Einteilung der 360 Bogengrad langen Ekliptik in 28 gleiche Teile ist in der Bronzezeit verbreitet gewesen. Daraus ergibt sich ein grobes Koordinatenraster für die ekliptikale Länge des Mondes.

Auf der '''Stachelscheibe von Platt''' aus der Bronzezeit (um 1500 vor Christus) werden die 28&amp;nbsp;Mondorte der Tage eines Monats beispielsweise durch eine Kreisreihe dargestellt. Die Hohlform diente zur Herstellung von Schmuckscheiben und hat insgesamt sieben konzentrische Kreise. Davon bestehen zwei aus 12&amp;nbsp;(innen) beziehungsweise aus 28&amp;nbsp;(außen) gleichmäßig verteilten Mulden.&lt;ref&gt;Irene Hager und Stefan Borovits (Wien, Österreich): ''Der Vorläufer einer Oktaëteris auf dem Kalenderstein bei Leodagger/Pulkau?'', Kapitel 26.2.2 ''Astronomisch/kalendarische &quot;Zählmaschinen&quot; aus der Bronzezeit'', in: Gudrun Wolfschmidt (Herausgeberin): ''Orientierung, Navigation und Zeitbestimmung - Wie der Himmel den Lebensraum des Menschen prägt'', Proceedings der Tagung der Gesellschaft für Archäoastronomie in Hamburg 2017, Band 42 von Nuncius Hamburgensis - Beiträge zur Geschichte der Naturwissenschaften, Verlag tredition, 2019, ISBN 9783749767717&lt;/ref&gt; Die zwölf inneren Mulden entsprechen entlang der Ekliptik den 12&amp;nbsp;Sonnenorten (Monaten) in einem tropischen Jahr beziehungsweise den 12&amp;nbsp;Jupiterorten (Jahren) in zwölf Jahren. Die 28&amp;nbsp;äußeren Mulden entsprechen entlang der Ekliptik den 28&amp;nbsp;Mondorten (respektive Mondhäusern beziehungsweise Mondstationen) und somit den Tagen in einem siderischen Monat. Der große kreisförmige Stachel im Zentrum der Scheibe könnte als Symbol für die Sonne stehen. Auf ihm konnte die Scheibe von unten zentrisch und drehbar gelagert werden. Mit der Scheibe konnte (abgesehen von den erforderlichen siderischen Schaltmonaten) zwölf Jahre lang in täglich wechselnden Kombinationen in den beiden Lochreihen die Lagen von Mond und Jupiter abgelesen und markiert werden. Damit konnte nach einer Einmessung der Ost-West-Richtung zum Beispiel bei der Tag-und-Nacht-Gleiche zur Jupiterrichtung im Frühlingspunkt der gesamte Lebewesenkreis (Zodiak) jederzeit mit dem täglich ein Mondhaus weiterwandernden Mond vollständig bestimmt werden, auch ohne dass der Jupiter sichtbar sein musste. Mit dieser Information ist es dann auch ohne weiteres möglich, das nicht sichtbare Lebewesenzeichen zu bestimmen, in welchem die Sonne sich aufhält.

Im der indischen Astronomie wurden zu diesem Zweck spätestens 500&amp;nbsp;Jahre danach die '''27&amp;nbsp;Mondhäuser''' (oder Mondstationen) eingeführt. Da sich die siderische und die synodische Periode um gut zwei Tage unterscheiden, liegen aufeinanderfolgende Neumonde oder Vollmonde in verschiedenen Mondhäusern, nach denen im hinduistischen Lunisolarkalender die Monate benannt werden.

Dieses System wurde etwas später von den Arabern mit '''28&amp;nbsp;Mondhäusern''' modifiziert. Das '''erste Mondhaus''' liegt bei beiden Einteilungen im Frühlingspunkt in der Epoche um Christi Geburt im '''Kopf des Lammes''' beziehungsweise des Widders (Aries) bei den nördlich der Ekliptik liegenden Sternen Scheratan und Hamal (indisch ''Ashvini'' = ''die beiden Rosseschirrenden'' und arabisch ''aš-šaraṭān'' = ''Die beiden Zeichen''). Für das '''zweite Mondhaus''' folgt der '''Bauch des Lammes''' (indisch ''Bharani'' = ''der Wegtragende'' und arabisch ''al-buṭayn'' = ''das Bäuchlein''). Die Plejaden (indisch ''Krittika'' und arabisch ''aṯ-ṯurayyā'') im fetten '''Schwanz des Lammes''' markieren im Anschluss das '''dritte Mondhaus'''. Das '''vierte Mondhaus''' ist durch den roten Riesenstern Aldebaran (arabisch ''al-dabarān'' = ''der Nachfolgende'', indisch ''Rohini'' = ''der Rötliche'') im Sternbild Stier (Taurus) gekennzeichnet.

&lt;gallery caption=&quot;Mondstationen&quot; mode=&quot;packed&quot; widths=&quot;600&quot; heights=&quot;600&quot;&gt;
Mondhaeuser.Ekliptik.zirkular.png|Die in eine ringförmige Darstellung projizierten 28&amp;nbsp;Mondhäuser (von 1 bis 28 entgegen dem Uhrzeigersinn) mit den wichtigsten Sternen entlang der Ekliptik (rote gestrichelte Linie '''zur Epoche J0000.0'''). Der Beobachter befindet sich auf der Erde im Zentrum der Darstellung. Nach innen werden die südlichen und nach außen die nördlichen ekliptikalen Breiten gemessen. Die scheinbare Mondbahn pendelt zwischen den beiden zur Ekliptikline benachbarten Hilfslinien. Der Abstand der Hilfslinien beträgt senkrecht zur Ekliptiklinie immer fünf Bogengrad und entlang der Ekliptiklinie immer knapp dreizehn Bogengrad. Mit bis zum Nordpol zunehmender geographischer Breite des Beobachtungspunktes können auch noch knapp ein Bogengrad südlichere ekliptikale Breiten von der Mondscheibe erreicht werden, am Südpol auch noch entsprechend nördlichere ekliptikale Breiten.
Stachelscheibe_Model_zweiseitig.jpg|Die in Niederösterreich gefundene und aus Sandstein gefertigte Gussform für die '''Stachelscheibe von Platt'''.&lt;br/&gt;Von innen nach außen gibt es '''sieben''' konzentrische Kreise, die folgendermaßen zugeordnet werden können:&lt;br/&gt;- Eine große zentrische Bohrung (im Gussteil eine große stachelartige Erhebung für die '''Sonne''').&lt;br/&gt;- Zwölf gleichmäßig verteilte kleine Bohrungen (Zodiak mit '''zwölf''' Sternzeichen sowie für die Umlaufzeit des Planeten '''Jupiter '''in Jahren).&lt;br/&gt;- Drei äquidistante Kreislinien (die drei inneren Planeten '''Merkur''', '''Venus''' und '''Mars''').&lt;br/&gt;- Achtundzwanzig gleichmäßig verteilte kleine Bohrungen ('''Mond'''häuser).&lt;br/&gt;- Ein großer abschließender Kreis ('''Saturn''' als der Langsame und Beständige).
Stonehenge_phase_one.jpg|Die älteste belegte kreisförmige Struktur in Stonehenge&amp;nbsp;1 (zirka 3100 bis 2900 vor Christi) besteht aus den 56&amp;nbsp;Aubrey-Löchern (in der Abbildung weiße Kreise). Diese können unter Verwendung von Quadranten, die geographisch durch die vier Himmelsrichtungen in jeweils 14 Mondstationen geteilt sind, dazu verwendet worden sein, die ekliptikale Länge des Mondes in Bezug zum Frühlingspunkt oder zum Herbstpunkt beziehungsweise in Bezug zur Jupiterposition täglich zu markieren (der Mond erreicht den Jupiter ungefähr alle 27,5 Tage). In dieser Zählung wären alle 28 Mondhäuser halbiert, in eine Tagesstation und eine Nachtstation.
&lt;/gallery&gt;

Zwischen dem dritten und vierten Mondhaus liegt das Goldene Tor der Ekliptik, wo der Frühlingspunkt zu Beginn der maltesischen Tarxien-Phase lag. Man beachte die fehlenden helleren ekliptiknahen Sterne im '''Trichter der Thuraya''' westlich davon, also rechts der Plejaden (ekliptikale Länge ungefähr 32&amp;nbsp;Bogengrad) bis hin zum Stern Hydor heutigen Sternbild Wassermann (Aquarius, ekliptikale Länge ungefähr 314&amp;nbsp;Bogengrad). Die hellsten ekliptiknahen Sterne in diesem Gebiet des Sternenhimmels Alpherg im Sternbild Fische (Pisces) sowie Hydor und Ancha im Sternbild Wassermann (Aquarius) erreichen lediglich die vierte Größenklasse (4&lt;sup&gt;m&lt;/sup&gt;), so dass zwischen dem auffälligen offenen Sternhaufen der Plejaden und Deneb Algedi, dem hellsten Stern im Sternbild Steinbock (Capricornus), auf einer Länge von 90&amp;nbsp;Bogengrad keine hellen ekliptiknahen Sterne vorhanden sind.

→ Zur Einteilung der Ekliptik nach den monatlichen Mondstationen siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Mondhäuser|Exkurs '''Mondhäuser''']]

→ Zum dunklen Himmelsquadranten entlang der Ekliptik siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Trichter_der_Thuraya|Exkurs '''Der Trichter der Thuraya''']]

===Drakonitischer Monat===
[[Datei:Drakonitischer.Monat.png|rechts|mini|hochkant=2|Schematische Darstellung der Mondbahn (gelb) im Laufe eines drakonitischen Monats in Bezug auf die Ekliptiklinie (rot). Nach dem Erreichen der südlichsten Lage in Bezug zur Ekliptiklinie wird die Mondbahn aufsteigend, und von der nördlichsten Lage in Bezug auf die Ekliptiklinie wird die Mondbahn dann wieder absteigend. In der deutschsprachigen Schweiz gibt es für diese im Laufe eines drakonitischen Monats täglich mehr oder weniger deutlich wahrnehmbaren Änderungen der ekliptikalen Breite sogar eigene Adjektive. Das Ansteigen der ekliptikalen Breite des Mondes nach Norden wird '''obsigend''' und das Abfallen des Mondes nach Süden '''nidsigend''' genannt. Direkt auf der Ekliptik befinden sich der aufsteigende und der absteigende Knoten der Mondbahn.]]

Der drakonitische Monat ist durch den Verlauf der ekliptikalen Breite des Mondes in Bezug zur Ekliptiklinie beschrieben.

Deswegen gibt es noch den '''drakonitischen Monat''' (altgriechisch ''δράκων'' (''drakon'') beziehungsweise lateinisch ''draco'' = ''Drache''), der eine Dauer von 27,212 Tagen hat. Diese Dauer beschreibt die Zeitpunkte, an denen die um gut 5&amp;nbsp;Bogengrad zur Ekliptik geneigte Mondbahn die Ekliptik kreuzt; die ekliptikale Breite des Mondes ist dann exakt null. Diese Schnittpunkte werden Mondknoten genannt und werden einmal im Monat im aufsteigenden Mondknoten und einmal im absteigenden Mondknoten erreicht. Befindet sich der Mond auf der Ekliptik, also in der Nähe dieser Mondknoten, kommt es bei dessen Sonnennähe (wenn der Neumond also in Konjunktion mit der Sonne steht) zu einer Sonnenfinsternis und bei dessen Sonnenferne (wenn der Vollmond also in Opposition zur Sonne steht) zu einer Mondfinsternis. Diese Mondpunkte wurden früher als Drachenpunkte bezeichnet, was sich aus der Vorstellung ableitete, dass ein Drache bei einer Mondfinsternis den Mond beziehungsweise bei einer Sonnenfinsternis die Sonne verschlingen würde.

Mit dem folgenden Java-Programm können die ekliptikalen Koordinaten der Sonne und des Mondes für jeden beliebigen Zeitpunkt eines Julianischen Datums in Julianischen Jahrhunderten in Bezug auf die astronomische Standardepoche J2000 berechnet werden:

'''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/ EkliptikaleKoordinatenMondSonne|→ Java-Programm &quot;EkliptikaleKoordinatenMondSonne&quot;]]'''&lt;ref&gt;Unter Verwendung der Formeln aus: Oliver Montenbruck, Thomas Pfleger: ''Astronomie mit dem Personal Computer'', Springer-Verlag Berlin Heidelberg GmbH, 1989, ISBN 978-3-662-05865-7&lt;/ref&gt;

[[Datei:Ekliptikale.Breiten.Mond.siderischer.Monat.png|links|mini|hochkant=4|Die ekliptikalen Breiten des Mondes im Verlauf eines drakonitischen Monats beziehungsweise eines nur gut zweieinhalb Stunden längeren siderischen Monats mit gut 27 Tagen.]]

{| class=&quot;wikitable&quot;
|+ Die täglichen Änderungen der ekliptikalen Breite des Mondes in Bogengrad innerhalb eines Mondviertels
!title=&quot;Tage nach aufsteigendem Knoten&quot;| Tage nach&lt;br/&gt;aufsteigendem&lt;br/&gt;Knoten
!title=&quot;Änderung der ekliptikalen Breite&quot;| Änderung der&lt;br/&gt;ekliptikalen Breite&lt;br/&gt;zum Vortag
|-
| 1 || 1,2°
|-
| 2 || 1,1°
|-
| 3 || 1,0°
|-
| 4 || 0,9°
|-
| 5 || 0,6°
|-
| 6 || 0,3°
|-
| 7 || 0,0°
|}
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

Der Mond kann auf seiner Bahn im Laufe der Zeiten alle ekliptiknahen Himmelsobjekte inklusive aller Planeten und der Sonne bedecken und innerhalb einer Stunde wieder freigeben, die sich in einem Band bis zu gut ±5&amp;nbsp;Bogengrad nördlich oder südlich neben der Ekliptiklinie befinden.

'''{{w|Aristoteles}}''' (384 bis 322) hat dies in seiner Schrift '''&quot;Über den Himmel&quot;''' (altgriechisch: ''Περὶ οὐρανοῦ'' / ''Peri uranu'') anhand der von ihm beobachteten '''Bedeckung des Planeten Mars durch den zunehmenden Halbmond in der Nähe des Sterns Regulus''' (α Leonis) beschrieben und darauf hingewiesen, dass die Babylonier und die Ägypter solche Phänomene über lange Zeit beobachtet und dokumentiert hatten.&lt;ref&gt;Aristoteles: [http://classics.mit.edu/Aristotle/heavens.2.ii.html On the Heavens], Teil 12, Buch II, um 350 vor Christus, ins Englische übersetzt von John Leofric Stocks (*&amp;nbsp;1882; †&amp;nbsp;1937)&lt;/ref&gt;

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Aristotelische Mars-Konjunktion|Abschnitt '''Aristotelische Mars-Konjunktion''']].

Der ekliptiknahe Hauptstern Pollux im Sternbild Zwillinge (Gemini) hat sich aufgrund seiner Eigenbewegung im Laufe der letzten zehntausend Jahre so weit von der Ekliptiklinie entfernt, dass er inzwischen nicht mehr vom Mond bedeckt werden kann.

→ Für helle ekliptiknahe Objekte siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Der_Fixsternhimmel#Die_sieben_hellsten_Objekte_der_Ekliptik|Abschnitt '''Die sieben hellsten Objekte der Ekliptik''']].

===Siderische Mondperioden===
Der Mond erscheint innerhalb eines tropischen Jahres dreizehn- oder vierzehnmal an einer bestimmten Stelle des Fixsternhimmels, wobei er wegen der unterschiedlichen Periodendauern von siderischen und synodischen Monaten immer ein anderes '''Mondalter''' (die Anzahl der Tage seit dem letzten Neumond) und wegen der unterschiedlichen Periodendauern von siderischen und drakonitischen Monaten immer eine andere ekliptikale Breite aufweist.

Die beiden folgenden Diagramme sollen den zeitlichen Verlauf der Mondphasen und der ekliptikalen Breiten des Mondes bei seinem Erscheinen im Goldenen Tor der Ekliptik während 254 aufeinanderfolgender siderischer Perioden mit jeweils 27,322&amp;nbsp;Tagen (insgesamt 6940&amp;nbsp;Tage beziehungsweise 19&amp;nbsp;Jahre) veranschaulichen:

[[Datei:Mondphasen.siderische.Perioden.png|links|mini|hochkant=4|Die Mondphasen bei aufeinanderfolgenden Erscheinungen des Mondes im Goldenen Tor der Ekliptik innerhalb von 254 siderischen Perioden (insgesamt 19&amp;nbsp;Jahre). Da der synodische Monat (von Neumond zu Neumond) über zwei Tage länger ist als der siderische Monat, kommt es hierbei zu Verschiebungen, weil der Mond nach Ablauf eines siderischen Monats beim Erreichen derselben ekliptikalen Länge noch nicht ganz wieder sein maximales Mondalter erreicht hat.&lt;br/&gt;&lt;br/&gt;In der oberen Hälfte des Diagramms sind zunehmende und in der unteren Hälfte abnehmende Monde zu beobachten. Eine Mondphase von 0 Prozent steht für einen Neumond und eine Mondphase von ±100 Prozent für einen Vollmond.&lt;br/&gt;&lt;br/&gt;Der Startpunkt (Tag&amp;nbsp;0 im Monat&amp;nbsp;0) kann zum Beispiel mit dem 22.&amp;nbsp;Mai 2020 am Abend (UTC) angesetzt werden, an dem der Neumond zusammen mit der Sonne im Goldenen Tor der Ekliptik stand. Dies geschieht dann nach 19 Jahren am 23.&amp;nbsp;Mai 2039 kurz nach Mitternacht (UTC) erneut.]]

[[Datei:Ekliptikale.Breiten.Mond.siderische.Perioden.png|links|mini|hochkant=4|Die ekliptikalen Breiten des Mondes bei aufeinanderfolgenden Erscheinungen des Mondes im Goldenen Tor der Ekliptik innerhalb von 254 aufeinanderfolgenden siderischen Perioden (insgesamt 19&amp;nbsp;Jahre). Da der drakonitische Monat (von einem aufsteigendem Mondknoten bis zum nächsten aufsteigenden Mondknoten) gut zweieinhalb Stunden kürzer ist als der siderische Monat, kommt es hierbei zu Verschiebungen, weil der Mond nach Ablauf eines siderischen Monats den aufsteigenden Knoten bereits wieder hinter sich gelassen hat.&lt;br/&gt;&lt;br/&gt;Bei großen ekliptikalen Breiten (oben) kommt es im Goldenen Tor der Ekliptik zu Bedeckungen der Plejaden und bei kleinen ekliptikalen Breiten (unten) kommt es zu Bedeckungen der Hyaden oder des Sterns Aldebaran durch die Mondscheibe.&lt;br/&gt;&lt;br/&gt;Der Startpunkt (Tag&amp;nbsp;0 im Monat&amp;nbsp;0) kann beispielsweise ebenfalls mit dem 22.&amp;nbsp;Mai 2020 angesetzt werden, an dem der Neumond vom Erdmittelpunkt aus gesehen bei einer ekliptikalen Breite von zirka -2,5&amp;nbsp;Bogengrad unterhalb der Sonne, deren ekliptikale Breite definitionsgemäß 0&amp;nbsp;Bogengrad beträgt, im Goldenen Tor der Ekliptik stand.&lt;br/&gt;&lt;br/&gt;Nach 18,61&amp;nbsp;Jahren (beziehungsweise 6793,5&amp;nbsp;Tagen oder gut 230&amp;nbsp;synodischen Monaten, in dieser Abbildung also nach gut 248,6&amp;nbsp;siderischen Monaten) erreicht der Mond dieselbe ekliptikale Breite und fast die gleiche Mondphase, befindet sich dann allerdings bei einer anderen ekliptikalen Länge.&lt;br/&gt;&lt;br/&gt;Die kurzperiodische kleine Wellenbewegung kommt durch die Nutation der Erdachse im Bezug zur Ekliptik beziehungsweise zum Fixsternhimmel zustande; sie hat eine Periodendauer von 35&amp;nbsp;Tagen und überlagert sich mit den zirka eine Woche kürzeren siderischen Mondperiode.]]
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

===Der Meton-Zyklus===
Nicht nur die Bestimmung und Vorhersage der Auf- und Untergänge der Venus haben die Aufmerksamkeit der Astronomen des Altertums auf sich gezogen, sondern auch der Mondzyklus mit den verschiedenen Mondphasen sowie das Auftreten von Mondfinsternissen bei Vollmond und von Sonnenfinsternissen bei Neumond. Es gibt einen Zyklus, der die Zeit beschreibt, nachdem die Sonne und der Mond die gleiche Konstellation erreichen. Nach '''19&amp;nbsp;Jahren''' (beziehungsweise knapp '''6940&amp;nbsp;Tagen''') hat nicht nur die Sonne dieselbe ekliptikale Länge erreicht, sondern auch der der Mond (nach '''254&amp;nbsp;siderischen Monaten'''), und er hat daher auch dieselbe Mondphase (nach '''235&amp;nbsp;synodischen Monaten'''). Außerdem hat er dann auch noch annährend die gleiche ekliptikale Breite (nach '''255&amp;nbsp;drakonitischen Monaten'''), so dass er fast wieder an derselben Stelle des Fixsternhimmels steht.&lt;ref name=&quot;rutherforth&quot;&gt;Thomas Rutherforth: &quot;A System Of Natural Philosophy: Being A Course of Lectures In Mechanics, Optics, Hydrostatics, and Astronomy; Which are Read in St Johns College Cambridge&quot;, volume 2, chapter XIV: &quot;Of the devision&lt;!--sic!--&gt; of time&quot;, paragraph 388: &quot;The cycle of Metos&quot;, 990 ff.&lt;/ref&gt;

Der Zyklus beruht also im Wesentlichen auf der zwar nur langfristig, bei entsprechender Ausdauer jedoch einfach zu beobachtenden Tatsache, dass 19&amp;nbsp;tropische Sonnenjahre, 235&amp;nbsp;synodische Monate, 254&amp;nbsp;siderische Monate und 255&amp;nbsp;drakonitische Monate fast die gleiche Länge haben. Der Unterschied zwischen den ersten beiden beträgt nur rund zwei Stunden:

* 19&amp;nbsp;Jahre = 6939,6&amp;nbsp;Tage, bestimmt durch die ekliptikale Länge der Sonne mit ihren Äquinoktien und Sonnenwenden.
* 235&amp;nbsp;synodische Monate = 6939,7&amp;nbsp;Tage, bestimmt durch die Mondphasen mit Neumonden und Vollmonden.
* 254&amp;nbsp;siderische Monate = 6939,7&amp;nbsp;Tage, bestimmt durch die ekliptikale Länge des Mondes.
* 255&amp;nbsp;drakonitische Monate = 6939,1&amp;nbsp;Tage, bestimmt durch die auf- und absteigenden Knoten der Mondbahn.

[[Datei:Legende.Meton-Zyklus.png|mini|rechts|Legende zum Diagramm &quot;Meton-Zyklus&quot;.]]

&lt;gallery caption=&quot;Der Meton-Zyklus&quot; mode=&quot;packed&quot;&gt;
Meton-Zyklus.Maerz.2019.png|Der Meton-Zyklus anhand der Frühlingsvollmonde (weiße Kreise) am 21. März 2019 (laufende Nummer 0) und am 21. März 2038 (laufende Nummer 235).
Meton-Zyklus.Januar.2023.Januar.2042.png|Der Meton-Zyklus vom Vollmond am 6. Januar 2023 bis zum Vollmond am 6. Januar 2042. Die farbigen Kreise symbolisieren die Äquinoktien und Sonnenwenden.
&lt;/gallery&gt;

[[Datei:Meton-Zyklus.2023.13996.png|mini|links|hochkant=4|Der 19-jährige Meton-Zyklus vom Januar&amp;nbsp;2023 bis zum Januar&amp;nbsp;2042. Die Zeit schreitet in horizontaler Richtung jeweils um einen halben Tag pro Bildpunkt voran. Der Vollmond (weißer Kreis) erscheint sowohl am 6.&amp;nbsp;Januar 2023 als auch am 6.&amp;nbsp;Januar 2042 im Sternbild Zwillinge (Gemini) nördlich vom Stern Mebsuta (ε&amp;nbsp;Geminorum). Unten sind die kleinen und großen Mondwenden für die geographische Breite 52,5 Bogengrad (zum Beispiel in Berlin) im Laufe der Zeit dargestellt.]]
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

Dieser 19-jährige nach dem antiken griechischen Astronomen {{w|Meton}} (5.&amp;nbsp;Jahrhundert vor Christus) benannte '''Meton-Zyklus''' sowie auch der unten erwähnte Saros-Zyklus waren im Altertum spätestens schon den Babyloniern bekannt und dienten als Grundlage für ihren Mondkalender. Meton ist davon ausgegangen, dass 19&amp;nbsp;Jahre exakt mit 6940&amp;nbsp;Tagen sowie mit 235 synodischen Monaten übereinstimmen. Dadurch, dass das Jahr nach dieser Annahme genau fünf Neunzehntel Tage länger ist als 365 Tage, sind neunzehn Jahre nach dieser Berechnung genau fünf Tage länger ist als neunzehn Mal 365 Tage, also 6935 Tage. Aus der Annahme einer festen ganzrationalen Kopplung der Umlaufzeiten der Erde um Ihre Achse (Tag) und um die Sonne (Jahr) sowie der Umlaufzeit des Mondes um die Erde (Monat) ergeben sich die folgenden Zusammenhänge:

* Abgerundet auf ganze Zahlen:
** '''Die Jahreslänge in ganzen Tagen:'''
**:&lt;math&gt;\frac {6940} {19} = 365 \text { Rest } 5&lt;/math&gt;, das heißt, dass für 19&amp;nbsp;Jahre mit der Länge 365 Tage '''fünf Schalttage''' (Jahreslänge dann 366&amp;nbsp;Tage) erforderlich sind, damit der Frühlingspunkt mit dem tropischen Sonnenjahr synchron bleibt (Solarkalender).
** '''Die Monatslänge in ganzen Tagen:'''
**:&lt;math&gt;\frac {6940} {235} = 29 \text { Rest } 125&lt;/math&gt;, das heißt, dass für 235&amp;nbsp;synodische Monate mit der Länge 29&amp;nbsp;Tage '''125&amp;nbsp;Schalttage''' (Monatslänge dann 30&amp;nbsp;Tage) erforderlich sind, damit ein tropisches Sonnenjahr immer zwölf Monate umfasst (Solarkalender).
** '''Die Jahreslänge in ganzen Monaten:'''
**:&lt;math&gt;\frac {\frac {6940} {19}} {\frac {6940} {235}} = \frac {235} {19} = 12 \text { Rest } 7&lt;/math&gt;, das heißt, dass in 19&amp;nbsp;Jahren mit 235&amp;nbsp;synodischen Monaten sowie 6490&amp;nbsp;Tagen '''sieben synodische Schaltmonate''' (Jahreslänge dann 13&amp;nbsp;Monate) erforderlich sind, um das Kalenderjahr mit dem tropischen Sonnenjahr synchron zu halten (Lunisolarkalender).

* Exakt mit Brüchen (ganzrationale Zahlen):
** Die Jahreslänge &lt;math&gt;d_a&lt;/math&gt; in Tagen (in einem Sonnenjahr):
**:&lt;math&gt;d_a = \frac {6940 \text { d}} {19 \text { a}} = 365 \frac {\text {d}} {\text {a}} + \frac {5} {19} \frac {\text {d}} {\text {a}} = 365 \frac {\text {d}} {\text {a}} + \frac {20} {76} \frac {\text {d}} {\text {a}} = 365 \frac {\text {d}} {\text {a}} + \frac {1} {4} \frac {\text {d}} {\text {a}} + \frac {1} {76} \frac {\text {d}} {\text {a}} = 365,25 \frac {\text {d}} {\text {a}} + \frac {1} {76} \frac {\text {d}} {\text {a}} \approx 365,263158 \frac {\text {d}} {\text {a}}&lt;/math&gt;
** Die Länge eines synodischen Monats &lt;math&gt;d_m&lt;/math&gt; in Tagen:
**:&lt;math&gt;d_m = \frac {6940 \text { d}} {235 \text { m}} = \frac {1388} {47} \frac {\text {d}} {\text {m}} = 29 \frac {\text {d}} {\text {m}} + \frac {125} {235} \frac {\text {h}} {\text {m}} = 29 \frac {\text {d}} {\text {m}} + \frac {25} {47} \frac {\text {h}} {\text {m}} \approx 29,531915 \frac {\text {d}} {\text {m}}&lt;/math&gt;
** Länge von zwölf synodischen Monaten &lt;math&gt;d_{m_{12}}&lt;/math&gt; in Tagen (in einem Mondjahr):
**:&lt;math&gt;d_{m_{12}} = 12 \frac {\text {m}} {\text {a}} \cdot d_m = 12 \frac {\text {m}} {\text {a}} \cdot \frac {1388} {47} \frac {\text {d}} {\text {m}} = \frac {16656} {47} \frac {\text {d}} {\text {a}} \approx 354,382979 \frac {\text {d}} {\text {a}} \approx d_a - 11 \frac {\text {d}} {\text {a}}&lt;/math&gt;
** Die Jahreslänge &lt;math&gt;m_a&lt;/math&gt; in synodischen Monaten (in einem Sonnenjahr):
**:&lt;math&gt;m_a = \frac {d_a} {d_m} = \frac {\frac {6940 \text { d}} {19 \text { a}}} {\frac {6940 \text { d}} {235 \text { m}}} = \frac {235} {19} \frac {\text {m}} {\text {a}} = 12 \frac {\text {m}} {\text {a}} + \frac {7} {19} \frac {\text {m}} {\text {a}} \approx 12,368421 \frac {\text {m}} {\text {a}}&lt;/math&gt;

:'''Anmerkung''': Man nehme zur Kenntnis, dass das der Mittelwert der Dauern vom Sonnenjahr &lt;math&gt;d_a&lt;/math&gt; und vom Mondjahr &lt;math&gt;d_{m_{12}}&lt;/math&gt; fast genau 360&amp;nbsp;Tage pro Jahr beträgt, also so viele Tage wie für einen vollständigen Kreis in Bogengrad gerechnet wird:
::&lt;math&gt;\frac {d_a + d_{m_{12}}} {2} = \frac {\frac {6940 \text { d}} {19 \text { a}} + \frac {16656} {47} \frac {\text {d}} {\text {a}}} {2} = \frac {321322} {893} \frac {\text {d}} {\text {a}} \approx 359,823 \frac {\text {d}} {\text {a}} \approx 360 \frac {\text {d}} {\text {a}}&lt;/math&gt;
::Mit den heutigen, jeweils rund eine halbe Stunde kürzeren Messwerten für die beiden Jahresdauern (tropisches Sonnenjahr mit 365,241 Tagen und Mondjahr mit zwölf Lunationen und 354,367 Tagen) zur Epoche J2000.0 ergibt sich ein nur geringfügig anderer Mittelwert, der ebenfalls nur um zirka eine Dreiviertelstunde von der Dauer von 360 Tagen abweicht:
::&lt;math&gt;\frac {d_a + d_{m_{12}}} {2} = \frac {365,241 \frac {\text {d}} {\text {a}} + 354,367 \frac {\text {d}} {\text {a}}} {2} \approx 359,804 \frac {\text {d}} {\text {a}} \approx 360 \frac {\text {d}} {\text {a}}&lt;/math&gt;

Für diese Erkenntnisse ist entweder die Weitergabe von beobachteten astronomischen Ereignissen, wie der Bedeckung der Plejaden durch den Mond oder die Messung der ekliptikalen Koordinaten des Mondes, an die nächste Generation erforderlich oder ein Lebensalter, das die Beobachtung von mindestens zwei solcher Zyklen umfasst – je nach Zeitpunkt der Geburt also rund 25 bis über 40 Jahre.

Da der Meton-Zyklus mit den aufgerundeten ganzzahligen 6940&amp;nbsp;Tagen einen Vierteltag länger dauert als 19&amp;nbsp;Sonnenjahre, summiert sich diese Differenz nach vier Meton-Zyklen auf einen ganzen Tag. Der entsprechende nach {{w|Kallippos von Kyzikos}} (viertes vorchristliches Jahrhundert) benannte '''Kallippische Zyklus''' von 76&amp;nbsp;Jahren (&lt;math&gt;= 4 \cdot 19&lt;/math&gt;&amp;nbsp;Jahre) oder 27759&amp;nbsp;Tage (&lt;math&gt;= (4 \cdot 6940) - 1&lt;/math&gt;&amp;nbsp;Tage) wird auch als verbesserter Meton-Zyklus bezeichnet:
* 76&amp;nbsp;Jahre = 27758,4&amp;nbsp;Tage
* 940&amp;nbsp;synodische Monate = 27758,8&amp;nbsp;Tage
* 1016&amp;nbsp;siderische Monate = 27758,8&amp;nbsp;Tage
* 1020&amp;nbsp;drakonitische Monate = 27756,5&amp;nbsp;Tage

Nach ungefähr 48&amp;nbsp;Sonnenjahren betrug die Differenz zwischen Meton-Zyklus und Sonnenjahr einen Tag, aber erst nach ungefähr 128&amp;nbsp;Sonnenjahren erreicht die Differenz zwischen Kallippischen Zyklus und Sonnenjahr so groß. Da der Kallippische Zyklus mit genau 27759;Tagen einen Vierteltag länger dauert als 76&amp;nbsp;Sonnenjahre, summiert sich diese Differenz nach vier Kallippischen Zyklen auf einen ganzen Tag. Der entsprechende nach {{w|Hipparchos (Astronom)|Hipparchos von Nicäa}} (zweites vorchristliches Jahrhundert) benannte '''Hipparchos-Zyklus''' von 304&amp;nbsp;Jahren (&lt;math&gt;= 4 \cdot 76 = 16 \cdot 19&lt;/math&gt;&amp;nbsp;Jahre) = 111035&amp;nbsp;Tage (&lt;math&gt;= (4 \cdot 27759) - 1&lt;/math&gt;&amp;nbsp;Tage) ist also wiederum ein verbesserter Kallippischer Zyklus:
* 304&amp;nbsp;Jahre = 111033,6&amp;nbsp;Tage
* 3760&amp;nbsp;synodische Monate = 111035,0&amp;nbsp;Tage
* 4064&amp;nbsp;siderische Monate = 111035,2&amp;nbsp;Tage
* 4080&amp;nbsp;drakonitische Monate = 111025,9&amp;nbsp;Tage

Nach einer Kallippischen Periode beträgt die Differenz zwischen 111035&amp;nbsp;ganzen Tagen und der Dauer von 3760&amp;nbsp;synodischen Monaten nur eine dreiviertel Stunde.

Die folgende Tabelle gibt einen Überblick über die Dauern im Meton-Zyklus, im Kallippischen Zyklus und im Hipparchos-Zyklus:

{| class=&quot;wikitable&quot;
!
!Tropische Perioden
!Synodische Perioden
!Siderische Perioden
!Ganzzahlige Tage
|-
|'''Dauer einer Periode in Tagen'''
|'''365,2422'''
|'''29,53059'''
|'''27,32166'''
|'''1'''
|-
|
|-
|'''Anzahl der Perioden im Meton-Zyklus'''
|'''19'''
|'''235'''
|'''254'''
|'''6940'''
|-
|'''Anzahl der Tage im Meton-Zyklus'''
|6939,6018
|6939,6887
|6939,7016
|6940
|-
|'''Differenz zu tropischen Perioden in Tagen'''
|0,0000
|0,0868
|0,0998
|0,3982
|-
|'''Differenz zu synodischen Perioden in Tagen'''
| -0,0868
|0,0000
|0,0130
|0,3113
|-
|'''Differenz zu siderischen Perioden in Tagen'''
| -0,0998
| -0,0130
|0,0000
|0,2984
|-
|'''Differenz zu tropischen Perioden in Stunden'''
|0,00
|2,08
|2,40
|9,56
|-
|'''Differenz zu synodischen Perioden in Stunden'''
| -2,08
|0,00
|0,31
|7,47
|-
|'''Differenz zu siderischen Perioden in Stunden'''
| -2,40
| -0,31
|0,00
|7,16
|-
|
|-
|'''Anzahl der Perioden im Kallippischen Zyklus'''
|'''76'''
|'''940'''
|'''1016'''
|'''27759'''
|-
|'''Anzahl der Tage im Kallippischen Zyklus'''
|27758,4072
|27758,7546
|27758,8066
|27759
|-
|'''Differenz zu tropischen Perioden in Tagen'''
|0,0000
|0,3474
|0,3994
|0,5928
|-
|'''Differenz zu synodischen Perioden in Tagen'''
| -0,3474
|0,0000
|0,0520
|0,2454
|-
|'''Differenz zu siderischen Perioden in Tagen'''
| -0,3994
| -0,0520
|0,0000
|0,1934
|-
|'''Differenz zu tropischen Perioden in Stunden'''
|0,00
|8,34
|9,58
|14,23
|-
|'''Differenz zu synodischen Perioden in Stunden'''
| -8,34
|0,00
|1,25
|5,89
|-
|'''Differenz zu siderischen Perioden in Stunden'''
| -9,58
| -1,25
|0,00
|4,64
|-
|
|-
|'''Anzahl der Perioden im Hipparchos-Zyklus'''
|'''304'''
|'''3760'''
|'''4064'''
|'''111035'''
|-
|'''Anzahl der Tage im Hipparchos-Zyklus'''
|111033,6288
|111035,0184
|111035,2262
|111035
|-
|'''Differenz zu tropischen Perioden in Tagen'''
|0,0000
|1,3896
|1,5974
|1,3712
|-
|'''Differenz zu synodischen Perioden in Tagen'''
| -1,3896
|0,0000
|0,2078
| -0,0184
|-
|'''Differenz zu siderischen Perioden in Tagen'''
| -1,5974
| -0,2078
|0,0000
| -0,2262
|-
|'''Differenz zu tropischen Perioden in Stunden'''
|0,00
|33,35
|38,34
|32,91
|-
|'''Differenz zu synodischen Perioden in Stunden'''
| -33,35
|0,00
|4,99
| -0,44
|-
|'''Differenz zu siderischen Perioden in Stunden'''
| -38,34
| -4,99
|0,00
| -5,43
|}

Vor gut 2000&amp;nbsp;Jahren betrug die Differenz zwischen Kallippischem Zyklus und Sonnenjahr nach ungefähr 227&amp;nbsp;Sonnenjahren einen Tag. Durch die inzwischen etwas verkürzte Dauer eines tropischen Jahres ist dies heute bereits nach etwa 221&amp;nbsp;Jahren der Fall.

====Die Goldene Zahl====
Die '''Goldene Zahl''' gibt an, das wievielte von diesen 19&amp;nbsp;Jahren ein bestimmtes Jahr ist, und sie spielt auch heute noch eine wichtige Rolle bei der Bestimmung des Datums von Pessach oder Ostern, zum Beispiel mit Hilfe der Formeln zur Berechnung von {{w|Carl Friedrich Gauß}} (*&amp;nbsp;1777; †&amp;nbsp;1855):

→ Siehe auch:

* [[Astronomie von der Frühgeschichte bis zur Neuzeit/ Kalenderführung/ Osterdatum|'''Osterdatum''']]
* {{w|Gaußsche Pessach-Formel}}
* {{w|Gaußsche Osterformel}}

Der Name Goldene Zahl rührt möglicherweise davon her, dass der diesem Zyklus zugrundeliegende Kalender ('''Parapegma''') des Meton auf den Steinmauern seiner Sonnenuhr (heliotropion) am Pnyx-Hügel in Athen in goldener Schrift zu sehen war.&lt;ref&gt;Michael Wright: [https://www3.astronomicalheritage.net/index.php/show-entity?identity=26&amp;idsubentity=1 The Pnyx, Athens, Greece], Portal to the Heritage of Astronomy, August 2011&lt;/ref&gt;&lt;ref name=&quot;rutherforth&quot; /&gt;

Heute ist in den Monaten um die Wintersonnenwende alle 19&amp;nbsp;Jahre morgens am westlichen Horizont der untergehende Vollmond im Goldenen Tor der Ekliptik zu sehen, wie im Dezember&amp;nbsp;2018. Die untere Hälfte des Mondes wird dann während des Untergangs vom Horizont verdeckt und der sichtbare leuchtende Teil bildet somit einen Halbkreis, wie er im mittleren Segment der Himmelstafel angedeutet ist. In diesem Fall liegen Hyaden und Plejaden im Westen auf einer Linie parallel zum Horizont und der dazwischenliegende, beim Untergang noch halb zu sehende Vollmond würde der Abbildung auf der Steintafel von Tal-Qadi entsprechen. Vor 4500&amp;nbsp;Jahren ergab sich diese Himmelsansicht wegen der Verschiebung des Frühlingspunktes bereits um die Tag-und-Nacht-Gleiche im Herbst.

Die 19&amp;nbsp;Megalithe des Blaustein-Hufeisens von '''Stonehenge''' (2270&amp;nbsp;bis 1930&amp;nbsp;vor Christus) werden ebenfalls mit dem 19-jährigen Meton-Zyklus in Zusammenhang gesehen.

Im Übrigen werden auch die Goldhüte aus der Bronzezeit mit diesem Zyklus in Verbindung gebracht. Der '''Berliner Goldhut''' zeigt in der siebenten und in der neunten ringförmigen Zone von oben horizontale Reihen mit 57 (=&amp;nbsp;3&amp;nbsp;x&amp;nbsp;19) kreisförmigen Punzen, die für ein Viertel der 228&amp;nbsp;Monate einer Meton-Periode stehen könnten.&lt;ref&gt;Wilfried Menghin: „Der Berliner Goldhut und die goldenen Kalendarien der alteuropäischen Bronzezeit“, Acta Praehistorica et Archaeologica, Band 32, 2000, ISSN 0341-1184, Seiten 31 bis 108&lt;/ref&gt;

An der östlichen Wand in der Kamme&amp;nbsp;A des hethitischen Heiligtums '''Yazılıkaya''' (türkisch für „beschriebener Fels“) aus dem 13.&amp;nbsp;vorchristlichen Jahrhundert existiert eine Reliefbilderreihe, die eine Prozession von '''neunzehn''' nach links schauenden Göttinnen im Ganzkörperprofil darstellt. Auch hier wird vermutet, dass diese Reihe als Zählwerk für den Meton-Zyklus eine Kalenderfunktion innehatte.&lt;ref&gt;Eberhard Zangger, Rita Gautschy: [http://63.33.38.154/JSA/article/view/12232 Celestial Aspects of Hittite Religion - An Investigation of the Rock Sanctuary Yazilikaya], Journal of Skyscape Archaeology, 5(1), 5–38, 2019&lt;/ref&gt;&lt;ref&gt;Edwin C. Krupp, Eberhard Zangger: [https://www.archaeologie-online.de/artikel/2021/die-symbolische-darstellung-des-kosmos-im-hethitischen-felsheiligtum-yazlkaya Die symbolische Darstellung des Kosmos im hethitischen Felsheiligtum Yazılıkaya] vom 16. Juni 2021, Archäologie Online, archaeomedia, Freiburg&lt;/ref&gt;

Der Zyklus mit der Anzahl 19 taucht in weiteren archäoastronomischen Kontexten auf:

* Mond-Sonne-Darstellung aus dem mesoamerikanischen '''Codex Borbonicus''' der Azteken vom Anfang des 16.&amp;nbsp;Jahrhunderts.
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Mondzyklen#Der_Kalenderstein_vom_Tempel_Mnajdra|Oberste Lochreihe auf dem östlichen Kalenderstein vom Tempel '''Mnajdra''' auf Malta]].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Höhlenmalerei_in_der_Magura-Höhle#Kalender|Kalender unter den Höhlenmalereien in der '''Magura'''-Höhle mit einer Matrix aus 19 Punkten]].

&lt;gallery caption=&quot;Die Zahl 19 in archäoastronomischen Kontexten&quot; mode=packed widths=360 heights=360&gt;
Magura_cave_calendar_1528.jpg|Detail mit Elementen eines Kalenders aus der '''Magura'''-Höhle in Bulgarien. Unten in der Mitte befindet sich ein Feld mit 19&amp;nbsp;Punkten.
Kalenderstein.Mnajdra.labelled.png|Skizze der Lochreihen auf dem Kalenderstein von '''Mnajdra''' auf Malta. Die oberste Lochreihe besteht aus 19&amp;nbsp;Löchern.
Hattusa,_capital_of_the_Hittite_Empire_51.jpg|Detail mit den linken drei der insgesamt neunzehn Göttinnen der Bilderreihe in der Kammer A des hethitischen Heiligtums '''Yazılıkaya'''.
Yazilikaya.19.Gottheiten.png|Schmatische Darstellung der 19&amp;nbsp;weiblichen Gottheiten im hethitischen Heiligtum '''Yazılıkaya''' in der Türkei. Im Original variieren die Darstellungen der einzelnen Figuren, die in unterschiedlichem Zustand erhalten sind. Über den Händen einzelner Figuren konnten verschiedene hieroglyphische Darstellungen festgestellt werden. Die erste Figur (ganz links) konnte hierdurch nur indirekt rekonstruiert werden.
Berliner.Goldhut.P1068203.jpg||'''Berliner Goldhut''' vom Ende der Bronzezeit (1000–800 vor Christus) im Neuen Museum.
MesoamerikanischerMond.CodexBorbonicus.png|Mond-Sonne-Darstellung aus dem mesoamerikanischen '''Codex Borbonicus''' der Azteken vom Anfang des 16.&amp;nbsp;Jahrhunderts. Die beiden sich zu einem vollen Kreis ergänzenden Halbkreise symbolisieren den Mond und die Sonne. Im Halbkreis des Mondes befinden sich '''19&amp;nbsp;Kreise'''.
&lt;/gallery&gt;

====MUL.APIN====
[[Datei:MUP.APIN.VAT09412.P1078712.jpg|thumb|1914 gefundene Tontafel mit Texten aus dem 687 vor Christus geschrieben babylonischen Kompendium MUL.APIN, Irak, Assur/Qal'at Scherqat, VAT 09412, Neues Museum Berlin]]

Die auf den MUL.APIN-Tafeln schriftlich überlieferten babylonischen [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|'''Plejaden-Schaltregeln''']] beziehen sich zweifelsfrei auf einen Zeitpunkt, als der offene Sternhaufen der Plejaden im Sternbild Stier (Taurus) die gleiche ekliptikale Länge wie der Frühlingspunkt gehabt hat. Dies bedeutet, dass die Sonne zur Tag-und-Nacht-Gleiche direkt neben den Plejaden stand, und dies war um 2600&amp;nbsp;vor Christus der Fall. Aus beiden Schaltregeln ergibt sich, dass innerhalb von 19&amp;nbsp;Sonnenjahren sieben zusätzliche synodische Monate eingeschaltet werden müssen, damit Sonnen- und synodisches Mondjahr synchron bleiben. Die Differenz zwischen Mondlauf und Sonnenlauf beträgt nach diesen 19&amp;nbsp;Sonnenjahren nur gut zwei Stunden. Diese Abweichung beträgt nur 0,0125&amp;nbsp;Promille beziehungsweise 12,58&amp;nbsp;parts&amp;nbsp;per&amp;nbsp;million (ppm):

* Tropisches Sonnenjahr (von Frühlingspunkt zu Frühlingspunkt): &lt;math&gt;J_S = 365,2422 \text { d} = 8765,813 \text { h}&lt;/math&gt;
* Synodischer Monat (von Neumond zu Neumond): &lt;math&gt;M_{syn} = 29,53059 \text { d} = 708,7342 \text { h}&lt;/math&gt;
* Synodisches Mondjahr (zwölf synodische Monate): &lt;math&gt;J_{syn} = 12 \cdot M_{syn} = 354,3671 \text { d} = 8504,810 \text { h}&lt;/math&gt;
* Jahresdifferenz zwischen tropischem Sonnenjahr und synodischem Mondjahr: &lt;math&gt;\Delta J = J_S - J_{syn} = 10,8751 \text { d} = 261,003 \text { h}&lt;/math&gt;
* Meton-Zyklus: &lt;math&gt;19 \cdot \Delta J = 206,627 \text { d} = 4959,046 \text { h}&lt;/math&gt; beziehungsweise &lt;math&gt;7 \cdot M_{syn} = 206,714 \text { d} = 4961,139 \text { h}&lt;/math&gt;
* Genauigkeit des Meton-Zyklus: &lt;math&gt;\Delta M = 7 \cdot M_{syn} - 19 \cdot \Delta J = 0,087 \text { d} \approx 2,09 \text { h} = 235 \cdot M_{syn} - 19 \cdot J_S&lt;/math&gt;
* Arithmetische Zusammensetzung und Primfaktorenzerlegung der Anzahl synodischer Mondzyklen: &lt;math&gt;235 = 7 + 19 \cdot 12 = 5 \cdot 47&lt;/math&gt;

Mit anderen Worten war der Meton-Zyklus bereits über zwei Jahrtausende lang bekannt, bevor sich der griechische Astronom Meton damit beschäftigte.

Es ist äußerst bemerkenswert, dass eine entsprechende Berechnung auch für dreizehn siderische Monate durchgeführt werden kann, bei denen der Mond jeweils einmal vollständig die Ekliptik mit ihren zwölf Ekliptiksternbildern beziehungsweise den 27 oder 28 Mondstationen (auch Mondhäuser genannt, siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Mondhäuser|Exkurs '''Mondhäuser''']]) durchläuft:

* Tropisches Sonnenjahr (von Frühlingspunkt zu Frühlingspunkt): &lt;math&gt;J_S = 365,2422 \text { d} = 8765,813 \text { h}&lt;/math&gt;
* Siderischer Monat (von Fixstern zu Fixstern): &lt;math&gt;M_{sid} = 27,32166 \text { d} = 655,720 \text { h}&lt;/math&gt;
* Siderisches Mondjahr (13 siderische Monate): &lt;math&gt;J_{sid} = 13 \cdot M_{sid} = 355,1816 \text { d} = 8524,358 \text { h}&lt;/math&gt;
* Jahresdifferenz zwischen tropischem Sonnenjahr und siderischem Mondjahr: &lt;math&gt;\Delta J = J_S - J_{sid} = 10,0606 \text { d} = 241,454 \text { h}&lt;/math&gt;
* Meton-Zyklus: &lt;math&gt;19 \cdot \Delta J = 191,151 \text { d} = 4587,634 \text { h}&lt;/math&gt; beziehungsweise &lt;math&gt;7 \cdot M_{sid} = 191,252 \text { d} = 4590,040 \text { h}&lt;/math&gt;
* Genauigkeit des Meton-Zyklus: &lt;math&gt;\Delta M = 7 \cdot M_{sid} - 19 \cdot \Delta J = 0,100 \text { d} \approx 2,40 \text { h} = 254 \cdot M_{sid} - 19 \cdot J_S&lt;/math&gt;
* Arithmetische Zusammensetzung und Primfaktorenzerlegung der Anzahl siderischer Mondzyklen: &lt;math&gt;254 = 7 + 19 \cdot 13 = 2 \cdot 127&lt;/math&gt;

Auch hier beträgt die Differenz zwischen Mondlauf und Sonnenlauf nur gut zwei Stunden. Und innerhalb der 19 Sonnenjahre eines Meton-Zyklus müssen auch hier sieben zusätzliche (vierzehnte) siderische Monate eingeschaltet werden, damit Sonnen- und siderisches Mondjahr synchron bleiben.

Zur Differenz von knapp elf Tagen zwischen Sonnen- und Mondjahr siehe auch '''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Das_babylonische_Neujahrsfest_Akiti|das babylonische Neujahrsfest Akiti]]'''. Dieses elftägige Fest wurde am Ende des Mondjahres gefeiert.

===Der drakonitische Zyklus===
Ferner existiert ein zirka '''18,61-jähriger Mondzyklus''', der darauf beruht, dass bedingt durch die Präzession der Mondbahn der aufsteigende und der absteigende Mondknoten nach dieser Zeit die Ekliptik entgegen der rechtläufigen (prograden) Umlaufrichtung des Mondes genau einmal vollständig rückläufig (retrograd) durchlaufen haben. Dieser Zyklus besteht aus 249,83&amp;nbsp;drakonitischen Monaten, die insgesamt 6798,38&amp;nbsp;Tagen beziehungsweise 18,61&amp;nbsp;tropischen Sonnenjahren entsprechen. Die ekliptikalen Längen der Mondknoten vermindern sich hierbei um einen Winkel von 19,34&amp;nbsp;Bogengrad pro Jahr.

Dieser drakonitische Zyklus ist zum Beispiel anhand der Abweichungen der ekliptikalen Breiten des Mondes und somit der Azimute bei den monatlichen Mondaufgängen und Monduntergängen am Horizont zu beobachten, die sich nach 18,61&amp;nbsp;Jahren wiederholen und dabei um die Punkte der Wintersonnenwende im Südosten und Südwesten sowie die Punkte der Sommersonnenwende im Nordosten und Nordwesten entlang dem Horizont pendeln. Die Zeitpunkte an dem die entsprechenden Auf- und Untergangspunkte zwischen dem nördlichen und dem südlichen Horizont um die Punkte der Tag-und-Nacht-Gleichen im Osten und Westen, die definitionsgemäß bei der ekliptikalen Breite null genau in der Ekliptik liegen, am engsten beziehungsweise am weitesten auseinanderliegen, heißen '''große und kleine Mondwenden'''. Diese Mondwenden wiederholen sich also alle 18,61&amp;nbsp;Jahre. Hierbei treten auch größte und kleinste Mondwenden auf. Um die Wintersonnenwenden der Jahre 2023, 2042, 2061 und so weiter treten beispielsweise '''größte Mondwenden''' auf, bei denen die Auf- und Untergangspunkte maximal in Richtung Norden von den genau im Osten und im Westen liegenden Äquinoktialpunkten entfernt sind. Und um die Sommersonnenwenden der Jahre 2024, 2043, 2062 und so weiter treten '''kleinste Mondwenden''' auf, bei denen die Auf- und Untergangspunkte maximal in Richtung Süden von den genau im Osten und im Westen liegenden Äquinoktialpunkten entfernt sind.

[[Datei:Ekliptik.helle.Objekte.png|mini|hochkant=2|rechts|Die sieben hellsten feststehenden Himmelsobjekte in der Nähe der Ekliptik liegen zwischen den Sternbildern Stier (Taurus, rechts) und Skorpion (Scorpio, links). Der Bogen der Ekliptik wird von den Wandelgestirnen entgegen dem Uhrzeigersinn vom Frühlingspunkt rechts zum Herbstpunkt links durchlaufen. In der Nähe unteren Bogenhälfte befinden sich keine hellen Fixsterne in der Nähe der Ekliptik, der helle Stern Fomalhaut (α&amp;nbsp;Piscis Austrini) im Sternbild Südlicher Fisch (Piscis Austrinus) dient lediglich zur Orientierung. Außerhalb des Bogens liegende Punkte befinden sich nördlich der Ekliptik und innen liegende südlich.]]

Aufgrund dieser Zusammenhänge werden alle möglichen Positionen des Mondes in Bezug auf die Ekliptik bei den ekliptikalen Längen von -180&amp;nbsp;bis +180&amp;nbsp;Bogengrad und den ekliptikalen Breiten von ungefähr -6&amp;nbsp;bis +6&amp;nbsp;Bogengrad innerhalb dieser 18,61-jährigen Periode erreicht. Somit erfolgen auch alle möglichen Sternbedeckungen (Okkultationen) oder nahe Konjunktionen innerhalb dieser Periodendauer und wiederholen sich danach im drakonitischen Zyklus. Die Bedeckungen hellsten ekliptiknahen Himmelsobjekte sind hierbei besonders spektakulär und gut zu beobachten. Dies gilt insbesondere für:

* die '''Plejaden''' (Messier 45, 1,5&lt;sup&gt;m&lt;/sup&gt;) im Sternbild Stier (Taurus)
* die '''Hyaden''' (0,5&lt;sup&gt;m&lt;/sup&gt;) im Sternbild Stier (Taurus)
* den Roten Riesen '''Aldebaran''' (α&amp;nbsp;Tauri, 1,0&lt;sup&gt;m&lt;/sup&gt;) im Sternbild Stier (Taurus)
* den Roten Überriesen '''Antares''' (α&amp;nbsp;Scorpii, 1,0&lt;sup&gt;m&lt;/sup&gt;) im Sternbild Skorpion (Scorpio),
* den Stern '''Spica''' (α&amp;nbsp;Virginis, 1,0&lt;sup&gt;m&lt;/sup&gt;) im Sternbild Jungfrau (Virgo)
* den Stern '''Regulus''' (α&amp;nbsp;Leonis, 1,5&lt;sup&gt;m&lt;/sup&gt;) im Sternbild Löwe (Leo)

Wenn der Mond bei der Bedeckung der '''Plejaden''' seine maximale nördliche ekliptikale Breite bereits zuvor erreicht hatte und sich also bereits wieder in Richtung seines absteigenden Knotens bewegt, befindet sich in der Nähe des absteigenden Knotens der Königsstern '''Regulus''' im Sternbild Löwe (Leo), so dass es ungefähr eine Woche später ebenfalls zu dessen Bedeckung durch den Mond kommen kann. Da der Stern '''Antares''' α&amp;nbsp;Scorpii) im Sternbild Skorpion (Scorpio) in etwa die gleiche südliche ekliptikale Breite hat, wie die Plejaden eine nördliche ekliptikale Breite haben, und beide auf gegenüberliegenden Punkten der Ekliptiklinie liegen, kommt es im Rhythmus des drakonitischen Zyklus innerhalb eines halben Monats gehäuft zu der Bedeckung beider Himmelsobjekte durch die Mondscheibe. Beide Ereignisse wären wegen der gegenüberliegenden Lage auf der Ekliptik heute allerdings nur während der langen Nächte im Winterhalbjahr zu sehen, wenn Antares praktisch nicht zu beobachten ist, weil er von der Sonne überstrahlt wird. Als der Frühlingspunkt im Altertum jedoch im Sternbild Stier stand, war die aufeinanderfolgende Bedeckung von Plejaden und Antares jedoch durchaus ein zu beobachtendes Doppelereignis.

Das nächste Mal werden die beiden eng benachbarten Elternsterne der Plejaden (der Titan Atlas und die Okeanide Pleione) von Mitteleuropa aus gesehen in den Morgenstunden des 8.&amp;nbsp;Augusts 2024 von der Scheibe des abnehmenden Halbmonds bedeckt. Am 1.&amp;nbsp;April 2025 werden gegen Mitternacht dann sogar mehrere helle Sterne des Sternhaufens durch die nur vier Tage alte Mondsichel bedeckt.

Auch im alten chinesischen, mündlich überlieferten Volksmärchen „Morgenhimmel“ wird der Zyklus vom '''Stern des großen Jahres''' erwähnt, der sich erst nach 18 Jahren, also im 19.&amp;nbsp;Jahr wiederholt:&lt;ref&gt;[[s:Morgenhimmel|Morgenhimmel]], Wikisource&lt;/ref&gt;

&lt;blockquote&gt;
Als Morgenhimmel gestorben war, berief der Kaiser den Sterndeuter und fragte: „Kanntest du Morgenhimmel?“&lt;br/&gt;
Der sagte: „Nein.“&lt;br/&gt;
Der Kaiser fragte: „Was verstehst du denn?“&lt;br/&gt;
Der Sterndeuter sagte: „Ich kann nach den Sternen sehen.“&lt;br/&gt;
„Sind alle Sterne an ihrem Platz?“ fragte der Kaiser.&lt;br/&gt;
„Ja. Nur den Stern des großen Jahres habe ich achtzehn Jahre nicht gesehen. Jetzt aber ist er wieder sichtbar.“&lt;br/&gt;
Da blickte der Kaiser zum Himmel auf und seufzte: „Achtzehn Jahre lang war Morgenhimmel mir zur Seite, und ich wusste nicht, dass er der Stern des großen Jahres war.“
&lt;/blockquote&gt;

Mit &quot;Stern des großen Jahres&quot; könnte ein Ereignis gemeint sein, bei dem der Mond alle 18,61 Jahre einen bestimmten hellen und ekliptiknahen Stern bedeckt, wie zum Beispiel einen der drei Königssterne Aldebaran (α&amp;nbsp;Tauri) im Sternbild Stier (Taurus), Regulus (α&amp;nbsp;Leonis) im Sternbild Löwe (Leo), Antares (α&amp;nbsp;Scorpii) im Sternbild Skorpion (Scorpio) oder auch Spica (α&amp;nbsp;Virginis) im Sternbild Jungfrau (Virgo).

Auch für den drakonitischen Zyklus kann für dreizehn drakonitische Monate eine Berechnung in Bezug auf den 19-jährigen Meton-Zyklus durchgeführt werden:

* Tropisches Sonnenjahr (von Frühlingspunkt zu Frühlingspunkt): &lt;math&gt;J_S = 365,2422 \text { d} = 8765,813 \text { h}&lt;/math&gt;
* Drakonitischer Monat (von Mondknoten zu Mondknoten): &lt;math&gt;M_{dra} = 27,21222 \text { d} = 653,093 \text { h}&lt;/math&gt;
* Drakonitisches Mondjahr (13 drakonitische Monate): &lt;math&gt;J_{dra} = 13 \cdot M_{dra} = 353,7589 \text { d} = 8490,213 \text { h}&lt;/math&gt;
* Jahresdifferenz zwischen tropischem Sonnenjahr und drakonitischem Mondjahr: &lt;math&gt;\Delta J = J_S - J_{dra} = 11,4833 \text { d} = 275,600 \text { h}&lt;/math&gt;
* Meton-Zyklus: &lt;math&gt;19 \cdot \Delta J = 218,1835 \text { d} = 5236,403 \text { h}&lt;/math&gt; beziehungsweise &lt;math&gt;8 \cdot M_{sid} = 217,6978 \text { d} = 5224,746 \text { h}&lt;/math&gt;
* Genauigkeit des Meton-Zyklus: &lt;math&gt;\Delta M = 8 \cdot M_{dra} - 19 \cdot \Delta J = -0,486 \text { d} \approx -11,66 \text { h} = -(255 \cdot M_{dra} - 19 \cdot J_S)&lt;/math&gt;
* Arithmetische Zusammensetzung und Primfaktorenzerlegung der Anzahl drakonitischer Mondzyklen: &lt;math&gt;255 = 8 + 19 \cdot 13 = 3 \cdot 5 \cdot 17&lt;/math&gt;

Hier beträgt die Differenz zwischen Mondlauf und Sonnenlauf knapp einen halben Tag. Innerhalb der 19 Sonnenjahre eines Meton-Zyklus müssen hier acht zusätzliche (vierzehnte) drakonitische Monate eingeschaltet werden, damit Sonnen- und drakonitisches Mondjahr synchron bleiben.

===Der Saros-Zyklus===
[[Datei:Saros-Zyklus.2023.Januar.png|rechts|mini|hochkant=4|Der '''Saros-Zyklus''' umfasst sowohl eine Periode von 242&amp;nbsp;drakonitischen Monaten als auch eine Periode von 223&amp;nbsp;synodischen Monaten. Das sind gut 6585&amp;nbsp;Tage oder 18,03 tropische Sonnenjahre, also 18&amp;nbsp;Jahre und knapp 11&amp;nbsp;Tage). In der Graphik ist die Zeit vom aufsteigenden Knoten (rot) am 1.&amp;nbsp;Januar 2023 bis zum aufsteigenden Knoten (rot) am 11.&amp;nbsp;Januar 2041 dargestellt. Man beachte die gleichzeitige zyklische Wiederholung der jeweiligen Mondphasen sowie daraus folgend der '''Finsternisse''' im April und Mai sowie im Oktober und November mit einer Verschiebung von elf Kalendertagen im Sonnenjahr.&lt;br/&gt;Die '''Mondwenden''' (die tagesaktuellen Auf- und Untergangsazimute des Mondes sind im unteren Bereich für die geographische Breite 52,5 Bogengrad (zum Beispiel in Berlin) dargestellt) haben ihr Minimum und Maximum demzufolge zu den entsprechenden Zeitpunkten, die Ausprägung dieser Extrema unterscheidet sich jedoch ein wenig, weil der Mond dort geringfügig abweichende minimale und maximale ekliptikale Breiten hat. Die kleinen Mondwenden beim Sommervollmond im Juli und die großen Mondwenden beim Wintervollmond (Jahreswechsel) sind in der Graphik ebenfalls nachvollziehbar.&lt;br/&gt;[[Datei:Legende.Meton-Zyklus.png|200px|zentriert|Legende]]]]

Über die weiter oben beschriebenen Koinzidenzen hinaus kann beobachtet werden, dass der Mond nach '''18,03&amp;nbsp;Jahren''' (also nach 242&amp;nbsp;drakonitischen Monaten beziehungsweise 6585,3&amp;nbsp;Tagen) denselben auf- oder absteigenden Knoten erreicht, wobei Sonne und Mond dann die gleiche Elongation haben (nach 223&amp;nbsp;synodischen Monaten beziehungsweise 6585,2&amp;nbsp;Tagen). Sie befinden sich dann allerdings nur fast bei den gleichen ekliptikalen Längen beziehungsweise an den gleichen Stellen des Fixsternhimmels, da diese Dauer nur mit ungefähr einem halben Tag Differenz mit 241 siderischen Perioden übereinstimmt (6584,6&amp;nbsp;Tage). Innerhalb dieses halben Tages hat sich die Sonne um zirka ein halbes Bogengrad und der Mond sogar um ungefähr sechseinhalb Bogengrad weiterbewegt.

Dieser Zyklus wird '''Saros-Zyklus''' genannt. Innerhalb dieser Zeitspanne ergibt sich eine Reihe von Sonnen- und Mondfinsternissen, die sich in ihrer Abfolge immer wieder ähneln. Der Saros-Zyklus war bei den Babyloniern bereits im Altertum bekannt, was in Keilschrift geschrieben auf Tontafeln aus der Mitte des achten vorchristlichen Jahrhunderts überliefert ist.

Heute werden die sich wiederholenden Sonnen- und Mondfinsternisse, die sich auf einen bestimmten auf- oder absteigenden Knoten der Mondbahn beziehen und jeweils eine Lebensdauer von mehreren Jahrhunderten haben, zum Zwecke der Unterscheidung mit Nummern versehen. Zu einem bestimmten Zeitpunkt der Weltgeschichte sind immer mehrere Dutzend Saros-Zyklen gleichzeitig aktiv.

Die anomalistische Periode steht für die Dauer, bis der Mond auf seiner elliptischen Bahn um die Erde erneut eines seiner beiden Apogäen erreicht, also das Perigäum (erdnächster Punkt) oder das Apogäum (erdfernster Punkt). Nach einer ganzzahligen vielfachen Dauer der anomalistischen Periode hat der Mond also stets fast die gleiche Entfernung zur Erde und somit auch die gleiche scheinbare Größe, so dass die Dauer und Art (totale oder ringförmige Sonnenfinsternis) einer Finsternis sich wiederholt.

Wegen der gleichen ekliptikalen Breiten des Mondes nach einer ganzzahligen vielfachen Dauer der drakonitischen Periode erscheint der Mondschatten auf der Erdoberfläche nach der Dauer einer Saros-Periode ungefähr beim gleichen Breitengrad. Durch die Differenz von rund einem drittel Tag ist der Längengrad allerdings nach einer Saros-Periode um knapp 120 Bogengrad nach Westen verschoben. Nach drei Saros Perioden, oder nach einem dadurch definierten Exeligmos-Zyklus, haben sich die drei Dritteltage fast auf einen Tag summiert, so dass nach der Mondschatten dann nicht nur wieder beim ähnlichen Breitengrad, sondern sogar beim ähnlichen Längengrad und zu einer ähnlichen Tageszeit auftaucht. Anders ausgedrückt: wenn an einem bestimmten Ort auf der Erdoberfläche eine Finsternis auftritt, so erfolgt in der Regel nach 19756 Tagen (54 Jahren und 33 Tagen) in dieser geographischen Region mit nur rund einer Stunde Verfrühung erneut eine solche Finsternis.

{| class=&quot;wikitable&quot;
|+ Exeligmos-Zyklus
! Anzahl der Saros-Zyklen !! Dauer in tropischen Jahren !! Dauer in ganzen Tagen
|-
| 1 || 18,03 || 6585
|-
| 3 || 54,09 || 19756
|}

Die folgende Tabelle gibt einen Überblick über die Dauern verschiedener Mondzyklen in einem '''Saros-Zyklus''' (18,03 tropische Jahre) sowie in einem dreimal so langen Zyklus '''Exeligmos-Zyklus''' (54,09 tropische Jahre) . 

{| class=&quot;wikitable&quot;
!
!Synodische Perioden
!Drakonitische Perioden
!Tage
!Anomalistische Perioden
|-
|'''Dauer einer Periode in Tagen'''
|'''29,53059'''
|'''27,21222'''
|'''1'''
|'''27,53455'''
|-
|
|-
|'''Anzahl der Perioden im Saros-Zyklus'''
|'''223'''
|'''242'''
|'''6585'''
|'''239'''
|-
|'''Anzahl der Tage im Saros-Zyklus'''
|6585,3216
|6585,3572
|6585,0000
|6580,7575
|-
|'''Differenz zu synodischen Perioden in Tagen'''
|0,0000
|0,0357
| -0,3216
| -4,5641
|-
|'''Differenz zu drakonitischen Perioden in Tagen'''
| -0,0357
|0,0000
| -0,3572
| -4,5998
|-
|'''Differenz zu ganzen Tagen'''
|0,3216
|0,3572
|0,0000
| -4,2425
|-
|'''Differenz zu synodischen Perioden in Stunden'''
|0,00
|0,86
| -7,72
| -109,54
|-
|'''Differenz zu drakonitischen Perioden in Stunden'''
| -0,86
|0,00
| -8,57
| -110,39
|-
|'''Differenz zu ganzen Tagen in Stunden'''
|7,72
|8,57
|0,00
| -101,82
|-
|
|-
|'''Anzahl der Perioden im Exeligmos-Zyklus'''
|'''669'''
|'''726'''
|'''19756'''
|'''717'''
|-
|'''Anzahl der Tage im Exeligmos-Zyklus'''
|19755,9647
|19756,0717
|19756,0000
|19742,2724
|-
|'''Differenz zu synodischen Perioden in Tagen'''
|0,0000
|0,1070
|0,0353
| -13,6924
|-
|'''Differenz zu drakonitischen Perioden in Tagen'''
| -0,1070
|0,0000
| -0,0717
| -13,7994
|-
|'''Differenz zu ganzen Tagen in Tagen'''
| -0,0353
|0,0717
|0,0000
| -13,7277
|-
|'''Differenz zu synodischen Perioden in Stunden'''
|0,00
|2,57
|0,85
| -328,62
|-
|'''Differenz zu drakonitischen Perioden in Stunden'''
| -2,57
|0,00
| -1,72
| -331,18
|-
|'''Differenz zu ganzen Tagen in Stunden'''
| -0,85
|1,72
|0,00
| -329,46
|}

===Mondwenden===
Da sich die '''Sonne''' definitionsgemäß immer in der Ekliptikebene befindet, wiederholen sich die Verhältnisse in Bezug auf ihre Auf- und Untergangspunkte sowie auf ihre südlichen und die nördlichen Kulminationshöhen in jedem tropischen Sonnenjahr. Zur '''Sommersonnenwende''' steht die Sonne am höchsten und am längsten über den Horizont, die Auf- und Untergangsazimute erreichen ihre nördlichsten Positionen und es ergibt sich der Kalendertag mit dem längsten Tagesslicht und der kürzesten Dunkelheit. Zur '''Wintersonnenwende''' steht die Sonne am niedrigsten und am kürzesten über den Horizont, die Auf- und Untergangsazimute erreichen ihre südlichsten Positionen und es ergibt sich der Kalendertag mit dem kürzesten Tagesslicht und der längsten Nacht. Bei den beiden '''Äquinoktien''' zum '''Frühlings- und Herbstbeginn''' herrscht die '''Tag-und-Nacht-Gleiche''', zwölf Stunden Tag und zwölf Stunden Nacht. Die Sonne geht überall auf der Erde exakt im Osten auf beziehungsweise im Westen unter.

Mit dem Neumond verhält es sich ähnlich wie mit der Sonne, da er sich stets in Sonnennähe befindet. Die Mondbahn ist gegenüber der Ekliptik jedoch geneigt (Inklination der Mondbahn), so dass der Mond bis zu gut 5&amp;nbsp;Bogengrad höher oder niedriger stehen kann als die Sonnenscheibe. Bei einer '''großen Mondwende''' steht die Ekliptik immer besonders hoch über dem Horizont und der Mond hat gleichzeitig seine maximale nördliche ekliptikale Breite erreicht. Wenn der Vollmond bei einer großen Mondwende auf dem südlichen Meridian kulminiert, findet dieses Ereignis als '''größte Mondwende''' um Mitternacht zur Wintersonnenwende statt (im Dezember 2023, 2042 und 2061).

[[Datei:Grosse.Mondwende.png|mini|zentriert|hochkant=2|Die größte Mondwende bei der am höchsten stehenden Ekliptik auf der Nordhalbkugel sowie die Sommersonnenwende im Horizontsystem. Die blaue Mondbahn wird während der Sommersonnenwende nur bei Neumond gleichzeitig mit der orangefarbenen Sonnenbahn durchlaufen. Während der Wintersonnenwende findet diese große Mondwende statt, wenn der Mond in Opposition zur Sonne steht und somit Vollmond herrscht.]]

Bei einer '''kleinen Mondwende''' steht die Ekliptik immer besonders niedrig über dem Horizont und der Mond hat gleichzeitig seine minimale südliche ekliptikale Breite erreicht. Wenn der Vollmond bei einer kleinen Mondwende auf dem südlichen Meridian kulminiert, findet dieses Ereignis als '''kleinste Mondwende''' um Mitternacht zur Sommersonnenwende statt (im Juni 2024, 2043 und 2062).

[[Datei:Kleine.Mondwende.png|mini|zentriert|hochkant=2|Die kleinste Mondwende bei der am niedrigsten stehenden Ekliptik auf der Nordhalbkugel sowie die Wintersonnenwende im Horizontsystem. Die blaue Mondbahn wird während der Wintersonnenwende nur bei Neumond gleichzeitig mit der orangefarbenen Sonnenbahn durchlaufen. Während der Sommersonnenwende findet diese kleine Mondwende statt, wenn der Mond in Opposition zur Sonne steht und somit Vollmond herrscht.]]

[[Datei:ZunehmenderMond.Herbst-Aequinoktium.P1185517.jpg|mini|rechts|Zunehmender Mond zum Herbst-Äquinoktium bei kleiner Mondwende mit flacher Ekliptik in Berlin mit fast senkrecht stehender Mondsichel (38% beleuchtet) im Sternbild Skorpion kurz vor Sonnenuntergang. Visuelle Helligkeit -9 mag, südliche ekliptikale Breite = -5°, Höhe über dem südlichen Horizont = 9°, Mondalter 6,2 Tage.]]

In der folgenden Übersicht sind die '''Mondaufgangspunkte''' am östlichen Horizont, die '''Kulminationspunkte''' auf dem südlichen Meridian und die '''Monduntergangspunkte''' am westlichen Horizont für die vier verschiedenen Jahreszeiten angegeben:

{| class=&quot;wikitable&quot;
|+ Die Lage des Bogens der Ekliptik über dem nächtlichen Horizont zu verschiedenen Jahreszeiten
!title=&quot;Jahreszeit&quot;| Jahreszeit
!title=&quot;Am Abend&quot;| Am Abend&lt;/br&gt;(Aufgang des Vollmonds&lt;/br&gt;in östlicher Richtung)
!title=&quot;Um Mitternacht&quot;| Um Mitternacht&lt;/br&gt;(Kulmination des Vollmonds&lt;/br&gt;auf dem südlichen Meridian)
!title=&quot;Am Morgen&quot;| Am Morgen&lt;/br&gt;(Untergang des Vollmonds&lt;/br&gt;in westlicher Richtung)
|-
| '''Frühlingsanfang'''&lt;/br&gt;'''Tag-und-Nacht-Gleiche''' || [[Datei:Ekliptik.C.png|360px]] || [[Datei:Ekliptik.D.png|360px]] || [[Datei:Ekliptik.A.png|360px]]
|-
| '''Sommeranfang'''&lt;/br&gt;'''Sommersonnenwende''' || [[Datei:Ekliptik.D.png|360px]] || [[Datei:Ekliptik.A.png|360px]] || [[Datei:Ekliptik.B.png|360px]]
|-
| '''Herbstanfang'''&lt;/br&gt;'''Tag-und-Nacht-Gleiche''' || [[Datei:Ekliptik.A.png|360px]] || [[Datei:Ekliptik.B.png|360px]] || [[Datei:Ekliptik.C.png|360px]]
|-
| '''Winteranfang'''&lt;/br&gt;'''Wintersonnenwende''' || [[Datei:Ekliptik.B.png|360px]] || [[Datei:Ekliptik.C.png|360px]] || [[Datei:Ekliptik.D.png|360px]]
|}

[[Datei:Orbit de Mondknoten.svg|mini|rechts|hochkant=2|Bahnellipse des Mondes mit den beiden Mondknoten.]]

Im Laufe eines '''drakonitischen Monats''' geht der Mond sowohl durch den aufsteigenden als auch durch den absteigenden Knoten (Drachenpunkte) seiner Mondbahn. Nach dem Durchqueren des aufsteigenden Knotens wird die ekliptikale Breite des Mondes positiv (nördliche ekliptikale Breite), er steigt in Bezug zur Ekliptiklinie nach Norden und bleibt entsprechend immer länger über dem Horizont. Nach dem Durchqueren des absteigenden Knotens wird die ekliptikale Breite des Mondes negativ (südliche ekliptikale Breite), er fällt in Bezug zur Ekliptiklinie nach Süden und bleibt entsprechend immer kürzer über dem Horizont. In der deutschsprachigen Schweiz gibt es für diese im Laufe eines drakonitischen Monats täglich mehr oder weniger deutlich wahrnehmbaren Änderungen der ekliptikalen Breite sogar eigene Adjektive. Das Ansteigen der ekliptikalen Breite des Mondes nach Norden wird '''obsigend''', und das Abfallen der ekliptikalen Breite des Mondes nach Süden wird '''nidsigend''' genannt. 

[[Datei:Mond-.und.Sonnenwenden.png|mini|rechts|hochkant=2|Verschiedene Mond- und Sonnenwenden auf dem südlichen Meridian im Laufe eines Jahres in Bezug zum Horizontsystem.]]

Im Laufe der Zeit pendelt der Mond immer wieder zwischen den kleinen und großen Mondwenden. Dieser Ablauf wiederholt sich nach einem vollständigen '''drakonitischen Zyklus''', also nach 18,61&amp;nbsp;Jahren, innerhalb dessen die kleinste und die größte Mondwende im zeitlichen Abstand von rund 9,3&amp;nbsp;Jahren jeweils einmal erreicht wird.

Die Deklinationen der Sonne &lt;math&gt;\delta_S&lt;/math&gt; pendeln also je nach Jahreszeit maximal um den Betrag der Schiefe der Ekliptik &lt;math&gt;\varepsilon&lt;/math&gt; um den Nullpunkt &lt;math&gt;\delta_S = 0&lt;/math&gt;, der nur zu den Tag-und-Nacht-Gleichen erreicht wird:

:&lt;math&gt;-\varepsilon \le \delta_S \le +\varepsilon&lt;/math&gt;

Die Deklinationen des Mondes &lt;math&gt;\delta_M&lt;/math&gt; pendeln zusätzlich um den Betrag der Inklination der Mondbahn &lt;math&gt;i&lt;/math&gt; (heute '''5,145&amp;nbsp;Bogengrad''') um die Werte der Deklination der Sonne &lt;math&gt;\delta_S&lt;/math&gt;:

:&lt;math&gt;-\varepsilon - i \le \delta_M \le +\varepsilon + i&lt;/math&gt;

Die Deklination und der maximale Höhenwinkel bei der Kulmination des Mondes auf dem südlichen Meridian variieren also sowohl innerhalb eines Monats durch die Inklination der Mondbahn als auch jährlich durch die Neigung der Erdachse (also die Schiefe der Ekliptik).

Die für die Azimute der Mondaufgänge &lt;math&gt;a_{A,M}&lt;/math&gt; anzuwendende Formel hängt nicht nur von der augenblicklichen Deklination des Mondes &lt;math&gt;\delta_M&lt;/math&gt;, sondern auch vom geographischen Breitengrad des Beobachters &lt;math&gt;\varphi&lt;/math&gt; ab:

:&lt;math&gt;\cos a_{A,M} = \frac {\sin \delta_M} {\cos \varphi}&lt;/math&gt;

Aus Symmetriegründen ergibt sich für die Azimute der Monduntergänge &lt;math&gt;a_{U,M}&lt;/math&gt;:

:&lt;math&gt;a_{U,M} = 360^\circ - a_{A,M} = 360^\circ - \arccos \frac {\sin \delta_M} {\cos \varphi}&lt;/math&gt;

{| class=&quot;wikitable&quot;
|+ Deklinationen des Mondes
! Ereignis !! Deklination des Mondes &lt;math&gt;\delta_M&lt;/math&gt; !! Maximaler Höhenwinkel des Mondes&lt;br/&gt;&lt;math&gt;h_{max,M}&lt;/math&gt; || Azimut des Mondaufgangs&lt;br/&gt;&lt;math&gt;a_{A,M}&lt;/math&gt; || Azimut des Monduntergangs&lt;br/&gt;&lt;math&gt;a_{U,M}&lt;/math&gt;
|-
| Kleinste Mondwende&lt;br/&gt;&lt;math&gt;\delta_S = -\varepsilon&lt;/math&gt; || &lt;math&gt;-(\varepsilon + i)&lt;/math&gt; || &lt;math&gt;(90^\circ - \varphi) - (\varepsilon + i)&lt;/math&gt; || &lt;math&gt;\arccos \frac {\sin (-\varepsilon - i)} {\cos \varphi}&lt;/math&gt; || &lt;math&gt;360^\circ - \arccos \frac {\sin (-\varepsilon - i)} {\cos \varphi}&lt;/math&gt;
|-
| Kleine Mondwende || &lt;math&gt;\delta_S - i&lt;/math&gt; || &lt;math&gt;(90^\circ - \varphi) + (\delta_S - i)&lt;/math&gt; || &lt;math&gt;\arccos \frac {\sin (\delta_S - i)} {\cos \varphi}&lt;/math&gt; || &lt;math&gt;360^\circ - \arccos \frac {\sin (\delta_S - i)} {\cos \varphi}&lt;/math&gt;
|-
| Mond im Knoten || &lt;math&gt;\delta_S&lt;/math&gt; || &lt;math&gt;(90^\circ - \varphi) + \delta_S&lt;/math&gt; || &lt;math&gt;\arccos \frac {\sin (\delta_S)} {\cos \varphi}&lt;/math&gt; || &lt;math&gt;360^\circ - \arccos \frac {\sin (\delta_S)} {\cos \varphi}&lt;/math&gt;
|-
| Große Mondwende || &lt;math&gt;\delta_S + i&lt;/math&gt; || &lt;math&gt;(90^\circ - \varphi) + (\delta_S + i)&lt;/math&gt; || &lt;math&gt;\arccos \frac {\sin (\delta_S + i)} {\cos \varphi}&lt;/math&gt; || &lt;math&gt;360^\circ - \arccos \frac {\sin (\delta_S + i)} {\cos \varphi}&lt;/math&gt;
|-
| Größte Mondwende&lt;br/&gt;&lt;math&gt;\delta_S = +\varepsilon&lt;/math&gt; || &lt;math&gt;+(\varepsilon + i)&lt;/math&gt; || &lt;math&gt;(90^\circ - \varphi) + (\varepsilon + i)&lt;/math&gt; || &lt;math&gt;\arccos \frac {\sin (\varepsilon + i)} {\cos \varphi}&lt;/math&gt; || &lt;math&gt;360^\circ - \arccos \frac {\sin (\varepsilon + i)} {\cos \varphi}&lt;/math&gt;
|}

Die Höhenwinkel des Mondes und der Sonne konnten zum Beispiel schon in der Bronzezeit mit Hilfe von '''Sonnenuhren''', '''Stabdolchen''' oder '''Kreisgrabenanlagen''' beobachtet und bestimmt werden. Im Laufe eines Jahres konnten damit die jahreszeitlichen Veränderungen der scheinbaren Sonnenbahn verfolgt werden. Durch eine langjährige Beobachtung war es dann auch möglich, die kleinsten und größten Mondwenden zu ermitteln.

Siehe hierzu auch:

* → '''[[Quadriviale_Kuriositäten/_Stabdolche|Stabdolche]]'''
* → '''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Kalenderführung#Frühgeschichtliche_Observatorien|Frühgeschichtliche Observatorien]]'''

===Vergleich der Perioden===
Die folgenden Periodendauern spielen bei Sonnen- und Mondzyklen eine besondere Rolle:

* '''Meton-Zyklus:'''
** 19&amp;nbsp;'''tropische Sonnenjahre''' = 6939,6&amp;nbsp;Tage, bestimmt durch die ekliptikale Länge der Sonne in Bezug zum Frühlingspunkt mit ihren Äquinoktien und Sonnenwenden.
** 235&amp;nbsp;'''synodische Monate''' = 6939,7&amp;nbsp;Tage, bestimmt durch die Mondphasen mit Neumonden und Vollmonden.
** 254&amp;nbsp;'''siderische Monate''' = 6939,7&amp;nbsp;Tage, bestimmt durch die ekliptikale Länge des Mondes in Bezug zum Frühlingspunkt und den Fixsternhimmel.
** 255&amp;nbsp;'''drakonitische Monate''' = 6939,1&amp;nbsp;Tage, bestimmt durch die ekliptikale Breite des Mondes beziehungsweise die auf- und absteigenden Knoten der Mondbahn.
* '''Drakonitischer Zyklus:''' 
** 249,83&amp;nbsp;'''drakonitische Monate''' = 6798,38&amp;nbsp;Tage = 18,613&amp;nbsp;tropische Sonnenjahre, bestimmt durch die ekliptikalen Längen der auf- und absteigenden Knoten der Mondbahn: Zyklus der Mondwenden und Sternbedeckungen (Nutationsperiode)
* '''Saros-Zyklus:'''
** 242&amp;nbsp;'''drakonitische Monate''' = 6585,3&amp;nbsp;Tage = 18,03&amp;nbsp;tropische Sonnenjahre (respektive 18&amp;nbsp;Jahre und 11&amp;nbsp;Tage): Zyklen der Sonnen- und Mondfinsternisse
** 223&amp;nbsp;'''synodische Monate''' = 6585,4&amp;nbsp;Tage, bestimmt durch die Mondphasen mit Neumonden und Vollmonden.

[[Datei:Meton-Zyklus.2023.4x5.png|mini|links|hochkant=4|Der 19-jährige Meton-Zyklus vom Januar&amp;nbsp;2023 bis zum Januar&amp;nbsp;2042. Die Zeit schreitet in horizontaler Richtung jeweils um einen halben Tag pro Bildpunkt voran.&lt;br/&gt;Im unteren Teil des Diagramms sind die kleinen und großen Mondwenden für die geographische Breite 52,5&amp;nbsp;Bogengrad (zum Beispiel in Berlin) dargestellt.]]
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;
[[Datei:Herbstaequinoktium.kleine.Mondwende.2033.png|mini|rechts|hochkant=1|Herbstäquinoktium (orange) und Sonnenfinsternis bei aufsteigendem (rot) Neumond am 23.&amp;nbsp;September 2033 (orangefarbene Linie), Mondfinsternis bei absteigendem (blau) Vollmond am 8.&amp;nbsp;Oktober 2033 und Wintersonnenwende (türkis) mit kleiner Mondwende bei Neumond am 21.&amp;nbsp;Dezember 2033 (grüne Linie).]]

Der '''Vollmond''' (weiß) erscheint sowohl zu Beginn der Darstellung am 6.&amp;nbsp;Januar 2023 als auch nach genau 19 Jahren am 6.&amp;nbsp;Januar 2042. Dieser Sachverhalt ergibt sich daraus, dass nach dem Durchlauf eines Meton-Zyklus eine ganzzahlige Anzahl von 235&amp;nbsp;synodischen Perioden durchlaufen wird (gleiche '''Elongation''' des Mondes). Diese Vollmonde stehen bei der gleichen ekliptikalen Länge im Sternbild Zwillinge (Gemini). Dieser Sachverhalt ergibt sich daraus, dass nach dem Durchlauf eines Meton-Zyklus eine ganzzahlige Anzahl von 254&amp;nbsp;siderischen Perioden durchlaufen wird. Gleichzeitig steht auch die Sonne nach 19&amp;nbsp;tropischen Sonnenjahren auf dem Zodiak bei der gleichen ekliptikalen Länge und somit erneut genau gegenüber vom Mond im Sternbild Schütze (Sagittarius). Da die Meton-Periode nur gut einen halben Tag länger ist als 255&amp;nbsp;drakonitische Perioden, stehen diese beiden Vollmonde bei fast der gleichen ekliptikalen Breite nördlich vom Stern Mebsuta (ε&amp;nbsp;Geminorum).

'''Große Mondwenden''' mit maximaler Höhe des Mondes und längstem Bogen über dem Horizont folgen stets dem aufsteigenden Mondknoten (rot), und '''kleine Mondwenden''' mit minimaler Höhe des Mondes und kürzestem Bogen über dem Horizont folgen stets dem absteigenden Mondknoten (blau).

[[Datei:KleinsteMondwende.23.6.2024.HDR.png|mini|hochkant=2|'''Kleinste Mondwende um die Mittsommernacht 2024''': Der Vollmond (scheinbarer Durchmesser = 31,8&amp;nbsp;Minuten) am 23.&amp;nbsp;Juni 2024 nach ein Uhr und kurz vor der oberen Kulmination auf dem südlichen Meridian von Berlin-Lankwitz (nördliche geographische Breite = 52,44&amp;nbsp;Bogengrad) aus gesehen. Die ekliptikale Breite hatte einen Minimalwert, der fast 6&amp;nbsp;Bogengrad südliche Breite betrug und somit zu einer extrem geringen maximalen Höhe über dem Horizont von nur 8,5&amp;nbsp;Bogengrad führte. Im norwegischen Trondheim (nördliche geographische Breite = 63,44&amp;nbsp;Bogengrad, also drei Breitengrade südlich vom nördlichen Polarkreis) oder im isländischen Reykjavik (nördliche geographische Breite = 64,15&amp;nbsp;Bogengrad) war in diesen Tagen weder die Mitternachtssonne noch der Vollmond zu sehen. Der helle Stern rechts oberhalb der Mondscheibe ist Nunki im Schützen (σ Sagittarius, visuell 2,7&lt;sup&gt;m&lt;/sup&gt;), unterhalb ist Asella (ζ Sagittarius, visuell 4,2&lt;sup&gt;m&lt;/sup&gt;) zu sehen.]]

Die '''größte Mondwende''' bei Vollmond tritt nur zur Wintersonnenwende und die '''kleinste Mondwende''' bei Vollmond tritt nur zur Sommersonnenwende auf. Je nach ekliptikaler Breite des Mondes schwanken die absoluten Werte für die Horizontwinkel um das doppelte der Inklination der Mondbahn, das heißt insgesamt um bis zu 10,29&amp;nbsp;Bogengrad. Die ekliptikale Breite bezieht sich auf den Erdmittelpunkt, da dieser in der Ekliptikebene liegt. Die von der Erdoberfläche aus beobachtete ekliptikale Breite des im Mittel nur zirka 383100&amp;nbsp;Kilometer entfernten Mondes hängt zusätzlich vom jeweiligen geographischen Breitengrad der Beobachtung ab. Der in Bezug auf die Ekliptik nördlichste und südlichste Punkt auf der Erdoberfläche liegen um den Erdradius von gut 6350&amp;nbsp;Kilometer oberhalb (nördlich) beziehungsweise unterhalb (südlich) der Ekliptikebene. Daraus resultiert für die beobachtete ekliptikale Breite ein zusätzlicher Winkel von knapp einem Bogengrad:

:&lt;math&gt;\Delta \beta = \arctan \frac {\pm 6350} {383100} \approx \pm 0,95^\circ&lt;/math&gt;

Die '''größte Mondwende bei Vollmond''' (weiß) tritt bei maximaler ekliptikaler Breite des Mondes um die Wintersonnenwende (türkis, siehe Dezember&amp;nbsp;2023) auf. Die '''kleinste Mondwende bei Vollmond''' (weiß) tritt bei minimaler ekliptikaler Breite des Mondes um die Sommersonnenwende (gelb, siehe Juni 2024).

Im 19-jährigen Diagramm (siehe oben) ist gut zu erkennen, wie sich die Konstellation zwischen Mondknoten (rot und blau) und Mondphasen (weiß und schwarz) nach den 19&amp;nbsp;Jahren des '''Meton-Zyklus''' wiederholt (vergleiche Januar&amp;nbsp;2023 und Januar&amp;nbsp;2042).

Der erste aufsteigende Mondknoten (rot) wird fünf Tage vor Vollmond am 2.&amp;nbsp;Januar 2023 erreicht. Nach einer vollständigen '''Saros-Periode''' von 18&amp;nbsp;Jahren und 11&amp;nbsp;Tagen, also am 12.&amp;nbsp;Januar 2041 wird fünf Tage vor Vollmond ebenfalls wieder ein aufsteigender Mondknoten erreicht.

Eine Besonderheit gibt es im März 2038: Die Tag-und-Nacht-Gleiche erfolgt bereits am 20.&amp;nbsp;März 2038 (Samstag) und der erste Frühlingsvollmond nur einige Stunden später am 21.&amp;nbsp;März 2038 (Sonntag). Grundsätzlich müsste also der darauffolgende Sonntag, nämlich der 28.&amp;nbsp;März 2038, das '''Osterdatum''' sein. In diesem Fall greift die abweichende Regel, dass erst der Vollmond nach dem 21.&amp;nbsp;März als Frühlingsvollmond zu rechnen ist, was erst am 19.&amp;nbsp;April 2038 (Montag) der Fall ist. Demzufolge ist das Osterdatum auf den 25.&amp;nbsp;April 2038 (Sonntag) festgelegt.

Eine '''Sonnenfinsternis '''tritt immer dann auf, wenn ein Neumond (weiß) zeitnah durch einen aufsteigenden (rot) oder absteigenden (blau) Mondknoten läuft. Dies ist im obigen Diagramm an den folgenden Tagen der Fall:

* 20.&amp;nbsp;April 2023, 14.&amp;nbsp;Oktober 2023, 8.&amp;nbsp;April 2024, 2.&amp;nbsp;Oktober 2024, 29.&amp;nbsp;März 2025, '''21.&amp;nbsp;September 2025''' (Herbstäquinoktium), 17.&amp;nbsp;Februar 2026, 12.&amp;nbsp;August 2026, 6.&amp;nbsp;Februar 2027, 2.&amp;nbsp;August 2027, 26.&amp;nbsp;Januar 2028, 22.&amp;nbsp;Juli 2028, 14.&amp;nbsp;Januar 2029, 12.&amp;nbsp;Juni 2029, 11.&amp;nbsp;Juli 2029, 5.&amp;nbsp;Dezember 2029, 1.&amp;nbsp;Juni 2030, 25.&amp;nbsp;November 2030, 21.&amp;nbsp;Mai 2031, 14.&amp;nbsp;November 2031, 9.&amp;nbsp;Mai 2032, 3.&amp;nbsp;November 2032, 30.&amp;nbsp;März 2033, '''23.&amp;nbsp;September 2033''' (Herbstäquinoktium), '''20.&amp;nbsp;März 2034''' (Frühlingsäquinoktium), 12.&amp;nbsp;September 2034, 9.&amp;nbsp;März 2035, 2.&amp;nbsp;September 2035, 27.&amp;nbsp;Februar 2036, 23.&amp;nbsp;Juli 2036, 21.&amp;nbsp;August 2036, 16.&amp;nbsp;Januar 2037, 13.&amp;nbsp;Juli 2037, 5.&amp;nbsp;Januar 2038, 2.&amp;nbsp;Juli 2038, 26.&amp;nbsp;Dezember 2038, '''21.&amp;nbsp;Juni 2039''' (Sommersonnenwende), 15.&amp;nbsp;Dezember 2039, 11.&amp;nbsp;Mai 2040, 4.&amp;nbsp;November 2040, 30.&amp;nbsp;April 2041, 25.&amp;nbsp;Oktober 2041

Genau neunzehn Jahre nach den ersten beiden genannten Sonnenfinsternissen im Jahr&amp;nbsp;2023 treten an den gleichen Kalendertagen erneut zwei Sonnenfinsternisse auf, nämlich am 20.&amp;nbsp;April 2042 und am 14.&amp;nbsp;Oktober 2042.

Neunzehn Jahre vor den sechs ersten aufgeführten Sonnenfinsternissen in den Jahren&amp;nbsp;2023 bis&amp;nbsp;2025 traten an fast immer den gleichen Kalendertagen ebenfalls Sonnenfinsternisse auf, nämlich am 19.&amp;nbsp;April 2004, am 14.&amp;nbsp;Oktober 2004, am 8.&amp;nbsp;April 2005, am 3.&amp;nbsp;Oktober 2005, am 29.&amp;nbsp;März 2006 und am 22.&amp;nbsp;September 2006.

Eine '''Mondfinsternis '''tritt immer dann auf, wenn ein Vollmond (weiß) zeitnah durch einen aufsteigenden (rot) oder absteigenden (blau) Mondknoten läuft. Dies ist im obigen Diagramm an den folgenden Tagen der Fall:

* 5.&amp;nbsp;Mai 2023, 28.&amp;nbsp;Oktober 2023, 25.&amp;nbsp;März 2024, 18.&amp;nbsp;September 2024, 14.&amp;nbsp;März 2025, 7.&amp;nbsp;September 2025, 3.&amp;nbsp;März 2026, 28.&amp;nbsp;August 2026, 20.&amp;nbsp;Februar 2027, 18.&amp;nbsp;Juli 2027, 17.&amp;nbsp;August 2027, 12.&amp;nbsp;Januar 2028, 6.&amp;nbsp;Juli 2028, 31.&amp;nbsp;Dezember 2028, 26.&amp;nbsp;Juni 2029, '''20.&amp;nbsp;Dezember 2029''' (Wintersonnenwende), 15.&amp;nbsp;Juni 2030, 9.&amp;nbsp;Dezember 2030, 7.&amp;nbsp;Mai 2031, 5.&amp;nbsp;Juni 2031, 30.&amp;nbsp;Oktober 2031, 25.&amp;nbsp;April 2032, 18.&amp;nbsp;Oktober 2032, 14.&amp;nbsp;April 2033, 8.&amp;nbsp;Oktober 2033, 3.&amp;nbsp;April 2034, 28.&amp;nbsp;September 2034, 22.&amp;nbsp;Februar 2035, 19.&amp;nbsp;August 2035, 11.&amp;nbsp;Februar 2036, 7.&amp;nbsp;August 2036, 31.&amp;nbsp;Januar 2037, 27.&amp;nbsp;Juli 2037, 21.&amp;nbsp;Januar 2038, '''17.&amp;nbsp;Juni 2038''' (Sommersonnenwende), 16.&amp;nbsp;Juli 2038, 11.&amp;nbsp;Dezember 2038, 6.&amp;nbsp;Juni 2039, 30.&amp;nbsp;November 2039, 26.&amp;nbsp;Mai 2040, 18.&amp;nbsp;November 2040, 16.&amp;nbsp;Mai 2041, 8.&amp;nbsp;November 2041

&lt;gallery caption=&quot;Finsternisse&quot; perrow=&quot;1&quot; widths=&quot;1024&quot; heights=&quot;470&quot;&gt;
Finsternisse.2025.png|Die Finsternisse im Jahr 2025 liegen in der Nähe der Tag-und-Nacht-Gleichen, wo mittlere Mondwenden vorliegen. Der Mond geht im Osten auf und im Westen unter.
Finsternisse.2029.png|Die Finsternisse im Jahr 2029 liegen in der Nähe der Sonnenwenden. Bei der Sonnenfinsternis im Juni kommt es bei Neumond zu einer großen Mondwende, und bei der darauffolgenden Mondfinsternis kommt es bei Vollmond zu einer kleinen Mondwende. Bei der Sonnenfinsternis im Dezember kommt es bei Neumond zu einer kleinen Mondwende, und bei der darauffolgenden Mondfinsternis kommt es bei Vollmond zu einer großen Mondwende.
&lt;/gallery&gt;

==Der Kalenderstein vom Tempel Mnajdra==
Auf Malta wurde im Hypogäum von Ħal-Saflieni beim Ort Tarxien ein annähernd kreisrunder Stein aus der Tempelperiode der Insel mit zirka sechs Zentimeter Durchmesser gefunden, der wie die Darstellung einer Vollmondscheibe aussieht.&lt;ref&gt;Daniel Cilia: [http://web.infinito.it/utenti/m/malta_mega_temples/TempleFig/%20Pres,Misc/pages/face.htm Found in a house at Hal Saflieni, stone, c.6 cm wide], The megalithic temples of Malta - the world's most ancient stone architectur, DSCF9754&lt;/ref&gt; Im maltesischen Tempel Mnajdra sind an der südlichen Küste Maltas zirka zehn Kilometer entfernt davon zwei große Kalendersteine gefunden worden, die ebenfalls aus dieser Zeit stammen.

&lt;gallery caption=&quot;Die Ruinen der Tempelanlage von Mnajdra&quot; widths=&quot;300&quot; heights=&quot;300&quot; mode=&quot;packed&quot;&gt;
Plan_der_Tempel_von_Mnajdra.png|Plan der Tempelanlage. Die beiden Kalendersteine befinden sich in der Mitte des Urtempels im Osten der Anlage (Buchstabe &quot;A&quot;), die aus dem vierten vorchristlichen Jahrtausend stammt.
Mini_Europa_Brüssel-2125_Tempel_von_Mnajdra.jpg|Modell der Tempelanlage im Park &quot;Mini-Europa&quot; in Brüssel. Die Kalendersteine befinden sich links und rechts hinter der Frauenfigur auf der rechten Seite.
Malta_-_Qrendi_-_Hagar_Qim_and_Mnajdra_Archaeological_Park_-_Mnajdra_16_ies.jpg|Darstellung der Lochreihen der beiden Kalendersteine auf einer Schautafel der archäologischen Stätte.
Mnajdra_East_Temple_1_(6799974274).jpg|Blick vom Eingang des Osttempels auf die beiden aufrechtstehenden Kalendersteine – links der westliche und rechts der östliche Kalenderstein.
Mnajdra_Temple_-_Chris_Brown.jpg|Blick über die Kalendersteine – links der östliche und rechts der westliche Kalenderstein, den Eingang des Osttempels und die Südküste Maltas auf das Mittelmeer mit der vorgelagerten Insel Filfla.
&lt;/gallery&gt;

Auf dem östlichen Kalenderstein gibt es mehrere Lochreihen, deren Lochzahlen alle mit lunaren und solaren Kalendern in Zusammenhang gebracht werden können. In der heute zusammengestellten Anordnung der Steine können nicht alle Löcher gebohrt worden sein, da diese teilweise von anderen Steinen verdeckt sind. Die Bohrungen sind heute in horizontaler Richtung ausgerichtet, wurden damals vermutlich unter Ausnutzung der Gravitation senkrecht nach unten auf dem noch liegenden Stein ausgeführt. In dieser Ausrichtung des Steins wäre es auch leicht möglich gewesen, für Markierungs- oder Zählzwecke zum Beispiel kugelförmige Gegenstände in die Löcher zu legen. Steckkalender aus Stein mit Bohrungen (bei den Griechen hießen sie '''Parapegmata''') waren im Altertum an vielen Orten in Verwendung.

Am Kopf des Steins gibt es mehrere hundert, flächenhaft angeordnete Löcher, die eventuell für die einzelnen Monate oder Jahre einer langfristigen Beobachtung stehen. Darunter tauchen rechtsbündig sieben horizontale Lochreihen auf, die in der Skizze mit den Buchstaben A bis G gekennzeichnet sind, wobei die beiden Teilreihengruppen B1 und B2 sowie C1, C2 und C3 zusammengefasst betrachtet werden:

[[Datei:Kalenderstein.Mnajdra.labelled.png|mini|links|hochkant=3|Skizze der Lochreihen auf dem Kalenderstein von Mnajdra nach Ventura und Hoskin.&lt;ref name=&quot;Ventura&quot;&gt;Frank Ventura, Michael Hoskin: [[doi:10.1007/978-1-4614-6141-8_133|Temples of Malta]], in: Clive Ruggles (Herausgeber), ''Handbook of Archaeoastronomy and Ethnoastronomy'', 7. Juli 2014, Seiten 1421-1430, Springer, New York, ISBN 978-1-4614-6140-1&lt;/ref&gt;]]

{| class=&quot;wikitable&quot;
|+ Lochreihen auf dem östlichen Kalenderstein vom Tempel Mnajdra auf Malta
!title=&quot;Reihe&quot;| Reihe
!title=&quot;Anzahl der Löcher&quot;| Anzahl der Löcher
!title=&quot;Mögliche Verwendung&quot;| Mögliche Verwendung
|-
| A || 19 || Für die jeweilige Goldene Zahl jedes Sonnenjahres innerhalb des 19-jährigen '''Meton-Zyklus''' (235&amp;nbsp;synodische, 255&amp;nbsp;drakonitische, 254&amp;nbsp;siderische Monate beziehungsweise 6940&amp;nbsp;Tage).&lt;br/&gt;Nach einem Sonnenjahr hat die Sonne wieder die gleiche ekliptikalen Länge. Nach Ablauf der gesamten Meton-Periode hat der Mond wieder die gleiche Mondphase '''und''' die gleiche ekliptikalen Breite '''und''' die gleiche ekliptikalen Länge (zum Beispiel im Goldenen Tor der Ekliptik oder im Frühlingspunkt).
|-
| rowspan=2 | B || B&lt;sub&gt;1&lt;/sub&gt;: 13 (links) || rowspan=2 | In Summe 29, für die Anzahl der vollständigen Tage in einem '''synodischen Monat''' (29,5&amp;nbsp;Tage). Nach dieser Zeit hat der Mond wieder die gleiche Mondphase erreicht.&lt;br/&gt;Vom Altlicht des Mondes bis zum Vollmond sind es 16&amp;nbsp;Tage, und danach sind es 13&amp;nbsp;Tage bis zum nächsten Altlicht.&lt;br/&gt;Nachdem die Doppelreihe vervollständigt wurde, gibt es dafür einen Übertrag in die Reihe&amp;nbsp;E und wenn diese bereits voll ist, für das nächste beginnende Jahr mit der nächstfolgenden '''Goldenen Zahl''' einen Übertrag in die Reihe&amp;nbsp;A.
|-
| B&lt;sub&gt;2&lt;/sub&gt;: 16 (rechts darunter)
|-
| rowspan=3 | C || C&lt;sub&gt;1&lt;/sub&gt;: 3 (rechts oben) || rowspan=2 | Für die sieben vollständigen Tage eines '''Mondviertels''' (≈7,4&amp;nbsp;Tage) respektive einer '''Woche'''.&lt;br/&gt;Wenn diese Doppelreihe gefüllt ist, gibt es für die Vervollständigung einer neuen Woche einen Übertrag in die Reihe&amp;nbsp;G für die Wochen in einem Jahr.&lt;br/&gt;Alternativ könnten hier jeweils die drei Monate in den vier Jahreszeiten markiert und gezählt worden sein.&lt;br/&gt;Ein weiterer Zusammenhang besteht eventuell mit der Tatsache, dass in 19 Jahren (siehe Reihe A) sieben synodische Schaltmonate erforderlich sind, um in einem lunisolaren Kalender den Lauf von Sonne und Mond bis auf wenige Stunden genau zu synchronisieren (siehe hierzu auch''' [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|Plejaden-Schaltregeln]]''').
|-
| C&lt;sub&gt;2&lt;/sub&gt;: 4 (rechts unten)
|-
| C&lt;sub&gt;3&lt;/sub&gt;: 3 (links) || Für die drei nach Neumond '''vollendeten Mondviertel''' innerhalb eines laufenden synodischen Monats.&lt;/br&gt;Beim Erreichen eines Neumonds, eines abnehmenden Halbmonds, eines Vollmonds oder eines abnehmenden Halbmonds gibt es jeweils einen Übertrag in die Reihe&amp;nbsp;D oder in die Reihe&amp;nbsp;F (siehe unten).
|-
| D || 25 || Für die 25&amp;nbsp;'''vollendeten Mondviertel''' in der ersten Hälfte eines Sonnenjahres, oder entweder für alle '''zunehmenden Mondviertel''' (wenn der Mond zu Beginn des Jahres zunehmend war) oder für alle '''abnehmenden Mondviertel''' (wenn der Mond zu Beginn des Jahres abnehmend war) eines Sonnenjahres (vergleiche Reihe&amp;nbsp;F).
|-
| E || 11 || Nachdem die Doppelreihe B vollständig durchlaufen wurde, gibt es einen Übertrag in diese Reihe. Diese elf Mulden stehen dann für '''überzähligen Tage''' in einem Sonnenjahr (365,2&amp;nbsp;Tage) im Vergleich zu zwölf synodischen Monaten (354,4&amp;nbsp;Tage). Wenn diese Reihe bereits voll ist, gibt es für das nächste beginnende Jahr mit der nächstfolgenden '''Goldenen Zahl''' einen Übertrag in die Reihe&amp;nbsp;A.
|-
| F || 24 + 1 = 25 || Für die 24 bis 25 '''vollendeten Mondviertel''' in der zweiten Hälfte eines Sonnenjahres, oder entweder für alle '''abnehmenden Mondviertel''' (wenn der Mond zu Beginn des Jahres zunehmend war) oder für alle '''zunehmenden Mondviertel''' (wenn der Mond zu Beginn des Jahres abnehmend war) eines Sonnenjahres (vergleiche Reihe&amp;nbsp;D). Das 25.&amp;nbsp;Loch ist etwas abgesetzt, da es für ein am Ende des Jahres eingeschaltetes 50.&amp;nbsp;Mondviertel (Dauer = 7,38265&amp;nbsp;Tage) steht, das nur in ungefähr jedem zweiten Sonnenjahr auftritt:&lt;br/&gt;
:49 x 7,38265 Tage ≈ 361,75 Tage beziehungsweise 50 x 7,38265 Tage ≈ 369,13 Tage&lt;br/&gt;
:365,242 Tage - 361,75 Tage ≈ 3,5 Tage beziehungsweise 365,242 Tage - 369,13 Tage ≈ -3,9 Tage
|-
| G || 53 || Für die begonnenen 53 '''Siebentagewochen''' in einem Sonnenjahr (Dauer = 365,242&amp;nbsp;Tage) beziehungsweise von einem heliakischen Auf- oder akronychischen Untergang der Plejaden zum nächsten.
|}

[[Datei:Altlicht.16.9.2020.P1079087.jpg|mini|rechts|Über dem östlichen Horizont beim Morgenletzt gerade noch sichtbares Altlicht des abnehmenden Mondes 33 Stunden vor Neumond mit der vom Erdschein beleuchteten Nachtseite des Mondes. Die Aufnahme entstand kurz vor Herbstbeginn, als die Ekliptik morgens fast senkrecht auf dem Horizont stand.]]

Zu der Doppelreihe&amp;nbsp;B sei angemerkt, dass auch im altägyptischen Mondkalender, der im Neolithikum in Verwendung war, der Monat nicht mit dem unsichtbaren Neumond, sondern mit dem gerade noch sichtbaren Altlicht des Morgenletztes des Mondes begann, also gut einen Tag vor Neumond.&lt;ref&gt;Joachim Friedrich Quack: [https://core.ac.uk/download/pdf/35120251.pdf Zwischen Sonne und Mond - Zeitrechnung im Alten Ägypten], Seite 38, in: Harry Falk (Herausgeber), ''Vom Herrscher zur Dynastie. Zum Wesen kontinuierlicher Zeitrechnung in Antike und Gegenwart'', Bremen 2002&lt;/ref&gt; Die beiden letzten Löcher sind etwas nach links abgesetzt, was mit folgendem Sachverhalt im Einklang steht: zwei Tage vor dem Ende einer synodischen Periode, also schon nach gut 27&amp;nbsp;Tagen, ist ein siderischer Monat vorüber, nach welchem der Mond die gleiche ekliptikale Länge erreicht hat. Das heißt bereits nach gut 27&amp;nbsp;Tagen steht der Mond zum Beispiel wieder im Goldenen Tor der Ekliptik, bevor er erst nach gut 29&amp;nbsp;Tagen erneut sein Altlicht erreicht (gut einen Tag vor Neumond). Die Sonne ist innerhalb des synodischen Monats durch die Bewegung der Erde um die Sonne gegenüber dem Fixsternhimmel um knapp 30&amp;nbsp;Bogengrad weiter nach links gezogen.

Die 25&amp;nbsp;Wochen des abnehmenden Mondes werden zum Beispiel auch im 79.&amp;nbsp;Kapitel des ungefähr 2000&amp;nbsp;Jahre alten {{w|Äthiopisches Henochbuch|äthiopischen Henochbuches}} erwähnt.&lt;ref&gt;Siehe auch {{s|Henochbuch_(oder_Erster_Henoch)#Der_dritte_Teil_72–82_Das_astronomische_Buch|Wikisource, Henochbuch, Teil 3, Kapitel 71 bis 82}}&lt;/ref&gt; Alternativ könnten die 50&amp;nbsp;Löcher in Reihen&amp;nbsp;D und F eventuell auch für die 50 vollständigen Siebentagewochen (350&amp;nbsp;Tage) innerhalb von zwölf synodischen Perioden stehen, die eine Dauer von 50,6&amp;nbsp;Wochen beziehungsweise 354,4&amp;nbsp;Tagen haben.

Zur Zahl Elf (Reihe&amp;nbsp;E) ist noch festzuhalten, dass die Erde innerhalb eines siderischen Jahres des Planeten Jupiter (zwölf Erdenjahre) elf Mal mit diesem in Opposition steht. Zu diesen Zeitpunkten ist der Abstand zwischen Erde und Jupiter am geringsten, der Jupiter hat steht in seinem größten Glanz und er kulminiert um Mitternacht auf dem südlichen Meridian.

[[Datei:Mnajdra East Temple 2 (6946102161).jpg|rechts|mini|Detail des westlichen Kalendersteins aus dem Osttempel von Mnajdra.]]

Auch auf einem weiteren, sogenannten westlichen und heute ebenfalls aufgerichteten Stein der Tempelanlage sind mehrere Lochreihen zu sehen, die aus 16, 12, 19, 7, 30, 31, 32, 35, 37, 12 und 13 Löchern bestehen.&lt;ref&gt;David Humiston Kelley, Eugene Frank Milone: ''Exploring Ancient Skies: A Survey of Ancient and Cultural Astronomy'', Part II ''Astronomy in Cultures'', 6 ''Paleolithic and Neolithic Cultures'', 6.2 ''Megalithic Cultures'', 6.2.18 ''Mediterranean and North African Megalithic Sites'', 6.2.18.1 ''Malta'', pages 201 and 202, Springer, 2011, ISBN 9781441976246&lt;/ref&gt; Einige dieser Zahlen tauchen auch im Zusammenhang mit dem östlichen Stein auf oder sind ebenfalls leicht mit lunaren oder solaren Kalendertagen in Verbindung zu bringen:

* 16: Anzahl der Tage vom Altlicht bis zum Vollmond.
* 12: Anzahl der vollständigen Monate pro Jahr.
* 19: Anzahl der tropischen Jahre pro Meton-Periode.
* 7: Anzahl der vollständigen Tage pro Mondviertel respektive der Tage pro Woche.
* 30: aufgerundete Anzahl der Tage pro synodische Periode respektive der Tage pro Monat.

→ In Bezug auf die Bedeutung von bestimmten Zahlen in der Astronomie siehe auch '''[[Quadriviale Kuriositäten‎/ Zahlen|Exkurs „Zahlen“]]'''.
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

==Malereien in der Höhle von Magura==
In der schon im Neolithikum genutzten Magura-Höhle im Nordwesten des heutigen Bulgariens gibt es nicht nur eine sehr alte bildliche Darstellung eines Schöpfungsmythos, sondern ebenfalls Hinweise darauf, dass verschiedene Mondzyklen bekannt waren. Unter den Darstellungen befindet sich insbesondere eine Reihe von Strichen, mit denen die 16&amp;nbsp;Tage vom Altlicht des Mondes bis zu Vollmond gezählt worden sein können.

→ Weitere Erläuterungen finden sich im '''[[Die_Höhlenmalerei_in_der_Magura-Höhle|Wikibook „Die Höhlenmalerei in der Magura-Höhle“]]'''.

[[Datei:Magura.Altlicht.Vollmond.png|links|mini|hochkant=4|Erste Hälfte des synodischen Monats in einer Darstellung der Höhlenmalerei von Magura. Rechts ist die schmale, liegende Mondsichel des Altlichts beim Morgenletzt zu sehen. Ein bis zwei Tage später ist Neumond, danach nimmt der Mond wieder zu, und nach insgesamt sechzehn Tagen wird der Vollmond erreicht (links).]]
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

== Kontrastverhältnisse bei aschgrauem Mondlicht ==
[[Datei:Aschgraues.Mondlicht.P1162513.jpg|mini|hochkant=2|Die vom Erdschein beleuchtete Nachtseite des Mondes wird neben der schmalen Mondsichel (11&amp;nbsp;Prozent, Mondalter = 3,3&amp;nbsp;Tage) mit ''aschgrauem Mondlicht'' sichtbar. Aufnahme über dem westlichen Abendhimmel kurz nach dem Äquinoktium im Frühjahr bei besonders steiler Ekliptik von Berlin aus gesehen. Links der Stern Omikron Arietis (37 Ari, 6,2&lt;sup&gt;m&lt;/sup&gt;) im Sternbild Widder.&lt;br/&gt;&lt;br/&gt;
Mit bloßen Augen ist das aschgraue Licht im Mondschatten nur unter sehr guten atmosphärischen Bedingungen und mit voller menschlicher Sehkraft gerade noch erkennbar. Der Mond hat nur einen Winkeldurchmesser von 0,5 Bogengrad, was bei ausgestrecktem Arm nur ungefähr einem Viertel der Breite eines Fingers entspricht. Die hier gezeigte Aufnahme ist sehr hell belichtet, so dass die Kontraste im Mondschatten einfacher wahrzunehmen sind als in der Natur:
[[Datei:Aschgraues.Mondlicht.P1162513.jpg|90px|zentriert]]
]]

Das '''aschgraue Mondlicht''' kann wenige Tage vor und nach Neumond im Schattenbereich des Mondes beobachtet werden, wenn die Sonne unter dem Horizont steht. Der Schattenbereich wird hierbei durch den '''Erdschein''' beleuchtet und hebt sich deutlich sichtbar vom Himmel ab, der den Mond umgibt. Der Erdschein hängt vom Albedo der vom direkten Sonnenlicht getroffenen Erde ab und kann insbesondere durch den Anteil an Wolken in der Atmosphäre sowie an Eis- und Schneeflächen auf der Erdoberfläche schwanken.

=== Historische Beobachtungen ===
Bereits die Babylonier haben im sechsten vorchristlichen Jahrhundert diesen visuellen Effekt in bildlichen Darstellungen auf Steinreliefs mit dem König Nabonid vor der Mondsichel mit aschgrauem Licht festgehalten:&lt;ref&gt;Friedhelm Pedde: ''[https://wfs.berlin/wp-content/uploads/2021/09/BROplanet-12-okt2021ff_www.pdf Götter und Planeten im Alten Orient - Sin und der Mond]'', Mitteilungen, Ausgabe 12, Seite 6 und 7, Oktober 2021, Wilhelm-Foerster-Sternwarte e.V. / Zeiss-Planetarium am Insulaner&lt;/ref&gt;

&lt;gallery caption=&quot;&quot; mode=&quot;packed&quot; widths=&quot;600&quot; heights=&quot;400&quot;&gt;
Urfa museum King Nabonid embossed inscription Iron age - 5026.jpg|Darstellung des letzten Königs des Neubabylonischen Reiches, Nabonid, vor der Mondsichel mit aschgrauem Mondlicht am Kopf einer babylonischen Stele aus Harran im Archäologischen Museum Şanlıurfa in der Türkei aus dem sechsten vorchristlichen Jahrhundert.
Nabonidus.jpg|Darstellung des letzten Königs des Neubabylonischen Reiches, Nabonid, vor der Mondsichel mit aschgrauem Mondlicht am Kopf einer babylonischen Stele im Britischen Museum.
Voynich.68r.Mondsichel.Erdschein.png|Darstellung der Mondsichel mit einem Gesicht im Schattenbereich des Mondes im astronomischen Abschnitt des Voynich-Manuskripts aus dem 15.&amp;nbsp;Jahrhundert.
Caspar David Friedrich - Zwei Männer in Betrachtung des Mondes.jpg|Zwei Männer am Abend bei der Betrachtung des Neulichts von Caspar David Friedrich (1819/1820), Öl auf Leinwand, Albertinum, Dresden. Eine in dieser Darstellung ähnliche Konstellation zwischen einer solchen Mondsichel und dem Planeten Jupiter fand am Abend des 28.&amp;nbsp;Märzes 1811 im Sternbild Stier (Taurus) statt. Eine Woche nach der Tag-und-Nacht-Gleiche des Frühjahrs stand der Mond wie im Bild dargestellt mit stark geneigter Sichel etwas tiefer als der Jupiter über dem westlichen Horizont.
Moon - Artemis II - April 6 2026 (55193552739).jpg|Die Aufnahme der Artemis-II-Besatzung während ihres Mondvorbeiflugs am 6.&amp;nbsp;April 2026 zeigt eine Sonnenfinsternis. Am linken Rand der Mondscheibe ist das schwache Leuchten des aschgrauen Mondlichts zu erkennen, das vom Erdschein der links vom Mond befindlichen Erde hervorgerufen wurde.
&lt;/gallery&gt;

=== Bestimmung der Kontraste ===
[[Datei:Altlicht.Mond.P1116624.jpg|mini|rechts|hochkant=2|Altlicht des Mondes am 3.&amp;nbsp;November&amp;nbsp;2021 mit aschgrauem Licht im Schattenbereich des Mondes von Berlin aus gesehen.]]

Das nebenstehende Bild des Altlichts (Mondalter 27,7 von 29,5 Tagen) im Sternbild Jungfrau wurde am 3.&amp;nbsp;November&amp;nbsp;2021 um 7:05&amp;nbsp;Uhr morgens mit einem hochwertigen Teleobjektiv mit guter Kontrastübertragung über dem ostsüdöstlichen Horizont (Azimut 122&amp;nbsp;Bogengrad) in Berlin aufgenom­men. Die Sonne stand zum Zeitpunkt der Aufnahme noch gut ein Bogengrad unter dem Hori­zont, der Mond hatte eine nördliche ekliptikale Breite von gut 3&amp;nbsp;Bogengrad und eine Elongation von 22&amp;nbsp;Bogengrad, so dass er bei wolkenlosem Himmel und bei einer Höhe von 17,5&amp;nbsp;Bogengrad über dem Horizont gut zu beobachten war. Die Mondscheibe war mit bloßem Auge vollständig sichtbar und war zu 3,7&amp;nbsp;Prozent vom direkten Sonnenlicht beleuchtet.

Die aufgenommenen Rohdaten wurden für diese Auswertung mit einer Software mit mög­lichst neutralen Einstellungen zu einer Schwarz-Weiß-Aufnahme entwickelt (Kontrast = 1, Gamma = 1, Farbtemperatur = 4100&amp;nbsp;Kelvin, Farbsättigung = 0). Anhand der Bilddaten können die Luminanzwerte (Helligkeiten) im Bild bestimmt werden, um aus beliebigen paarweisen Luminanzwerten den jeweiligen Kontrast zu berechnen. Der '''Michelson-Kontrast''' &lt;math&gt;M&lt;/math&gt; (auch '''Modulation'''), der sich aus zwei benachbarten Luminanzwerten &lt;math&gt;L_2&lt;/math&gt; und &lt;math&gt;L_1&lt;/math&gt; ergibt (Bedingung: &lt;math&gt;L_2 \ge L_1 \ge 0&lt;/math&gt;), liegt immer zwischen 0 (&lt;math&gt;L_2 = L_1&lt;/math&gt;, also kein Kontrast) und 1 beziehungsweise 100&amp;nbsp;Prozent (&lt;math&gt;L_1 = 0&lt;/math&gt;, also maxi­maler Kontrast):

:&lt;math&gt;M = \frac {L_2 - L_1} {L_2 + L_1}&lt;/math&gt;

→ Siehe auch [[Digitale_bildgebende_Verfahren:_Grundlagen#Modulation|Wikibook '''Digitale bildgebende Verfahren''', Kapitel '''Grundlagen''', Abschnitt '''Modulation''']].

Die Sichel ist in der ausgewerteten Aufnahme nicht überbelichtet, hat im Scheitel einen mittleren Luminanzwert von:

:&lt;math&gt;L_{Sichel} = 236&lt;/math&gt;

Der den Mond umgebende Himmel hat durch das vorhandene Streulicht in der Troposphäre einen mittleren Luminanzwert von:

:&lt;math&gt;L_{Himmel} = 15&lt;/math&gt;

Daraus resultiert ein entsprechend hoher Michelson-Kontrast &lt;math&gt;M&lt;/math&gt;:

:&lt;math&gt;M_{Sichel,Himmel} = \frac {L_{Sichel} - L_{Himmel}} {L_{Sichel} + L_{Himmel}} = \frac {236 - 15} {236 + 15} = \frac {221} {251} = 0,88&lt;/math&gt;

Im aschgrauen Licht in der Schattenseite des abnehmenden Mondes (dessen gesamte scheinbare Helligkeit beträgt bei der in der Abbildung sichtbaren Mondphase übrigens ungefähr -3&lt;sup&gt;m&lt;/sup&gt;), die vom Erdschein beleuchtet wird, ergibt sich für die etwas variierende Reflektivität der Mondoberfläche ein mittlerer Luminanzwert von:

:&lt;math&gt;L_{Schatten} = 24,5&lt;/math&gt;

Im Vergleich zur hellen Mondsichel ergibt sich daraus ein etwas geringerer Kontrast zwischen Mondsichel und Mondschatten als zwischen Mondsichel und Nachthimmel:

:&lt;math&gt;M_{Sichel,Schatten} = \frac {L_{Sichel} - L_{Schatten}} {L_{Sichel} + L_{Schatten}} = \frac {236 - 24,5} {236 + 24,5} = \frac {211,5} {260,5} = 0,81&lt;/math&gt;

Die Standardabweichung beträgt in der Schattenseite des abnehmenden Mondes:

:&lt;math&gt;L_{Abweichung} = 2,5&lt;/math&gt;.

Innerhalb der sichtbaren Schattenseite des Mondes resultiert aus den dort mit einer Standardabweichung um den Mittelwert herum auftretenden Luminanzwerten für das aschgraue Licht ein Kontrast von nur 10&amp;nbsp;Prozent:

:&lt;math&gt;M_{Schatten} = \frac {(L_{Schatten} + L_{Abweichung}) - (L_{Schatten} - L_{Abweichung})} {(L_{Schatten} + L_{Abweichung}) + (L_{Schatten} - L_{Abweichung})} = \frac {L_{Abweichung}} {L_{Schatten}}= \frac {2,5} {24,5} = 0,10&lt;/math&gt;

Dieser Kontrastwert ergibt sich im Übrigen im gleichen Maße auch auf der von der Sonne voll beleuchteten und dann jedoch insgesamt erheblich helleren Oberfläche des Vollmonds (die scheinbare Helligkeit beträgt dann ungefähr -13&lt;sup&gt;m&lt;/sup&gt;).

:'''Anmerkung''': ''Die Sinnhaftigkeit der Kontrastbestimmung mit der Standardabweichung begründet sich in der Tatsache, dass eine perfekte schwarz-weiße Kante mit einem maximalen Luminanzwert &lt;math&gt;L_{max}&lt;/math&gt; im hellen Bereich und einem Luminanzwert von Null im dunklen Bereich eine Modulation &lt;math&gt;M&lt;/math&gt; von eins hat, sofern die weiße und die schwarze Teilfläche gleich groß sind und jeweils &lt;math&gt;\frac {n} {2}&lt;/math&gt; Messwerte beinhalten. Sowohl der Mittelwert aller &lt;math&gt;n&lt;/math&gt; Luminanzwerte als auch die Standardabweichung aller &lt;math&gt;n&lt;/math&gt; Luminanzwerte sind dann beide genau halb so groß wie der maximale Luminanzwert:''

::&lt;math&gt;L_{Mittelwert} = \sum_{i=1}^n L_{i} = \sum_{i=1}^{\frac {n} {2}} 0 + \sum_{i=1}^{\frac {n} {2}} L_{max} = \frac {L_{max}} {2}&lt;/math&gt; 
::&lt;math&gt;L_{Standardabweichung} = \sqrt {\frac {\sum_{i=1}^n (L_{i} - L_{Mittelwert})^2} {n}} = \sqrt {\frac {\sum_{i=1}^n \left( \frac {L_{max}} {2} \right)^2} {n}} = \sqrt {\frac {n \cdot \left( \frac {L_{max}} {2} \right)^2} {n}} = \frac {L_{max}} {2}&lt;/math&gt;

:''Der Mittelwert zuzüglich der Standardabweichung entspricht dann dem maximalen Luminanzwert:''

::&lt;math&gt;L_{Mittelwert} + L_{Standardabweichung} = \frac {L_{max}} {2} + \frac {L_{max}} {2} = L_{max}&lt;/math&gt;

:''Und der Mittelwert abzüglich der Standardabweichung hat dann den Wert Null:''

::&lt;math&gt;L_{Mittelwert} - L_{Standardabweichung} = \frac {L_{max}} {2} - \frac {L_{max}} {2} = 0&lt;/math&gt;

:''Der auf diesem Weg bestimmte Kontrast stimmt mit dem oben genannten Kontrast an der Kante überein:''

::&lt;math&gt;M = \frac {L_{max} - 0} {L_{max} + 0} = \frac {L_{max}} {L_{max}} = 1&lt;/math&gt;

Schließlich kann auch noch der Kontrast an der Außenkante der nur vom Erdschein beleuch­teten Mondscheibe bestimmt werden, also zwischen aschgrauem Mondlicht und Himmel:

:&lt;math&gt;M_{Schatten,Himmel} = \frac {L_{Schatten} - L_{Himmel}} {L_{Schatten} + L_{Himmel}} = \frac {24,5 - 15} {24,5 + 15} = \frac {9,5} {39,5} = 0,24&lt;/math&gt;

Dieser Kontrast ist also deutlich höher als der innerhalb des Mondschattenbereichs. Die Helligkeit wechselt an der Kante der Mondscheibe zudem schlagartig und ist deswegen besser wahrnehmbar als die Helligkeitsunterschiede innerhalb des Schattenbereiches, wie im Folgenden ausgeführt wird.

=== Wahrnehmungsphysiologie ===
[[Datei:CSF.against.angular.frequency.in.cycles.per.degree.png|mini|rechts|hochkant=2|Kontrastempfindlichkeitsfunktion (englisch: Contrast Sensitivity Function, CSF) des menschlichen Auges über der Ortsfrequenz &lt;math&gt;f_a&lt;/math&gt; in Linienpaaren pro Grad.]]

Strukturen, bei denen sich die Helligkeit innerhalb eines achtel Bogengrades (7,5&amp;nbsp;Bogen­minuten) ändert, werden von einem gesunden menschlichen Auge nahezu perfekt auf die Netzhaut übertragen und sind deshalb am besten wahrzunehmen. Weichere Strukturen mit sich langsamer und kontinuierlich ändernder Helligkeit oder kleinere Strukturen sind bei gleichem Objektkontrast schwieriger zu erkennen. Ob ein bestimmter Objektkontrast mit bloßem Auge wahrgenommen werden kann, kann mit Hilfe der Kontrastempfindlichkeits­funktion (Contrast Sensitivity Function (CSF)) des menschlichen Auges ermittelt werden, bei der die Kontrastübertragung von einem Objekt auf die Netzhaut des Auges über der Ortsfrequenz in Linienpaaren pro Bogengrad angegeben ist:

→ Siehe auch [[Digitale_bildgebende_Verfahren:_Grundlagen#Kontrastempfindlichkeitsfunktion|Wikibook '''Digitale bildgebende Verfahren''', Kapitel '''Grundlagen''', Abschnitt '''Kontrastempfindlichkeitsfunktion''']].

[[Datei:CSF.UHD.png|mini|rechts|hochkant=2|Zur Kontrastempfindlichkeitsfunktion des menschlichen Auges mit den Ortsfrequenzen von 2&amp;nbsp;sinusmodulierten Linienpaaren pro Bildbreite (linke Bildhälfte) bis hin zu 1024&amp;nbsp;Linienpaaren pro Bildbreite (rechts am Bildrand), Bildgröße 3860&amp;nbsp;mal 2160&amp;nbsp;Bildpunkte (16:9) mit maximalem Kontrast unten, ohne Kontrast oben.]]

Das nebenstehende Diagramm und die darunter befindliche unfarbige Graphik mit den sinusförmigen Helligkeitsmodulationen visualisieren dies. Von links nach rechts wächst die Ortsfrequenz ausgehend von zwei Linienpaaren pro Bildbreite immer weiter, und der Kontrast ändert sich in vertikaler Richtung kontinuierlich zwischen den Extremwerten 0&amp;nbsp;und&amp;nbsp;1. Bei großen und sehr kleinen Ortsfrequenzen sind geringe Kontraste nicht so gut zu erkennen wie im mittleren Bereich. Die maximale Empfindlichkeit wird bei acht Linienpaaren pro Bogengrad erreicht und hängt bei einem gegebenen Objekt demzufolge vom Betrachtungsabstand ab.

Das Auge kann nach dieser Kontrastempfindlichkeitsfunktion innerhalb eines Bogengrades maximal bis zu 80&amp;nbsp;Linien mit maximalem Objektkontrast (also 40&amp;nbsp;Linienpaare mit dem Kontrast&amp;nbsp;1) wahrnehmen. In diesem Fall liegt der wahrgenommene Kontrast zwischen den benachbarten Linien bei ungefähr 5&amp;nbsp;Prozent. Bei 120&amp;nbsp;Linien mit maximalem Objektkontrast (also 60&amp;nbsp;Linienpaare mit dem Kontrast&amp;nbsp;1) sinkt der wahrgenommene Kontrast auf unter ein Prozent und ist somit praktisch nicht mehr wahrnehmbar. Wegen des scheinbaren Winkeldurchmessers der Mondscheibe von 0,5&amp;nbsp;Bogengrad, kann das Auge innerhalb des Monddurchmessers also maximal 20&amp;nbsp;Linienpaare beziehungsweise 40&amp;nbsp;Linien unterscheiden. Insbesondere an der scharfen Kante der Mondscheibe ist eine ins Auge nahezu verlustfrei übertragene Ortfrequenz von acht Linienpaaren pro Bogengrad stark vertreten, so dass der in der obigen Aufnahme des Mondes vorhandene Objektkontrast von 24&amp;nbsp;Prozent zwischen Mondschatten und Himmel (siehe oben) gut wahrgenommen werden kann.

Etwas schwieriger gestaltet sich dies innerhalb des Schattenbereichs des Mondes. In der obigen Aufnah­me tauchen die stärksten Kontraste entlang einer Linie von oben nach unten auf, wo die helleren Mondebenen mit den Kratern Copernicus und Tycho durch die dunkleren Maria Imbrium und Nubium unterbrochen werden. Daraus resultiert eine Ortsfrequenz mit fünf Linienpaaren pro Bogengrad, wo die Kontrastempfindlichkeitsfunktion ebenfalls einen recht hohen Wert von 0,9&amp;nbsp;beziehungsweise 90&amp;nbsp;Prozent erreicht. Dies schwächt den auf der Mond­oberfläche vorhandenen Objektkontrast von 10&amp;nbsp;Prozent im vom Auge auf die Netzhaut übertragenen Bildkontrast nur geringfügig ab.

Aus diesen Überlegungen resultiert, dass die im aschgrauen Licht des Mondes wahrnehmba­ren Kontraste knapp 10 Prozent betragen. Diese sind zwar geringer als der Kontrast von 24&amp;nbsp;Prozent zwischen dem aschgrauen Mondlicht und dem den Mond umgebenden Himmel, sie liegen allerdings noch in einem wahrnehmbaren Bereich. Somit ist erwiesen, dass ein gesundes Auge unter idealen Beobachtungsbedingungen auch völlig ohne optische Hilfsmittel die Helligkeitsunterschiede und Strukturen im nur durch den Erdschein erhellten Schattenbereich des Mondes erkennen kann.

Es gibt jedoch zahlreiche Faktoren, die den wahrnehmbaren Kontrast deutlich herabsetzen oder die Möglichkeit der Wahrnehmung verhindern können. Je älter ein Mensch wird, desto mehr Streulicht wird durch kleinste Verletzungen beziehungsweise Narben in der Hornhaut oder in der Linse des Auges erzeugt. Dieses Streulicht erzeugt einen mehr oder weniger gleichmäßigen Lichtschleier, der auch die dunklen Stellen auf der Netzhaut beleuchtet. Dies führt in jedem Fall zu einer Herabsetzung des wahrnehmbaren Kontrastes und verhindert somit das Erkennen von schwachen Kontrasten.

=== Begrenzende Einflüsse ===
Aber auch in der Natur gibt es viele begrenzende Faktoren. Hierzu gehört das natürliche Streulicht durch die Sonne in der Troposphäre, wenn diese zu dicht am Mond oder zu dicht unter dem Horizont oder gar über dem Horizont steht. In bewohnten Gegenden kommt als großer Störfaktor noch die Lichtverschmutzung hinzu. Ferner wird der Objektkontrast durch atmosphärische Störungen vermindert. Diese ergeben sich zum einen durch Dunst, Nebel oder Staub in der Atmosphäre, und zum anderen aus den langen Wegstrecken, die das Licht bei einer Beobachtung eines Himmelsobjekts durch die Troposphäre zurücklegen muss, wenn dieses sehr dicht über dem Horizont steht. Hierbei wird das den Beobachter erreichende Licht nicht nur abgeschwächt ('''Extinktion'''), sondern auch durch das Licht aller möglichen anderen Lichtquellen angereichert, das an den Luftmolekülen gestreut oder durch Mikroturbulenzen abgelenkt wurde, so dass sich die minimal vorhandene Helligkeit vergrößert und der Kontrast somit verringert. In bewohnten Regionen ist zudem mit erheblicher Lichtverschmutzung durch künstliche Lichtquellen zu rechnen.

Auf der anderen Seite wird insbesondere in Horizontnähe der blaue Lichtanteil von astronomischen Objekten auf dem Lichtweg durch die Troposphäre durch die stark wellenlängenabhängige '''Rayleigh-Streuung''' seitlich abgelenkt, so dass es praktisch gar nicht mehr zum Beobachter gelangt. Dies führt zu den rötlichen Auf- und Untergängen von Sonne und Mond sowie zur Blaufärbung des Taghimmels.

Unter Umständen muss das Licht mehrere hundert Kilometer durch die Atmosphäre zurücklegen, wie in der folgenden Abbildung zu erkennen ist:

[[Datei:Troposphaerische.Laengen.png|mini|zentriert|hochkant=4|Weglängen für Lichtstrahlen in der 15&amp;nbsp;Kilometer hohen Troposphäre in Abhängigkeit von der Zenitdistanz.]]

=== Beobachtung ===
Die Beobachtungsmöglichkeiten des aschgrauen Lichts werden grundsätzlich durch die folgenden, sich teilweise widerstrebenden Bedingungen verbessert:

* Die '''Lichtverschmutzung''' in der Atmosphäre ist gering.
* Das '''Mondalter''' beträgt wenige Tage vor oder nach Neumond.
* Die '''Sonne''' steht möglichst weit unter dem Horizont.
* Der '''Mond''' hat eine möglichst große Höhe über dem Horizont.
* Die '''Mondsichel''' ist möglichst klein, um möglichst wenig Streulicht zu verursachen.

Für die Beobachtung aus nördlichen geographischen Breiten gilt insbesondere:

* Der Mond hat eine möglichst große '''nördliche ekliptikale Breite''' zwischen seinem aufsteigenden und seinem absteigenden Knoten.
* Die '''Ekliptik''' steht möglichst steil auf dem Horizont. Dies ist bei den Tag-und-Nacht-Gleichen der Fall, besonders gut
** abends im Frühjahr beim '''Neulicht''' des Mondes nach Sonnenuntergang im Westen.
** morgens im Herbst beim '''Altlicht''' des Mondes vor Sonnenaufgang im Osten.

=== Farbigkeit ===
[[Datei:Neulicht.21.3.2026.HDR.1024.png|mini|hochkant=2|Die Abbildung zeigt eine Hochkontrastaufnahme des Erdscheins im Mondschatten zum Frühlingbeginn drei Tage nach Neumond mit Sternen bis zur zehnten Größenklasse (10&lt;sup&gt;m&lt;/sup&gt;) in der Umgebung. Die Sichel zeigte einen Tag nach der Tag-und-Nacht-Gleiche im Frühjahr 2026 und zwei Tage vor der großen Mondwende bei einer nördlichen ekliptikalen Breite des Mondes von vier Bogengrad eine besonders starke Neigung. Die Sonne war zuvor im Westen untergegangen und stand bereits elf Bogengrad unter dem Horizont. Die Symmetrieachse der Mondsichel (-7&lt;sup&gt;m&lt;/sup&gt;) auf der zu 9,3&amp;nbsp;Prozent beleuchteten Mondscheibe zeigt nach rechts unten in Richtung der Sonne (Farbtemperatur = 4100 Kelvin, Belichtungsreihe mit sieben Bildern in ganzen Blendenstufen).]]

Bei genauer Betrachtung und Beobachtung ist das sogenannte aschgraue Licht gar nicht farbneutral, sondern spiegelt einen mittleren Farbton der von der Sonne beleuchteten Erdoberfläche wider, von der wiederum der Mondschatten beleuchtet wird. Je niedriger der Bewölkungsgrad, desto stärker ist zudem der Einfluss der farbigen Oberfläche der Erde. Die Farben der Erdoberfläche schwanken hierbei deutlich zwischen den Ozeanen, Wäldern oder Wüsten. In der nebenstehenden Hochkontrastaufnahme zeigt der Mondschatten im HSV-Farbraum einen mittleren Farbwert mit dem Farbwinkel 202°, was als Farbton blaucyan übersetzt werden kann. Dies entspricht recht gut dem mittleren Farbton der der Sonne zugewandten Seite der Erde (&quot;Blue Marble&quot;) während der Aufnahme, der für das hier gezeigte Beispielbild im HSV-Farbraum einen mittleren Farbwert mit dem Farbwinkel 201° hat. Der Farbwinkel ist von der Sättigung oder der Helligkeit nicht abhängig.

[[Datei:Neulicht.21.3.2026.HDR.Original.Durchschnitt.gesaettigt.aufgehellt.png|mini|links|hochkant=4|Sichtbarmachung des Farbwerts mit dem Farbwinkel 202° des aschgrauen Mondlichts in einer Hochkontrastaufnahme des Erdscheins im Mondschatten zum Frühlingbeginn drei Tage nach Neumond.&lt;br/&gt;Von links nach rechts:&lt;br/&gt;1. Originalaufnahme&lt;br/&gt;2. Mittelwert&lt;br/&gt;3. Farbe gesättigt&lt;br/&gt;4. aufgehellt]]
[[Datei:North America from low orbiting satellite Suomi NPP.Original.Durchschnitt.gesaettigt.abgedunkelt.png|mini|links|hochkant=4|Sichtbarmachung des Farbwerts mit dem Farbwinkel 201° der Erdoberfläche im Bereich von Nordamerika und dem südöstlichen Pazifik.&lt;br/&gt;Von links nach rechts:&lt;br/&gt;1. Originalaufnahme&lt;br/&gt;2. Mittelwert&lt;br/&gt;3. Farbe gesättigt&lt;br/&gt;4. abgedunkelt]]
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

==Einzelnachweise==
&lt;references&gt;&lt;/references&gt;

&lt;noinclude&gt;
[[Kategorie:Astronomische Kuriositäten]]
&lt;/noinclude&gt;</text>
      <sha1>4n2ouaogm74nlzju5g9ckt2vz13vpbu</sha1>
    </revision>
    <revision>
      <id>1092185</id>
      <parentid>1092181</parentid>
      <timestamp>2026-10-17T11:15:57Z</timestamp>
      <contributor>
        <username>Bautsch</username>
        <id>35687</id>
      </contributor>
      <comment>/* Siderischer Monat */ überarbeitet</comment>
      <origin>1092185</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="121749" sha1="mjvao3m19jagcfc2nsioy0auxlkjw0n" xml:space="preserve">[[Datei:Mondfinsternis.7.9.2025.20.46MESZ.Berlin.png|mini|rechts|hochkant=2|Ein bei Vollmond während einer Mondfinsternis im Kernschatten der Erde befindlicher Blutmond nach Mondaufgang von Berlin aus gesehen am 7. September 2025.]]

== Monat ==
Die Bezeichnung '''Monat''' stammt etymologisch von unserem Erdmond ab. Es handelt sich um ein Erbwort, das auf die seit dem 8.&amp;nbsp;Jahrhundert bezeugten althochdeutschen Formen ''mānōd'' beziehungsweise ''mānōth'' zurückgeht. Diese wiederum stammen vom indoeuropäischen Wort ''mēnōt'' ab, das sowohl ''Monat'' als auch ''Mond'' bedeuten kann.&lt;ref&gt;[https://indogermanisch.org/pokorny-etymologisches-woerterbuch/m%C4%93n%C5%8Dt_gen_m%C4%93neses_woraus_m%C4%93nes-_m%C4%93ns-_m%C4%93s-_m%C4%93n.htm mēnōt], Pokorny - Indogermanisches etymologisches Wörterbuch&lt;/ref&gt;

== Die Naturgeschichte von Plinius dem Älteren ==
'''Gaius Plinius Secundus''' (&quot;der Ältere&quot;) hat im ersten nachchristlichen Jahrhundert über den '''Mond''' geschrieben. Das neunte Kapitel des zweiten Buches aus dem ersten Band hat den Titel ''Von der Natur des Mondes''. Über den Mond schreibt Plinius Folgendes:&lt;ref name=&quot;Denso1764&quot;&gt;Plinius: ''Naturgeschichte'', erster Band, zweites Buch, neuntes Kapitel: ''Von der Natur des Mondes'', übersetzt von Johann Daniel Denso (1708–1795), Rostock und Greifswald, Anton Ferdinand Rösens Buchhandlung, 1764, in moderne deutsche Sprache gesetzt.&lt;/ref&gt;

&lt;blockquote&gt;
Aber alle diese [Wandelgestirne] übertrifft an Bewunderungswürdigkeit das Gestirn des '''Mondes''', das niedrigste, der Erde bekannteste, und zur Verminderung der Finsternis erfunden. Dieser hat durch seinen Wandel und veränderte Gestalt, da er beständig zu- und abnimmt, den Witz seiner Beobachter gequält, die es sich für einen Schimpf hielten, wenn man das nächste Gestirn nicht kennen sollte. Ja er ist auch in Spitzen gekrümmt, bald gerade halbgeteilt, bald in eine ganze Scheibe gebogen, bald, da er einem dunkeln Flecken ähnlich war, scheint er plötzlich hervor, und ist ist er ohne Grenzen rund und voll, ist gar nicht zu sehen. Bald scheint er die ganze Nacht durch, bald geht er spåt auf, und verstärkt noch bei Tage den Schein der Sonne. Er wird verfinstert, und lässt sich auch in der Verfinsterung noch sehen. Beim Ausgang des Monats sieht man ihn nicht, und man glaubt nicht, dass er alsdenn verfinstert werde.&lt;br/&gt;
Bald steht er niedrig, bald erhaben, und auch dies nicht auf eine Art. Bald steht er in der Höhe des Himmels, bald reicht er an die Berge: jetzt steht er hoch gegen Norden, bald tief gegen Süden herunter. Alles dies hat '''Endymion''' unter allen Menschen an ihm zuerst wahrgenommen, und deswegen ist die Sage, dass dieser in ihm verliebt gewesen sei. Wir sind wahrlich gegen diejenigen, welche uns zuerst bei diesem Himmelslicht durch ihre Arbeit und Sorge ein Licht aufgesteckt haben, nicht dankbar. Es ist ein wunderbares Verderben des menschlichen Witzes, dass wir ein Vergnügen daran finden, Blutvergießen und Mord in unsern Jahrbüchern aufzuzeichnen, damit die, welche die Welt nicht kennen, doch von unsern Lastern wissen mochten.&lt;br/&gt;
Doch aber da der Mond der Weltachse am nächsten steht, und also den engsten Umlauf hat, so durchlauft er in 27 und 1/3 Tag eben den Raum, welchen der höchste Stern des Saturns, wie gesagt ist, in dreißig Jahren zurücklegt. Hiernächst hält er sich in der Zusammenkunft mit der Sonne zwei Tage, wenn es am langsamsten geschieht, aus, und geht mit dem dreißigsten Tag zu seinen vorigen Abwechselungen wieder hervor. Ich weiß nicht, ob er nicht unter allen am Himmel der einzige Lehrmeister gewesen sei, dass man das Jahr in einen Raum von zwölf Monaten einteilen müsse, denn ebenso oft folgt er der Sonne, wenn sie zu einem neuen Zeichen zurückkehrt.&lt;br/&gt;
Er wird, wie die übrigen Sterne vom Sonnenlicht verdeckt. Denn wir sehen, dass er von derselben sein Licht gänzlich entlehne, und damit dergestalt leuchte, als wenn wir ihr zurückprallendes Licht in einem Wasser schweben sehen. Da er die Feuchtigkeit mit sanfterer und unvollkommener Kraft auflöst, auch wohl vermehrt, welche die Strahlen der Sonne verzehren. Hierher kommt es auch, dass man ihn in ungleichem Licht sieht, dass er alsdenn nur voll ist, wenn er der Sonne gerade gegenübersteht, in den übrigen Tagen nur so viel desselben, als er von jener empfängt, auf seiner Scheibe zeigt. Wenn er mit der Sonne zusammenkommt, kann man ihn nicht sehen, weil er uns die dunkle Seite zukehrt, und alles Geschöpfte dorthin, woher er es empfangen hat, wieder zurückwirft.&lt;br/&gt;
Es scheint außer Zweifel gesetzt zu sein, dass die Gestirne ihre Nahrung von der Feuchtigkeit der Erde haben. Denn er wird auf der einen Hälfte seiner Scheibe oft voller Flecken gesehen, weil er etwa noch nicht Kraft genug hat, mehr als ihm dienlich ist, an sich zu ziehen. Seine Flecken sind gewiss nichts anderes, als die mit der Feuchtigkeit von der Erde mit fortgerissenen Unreinigkeiten.&lt;br/&gt;
&lt;/blockquote&gt;
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

== Mondperioden ==
Die zu beobachtende scheinbare Mondbahn kann im Verlauf verschiedener Perioden durch zahlreiche '''Mondzyklen''' beschrieben werden. Die kürzesten Zyklen dauern ungefähr einen Monat im Sonnenkalender, sie längeren Mondzyklen können aber auch mehrere Jahre umfassen.

Der Mond hat ähnlich wie die Sonne einen scheinbaren Winkeldurchmesser von ungefähr 30&amp;nbsp;Bogenminuten beziehungsweise 0,5&amp;nbsp;Bogengrad. Dies entspricht bei Betrachtung des eigenen Fingers mit ausgestrecktem Arm in etwa einem Viertel der Fingerdicke.

===Synodischer Monat===
[[Datei:Courtenay.Mondsichel.P1033938.png|mini|Altlicht beim Morgenletzt des Mondes (heliakischer Aufgang) über dem östlichen Horizont auf Vancouver Island kurz nach der Tag-und-Nachtgleiche im September 2019.]]
[[Datei:Neulicht.37Tauri.P1138734.jpg|mini|Neulicht beim Abenderst des Mondes (akronychischer Untergang) über dem westlichen Horizont in Berlin Anfang Mai 2022.]]

Der synodische Monat ist durch den Verlauf der Elongation des Mondes in Bezug zur Sonne beschrieben.

Der Mond umrundet die Erde ungefähr zwölfmal schneller als die Erde die Sonne und benötigt für einen Umlauf einen Monat. Die einfachste Wahrnehmung des Mondlaufs ergibt sich durch die Beobachtung der Mondphasen beziehungsweise der Elongationen des Mondes. Der '''synodische Monat''' (altgriechisch ''σύνοδος'' (''synodos'') = ''Zusammentreffen'') beschreibt die Dauer zwischen zwei gleichen Mondphasen, also von Neumond zu Neumond beziehungsweise von Vollmond zu Vollmond. Hier wird gemeinhin das Zusammentreffen von Neumond und Sonne am Himmel als Referenzzeitpunkt betrachtet. Ein synodischer Monat dauert etwa 29,53&amp;nbsp;Tage, und zwölf synodische Monate dauern demzufolge rund 354,37&amp;nbsp;Tage - das sind gut fünfeinhalb Tage weniger als 360. Dieser Zyklus ist dies Basis für die gängigen Mondkalender (Lunarkalender) mit der gegenüber dem am Sonnenjahr orientierten Solarkalender um zirka 11&amp;nbsp;Tagen kürzeren Jahreslänge. Bei Lunisolarkalendern wird durchschnittlich alle drei Jahre ein dreizehnter synodischer Monat eingeschaltet, damit der Frühlingspunkt der Sonne ungefähr in der gleichen Jahreszeit bleibt.

→ Zur Zahl Zwölf siehe auch [[Quadriviale Kuriositäten‎/ Zahlen#Zur Zwölf|Exkurs '''Zur Zwölf''']].

[[Datei:Horusauge.Faltung.png|mini|rechts|hochkant=2|Das altägyptische Horusauge als Folge von Rechtecken mit jeweils der Hälfte der Fläche des Vorgängers in einem Rechteck mit dem Flächeninhalt eins.]]
[[Datei:Dendera_Deckenrelief_03.JPG|mini|hochkant=2|Deckenrelief im altägyptischen Tempel von Dendera mit der Darstellung von 15&amp;nbsp;Mondphasen von links (Neumond) nach rechts (Vollmond) mit den Göttern Junit, Sopdet-Tjenenet, Hor-Behdeti, Hathor, Nephthys, Harsiese, Isis, Osiris, Nut, Geb, Tefnut, Schu, Atum und Month. Im Vollmond vor dem Gott des Mondes Thot ist das von ihm geheilte linke Auge („Mondauge“) des Lichtgottes Horus dargestellt.]]

Die Ägypter haben ihre Kalender nicht mit einer Siebentagewoche, sondern sowohl mit einer Fünftagewoche als auch mit einer Zehntagewoche geführt. Damit besteht ein synodischer Monat auf weniger als einen halben Tag genau aus sechs Fünftagewochen beziehungsweise aus drei Zehntagewochen. Es wird in der Literatur manchmal darauf hingewiesen, dass das Verhältnis der Länge eines synodischen Monats zu dreißig vollen Tagen

:&lt;math&gt;\frac {29,530589 \text{d}} {30 \text{d}} = 0,984353&lt;/math&gt;

fast identisch mit dem folgenden Verhältnis ist (siehe auch Horusauge und Heqat in der altägyptischen Geschichte&lt;ref&gt;Donald Frazer: ''Hieroglyphs and Arithmetic of the Ancient Egyptian Scribes'', Kapitel 2.6.5 ''Hekat Fractions and Ro'', Xlibris Corporation, 2012, ISBN 9781469136462&lt;/ref&gt;):

:&lt;math&gt;\frac {1} {2} + \frac {1} {4} + \frac {1} {8} + \frac {1} {16} + \frac {1} {32} + \frac {1} {64}&lt;/math&gt;

:&lt;math&gt;= \frac {32} {64} + \frac {16} {64} + \frac {8} {64} + \frac {4} {64} + \frac {2} {64} + \frac {1} {64}&lt;/math&gt;

:&lt;math&gt;= \frac {63} {64} = \frac {2^6 - 1} {2^6} = 1 - 2^{-6} = 0,984375&lt;/math&gt;

Die Abweichung der beiden Verhältnisse beträgt nur 0,022&amp;nbsp;Promille. Erst nach rund 44700&amp;nbsp;Monaten oder 3700&amp;nbsp;Jahren hat sich diese Abweichung auf einen Tag aufsummiert.

Die verschiedenen Mondphasen waren für die Menschen schon immer sichtbar und konnten im Laufe eines synodischen Monats verfolgt werden. Es wird davon ausgegangen, dass zum Beispiel auch auf der Himmelsscheibe von Nebra mindestens eine Mondsichel dargestellt ist, eventuell auch der Vollmond und nach dem österreichischen Ur- und Frühgeschichtler '''Paul Gleirscher''' zusätzlich das Altlicht des Mondes:&lt;ref&gt;Paul Gleirscher: [https://dialnet.unirioja.es/servlet/articulo?codigo=4142096 Zum Bildprogramm der Himmelsscheibe von Nebra: Schiff oder Sichel?], Germania: Anzeiger der Römisch-Germanischen Kommission des Deutschen Archäologischen Instituts, Band 85, Nummer 1, ISSN 0016-8874, Seiten 23 bis 33, 2007&lt;/ref&gt;

&lt;gallery caption=&quot;Verschiedene möglicherweise auf der Himmelsscheibe von Nebra dargestellte Mondphasen&quot; perrow=&quot;2&quot; widths=&quot;300&quot; heights=&quot;300&quot;&gt;
Vollmond.P1080516.jpg|Ein im Dezember um Mitternacht fast im Zenit stehender, sehr heller Vollmond.
Zunehmende.Mondsichel.png|Ein zunehmender Mond drei Tage nach Neumond beim akronychischen Untergang am westlichen Abendhimmel drei Wochen vor der Tag-und-Nacht-Gleiche im Herbst. Die rötliche Färbung entstand genauso wie bei der untergehenden Sonne durch die Rayleigh-Streuung in der Erdatmosphäre.
Altlicht.3.Nov.2021.P1116624.jpg|Das Altlicht eines abnehmenden Mondes (Morgenletzt, vier Prozent beleuchtet) beim heliakischen Aufgang am südöstlichen Morgenhimmel der nördlichen Hemisphäre während der bürgerlichen Dämmerung einen Monat nach der Tag-und-Nacht-Gleiche im Herbst mit Erdschein.
Nebra_Scheibe_Modell.jpg|Vollständig rekonstruiertes Modell der bronzenen und mit Gold tauschierten Himmelsscheibe von Nebra.
&lt;/gallery&gt;

===Siderischer Monat===
Der '''siderische Monat''' ist durch den Verlauf der ekliptikalen Länge des Mondes in Bezug zum Frühlingspunkt der Sonnenbahn einer astronomischen Epoche definiert und beschreibt die Zeitspanne, nach der der Mond bei seinem Umlauf um die Erde Richtung Osten erneut die ekliptikale Länge des Frühlingspunktes erreicht hat. Da sich er Frühlingspunkt gegenüber dem Fixsternhimmel entlang der Ekliptiklinie verschiebt, ist der siderische Monat vom '''tropischen Monat''' zu unterscheiden. Letzterer bezieht sich ebenfalls auf den Frühlingspunkt, allerdings den des aktuellen Datums und nicht den, der zu einem bereits vergangenen und unveränderlichen Referenzzeitpunkt des Datums einer bestimmten astronomischen Epoche gegolten hat. Zur Zeit wird hierfür meist die Julianische Standardepoche J2000.0 verwendet, die sich auf die Uhrzeit 11:58:55,8 UTC am 1. Januar 2000 bezieht. Bezogen auf diese Standardepoche dauert ein tropischer Monat 27,32158&amp;nbsp;Tage. Durch die langsame gegenläufige Wanderung des Frühlingspunkts Richtung Westen besteht ein kleiner Unterschied zwischen tropischem und siderischem Monat, der mit 27,32166&amp;nbsp;Tage geringfügig länger ist. Die Differenz von 0,00008&amp;nbsp;Tagen entspricht einer Abweichung von von lediglich sieben Sekunden pro Monat: Dies bedeutet, dass der Mond den Frühlingspunkt des aktuellen Datums nach einer Umrundung (griechisch ''tropos'' = ''Drehung'') der Erde sieben Sekunden früher erreicht als einen Stern (lateinisch ''sideris'' = ''des Sterns'') der sich am Anfang der Umrundung noch beim Frühlingspunkt des einen Monat alten Datums befunden hat.

Es kann auch die Zeitspanne betrachtet werden, in der der Mond in Bezug auf den Fixsternhimmel entlang der Ekliptik wieder an einer beliebigen gleichen Stelle erscheint. Dies ist also beispielsweise auch die Dauer zwischen zwei aufeinanderfolgenden Erscheinungen des Mondes im '''Goldenen Tor der Ekliptik''', da dessen Lage durch die Sterne des Fixsternhimmels bei einer bestimmten ekliptikalen Länge bestimmt ist.

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der_Ekliptik|Exkurs '''Das Goldene Tor der Ekliptik''']].

Die Einteilung der 360 Bogengrad langen Ekliptik in 28 gleiche Teile ist in der Bronzezeit verbreitet gewesen. Daraus ergibt sich ein grobes Koordinatenraster für die ekliptikale Länge des Mondes mit 28 Mondhäusern respektive Mondstationen.

Auf der '''Stachelscheibe von Platt''' aus der Bronzezeit (um 1500 vor Christus) werden die 28&amp;nbsp;Mondorte der Tage eines Monats beispielsweise durch eine Kreisreihe dargestellt. Die Hohlform diente zur Herstellung von Schmuckscheiben und hat insgesamt sieben konzentrische Kreise. Davon bestehen zwei aus 12&amp;nbsp;(innen) beziehungsweise aus 28&amp;nbsp;(außen) gleichmäßig verteilten Mulden.&lt;ref&gt;Irene Hager und Stefan Borovits (Wien, Österreich): ''Der Vorläufer einer Oktaëteris auf dem Kalenderstein bei Leodagger/Pulkau?'', Kapitel 26.2.2 ''Astronomisch/kalendarische &quot;Zählmaschinen&quot; aus der Bronzezeit'', in: Gudrun Wolfschmidt (Herausgeberin): ''Orientierung, Navigation und Zeitbestimmung - Wie der Himmel den Lebensraum des Menschen prägt'', Proceedings der Tagung der Gesellschaft für Archäoastronomie in Hamburg 2017, Band 42 von Nuncius Hamburgensis - Beiträge zur Geschichte der Naturwissenschaften, Verlag tredition, 2019, ISBN 9783749767717&lt;/ref&gt; Die zwölf inneren Mulden entsprechen entlang der Ekliptik den 12&amp;nbsp;Sonnenorten (Monaten) in einem tropischen Jahr beziehungsweise den 12&amp;nbsp;Jupiterorten (Jahren) in zwölf Jahren. Die 28&amp;nbsp;äußeren Mulden entsprechen entlang der Ekliptik den 28&amp;nbsp;Mondorten und somit den Tagen in einem siderischen Monat. Der große kreisförmige Stachel im Zentrum der Scheibe könnte als Symbol für die Sonne stehen. Auf ihm konnte die Scheibe von unten zentrisch und drehbar gelagert werden. Mit der Scheibe konnte (abgesehen vom ungefähr alle drei Jahre zusätzlich erforderlichen 14.&amp;nbsp;siderische Schaltmonat) zwölf Jahre lang in täglich wechselnden Kombinationen in den beiden Lochreihen die Lagen von Mond und Jupiter markiert und abgelesen werden. Damit konnte nach einer Einmessung der Ost-West-Richtung zum Beispiel bei der Tag-und-Nacht-Gleiche zur Jupiterrichtung im Frühlingspunkt der gesamte Lebewesenkreis (Zodiak) jederzeit mit dem täglich ein Mondhaus weiterwandernden Mond vollständig bestimmt werden, auch ohne dass der Jupiter immer sichtbar sein musste. Mit dieser Information ist es dann auch ohne weiteres möglich, das am Himmel nicht sichtbare Lebewesenzeichen zu bestimmen, in dessen Richtung sich die Sonne jeweils gerade befindet.

Im der indischen Astronomie wurden zu diesem Zweck spätestens 500&amp;nbsp;Jahre danach die '''27&amp;nbsp;Mondhäuser''' (oder Mondstationen) eingeführt. Da sich die siderische und die synodische Periode um gut zwei Tage unterscheiden, liegen aufeinanderfolgende Neumonde oder Vollmonde in verschiedenen Mondhäusern, nach denen im hinduistischen Lunisolarkalender die Monate benannt werden.

Dieses System wurde etwas später von den Arabern mit '''28&amp;nbsp;Mondhäusern''' modifiziert. Das '''erste Mondhaus''' liegt bei beiden Einteilungen im Frühlingspunkt in der Epoche um Christi Geburt im '''Kopf des Lammes''' beziehungsweise des Widders (Aries) bei den nördlich der Ekliptik liegenden Sternen Scheratan und Hamal (indisch ''Ashvini'' = ''die beiden Rosseschirrenden'' und arabisch ''aš-šaraṭān'' = ''Die beiden Zeichen''). Für das '''zweite Mondhaus''' folgt der '''Bauch des Lammes''' (indisch ''Bharani'' = ''der Wegtragende'' und arabisch ''al-buṭayn'' = ''das Bäuchlein''). Die Plejaden (indisch ''Krittika'' und arabisch ''aṯ-ṯurayyā'') im fetten '''Schwanz des Lammes''' markieren im Anschluss das '''dritte Mondhaus'''. Das '''vierte Mondhaus''' ist durch den roten Riesenstern Aldebaran (arabisch ''al-dabarān'' = ''der Nachfolgende'', indisch ''Rohini'' = ''der Rötliche'') im Sternbild Stier (Taurus) gekennzeichnet.

&lt;gallery caption=&quot;Mondstationen&quot; mode=&quot;packed&quot; widths=&quot;600&quot; heights=&quot;600&quot;&gt;
Mondhaeuser.Ekliptik.zirkular.png|Die in eine ringförmige Darstellung projizierten 28&amp;nbsp;Mondhäuser (von 1 bis 28 entgegen dem Uhrzeigersinn) mit den wichtigsten Sternen entlang der Ekliptik (rote gestrichelte Linie '''zur Epoche J0000.0'''). Der Beobachter befindet sich auf der Erde im Zentrum der Darstellung. Nach innen werden die südlichen und nach außen die nördlichen ekliptikalen Breiten gemessen. Die scheinbare Mondbahn pendelt zwischen den beiden zur Ekliptikline benachbarten Hilfslinien. Der Abstand der Hilfslinien beträgt senkrecht zur Ekliptiklinie immer fünf Bogengrad und entlang der Ekliptiklinie immer knapp dreizehn Bogengrad. Mit bis zum Nordpol zunehmender geographischer Breite des Beobachtungspunktes können auch noch knapp ein Bogengrad südlichere ekliptikale Breiten von der Mondscheibe erreicht werden, am Südpol auch noch entsprechend nördlichere ekliptikale Breiten.
Stachelscheibe_Model_zweiseitig.jpg|Die in Niederösterreich gefundene und aus Sandstein gefertigte Gussform für die '''Stachelscheibe von Platt'''.&lt;br/&gt;Von innen nach außen gibt es '''sieben''' konzentrische Kreise, die folgendermaßen zugeordnet werden können:&lt;br/&gt;- Eine große zentrische Bohrung (im Gussteil eine große stachelartige Erhebung für die '''Sonne''').&lt;br/&gt;- Zwölf gleichmäßig verteilte kleine Bohrungen (Zodiak mit '''zwölf''' Sternzeichen sowie für die Umlaufzeit des Planeten '''Jupiter '''in Jahren).&lt;br/&gt;- Drei äquidistante Kreislinien (die drei inneren Planeten '''Merkur''', '''Venus''' und '''Mars''').&lt;br/&gt;- Achtundzwanzig gleichmäßig verteilte kleine Bohrungen ('''Mond'''häuser).&lt;br/&gt;- Ein großer abschließender Kreis ('''Saturn''' als der Langsame und Beständige).
Stonehenge_phase_one.jpg|Die älteste belegte kreisförmige Struktur in Stonehenge&amp;nbsp;1 (zirka 3100 bis 2900 vor Christi) besteht aus den 56&amp;nbsp;Aubrey-Löchern (in der Abbildung weiße Kreise). Diese können unter Verwendung von Quadranten, die geographisch durch die vier Himmelsrichtungen in jeweils 14 Mondstationen geteilt sind, dazu verwendet worden sein, die ekliptikale Länge des Mondes in Bezug zum Frühlingspunkt oder zum Herbstpunkt beziehungsweise in Bezug zur Jupiterposition täglich zu markieren (der Mond erreicht den Jupiter ungefähr alle 27,5 Tage). In dieser Zählung wären alle 28 Mondhäuser halbiert, in eine Tagesstation und eine Nachtstation.
&lt;/gallery&gt;

Zwischen dem dritten und vierten Mondhaus liegt das Goldene Tor der Ekliptik, wo der Frühlingspunkt zu Beginn der maltesischen Tarxien-Phase lag. Man beachte die fehlenden helleren ekliptiknahen Sterne im '''Trichter der Thuraya''' westlich davon, also rechts der Plejaden (ekliptikale Länge ungefähr 32&amp;nbsp;Bogengrad) bis hin zum Stern Hydor heutigen Sternbild Wassermann (Aquarius, ekliptikale Länge ungefähr 314&amp;nbsp;Bogengrad). Die hellsten ekliptiknahen Sterne in diesem Gebiet des Sternenhimmels Alpherg im Sternbild Fische (Pisces) sowie Hydor und Ancha im Sternbild Wassermann (Aquarius) erreichen lediglich die vierte Größenklasse (4&lt;sup&gt;m&lt;/sup&gt;), so dass zwischen dem auffälligen offenen Sternhaufen der Plejaden und Deneb Algedi, dem hellsten Stern im Sternbild Steinbock (Capricornus), auf einer Länge von 90&amp;nbsp;Bogengrad keine hellen ekliptiknahen Sterne vorhanden sind.

→ Zur Einteilung der Ekliptik nach den monatlichen Mondstationen siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Mondhäuser|Exkurs '''Mondhäuser''']]

→ Zum dunklen Himmelsquadranten entlang der Ekliptik siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Trichter_der_Thuraya|Exkurs '''Der Trichter der Thuraya''']]

===Drakonitischer Monat===
[[Datei:Drakonitischer.Monat.png|rechts|mini|hochkant=2|Schematische Darstellung der Mondbahn (gelb) im Laufe eines drakonitischen Monats in Bezug auf die Ekliptiklinie (rot). Nach dem Erreichen der südlichsten Lage in Bezug zur Ekliptiklinie wird die Mondbahn aufsteigend, und von der nördlichsten Lage in Bezug auf die Ekliptiklinie wird die Mondbahn dann wieder absteigend. In der deutschsprachigen Schweiz gibt es für diese im Laufe eines drakonitischen Monats täglich mehr oder weniger deutlich wahrnehmbaren Änderungen der ekliptikalen Breite sogar eigene Adjektive. Das Ansteigen der ekliptikalen Breite des Mondes nach Norden wird '''obsigend''' und das Abfallen des Mondes nach Süden '''nidsigend''' genannt. Direkt auf der Ekliptik befinden sich der aufsteigende und der absteigende Knoten der Mondbahn.]]

Der drakonitische Monat ist durch den Verlauf der ekliptikalen Breite des Mondes in Bezug zur Ekliptiklinie beschrieben.

Deswegen gibt es noch den '''drakonitischen Monat''' (altgriechisch ''δράκων'' (''drakon'') beziehungsweise lateinisch ''draco'' = ''Drache''), der eine Dauer von 27,212 Tagen hat. Diese Dauer beschreibt die Zeitpunkte, an denen die um gut 5&amp;nbsp;Bogengrad zur Ekliptik geneigte Mondbahn die Ekliptik kreuzt; die ekliptikale Breite des Mondes ist dann exakt null. Diese Schnittpunkte werden Mondknoten genannt und werden einmal im Monat im aufsteigenden Mondknoten und einmal im absteigenden Mondknoten erreicht. Befindet sich der Mond auf der Ekliptik, also in der Nähe dieser Mondknoten, kommt es bei dessen Sonnennähe (wenn der Neumond also in Konjunktion mit der Sonne steht) zu einer Sonnenfinsternis und bei dessen Sonnenferne (wenn der Vollmond also in Opposition zur Sonne steht) zu einer Mondfinsternis. Diese Mondpunkte wurden früher als Drachenpunkte bezeichnet, was sich aus der Vorstellung ableitete, dass ein Drache bei einer Mondfinsternis den Mond beziehungsweise bei einer Sonnenfinsternis die Sonne verschlingen würde.

Mit dem folgenden Java-Programm können die ekliptikalen Koordinaten der Sonne und des Mondes für jeden beliebigen Zeitpunkt eines Julianischen Datums in Julianischen Jahrhunderten in Bezug auf die astronomische Standardepoche J2000 berechnet werden:

'''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/ EkliptikaleKoordinatenMondSonne|→ Java-Programm &quot;EkliptikaleKoordinatenMondSonne&quot;]]'''&lt;ref&gt;Unter Verwendung der Formeln aus: Oliver Montenbruck, Thomas Pfleger: ''Astronomie mit dem Personal Computer'', Springer-Verlag Berlin Heidelberg GmbH, 1989, ISBN 978-3-662-05865-7&lt;/ref&gt;

[[Datei:Ekliptikale.Breiten.Mond.siderischer.Monat.png|links|mini|hochkant=4|Die ekliptikalen Breiten des Mondes im Verlauf eines drakonitischen Monats beziehungsweise eines nur gut zweieinhalb Stunden längeren siderischen Monats mit gut 27 Tagen.]]

{| class=&quot;wikitable&quot;
|+ Die täglichen Änderungen der ekliptikalen Breite des Mondes in Bogengrad innerhalb eines Mondviertels
!title=&quot;Tage nach aufsteigendem Knoten&quot;| Tage nach&lt;br/&gt;aufsteigendem&lt;br/&gt;Knoten
!title=&quot;Änderung der ekliptikalen Breite&quot;| Änderung der&lt;br/&gt;ekliptikalen Breite&lt;br/&gt;zum Vortag
|-
| 1 || 1,2°
|-
| 2 || 1,1°
|-
| 3 || 1,0°
|-
| 4 || 0,9°
|-
| 5 || 0,6°
|-
| 6 || 0,3°
|-
| 7 || 0,0°
|}
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

Der Mond kann auf seiner Bahn im Laufe der Zeiten alle ekliptiknahen Himmelsobjekte inklusive aller Planeten und der Sonne bedecken und innerhalb einer Stunde wieder freigeben, die sich in einem Band bis zu gut ±5&amp;nbsp;Bogengrad nördlich oder südlich neben der Ekliptiklinie befinden.

'''{{w|Aristoteles}}''' (384 bis 322) hat dies in seiner Schrift '''&quot;Über den Himmel&quot;''' (altgriechisch: ''Περὶ οὐρανοῦ'' / ''Peri uranu'') anhand der von ihm beobachteten '''Bedeckung des Planeten Mars durch den zunehmenden Halbmond in der Nähe des Sterns Regulus''' (α Leonis) beschrieben und darauf hingewiesen, dass die Babylonier und die Ägypter solche Phänomene über lange Zeit beobachtet und dokumentiert hatten.&lt;ref&gt;Aristoteles: [http://classics.mit.edu/Aristotle/heavens.2.ii.html On the Heavens], Teil 12, Buch II, um 350 vor Christus, ins Englische übersetzt von John Leofric Stocks (*&amp;nbsp;1882; †&amp;nbsp;1937)&lt;/ref&gt;

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Aristotelische Mars-Konjunktion|Abschnitt '''Aristotelische Mars-Konjunktion''']].

Der ekliptiknahe Hauptstern Pollux im Sternbild Zwillinge (Gemini) hat sich aufgrund seiner Eigenbewegung im Laufe der letzten zehntausend Jahre so weit von der Ekliptiklinie entfernt, dass er inzwischen nicht mehr vom Mond bedeckt werden kann.

→ Für helle ekliptiknahe Objekte siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Der_Fixsternhimmel#Die_sieben_hellsten_Objekte_der_Ekliptik|Abschnitt '''Die sieben hellsten Objekte der Ekliptik''']].

===Siderische Mondperioden===
Der Mond erscheint innerhalb eines tropischen Jahres dreizehn- oder vierzehnmal an einer bestimmten Stelle des Fixsternhimmels, wobei er wegen der unterschiedlichen Periodendauern von siderischen und synodischen Monaten immer ein anderes '''Mondalter''' (die Anzahl der Tage seit dem letzten Neumond) und wegen der unterschiedlichen Periodendauern von siderischen und drakonitischen Monaten immer eine andere ekliptikale Breite aufweist.

Die beiden folgenden Diagramme sollen den zeitlichen Verlauf der Mondphasen und der ekliptikalen Breiten des Mondes bei seinem Erscheinen im Goldenen Tor der Ekliptik während 254 aufeinanderfolgender siderischer Perioden mit jeweils 27,322&amp;nbsp;Tagen (insgesamt 6940&amp;nbsp;Tage beziehungsweise 19&amp;nbsp;Jahre) veranschaulichen:

[[Datei:Mondphasen.siderische.Perioden.png|links|mini|hochkant=4|Die Mondphasen bei aufeinanderfolgenden Erscheinungen des Mondes im Goldenen Tor der Ekliptik innerhalb von 254 siderischen Perioden (insgesamt 19&amp;nbsp;Jahre). Da der synodische Monat (von Neumond zu Neumond) über zwei Tage länger ist als der siderische Monat, kommt es hierbei zu Verschiebungen, weil der Mond nach Ablauf eines siderischen Monats beim Erreichen derselben ekliptikalen Länge noch nicht ganz wieder sein maximales Mondalter erreicht hat.&lt;br/&gt;&lt;br/&gt;In der oberen Hälfte des Diagramms sind zunehmende und in der unteren Hälfte abnehmende Monde zu beobachten. Eine Mondphase von 0 Prozent steht für einen Neumond und eine Mondphase von ±100 Prozent für einen Vollmond.&lt;br/&gt;&lt;br/&gt;Der Startpunkt (Tag&amp;nbsp;0 im Monat&amp;nbsp;0) kann zum Beispiel mit dem 22.&amp;nbsp;Mai 2020 am Abend (UTC) angesetzt werden, an dem der Neumond zusammen mit der Sonne im Goldenen Tor der Ekliptik stand. Dies geschieht dann nach 19 Jahren am 23.&amp;nbsp;Mai 2039 kurz nach Mitternacht (UTC) erneut.]]

[[Datei:Ekliptikale.Breiten.Mond.siderische.Perioden.png|links|mini|hochkant=4|Die ekliptikalen Breiten des Mondes bei aufeinanderfolgenden Erscheinungen des Mondes im Goldenen Tor der Ekliptik innerhalb von 254 aufeinanderfolgenden siderischen Perioden (insgesamt 19&amp;nbsp;Jahre). Da der drakonitische Monat (von einem aufsteigendem Mondknoten bis zum nächsten aufsteigenden Mondknoten) gut zweieinhalb Stunden kürzer ist als der siderische Monat, kommt es hierbei zu Verschiebungen, weil der Mond nach Ablauf eines siderischen Monats den aufsteigenden Knoten bereits wieder hinter sich gelassen hat.&lt;br/&gt;&lt;br/&gt;Bei großen ekliptikalen Breiten (oben) kommt es im Goldenen Tor der Ekliptik zu Bedeckungen der Plejaden und bei kleinen ekliptikalen Breiten (unten) kommt es zu Bedeckungen der Hyaden oder des Sterns Aldebaran durch die Mondscheibe.&lt;br/&gt;&lt;br/&gt;Der Startpunkt (Tag&amp;nbsp;0 im Monat&amp;nbsp;0) kann beispielsweise ebenfalls mit dem 22.&amp;nbsp;Mai 2020 angesetzt werden, an dem der Neumond vom Erdmittelpunkt aus gesehen bei einer ekliptikalen Breite von zirka -2,5&amp;nbsp;Bogengrad unterhalb der Sonne, deren ekliptikale Breite definitionsgemäß 0&amp;nbsp;Bogengrad beträgt, im Goldenen Tor der Ekliptik stand.&lt;br/&gt;&lt;br/&gt;Nach 18,61&amp;nbsp;Jahren (beziehungsweise 6793,5&amp;nbsp;Tagen oder gut 230&amp;nbsp;synodischen Monaten, in dieser Abbildung also nach gut 248,6&amp;nbsp;siderischen Monaten) erreicht der Mond dieselbe ekliptikale Breite und fast die gleiche Mondphase, befindet sich dann allerdings bei einer anderen ekliptikalen Länge.&lt;br/&gt;&lt;br/&gt;Die kurzperiodische kleine Wellenbewegung kommt durch die Nutation der Erdachse im Bezug zur Ekliptik beziehungsweise zum Fixsternhimmel zustande; sie hat eine Periodendauer von 35&amp;nbsp;Tagen und überlagert sich mit den zirka eine Woche kürzeren siderischen Mondperiode.]]
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

===Der Meton-Zyklus===
Nicht nur die Bestimmung und Vorhersage der Auf- und Untergänge der Venus haben die Aufmerksamkeit der Astronomen des Altertums auf sich gezogen, sondern auch der Mondzyklus mit den verschiedenen Mondphasen sowie das Auftreten von Mondfinsternissen bei Vollmond und von Sonnenfinsternissen bei Neumond. Es gibt einen Zyklus, der die Zeit beschreibt, nachdem die Sonne und der Mond die gleiche Konstellation erreichen. Nach '''19&amp;nbsp;Jahren''' (beziehungsweise knapp '''6940&amp;nbsp;Tagen''') hat nicht nur die Sonne dieselbe ekliptikale Länge erreicht, sondern auch der der Mond (nach '''254&amp;nbsp;siderischen Monaten'''), und er hat daher auch dieselbe Mondphase (nach '''235&amp;nbsp;synodischen Monaten'''). Außerdem hat er dann auch noch annährend die gleiche ekliptikale Breite (nach '''255&amp;nbsp;drakonitischen Monaten'''), so dass er fast wieder an derselben Stelle des Fixsternhimmels steht.&lt;ref name=&quot;rutherforth&quot;&gt;Thomas Rutherforth: &quot;A System Of Natural Philosophy: Being A Course of Lectures In Mechanics, Optics, Hydrostatics, and Astronomy; Which are Read in St Johns College Cambridge&quot;, volume 2, chapter XIV: &quot;Of the devision&lt;!--sic!--&gt; of time&quot;, paragraph 388: &quot;The cycle of Metos&quot;, 990 ff.&lt;/ref&gt;

Der Zyklus beruht also im Wesentlichen auf der zwar nur langfristig, bei entsprechender Ausdauer jedoch einfach zu beobachtenden Tatsache, dass 19&amp;nbsp;tropische Sonnenjahre, 235&amp;nbsp;synodische Monate, 254&amp;nbsp;siderische Monate und 255&amp;nbsp;drakonitische Monate fast die gleiche Länge haben. Der Unterschied zwischen den ersten beiden beträgt nur rund zwei Stunden:

* 19&amp;nbsp;Jahre = 6939,6&amp;nbsp;Tage, bestimmt durch die ekliptikale Länge der Sonne mit ihren Äquinoktien und Sonnenwenden.
* 235&amp;nbsp;synodische Monate = 6939,7&amp;nbsp;Tage, bestimmt durch die Mondphasen mit Neumonden und Vollmonden.
* 254&amp;nbsp;siderische Monate = 6939,7&amp;nbsp;Tage, bestimmt durch die ekliptikale Länge des Mondes.
* 255&amp;nbsp;drakonitische Monate = 6939,1&amp;nbsp;Tage, bestimmt durch die auf- und absteigenden Knoten der Mondbahn.

[[Datei:Legende.Meton-Zyklus.png|mini|rechts|Legende zum Diagramm &quot;Meton-Zyklus&quot;.]]

&lt;gallery caption=&quot;Der Meton-Zyklus&quot; mode=&quot;packed&quot;&gt;
Meton-Zyklus.Maerz.2019.png|Der Meton-Zyklus anhand der Frühlingsvollmonde (weiße Kreise) am 21. März 2019 (laufende Nummer 0) und am 21. März 2038 (laufende Nummer 235).
Meton-Zyklus.Januar.2023.Januar.2042.png|Der Meton-Zyklus vom Vollmond am 6. Januar 2023 bis zum Vollmond am 6. Januar 2042. Die farbigen Kreise symbolisieren die Äquinoktien und Sonnenwenden.
&lt;/gallery&gt;

[[Datei:Meton-Zyklus.2023.13996.png|mini|links|hochkant=4|Der 19-jährige Meton-Zyklus vom Januar&amp;nbsp;2023 bis zum Januar&amp;nbsp;2042. Die Zeit schreitet in horizontaler Richtung jeweils um einen halben Tag pro Bildpunkt voran. Der Vollmond (weißer Kreis) erscheint sowohl am 6.&amp;nbsp;Januar 2023 als auch am 6.&amp;nbsp;Januar 2042 im Sternbild Zwillinge (Gemini) nördlich vom Stern Mebsuta (ε&amp;nbsp;Geminorum). Unten sind die kleinen und großen Mondwenden für die geographische Breite 52,5 Bogengrad (zum Beispiel in Berlin) im Laufe der Zeit dargestellt.]]
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

Dieser 19-jährige nach dem antiken griechischen Astronomen {{w|Meton}} (5.&amp;nbsp;Jahrhundert vor Christus) benannte '''Meton-Zyklus''' sowie auch der unten erwähnte Saros-Zyklus waren im Altertum spätestens schon den Babyloniern bekannt und dienten als Grundlage für ihren Mondkalender. Meton ist davon ausgegangen, dass 19&amp;nbsp;Jahre exakt mit 6940&amp;nbsp;Tagen sowie mit 235 synodischen Monaten übereinstimmen. Dadurch, dass das Jahr nach dieser Annahme genau fünf Neunzehntel Tage länger ist als 365 Tage, sind neunzehn Jahre nach dieser Berechnung genau fünf Tage länger ist als neunzehn Mal 365 Tage, also 6935 Tage. Aus der Annahme einer festen ganzrationalen Kopplung der Umlaufzeiten der Erde um Ihre Achse (Tag) und um die Sonne (Jahr) sowie der Umlaufzeit des Mondes um die Erde (Monat) ergeben sich die folgenden Zusammenhänge:

* Abgerundet auf ganze Zahlen:
** '''Die Jahreslänge in ganzen Tagen:'''
**:&lt;math&gt;\frac {6940} {19} = 365 \text { Rest } 5&lt;/math&gt;, das heißt, dass für 19&amp;nbsp;Jahre mit der Länge 365 Tage '''fünf Schalttage''' (Jahreslänge dann 366&amp;nbsp;Tage) erforderlich sind, damit der Frühlingspunkt mit dem tropischen Sonnenjahr synchron bleibt (Solarkalender).
** '''Die Monatslänge in ganzen Tagen:'''
**:&lt;math&gt;\frac {6940} {235} = 29 \text { Rest } 125&lt;/math&gt;, das heißt, dass für 235&amp;nbsp;synodische Monate mit der Länge 29&amp;nbsp;Tage '''125&amp;nbsp;Schalttage''' (Monatslänge dann 30&amp;nbsp;Tage) erforderlich sind, damit ein tropisches Sonnenjahr immer zwölf Monate umfasst (Solarkalender).
** '''Die Jahreslänge in ganzen Monaten:'''
**:&lt;math&gt;\frac {\frac {6940} {19}} {\frac {6940} {235}} = \frac {235} {19} = 12 \text { Rest } 7&lt;/math&gt;, das heißt, dass in 19&amp;nbsp;Jahren mit 235&amp;nbsp;synodischen Monaten sowie 6490&amp;nbsp;Tagen '''sieben synodische Schaltmonate''' (Jahreslänge dann 13&amp;nbsp;Monate) erforderlich sind, um das Kalenderjahr mit dem tropischen Sonnenjahr synchron zu halten (Lunisolarkalender).

* Exakt mit Brüchen (ganzrationale Zahlen):
** Die Jahreslänge &lt;math&gt;d_a&lt;/math&gt; in Tagen (in einem Sonnenjahr):
**:&lt;math&gt;d_a = \frac {6940 \text { d}} {19 \text { a}} = 365 \frac {\text {d}} {\text {a}} + \frac {5} {19} \frac {\text {d}} {\text {a}} = 365 \frac {\text {d}} {\text {a}} + \frac {20} {76} \frac {\text {d}} {\text {a}} = 365 \frac {\text {d}} {\text {a}} + \frac {1} {4} \frac {\text {d}} {\text {a}} + \frac {1} {76} \frac {\text {d}} {\text {a}} = 365,25 \frac {\text {d}} {\text {a}} + \frac {1} {76} \frac {\text {d}} {\text {a}} \approx 365,263158 \frac {\text {d}} {\text {a}}&lt;/math&gt;
** Die Länge eines synodischen Monats &lt;math&gt;d_m&lt;/math&gt; in Tagen:
**:&lt;math&gt;d_m = \frac {6940 \text { d}} {235 \text { m}} = \frac {1388} {47} \frac {\text {d}} {\text {m}} = 29 \frac {\text {d}} {\text {m}} + \frac {125} {235} \frac {\text {h}} {\text {m}} = 29 \frac {\text {d}} {\text {m}} + \frac {25} {47} \frac {\text {h}} {\text {m}} \approx 29,531915 \frac {\text {d}} {\text {m}}&lt;/math&gt;
** Länge von zwölf synodischen Monaten &lt;math&gt;d_{m_{12}}&lt;/math&gt; in Tagen (in einem Mondjahr):
**:&lt;math&gt;d_{m_{12}} = 12 \frac {\text {m}} {\text {a}} \cdot d_m = 12 \frac {\text {m}} {\text {a}} \cdot \frac {1388} {47} \frac {\text {d}} {\text {m}} = \frac {16656} {47} \frac {\text {d}} {\text {a}} \approx 354,382979 \frac {\text {d}} {\text {a}} \approx d_a - 11 \frac {\text {d}} {\text {a}}&lt;/math&gt;
** Die Jahreslänge &lt;math&gt;m_a&lt;/math&gt; in synodischen Monaten (in einem Sonnenjahr):
**:&lt;math&gt;m_a = \frac {d_a} {d_m} = \frac {\frac {6940 \text { d}} {19 \text { a}}} {\frac {6940 \text { d}} {235 \text { m}}} = \frac {235} {19} \frac {\text {m}} {\text {a}} = 12 \frac {\text {m}} {\text {a}} + \frac {7} {19} \frac {\text {m}} {\text {a}} \approx 12,368421 \frac {\text {m}} {\text {a}}&lt;/math&gt;

:'''Anmerkung''': Man nehme zur Kenntnis, dass das der Mittelwert der Dauern vom Sonnenjahr &lt;math&gt;d_a&lt;/math&gt; und vom Mondjahr &lt;math&gt;d_{m_{12}}&lt;/math&gt; fast genau 360&amp;nbsp;Tage pro Jahr beträgt, also so viele Tage wie für einen vollständigen Kreis in Bogengrad gerechnet wird:
::&lt;math&gt;\frac {d_a + d_{m_{12}}} {2} = \frac {\frac {6940 \text { d}} {19 \text { a}} + \frac {16656} {47} \frac {\text {d}} {\text {a}}} {2} = \frac {321322} {893} \frac {\text {d}} {\text {a}} \approx 359,823 \frac {\text {d}} {\text {a}} \approx 360 \frac {\text {d}} {\text {a}}&lt;/math&gt;
::Mit den heutigen, jeweils rund eine halbe Stunde kürzeren Messwerten für die beiden Jahresdauern (tropisches Sonnenjahr mit 365,241 Tagen und Mondjahr mit zwölf Lunationen und 354,367 Tagen) zur Epoche J2000.0 ergibt sich ein nur geringfügig anderer Mittelwert, der ebenfalls nur um zirka eine Dreiviertelstunde von der Dauer von 360 Tagen abweicht:
::&lt;math&gt;\frac {d_a + d_{m_{12}}} {2} = \frac {365,241 \frac {\text {d}} {\text {a}} + 354,367 \frac {\text {d}} {\text {a}}} {2} \approx 359,804 \frac {\text {d}} {\text {a}} \approx 360 \frac {\text {d}} {\text {a}}&lt;/math&gt;

Für diese Erkenntnisse ist entweder die Weitergabe von beobachteten astronomischen Ereignissen, wie der Bedeckung der Plejaden durch den Mond oder die Messung der ekliptikalen Koordinaten des Mondes, an die nächste Generation erforderlich oder ein Lebensalter, das die Beobachtung von mindestens zwei solcher Zyklen umfasst – je nach Zeitpunkt der Geburt also rund 25 bis über 40 Jahre.

Da der Meton-Zyklus mit den aufgerundeten ganzzahligen 6940&amp;nbsp;Tagen einen Vierteltag länger dauert als 19&amp;nbsp;Sonnenjahre, summiert sich diese Differenz nach vier Meton-Zyklen auf einen ganzen Tag. Der entsprechende nach {{w|Kallippos von Kyzikos}} (viertes vorchristliches Jahrhundert) benannte '''Kallippische Zyklus''' von 76&amp;nbsp;Jahren (&lt;math&gt;= 4 \cdot 19&lt;/math&gt;&amp;nbsp;Jahre) oder 27759&amp;nbsp;Tage (&lt;math&gt;= (4 \cdot 6940) - 1&lt;/math&gt;&amp;nbsp;Tage) wird auch als verbesserter Meton-Zyklus bezeichnet:
* 76&amp;nbsp;Jahre = 27758,4&amp;nbsp;Tage
* 940&amp;nbsp;synodische Monate = 27758,8&amp;nbsp;Tage
* 1016&amp;nbsp;siderische Monate = 27758,8&amp;nbsp;Tage
* 1020&amp;nbsp;drakonitische Monate = 27756,5&amp;nbsp;Tage

Nach ungefähr 48&amp;nbsp;Sonnenjahren betrug die Differenz zwischen Meton-Zyklus und Sonnenjahr einen Tag, aber erst nach ungefähr 128&amp;nbsp;Sonnenjahren erreicht die Differenz zwischen Kallippischen Zyklus und Sonnenjahr so groß. Da der Kallippische Zyklus mit genau 27759;Tagen einen Vierteltag länger dauert als 76&amp;nbsp;Sonnenjahre, summiert sich diese Differenz nach vier Kallippischen Zyklen auf einen ganzen Tag. Der entsprechende nach {{w|Hipparchos (Astronom)|Hipparchos von Nicäa}} (zweites vorchristliches Jahrhundert) benannte '''Hipparchos-Zyklus''' von 304&amp;nbsp;Jahren (&lt;math&gt;= 4 \cdot 76 = 16 \cdot 19&lt;/math&gt;&amp;nbsp;Jahre) = 111035&amp;nbsp;Tage (&lt;math&gt;= (4 \cdot 27759) - 1&lt;/math&gt;&amp;nbsp;Tage) ist also wiederum ein verbesserter Kallippischer Zyklus:
* 304&amp;nbsp;Jahre = 111033,6&amp;nbsp;Tage
* 3760&amp;nbsp;synodische Monate = 111035,0&amp;nbsp;Tage
* 4064&amp;nbsp;siderische Monate = 111035,2&amp;nbsp;Tage
* 4080&amp;nbsp;drakonitische Monate = 111025,9&amp;nbsp;Tage

Nach einer Kallippischen Periode beträgt die Differenz zwischen 111035&amp;nbsp;ganzen Tagen und der Dauer von 3760&amp;nbsp;synodischen Monaten nur eine dreiviertel Stunde.

Die folgende Tabelle gibt einen Überblick über die Dauern im Meton-Zyklus, im Kallippischen Zyklus und im Hipparchos-Zyklus:

{| class=&quot;wikitable&quot;
!
!Tropische Perioden
!Synodische Perioden
!Siderische Perioden
!Ganzzahlige Tage
|-
|'''Dauer einer Periode in Tagen'''
|'''365,2422'''
|'''29,53059'''
|'''27,32166'''
|'''1'''
|-
|
|-
|'''Anzahl der Perioden im Meton-Zyklus'''
|'''19'''
|'''235'''
|'''254'''
|'''6940'''
|-
|'''Anzahl der Tage im Meton-Zyklus'''
|6939,6018
|6939,6887
|6939,7016
|6940
|-
|'''Differenz zu tropischen Perioden in Tagen'''
|0,0000
|0,0868
|0,0998
|0,3982
|-
|'''Differenz zu synodischen Perioden in Tagen'''
| -0,0868
|0,0000
|0,0130
|0,3113
|-
|'''Differenz zu siderischen Perioden in Tagen'''
| -0,0998
| -0,0130
|0,0000
|0,2984
|-
|'''Differenz zu tropischen Perioden in Stunden'''
|0,00
|2,08
|2,40
|9,56
|-
|'''Differenz zu synodischen Perioden in Stunden'''
| -2,08
|0,00
|0,31
|7,47
|-
|'''Differenz zu siderischen Perioden in Stunden'''
| -2,40
| -0,31
|0,00
|7,16
|-
|
|-
|'''Anzahl der Perioden im Kallippischen Zyklus'''
|'''76'''
|'''940'''
|'''1016'''
|'''27759'''
|-
|'''Anzahl der Tage im Kallippischen Zyklus'''
|27758,4072
|27758,7546
|27758,8066
|27759
|-
|'''Differenz zu tropischen Perioden in Tagen'''
|0,0000
|0,3474
|0,3994
|0,5928
|-
|'''Differenz zu synodischen Perioden in Tagen'''
| -0,3474
|0,0000
|0,0520
|0,2454
|-
|'''Differenz zu siderischen Perioden in Tagen'''
| -0,3994
| -0,0520
|0,0000
|0,1934
|-
|'''Differenz zu tropischen Perioden in Stunden'''
|0,00
|8,34
|9,58
|14,23
|-
|'''Differenz zu synodischen Perioden in Stunden'''
| -8,34
|0,00
|1,25
|5,89
|-
|'''Differenz zu siderischen Perioden in Stunden'''
| -9,58
| -1,25
|0,00
|4,64
|-
|
|-
|'''Anzahl der Perioden im Hipparchos-Zyklus'''
|'''304'''
|'''3760'''
|'''4064'''
|'''111035'''
|-
|'''Anzahl der Tage im Hipparchos-Zyklus'''
|111033,6288
|111035,0184
|111035,2262
|111035
|-
|'''Differenz zu tropischen Perioden in Tagen'''
|0,0000
|1,3896
|1,5974
|1,3712
|-
|'''Differenz zu synodischen Perioden in Tagen'''
| -1,3896
|0,0000
|0,2078
| -0,0184
|-
|'''Differenz zu siderischen Perioden in Tagen'''
| -1,5974
| -0,2078
|0,0000
| -0,2262
|-
|'''Differenz zu tropischen Perioden in Stunden'''
|0,00
|33,35
|38,34
|32,91
|-
|'''Differenz zu synodischen Perioden in Stunden'''
| -33,35
|0,00
|4,99
| -0,44
|-
|'''Differenz zu siderischen Perioden in Stunden'''
| -38,34
| -4,99
|0,00
| -5,43
|}

Vor gut 2000&amp;nbsp;Jahren betrug die Differenz zwischen Kallippischem Zyklus und Sonnenjahr nach ungefähr 227&amp;nbsp;Sonnenjahren einen Tag. Durch die inzwischen etwas verkürzte Dauer eines tropischen Jahres ist dies heute bereits nach etwa 221&amp;nbsp;Jahren der Fall.

====Die Goldene Zahl====
Die '''Goldene Zahl''' gibt an, das wievielte von diesen 19&amp;nbsp;Jahren ein bestimmtes Jahr ist, und sie spielt auch heute noch eine wichtige Rolle bei der Bestimmung des Datums von Pessach oder Ostern, zum Beispiel mit Hilfe der Formeln zur Berechnung von {{w|Carl Friedrich Gauß}} (*&amp;nbsp;1777; †&amp;nbsp;1855):

→ Siehe auch:

* [[Astronomie von der Frühgeschichte bis zur Neuzeit/ Kalenderführung/ Osterdatum|'''Osterdatum''']]
* {{w|Gaußsche Pessach-Formel}}
* {{w|Gaußsche Osterformel}}

Der Name Goldene Zahl rührt möglicherweise davon her, dass der diesem Zyklus zugrundeliegende Kalender ('''Parapegma''') des Meton auf den Steinmauern seiner Sonnenuhr (heliotropion) am Pnyx-Hügel in Athen in goldener Schrift zu sehen war.&lt;ref&gt;Michael Wright: [https://www3.astronomicalheritage.net/index.php/show-entity?identity=26&amp;idsubentity=1 The Pnyx, Athens, Greece], Portal to the Heritage of Astronomy, August 2011&lt;/ref&gt;&lt;ref name=&quot;rutherforth&quot; /&gt;

Heute ist in den Monaten um die Wintersonnenwende alle 19&amp;nbsp;Jahre morgens am westlichen Horizont der untergehende Vollmond im Goldenen Tor der Ekliptik zu sehen, wie im Dezember&amp;nbsp;2018. Die untere Hälfte des Mondes wird dann während des Untergangs vom Horizont verdeckt und der sichtbare leuchtende Teil bildet somit einen Halbkreis, wie er im mittleren Segment der Himmelstafel angedeutet ist. In diesem Fall liegen Hyaden und Plejaden im Westen auf einer Linie parallel zum Horizont und der dazwischenliegende, beim Untergang noch halb zu sehende Vollmond würde der Abbildung auf der Steintafel von Tal-Qadi entsprechen. Vor 4500&amp;nbsp;Jahren ergab sich diese Himmelsansicht wegen der Verschiebung des Frühlingspunktes bereits um die Tag-und-Nacht-Gleiche im Herbst.

Die 19&amp;nbsp;Megalithe des Blaustein-Hufeisens von '''Stonehenge''' (2270&amp;nbsp;bis 1930&amp;nbsp;vor Christus) werden ebenfalls mit dem 19-jährigen Meton-Zyklus in Zusammenhang gesehen.

Im Übrigen werden auch die Goldhüte aus der Bronzezeit mit diesem Zyklus in Verbindung gebracht. Der '''Berliner Goldhut''' zeigt in der siebenten und in der neunten ringförmigen Zone von oben horizontale Reihen mit 57 (=&amp;nbsp;3&amp;nbsp;x&amp;nbsp;19) kreisförmigen Punzen, die für ein Viertel der 228&amp;nbsp;Monate einer Meton-Periode stehen könnten.&lt;ref&gt;Wilfried Menghin: „Der Berliner Goldhut und die goldenen Kalendarien der alteuropäischen Bronzezeit“, Acta Praehistorica et Archaeologica, Band 32, 2000, ISSN 0341-1184, Seiten 31 bis 108&lt;/ref&gt;

An der östlichen Wand in der Kamme&amp;nbsp;A des hethitischen Heiligtums '''Yazılıkaya''' (türkisch für „beschriebener Fels“) aus dem 13.&amp;nbsp;vorchristlichen Jahrhundert existiert eine Reliefbilderreihe, die eine Prozession von '''neunzehn''' nach links schauenden Göttinnen im Ganzkörperprofil darstellt. Auch hier wird vermutet, dass diese Reihe als Zählwerk für den Meton-Zyklus eine Kalenderfunktion innehatte.&lt;ref&gt;Eberhard Zangger, Rita Gautschy: [http://63.33.38.154/JSA/article/view/12232 Celestial Aspects of Hittite Religion - An Investigation of the Rock Sanctuary Yazilikaya], Journal of Skyscape Archaeology, 5(1), 5–38, 2019&lt;/ref&gt;&lt;ref&gt;Edwin C. Krupp, Eberhard Zangger: [https://www.archaeologie-online.de/artikel/2021/die-symbolische-darstellung-des-kosmos-im-hethitischen-felsheiligtum-yazlkaya Die symbolische Darstellung des Kosmos im hethitischen Felsheiligtum Yazılıkaya] vom 16. Juni 2021, Archäologie Online, archaeomedia, Freiburg&lt;/ref&gt;

Der Zyklus mit der Anzahl 19 taucht in weiteren archäoastronomischen Kontexten auf:

* Mond-Sonne-Darstellung aus dem mesoamerikanischen '''Codex Borbonicus''' der Azteken vom Anfang des 16.&amp;nbsp;Jahrhunderts.
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Mondzyklen#Der_Kalenderstein_vom_Tempel_Mnajdra|Oberste Lochreihe auf dem östlichen Kalenderstein vom Tempel '''Mnajdra''' auf Malta]].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Höhlenmalerei_in_der_Magura-Höhle#Kalender|Kalender unter den Höhlenmalereien in der '''Magura'''-Höhle mit einer Matrix aus 19 Punkten]].

&lt;gallery caption=&quot;Die Zahl 19 in archäoastronomischen Kontexten&quot; mode=packed widths=360 heights=360&gt;
Magura_cave_calendar_1528.jpg|Detail mit Elementen eines Kalenders aus der '''Magura'''-Höhle in Bulgarien. Unten in der Mitte befindet sich ein Feld mit 19&amp;nbsp;Punkten.
Kalenderstein.Mnajdra.labelled.png|Skizze der Lochreihen auf dem Kalenderstein von '''Mnajdra''' auf Malta. Die oberste Lochreihe besteht aus 19&amp;nbsp;Löchern.
Hattusa,_capital_of_the_Hittite_Empire_51.jpg|Detail mit den linken drei der insgesamt neunzehn Göttinnen der Bilderreihe in der Kammer A des hethitischen Heiligtums '''Yazılıkaya'''.
Yazilikaya.19.Gottheiten.png|Schmatische Darstellung der 19&amp;nbsp;weiblichen Gottheiten im hethitischen Heiligtum '''Yazılıkaya''' in der Türkei. Im Original variieren die Darstellungen der einzelnen Figuren, die in unterschiedlichem Zustand erhalten sind. Über den Händen einzelner Figuren konnten verschiedene hieroglyphische Darstellungen festgestellt werden. Die erste Figur (ganz links) konnte hierdurch nur indirekt rekonstruiert werden.
Berliner.Goldhut.P1068203.jpg||'''Berliner Goldhut''' vom Ende der Bronzezeit (1000–800 vor Christus) im Neuen Museum.
MesoamerikanischerMond.CodexBorbonicus.png|Mond-Sonne-Darstellung aus dem mesoamerikanischen '''Codex Borbonicus''' der Azteken vom Anfang des 16.&amp;nbsp;Jahrhunderts. Die beiden sich zu einem vollen Kreis ergänzenden Halbkreise symbolisieren den Mond und die Sonne. Im Halbkreis des Mondes befinden sich '''19&amp;nbsp;Kreise'''.
&lt;/gallery&gt;

====MUL.APIN====
[[Datei:MUP.APIN.VAT09412.P1078712.jpg|thumb|1914 gefundene Tontafel mit Texten aus dem 687 vor Christus geschrieben babylonischen Kompendium MUL.APIN, Irak, Assur/Qal'at Scherqat, VAT 09412, Neues Museum Berlin]]

Die auf den MUL.APIN-Tafeln schriftlich überlieferten babylonischen [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|'''Plejaden-Schaltregeln''']] beziehen sich zweifelsfrei auf einen Zeitpunkt, als der offene Sternhaufen der Plejaden im Sternbild Stier (Taurus) die gleiche ekliptikale Länge wie der Frühlingspunkt gehabt hat. Dies bedeutet, dass die Sonne zur Tag-und-Nacht-Gleiche direkt neben den Plejaden stand, und dies war um 2600&amp;nbsp;vor Christus der Fall. Aus beiden Schaltregeln ergibt sich, dass innerhalb von 19&amp;nbsp;Sonnenjahren sieben zusätzliche synodische Monate eingeschaltet werden müssen, damit Sonnen- und synodisches Mondjahr synchron bleiben. Die Differenz zwischen Mondlauf und Sonnenlauf beträgt nach diesen 19&amp;nbsp;Sonnenjahren nur gut zwei Stunden. Diese Abweichung beträgt nur 0,0125&amp;nbsp;Promille beziehungsweise 12,58&amp;nbsp;parts&amp;nbsp;per&amp;nbsp;million (ppm):

* Tropisches Sonnenjahr (von Frühlingspunkt zu Frühlingspunkt): &lt;math&gt;J_S = 365,2422 \text { d} = 8765,813 \text { h}&lt;/math&gt;
* Synodischer Monat (von Neumond zu Neumond): &lt;math&gt;M_{syn} = 29,53059 \text { d} = 708,7342 \text { h}&lt;/math&gt;
* Synodisches Mondjahr (zwölf synodische Monate): &lt;math&gt;J_{syn} = 12 \cdot M_{syn} = 354,3671 \text { d} = 8504,810 \text { h}&lt;/math&gt;
* Jahresdifferenz zwischen tropischem Sonnenjahr und synodischem Mondjahr: &lt;math&gt;\Delta J = J_S - J_{syn} = 10,8751 \text { d} = 261,003 \text { h}&lt;/math&gt;
* Meton-Zyklus: &lt;math&gt;19 \cdot \Delta J = 206,627 \text { d} = 4959,046 \text { h}&lt;/math&gt; beziehungsweise &lt;math&gt;7 \cdot M_{syn} = 206,714 \text { d} = 4961,139 \text { h}&lt;/math&gt;
* Genauigkeit des Meton-Zyklus: &lt;math&gt;\Delta M = 7 \cdot M_{syn} - 19 \cdot \Delta J = 0,087 \text { d} \approx 2,09 \text { h} = 235 \cdot M_{syn} - 19 \cdot J_S&lt;/math&gt;
* Arithmetische Zusammensetzung und Primfaktorenzerlegung der Anzahl synodischer Mondzyklen: &lt;math&gt;235 = 7 + 19 \cdot 12 = 5 \cdot 47&lt;/math&gt;

Mit anderen Worten war der Meton-Zyklus bereits über zwei Jahrtausende lang bekannt, bevor sich der griechische Astronom Meton damit beschäftigte.

Es ist äußerst bemerkenswert, dass eine entsprechende Berechnung auch für dreizehn siderische Monate durchgeführt werden kann, bei denen der Mond jeweils einmal vollständig die Ekliptik mit ihren zwölf Ekliptiksternbildern beziehungsweise den 27 oder 28 Mondstationen (auch Mondhäuser genannt, siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Mondhäuser|Exkurs '''Mondhäuser''']]) durchläuft:

* Tropisches Sonnenjahr (von Frühlingspunkt zu Frühlingspunkt): &lt;math&gt;J_S = 365,2422 \text { d} = 8765,813 \text { h}&lt;/math&gt;
* Siderischer Monat (von Fixstern zu Fixstern): &lt;math&gt;M_{sid} = 27,32166 \text { d} = 655,720 \text { h}&lt;/math&gt;
* Siderisches Mondjahr (13 siderische Monate): &lt;math&gt;J_{sid} = 13 \cdot M_{sid} = 355,1816 \text { d} = 8524,358 \text { h}&lt;/math&gt;
* Jahresdifferenz zwischen tropischem Sonnenjahr und siderischem Mondjahr: &lt;math&gt;\Delta J = J_S - J_{sid} = 10,0606 \text { d} = 241,454 \text { h}&lt;/math&gt;
* Meton-Zyklus: &lt;math&gt;19 \cdot \Delta J = 191,151 \text { d} = 4587,634 \text { h}&lt;/math&gt; beziehungsweise &lt;math&gt;7 \cdot M_{sid} = 191,252 \text { d} = 4590,040 \text { h}&lt;/math&gt;
* Genauigkeit des Meton-Zyklus: &lt;math&gt;\Delta M = 7 \cdot M_{sid} - 19 \cdot \Delta J = 0,100 \text { d} \approx 2,40 \text { h} = 254 \cdot M_{sid} - 19 \cdot J_S&lt;/math&gt;
* Arithmetische Zusammensetzung und Primfaktorenzerlegung der Anzahl siderischer Mondzyklen: &lt;math&gt;254 = 7 + 19 \cdot 13 = 2 \cdot 127&lt;/math&gt;

Auch hier beträgt die Differenz zwischen Mondlauf und Sonnenlauf nur gut zwei Stunden. Und innerhalb der 19 Sonnenjahre eines Meton-Zyklus müssen auch hier sieben zusätzliche (vierzehnte) siderische Monate eingeschaltet werden, damit Sonnen- und siderisches Mondjahr synchron bleiben.

Zur Differenz von knapp elf Tagen zwischen Sonnen- und Mondjahr siehe auch '''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Das_babylonische_Neujahrsfest_Akiti|das babylonische Neujahrsfest Akiti]]'''. Dieses elftägige Fest wurde am Ende des Mondjahres gefeiert.

===Der drakonitische Zyklus===
Ferner existiert ein zirka '''18,61-jähriger Mondzyklus''', der darauf beruht, dass bedingt durch die Präzession der Mondbahn der aufsteigende und der absteigende Mondknoten nach dieser Zeit die Ekliptik entgegen der rechtläufigen (prograden) Umlaufrichtung des Mondes genau einmal vollständig rückläufig (retrograd) durchlaufen haben. Dieser Zyklus besteht aus 249,83&amp;nbsp;drakonitischen Monaten, die insgesamt 6798,38&amp;nbsp;Tagen beziehungsweise 18,61&amp;nbsp;tropischen Sonnenjahren entsprechen. Die ekliptikalen Längen der Mondknoten vermindern sich hierbei um einen Winkel von 19,34&amp;nbsp;Bogengrad pro Jahr.

Dieser drakonitische Zyklus ist zum Beispiel anhand der Abweichungen der ekliptikalen Breiten des Mondes und somit der Azimute bei den monatlichen Mondaufgängen und Monduntergängen am Horizont zu beobachten, die sich nach 18,61&amp;nbsp;Jahren wiederholen und dabei um die Punkte der Wintersonnenwende im Südosten und Südwesten sowie die Punkte der Sommersonnenwende im Nordosten und Nordwesten entlang dem Horizont pendeln. Die Zeitpunkte an dem die entsprechenden Auf- und Untergangspunkte zwischen dem nördlichen und dem südlichen Horizont um die Punkte der Tag-und-Nacht-Gleichen im Osten und Westen, die definitionsgemäß bei der ekliptikalen Breite null genau in der Ekliptik liegen, am engsten beziehungsweise am weitesten auseinanderliegen, heißen '''große und kleine Mondwenden'''. Diese Mondwenden wiederholen sich also alle 18,61&amp;nbsp;Jahre. Hierbei treten auch größte und kleinste Mondwenden auf. Um die Wintersonnenwenden der Jahre 2023, 2042, 2061 und so weiter treten beispielsweise '''größte Mondwenden''' auf, bei denen die Auf- und Untergangspunkte maximal in Richtung Norden von den genau im Osten und im Westen liegenden Äquinoktialpunkten entfernt sind. Und um die Sommersonnenwenden der Jahre 2024, 2043, 2062 und so weiter treten '''kleinste Mondwenden''' auf, bei denen die Auf- und Untergangspunkte maximal in Richtung Süden von den genau im Osten und im Westen liegenden Äquinoktialpunkten entfernt sind.

[[Datei:Ekliptik.helle.Objekte.png|mini|hochkant=2|rechts|Die sieben hellsten feststehenden Himmelsobjekte in der Nähe der Ekliptik liegen zwischen den Sternbildern Stier (Taurus, rechts) und Skorpion (Scorpio, links). Der Bogen der Ekliptik wird von den Wandelgestirnen entgegen dem Uhrzeigersinn vom Frühlingspunkt rechts zum Herbstpunkt links durchlaufen. In der Nähe unteren Bogenhälfte befinden sich keine hellen Fixsterne in der Nähe der Ekliptik, der helle Stern Fomalhaut (α&amp;nbsp;Piscis Austrini) im Sternbild Südlicher Fisch (Piscis Austrinus) dient lediglich zur Orientierung. Außerhalb des Bogens liegende Punkte befinden sich nördlich der Ekliptik und innen liegende südlich.]]

Aufgrund dieser Zusammenhänge werden alle möglichen Positionen des Mondes in Bezug auf die Ekliptik bei den ekliptikalen Längen von -180&amp;nbsp;bis +180&amp;nbsp;Bogengrad und den ekliptikalen Breiten von ungefähr -6&amp;nbsp;bis +6&amp;nbsp;Bogengrad innerhalb dieser 18,61-jährigen Periode erreicht. Somit erfolgen auch alle möglichen Sternbedeckungen (Okkultationen) oder nahe Konjunktionen innerhalb dieser Periodendauer und wiederholen sich danach im drakonitischen Zyklus. Die Bedeckungen hellsten ekliptiknahen Himmelsobjekte sind hierbei besonders spektakulär und gut zu beobachten. Dies gilt insbesondere für:

* die '''Plejaden''' (Messier 45, 1,5&lt;sup&gt;m&lt;/sup&gt;) im Sternbild Stier (Taurus)
* die '''Hyaden''' (0,5&lt;sup&gt;m&lt;/sup&gt;) im Sternbild Stier (Taurus)
* den Roten Riesen '''Aldebaran''' (α&amp;nbsp;Tauri, 1,0&lt;sup&gt;m&lt;/sup&gt;) im Sternbild Stier (Taurus)
* den Roten Überriesen '''Antares''' (α&amp;nbsp;Scorpii, 1,0&lt;sup&gt;m&lt;/sup&gt;) im Sternbild Skorpion (Scorpio),
* den Stern '''Spica''' (α&amp;nbsp;Virginis, 1,0&lt;sup&gt;m&lt;/sup&gt;) im Sternbild Jungfrau (Virgo)
* den Stern '''Regulus''' (α&amp;nbsp;Leonis, 1,5&lt;sup&gt;m&lt;/sup&gt;) im Sternbild Löwe (Leo)

Wenn der Mond bei der Bedeckung der '''Plejaden''' seine maximale nördliche ekliptikale Breite bereits zuvor erreicht hatte und sich also bereits wieder in Richtung seines absteigenden Knotens bewegt, befindet sich in der Nähe des absteigenden Knotens der Königsstern '''Regulus''' im Sternbild Löwe (Leo), so dass es ungefähr eine Woche später ebenfalls zu dessen Bedeckung durch den Mond kommen kann. Da der Stern '''Antares''' α&amp;nbsp;Scorpii) im Sternbild Skorpion (Scorpio) in etwa die gleiche südliche ekliptikale Breite hat, wie die Plejaden eine nördliche ekliptikale Breite haben, und beide auf gegenüberliegenden Punkten der Ekliptiklinie liegen, kommt es im Rhythmus des drakonitischen Zyklus innerhalb eines halben Monats gehäuft zu der Bedeckung beider Himmelsobjekte durch die Mondscheibe. Beide Ereignisse wären wegen der gegenüberliegenden Lage auf der Ekliptik heute allerdings nur während der langen Nächte im Winterhalbjahr zu sehen, wenn Antares praktisch nicht zu beobachten ist, weil er von der Sonne überstrahlt wird. Als der Frühlingspunkt im Altertum jedoch im Sternbild Stier stand, war die aufeinanderfolgende Bedeckung von Plejaden und Antares jedoch durchaus ein zu beobachtendes Doppelereignis.

Das nächste Mal werden die beiden eng benachbarten Elternsterne der Plejaden (der Titan Atlas und die Okeanide Pleione) von Mitteleuropa aus gesehen in den Morgenstunden des 8.&amp;nbsp;Augusts 2024 von der Scheibe des abnehmenden Halbmonds bedeckt. Am 1.&amp;nbsp;April 2025 werden gegen Mitternacht dann sogar mehrere helle Sterne des Sternhaufens durch die nur vier Tage alte Mondsichel bedeckt.

Auch im alten chinesischen, mündlich überlieferten Volksmärchen „Morgenhimmel“ wird der Zyklus vom '''Stern des großen Jahres''' erwähnt, der sich erst nach 18 Jahren, also im 19.&amp;nbsp;Jahr wiederholt:&lt;ref&gt;[[s:Morgenhimmel|Morgenhimmel]], Wikisource&lt;/ref&gt;

&lt;blockquote&gt;
Als Morgenhimmel gestorben war, berief der Kaiser den Sterndeuter und fragte: „Kanntest du Morgenhimmel?“&lt;br/&gt;
Der sagte: „Nein.“&lt;br/&gt;
Der Kaiser fragte: „Was verstehst du denn?“&lt;br/&gt;
Der Sterndeuter sagte: „Ich kann nach den Sternen sehen.“&lt;br/&gt;
„Sind alle Sterne an ihrem Platz?“ fragte der Kaiser.&lt;br/&gt;
„Ja. Nur den Stern des großen Jahres habe ich achtzehn Jahre nicht gesehen. Jetzt aber ist er wieder sichtbar.“&lt;br/&gt;
Da blickte der Kaiser zum Himmel auf und seufzte: „Achtzehn Jahre lang war Morgenhimmel mir zur Seite, und ich wusste nicht, dass er der Stern des großen Jahres war.“
&lt;/blockquote&gt;

Mit &quot;Stern des großen Jahres&quot; könnte ein Ereignis gemeint sein, bei dem der Mond alle 18,61 Jahre einen bestimmten hellen und ekliptiknahen Stern bedeckt, wie zum Beispiel einen der drei Königssterne Aldebaran (α&amp;nbsp;Tauri) im Sternbild Stier (Taurus), Regulus (α&amp;nbsp;Leonis) im Sternbild Löwe (Leo), Antares (α&amp;nbsp;Scorpii) im Sternbild Skorpion (Scorpio) oder auch Spica (α&amp;nbsp;Virginis) im Sternbild Jungfrau (Virgo).

Auch für den drakonitischen Zyklus kann für dreizehn drakonitische Monate eine Berechnung in Bezug auf den 19-jährigen Meton-Zyklus durchgeführt werden:

* Tropisches Sonnenjahr (von Frühlingspunkt zu Frühlingspunkt): &lt;math&gt;J_S = 365,2422 \text { d} = 8765,813 \text { h}&lt;/math&gt;
* Drakonitischer Monat (von Mondknoten zu Mondknoten): &lt;math&gt;M_{dra} = 27,21222 \text { d} = 653,093 \text { h}&lt;/math&gt;
* Drakonitisches Mondjahr (13 drakonitische Monate): &lt;math&gt;J_{dra} = 13 \cdot M_{dra} = 353,7589 \text { d} = 8490,213 \text { h}&lt;/math&gt;
* Jahresdifferenz zwischen tropischem Sonnenjahr und drakonitischem Mondjahr: &lt;math&gt;\Delta J = J_S - J_{dra} = 11,4833 \text { d} = 275,600 \text { h}&lt;/math&gt;
* Meton-Zyklus: &lt;math&gt;19 \cdot \Delta J = 218,1835 \text { d} = 5236,403 \text { h}&lt;/math&gt; beziehungsweise &lt;math&gt;8 \cdot M_{sid} = 217,6978 \text { d} = 5224,746 \text { h}&lt;/math&gt;
* Genauigkeit des Meton-Zyklus: &lt;math&gt;\Delta M = 8 \cdot M_{dra} - 19 \cdot \Delta J = -0,486 \text { d} \approx -11,66 \text { h} = -(255 \cdot M_{dra} - 19 \cdot J_S)&lt;/math&gt;
* Arithmetische Zusammensetzung und Primfaktorenzerlegung der Anzahl drakonitischer Mondzyklen: &lt;math&gt;255 = 8 + 19 \cdot 13 = 3 \cdot 5 \cdot 17&lt;/math&gt;

Hier beträgt die Differenz zwischen Mondlauf und Sonnenlauf knapp einen halben Tag. Innerhalb der 19 Sonnenjahre eines Meton-Zyklus müssen hier acht zusätzliche (vierzehnte) drakonitische Monate eingeschaltet werden, damit Sonnen- und drakonitisches Mondjahr synchron bleiben.

===Der Saros-Zyklus===
[[Datei:Saros-Zyklus.2023.Januar.png|rechts|mini|hochkant=4|Der '''Saros-Zyklus''' umfasst sowohl eine Periode von 242&amp;nbsp;drakonitischen Monaten als auch eine Periode von 223&amp;nbsp;synodischen Monaten. Das sind gut 6585&amp;nbsp;Tage oder 18,03 tropische Sonnenjahre, also 18&amp;nbsp;Jahre und knapp 11&amp;nbsp;Tage). In der Graphik ist die Zeit vom aufsteigenden Knoten (rot) am 1.&amp;nbsp;Januar 2023 bis zum aufsteigenden Knoten (rot) am 11.&amp;nbsp;Januar 2041 dargestellt. Man beachte die gleichzeitige zyklische Wiederholung der jeweiligen Mondphasen sowie daraus folgend der '''Finsternisse''' im April und Mai sowie im Oktober und November mit einer Verschiebung von elf Kalendertagen im Sonnenjahr.&lt;br/&gt;Die '''Mondwenden''' (die tagesaktuellen Auf- und Untergangsazimute des Mondes sind im unteren Bereich für die geographische Breite 52,5 Bogengrad (zum Beispiel in Berlin) dargestellt) haben ihr Minimum und Maximum demzufolge zu den entsprechenden Zeitpunkten, die Ausprägung dieser Extrema unterscheidet sich jedoch ein wenig, weil der Mond dort geringfügig abweichende minimale und maximale ekliptikale Breiten hat. Die kleinen Mondwenden beim Sommervollmond im Juli und die großen Mondwenden beim Wintervollmond (Jahreswechsel) sind in der Graphik ebenfalls nachvollziehbar.&lt;br/&gt;[[Datei:Legende.Meton-Zyklus.png|200px|zentriert|Legende]]]]

Über die weiter oben beschriebenen Koinzidenzen hinaus kann beobachtet werden, dass der Mond nach '''18,03&amp;nbsp;Jahren''' (also nach 242&amp;nbsp;drakonitischen Monaten beziehungsweise 6585,3&amp;nbsp;Tagen) denselben auf- oder absteigenden Knoten erreicht, wobei Sonne und Mond dann die gleiche Elongation haben (nach 223&amp;nbsp;synodischen Monaten beziehungsweise 6585,2&amp;nbsp;Tagen). Sie befinden sich dann allerdings nur fast bei den gleichen ekliptikalen Längen beziehungsweise an den gleichen Stellen des Fixsternhimmels, da diese Dauer nur mit ungefähr einem halben Tag Differenz mit 241 siderischen Perioden übereinstimmt (6584,6&amp;nbsp;Tage). Innerhalb dieses halben Tages hat sich die Sonne um zirka ein halbes Bogengrad und der Mond sogar um ungefähr sechseinhalb Bogengrad weiterbewegt.

Dieser Zyklus wird '''Saros-Zyklus''' genannt. Innerhalb dieser Zeitspanne ergibt sich eine Reihe von Sonnen- und Mondfinsternissen, die sich in ihrer Abfolge immer wieder ähneln. Der Saros-Zyklus war bei den Babyloniern bereits im Altertum bekannt, was in Keilschrift geschrieben auf Tontafeln aus der Mitte des achten vorchristlichen Jahrhunderts überliefert ist.

Heute werden die sich wiederholenden Sonnen- und Mondfinsternisse, die sich auf einen bestimmten auf- oder absteigenden Knoten der Mondbahn beziehen und jeweils eine Lebensdauer von mehreren Jahrhunderten haben, zum Zwecke der Unterscheidung mit Nummern versehen. Zu einem bestimmten Zeitpunkt der Weltgeschichte sind immer mehrere Dutzend Saros-Zyklen gleichzeitig aktiv.

Die anomalistische Periode steht für die Dauer, bis der Mond auf seiner elliptischen Bahn um die Erde erneut eines seiner beiden Apogäen erreicht, also das Perigäum (erdnächster Punkt) oder das Apogäum (erdfernster Punkt). Nach einer ganzzahligen vielfachen Dauer der anomalistischen Periode hat der Mond also stets fast die gleiche Entfernung zur Erde und somit auch die gleiche scheinbare Größe, so dass die Dauer und Art (totale oder ringförmige Sonnenfinsternis) einer Finsternis sich wiederholt.

Wegen der gleichen ekliptikalen Breiten des Mondes nach einer ganzzahligen vielfachen Dauer der drakonitischen Periode erscheint der Mondschatten auf der Erdoberfläche nach der Dauer einer Saros-Periode ungefähr beim gleichen Breitengrad. Durch die Differenz von rund einem drittel Tag ist der Längengrad allerdings nach einer Saros-Periode um knapp 120 Bogengrad nach Westen verschoben. Nach drei Saros Perioden, oder nach einem dadurch definierten Exeligmos-Zyklus, haben sich die drei Dritteltage fast auf einen Tag summiert, so dass nach der Mondschatten dann nicht nur wieder beim ähnlichen Breitengrad, sondern sogar beim ähnlichen Längengrad und zu einer ähnlichen Tageszeit auftaucht. Anders ausgedrückt: wenn an einem bestimmten Ort auf der Erdoberfläche eine Finsternis auftritt, so erfolgt in der Regel nach 19756 Tagen (54 Jahren und 33 Tagen) in dieser geographischen Region mit nur rund einer Stunde Verfrühung erneut eine solche Finsternis.

{| class=&quot;wikitable&quot;
|+ Exeligmos-Zyklus
! Anzahl der Saros-Zyklen !! Dauer in tropischen Jahren !! Dauer in ganzen Tagen
|-
| 1 || 18,03 || 6585
|-
| 3 || 54,09 || 19756
|}

Die folgende Tabelle gibt einen Überblick über die Dauern verschiedener Mondzyklen in einem '''Saros-Zyklus''' (18,03 tropische Jahre) sowie in einem dreimal so langen Zyklus '''Exeligmos-Zyklus''' (54,09 tropische Jahre) . 

{| class=&quot;wikitable&quot;
!
!Synodische Perioden
!Drakonitische Perioden
!Tage
!Anomalistische Perioden
|-
|'''Dauer einer Periode in Tagen'''
|'''29,53059'''
|'''27,21222'''
|'''1'''
|'''27,53455'''
|-
|
|-
|'''Anzahl der Perioden im Saros-Zyklus'''
|'''223'''
|'''242'''
|'''6585'''
|'''239'''
|-
|'''Anzahl der Tage im Saros-Zyklus'''
|6585,3216
|6585,3572
|6585,0000
|6580,7575
|-
|'''Differenz zu synodischen Perioden in Tagen'''
|0,0000
|0,0357
| -0,3216
| -4,5641
|-
|'''Differenz zu drakonitischen Perioden in Tagen'''
| -0,0357
|0,0000
| -0,3572
| -4,5998
|-
|'''Differenz zu ganzen Tagen'''
|0,3216
|0,3572
|0,0000
| -4,2425
|-
|'''Differenz zu synodischen Perioden in Stunden'''
|0,00
|0,86
| -7,72
| -109,54
|-
|'''Differenz zu drakonitischen Perioden in Stunden'''
| -0,86
|0,00
| -8,57
| -110,39
|-
|'''Differenz zu ganzen Tagen in Stunden'''
|7,72
|8,57
|0,00
| -101,82
|-
|
|-
|'''Anzahl der Perioden im Exeligmos-Zyklus'''
|'''669'''
|'''726'''
|'''19756'''
|'''717'''
|-
|'''Anzahl der Tage im Exeligmos-Zyklus'''
|19755,9647
|19756,0717
|19756,0000
|19742,2724
|-
|'''Differenz zu synodischen Perioden in Tagen'''
|0,0000
|0,1070
|0,0353
| -13,6924
|-
|'''Differenz zu drakonitischen Perioden in Tagen'''
| -0,1070
|0,0000
| -0,0717
| -13,7994
|-
|'''Differenz zu ganzen Tagen in Tagen'''
| -0,0353
|0,0717
|0,0000
| -13,7277
|-
|'''Differenz zu synodischen Perioden in Stunden'''
|0,00
|2,57
|0,85
| -328,62
|-
|'''Differenz zu drakonitischen Perioden in Stunden'''
| -2,57
|0,00
| -1,72
| -331,18
|-
|'''Differenz zu ganzen Tagen in Stunden'''
| -0,85
|1,72
|0,00
| -329,46
|}

===Mondwenden===
Da sich die '''Sonne''' definitionsgemäß immer in der Ekliptikebene befindet, wiederholen sich die Verhältnisse in Bezug auf ihre Auf- und Untergangspunkte sowie auf ihre südlichen und die nördlichen Kulminationshöhen in jedem tropischen Sonnenjahr. Zur '''Sommersonnenwende''' steht die Sonne am höchsten und am längsten über den Horizont, die Auf- und Untergangsazimute erreichen ihre nördlichsten Positionen und es ergibt sich der Kalendertag mit dem längsten Tagesslicht und der kürzesten Dunkelheit. Zur '''Wintersonnenwende''' steht die Sonne am niedrigsten und am kürzesten über den Horizont, die Auf- und Untergangsazimute erreichen ihre südlichsten Positionen und es ergibt sich der Kalendertag mit dem kürzesten Tagesslicht und der längsten Nacht. Bei den beiden '''Äquinoktien''' zum '''Frühlings- und Herbstbeginn''' herrscht die '''Tag-und-Nacht-Gleiche''', zwölf Stunden Tag und zwölf Stunden Nacht. Die Sonne geht überall auf der Erde exakt im Osten auf beziehungsweise im Westen unter.

Mit dem Neumond verhält es sich ähnlich wie mit der Sonne, da er sich stets in Sonnennähe befindet. Die Mondbahn ist gegenüber der Ekliptik jedoch geneigt (Inklination der Mondbahn), so dass der Mond bis zu gut 5&amp;nbsp;Bogengrad höher oder niedriger stehen kann als die Sonnenscheibe. Bei einer '''großen Mondwende''' steht die Ekliptik immer besonders hoch über dem Horizont und der Mond hat gleichzeitig seine maximale nördliche ekliptikale Breite erreicht. Wenn der Vollmond bei einer großen Mondwende auf dem südlichen Meridian kulminiert, findet dieses Ereignis als '''größte Mondwende''' um Mitternacht zur Wintersonnenwende statt (im Dezember 2023, 2042 und 2061).

[[Datei:Grosse.Mondwende.png|mini|zentriert|hochkant=2|Die größte Mondwende bei der am höchsten stehenden Ekliptik auf der Nordhalbkugel sowie die Sommersonnenwende im Horizontsystem. Die blaue Mondbahn wird während der Sommersonnenwende nur bei Neumond gleichzeitig mit der orangefarbenen Sonnenbahn durchlaufen. Während der Wintersonnenwende findet diese große Mondwende statt, wenn der Mond in Opposition zur Sonne steht und somit Vollmond herrscht.]]

Bei einer '''kleinen Mondwende''' steht die Ekliptik immer besonders niedrig über dem Horizont und der Mond hat gleichzeitig seine minimale südliche ekliptikale Breite erreicht. Wenn der Vollmond bei einer kleinen Mondwende auf dem südlichen Meridian kulminiert, findet dieses Ereignis als '''kleinste Mondwende''' um Mitternacht zur Sommersonnenwende statt (im Juni 2024, 2043 und 2062).

[[Datei:Kleine.Mondwende.png|mini|zentriert|hochkant=2|Die kleinste Mondwende bei der am niedrigsten stehenden Ekliptik auf der Nordhalbkugel sowie die Wintersonnenwende im Horizontsystem. Die blaue Mondbahn wird während der Wintersonnenwende nur bei Neumond gleichzeitig mit der orangefarbenen Sonnenbahn durchlaufen. Während der Sommersonnenwende findet diese kleine Mondwende statt, wenn der Mond in Opposition zur Sonne steht und somit Vollmond herrscht.]]

[[Datei:ZunehmenderMond.Herbst-Aequinoktium.P1185517.jpg|mini|rechts|Zunehmender Mond zum Herbst-Äquinoktium bei kleiner Mondwende mit flacher Ekliptik in Berlin mit fast senkrecht stehender Mondsichel (38% beleuchtet) im Sternbild Skorpion kurz vor Sonnenuntergang. Visuelle Helligkeit -9 mag, südliche ekliptikale Breite = -5°, Höhe über dem südlichen Horizont = 9°, Mondalter 6,2 Tage.]]

In der folgenden Übersicht sind die '''Mondaufgangspunkte''' am östlichen Horizont, die '''Kulminationspunkte''' auf dem südlichen Meridian und die '''Monduntergangspunkte''' am westlichen Horizont für die vier verschiedenen Jahreszeiten angegeben:

{| class=&quot;wikitable&quot;
|+ Die Lage des Bogens der Ekliptik über dem nächtlichen Horizont zu verschiedenen Jahreszeiten
!title=&quot;Jahreszeit&quot;| Jahreszeit
!title=&quot;Am Abend&quot;| Am Abend&lt;/br&gt;(Aufgang des Vollmonds&lt;/br&gt;in östlicher Richtung)
!title=&quot;Um Mitternacht&quot;| Um Mitternacht&lt;/br&gt;(Kulmination des Vollmonds&lt;/br&gt;auf dem südlichen Meridian)
!title=&quot;Am Morgen&quot;| Am Morgen&lt;/br&gt;(Untergang des Vollmonds&lt;/br&gt;in westlicher Richtung)
|-
| '''Frühlingsanfang'''&lt;/br&gt;'''Tag-und-Nacht-Gleiche''' || [[Datei:Ekliptik.C.png|360px]] || [[Datei:Ekliptik.D.png|360px]] || [[Datei:Ekliptik.A.png|360px]]
|-
| '''Sommeranfang'''&lt;/br&gt;'''Sommersonnenwende''' || [[Datei:Ekliptik.D.png|360px]] || [[Datei:Ekliptik.A.png|360px]] || [[Datei:Ekliptik.B.png|360px]]
|-
| '''Herbstanfang'''&lt;/br&gt;'''Tag-und-Nacht-Gleiche''' || [[Datei:Ekliptik.A.png|360px]] || [[Datei:Ekliptik.B.png|360px]] || [[Datei:Ekliptik.C.png|360px]]
|-
| '''Winteranfang'''&lt;/br&gt;'''Wintersonnenwende''' || [[Datei:Ekliptik.B.png|360px]] || [[Datei:Ekliptik.C.png|360px]] || [[Datei:Ekliptik.D.png|360px]]
|}

[[Datei:Orbit de Mondknoten.svg|mini|rechts|hochkant=2|Bahnellipse des Mondes mit den beiden Mondknoten.]]

Im Laufe eines '''drakonitischen Monats''' geht der Mond sowohl durch den aufsteigenden als auch durch den absteigenden Knoten (Drachenpunkte) seiner Mondbahn. Nach dem Durchqueren des aufsteigenden Knotens wird die ekliptikale Breite des Mondes positiv (nördliche ekliptikale Breite), er steigt in Bezug zur Ekliptiklinie nach Norden und bleibt entsprechend immer länger über dem Horizont. Nach dem Durchqueren des absteigenden Knotens wird die ekliptikale Breite des Mondes negativ (südliche ekliptikale Breite), er fällt in Bezug zur Ekliptiklinie nach Süden und bleibt entsprechend immer kürzer über dem Horizont. In der deutschsprachigen Schweiz gibt es für diese im Laufe eines drakonitischen Monats täglich mehr oder weniger deutlich wahrnehmbaren Änderungen der ekliptikalen Breite sogar eigene Adjektive. Das Ansteigen der ekliptikalen Breite des Mondes nach Norden wird '''obsigend''', und das Abfallen der ekliptikalen Breite des Mondes nach Süden wird '''nidsigend''' genannt. 

[[Datei:Mond-.und.Sonnenwenden.png|mini|rechts|hochkant=2|Verschiedene Mond- und Sonnenwenden auf dem südlichen Meridian im Laufe eines Jahres in Bezug zum Horizontsystem.]]

Im Laufe der Zeit pendelt der Mond immer wieder zwischen den kleinen und großen Mondwenden. Dieser Ablauf wiederholt sich nach einem vollständigen '''drakonitischen Zyklus''', also nach 18,61&amp;nbsp;Jahren, innerhalb dessen die kleinste und die größte Mondwende im zeitlichen Abstand von rund 9,3&amp;nbsp;Jahren jeweils einmal erreicht wird.

Die Deklinationen der Sonne &lt;math&gt;\delta_S&lt;/math&gt; pendeln also je nach Jahreszeit maximal um den Betrag der Schiefe der Ekliptik &lt;math&gt;\varepsilon&lt;/math&gt; um den Nullpunkt &lt;math&gt;\delta_S = 0&lt;/math&gt;, der nur zu den Tag-und-Nacht-Gleichen erreicht wird:

:&lt;math&gt;-\varepsilon \le \delta_S \le +\varepsilon&lt;/math&gt;

Die Deklinationen des Mondes &lt;math&gt;\delta_M&lt;/math&gt; pendeln zusätzlich um den Betrag der Inklination der Mondbahn &lt;math&gt;i&lt;/math&gt; (heute '''5,145&amp;nbsp;Bogengrad''') um die Werte der Deklination der Sonne &lt;math&gt;\delta_S&lt;/math&gt;:

:&lt;math&gt;-\varepsilon - i \le \delta_M \le +\varepsilon + i&lt;/math&gt;

Die Deklination und der maximale Höhenwinkel bei der Kulmination des Mondes auf dem südlichen Meridian variieren also sowohl innerhalb eines Monats durch die Inklination der Mondbahn als auch jährlich durch die Neigung der Erdachse (also die Schiefe der Ekliptik).

Die für die Azimute der Mondaufgänge &lt;math&gt;a_{A,M}&lt;/math&gt; anzuwendende Formel hängt nicht nur von der augenblicklichen Deklination des Mondes &lt;math&gt;\delta_M&lt;/math&gt;, sondern auch vom geographischen Breitengrad des Beobachters &lt;math&gt;\varphi&lt;/math&gt; ab:

:&lt;math&gt;\cos a_{A,M} = \frac {\sin \delta_M} {\cos \varphi}&lt;/math&gt;

Aus Symmetriegründen ergibt sich für die Azimute der Monduntergänge &lt;math&gt;a_{U,M}&lt;/math&gt;:

:&lt;math&gt;a_{U,M} = 360^\circ - a_{A,M} = 360^\circ - \arccos \frac {\sin \delta_M} {\cos \varphi}&lt;/math&gt;

{| class=&quot;wikitable&quot;
|+ Deklinationen des Mondes
! Ereignis !! Deklination des Mondes &lt;math&gt;\delta_M&lt;/math&gt; !! Maximaler Höhenwinkel des Mondes&lt;br/&gt;&lt;math&gt;h_{max,M}&lt;/math&gt; || Azimut des Mondaufgangs&lt;br/&gt;&lt;math&gt;a_{A,M}&lt;/math&gt; || Azimut des Monduntergangs&lt;br/&gt;&lt;math&gt;a_{U,M}&lt;/math&gt;
|-
| Kleinste Mondwende&lt;br/&gt;&lt;math&gt;\delta_S = -\varepsilon&lt;/math&gt; || &lt;math&gt;-(\varepsilon + i)&lt;/math&gt; || &lt;math&gt;(90^\circ - \varphi) - (\varepsilon + i)&lt;/math&gt; || &lt;math&gt;\arccos \frac {\sin (-\varepsilon - i)} {\cos \varphi}&lt;/math&gt; || &lt;math&gt;360^\circ - \arccos \frac {\sin (-\varepsilon - i)} {\cos \varphi}&lt;/math&gt;
|-
| Kleine Mondwende || &lt;math&gt;\delta_S - i&lt;/math&gt; || &lt;math&gt;(90^\circ - \varphi) + (\delta_S - i)&lt;/math&gt; || &lt;math&gt;\arccos \frac {\sin (\delta_S - i)} {\cos \varphi}&lt;/math&gt; || &lt;math&gt;360^\circ - \arccos \frac {\sin (\delta_S - i)} {\cos \varphi}&lt;/math&gt;
|-
| Mond im Knoten || &lt;math&gt;\delta_S&lt;/math&gt; || &lt;math&gt;(90^\circ - \varphi) + \delta_S&lt;/math&gt; || &lt;math&gt;\arccos \frac {\sin (\delta_S)} {\cos \varphi}&lt;/math&gt; || &lt;math&gt;360^\circ - \arccos \frac {\sin (\delta_S)} {\cos \varphi}&lt;/math&gt;
|-
| Große Mondwende || &lt;math&gt;\delta_S + i&lt;/math&gt; || &lt;math&gt;(90^\circ - \varphi) + (\delta_S + i)&lt;/math&gt; || &lt;math&gt;\arccos \frac {\sin (\delta_S + i)} {\cos \varphi}&lt;/math&gt; || &lt;math&gt;360^\circ - \arccos \frac {\sin (\delta_S + i)} {\cos \varphi}&lt;/math&gt;
|-
| Größte Mondwende&lt;br/&gt;&lt;math&gt;\delta_S = +\varepsilon&lt;/math&gt; || &lt;math&gt;+(\varepsilon + i)&lt;/math&gt; || &lt;math&gt;(90^\circ - \varphi) + (\varepsilon + i)&lt;/math&gt; || &lt;math&gt;\arccos \frac {\sin (\varepsilon + i)} {\cos \varphi}&lt;/math&gt; || &lt;math&gt;360^\circ - \arccos \frac {\sin (\varepsilon + i)} {\cos \varphi}&lt;/math&gt;
|}

Die Höhenwinkel des Mondes und der Sonne konnten zum Beispiel schon in der Bronzezeit mit Hilfe von '''Sonnenuhren''', '''Stabdolchen''' oder '''Kreisgrabenanlagen''' beobachtet und bestimmt werden. Im Laufe eines Jahres konnten damit die jahreszeitlichen Veränderungen der scheinbaren Sonnenbahn verfolgt werden. Durch eine langjährige Beobachtung war es dann auch möglich, die kleinsten und größten Mondwenden zu ermitteln.

Siehe hierzu auch:

* → '''[[Quadriviale_Kuriositäten/_Stabdolche|Stabdolche]]'''
* → '''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Kalenderführung#Frühgeschichtliche_Observatorien|Frühgeschichtliche Observatorien]]'''

===Vergleich der Perioden===
Die folgenden Periodendauern spielen bei Sonnen- und Mondzyklen eine besondere Rolle:

* '''Meton-Zyklus:'''
** 19&amp;nbsp;'''tropische Sonnenjahre''' = 6939,6&amp;nbsp;Tage, bestimmt durch die ekliptikale Länge der Sonne in Bezug zum Frühlingspunkt mit ihren Äquinoktien und Sonnenwenden.
** 235&amp;nbsp;'''synodische Monate''' = 6939,7&amp;nbsp;Tage, bestimmt durch die Mondphasen mit Neumonden und Vollmonden.
** 254&amp;nbsp;'''siderische Monate''' = 6939,7&amp;nbsp;Tage, bestimmt durch die ekliptikale Länge des Mondes in Bezug zum Frühlingspunkt und den Fixsternhimmel.
** 255&amp;nbsp;'''drakonitische Monate''' = 6939,1&amp;nbsp;Tage, bestimmt durch die ekliptikale Breite des Mondes beziehungsweise die auf- und absteigenden Knoten der Mondbahn.
* '''Drakonitischer Zyklus:''' 
** 249,83&amp;nbsp;'''drakonitische Monate''' = 6798,38&amp;nbsp;Tage = 18,613&amp;nbsp;tropische Sonnenjahre, bestimmt durch die ekliptikalen Längen der auf- und absteigenden Knoten der Mondbahn: Zyklus der Mondwenden und Sternbedeckungen (Nutationsperiode)
* '''Saros-Zyklus:'''
** 242&amp;nbsp;'''drakonitische Monate''' = 6585,3&amp;nbsp;Tage = 18,03&amp;nbsp;tropische Sonnenjahre (respektive 18&amp;nbsp;Jahre und 11&amp;nbsp;Tage): Zyklen der Sonnen- und Mondfinsternisse
** 223&amp;nbsp;'''synodische Monate''' = 6585,4&amp;nbsp;Tage, bestimmt durch die Mondphasen mit Neumonden und Vollmonden.

[[Datei:Meton-Zyklus.2023.4x5.png|mini|links|hochkant=4|Der 19-jährige Meton-Zyklus vom Januar&amp;nbsp;2023 bis zum Januar&amp;nbsp;2042. Die Zeit schreitet in horizontaler Richtung jeweils um einen halben Tag pro Bildpunkt voran.&lt;br/&gt;Im unteren Teil des Diagramms sind die kleinen und großen Mondwenden für die geographische Breite 52,5&amp;nbsp;Bogengrad (zum Beispiel in Berlin) dargestellt.]]
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;
[[Datei:Herbstaequinoktium.kleine.Mondwende.2033.png|mini|rechts|hochkant=1|Herbstäquinoktium (orange) und Sonnenfinsternis bei aufsteigendem (rot) Neumond am 23.&amp;nbsp;September 2033 (orangefarbene Linie), Mondfinsternis bei absteigendem (blau) Vollmond am 8.&amp;nbsp;Oktober 2033 und Wintersonnenwende (türkis) mit kleiner Mondwende bei Neumond am 21.&amp;nbsp;Dezember 2033 (grüne Linie).]]

Der '''Vollmond''' (weiß) erscheint sowohl zu Beginn der Darstellung am 6.&amp;nbsp;Januar 2023 als auch nach genau 19 Jahren am 6.&amp;nbsp;Januar 2042. Dieser Sachverhalt ergibt sich daraus, dass nach dem Durchlauf eines Meton-Zyklus eine ganzzahlige Anzahl von 235&amp;nbsp;synodischen Perioden durchlaufen wird (gleiche '''Elongation''' des Mondes). Diese Vollmonde stehen bei der gleichen ekliptikalen Länge im Sternbild Zwillinge (Gemini). Dieser Sachverhalt ergibt sich daraus, dass nach dem Durchlauf eines Meton-Zyklus eine ganzzahlige Anzahl von 254&amp;nbsp;siderischen Perioden durchlaufen wird. Gleichzeitig steht auch die Sonne nach 19&amp;nbsp;tropischen Sonnenjahren auf dem Zodiak bei der gleichen ekliptikalen Länge und somit erneut genau gegenüber vom Mond im Sternbild Schütze (Sagittarius). Da die Meton-Periode nur gut einen halben Tag länger ist als 255&amp;nbsp;drakonitische Perioden, stehen diese beiden Vollmonde bei fast der gleichen ekliptikalen Breite nördlich vom Stern Mebsuta (ε&amp;nbsp;Geminorum).

'''Große Mondwenden''' mit maximaler Höhe des Mondes und längstem Bogen über dem Horizont folgen stets dem aufsteigenden Mondknoten (rot), und '''kleine Mondwenden''' mit minimaler Höhe des Mondes und kürzestem Bogen über dem Horizont folgen stets dem absteigenden Mondknoten (blau).

[[Datei:KleinsteMondwende.23.6.2024.HDR.png|mini|hochkant=2|'''Kleinste Mondwende um die Mittsommernacht 2024''': Der Vollmond (scheinbarer Durchmesser = 31,8&amp;nbsp;Minuten) am 23.&amp;nbsp;Juni 2024 nach ein Uhr und kurz vor der oberen Kulmination auf dem südlichen Meridian von Berlin-Lankwitz (nördliche geographische Breite = 52,44&amp;nbsp;Bogengrad) aus gesehen. Die ekliptikale Breite hatte einen Minimalwert, der fast 6&amp;nbsp;Bogengrad südliche Breite betrug und somit zu einer extrem geringen maximalen Höhe über dem Horizont von nur 8,5&amp;nbsp;Bogengrad führte. Im norwegischen Trondheim (nördliche geographische Breite = 63,44&amp;nbsp;Bogengrad, also drei Breitengrade südlich vom nördlichen Polarkreis) oder im isländischen Reykjavik (nördliche geographische Breite = 64,15&amp;nbsp;Bogengrad) war in diesen Tagen weder die Mitternachtssonne noch der Vollmond zu sehen. Der helle Stern rechts oberhalb der Mondscheibe ist Nunki im Schützen (σ Sagittarius, visuell 2,7&lt;sup&gt;m&lt;/sup&gt;), unterhalb ist Asella (ζ Sagittarius, visuell 4,2&lt;sup&gt;m&lt;/sup&gt;) zu sehen.]]

Die '''größte Mondwende''' bei Vollmond tritt nur zur Wintersonnenwende und die '''kleinste Mondwende''' bei Vollmond tritt nur zur Sommersonnenwende auf. Je nach ekliptikaler Breite des Mondes schwanken die absoluten Werte für die Horizontwinkel um das doppelte der Inklination der Mondbahn, das heißt insgesamt um bis zu 10,29&amp;nbsp;Bogengrad. Die ekliptikale Breite bezieht sich auf den Erdmittelpunkt, da dieser in der Ekliptikebene liegt. Die von der Erdoberfläche aus beobachtete ekliptikale Breite des im Mittel nur zirka 383100&amp;nbsp;Kilometer entfernten Mondes hängt zusätzlich vom jeweiligen geographischen Breitengrad der Beobachtung ab. Der in Bezug auf die Ekliptik nördlichste und südlichste Punkt auf der Erdoberfläche liegen um den Erdradius von gut 6350&amp;nbsp;Kilometer oberhalb (nördlich) beziehungsweise unterhalb (südlich) der Ekliptikebene. Daraus resultiert für die beobachtete ekliptikale Breite ein zusätzlicher Winkel von knapp einem Bogengrad:

:&lt;math&gt;\Delta \beta = \arctan \frac {\pm 6350} {383100} \approx \pm 0,95^\circ&lt;/math&gt;

Die '''größte Mondwende bei Vollmond''' (weiß) tritt bei maximaler ekliptikaler Breite des Mondes um die Wintersonnenwende (türkis, siehe Dezember&amp;nbsp;2023) auf. Die '''kleinste Mondwende bei Vollmond''' (weiß) tritt bei minimaler ekliptikaler Breite des Mondes um die Sommersonnenwende (gelb, siehe Juni 2024).

Im 19-jährigen Diagramm (siehe oben) ist gut zu erkennen, wie sich die Konstellation zwischen Mondknoten (rot und blau) und Mondphasen (weiß und schwarz) nach den 19&amp;nbsp;Jahren des '''Meton-Zyklus''' wiederholt (vergleiche Januar&amp;nbsp;2023 und Januar&amp;nbsp;2042).

Der erste aufsteigende Mondknoten (rot) wird fünf Tage vor Vollmond am 2.&amp;nbsp;Januar 2023 erreicht. Nach einer vollständigen '''Saros-Periode''' von 18&amp;nbsp;Jahren und 11&amp;nbsp;Tagen, also am 12.&amp;nbsp;Januar 2041 wird fünf Tage vor Vollmond ebenfalls wieder ein aufsteigender Mondknoten erreicht.

Eine Besonderheit gibt es im März 2038: Die Tag-und-Nacht-Gleiche erfolgt bereits am 20.&amp;nbsp;März 2038 (Samstag) und der erste Frühlingsvollmond nur einige Stunden später am 21.&amp;nbsp;März 2038 (Sonntag). Grundsätzlich müsste also der darauffolgende Sonntag, nämlich der 28.&amp;nbsp;März 2038, das '''Osterdatum''' sein. In diesem Fall greift die abweichende Regel, dass erst der Vollmond nach dem 21.&amp;nbsp;März als Frühlingsvollmond zu rechnen ist, was erst am 19.&amp;nbsp;April 2038 (Montag) der Fall ist. Demzufolge ist das Osterdatum auf den 25.&amp;nbsp;April 2038 (Sonntag) festgelegt.

Eine '''Sonnenfinsternis '''tritt immer dann auf, wenn ein Neumond (weiß) zeitnah durch einen aufsteigenden (rot) oder absteigenden (blau) Mondknoten läuft. Dies ist im obigen Diagramm an den folgenden Tagen der Fall:

* 20.&amp;nbsp;April 2023, 14.&amp;nbsp;Oktober 2023, 8.&amp;nbsp;April 2024, 2.&amp;nbsp;Oktober 2024, 29.&amp;nbsp;März 2025, '''21.&amp;nbsp;September 2025''' (Herbstäquinoktium), 17.&amp;nbsp;Februar 2026, 12.&amp;nbsp;August 2026, 6.&amp;nbsp;Februar 2027, 2.&amp;nbsp;August 2027, 26.&amp;nbsp;Januar 2028, 22.&amp;nbsp;Juli 2028, 14.&amp;nbsp;Januar 2029, 12.&amp;nbsp;Juni 2029, 11.&amp;nbsp;Juli 2029, 5.&amp;nbsp;Dezember 2029, 1.&amp;nbsp;Juni 2030, 25.&amp;nbsp;November 2030, 21.&amp;nbsp;Mai 2031, 14.&amp;nbsp;November 2031, 9.&amp;nbsp;Mai 2032, 3.&amp;nbsp;November 2032, 30.&amp;nbsp;März 2033, '''23.&amp;nbsp;September 2033''' (Herbstäquinoktium), '''20.&amp;nbsp;März 2034''' (Frühlingsäquinoktium), 12.&amp;nbsp;September 2034, 9.&amp;nbsp;März 2035, 2.&amp;nbsp;September 2035, 27.&amp;nbsp;Februar 2036, 23.&amp;nbsp;Juli 2036, 21.&amp;nbsp;August 2036, 16.&amp;nbsp;Januar 2037, 13.&amp;nbsp;Juli 2037, 5.&amp;nbsp;Januar 2038, 2.&amp;nbsp;Juli 2038, 26.&amp;nbsp;Dezember 2038, '''21.&amp;nbsp;Juni 2039''' (Sommersonnenwende), 15.&amp;nbsp;Dezember 2039, 11.&amp;nbsp;Mai 2040, 4.&amp;nbsp;November 2040, 30.&amp;nbsp;April 2041, 25.&amp;nbsp;Oktober 2041

Genau neunzehn Jahre nach den ersten beiden genannten Sonnenfinsternissen im Jahr&amp;nbsp;2023 treten an den gleichen Kalendertagen erneut zwei Sonnenfinsternisse auf, nämlich am 20.&amp;nbsp;April 2042 und am 14.&amp;nbsp;Oktober 2042.

Neunzehn Jahre vor den sechs ersten aufgeführten Sonnenfinsternissen in den Jahren&amp;nbsp;2023 bis&amp;nbsp;2025 traten an fast immer den gleichen Kalendertagen ebenfalls Sonnenfinsternisse auf, nämlich am 19.&amp;nbsp;April 2004, am 14.&amp;nbsp;Oktober 2004, am 8.&amp;nbsp;April 2005, am 3.&amp;nbsp;Oktober 2005, am 29.&amp;nbsp;März 2006 und am 22.&amp;nbsp;September 2006.

Eine '''Mondfinsternis '''tritt immer dann auf, wenn ein Vollmond (weiß) zeitnah durch einen aufsteigenden (rot) oder absteigenden (blau) Mondknoten läuft. Dies ist im obigen Diagramm an den folgenden Tagen der Fall:

* 5.&amp;nbsp;Mai 2023, 28.&amp;nbsp;Oktober 2023, 25.&amp;nbsp;März 2024, 18.&amp;nbsp;September 2024, 14.&amp;nbsp;März 2025, 7.&amp;nbsp;September 2025, 3.&amp;nbsp;März 2026, 28.&amp;nbsp;August 2026, 20.&amp;nbsp;Februar 2027, 18.&amp;nbsp;Juli 2027, 17.&amp;nbsp;August 2027, 12.&amp;nbsp;Januar 2028, 6.&amp;nbsp;Juli 2028, 31.&amp;nbsp;Dezember 2028, 26.&amp;nbsp;Juni 2029, '''20.&amp;nbsp;Dezember 2029''' (Wintersonnenwende), 15.&amp;nbsp;Juni 2030, 9.&amp;nbsp;Dezember 2030, 7.&amp;nbsp;Mai 2031, 5.&amp;nbsp;Juni 2031, 30.&amp;nbsp;Oktober 2031, 25.&amp;nbsp;April 2032, 18.&amp;nbsp;Oktober 2032, 14.&amp;nbsp;April 2033, 8.&amp;nbsp;Oktober 2033, 3.&amp;nbsp;April 2034, 28.&amp;nbsp;September 2034, 22.&amp;nbsp;Februar 2035, 19.&amp;nbsp;August 2035, 11.&amp;nbsp;Februar 2036, 7.&amp;nbsp;August 2036, 31.&amp;nbsp;Januar 2037, 27.&amp;nbsp;Juli 2037, 21.&amp;nbsp;Januar 2038, '''17.&amp;nbsp;Juni 2038''' (Sommersonnenwende), 16.&amp;nbsp;Juli 2038, 11.&amp;nbsp;Dezember 2038, 6.&amp;nbsp;Juni 2039, 30.&amp;nbsp;November 2039, 26.&amp;nbsp;Mai 2040, 18.&amp;nbsp;November 2040, 16.&amp;nbsp;Mai 2041, 8.&amp;nbsp;November 2041

&lt;gallery caption=&quot;Finsternisse&quot; perrow=&quot;1&quot; widths=&quot;1024&quot; heights=&quot;470&quot;&gt;
Finsternisse.2025.png|Die Finsternisse im Jahr 2025 liegen in der Nähe der Tag-und-Nacht-Gleichen, wo mittlere Mondwenden vorliegen. Der Mond geht im Osten auf und im Westen unter.
Finsternisse.2029.png|Die Finsternisse im Jahr 2029 liegen in der Nähe der Sonnenwenden. Bei der Sonnenfinsternis im Juni kommt es bei Neumond zu einer großen Mondwende, und bei der darauffolgenden Mondfinsternis kommt es bei Vollmond zu einer kleinen Mondwende. Bei der Sonnenfinsternis im Dezember kommt es bei Neumond zu einer kleinen Mondwende, und bei der darauffolgenden Mondfinsternis kommt es bei Vollmond zu einer großen Mondwende.
&lt;/gallery&gt;

==Der Kalenderstein vom Tempel Mnajdra==
Auf Malta wurde im Hypogäum von Ħal-Saflieni beim Ort Tarxien ein annähernd kreisrunder Stein aus der Tempelperiode der Insel mit zirka sechs Zentimeter Durchmesser gefunden, der wie die Darstellung einer Vollmondscheibe aussieht.&lt;ref&gt;Daniel Cilia: [http://web.infinito.it/utenti/m/malta_mega_temples/TempleFig/%20Pres,Misc/pages/face.htm Found in a house at Hal Saflieni, stone, c.6 cm wide], The megalithic temples of Malta - the world's most ancient stone architectur, DSCF9754&lt;/ref&gt; Im maltesischen Tempel Mnajdra sind an der südlichen Küste Maltas zirka zehn Kilometer entfernt davon zwei große Kalendersteine gefunden worden, die ebenfalls aus dieser Zeit stammen.

&lt;gallery caption=&quot;Die Ruinen der Tempelanlage von Mnajdra&quot; widths=&quot;300&quot; heights=&quot;300&quot; mode=&quot;packed&quot;&gt;
Plan_der_Tempel_von_Mnajdra.png|Plan der Tempelanlage. Die beiden Kalendersteine befinden sich in der Mitte des Urtempels im Osten der Anlage (Buchstabe &quot;A&quot;), die aus dem vierten vorchristlichen Jahrtausend stammt.
Mini_Europa_Brüssel-2125_Tempel_von_Mnajdra.jpg|Modell der Tempelanlage im Park &quot;Mini-Europa&quot; in Brüssel. Die Kalendersteine befinden sich links und rechts hinter der Frauenfigur auf der rechten Seite.
Malta_-_Qrendi_-_Hagar_Qim_and_Mnajdra_Archaeological_Park_-_Mnajdra_16_ies.jpg|Darstellung der Lochreihen der beiden Kalendersteine auf einer Schautafel der archäologischen Stätte.
Mnajdra_East_Temple_1_(6799974274).jpg|Blick vom Eingang des Osttempels auf die beiden aufrechtstehenden Kalendersteine – links der westliche und rechts der östliche Kalenderstein.
Mnajdra_Temple_-_Chris_Brown.jpg|Blick über die Kalendersteine – links der östliche und rechts der westliche Kalenderstein, den Eingang des Osttempels und die Südküste Maltas auf das Mittelmeer mit der vorgelagerten Insel Filfla.
&lt;/gallery&gt;

Auf dem östlichen Kalenderstein gibt es mehrere Lochreihen, deren Lochzahlen alle mit lunaren und solaren Kalendern in Zusammenhang gebracht werden können. In der heute zusammengestellten Anordnung der Steine können nicht alle Löcher gebohrt worden sein, da diese teilweise von anderen Steinen verdeckt sind. Die Bohrungen sind heute in horizontaler Richtung ausgerichtet, wurden damals vermutlich unter Ausnutzung der Gravitation senkrecht nach unten auf dem noch liegenden Stein ausgeführt. In dieser Ausrichtung des Steins wäre es auch leicht möglich gewesen, für Markierungs- oder Zählzwecke zum Beispiel kugelförmige Gegenstände in die Löcher zu legen. Steckkalender aus Stein mit Bohrungen (bei den Griechen hießen sie '''Parapegmata''') waren im Altertum an vielen Orten in Verwendung.

Am Kopf des Steins gibt es mehrere hundert, flächenhaft angeordnete Löcher, die eventuell für die einzelnen Monate oder Jahre einer langfristigen Beobachtung stehen. Darunter tauchen rechtsbündig sieben horizontale Lochreihen auf, die in der Skizze mit den Buchstaben A bis G gekennzeichnet sind, wobei die beiden Teilreihengruppen B1 und B2 sowie C1, C2 und C3 zusammengefasst betrachtet werden:

[[Datei:Kalenderstein.Mnajdra.labelled.png|mini|links|hochkant=3|Skizze der Lochreihen auf dem Kalenderstein von Mnajdra nach Ventura und Hoskin.&lt;ref name=&quot;Ventura&quot;&gt;Frank Ventura, Michael Hoskin: [[doi:10.1007/978-1-4614-6141-8_133|Temples of Malta]], in: Clive Ruggles (Herausgeber), ''Handbook of Archaeoastronomy and Ethnoastronomy'', 7. Juli 2014, Seiten 1421-1430, Springer, New York, ISBN 978-1-4614-6140-1&lt;/ref&gt;]]

{| class=&quot;wikitable&quot;
|+ Lochreihen auf dem östlichen Kalenderstein vom Tempel Mnajdra auf Malta
!title=&quot;Reihe&quot;| Reihe
!title=&quot;Anzahl der Löcher&quot;| Anzahl der Löcher
!title=&quot;Mögliche Verwendung&quot;| Mögliche Verwendung
|-
| A || 19 || Für die jeweilige Goldene Zahl jedes Sonnenjahres innerhalb des 19-jährigen '''Meton-Zyklus''' (235&amp;nbsp;synodische, 255&amp;nbsp;drakonitische, 254&amp;nbsp;siderische Monate beziehungsweise 6940&amp;nbsp;Tage).&lt;br/&gt;Nach einem Sonnenjahr hat die Sonne wieder die gleiche ekliptikalen Länge. Nach Ablauf der gesamten Meton-Periode hat der Mond wieder die gleiche Mondphase '''und''' die gleiche ekliptikalen Breite '''und''' die gleiche ekliptikalen Länge (zum Beispiel im Goldenen Tor der Ekliptik oder im Frühlingspunkt).
|-
| rowspan=2 | B || B&lt;sub&gt;1&lt;/sub&gt;: 13 (links) || rowspan=2 | In Summe 29, für die Anzahl der vollständigen Tage in einem '''synodischen Monat''' (29,5&amp;nbsp;Tage). Nach dieser Zeit hat der Mond wieder die gleiche Mondphase erreicht.&lt;br/&gt;Vom Altlicht des Mondes bis zum Vollmond sind es 16&amp;nbsp;Tage, und danach sind es 13&amp;nbsp;Tage bis zum nächsten Altlicht.&lt;br/&gt;Nachdem die Doppelreihe vervollständigt wurde, gibt es dafür einen Übertrag in die Reihe&amp;nbsp;E und wenn diese bereits voll ist, für das nächste beginnende Jahr mit der nächstfolgenden '''Goldenen Zahl''' einen Übertrag in die Reihe&amp;nbsp;A.
|-
| B&lt;sub&gt;2&lt;/sub&gt;: 16 (rechts darunter)
|-
| rowspan=3 | C || C&lt;sub&gt;1&lt;/sub&gt;: 3 (rechts oben) || rowspan=2 | Für die sieben vollständigen Tage eines '''Mondviertels''' (≈7,4&amp;nbsp;Tage) respektive einer '''Woche'''.&lt;br/&gt;Wenn diese Doppelreihe gefüllt ist, gibt es für die Vervollständigung einer neuen Woche einen Übertrag in die Reihe&amp;nbsp;G für die Wochen in einem Jahr.&lt;br/&gt;Alternativ könnten hier jeweils die drei Monate in den vier Jahreszeiten markiert und gezählt worden sein.&lt;br/&gt;Ein weiterer Zusammenhang besteht eventuell mit der Tatsache, dass in 19 Jahren (siehe Reihe A) sieben synodische Schaltmonate erforderlich sind, um in einem lunisolaren Kalender den Lauf von Sonne und Mond bis auf wenige Stunden genau zu synchronisieren (siehe hierzu auch''' [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|Plejaden-Schaltregeln]]''').
|-
| C&lt;sub&gt;2&lt;/sub&gt;: 4 (rechts unten)
|-
| C&lt;sub&gt;3&lt;/sub&gt;: 3 (links) || Für die drei nach Neumond '''vollendeten Mondviertel''' innerhalb eines laufenden synodischen Monats.&lt;/br&gt;Beim Erreichen eines Neumonds, eines abnehmenden Halbmonds, eines Vollmonds oder eines abnehmenden Halbmonds gibt es jeweils einen Übertrag in die Reihe&amp;nbsp;D oder in die Reihe&amp;nbsp;F (siehe unten).
|-
| D || 25 || Für die 25&amp;nbsp;'''vollendeten Mondviertel''' in der ersten Hälfte eines Sonnenjahres, oder entweder für alle '''zunehmenden Mondviertel''' (wenn der Mond zu Beginn des Jahres zunehmend war) oder für alle '''abnehmenden Mondviertel''' (wenn der Mond zu Beginn des Jahres abnehmend war) eines Sonnenjahres (vergleiche Reihe&amp;nbsp;F).
|-
| E || 11 || Nachdem die Doppelreihe B vollständig durchlaufen wurde, gibt es einen Übertrag in diese Reihe. Diese elf Mulden stehen dann für '''überzähligen Tage''' in einem Sonnenjahr (365,2&amp;nbsp;Tage) im Vergleich zu zwölf synodischen Monaten (354,4&amp;nbsp;Tage). Wenn diese Reihe bereits voll ist, gibt es für das nächste beginnende Jahr mit der nächstfolgenden '''Goldenen Zahl''' einen Übertrag in die Reihe&amp;nbsp;A.
|-
| F || 24 + 1 = 25 || Für die 24 bis 25 '''vollendeten Mondviertel''' in der zweiten Hälfte eines Sonnenjahres, oder entweder für alle '''abnehmenden Mondviertel''' (wenn der Mond zu Beginn des Jahres zunehmend war) oder für alle '''zunehmenden Mondviertel''' (wenn der Mond zu Beginn des Jahres abnehmend war) eines Sonnenjahres (vergleiche Reihe&amp;nbsp;D). Das 25.&amp;nbsp;Loch ist etwas abgesetzt, da es für ein am Ende des Jahres eingeschaltetes 50.&amp;nbsp;Mondviertel (Dauer = 7,38265&amp;nbsp;Tage) steht, das nur in ungefähr jedem zweiten Sonnenjahr auftritt:&lt;br/&gt;
:49 x 7,38265 Tage ≈ 361,75 Tage beziehungsweise 50 x 7,38265 Tage ≈ 369,13 Tage&lt;br/&gt;
:365,242 Tage - 361,75 Tage ≈ 3,5 Tage beziehungsweise 365,242 Tage - 369,13 Tage ≈ -3,9 Tage
|-
| G || 53 || Für die begonnenen 53 '''Siebentagewochen''' in einem Sonnenjahr (Dauer = 365,242&amp;nbsp;Tage) beziehungsweise von einem heliakischen Auf- oder akronychischen Untergang der Plejaden zum nächsten.
|}

[[Datei:Altlicht.16.9.2020.P1079087.jpg|mini|rechts|Über dem östlichen Horizont beim Morgenletzt gerade noch sichtbares Altlicht des abnehmenden Mondes 33 Stunden vor Neumond mit der vom Erdschein beleuchteten Nachtseite des Mondes. Die Aufnahme entstand kurz vor Herbstbeginn, als die Ekliptik morgens fast senkrecht auf dem Horizont stand.]]

Zu der Doppelreihe&amp;nbsp;B sei angemerkt, dass auch im altägyptischen Mondkalender, der im Neolithikum in Verwendung war, der Monat nicht mit dem unsichtbaren Neumond, sondern mit dem gerade noch sichtbaren Altlicht des Morgenletztes des Mondes begann, also gut einen Tag vor Neumond.&lt;ref&gt;Joachim Friedrich Quack: [https://core.ac.uk/download/pdf/35120251.pdf Zwischen Sonne und Mond - Zeitrechnung im Alten Ägypten], Seite 38, in: Harry Falk (Herausgeber), ''Vom Herrscher zur Dynastie. Zum Wesen kontinuierlicher Zeitrechnung in Antike und Gegenwart'', Bremen 2002&lt;/ref&gt; Die beiden letzten Löcher sind etwas nach links abgesetzt, was mit folgendem Sachverhalt im Einklang steht: zwei Tage vor dem Ende einer synodischen Periode, also schon nach gut 27&amp;nbsp;Tagen, ist ein siderischer Monat vorüber, nach welchem der Mond die gleiche ekliptikale Länge erreicht hat. Das heißt bereits nach gut 27&amp;nbsp;Tagen steht der Mond zum Beispiel wieder im Goldenen Tor der Ekliptik, bevor er erst nach gut 29&amp;nbsp;Tagen erneut sein Altlicht erreicht (gut einen Tag vor Neumond). Die Sonne ist innerhalb des synodischen Monats durch die Bewegung der Erde um die Sonne gegenüber dem Fixsternhimmel um knapp 30&amp;nbsp;Bogengrad weiter nach links gezogen.

Die 25&amp;nbsp;Wochen des abnehmenden Mondes werden zum Beispiel auch im 79.&amp;nbsp;Kapitel des ungefähr 2000&amp;nbsp;Jahre alten {{w|Äthiopisches Henochbuch|äthiopischen Henochbuches}} erwähnt.&lt;ref&gt;Siehe auch {{s|Henochbuch_(oder_Erster_Henoch)#Der_dritte_Teil_72–82_Das_astronomische_Buch|Wikisource, Henochbuch, Teil 3, Kapitel 71 bis 82}}&lt;/ref&gt; Alternativ könnten die 50&amp;nbsp;Löcher in Reihen&amp;nbsp;D und F eventuell auch für die 50 vollständigen Siebentagewochen (350&amp;nbsp;Tage) innerhalb von zwölf synodischen Perioden stehen, die eine Dauer von 50,6&amp;nbsp;Wochen beziehungsweise 354,4&amp;nbsp;Tagen haben.

Zur Zahl Elf (Reihe&amp;nbsp;E) ist noch festzuhalten, dass die Erde innerhalb eines siderischen Jahres des Planeten Jupiter (zwölf Erdenjahre) elf Mal mit diesem in Opposition steht. Zu diesen Zeitpunkten ist der Abstand zwischen Erde und Jupiter am geringsten, der Jupiter hat steht in seinem größten Glanz und er kulminiert um Mitternacht auf dem südlichen Meridian.

[[Datei:Mnajdra East Temple 2 (6946102161).jpg|rechts|mini|Detail des westlichen Kalendersteins aus dem Osttempel von Mnajdra.]]

Auch auf einem weiteren, sogenannten westlichen und heute ebenfalls aufgerichteten Stein der Tempelanlage sind mehrere Lochreihen zu sehen, die aus 16, 12, 19, 7, 30, 31, 32, 35, 37, 12 und 13 Löchern bestehen.&lt;ref&gt;David Humiston Kelley, Eugene Frank Milone: ''Exploring Ancient Skies: A Survey of Ancient and Cultural Astronomy'', Part II ''Astronomy in Cultures'', 6 ''Paleolithic and Neolithic Cultures'', 6.2 ''Megalithic Cultures'', 6.2.18 ''Mediterranean and North African Megalithic Sites'', 6.2.18.1 ''Malta'', pages 201 and 202, Springer, 2011, ISBN 9781441976246&lt;/ref&gt; Einige dieser Zahlen tauchen auch im Zusammenhang mit dem östlichen Stein auf oder sind ebenfalls leicht mit lunaren oder solaren Kalendertagen in Verbindung zu bringen:

* 16: Anzahl der Tage vom Altlicht bis zum Vollmond.
* 12: Anzahl der vollständigen Monate pro Jahr.
* 19: Anzahl der tropischen Jahre pro Meton-Periode.
* 7: Anzahl der vollständigen Tage pro Mondviertel respektive der Tage pro Woche.
* 30: aufgerundete Anzahl der Tage pro synodische Periode respektive der Tage pro Monat.

→ In Bezug auf die Bedeutung von bestimmten Zahlen in der Astronomie siehe auch '''[[Quadriviale Kuriositäten‎/ Zahlen|Exkurs „Zahlen“]]'''.
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

==Malereien in der Höhle von Magura==
In der schon im Neolithikum genutzten Magura-Höhle im Nordwesten des heutigen Bulgariens gibt es nicht nur eine sehr alte bildliche Darstellung eines Schöpfungsmythos, sondern ebenfalls Hinweise darauf, dass verschiedene Mondzyklen bekannt waren. Unter den Darstellungen befindet sich insbesondere eine Reihe von Strichen, mit denen die 16&amp;nbsp;Tage vom Altlicht des Mondes bis zu Vollmond gezählt worden sein können.

→ Weitere Erläuterungen finden sich im '''[[Die_Höhlenmalerei_in_der_Magura-Höhle|Wikibook „Die Höhlenmalerei in der Magura-Höhle“]]'''.

[[Datei:Magura.Altlicht.Vollmond.png|links|mini|hochkant=4|Erste Hälfte des synodischen Monats in einer Darstellung der Höhlenmalerei von Magura. Rechts ist die schmale, liegende Mondsichel des Altlichts beim Morgenletzt zu sehen. Ein bis zwei Tage später ist Neumond, danach nimmt der Mond wieder zu, und nach insgesamt sechzehn Tagen wird der Vollmond erreicht (links).]]
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

== Kontrastverhältnisse bei aschgrauem Mondlicht ==
[[Datei:Aschgraues.Mondlicht.P1162513.jpg|mini|hochkant=2|Die vom Erdschein beleuchtete Nachtseite des Mondes wird neben der schmalen Mondsichel (11&amp;nbsp;Prozent, Mondalter = 3,3&amp;nbsp;Tage) mit ''aschgrauem Mondlicht'' sichtbar. Aufnahme über dem westlichen Abendhimmel kurz nach dem Äquinoktium im Frühjahr bei besonders steiler Ekliptik von Berlin aus gesehen. Links der Stern Omikron Arietis (37 Ari, 6,2&lt;sup&gt;m&lt;/sup&gt;) im Sternbild Widder.&lt;br/&gt;&lt;br/&gt;
Mit bloßen Augen ist das aschgraue Licht im Mondschatten nur unter sehr guten atmosphärischen Bedingungen und mit voller menschlicher Sehkraft gerade noch erkennbar. Der Mond hat nur einen Winkeldurchmesser von 0,5 Bogengrad, was bei ausgestrecktem Arm nur ungefähr einem Viertel der Breite eines Fingers entspricht. Die hier gezeigte Aufnahme ist sehr hell belichtet, so dass die Kontraste im Mondschatten einfacher wahrzunehmen sind als in der Natur:
[[Datei:Aschgraues.Mondlicht.P1162513.jpg|90px|zentriert]]
]]

Das '''aschgraue Mondlicht''' kann wenige Tage vor und nach Neumond im Schattenbereich des Mondes beobachtet werden, wenn die Sonne unter dem Horizont steht. Der Schattenbereich wird hierbei durch den '''Erdschein''' beleuchtet und hebt sich deutlich sichtbar vom Himmel ab, der den Mond umgibt. Der Erdschein hängt vom Albedo der vom direkten Sonnenlicht getroffenen Erde ab und kann insbesondere durch den Anteil an Wolken in der Atmosphäre sowie an Eis- und Schneeflächen auf der Erdoberfläche schwanken.

=== Historische Beobachtungen ===
Bereits die Babylonier haben im sechsten vorchristlichen Jahrhundert diesen visuellen Effekt in bildlichen Darstellungen auf Steinreliefs mit dem König Nabonid vor der Mondsichel mit aschgrauem Licht festgehalten:&lt;ref&gt;Friedhelm Pedde: ''[https://wfs.berlin/wp-content/uploads/2021/09/BROplanet-12-okt2021ff_www.pdf Götter und Planeten im Alten Orient - Sin und der Mond]'', Mitteilungen, Ausgabe 12, Seite 6 und 7, Oktober 2021, Wilhelm-Foerster-Sternwarte e.V. / Zeiss-Planetarium am Insulaner&lt;/ref&gt;

&lt;gallery caption=&quot;&quot; mode=&quot;packed&quot; widths=&quot;600&quot; heights=&quot;400&quot;&gt;
Urfa museum King Nabonid embossed inscription Iron age - 5026.jpg|Darstellung des letzten Königs des Neubabylonischen Reiches, Nabonid, vor der Mondsichel mit aschgrauem Mondlicht am Kopf einer babylonischen Stele aus Harran im Archäologischen Museum Şanlıurfa in der Türkei aus dem sechsten vorchristlichen Jahrhundert.
Nabonidus.jpg|Darstellung des letzten Königs des Neubabylonischen Reiches, Nabonid, vor der Mondsichel mit aschgrauem Mondlicht am Kopf einer babylonischen Stele im Britischen Museum.
Voynich.68r.Mondsichel.Erdschein.png|Darstellung der Mondsichel mit einem Gesicht im Schattenbereich des Mondes im astronomischen Abschnitt des Voynich-Manuskripts aus dem 15.&amp;nbsp;Jahrhundert.
Caspar David Friedrich - Zwei Männer in Betrachtung des Mondes.jpg|Zwei Männer am Abend bei der Betrachtung des Neulichts von Caspar David Friedrich (1819/1820), Öl auf Leinwand, Albertinum, Dresden. Eine in dieser Darstellung ähnliche Konstellation zwischen einer solchen Mondsichel und dem Planeten Jupiter fand am Abend des 28.&amp;nbsp;Märzes 1811 im Sternbild Stier (Taurus) statt. Eine Woche nach der Tag-und-Nacht-Gleiche des Frühjahrs stand der Mond wie im Bild dargestellt mit stark geneigter Sichel etwas tiefer als der Jupiter über dem westlichen Horizont.
Moon - Artemis II - April 6 2026 (55193552739).jpg|Die Aufnahme der Artemis-II-Besatzung während ihres Mondvorbeiflugs am 6.&amp;nbsp;April 2026 zeigt eine Sonnenfinsternis. Am linken Rand der Mondscheibe ist das schwache Leuchten des aschgrauen Mondlichts zu erkennen, das vom Erdschein der links vom Mond befindlichen Erde hervorgerufen wurde.
&lt;/gallery&gt;

=== Bestimmung der Kontraste ===
[[Datei:Altlicht.Mond.P1116624.jpg|mini|rechts|hochkant=2|Altlicht des Mondes am 3.&amp;nbsp;November&amp;nbsp;2021 mit aschgrauem Licht im Schattenbereich des Mondes von Berlin aus gesehen.]]

Das nebenstehende Bild des Altlichts (Mondalter 27,7 von 29,5 Tagen) im Sternbild Jungfrau wurde am 3.&amp;nbsp;November&amp;nbsp;2021 um 7:05&amp;nbsp;Uhr morgens mit einem hochwertigen Teleobjektiv mit guter Kontrastübertragung über dem ostsüdöstlichen Horizont (Azimut 122&amp;nbsp;Bogengrad) in Berlin aufgenom­men. Die Sonne stand zum Zeitpunkt der Aufnahme noch gut ein Bogengrad unter dem Hori­zont, der Mond hatte eine nördliche ekliptikale Breite von gut 3&amp;nbsp;Bogengrad und eine Elongation von 22&amp;nbsp;Bogengrad, so dass er bei wolkenlosem Himmel und bei einer Höhe von 17,5&amp;nbsp;Bogengrad über dem Horizont gut zu beobachten war. Die Mondscheibe war mit bloßem Auge vollständig sichtbar und war zu 3,7&amp;nbsp;Prozent vom direkten Sonnenlicht beleuchtet.

Die aufgenommenen Rohdaten wurden für diese Auswertung mit einer Software mit mög­lichst neutralen Einstellungen zu einer Schwarz-Weiß-Aufnahme entwickelt (Kontrast = 1, Gamma = 1, Farbtemperatur = 4100&amp;nbsp;Kelvin, Farbsättigung = 0). Anhand der Bilddaten können die Luminanzwerte (Helligkeiten) im Bild bestimmt werden, um aus beliebigen paarweisen Luminanzwerten den jeweiligen Kontrast zu berechnen. Der '''Michelson-Kontrast''' &lt;math&gt;M&lt;/math&gt; (auch '''Modulation'''), der sich aus zwei benachbarten Luminanzwerten &lt;math&gt;L_2&lt;/math&gt; und &lt;math&gt;L_1&lt;/math&gt; ergibt (Bedingung: &lt;math&gt;L_2 \ge L_1 \ge 0&lt;/math&gt;), liegt immer zwischen 0 (&lt;math&gt;L_2 = L_1&lt;/math&gt;, also kein Kontrast) und 1 beziehungsweise 100&amp;nbsp;Prozent (&lt;math&gt;L_1 = 0&lt;/math&gt;, also maxi­maler Kontrast):

:&lt;math&gt;M = \frac {L_2 - L_1} {L_2 + L_1}&lt;/math&gt;

→ Siehe auch [[Digitale_bildgebende_Verfahren:_Grundlagen#Modulation|Wikibook '''Digitale bildgebende Verfahren''', Kapitel '''Grundlagen''', Abschnitt '''Modulation''']].

Die Sichel ist in der ausgewerteten Aufnahme nicht überbelichtet, hat im Scheitel einen mittleren Luminanzwert von:

:&lt;math&gt;L_{Sichel} = 236&lt;/math&gt;

Der den Mond umgebende Himmel hat durch das vorhandene Streulicht in der Troposphäre einen mittleren Luminanzwert von:

:&lt;math&gt;L_{Himmel} = 15&lt;/math&gt;

Daraus resultiert ein entsprechend hoher Michelson-Kontrast &lt;math&gt;M&lt;/math&gt;:

:&lt;math&gt;M_{Sichel,Himmel} = \frac {L_{Sichel} - L_{Himmel}} {L_{Sichel} + L_{Himmel}} = \frac {236 - 15} {236 + 15} = \frac {221} {251} = 0,88&lt;/math&gt;

Im aschgrauen Licht in der Schattenseite des abnehmenden Mondes (dessen gesamte scheinbare Helligkeit beträgt bei der in der Abbildung sichtbaren Mondphase übrigens ungefähr -3&lt;sup&gt;m&lt;/sup&gt;), die vom Erdschein beleuchtet wird, ergibt sich für die etwas variierende Reflektivität der Mondoberfläche ein mittlerer Luminanzwert von:

:&lt;math&gt;L_{Schatten} = 24,5&lt;/math&gt;

Im Vergleich zur hellen Mondsichel ergibt sich daraus ein etwas geringerer Kontrast zwischen Mondsichel und Mondschatten als zwischen Mondsichel und Nachthimmel:

:&lt;math&gt;M_{Sichel,Schatten} = \frac {L_{Sichel} - L_{Schatten}} {L_{Sichel} + L_{Schatten}} = \frac {236 - 24,5} {236 + 24,5} = \frac {211,5} {260,5} = 0,81&lt;/math&gt;

Die Standardabweichung beträgt in der Schattenseite des abnehmenden Mondes:

:&lt;math&gt;L_{Abweichung} = 2,5&lt;/math&gt;.

Innerhalb der sichtbaren Schattenseite des Mondes resultiert aus den dort mit einer Standardabweichung um den Mittelwert herum auftretenden Luminanzwerten für das aschgraue Licht ein Kontrast von nur 10&amp;nbsp;Prozent:

:&lt;math&gt;M_{Schatten} = \frac {(L_{Schatten} + L_{Abweichung}) - (L_{Schatten} - L_{Abweichung})} {(L_{Schatten} + L_{Abweichung}) + (L_{Schatten} - L_{Abweichung})} = \frac {L_{Abweichung}} {L_{Schatten}}= \frac {2,5} {24,5} = 0,10&lt;/math&gt;

Dieser Kontrastwert ergibt sich im Übrigen im gleichen Maße auch auf der von der Sonne voll beleuchteten und dann jedoch insgesamt erheblich helleren Oberfläche des Vollmonds (die scheinbare Helligkeit beträgt dann ungefähr -13&lt;sup&gt;m&lt;/sup&gt;).

:'''Anmerkung''': ''Die Sinnhaftigkeit der Kontrastbestimmung mit der Standardabweichung begründet sich in der Tatsache, dass eine perfekte schwarz-weiße Kante mit einem maximalen Luminanzwert &lt;math&gt;L_{max}&lt;/math&gt; im hellen Bereich und einem Luminanzwert von Null im dunklen Bereich eine Modulation &lt;math&gt;M&lt;/math&gt; von eins hat, sofern die weiße und die schwarze Teilfläche gleich groß sind und jeweils &lt;math&gt;\frac {n} {2}&lt;/math&gt; Messwerte beinhalten. Sowohl der Mittelwert aller &lt;math&gt;n&lt;/math&gt; Luminanzwerte als auch die Standardabweichung aller &lt;math&gt;n&lt;/math&gt; Luminanzwerte sind dann beide genau halb so groß wie der maximale Luminanzwert:''

::&lt;math&gt;L_{Mittelwert} = \sum_{i=1}^n L_{i} = \sum_{i=1}^{\frac {n} {2}} 0 + \sum_{i=1}^{\frac {n} {2}} L_{max} = \frac {L_{max}} {2}&lt;/math&gt; 
::&lt;math&gt;L_{Standardabweichung} = \sqrt {\frac {\sum_{i=1}^n (L_{i} - L_{Mittelwert})^2} {n}} = \sqrt {\frac {\sum_{i=1}^n \left( \frac {L_{max}} {2} \right)^2} {n}} = \sqrt {\frac {n \cdot \left( \frac {L_{max}} {2} \right)^2} {n}} = \frac {L_{max}} {2}&lt;/math&gt;

:''Der Mittelwert zuzüglich der Standardabweichung entspricht dann dem maximalen Luminanzwert:''

::&lt;math&gt;L_{Mittelwert} + L_{Standardabweichung} = \frac {L_{max}} {2} + \frac {L_{max}} {2} = L_{max}&lt;/math&gt;

:''Und der Mittelwert abzüglich der Standardabweichung hat dann den Wert Null:''

::&lt;math&gt;L_{Mittelwert} - L_{Standardabweichung} = \frac {L_{max}} {2} - \frac {L_{max}} {2} = 0&lt;/math&gt;

:''Der auf diesem Weg bestimmte Kontrast stimmt mit dem oben genannten Kontrast an der Kante überein:''

::&lt;math&gt;M = \frac {L_{max} - 0} {L_{max} + 0} = \frac {L_{max}} {L_{max}} = 1&lt;/math&gt;

Schließlich kann auch noch der Kontrast an der Außenkante der nur vom Erdschein beleuch­teten Mondscheibe bestimmt werden, also zwischen aschgrauem Mondlicht und Himmel:

:&lt;math&gt;M_{Schatten,Himmel} = \frac {L_{Schatten} - L_{Himmel}} {L_{Schatten} + L_{Himmel}} = \frac {24,5 - 15} {24,5 + 15} = \frac {9,5} {39,5} = 0,24&lt;/math&gt;

Dieser Kontrast ist also deutlich höher als der innerhalb des Mondschattenbereichs. Die Helligkeit wechselt an der Kante der Mondscheibe zudem schlagartig und ist deswegen besser wahrnehmbar als die Helligkeitsunterschiede innerhalb des Schattenbereiches, wie im Folgenden ausgeführt wird.

=== Wahrnehmungsphysiologie ===
[[Datei:CSF.against.angular.frequency.in.cycles.per.degree.png|mini|rechts|hochkant=2|Kontrastempfindlichkeitsfunktion (englisch: Contrast Sensitivity Function, CSF) des menschlichen Auges über der Ortsfrequenz &lt;math&gt;f_a&lt;/math&gt; in Linienpaaren pro Grad.]]

Strukturen, bei denen sich die Helligkeit innerhalb eines achtel Bogengrades (7,5&amp;nbsp;Bogen­minuten) ändert, werden von einem gesunden menschlichen Auge nahezu perfekt auf die Netzhaut übertragen und sind deshalb am besten wahrzunehmen. Weichere Strukturen mit sich langsamer und kontinuierlich ändernder Helligkeit oder kleinere Strukturen sind bei gleichem Objektkontrast schwieriger zu erkennen. Ob ein bestimmter Objektkontrast mit bloßem Auge wahrgenommen werden kann, kann mit Hilfe der Kontrastempfindlichkeits­funktion (Contrast Sensitivity Function (CSF)) des menschlichen Auges ermittelt werden, bei der die Kontrastübertragung von einem Objekt auf die Netzhaut des Auges über der Ortsfrequenz in Linienpaaren pro Bogengrad angegeben ist:

→ Siehe auch [[Digitale_bildgebende_Verfahren:_Grundlagen#Kontrastempfindlichkeitsfunktion|Wikibook '''Digitale bildgebende Verfahren''', Kapitel '''Grundlagen''', Abschnitt '''Kontrastempfindlichkeitsfunktion''']].

[[Datei:CSF.UHD.png|mini|rechts|hochkant=2|Zur Kontrastempfindlichkeitsfunktion des menschlichen Auges mit den Ortsfrequenzen von 2&amp;nbsp;sinusmodulierten Linienpaaren pro Bildbreite (linke Bildhälfte) bis hin zu 1024&amp;nbsp;Linienpaaren pro Bildbreite (rechts am Bildrand), Bildgröße 3860&amp;nbsp;mal 2160&amp;nbsp;Bildpunkte (16:9) mit maximalem Kontrast unten, ohne Kontrast oben.]]

Das nebenstehende Diagramm und die darunter befindliche unfarbige Graphik mit den sinusförmigen Helligkeitsmodulationen visualisieren dies. Von links nach rechts wächst die Ortsfrequenz ausgehend von zwei Linienpaaren pro Bildbreite immer weiter, und der Kontrast ändert sich in vertikaler Richtung kontinuierlich zwischen den Extremwerten 0&amp;nbsp;und&amp;nbsp;1. Bei großen und sehr kleinen Ortsfrequenzen sind geringe Kontraste nicht so gut zu erkennen wie im mittleren Bereich. Die maximale Empfindlichkeit wird bei acht Linienpaaren pro Bogengrad erreicht und hängt bei einem gegebenen Objekt demzufolge vom Betrachtungsabstand ab.

Das Auge kann nach dieser Kontrastempfindlichkeitsfunktion innerhalb eines Bogengrades maximal bis zu 80&amp;nbsp;Linien mit maximalem Objektkontrast (also 40&amp;nbsp;Linienpaare mit dem Kontrast&amp;nbsp;1) wahrnehmen. In diesem Fall liegt der wahrgenommene Kontrast zwischen den benachbarten Linien bei ungefähr 5&amp;nbsp;Prozent. Bei 120&amp;nbsp;Linien mit maximalem Objektkontrast (also 60&amp;nbsp;Linienpaare mit dem Kontrast&amp;nbsp;1) sinkt der wahrgenommene Kontrast auf unter ein Prozent und ist somit praktisch nicht mehr wahrnehmbar. Wegen des scheinbaren Winkeldurchmessers der Mondscheibe von 0,5&amp;nbsp;Bogengrad, kann das Auge innerhalb des Monddurchmessers also maximal 20&amp;nbsp;Linienpaare beziehungsweise 40&amp;nbsp;Linien unterscheiden. Insbesondere an der scharfen Kante der Mondscheibe ist eine ins Auge nahezu verlustfrei übertragene Ortfrequenz von acht Linienpaaren pro Bogengrad stark vertreten, so dass der in der obigen Aufnahme des Mondes vorhandene Objektkontrast von 24&amp;nbsp;Prozent zwischen Mondschatten und Himmel (siehe oben) gut wahrgenommen werden kann.

Etwas schwieriger gestaltet sich dies innerhalb des Schattenbereichs des Mondes. In der obigen Aufnah­me tauchen die stärksten Kontraste entlang einer Linie von oben nach unten auf, wo die helleren Mondebenen mit den Kratern Copernicus und Tycho durch die dunkleren Maria Imbrium und Nubium unterbrochen werden. Daraus resultiert eine Ortsfrequenz mit fünf Linienpaaren pro Bogengrad, wo die Kontrastempfindlichkeitsfunktion ebenfalls einen recht hohen Wert von 0,9&amp;nbsp;beziehungsweise 90&amp;nbsp;Prozent erreicht. Dies schwächt den auf der Mond­oberfläche vorhandenen Objektkontrast von 10&amp;nbsp;Prozent im vom Auge auf die Netzhaut übertragenen Bildkontrast nur geringfügig ab.

Aus diesen Überlegungen resultiert, dass die im aschgrauen Licht des Mondes wahrnehmba­ren Kontraste knapp 10 Prozent betragen. Diese sind zwar geringer als der Kontrast von 24&amp;nbsp;Prozent zwischen dem aschgrauen Mondlicht und dem den Mond umgebenden Himmel, sie liegen allerdings noch in einem wahrnehmbaren Bereich. Somit ist erwiesen, dass ein gesundes Auge unter idealen Beobachtungsbedingungen auch völlig ohne optische Hilfsmittel die Helligkeitsunterschiede und Strukturen im nur durch den Erdschein erhellten Schattenbereich des Mondes erkennen kann.

Es gibt jedoch zahlreiche Faktoren, die den wahrnehmbaren Kontrast deutlich herabsetzen oder die Möglichkeit der Wahrnehmung verhindern können. Je älter ein Mensch wird, desto mehr Streulicht wird durch kleinste Verletzungen beziehungsweise Narben in der Hornhaut oder in der Linse des Auges erzeugt. Dieses Streulicht erzeugt einen mehr oder weniger gleichmäßigen Lichtschleier, der auch die dunklen Stellen auf der Netzhaut beleuchtet. Dies führt in jedem Fall zu einer Herabsetzung des wahrnehmbaren Kontrastes und verhindert somit das Erkennen von schwachen Kontrasten.

=== Begrenzende Einflüsse ===
Aber auch in der Natur gibt es viele begrenzende Faktoren. Hierzu gehört das natürliche Streulicht durch die Sonne in der Troposphäre, wenn diese zu dicht am Mond oder zu dicht unter dem Horizont oder gar über dem Horizont steht. In bewohnten Gegenden kommt als großer Störfaktor noch die Lichtverschmutzung hinzu. Ferner wird der Objektkontrast durch atmosphärische Störungen vermindert. Diese ergeben sich zum einen durch Dunst, Nebel oder Staub in der Atmosphäre, und zum anderen aus den langen Wegstrecken, die das Licht bei einer Beobachtung eines Himmelsobjekts durch die Troposphäre zurücklegen muss, wenn dieses sehr dicht über dem Horizont steht. Hierbei wird das den Beobachter erreichende Licht nicht nur abgeschwächt ('''Extinktion'''), sondern auch durch das Licht aller möglichen anderen Lichtquellen angereichert, das an den Luftmolekülen gestreut oder durch Mikroturbulenzen abgelenkt wurde, so dass sich die minimal vorhandene Helligkeit vergrößert und der Kontrast somit verringert. In bewohnten Regionen ist zudem mit erheblicher Lichtverschmutzung durch künstliche Lichtquellen zu rechnen.

Auf der anderen Seite wird insbesondere in Horizontnähe der blaue Lichtanteil von astronomischen Objekten auf dem Lichtweg durch die Troposphäre durch die stark wellenlängenabhängige '''Rayleigh-Streuung''' seitlich abgelenkt, so dass es praktisch gar nicht mehr zum Beobachter gelangt. Dies führt zu den rötlichen Auf- und Untergängen von Sonne und Mond sowie zur Blaufärbung des Taghimmels.

Unter Umständen muss das Licht mehrere hundert Kilometer durch die Atmosphäre zurücklegen, wie in der folgenden Abbildung zu erkennen ist:

[[Datei:Troposphaerische.Laengen.png|mini|zentriert|hochkant=4|Weglängen für Lichtstrahlen in der 15&amp;nbsp;Kilometer hohen Troposphäre in Abhängigkeit von der Zenitdistanz.]]

=== Beobachtung ===
Die Beobachtungsmöglichkeiten des aschgrauen Lichts werden grundsätzlich durch die folgenden, sich teilweise widerstrebenden Bedingungen verbessert:

* Die '''Lichtverschmutzung''' in der Atmosphäre ist gering.
* Das '''Mondalter''' beträgt wenige Tage vor oder nach Neumond.
* Die '''Sonne''' steht möglichst weit unter dem Horizont.
* Der '''Mond''' hat eine möglichst große Höhe über dem Horizont.
* Die '''Mondsichel''' ist möglichst klein, um möglichst wenig Streulicht zu verursachen.

Für die Beobachtung aus nördlichen geographischen Breiten gilt insbesondere:

* Der Mond hat eine möglichst große '''nördliche ekliptikale Breite''' zwischen seinem aufsteigenden und seinem absteigenden Knoten.
* Die '''Ekliptik''' steht möglichst steil auf dem Horizont. Dies ist bei den Tag-und-Nacht-Gleichen der Fall, besonders gut
** abends im Frühjahr beim '''Neulicht''' des Mondes nach Sonnenuntergang im Westen.
** morgens im Herbst beim '''Altlicht''' des Mondes vor Sonnenaufgang im Osten.

=== Farbigkeit ===
[[Datei:Neulicht.21.3.2026.HDR.1024.png|mini|hochkant=2|Die Abbildung zeigt eine Hochkontrastaufnahme des Erdscheins im Mondschatten zum Frühlingbeginn drei Tage nach Neumond mit Sternen bis zur zehnten Größenklasse (10&lt;sup&gt;m&lt;/sup&gt;) in der Umgebung. Die Sichel zeigte einen Tag nach der Tag-und-Nacht-Gleiche im Frühjahr 2026 und zwei Tage vor der großen Mondwende bei einer nördlichen ekliptikalen Breite des Mondes von vier Bogengrad eine besonders starke Neigung. Die Sonne war zuvor im Westen untergegangen und stand bereits elf Bogengrad unter dem Horizont. Die Symmetrieachse der Mondsichel (-7&lt;sup&gt;m&lt;/sup&gt;) auf der zu 9,3&amp;nbsp;Prozent beleuchteten Mondscheibe zeigt nach rechts unten in Richtung der Sonne (Farbtemperatur = 4100 Kelvin, Belichtungsreihe mit sieben Bildern in ganzen Blendenstufen).]]

Bei genauer Betrachtung und Beobachtung ist das sogenannte aschgraue Licht gar nicht farbneutral, sondern spiegelt einen mittleren Farbton der von der Sonne beleuchteten Erdoberfläche wider, von der wiederum der Mondschatten beleuchtet wird. Je niedriger der Bewölkungsgrad, desto stärker ist zudem der Einfluss der farbigen Oberfläche der Erde. Die Farben der Erdoberfläche schwanken hierbei deutlich zwischen den Ozeanen, Wäldern oder Wüsten. In der nebenstehenden Hochkontrastaufnahme zeigt der Mondschatten im HSV-Farbraum einen mittleren Farbwert mit dem Farbwinkel 202°, was als Farbton blaucyan übersetzt werden kann. Dies entspricht recht gut dem mittleren Farbton der der Sonne zugewandten Seite der Erde (&quot;Blue Marble&quot;) während der Aufnahme, der für das hier gezeigte Beispielbild im HSV-Farbraum einen mittleren Farbwert mit dem Farbwinkel 201° hat. Der Farbwinkel ist von der Sättigung oder der Helligkeit nicht abhängig.

[[Datei:Neulicht.21.3.2026.HDR.Original.Durchschnitt.gesaettigt.aufgehellt.png|mini|links|hochkant=4|Sichtbarmachung des Farbwerts mit dem Farbwinkel 202° des aschgrauen Mondlichts in einer Hochkontrastaufnahme des Erdscheins im Mondschatten zum Frühlingbeginn drei Tage nach Neumond.&lt;br/&gt;Von links nach rechts:&lt;br/&gt;1. Originalaufnahme&lt;br/&gt;2. Mittelwert&lt;br/&gt;3. Farbe gesättigt&lt;br/&gt;4. aufgehellt]]
[[Datei:North America from low orbiting satellite Suomi NPP.Original.Durchschnitt.gesaettigt.abgedunkelt.png|mini|links|hochkant=4|Sichtbarmachung des Farbwerts mit dem Farbwinkel 201° der Erdoberfläche im Bereich von Nordamerika und dem südöstlichen Pazifik.&lt;br/&gt;Von links nach rechts:&lt;br/&gt;1. Originalaufnahme&lt;br/&gt;2. Mittelwert&lt;br/&gt;3. Farbe gesättigt&lt;br/&gt;4. abgedunkelt]]
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

==Einzelnachweise==
&lt;references&gt;&lt;/references&gt;

&lt;noinclude&gt;
[[Kategorie:Astronomische Kuriositäten]]
&lt;/noinclude&gt;</text>
      <sha1>mjvao3m19jagcfc2nsioy0auxlkjw0n</sha1>
    </revision>
    <revision>
      <id>1092186</id>
      <parentid>1092185</parentid>
      <timestamp>2026-10-17T11:30:23Z</timestamp>
      <contributor>
        <username>Bautsch</username>
        <id>35687</id>
      </contributor>
      <comment>/* Siderischer Monat */ Sonne, Mond, Jupiter / Manazil al-Qamar</comment>
      <origin>1092186</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="122068" sha1="9n6md8ass9me5gxv9skob8y6r3f73cs" xml:space="preserve">[[Datei:Mondfinsternis.7.9.2025.20.46MESZ.Berlin.png|mini|rechts|hochkant=2|Ein bei Vollmond während einer Mondfinsternis im Kernschatten der Erde befindlicher Blutmond nach Mondaufgang von Berlin aus gesehen am 7. September 2025.]]

== Monat ==
Die Bezeichnung '''Monat''' stammt etymologisch von unserem Erdmond ab. Es handelt sich um ein Erbwort, das auf die seit dem 8.&amp;nbsp;Jahrhundert bezeugten althochdeutschen Formen ''mānōd'' beziehungsweise ''mānōth'' zurückgeht. Diese wiederum stammen vom indoeuropäischen Wort ''mēnōt'' ab, das sowohl ''Monat'' als auch ''Mond'' bedeuten kann.&lt;ref&gt;[https://indogermanisch.org/pokorny-etymologisches-woerterbuch/m%C4%93n%C5%8Dt_gen_m%C4%93neses_woraus_m%C4%93nes-_m%C4%93ns-_m%C4%93s-_m%C4%93n.htm mēnōt], Pokorny - Indogermanisches etymologisches Wörterbuch&lt;/ref&gt;

== Die Naturgeschichte von Plinius dem Älteren ==
'''Gaius Plinius Secundus''' (&quot;der Ältere&quot;) hat im ersten nachchristlichen Jahrhundert über den '''Mond''' geschrieben. Das neunte Kapitel des zweiten Buches aus dem ersten Band hat den Titel ''Von der Natur des Mondes''. Über den Mond schreibt Plinius Folgendes:&lt;ref name=&quot;Denso1764&quot;&gt;Plinius: ''Naturgeschichte'', erster Band, zweites Buch, neuntes Kapitel: ''Von der Natur des Mondes'', übersetzt von Johann Daniel Denso (1708–1795), Rostock und Greifswald, Anton Ferdinand Rösens Buchhandlung, 1764, in moderne deutsche Sprache gesetzt.&lt;/ref&gt;

&lt;blockquote&gt;
Aber alle diese [Wandelgestirne] übertrifft an Bewunderungswürdigkeit das Gestirn des '''Mondes''', das niedrigste, der Erde bekannteste, und zur Verminderung der Finsternis erfunden. Dieser hat durch seinen Wandel und veränderte Gestalt, da er beständig zu- und abnimmt, den Witz seiner Beobachter gequält, die es sich für einen Schimpf hielten, wenn man das nächste Gestirn nicht kennen sollte. Ja er ist auch in Spitzen gekrümmt, bald gerade halbgeteilt, bald in eine ganze Scheibe gebogen, bald, da er einem dunkeln Flecken ähnlich war, scheint er plötzlich hervor, und ist ist er ohne Grenzen rund und voll, ist gar nicht zu sehen. Bald scheint er die ganze Nacht durch, bald geht er spåt auf, und verstärkt noch bei Tage den Schein der Sonne. Er wird verfinstert, und lässt sich auch in der Verfinsterung noch sehen. Beim Ausgang des Monats sieht man ihn nicht, und man glaubt nicht, dass er alsdenn verfinstert werde.&lt;br/&gt;
Bald steht er niedrig, bald erhaben, und auch dies nicht auf eine Art. Bald steht er in der Höhe des Himmels, bald reicht er an die Berge: jetzt steht er hoch gegen Norden, bald tief gegen Süden herunter. Alles dies hat '''Endymion''' unter allen Menschen an ihm zuerst wahrgenommen, und deswegen ist die Sage, dass dieser in ihm verliebt gewesen sei. Wir sind wahrlich gegen diejenigen, welche uns zuerst bei diesem Himmelslicht durch ihre Arbeit und Sorge ein Licht aufgesteckt haben, nicht dankbar. Es ist ein wunderbares Verderben des menschlichen Witzes, dass wir ein Vergnügen daran finden, Blutvergießen und Mord in unsern Jahrbüchern aufzuzeichnen, damit die, welche die Welt nicht kennen, doch von unsern Lastern wissen mochten.&lt;br/&gt;
Doch aber da der Mond der Weltachse am nächsten steht, und also den engsten Umlauf hat, so durchlauft er in 27 und 1/3 Tag eben den Raum, welchen der höchste Stern des Saturns, wie gesagt ist, in dreißig Jahren zurücklegt. Hiernächst hält er sich in der Zusammenkunft mit der Sonne zwei Tage, wenn es am langsamsten geschieht, aus, und geht mit dem dreißigsten Tag zu seinen vorigen Abwechselungen wieder hervor. Ich weiß nicht, ob er nicht unter allen am Himmel der einzige Lehrmeister gewesen sei, dass man das Jahr in einen Raum von zwölf Monaten einteilen müsse, denn ebenso oft folgt er der Sonne, wenn sie zu einem neuen Zeichen zurückkehrt.&lt;br/&gt;
Er wird, wie die übrigen Sterne vom Sonnenlicht verdeckt. Denn wir sehen, dass er von derselben sein Licht gänzlich entlehne, und damit dergestalt leuchte, als wenn wir ihr zurückprallendes Licht in einem Wasser schweben sehen. Da er die Feuchtigkeit mit sanfterer und unvollkommener Kraft auflöst, auch wohl vermehrt, welche die Strahlen der Sonne verzehren. Hierher kommt es auch, dass man ihn in ungleichem Licht sieht, dass er alsdenn nur voll ist, wenn er der Sonne gerade gegenübersteht, in den übrigen Tagen nur so viel desselben, als er von jener empfängt, auf seiner Scheibe zeigt. Wenn er mit der Sonne zusammenkommt, kann man ihn nicht sehen, weil er uns die dunkle Seite zukehrt, und alles Geschöpfte dorthin, woher er es empfangen hat, wieder zurückwirft.&lt;br/&gt;
Es scheint außer Zweifel gesetzt zu sein, dass die Gestirne ihre Nahrung von der Feuchtigkeit der Erde haben. Denn er wird auf der einen Hälfte seiner Scheibe oft voller Flecken gesehen, weil er etwa noch nicht Kraft genug hat, mehr als ihm dienlich ist, an sich zu ziehen. Seine Flecken sind gewiss nichts anderes, als die mit der Feuchtigkeit von der Erde mit fortgerissenen Unreinigkeiten.&lt;br/&gt;
&lt;/blockquote&gt;
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

== Mondperioden ==
Die zu beobachtende scheinbare Mondbahn kann im Verlauf verschiedener Perioden durch zahlreiche '''Mondzyklen''' beschrieben werden. Die kürzesten Zyklen dauern ungefähr einen Monat im Sonnenkalender, sie längeren Mondzyklen können aber auch mehrere Jahre umfassen.

Der Mond hat ähnlich wie die Sonne einen scheinbaren Winkeldurchmesser von ungefähr 30&amp;nbsp;Bogenminuten beziehungsweise 0,5&amp;nbsp;Bogengrad. Dies entspricht bei Betrachtung des eigenen Fingers mit ausgestrecktem Arm in etwa einem Viertel der Fingerdicke.

===Synodischer Monat===
[[Datei:Courtenay.Mondsichel.P1033938.png|mini|Altlicht beim Morgenletzt des Mondes (heliakischer Aufgang) über dem östlichen Horizont auf Vancouver Island kurz nach der Tag-und-Nachtgleiche im September 2019.]]
[[Datei:Neulicht.37Tauri.P1138734.jpg|mini|Neulicht beim Abenderst des Mondes (akronychischer Untergang) über dem westlichen Horizont in Berlin Anfang Mai 2022.]]

Der synodische Monat ist durch den Verlauf der Elongation des Mondes in Bezug zur Sonne beschrieben.

Der Mond umrundet die Erde ungefähr zwölfmal schneller als die Erde die Sonne und benötigt für einen Umlauf einen Monat. Die einfachste Wahrnehmung des Mondlaufs ergibt sich durch die Beobachtung der Mondphasen beziehungsweise der Elongationen des Mondes. Der '''synodische Monat''' (altgriechisch ''σύνοδος'' (''synodos'') = ''Zusammentreffen'') beschreibt die Dauer zwischen zwei gleichen Mondphasen, also von Neumond zu Neumond beziehungsweise von Vollmond zu Vollmond. Hier wird gemeinhin das Zusammentreffen von Neumond und Sonne am Himmel als Referenzzeitpunkt betrachtet. Ein synodischer Monat dauert etwa 29,53&amp;nbsp;Tage, und zwölf synodische Monate dauern demzufolge rund 354,37&amp;nbsp;Tage - das sind gut fünfeinhalb Tage weniger als 360. Dieser Zyklus ist dies Basis für die gängigen Mondkalender (Lunarkalender) mit der gegenüber dem am Sonnenjahr orientierten Solarkalender um zirka 11&amp;nbsp;Tagen kürzeren Jahreslänge. Bei Lunisolarkalendern wird durchschnittlich alle drei Jahre ein dreizehnter synodischer Monat eingeschaltet, damit der Frühlingspunkt der Sonne ungefähr in der gleichen Jahreszeit bleibt.

→ Zur Zahl Zwölf siehe auch [[Quadriviale Kuriositäten‎/ Zahlen#Zur Zwölf|Exkurs '''Zur Zwölf''']].

[[Datei:Horusauge.Faltung.png|mini|rechts|hochkant=2|Das altägyptische Horusauge als Folge von Rechtecken mit jeweils der Hälfte der Fläche des Vorgängers in einem Rechteck mit dem Flächeninhalt eins.]]
[[Datei:Dendera_Deckenrelief_03.JPG|mini|hochkant=2|Deckenrelief im altägyptischen Tempel von Dendera mit der Darstellung von 15&amp;nbsp;Mondphasen von links (Neumond) nach rechts (Vollmond) mit den Göttern Junit, Sopdet-Tjenenet, Hor-Behdeti, Hathor, Nephthys, Harsiese, Isis, Osiris, Nut, Geb, Tefnut, Schu, Atum und Month. Im Vollmond vor dem Gott des Mondes Thot ist das von ihm geheilte linke Auge („Mondauge“) des Lichtgottes Horus dargestellt.]]

Die Ägypter haben ihre Kalender nicht mit einer Siebentagewoche, sondern sowohl mit einer Fünftagewoche als auch mit einer Zehntagewoche geführt. Damit besteht ein synodischer Monat auf weniger als einen halben Tag genau aus sechs Fünftagewochen beziehungsweise aus drei Zehntagewochen. Es wird in der Literatur manchmal darauf hingewiesen, dass das Verhältnis der Länge eines synodischen Monats zu dreißig vollen Tagen

:&lt;math&gt;\frac {29,530589 \text{d}} {30 \text{d}} = 0,984353&lt;/math&gt;

fast identisch mit dem folgenden Verhältnis ist (siehe auch Horusauge und Heqat in der altägyptischen Geschichte&lt;ref&gt;Donald Frazer: ''Hieroglyphs and Arithmetic of the Ancient Egyptian Scribes'', Kapitel 2.6.5 ''Hekat Fractions and Ro'', Xlibris Corporation, 2012, ISBN 9781469136462&lt;/ref&gt;):

:&lt;math&gt;\frac {1} {2} + \frac {1} {4} + \frac {1} {8} + \frac {1} {16} + \frac {1} {32} + \frac {1} {64}&lt;/math&gt;

:&lt;math&gt;= \frac {32} {64} + \frac {16} {64} + \frac {8} {64} + \frac {4} {64} + \frac {2} {64} + \frac {1} {64}&lt;/math&gt;

:&lt;math&gt;= \frac {63} {64} = \frac {2^6 - 1} {2^6} = 1 - 2^{-6} = 0,984375&lt;/math&gt;

Die Abweichung der beiden Verhältnisse beträgt nur 0,022&amp;nbsp;Promille. Erst nach rund 44700&amp;nbsp;Monaten oder 3700&amp;nbsp;Jahren hat sich diese Abweichung auf einen Tag aufsummiert.

Die verschiedenen Mondphasen waren für die Menschen schon immer sichtbar und konnten im Laufe eines synodischen Monats verfolgt werden. Es wird davon ausgegangen, dass zum Beispiel auch auf der Himmelsscheibe von Nebra mindestens eine Mondsichel dargestellt ist, eventuell auch der Vollmond und nach dem österreichischen Ur- und Frühgeschichtler '''Paul Gleirscher''' zusätzlich das Altlicht des Mondes:&lt;ref&gt;Paul Gleirscher: [https://dialnet.unirioja.es/servlet/articulo?codigo=4142096 Zum Bildprogramm der Himmelsscheibe von Nebra: Schiff oder Sichel?], Germania: Anzeiger der Römisch-Germanischen Kommission des Deutschen Archäologischen Instituts, Band 85, Nummer 1, ISSN 0016-8874, Seiten 23 bis 33, 2007&lt;/ref&gt;

&lt;gallery caption=&quot;Verschiedene möglicherweise auf der Himmelsscheibe von Nebra dargestellte Mondphasen&quot; perrow=&quot;2&quot; widths=&quot;300&quot; heights=&quot;300&quot;&gt;
Vollmond.P1080516.jpg|Ein im Dezember um Mitternacht fast im Zenit stehender, sehr heller Vollmond.
Zunehmende.Mondsichel.png|Ein zunehmender Mond drei Tage nach Neumond beim akronychischen Untergang am westlichen Abendhimmel drei Wochen vor der Tag-und-Nacht-Gleiche im Herbst. Die rötliche Färbung entstand genauso wie bei der untergehenden Sonne durch die Rayleigh-Streuung in der Erdatmosphäre.
Altlicht.3.Nov.2021.P1116624.jpg|Das Altlicht eines abnehmenden Mondes (Morgenletzt, vier Prozent beleuchtet) beim heliakischen Aufgang am südöstlichen Morgenhimmel der nördlichen Hemisphäre während der bürgerlichen Dämmerung einen Monat nach der Tag-und-Nacht-Gleiche im Herbst mit Erdschein.
Nebra_Scheibe_Modell.jpg|Vollständig rekonstruiertes Modell der bronzenen und mit Gold tauschierten Himmelsscheibe von Nebra.
&lt;/gallery&gt;

===Siderischer Monat===
Der '''siderische Monat''' ist durch den Verlauf der ekliptikalen Länge des Mondes in Bezug zum Frühlingspunkt der Sonnenbahn einer astronomischen Epoche definiert und beschreibt die Zeitspanne, nach der der Mond bei seinem Umlauf um die Erde Richtung Osten erneut die ekliptikale Länge des Frühlingspunktes erreicht hat. Da sich er Frühlingspunkt gegenüber dem Fixsternhimmel entlang der Ekliptiklinie verschiebt, ist der siderische Monat vom '''tropischen Monat''' zu unterscheiden. Letzterer bezieht sich ebenfalls auf den Frühlingspunkt, allerdings den des aktuellen Datums und nicht den, der zu einem bereits vergangenen und unveränderlichen Referenzzeitpunkt des Datums einer bestimmten astronomischen Epoche gegolten hat. Zur Zeit wird hierfür meist die Julianische Standardepoche J2000.0 verwendet, die sich auf die Uhrzeit 11:58:55,8 UTC am 1. Januar 2000 bezieht. Bezogen auf diese Standardepoche dauert ein tropischer Monat 27,32158&amp;nbsp;Tage. Durch die langsame gegenläufige Wanderung des Frühlingspunkts Richtung Westen besteht ein kleiner Unterschied zwischen tropischem und siderischem Monat, der mit 27,32166&amp;nbsp;Tage geringfügig länger ist. Die Differenz von 0,00008&amp;nbsp;Tagen entspricht einer Abweichung von von lediglich sieben Sekunden pro Monat: Dies bedeutet, dass der Mond den Frühlingspunkt des aktuellen Datums nach einer Umrundung (griechisch ''tropos'' = ''Drehung'') der Erde sieben Sekunden früher erreicht als einen Stern (lateinisch ''sideris'' = ''des Sterns'') der sich am Anfang der Umrundung noch beim Frühlingspunkt des einen Monat alten Datums befunden hat.

Es kann auch die Zeitspanne betrachtet werden, in der der Mond in Bezug auf den Fixsternhimmel entlang der Ekliptik wieder an einer beliebigen gleichen Stelle erscheint. Dies ist also beispielsweise auch die Dauer zwischen zwei aufeinanderfolgenden Erscheinungen des Mondes im '''Goldenen Tor der Ekliptik''', da dessen Lage durch die Sterne des Fixsternhimmels bei einer bestimmten ekliptikalen Länge bestimmt ist.

→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der_Ekliptik|Exkurs '''Das Goldene Tor der Ekliptik''']].

Die Einteilung der 360 Bogengrad langen Ekliptik in 28 gleiche Teile ist in der Bronzezeit verbreitet gewesen. Daraus ergibt sich ein grobes Koordinatenraster für die ekliptikale Länge des Mondes mit 28 Mondhäusern respektive Mondstationen.

Auf der '''Stachelscheibe von Platt''' aus der Bronzezeit (um 1500 vor Christus) werden die 28&amp;nbsp;Mondorte der Tage eines Monats beispielsweise durch eine Kreisreihe dargestellt. Die entsprechende Hohlform hat insgesamt sieben konzentrische Kreise und diente zum Gießen von Schmuckscheiben. Zwei der Kreise bestehen zwei aus 12&amp;nbsp;(innen) beziehungsweise aus 28&amp;nbsp;(außen) gleichmäßig verteilten Mulden.&lt;ref&gt;Irene Hager und Stefan Borovits (Wien, Österreich): ''Der Vorläufer einer Oktaëteris auf dem Kalenderstein bei Leodagger/Pulkau?'', Kapitel 26.2.2 ''Astronomisch/kalendarische &quot;Zählmaschinen&quot; aus der Bronzezeit'', in: Gudrun Wolfschmidt (Herausgeberin): ''Orientierung, Navigation und Zeitbestimmung - Wie der Himmel den Lebensraum des Menschen prägt'', Proceedings der Tagung der Gesellschaft für Archäoastronomie in Hamburg 2017, Band 42 von Nuncius Hamburgensis - Beiträge zur Geschichte der Naturwissenschaften, Verlag tredition, 2019, ISBN 9783749767717&lt;/ref&gt; Die zwölf inneren Mulden entsprechen entlang der Ekliptik den 12&amp;nbsp;Sonnenorten (Monaten) in einem tropischen Jahr beziehungsweise den 12&amp;nbsp;Jupiterorten (Jahren) in zwölf Jahren. Die 28&amp;nbsp;äußeren Mulden entsprechen entlang der Ekliptik den 28&amp;nbsp;Mondorten und somit den Tagen in einem siderischen Monat. Der große kreisförmige Stachel im Zentrum der Scheibe könnte als Symbol für die Sonne stehen. Auf ihm konnte die Scheibe von unten zentrisch und drehbar gelagert werden. Mit der Scheibe konnte (abgesehen vom ungefähr alle drei Jahre zusätzlich erforderlichen 14.&amp;nbsp;siderische Schaltmonat) zwölf Jahre lang in täglich wechselnden Kombinationen in den beiden Lochreihen die Lagen von Mond und Jupiter eingestellt und abgelesen werden. Damit konnte nach einer Einmessung der Ost-West-Richtung zum Beispiel bei der Tag-und-Nacht-Gleiche zur Jupiterrichtung im Frühlingspunkt der gesamte Lebewesenkreis (Zodiak) jederzeit mit dem täglich ein Mondhaus weiterwandernden Mond vollständig bestimmt werden, auch ohne dass der Jupiter immer sichtbar sein musste. Mit dieser Information ist es dann ohne weiteres möglich, mit Hilfe des Monds oder des Jupiters die aktuelle Richtung der Sonne oder mit Hilfe der Sonne, des Monds oder des Jupiters die aktuellen Richtungen aller Lebewesenkreiszeichen zu bestimmen, auch wenn diese am Himmel gar nicht sichtbar sind, weil sie unter dem Horizont stehen oder vom Sonnenlicht überstrahlt werden.

Im der indischen Astronomie wurde zu diesem Zweck spätestens 500&amp;nbsp;Jahre danach die Aufteilung in nur '''27&amp;nbsp;Mondhäuser''' (oder Mondstationen) eingeführt. Da sich die siderische und die synodische Periode um gut zwei Tage unterscheiden, liegen aufeinanderfolgende Neumonde oder Vollmonde stets in verschiedenen Mondhäusern, nach denen im hinduistischen Lunisolarkalender somit die entsprechenden Monate benannt werden können.

Das System mit 28&amp;nbsp;Mondhäusern wurde etwas später auch von den Altarabern mit '''28&amp;nbsp;Mondhäusern''' eingesetzt (&quot;Manazil al-Qamar&quot;). Das '''erste Mondhaus''' liegt bei beiden Einteilungen im Frühlingspunkt in der Epoche um Christi Geburt im '''Kopf des Lammes''' beziehungsweise des Widders (Aries) bei den nördlich der Ekliptik liegenden Sternen Scheratan und Hamal (indisch ''Ashvini'' = ''die beiden Rosseschirrenden'' und arabisch ''aš-šaraṭān'' = ''Die beiden Zeichen''). Für das '''zweite Mondhaus''' folgt der '''Bauch des Lammes''' (indisch ''Bharani'' = ''der Wegtragende'' und arabisch ''al-buṭayn'' = ''das Bäuchlein''). Die Plejaden (indisch ''Krittika'' und arabisch ''aṯ-ṯurayyā'') im fetten '''Schwanz des Lammes''' markieren im Anschluss das '''dritte Mondhaus'''. Das '''vierte Mondhaus''' ist durch den roten Riesenstern Aldebaran (arabisch ''al-dabarān'' = ''der Nachfolgende'', indisch ''Rohini'' = ''der Rötliche'') im Sternbild Stier (Taurus) gekennzeichnet.

&lt;gallery caption=&quot;Mondstationen&quot; mode=&quot;packed&quot; widths=&quot;600&quot; heights=&quot;600&quot;&gt;
Mondhaeuser.Ekliptik.zirkular.png|Die in eine ringförmige Darstellung projizierten 28&amp;nbsp;Mondhäuser (von 1 bis 28 entgegen dem Uhrzeigersinn) mit den wichtigsten Sternen entlang der Ekliptik (rote gestrichelte Linie '''zur Epoche J0000.0'''). Der Beobachter befindet sich auf der Erde im Zentrum der Darstellung. Nach innen werden die südlichen und nach außen die nördlichen ekliptikalen Breiten gemessen. Die scheinbare Mondbahn pendelt zwischen den beiden zur Ekliptikline benachbarten Hilfslinien. Der Abstand der Hilfslinien beträgt senkrecht zur Ekliptiklinie immer fünf Bogengrad und entlang der Ekliptiklinie immer knapp dreizehn Bogengrad. Mit bis zum Nordpol zunehmender geographischer Breite des Beobachtungspunktes können auch noch knapp ein Bogengrad südlichere ekliptikale Breiten von der Mondscheibe erreicht werden, am Südpol auch noch entsprechend nördlichere ekliptikale Breiten.
Stachelscheibe_Model_zweiseitig.jpg|Die in Niederösterreich gefundene und aus Sandstein gefertigte Gussform für die '''Stachelscheibe von Platt'''.&lt;br/&gt;Von innen nach außen gibt es '''sieben''' konzentrische Kreise, die folgendermaßen zugeordnet werden können:&lt;br/&gt;- Eine große zentrische Bohrung (im Gussteil eine große stachelartige Erhebung für die '''Sonne''').&lt;br/&gt;- Zwölf gleichmäßig verteilte kleine Bohrungen (Zodiak mit '''zwölf''' Sternzeichen sowie für die Umlaufzeit des Planeten '''Jupiter '''in Jahren).&lt;br/&gt;- Drei äquidistante Kreislinien (die drei inneren Planeten '''Merkur''', '''Venus''' und '''Mars''').&lt;br/&gt;- Achtundzwanzig gleichmäßig verteilte kleine Bohrungen ('''Mond'''häuser).&lt;br/&gt;- Ein großer abschließender Kreis ('''Saturn''' als der Langsame und Beständige).
Stonehenge_phase_one.jpg|Die älteste belegte kreisförmige Struktur in Stonehenge&amp;nbsp;1 (zirka 3100 bis 2900 vor Christi) besteht aus den 56&amp;nbsp;Aubrey-Löchern (in der Abbildung weiße Kreise). Diese können unter Verwendung von Quadranten, die geographisch durch die vier Himmelsrichtungen in jeweils 14 Mondstationen geteilt sind, dazu verwendet worden sein, die ekliptikale Länge des Mondes in Bezug zum Frühlingspunkt oder zum Herbstpunkt beziehungsweise in Bezug zur Jupiterposition täglich zu markieren (der Mond erreicht den Jupiter ungefähr alle 27,5 Tage). In dieser Zählung wären alle 28 Mondhäuser halbiert, in eine Tagesstation und eine Nachtstation.
&lt;/gallery&gt;

Zwischen dem dritten und vierten Mondhaus liegt das Goldene Tor der Ekliptik, wo der Frühlingspunkt zu Beginn der maltesischen Tarxien-Phase lag. Man beachte die fehlenden helleren ekliptiknahen Sterne im '''Trichter der Thuraya''' westlich davon, also rechts der Plejaden (ekliptikale Länge ungefähr 32&amp;nbsp;Bogengrad) bis hin zum Stern Hydor heutigen Sternbild Wassermann (Aquarius, ekliptikale Länge ungefähr 314&amp;nbsp;Bogengrad). Die hellsten ekliptiknahen Sterne in diesem Gebiet des Sternenhimmels Alpherg im Sternbild Fische (Pisces) sowie Hydor und Ancha im Sternbild Wassermann (Aquarius) erreichen lediglich die vierte Größenklasse (4&lt;sup&gt;m&lt;/sup&gt;), so dass zwischen dem auffälligen offenen Sternhaufen der Plejaden und Deneb Algedi, dem hellsten Stern im Sternbild Steinbock (Capricornus), auf einer Länge von 90&amp;nbsp;Bogengrad keine hellen ekliptiknahen Sterne vorhanden sind.

→ Zur Einteilung der Ekliptik nach den monatlichen Mondstationen siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Mondhäuser|Exkurs '''Mondhäuser''']]

→ Zum dunklen Himmelsquadranten entlang der Ekliptik siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Trichter_der_Thuraya|Exkurs '''Der Trichter der Thuraya''']]

===Drakonitischer Monat===
[[Datei:Drakonitischer.Monat.png|rechts|mini|hochkant=2|Schematische Darstellung der Mondbahn (gelb) im Laufe eines drakonitischen Monats in Bezug auf die Ekliptiklinie (rot). Nach dem Erreichen der südlichsten Lage in Bezug zur Ekliptiklinie wird die Mondbahn aufsteigend, und von der nördlichsten Lage in Bezug auf die Ekliptiklinie wird die Mondbahn dann wieder absteigend. In der deutschsprachigen Schweiz gibt es für diese im Laufe eines drakonitischen Monats täglich mehr oder weniger deutlich wahrnehmbaren Änderungen der ekliptikalen Breite sogar eigene Adjektive. Das Ansteigen der ekliptikalen Breite des Mondes nach Norden wird '''obsigend''' und das Abfallen des Mondes nach Süden '''nidsigend''' genannt. Direkt auf der Ekliptik befinden sich der aufsteigende und der absteigende Knoten der Mondbahn.]]

Der drakonitische Monat ist durch den Verlauf der ekliptikalen Breite des Mondes in Bezug zur Ekliptiklinie beschrieben.

Deswegen gibt es noch den '''drakonitischen Monat''' (altgriechisch ''δράκων'' (''drakon'') beziehungsweise lateinisch ''draco'' = ''Drache''), der eine Dauer von 27,212 Tagen hat. Diese Dauer beschreibt die Zeitpunkte, an denen die um gut 5&amp;nbsp;Bogengrad zur Ekliptik geneigte Mondbahn die Ekliptik kreuzt; die ekliptikale Breite des Mondes ist dann exakt null. Diese Schnittpunkte werden Mondknoten genannt und werden einmal im Monat im aufsteigenden Mondknoten und einmal im absteigenden Mondknoten erreicht. Befindet sich der Mond auf der Ekliptik, also in der Nähe dieser Mondknoten, kommt es bei dessen Sonnennähe (wenn der Neumond also in Konjunktion mit der Sonne steht) zu einer Sonnenfinsternis und bei dessen Sonnenferne (wenn der Vollmond also in Opposition zur Sonne steht) zu einer Mondfinsternis. Diese Mondpunkte wurden früher als Drachenpunkte bezeichnet, was sich aus der Vorstellung ableitete, dass ein Drache bei einer Mondfinsternis den Mond beziehungsweise bei einer Sonnenfinsternis die Sonne verschlingen würde.

Mit dem folgenden Java-Programm können die ekliptikalen Koordinaten der Sonne und des Mondes für jeden beliebigen Zeitpunkt eines Julianischen Datums in Julianischen Jahrhunderten in Bezug auf die astronomische Standardepoche J2000 berechnet werden:

'''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/ EkliptikaleKoordinatenMondSonne|→ Java-Programm &quot;EkliptikaleKoordinatenMondSonne&quot;]]'''&lt;ref&gt;Unter Verwendung der Formeln aus: Oliver Montenbruck, Thomas Pfleger: ''Astronomie mit dem Personal Computer'', Springer-Verlag Berlin Heidelberg GmbH, 1989, ISBN 978-3-662-05865-7&lt;/ref&gt;

[[Datei:Ekliptikale.Breiten.Mond.siderischer.Monat.png|links|mini|hochkant=4|Die ekliptikalen Breiten des Mondes im Verlauf eines drakonitischen Monats beziehungsweise eines nur gut zweieinhalb Stunden längeren siderischen Monats mit gut 27 Tagen.]]

{| class=&quot;wikitable&quot;
|+ Die täglichen Änderungen der ekliptikalen Breite des Mondes in Bogengrad innerhalb eines Mondviertels
!title=&quot;Tage nach aufsteigendem Knoten&quot;| Tage nach&lt;br/&gt;aufsteigendem&lt;br/&gt;Knoten
!title=&quot;Änderung der ekliptikalen Breite&quot;| Änderung der&lt;br/&gt;ekliptikalen Breite&lt;br/&gt;zum Vortag
|-
| 1 || 1,2°
|-
| 2 || 1,1°
|-
| 3 || 1,0°
|-
| 4 || 0,9°
|-
| 5 || 0,6°
|-
| 6 || 0,3°
|-
| 7 || 0,0°
|}
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

Der Mond kann auf seiner Bahn im Laufe der Zeiten alle ekliptiknahen Himmelsobjekte inklusive aller Planeten und der Sonne bedecken und innerhalb einer Stunde wieder freigeben, die sich in einem Band bis zu gut ±5&amp;nbsp;Bogengrad nördlich oder südlich neben der Ekliptiklinie befinden.

'''{{w|Aristoteles}}''' (384 bis 322) hat dies in seiner Schrift '''&quot;Über den Himmel&quot;''' (altgriechisch: ''Περὶ οὐρανοῦ'' / ''Peri uranu'') anhand der von ihm beobachteten '''Bedeckung des Planeten Mars durch den zunehmenden Halbmond in der Nähe des Sterns Regulus''' (α Leonis) beschrieben und darauf hingewiesen, dass die Babylonier und die Ägypter solche Phänomene über lange Zeit beobachtet und dokumentiert hatten.&lt;ref&gt;Aristoteles: [http://classics.mit.edu/Aristotle/heavens.2.ii.html On the Heavens], Teil 12, Buch II, um 350 vor Christus, ins Englische übersetzt von John Leofric Stocks (*&amp;nbsp;1882; †&amp;nbsp;1937)&lt;/ref&gt;

→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Aristotelische Mars-Konjunktion|Abschnitt '''Aristotelische Mars-Konjunktion''']].

Der ekliptiknahe Hauptstern Pollux im Sternbild Zwillinge (Gemini) hat sich aufgrund seiner Eigenbewegung im Laufe der letzten zehntausend Jahre so weit von der Ekliptiklinie entfernt, dass er inzwischen nicht mehr vom Mond bedeckt werden kann.

→ Für helle ekliptiknahe Objekte siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Der_Fixsternhimmel#Die_sieben_hellsten_Objekte_der_Ekliptik|Abschnitt '''Die sieben hellsten Objekte der Ekliptik''']].

===Siderische Mondperioden===
Der Mond erscheint innerhalb eines tropischen Jahres dreizehn- oder vierzehnmal an einer bestimmten Stelle des Fixsternhimmels, wobei er wegen der unterschiedlichen Periodendauern von siderischen und synodischen Monaten immer ein anderes '''Mondalter''' (die Anzahl der Tage seit dem letzten Neumond) und wegen der unterschiedlichen Periodendauern von siderischen und drakonitischen Monaten immer eine andere ekliptikale Breite aufweist.

Die beiden folgenden Diagramme sollen den zeitlichen Verlauf der Mondphasen und der ekliptikalen Breiten des Mondes bei seinem Erscheinen im Goldenen Tor der Ekliptik während 254 aufeinanderfolgender siderischer Perioden mit jeweils 27,322&amp;nbsp;Tagen (insgesamt 6940&amp;nbsp;Tage beziehungsweise 19&amp;nbsp;Jahre) veranschaulichen:

[[Datei:Mondphasen.siderische.Perioden.png|links|mini|hochkant=4|Die Mondphasen bei aufeinanderfolgenden Erscheinungen des Mondes im Goldenen Tor der Ekliptik innerhalb von 254 siderischen Perioden (insgesamt 19&amp;nbsp;Jahre). Da der synodische Monat (von Neumond zu Neumond) über zwei Tage länger ist als der siderische Monat, kommt es hierbei zu Verschiebungen, weil der Mond nach Ablauf eines siderischen Monats beim Erreichen derselben ekliptikalen Länge noch nicht ganz wieder sein maximales Mondalter erreicht hat.&lt;br/&gt;&lt;br/&gt;In der oberen Hälfte des Diagramms sind zunehmende und in der unteren Hälfte abnehmende Monde zu beobachten. Eine Mondphase von 0 Prozent steht für einen Neumond und eine Mondphase von ±100 Prozent für einen Vollmond.&lt;br/&gt;&lt;br/&gt;Der Startpunkt (Tag&amp;nbsp;0 im Monat&amp;nbsp;0) kann zum Beispiel mit dem 22.&amp;nbsp;Mai 2020 am Abend (UTC) angesetzt werden, an dem der Neumond zusammen mit der Sonne im Goldenen Tor der Ekliptik stand. Dies geschieht dann nach 19 Jahren am 23.&amp;nbsp;Mai 2039 kurz nach Mitternacht (UTC) erneut.]]

[[Datei:Ekliptikale.Breiten.Mond.siderische.Perioden.png|links|mini|hochkant=4|Die ekliptikalen Breiten des Mondes bei aufeinanderfolgenden Erscheinungen des Mondes im Goldenen Tor der Ekliptik innerhalb von 254 aufeinanderfolgenden siderischen Perioden (insgesamt 19&amp;nbsp;Jahre). Da der drakonitische Monat (von einem aufsteigendem Mondknoten bis zum nächsten aufsteigenden Mondknoten) gut zweieinhalb Stunden kürzer ist als der siderische Monat, kommt es hierbei zu Verschiebungen, weil der Mond nach Ablauf eines siderischen Monats den aufsteigenden Knoten bereits wieder hinter sich gelassen hat.&lt;br/&gt;&lt;br/&gt;Bei großen ekliptikalen Breiten (oben) kommt es im Goldenen Tor der Ekliptik zu Bedeckungen der Plejaden und bei kleinen ekliptikalen Breiten (unten) kommt es zu Bedeckungen der Hyaden oder des Sterns Aldebaran durch die Mondscheibe.&lt;br/&gt;&lt;br/&gt;Der Startpunkt (Tag&amp;nbsp;0 im Monat&amp;nbsp;0) kann beispielsweise ebenfalls mit dem 22.&amp;nbsp;Mai 2020 angesetzt werden, an dem der Neumond vom Erdmittelpunkt aus gesehen bei einer ekliptikalen Breite von zirka -2,5&amp;nbsp;Bogengrad unterhalb der Sonne, deren ekliptikale Breite definitionsgemäß 0&amp;nbsp;Bogengrad beträgt, im Goldenen Tor der Ekliptik stand.&lt;br/&gt;&lt;br/&gt;Nach 18,61&amp;nbsp;Jahren (beziehungsweise 6793,5&amp;nbsp;Tagen oder gut 230&amp;nbsp;synodischen Monaten, in dieser Abbildung also nach gut 248,6&amp;nbsp;siderischen Monaten) erreicht der Mond dieselbe ekliptikale Breite und fast die gleiche Mondphase, befindet sich dann allerdings bei einer anderen ekliptikalen Länge.&lt;br/&gt;&lt;br/&gt;Die kurzperiodische kleine Wellenbewegung kommt durch die Nutation der Erdachse im Bezug zur Ekliptik beziehungsweise zum Fixsternhimmel zustande; sie hat eine Periodendauer von 35&amp;nbsp;Tagen und überlagert sich mit den zirka eine Woche kürzeren siderischen Mondperiode.]]
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

===Der Meton-Zyklus===
Nicht nur die Bestimmung und Vorhersage der Auf- und Untergänge der Venus haben die Aufmerksamkeit der Astronomen des Altertums auf sich gezogen, sondern auch der Mondzyklus mit den verschiedenen Mondphasen sowie das Auftreten von Mondfinsternissen bei Vollmond und von Sonnenfinsternissen bei Neumond. Es gibt einen Zyklus, der die Zeit beschreibt, nachdem die Sonne und der Mond die gleiche Konstellation erreichen. Nach '''19&amp;nbsp;Jahren''' (beziehungsweise knapp '''6940&amp;nbsp;Tagen''') hat nicht nur die Sonne dieselbe ekliptikale Länge erreicht, sondern auch der der Mond (nach '''254&amp;nbsp;siderischen Monaten'''), und er hat daher auch dieselbe Mondphase (nach '''235&amp;nbsp;synodischen Monaten'''). Außerdem hat er dann auch noch annährend die gleiche ekliptikale Breite (nach '''255&amp;nbsp;drakonitischen Monaten'''), so dass er fast wieder an derselben Stelle des Fixsternhimmels steht.&lt;ref name=&quot;rutherforth&quot;&gt;Thomas Rutherforth: &quot;A System Of Natural Philosophy: Being A Course of Lectures In Mechanics, Optics, Hydrostatics, and Astronomy; Which are Read in St Johns College Cambridge&quot;, volume 2, chapter XIV: &quot;Of the devision&lt;!--sic!--&gt; of time&quot;, paragraph 388: &quot;The cycle of Metos&quot;, 990 ff.&lt;/ref&gt;

Der Zyklus beruht also im Wesentlichen auf der zwar nur langfristig, bei entsprechender Ausdauer jedoch einfach zu beobachtenden Tatsache, dass 19&amp;nbsp;tropische Sonnenjahre, 235&amp;nbsp;synodische Monate, 254&amp;nbsp;siderische Monate und 255&amp;nbsp;drakonitische Monate fast die gleiche Länge haben. Der Unterschied zwischen den ersten beiden beträgt nur rund zwei Stunden:

* 19&amp;nbsp;Jahre = 6939,6&amp;nbsp;Tage, bestimmt durch die ekliptikale Länge der Sonne mit ihren Äquinoktien und Sonnenwenden.
* 235&amp;nbsp;synodische Monate = 6939,7&amp;nbsp;Tage, bestimmt durch die Mondphasen mit Neumonden und Vollmonden.
* 254&amp;nbsp;siderische Monate = 6939,7&amp;nbsp;Tage, bestimmt durch die ekliptikale Länge des Mondes.
* 255&amp;nbsp;drakonitische Monate = 6939,1&amp;nbsp;Tage, bestimmt durch die auf- und absteigenden Knoten der Mondbahn.

[[Datei:Legende.Meton-Zyklus.png|mini|rechts|Legende zum Diagramm &quot;Meton-Zyklus&quot;.]]

&lt;gallery caption=&quot;Der Meton-Zyklus&quot; mode=&quot;packed&quot;&gt;
Meton-Zyklus.Maerz.2019.png|Der Meton-Zyklus anhand der Frühlingsvollmonde (weiße Kreise) am 21. März 2019 (laufende Nummer 0) und am 21. März 2038 (laufende Nummer 235).
Meton-Zyklus.Januar.2023.Januar.2042.png|Der Meton-Zyklus vom Vollmond am 6. Januar 2023 bis zum Vollmond am 6. Januar 2042. Die farbigen Kreise symbolisieren die Äquinoktien und Sonnenwenden.
&lt;/gallery&gt;

[[Datei:Meton-Zyklus.2023.13996.png|mini|links|hochkant=4|Der 19-jährige Meton-Zyklus vom Januar&amp;nbsp;2023 bis zum Januar&amp;nbsp;2042. Die Zeit schreitet in horizontaler Richtung jeweils um einen halben Tag pro Bildpunkt voran. Der Vollmond (weißer Kreis) erscheint sowohl am 6.&amp;nbsp;Januar 2023 als auch am 6.&amp;nbsp;Januar 2042 im Sternbild Zwillinge (Gemini) nördlich vom Stern Mebsuta (ε&amp;nbsp;Geminorum). Unten sind die kleinen und großen Mondwenden für die geographische Breite 52,5 Bogengrad (zum Beispiel in Berlin) im Laufe der Zeit dargestellt.]]
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

Dieser 19-jährige nach dem antiken griechischen Astronomen {{w|Meton}} (5.&amp;nbsp;Jahrhundert vor Christus) benannte '''Meton-Zyklus''' sowie auch der unten erwähnte Saros-Zyklus waren im Altertum spätestens schon den Babyloniern bekannt und dienten als Grundlage für ihren Mondkalender. Meton ist davon ausgegangen, dass 19&amp;nbsp;Jahre exakt mit 6940&amp;nbsp;Tagen sowie mit 235 synodischen Monaten übereinstimmen. Dadurch, dass das Jahr nach dieser Annahme genau fünf Neunzehntel Tage länger ist als 365 Tage, sind neunzehn Jahre nach dieser Berechnung genau fünf Tage länger ist als neunzehn Mal 365 Tage, also 6935 Tage. Aus der Annahme einer festen ganzrationalen Kopplung der Umlaufzeiten der Erde um Ihre Achse (Tag) und um die Sonne (Jahr) sowie der Umlaufzeit des Mondes um die Erde (Monat) ergeben sich die folgenden Zusammenhänge:

* Abgerundet auf ganze Zahlen:
** '''Die Jahreslänge in ganzen Tagen:'''
**:&lt;math&gt;\frac {6940} {19} = 365 \text { Rest } 5&lt;/math&gt;, das heißt, dass für 19&amp;nbsp;Jahre mit der Länge 365 Tage '''fünf Schalttage''' (Jahreslänge dann 366&amp;nbsp;Tage) erforderlich sind, damit der Frühlingspunkt mit dem tropischen Sonnenjahr synchron bleibt (Solarkalender).
** '''Die Monatslänge in ganzen Tagen:'''
**:&lt;math&gt;\frac {6940} {235} = 29 \text { Rest } 125&lt;/math&gt;, das heißt, dass für 235&amp;nbsp;synodische Monate mit der Länge 29&amp;nbsp;Tage '''125&amp;nbsp;Schalttage''' (Monatslänge dann 30&amp;nbsp;Tage) erforderlich sind, damit ein tropisches Sonnenjahr immer zwölf Monate umfasst (Solarkalender).
** '''Die Jahreslänge in ganzen Monaten:'''
**:&lt;math&gt;\frac {\frac {6940} {19}} {\frac {6940} {235}} = \frac {235} {19} = 12 \text { Rest } 7&lt;/math&gt;, das heißt, dass in 19&amp;nbsp;Jahren mit 235&amp;nbsp;synodischen Monaten sowie 6490&amp;nbsp;Tagen '''sieben synodische Schaltmonate''' (Jahreslänge dann 13&amp;nbsp;Monate) erforderlich sind, um das Kalenderjahr mit dem tropischen Sonnenjahr synchron zu halten (Lunisolarkalender).

* Exakt mit Brüchen (ganzrationale Zahlen):
** Die Jahreslänge &lt;math&gt;d_a&lt;/math&gt; in Tagen (in einem Sonnenjahr):
**:&lt;math&gt;d_a = \frac {6940 \text { d}} {19 \text { a}} = 365 \frac {\text {d}} {\text {a}} + \frac {5} {19} \frac {\text {d}} {\text {a}} = 365 \frac {\text {d}} {\text {a}} + \frac {20} {76} \frac {\text {d}} {\text {a}} = 365 \frac {\text {d}} {\text {a}} + \frac {1} {4} \frac {\text {d}} {\text {a}} + \frac {1} {76} \frac {\text {d}} {\text {a}} = 365,25 \frac {\text {d}} {\text {a}} + \frac {1} {76} \frac {\text {d}} {\text {a}} \approx 365,263158 \frac {\text {d}} {\text {a}}&lt;/math&gt;
** Die Länge eines synodischen Monats &lt;math&gt;d_m&lt;/math&gt; in Tagen:
**:&lt;math&gt;d_m = \frac {6940 \text { d}} {235 \text { m}} = \frac {1388} {47} \frac {\text {d}} {\text {m}} = 29 \frac {\text {d}} {\text {m}} + \frac {125} {235} \frac {\text {h}} {\text {m}} = 29 \frac {\text {d}} {\text {m}} + \frac {25} {47} \frac {\text {h}} {\text {m}} \approx 29,531915 \frac {\text {d}} {\text {m}}&lt;/math&gt;
** Länge von zwölf synodischen Monaten &lt;math&gt;d_{m_{12}}&lt;/math&gt; in Tagen (in einem Mondjahr):
**:&lt;math&gt;d_{m_{12}} = 12 \frac {\text {m}} {\text {a}} \cdot d_m = 12 \frac {\text {m}} {\text {a}} \cdot \frac {1388} {47} \frac {\text {d}} {\text {m}} = \frac {16656} {47} \frac {\text {d}} {\text {a}} \approx 354,382979 \frac {\text {d}} {\text {a}} \approx d_a - 11 \frac {\text {d}} {\text {a}}&lt;/math&gt;
** Die Jahreslänge &lt;math&gt;m_a&lt;/math&gt; in synodischen Monaten (in einem Sonnenjahr):
**:&lt;math&gt;m_a = \frac {d_a} {d_m} = \frac {\frac {6940 \text { d}} {19 \text { a}}} {\frac {6940 \text { d}} {235 \text { m}}} = \frac {235} {19} \frac {\text {m}} {\text {a}} = 12 \frac {\text {m}} {\text {a}} + \frac {7} {19} \frac {\text {m}} {\text {a}} \approx 12,368421 \frac {\text {m}} {\text {a}}&lt;/math&gt;

:'''Anmerkung''': Man nehme zur Kenntnis, dass das der Mittelwert der Dauern vom Sonnenjahr &lt;math&gt;d_a&lt;/math&gt; und vom Mondjahr &lt;math&gt;d_{m_{12}}&lt;/math&gt; fast genau 360&amp;nbsp;Tage pro Jahr beträgt, also so viele Tage wie für einen vollständigen Kreis in Bogengrad gerechnet wird:
::&lt;math&gt;\frac {d_a + d_{m_{12}}} {2} = \frac {\frac {6940 \text { d}} {19 \text { a}} + \frac {16656} {47} \frac {\text {d}} {\text {a}}} {2} = \frac {321322} {893} \frac {\text {d}} {\text {a}} \approx 359,823 \frac {\text {d}} {\text {a}} \approx 360 \frac {\text {d}} {\text {a}}&lt;/math&gt;
::Mit den heutigen, jeweils rund eine halbe Stunde kürzeren Messwerten für die beiden Jahresdauern (tropisches Sonnenjahr mit 365,241 Tagen und Mondjahr mit zwölf Lunationen und 354,367 Tagen) zur Epoche J2000.0 ergibt sich ein nur geringfügig anderer Mittelwert, der ebenfalls nur um zirka eine Dreiviertelstunde von der Dauer von 360 Tagen abweicht:
::&lt;math&gt;\frac {d_a + d_{m_{12}}} {2} = \frac {365,241 \frac {\text {d}} {\text {a}} + 354,367 \frac {\text {d}} {\text {a}}} {2} \approx 359,804 \frac {\text {d}} {\text {a}} \approx 360 \frac {\text {d}} {\text {a}}&lt;/math&gt;

Für diese Erkenntnisse ist entweder die Weitergabe von beobachteten astronomischen Ereignissen, wie der Bedeckung der Plejaden durch den Mond oder die Messung der ekliptikalen Koordinaten des Mondes, an die nächste Generation erforderlich oder ein Lebensalter, das die Beobachtung von mindestens zwei solcher Zyklen umfasst – je nach Zeitpunkt der Geburt also rund 25 bis über 40 Jahre.

Da der Meton-Zyklus mit den aufgerundeten ganzzahligen 6940&amp;nbsp;Tagen einen Vierteltag länger dauert als 19&amp;nbsp;Sonnenjahre, summiert sich diese Differenz nach vier Meton-Zyklen auf einen ganzen Tag. Der entsprechende nach {{w|Kallippos von Kyzikos}} (viertes vorchristliches Jahrhundert) benannte '''Kallippische Zyklus''' von 76&amp;nbsp;Jahren (&lt;math&gt;= 4 \cdot 19&lt;/math&gt;&amp;nbsp;Jahre) oder 27759&amp;nbsp;Tage (&lt;math&gt;= (4 \cdot 6940) - 1&lt;/math&gt;&amp;nbsp;Tage) wird auch als verbesserter Meton-Zyklus bezeichnet:
* 76&amp;nbsp;Jahre = 27758,4&amp;nbsp;Tage
* 940&amp;nbsp;synodische Monate = 27758,8&amp;nbsp;Tage
* 1016&amp;nbsp;siderische Monate = 27758,8&amp;nbsp;Tage
* 1020&amp;nbsp;drakonitische Monate = 27756,5&amp;nbsp;Tage

Nach ungefähr 48&amp;nbsp;Sonnenjahren betrug die Differenz zwischen Meton-Zyklus und Sonnenjahr einen Tag, aber erst nach ungefähr 128&amp;nbsp;Sonnenjahren erreicht die Differenz zwischen Kallippischen Zyklus und Sonnenjahr so groß. Da der Kallippische Zyklus mit genau 27759;Tagen einen Vierteltag länger dauert als 76&amp;nbsp;Sonnenjahre, summiert sich diese Differenz nach vier Kallippischen Zyklen auf einen ganzen Tag. Der entsprechende nach {{w|Hipparchos (Astronom)|Hipparchos von Nicäa}} (zweites vorchristliches Jahrhundert) benannte '''Hipparchos-Zyklus''' von 304&amp;nbsp;Jahren (&lt;math&gt;= 4 \cdot 76 = 16 \cdot 19&lt;/math&gt;&amp;nbsp;Jahre) = 111035&amp;nbsp;Tage (&lt;math&gt;= (4 \cdot 27759) - 1&lt;/math&gt;&amp;nbsp;Tage) ist also wiederum ein verbesserter Kallippischer Zyklus:
* 304&amp;nbsp;Jahre = 111033,6&amp;nbsp;Tage
* 3760&amp;nbsp;synodische Monate = 111035,0&amp;nbsp;Tage
* 4064&amp;nbsp;siderische Monate = 111035,2&amp;nbsp;Tage
* 4080&amp;nbsp;drakonitische Monate = 111025,9&amp;nbsp;Tage

Nach einer Kallippischen Periode beträgt die Differenz zwischen 111035&amp;nbsp;ganzen Tagen und der Dauer von 3760&amp;nbsp;synodischen Monaten nur eine dreiviertel Stunde.

Die folgende Tabelle gibt einen Überblick über die Dauern im Meton-Zyklus, im Kallippischen Zyklus und im Hipparchos-Zyklus:

{| class=&quot;wikitable&quot;
!
!Tropische Perioden
!Synodische Perioden
!Siderische Perioden
!Ganzzahlige Tage
|-
|'''Dauer einer Periode in Tagen'''
|'''365,2422'''
|'''29,53059'''
|'''27,32166'''
|'''1'''
|-
|
|-
|'''Anzahl der Perioden im Meton-Zyklus'''
|'''19'''
|'''235'''
|'''254'''
|'''6940'''
|-
|'''Anzahl der Tage im Meton-Zyklus'''
|6939,6018
|6939,6887
|6939,7016
|6940
|-
|'''Differenz zu tropischen Perioden in Tagen'''
|0,0000
|0,0868
|0,0998
|0,3982
|-
|'''Differenz zu synodischen Perioden in Tagen'''
| -0,0868
|0,0000
|0,0130
|0,3113
|-
|'''Differenz zu siderischen Perioden in Tagen'''
| -0,0998
| -0,0130
|0,0000
|0,2984
|-
|'''Differenz zu tropischen Perioden in Stunden'''
|0,00
|2,08
|2,40
|9,56
|-
|'''Differenz zu synodischen Perioden in Stunden'''
| -2,08
|0,00
|0,31
|7,47
|-
|'''Differenz zu siderischen Perioden in Stunden'''
| -2,40
| -0,31
|0,00
|7,16
|-
|
|-
|'''Anzahl der Perioden im Kallippischen Zyklus'''
|'''76'''
|'''940'''
|'''1016'''
|'''27759'''
|-
|'''Anzahl der Tage im Kallippischen Zyklus'''
|27758,4072
|27758,7546
|27758,8066
|27759
|-
|'''Differenz zu tropischen Perioden in Tagen'''
|0,0000
|0,3474
|0,3994
|0,5928
|-
|'''Differenz zu synodischen Perioden in Tagen'''
| -0,3474
|0,0000
|0,0520
|0,2454
|-
|'''Differenz zu siderischen Perioden in Tagen'''
| -0,3994
| -0,0520
|0,0000
|0,1934
|-
|'''Differenz zu tropischen Perioden in Stunden'''
|0,00
|8,34
|9,58
|14,23
|-
|'''Differenz zu synodischen Perioden in Stunden'''
| -8,34
|0,00
|1,25
|5,89
|-
|'''Differenz zu siderischen Perioden in Stunden'''
| -9,58
| -1,25
|0,00
|4,64
|-
|
|-
|'''Anzahl der Perioden im Hipparchos-Zyklus'''
|'''304'''
|'''3760'''
|'''4064'''
|'''111035'''
|-
|'''Anzahl der Tage im Hipparchos-Zyklus'''
|111033,6288
|111035,0184
|111035,2262
|111035
|-
|'''Differenz zu tropischen Perioden in Tagen'''
|0,0000
|1,3896
|1,5974
|1,3712
|-
|'''Differenz zu synodischen Perioden in Tagen'''
| -1,3896
|0,0000
|0,2078
| -0,0184
|-
|'''Differenz zu siderischen Perioden in Tagen'''
| -1,5974
| -0,2078
|0,0000
| -0,2262
|-
|'''Differenz zu tropischen Perioden in Stunden'''
|0,00
|33,35
|38,34
|32,91
|-
|'''Differenz zu synodischen Perioden in Stunden'''
| -33,35
|0,00
|4,99
| -0,44
|-
|'''Differenz zu siderischen Perioden in Stunden'''
| -38,34
| -4,99
|0,00
| -5,43
|}

Vor gut 2000&amp;nbsp;Jahren betrug die Differenz zwischen Kallippischem Zyklus und Sonnenjahr nach ungefähr 227&amp;nbsp;Sonnenjahren einen Tag. Durch die inzwischen etwas verkürzte Dauer eines tropischen Jahres ist dies heute bereits nach etwa 221&amp;nbsp;Jahren der Fall.

====Die Goldene Zahl====
Die '''Goldene Zahl''' gibt an, das wievielte von diesen 19&amp;nbsp;Jahren ein bestimmtes Jahr ist, und sie spielt auch heute noch eine wichtige Rolle bei der Bestimmung des Datums von Pessach oder Ostern, zum Beispiel mit Hilfe der Formeln zur Berechnung von {{w|Carl Friedrich Gauß}} (*&amp;nbsp;1777; †&amp;nbsp;1855):

→ Siehe auch:

* [[Astronomie von der Frühgeschichte bis zur Neuzeit/ Kalenderführung/ Osterdatum|'''Osterdatum''']]
* {{w|Gaußsche Pessach-Formel}}
* {{w|Gaußsche Osterformel}}

Der Name Goldene Zahl rührt möglicherweise davon her, dass der diesem Zyklus zugrundeliegende Kalender ('''Parapegma''') des Meton auf den Steinmauern seiner Sonnenuhr (heliotropion) am Pnyx-Hügel in Athen in goldener Schrift zu sehen war.&lt;ref&gt;Michael Wright: [https://www3.astronomicalheritage.net/index.php/show-entity?identity=26&amp;idsubentity=1 The Pnyx, Athens, Greece], Portal to the Heritage of Astronomy, August 2011&lt;/ref&gt;&lt;ref name=&quot;rutherforth&quot; /&gt;

Heute ist in den Monaten um die Wintersonnenwende alle 19&amp;nbsp;Jahre morgens am westlichen Horizont der untergehende Vollmond im Goldenen Tor der Ekliptik zu sehen, wie im Dezember&amp;nbsp;2018. Die untere Hälfte des Mondes wird dann während des Untergangs vom Horizont verdeckt und der sichtbare leuchtende Teil bildet somit einen Halbkreis, wie er im mittleren Segment der Himmelstafel angedeutet ist. In diesem Fall liegen Hyaden und Plejaden im Westen auf einer Linie parallel zum Horizont und der dazwischenliegende, beim Untergang noch halb zu sehende Vollmond würde der Abbildung auf der Steintafel von Tal-Qadi entsprechen. Vor 4500&amp;nbsp;Jahren ergab sich diese Himmelsansicht wegen der Verschiebung des Frühlingspunktes bereits um die Tag-und-Nacht-Gleiche im Herbst.

Die 19&amp;nbsp;Megalithe des Blaustein-Hufeisens von '''Stonehenge''' (2270&amp;nbsp;bis 1930&amp;nbsp;vor Christus) werden ebenfalls mit dem 19-jährigen Meton-Zyklus in Zusammenhang gesehen.

Im Übrigen werden auch die Goldhüte aus der Bronzezeit mit diesem Zyklus in Verbindung gebracht. Der '''Berliner Goldhut''' zeigt in der siebenten und in der neunten ringförmigen Zone von oben horizontale Reihen mit 57 (=&amp;nbsp;3&amp;nbsp;x&amp;nbsp;19) kreisförmigen Punzen, die für ein Viertel der 228&amp;nbsp;Monate einer Meton-Periode stehen könnten.&lt;ref&gt;Wilfried Menghin: „Der Berliner Goldhut und die goldenen Kalendarien der alteuropäischen Bronzezeit“, Acta Praehistorica et Archaeologica, Band 32, 2000, ISSN 0341-1184, Seiten 31 bis 108&lt;/ref&gt;

An der östlichen Wand in der Kamme&amp;nbsp;A des hethitischen Heiligtums '''Yazılıkaya''' (türkisch für „beschriebener Fels“) aus dem 13.&amp;nbsp;vorchristlichen Jahrhundert existiert eine Reliefbilderreihe, die eine Prozession von '''neunzehn''' nach links schauenden Göttinnen im Ganzkörperprofil darstellt. Auch hier wird vermutet, dass diese Reihe als Zählwerk für den Meton-Zyklus eine Kalenderfunktion innehatte.&lt;ref&gt;Eberhard Zangger, Rita Gautschy: [http://63.33.38.154/JSA/article/view/12232 Celestial Aspects of Hittite Religion - An Investigation of the Rock Sanctuary Yazilikaya], Journal of Skyscape Archaeology, 5(1), 5–38, 2019&lt;/ref&gt;&lt;ref&gt;Edwin C. Krupp, Eberhard Zangger: [https://www.archaeologie-online.de/artikel/2021/die-symbolische-darstellung-des-kosmos-im-hethitischen-felsheiligtum-yazlkaya Die symbolische Darstellung des Kosmos im hethitischen Felsheiligtum Yazılıkaya] vom 16. Juni 2021, Archäologie Online, archaeomedia, Freiburg&lt;/ref&gt;

Der Zyklus mit der Anzahl 19 taucht in weiteren archäoastronomischen Kontexten auf:

* Mond-Sonne-Darstellung aus dem mesoamerikanischen '''Codex Borbonicus''' der Azteken vom Anfang des 16.&amp;nbsp;Jahrhunderts.
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Mondzyklen#Der_Kalenderstein_vom_Tempel_Mnajdra|Oberste Lochreihe auf dem östlichen Kalenderstein vom Tempel '''Mnajdra''' auf Malta]].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Höhlenmalerei_in_der_Magura-Höhle#Kalender|Kalender unter den Höhlenmalereien in der '''Magura'''-Höhle mit einer Matrix aus 19 Punkten]].

&lt;gallery caption=&quot;Die Zahl 19 in archäoastronomischen Kontexten&quot; mode=packed widths=360 heights=360&gt;
Magura_cave_calendar_1528.jpg|Detail mit Elementen eines Kalenders aus der '''Magura'''-Höhle in Bulgarien. Unten in der Mitte befindet sich ein Feld mit 19&amp;nbsp;Punkten.
Kalenderstein.Mnajdra.labelled.png|Skizze der Lochreihen auf dem Kalenderstein von '''Mnajdra''' auf Malta. Die oberste Lochreihe besteht aus 19&amp;nbsp;Löchern.
Hattusa,_capital_of_the_Hittite_Empire_51.jpg|Detail mit den linken drei der insgesamt neunzehn Göttinnen der Bilderreihe in der Kammer A des hethitischen Heiligtums '''Yazılıkaya'''.
Yazilikaya.19.Gottheiten.png|Schmatische Darstellung der 19&amp;nbsp;weiblichen Gottheiten im hethitischen Heiligtum '''Yazılıkaya''' in der Türkei. Im Original variieren die Darstellungen der einzelnen Figuren, die in unterschiedlichem Zustand erhalten sind. Über den Händen einzelner Figuren konnten verschiedene hieroglyphische Darstellungen festgestellt werden. Die erste Figur (ganz links) konnte hierdurch nur indirekt rekonstruiert werden.
Berliner.Goldhut.P1068203.jpg||'''Berliner Goldhut''' vom Ende der Bronzezeit (1000–800 vor Christus) im Neuen Museum.
MesoamerikanischerMond.CodexBorbonicus.png|Mond-Sonne-Darstellung aus dem mesoamerikanischen '''Codex Borbonicus''' der Azteken vom Anfang des 16.&amp;nbsp;Jahrhunderts. Die beiden sich zu einem vollen Kreis ergänzenden Halbkreise symbolisieren den Mond und die Sonne. Im Halbkreis des Mondes befinden sich '''19&amp;nbsp;Kreise'''.
&lt;/gallery&gt;

====MUL.APIN====
[[Datei:MUP.APIN.VAT09412.P1078712.jpg|thumb|1914 gefundene Tontafel mit Texten aus dem 687 vor Christus geschrieben babylonischen Kompendium MUL.APIN, Irak, Assur/Qal'at Scherqat, VAT 09412, Neues Museum Berlin]]

Die auf den MUL.APIN-Tafeln schriftlich überlieferten babylonischen [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|'''Plejaden-Schaltregeln''']] beziehen sich zweifelsfrei auf einen Zeitpunkt, als der offene Sternhaufen der Plejaden im Sternbild Stier (Taurus) die gleiche ekliptikale Länge wie der Frühlingspunkt gehabt hat. Dies bedeutet, dass die Sonne zur Tag-und-Nacht-Gleiche direkt neben den Plejaden stand, und dies war um 2600&amp;nbsp;vor Christus der Fall. Aus beiden Schaltregeln ergibt sich, dass innerhalb von 19&amp;nbsp;Sonnenjahren sieben zusätzliche synodische Monate eingeschaltet werden müssen, damit Sonnen- und synodisches Mondjahr synchron bleiben. Die Differenz zwischen Mondlauf und Sonnenlauf beträgt nach diesen 19&amp;nbsp;Sonnenjahren nur gut zwei Stunden. Diese Abweichung beträgt nur 0,0125&amp;nbsp;Promille beziehungsweise 12,58&amp;nbsp;parts&amp;nbsp;per&amp;nbsp;million (ppm):

* Tropisches Sonnenjahr (von Frühlingspunkt zu Frühlingspunkt): &lt;math&gt;J_S = 365,2422 \text { d} = 8765,813 \text { h}&lt;/math&gt;
* Synodischer Monat (von Neumond zu Neumond): &lt;math&gt;M_{syn} = 29,53059 \text { d} = 708,7342 \text { h}&lt;/math&gt;
* Synodisches Mondjahr (zwölf synodische Monate): &lt;math&gt;J_{syn} = 12 \cdot M_{syn} = 354,3671 \text { d} = 8504,810 \text { h}&lt;/math&gt;
* Jahresdifferenz zwischen tropischem Sonnenjahr und synodischem Mondjahr: &lt;math&gt;\Delta J = J_S - J_{syn} = 10,8751 \text { d} = 261,003 \text { h}&lt;/math&gt;
* Meton-Zyklus: &lt;math&gt;19 \cdot \Delta J = 206,627 \text { d} = 4959,046 \text { h}&lt;/math&gt; beziehungsweise &lt;math&gt;7 \cdot M_{syn} = 206,714 \text { d} = 4961,139 \text { h}&lt;/math&gt;
* Genauigkeit des Meton-Zyklus: &lt;math&gt;\Delta M = 7 \cdot M_{syn} - 19 \cdot \Delta J = 0,087 \text { d} \approx 2,09 \text { h} = 235 \cdot M_{syn} - 19 \cdot J_S&lt;/math&gt;
* Arithmetische Zusammensetzung und Primfaktorenzerlegung der Anzahl synodischer Mondzyklen: &lt;math&gt;235 = 7 + 19 \cdot 12 = 5 \cdot 47&lt;/math&gt;

Mit anderen Worten war der Meton-Zyklus bereits über zwei Jahrtausende lang bekannt, bevor sich der griechische Astronom Meton damit beschäftigte.

Es ist äußerst bemerkenswert, dass eine entsprechende Berechnung auch für dreizehn siderische Monate durchgeführt werden kann, bei denen der Mond jeweils einmal vollständig die Ekliptik mit ihren zwölf Ekliptiksternbildern beziehungsweise den 27 oder 28 Mondstationen (auch Mondhäuser genannt, siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Mondhäuser|Exkurs '''Mondhäuser''']]) durchläuft:

* Tropisches Sonnenjahr (von Frühlingspunkt zu Frühlingspunkt): &lt;math&gt;J_S = 365,2422 \text { d} = 8765,813 \text { h}&lt;/math&gt;
* Siderischer Monat (von Fixstern zu Fixstern): &lt;math&gt;M_{sid} = 27,32166 \text { d} = 655,720 \text { h}&lt;/math&gt;
* Siderisches Mondjahr (13 siderische Monate): &lt;math&gt;J_{sid} = 13 \cdot M_{sid} = 355,1816 \text { d} = 8524,358 \text { h}&lt;/math&gt;
* Jahresdifferenz zwischen tropischem Sonnenjahr und siderischem Mondjahr: &lt;math&gt;\Delta J = J_S - J_{sid} = 10,0606 \text { d} = 241,454 \text { h}&lt;/math&gt;
* Meton-Zyklus: &lt;math&gt;19 \cdot \Delta J = 191,151 \text { d} = 4587,634 \text { h}&lt;/math&gt; beziehungsweise &lt;math&gt;7 \cdot M_{sid} = 191,252 \text { d} = 4590,040 \text { h}&lt;/math&gt;
* Genauigkeit des Meton-Zyklus: &lt;math&gt;\Delta M = 7 \cdot M_{sid} - 19 \cdot \Delta J = 0,100 \text { d} \approx 2,40 \text { h} = 254 \cdot M_{sid} - 19 \cdot J_S&lt;/math&gt;
* Arithmetische Zusammensetzung und Primfaktorenzerlegung der Anzahl siderischer Mondzyklen: &lt;math&gt;254 = 7 + 19 \cdot 13 = 2 \cdot 127&lt;/math&gt;

Auch hier beträgt die Differenz zwischen Mondlauf und Sonnenlauf nur gut zwei Stunden. Und innerhalb der 19 Sonnenjahre eines Meton-Zyklus müssen auch hier sieben zusätzliche (vierzehnte) siderische Monate eingeschaltet werden, damit Sonnen- und siderisches Mondjahr synchron bleiben.

Zur Differenz von knapp elf Tagen zwischen Sonnen- und Mondjahr siehe auch '''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Das_babylonische_Neujahrsfest_Akiti|das babylonische Neujahrsfest Akiti]]'''. Dieses elftägige Fest wurde am Ende des Mondjahres gefeiert.

===Der drakonitische Zyklus===
Ferner existiert ein zirka '''18,61-jähriger Mondzyklus''', der darauf beruht, dass bedingt durch die Präzession der Mondbahn der aufsteigende und der absteigende Mondknoten nach dieser Zeit die Ekliptik entgegen der rechtläufigen (prograden) Umlaufrichtung des Mondes genau einmal vollständig rückläufig (retrograd) durchlaufen haben. Dieser Zyklus besteht aus 249,83&amp;nbsp;drakonitischen Monaten, die insgesamt 6798,38&amp;nbsp;Tagen beziehungsweise 18,61&amp;nbsp;tropischen Sonnenjahren entsprechen. Die ekliptikalen Längen der Mondknoten vermindern sich hierbei um einen Winkel von 19,34&amp;nbsp;Bogengrad pro Jahr.

Dieser drakonitische Zyklus ist zum Beispiel anhand der Abweichungen der ekliptikalen Breiten des Mondes und somit der Azimute bei den monatlichen Mondaufgängen und Monduntergängen am Horizont zu beobachten, die sich nach 18,61&amp;nbsp;Jahren wiederholen und dabei um die Punkte der Wintersonnenwende im Südosten und Südwesten sowie die Punkte der Sommersonnenwende im Nordosten und Nordwesten entlang dem Horizont pendeln. Die Zeitpunkte an dem die entsprechenden Auf- und Untergangspunkte zwischen dem nördlichen und dem südlichen Horizont um die Punkte der Tag-und-Nacht-Gleichen im Osten und Westen, die definitionsgemäß bei der ekliptikalen Breite null genau in der Ekliptik liegen, am engsten beziehungsweise am weitesten auseinanderliegen, heißen '''große und kleine Mondwenden'''. Diese Mondwenden wiederholen sich also alle 18,61&amp;nbsp;Jahre. Hierbei treten auch größte und kleinste Mondwenden auf. Um die Wintersonnenwenden der Jahre 2023, 2042, 2061 und so weiter treten beispielsweise '''größte Mondwenden''' auf, bei denen die Auf- und Untergangspunkte maximal in Richtung Norden von den genau im Osten und im Westen liegenden Äquinoktialpunkten entfernt sind. Und um die Sommersonnenwenden der Jahre 2024, 2043, 2062 und so weiter treten '''kleinste Mondwenden''' auf, bei denen die Auf- und Untergangspunkte maximal in Richtung Süden von den genau im Osten und im Westen liegenden Äquinoktialpunkten entfernt sind.

[[Datei:Ekliptik.helle.Objekte.png|mini|hochkant=2|rechts|Die sieben hellsten feststehenden Himmelsobjekte in der Nähe der Ekliptik liegen zwischen den Sternbildern Stier (Taurus, rechts) und Skorpion (Scorpio, links). Der Bogen der Ekliptik wird von den Wandelgestirnen entgegen dem Uhrzeigersinn vom Frühlingspunkt rechts zum Herbstpunkt links durchlaufen. In der Nähe unteren Bogenhälfte befinden sich keine hellen Fixsterne in der Nähe der Ekliptik, der helle Stern Fomalhaut (α&amp;nbsp;Piscis Austrini) im Sternbild Südlicher Fisch (Piscis Austrinus) dient lediglich zur Orientierung. Außerhalb des Bogens liegende Punkte befinden sich nördlich der Ekliptik und innen liegende südlich.]]

Aufgrund dieser Zusammenhänge werden alle möglichen Positionen des Mondes in Bezug auf die Ekliptik bei den ekliptikalen Längen von -180&amp;nbsp;bis +180&amp;nbsp;Bogengrad und den ekliptikalen Breiten von ungefähr -6&amp;nbsp;bis +6&amp;nbsp;Bogengrad innerhalb dieser 18,61-jährigen Periode erreicht. Somit erfolgen auch alle möglichen Sternbedeckungen (Okkultationen) oder nahe Konjunktionen innerhalb dieser Periodendauer und wiederholen sich danach im drakonitischen Zyklus. Die Bedeckungen hellsten ekliptiknahen Himmelsobjekte sind hierbei besonders spektakulär und gut zu beobachten. Dies gilt insbesondere für:

* die '''Plejaden''' (Messier 45, 1,5&lt;sup&gt;m&lt;/sup&gt;) im Sternbild Stier (Taurus)
* die '''Hyaden''' (0,5&lt;sup&gt;m&lt;/sup&gt;) im Sternbild Stier (Taurus)
* den Roten Riesen '''Aldebaran''' (α&amp;nbsp;Tauri, 1,0&lt;sup&gt;m&lt;/sup&gt;) im Sternbild Stier (Taurus)
* den Roten Überriesen '''Antares''' (α&amp;nbsp;Scorpii, 1,0&lt;sup&gt;m&lt;/sup&gt;) im Sternbild Skorpion (Scorpio),
* den Stern '''Spica''' (α&amp;nbsp;Virginis, 1,0&lt;sup&gt;m&lt;/sup&gt;) im Sternbild Jungfrau (Virgo)
* den Stern '''Regulus''' (α&amp;nbsp;Leonis, 1,5&lt;sup&gt;m&lt;/sup&gt;) im Sternbild Löwe (Leo)

Wenn der Mond bei der Bedeckung der '''Plejaden''' seine maximale nördliche ekliptikale Breite bereits zuvor erreicht hatte und sich also bereits wieder in Richtung seines absteigenden Knotens bewegt, befindet sich in der Nähe des absteigenden Knotens der Königsstern '''Regulus''' im Sternbild Löwe (Leo), so dass es ungefähr eine Woche später ebenfalls zu dessen Bedeckung durch den Mond kommen kann. Da der Stern '''Antares''' α&amp;nbsp;Scorpii) im Sternbild Skorpion (Scorpio) in etwa die gleiche südliche ekliptikale Breite hat, wie die Plejaden eine nördliche ekliptikale Breite haben, und beide auf gegenüberliegenden Punkten der Ekliptiklinie liegen, kommt es im Rhythmus des drakonitischen Zyklus innerhalb eines halben Monats gehäuft zu der Bedeckung beider Himmelsobjekte durch die Mondscheibe. Beide Ereignisse wären wegen der gegenüberliegenden Lage auf der Ekliptik heute allerdings nur während der langen Nächte im Winterhalbjahr zu sehen, wenn Antares praktisch nicht zu beobachten ist, weil er von der Sonne überstrahlt wird. Als der Frühlingspunkt im Altertum jedoch im Sternbild Stier stand, war die aufeinanderfolgende Bedeckung von Plejaden und Antares jedoch durchaus ein zu beobachtendes Doppelereignis.

Das nächste Mal werden die beiden eng benachbarten Elternsterne der Plejaden (der Titan Atlas und die Okeanide Pleione) von Mitteleuropa aus gesehen in den Morgenstunden des 8.&amp;nbsp;Augusts 2024 von der Scheibe des abnehmenden Halbmonds bedeckt. Am 1.&amp;nbsp;April 2025 werden gegen Mitternacht dann sogar mehrere helle Sterne des Sternhaufens durch die nur vier Tage alte Mondsichel bedeckt.

Auch im alten chinesischen, mündlich überlieferten Volksmärchen „Morgenhimmel“ wird der Zyklus vom '''Stern des großen Jahres''' erwähnt, der sich erst nach 18 Jahren, also im 19.&amp;nbsp;Jahr wiederholt:&lt;ref&gt;[[s:Morgenhimmel|Morgenhimmel]], Wikisource&lt;/ref&gt;

&lt;blockquote&gt;
Als Morgenhimmel gestorben war, berief der Kaiser den Sterndeuter und fragte: „Kanntest du Morgenhimmel?“&lt;br/&gt;
Der sagte: „Nein.“&lt;br/&gt;
Der Kaiser fragte: „Was verstehst du denn?“&lt;br/&gt;
Der Sterndeuter sagte: „Ich kann nach den Sternen sehen.“&lt;br/&gt;
„Sind alle Sterne an ihrem Platz?“ fragte der Kaiser.&lt;br/&gt;
„Ja. Nur den Stern des großen Jahres habe ich achtzehn Jahre nicht gesehen. Jetzt aber ist er wieder sichtbar.“&lt;br/&gt;
Da blickte der Kaiser zum Himmel auf und seufzte: „Achtzehn Jahre lang war Morgenhimmel mir zur Seite, und ich wusste nicht, dass er der Stern des großen Jahres war.“
&lt;/blockquote&gt;

Mit &quot;Stern des großen Jahres&quot; könnte ein Ereignis gemeint sein, bei dem der Mond alle 18,61 Jahre einen bestimmten hellen und ekliptiknahen Stern bedeckt, wie zum Beispiel einen der drei Königssterne Aldebaran (α&amp;nbsp;Tauri) im Sternbild Stier (Taurus), Regulus (α&amp;nbsp;Leonis) im Sternbild Löwe (Leo), Antares (α&amp;nbsp;Scorpii) im Sternbild Skorpion (Scorpio) oder auch Spica (α&amp;nbsp;Virginis) im Sternbild Jungfrau (Virgo).

Auch für den drakonitischen Zyklus kann für dreizehn drakonitische Monate eine Berechnung in Bezug auf den 19-jährigen Meton-Zyklus durchgeführt werden:

* Tropisches Sonnenjahr (von Frühlingspunkt zu Frühlingspunkt): &lt;math&gt;J_S = 365,2422 \text { d} = 8765,813 \text { h}&lt;/math&gt;
* Drakonitischer Monat (von Mondknoten zu Mondknoten): &lt;math&gt;M_{dra} = 27,21222 \text { d} = 653,093 \text { h}&lt;/math&gt;
* Drakonitisches Mondjahr (13 drakonitische Monate): &lt;math&gt;J_{dra} = 13 \cdot M_{dra} = 353,7589 \text { d} = 8490,213 \text { h}&lt;/math&gt;
* Jahresdifferenz zwischen tropischem Sonnenjahr und drakonitischem Mondjahr: &lt;math&gt;\Delta J = J_S - J_{dra} = 11,4833 \text { d} = 275,600 \text { h}&lt;/math&gt;
* Meton-Zyklus: &lt;math&gt;19 \cdot \Delta J = 218,1835 \text { d} = 5236,403 \text { h}&lt;/math&gt; beziehungsweise &lt;math&gt;8 \cdot M_{sid} = 217,6978 \text { d} = 5224,746 \text { h}&lt;/math&gt;
* Genauigkeit des Meton-Zyklus: &lt;math&gt;\Delta M = 8 \cdot M_{dra} - 19 \cdot \Delta J = -0,486 \text { d} \approx -11,66 \text { h} = -(255 \cdot M_{dra} - 19 \cdot J_S)&lt;/math&gt;
* Arithmetische Zusammensetzung und Primfaktorenzerlegung der Anzahl drakonitischer Mondzyklen: &lt;math&gt;255 = 8 + 19 \cdot 13 = 3 \cdot 5 \cdot 17&lt;/math&gt;

Hier beträgt die Differenz zwischen Mondlauf und Sonnenlauf knapp einen halben Tag. Innerhalb der 19 Sonnenjahre eines Meton-Zyklus müssen hier acht zusätzliche (vierzehnte) drakonitische Monate eingeschaltet werden, damit Sonnen- und drakonitisches Mondjahr synchron bleiben.

===Der Saros-Zyklus===
[[Datei:Saros-Zyklus.2023.Januar.png|rechts|mini|hochkant=4|Der '''Saros-Zyklus''' umfasst sowohl eine Periode von 242&amp;nbsp;drakonitischen Monaten als auch eine Periode von 223&amp;nbsp;synodischen Monaten. Das sind gut 6585&amp;nbsp;Tage oder 18,03 tropische Sonnenjahre, also 18&amp;nbsp;Jahre und knapp 11&amp;nbsp;Tage). In der Graphik ist die Zeit vom aufsteigenden Knoten (rot) am 1.&amp;nbsp;Januar 2023 bis zum aufsteigenden Knoten (rot) am 11.&amp;nbsp;Januar 2041 dargestellt. Man beachte die gleichzeitige zyklische Wiederholung der jeweiligen Mondphasen sowie daraus folgend der '''Finsternisse''' im April und Mai sowie im Oktober und November mit einer Verschiebung von elf Kalendertagen im Sonnenjahr.&lt;br/&gt;Die '''Mondwenden''' (die tagesaktuellen Auf- und Untergangsazimute des Mondes sind im unteren Bereich für die geographische Breite 52,5 Bogengrad (zum Beispiel in Berlin) dargestellt) haben ihr Minimum und Maximum demzufolge zu den entsprechenden Zeitpunkten, die Ausprägung dieser Extrema unterscheidet sich jedoch ein wenig, weil der Mond dort geringfügig abweichende minimale und maximale ekliptikale Breiten hat. Die kleinen Mondwenden beim Sommervollmond im Juli und die großen Mondwenden beim Wintervollmond (Jahreswechsel) sind in der Graphik ebenfalls nachvollziehbar.&lt;br/&gt;[[Datei:Legende.Meton-Zyklus.png|200px|zentriert|Legende]]]]

Über die weiter oben beschriebenen Koinzidenzen hinaus kann beobachtet werden, dass der Mond nach '''18,03&amp;nbsp;Jahren''' (also nach 242&amp;nbsp;drakonitischen Monaten beziehungsweise 6585,3&amp;nbsp;Tagen) denselben auf- oder absteigenden Knoten erreicht, wobei Sonne und Mond dann die gleiche Elongation haben (nach 223&amp;nbsp;synodischen Monaten beziehungsweise 6585,2&amp;nbsp;Tagen). Sie befinden sich dann allerdings nur fast bei den gleichen ekliptikalen Längen beziehungsweise an den gleichen Stellen des Fixsternhimmels, da diese Dauer nur mit ungefähr einem halben Tag Differenz mit 241 siderischen Perioden übereinstimmt (6584,6&amp;nbsp;Tage). Innerhalb dieses halben Tages hat sich die Sonne um zirka ein halbes Bogengrad und der Mond sogar um ungefähr sechseinhalb Bogengrad weiterbewegt.

Dieser Zyklus wird '''Saros-Zyklus''' genannt. Innerhalb dieser Zeitspanne ergibt sich eine Reihe von Sonnen- und Mondfinsternissen, die sich in ihrer Abfolge immer wieder ähneln. Der Saros-Zyklus war bei den Babyloniern bereits im Altertum bekannt, was in Keilschrift geschrieben auf Tontafeln aus der Mitte des achten vorchristlichen Jahrhunderts überliefert ist.

Heute werden die sich wiederholenden Sonnen- und Mondfinsternisse, die sich auf einen bestimmten auf- oder absteigenden Knoten der Mondbahn beziehen und jeweils eine Lebensdauer von mehreren Jahrhunderten haben, zum Zwecke der Unterscheidung mit Nummern versehen. Zu einem bestimmten Zeitpunkt der Weltgeschichte sind immer mehrere Dutzend Saros-Zyklen gleichzeitig aktiv.

Die anomalistische Periode steht für die Dauer, bis der Mond auf seiner elliptischen Bahn um die Erde erneut eines seiner beiden Apogäen erreicht, also das Perigäum (erdnächster Punkt) oder das Apogäum (erdfernster Punkt). Nach einer ganzzahligen vielfachen Dauer der anomalistischen Periode hat der Mond also stets fast die gleiche Entfernung zur Erde und somit auch die gleiche scheinbare Größe, so dass die Dauer und Art (totale oder ringförmige Sonnenfinsternis) einer Finsternis sich wiederholt.

Wegen der gleichen ekliptikalen Breiten des Mondes nach einer ganzzahligen vielfachen Dauer der drakonitischen Periode erscheint der Mondschatten auf der Erdoberfläche nach der Dauer einer Saros-Periode ungefähr beim gleichen Breitengrad. Durch die Differenz von rund einem drittel Tag ist der Längengrad allerdings nach einer Saros-Periode um knapp 120 Bogengrad nach Westen verschoben. Nach drei Saros Perioden, oder nach einem dadurch definierten Exeligmos-Zyklus, haben sich die drei Dritteltage fast auf einen Tag summiert, so dass nach der Mondschatten dann nicht nur wieder beim ähnlichen Breitengrad, sondern sogar beim ähnlichen Längengrad und zu einer ähnlichen Tageszeit auftaucht. Anders ausgedrückt: wenn an einem bestimmten Ort auf der Erdoberfläche eine Finsternis auftritt, so erfolgt in der Regel nach 19756 Tagen (54 Jahren und 33 Tagen) in dieser geographischen Region mit nur rund einer Stunde Verfrühung erneut eine solche Finsternis.

{| class=&quot;wikitable&quot;
|+ Exeligmos-Zyklus
! Anzahl der Saros-Zyklen !! Dauer in tropischen Jahren !! Dauer in ganzen Tagen
|-
| 1 || 18,03 || 6585
|-
| 3 || 54,09 || 19756
|}

Die folgende Tabelle gibt einen Überblick über die Dauern verschiedener Mondzyklen in einem '''Saros-Zyklus''' (18,03 tropische Jahre) sowie in einem dreimal so langen Zyklus '''Exeligmos-Zyklus''' (54,09 tropische Jahre) . 

{| class=&quot;wikitable&quot;
!
!Synodische Perioden
!Drakonitische Perioden
!Tage
!Anomalistische Perioden
|-
|'''Dauer einer Periode in Tagen'''
|'''29,53059'''
|'''27,21222'''
|'''1'''
|'''27,53455'''
|-
|
|-
|'''Anzahl der Perioden im Saros-Zyklus'''
|'''223'''
|'''242'''
|'''6585'''
|'''239'''
|-
|'''Anzahl der Tage im Saros-Zyklus'''
|6585,3216
|6585,3572
|6585,0000
|6580,7575
|-
|'''Differenz zu synodischen Perioden in Tagen'''
|0,0000
|0,0357
| -0,3216
| -4,5641
|-
|'''Differenz zu drakonitischen Perioden in Tagen'''
| -0,0357
|0,0000
| -0,3572
| -4,5998
|-
|'''Differenz zu ganzen Tagen'''
|0,3216
|0,3572
|0,0000
| -4,2425
|-
|'''Differenz zu synodischen Perioden in Stunden'''
|0,00
|0,86
| -7,72
| -109,54
|-
|'''Differenz zu drakonitischen Perioden in Stunden'''
| -0,86
|0,00
| -8,57
| -110,39
|-
|'''Differenz zu ganzen Tagen in Stunden'''
|7,72
|8,57
|0,00
| -101,82
|-
|
|-
|'''Anzahl der Perioden im Exeligmos-Zyklus'''
|'''669'''
|'''726'''
|'''19756'''
|'''717'''
|-
|'''Anzahl der Tage im Exeligmos-Zyklus'''
|19755,9647
|19756,0717
|19756,0000
|19742,2724
|-
|'''Differenz zu synodischen Perioden in Tagen'''
|0,0000
|0,1070
|0,0353
| -13,6924
|-
|'''Differenz zu drakonitischen Perioden in Tagen'''
| -0,1070
|0,0000
| -0,0717
| -13,7994
|-
|'''Differenz zu ganzen Tagen in Tagen'''
| -0,0353
|0,0717
|0,0000
| -13,7277
|-
|'''Differenz zu synodischen Perioden in Stunden'''
|0,00
|2,57
|0,85
| -328,62
|-
|'''Differenz zu drakonitischen Perioden in Stunden'''
| -2,57
|0,00
| -1,72
| -331,18
|-
|'''Differenz zu ganzen Tagen in Stunden'''
| -0,85
|1,72
|0,00
| -329,46
|}

===Mondwenden===
Da sich die '''Sonne''' definitionsgemäß immer in der Ekliptikebene befindet, wiederholen sich die Verhältnisse in Bezug auf ihre Auf- und Untergangspunkte sowie auf ihre südlichen und die nördlichen Kulminationshöhen in jedem tropischen Sonnenjahr. Zur '''Sommersonnenwende''' steht die Sonne am höchsten und am längsten über den Horizont, die Auf- und Untergangsazimute erreichen ihre nördlichsten Positionen und es ergibt sich der Kalendertag mit dem längsten Tagesslicht und der kürzesten Dunkelheit. Zur '''Wintersonnenwende''' steht die Sonne am niedrigsten und am kürzesten über den Horizont, die Auf- und Untergangsazimute erreichen ihre südlichsten Positionen und es ergibt sich der Kalendertag mit dem kürzesten Tagesslicht und der längsten Nacht. Bei den beiden '''Äquinoktien''' zum '''Frühlings- und Herbstbeginn''' herrscht die '''Tag-und-Nacht-Gleiche''', zwölf Stunden Tag und zwölf Stunden Nacht. Die Sonne geht überall auf der Erde exakt im Osten auf beziehungsweise im Westen unter.

Mit dem Neumond verhält es sich ähnlich wie mit der Sonne, da er sich stets in Sonnennähe befindet. Die Mondbahn ist gegenüber der Ekliptik jedoch geneigt (Inklination der Mondbahn), so dass der Mond bis zu gut 5&amp;nbsp;Bogengrad höher oder niedriger stehen kann als die Sonnenscheibe. Bei einer '''großen Mondwende''' steht die Ekliptik immer besonders hoch über dem Horizont und der Mond hat gleichzeitig seine maximale nördliche ekliptikale Breite erreicht. Wenn der Vollmond bei einer großen Mondwende auf dem südlichen Meridian kulminiert, findet dieses Ereignis als '''größte Mondwende''' um Mitternacht zur Wintersonnenwende statt (im Dezember 2023, 2042 und 2061).

[[Datei:Grosse.Mondwende.png|mini|zentriert|hochkant=2|Die größte Mondwende bei der am höchsten stehenden Ekliptik auf der Nordhalbkugel sowie die Sommersonnenwende im Horizontsystem. Die blaue Mondbahn wird während der Sommersonnenwende nur bei Neumond gleichzeitig mit der orangefarbenen Sonnenbahn durchlaufen. Während der Wintersonnenwende findet diese große Mondwende statt, wenn der Mond in Opposition zur Sonne steht und somit Vollmond herrscht.]]

Bei einer '''kleinen Mondwende''' steht die Ekliptik immer besonders niedrig über dem Horizont und der Mond hat gleichzeitig seine minimale südliche ekliptikale Breite erreicht. Wenn der Vollmond bei einer kleinen Mondwende auf dem südlichen Meridian kulminiert, findet dieses Ereignis als '''kleinste Mondwende''' um Mitternacht zur Sommersonnenwende statt (im Juni 2024, 2043 und 2062).

[[Datei:Kleine.Mondwende.png|mini|zentriert|hochkant=2|Die kleinste Mondwende bei der am niedrigsten stehenden Ekliptik auf der Nordhalbkugel sowie die Wintersonnenwende im Horizontsystem. Die blaue Mondbahn wird während der Wintersonnenwende nur bei Neumond gleichzeitig mit der orangefarbenen Sonnenbahn durchlaufen. Während der Sommersonnenwende findet diese kleine Mondwende statt, wenn der Mond in Opposition zur Sonne steht und somit Vollmond herrscht.]]

[[Datei:ZunehmenderMond.Herbst-Aequinoktium.P1185517.jpg|mini|rechts|Zunehmender Mond zum Herbst-Äquinoktium bei kleiner Mondwende mit flacher Ekliptik in Berlin mit fast senkrecht stehender Mondsichel (38% beleuchtet) im Sternbild Skorpion kurz vor Sonnenuntergang. Visuelle Helligkeit -9 mag, südliche ekliptikale Breite = -5°, Höhe über dem südlichen Horizont = 9°, Mondalter 6,2 Tage.]]

In der folgenden Übersicht sind die '''Mondaufgangspunkte''' am östlichen Horizont, die '''Kulminationspunkte''' auf dem südlichen Meridian und die '''Monduntergangspunkte''' am westlichen Horizont für die vier verschiedenen Jahreszeiten angegeben:

{| class=&quot;wikitable&quot;
|+ Die Lage des Bogens der Ekliptik über dem nächtlichen Horizont zu verschiedenen Jahreszeiten
!title=&quot;Jahreszeit&quot;| Jahreszeit
!title=&quot;Am Abend&quot;| Am Abend&lt;/br&gt;(Aufgang des Vollmonds&lt;/br&gt;in östlicher Richtung)
!title=&quot;Um Mitternacht&quot;| Um Mitternacht&lt;/br&gt;(Kulmination des Vollmonds&lt;/br&gt;auf dem südlichen Meridian)
!title=&quot;Am Morgen&quot;| Am Morgen&lt;/br&gt;(Untergang des Vollmonds&lt;/br&gt;in westlicher Richtung)
|-
| '''Frühlingsanfang'''&lt;/br&gt;'''Tag-und-Nacht-Gleiche''' || [[Datei:Ekliptik.C.png|360px]] || [[Datei:Ekliptik.D.png|360px]] || [[Datei:Ekliptik.A.png|360px]]
|-
| '''Sommeranfang'''&lt;/br&gt;'''Sommersonnenwende''' || [[Datei:Ekliptik.D.png|360px]] || [[Datei:Ekliptik.A.png|360px]] || [[Datei:Ekliptik.B.png|360px]]
|-
| '''Herbstanfang'''&lt;/br&gt;'''Tag-und-Nacht-Gleiche''' || [[Datei:Ekliptik.A.png|360px]] || [[Datei:Ekliptik.B.png|360px]] || [[Datei:Ekliptik.C.png|360px]]
|-
| '''Winteranfang'''&lt;/br&gt;'''Wintersonnenwende''' || [[Datei:Ekliptik.B.png|360px]] || [[Datei:Ekliptik.C.png|360px]] || [[Datei:Ekliptik.D.png|360px]]
|}

[[Datei:Orbit de Mondknoten.svg|mini|rechts|hochkant=2|Bahnellipse des Mondes mit den beiden Mondknoten.]]

Im Laufe eines '''drakonitischen Monats''' geht der Mond sowohl durch den aufsteigenden als auch durch den absteigenden Knoten (Drachenpunkte) seiner Mondbahn. Nach dem Durchqueren des aufsteigenden Knotens wird die ekliptikale Breite des Mondes positiv (nördliche ekliptikale Breite), er steigt in Bezug zur Ekliptiklinie nach Norden und bleibt entsprechend immer länger über dem Horizont. Nach dem Durchqueren des absteigenden Knotens wird die ekliptikale Breite des Mondes negativ (südliche ekliptikale Breite), er fällt in Bezug zur Ekliptiklinie nach Süden und bleibt entsprechend immer kürzer über dem Horizont. In der deutschsprachigen Schweiz gibt es für diese im Laufe eines drakonitischen Monats täglich mehr oder weniger deutlich wahrnehmbaren Änderungen der ekliptikalen Breite sogar eigene Adjektive. Das Ansteigen der ekliptikalen Breite des Mondes nach Norden wird '''obsigend''', und das Abfallen der ekliptikalen Breite des Mondes nach Süden wird '''nidsigend''' genannt. 

[[Datei:Mond-.und.Sonnenwenden.png|mini|rechts|hochkant=2|Verschiedene Mond- und Sonnenwenden auf dem südlichen Meridian im Laufe eines Jahres in Bezug zum Horizontsystem.]]

Im Laufe der Zeit pendelt der Mond immer wieder zwischen den kleinen und großen Mondwenden. Dieser Ablauf wiederholt sich nach einem vollständigen '''drakonitischen Zyklus''', also nach 18,61&amp;nbsp;Jahren, innerhalb dessen die kleinste und die größte Mondwende im zeitlichen Abstand von rund 9,3&amp;nbsp;Jahren jeweils einmal erreicht wird.

Die Deklinationen der Sonne &lt;math&gt;\delta_S&lt;/math&gt; pendeln also je nach Jahreszeit maximal um den Betrag der Schiefe der Ekliptik &lt;math&gt;\varepsilon&lt;/math&gt; um den Nullpunkt &lt;math&gt;\delta_S = 0&lt;/math&gt;, der nur zu den Tag-und-Nacht-Gleichen erreicht wird:

:&lt;math&gt;-\varepsilon \le \delta_S \le +\varepsilon&lt;/math&gt;

Die Deklinationen des Mondes &lt;math&gt;\delta_M&lt;/math&gt; pendeln zusätzlich um den Betrag der Inklination der Mondbahn &lt;math&gt;i&lt;/math&gt; (heute '''5,145&amp;nbsp;Bogengrad''') um die Werte der Deklination der Sonne &lt;math&gt;\delta_S&lt;/math&gt;:

:&lt;math&gt;-\varepsilon - i \le \delta_M \le +\varepsilon + i&lt;/math&gt;

Die Deklination und der maximale Höhenwinkel bei der Kulmination des Mondes auf dem südlichen Meridian variieren also sowohl innerhalb eines Monats durch die Inklination der Mondbahn als auch jährlich durch die Neigung der Erdachse (also die Schiefe der Ekliptik).

Die für die Azimute der Mondaufgänge &lt;math&gt;a_{A,M}&lt;/math&gt; anzuwendende Formel hängt nicht nur von der augenblicklichen Deklination des Mondes &lt;math&gt;\delta_M&lt;/math&gt;, sondern auch vom geographischen Breitengrad des Beobachters &lt;math&gt;\varphi&lt;/math&gt; ab:

:&lt;math&gt;\cos a_{A,M} = \frac {\sin \delta_M} {\cos \varphi}&lt;/math&gt;

Aus Symmetriegründen ergibt sich für die Azimute der Monduntergänge &lt;math&gt;a_{U,M}&lt;/math&gt;:

:&lt;math&gt;a_{U,M} = 360^\circ - a_{A,M} = 360^\circ - \arccos \frac {\sin \delta_M} {\cos \varphi}&lt;/math&gt;

{| class=&quot;wikitable&quot;
|+ Deklinationen des Mondes
! Ereignis !! Deklination des Mondes &lt;math&gt;\delta_M&lt;/math&gt; !! Maximaler Höhenwinkel des Mondes&lt;br/&gt;&lt;math&gt;h_{max,M}&lt;/math&gt; || Azimut des Mondaufgangs&lt;br/&gt;&lt;math&gt;a_{A,M}&lt;/math&gt; || Azimut des Monduntergangs&lt;br/&gt;&lt;math&gt;a_{U,M}&lt;/math&gt;
|-
| Kleinste Mondwende&lt;br/&gt;&lt;math&gt;\delta_S = -\varepsilon&lt;/math&gt; || &lt;math&gt;-(\varepsilon + i)&lt;/math&gt; || &lt;math&gt;(90^\circ - \varphi) - (\varepsilon + i)&lt;/math&gt; || &lt;math&gt;\arccos \frac {\sin (-\varepsilon - i)} {\cos \varphi}&lt;/math&gt; || &lt;math&gt;360^\circ - \arccos \frac {\sin (-\varepsilon - i)} {\cos \varphi}&lt;/math&gt;
|-
| Kleine Mondwende || &lt;math&gt;\delta_S - i&lt;/math&gt; || &lt;math&gt;(90^\circ - \varphi) + (\delta_S - i)&lt;/math&gt; || &lt;math&gt;\arccos \frac {\sin (\delta_S - i)} {\cos \varphi}&lt;/math&gt; || &lt;math&gt;360^\circ - \arccos \frac {\sin (\delta_S - i)} {\cos \varphi}&lt;/math&gt;
|-
| Mond im Knoten || &lt;math&gt;\delta_S&lt;/math&gt; || &lt;math&gt;(90^\circ - \varphi) + \delta_S&lt;/math&gt; || &lt;math&gt;\arccos \frac {\sin (\delta_S)} {\cos \varphi}&lt;/math&gt; || &lt;math&gt;360^\circ - \arccos \frac {\sin (\delta_S)} {\cos \varphi}&lt;/math&gt;
|-
| Große Mondwende || &lt;math&gt;\delta_S + i&lt;/math&gt; || &lt;math&gt;(90^\circ - \varphi) + (\delta_S + i)&lt;/math&gt; || &lt;math&gt;\arccos \frac {\sin (\delta_S + i)} {\cos \varphi}&lt;/math&gt; || &lt;math&gt;360^\circ - \arccos \frac {\sin (\delta_S + i)} {\cos \varphi}&lt;/math&gt;
|-
| Größte Mondwende&lt;br/&gt;&lt;math&gt;\delta_S = +\varepsilon&lt;/math&gt; || &lt;math&gt;+(\varepsilon + i)&lt;/math&gt; || &lt;math&gt;(90^\circ - \varphi) + (\varepsilon + i)&lt;/math&gt; || &lt;math&gt;\arccos \frac {\sin (\varepsilon + i)} {\cos \varphi}&lt;/math&gt; || &lt;math&gt;360^\circ - \arccos \frac {\sin (\varepsilon + i)} {\cos \varphi}&lt;/math&gt;
|}

Die Höhenwinkel des Mondes und der Sonne konnten zum Beispiel schon in der Bronzezeit mit Hilfe von '''Sonnenuhren''', '''Stabdolchen''' oder '''Kreisgrabenanlagen''' beobachtet und bestimmt werden. Im Laufe eines Jahres konnten damit die jahreszeitlichen Veränderungen der scheinbaren Sonnenbahn verfolgt werden. Durch eine langjährige Beobachtung war es dann auch möglich, die kleinsten und größten Mondwenden zu ermitteln.

Siehe hierzu auch:

* → '''[[Quadriviale_Kuriositäten/_Stabdolche|Stabdolche]]'''
* → '''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Kalenderführung#Frühgeschichtliche_Observatorien|Frühgeschichtliche Observatorien]]'''

===Vergleich der Perioden===
Die folgenden Periodendauern spielen bei Sonnen- und Mondzyklen eine besondere Rolle:

* '''Meton-Zyklus:'''
** 19&amp;nbsp;'''tropische Sonnenjahre''' = 6939,6&amp;nbsp;Tage, bestimmt durch die ekliptikale Länge der Sonne in Bezug zum Frühlingspunkt mit ihren Äquinoktien und Sonnenwenden.
** 235&amp;nbsp;'''synodische Monate''' = 6939,7&amp;nbsp;Tage, bestimmt durch die Mondphasen mit Neumonden und Vollmonden.
** 254&amp;nbsp;'''siderische Monate''' = 6939,7&amp;nbsp;Tage, bestimmt durch die ekliptikale Länge des Mondes in Bezug zum Frühlingspunkt und den Fixsternhimmel.
** 255&amp;nbsp;'''drakonitische Monate''' = 6939,1&amp;nbsp;Tage, bestimmt durch die ekliptikale Breite des Mondes beziehungsweise die auf- und absteigenden Knoten der Mondbahn.
* '''Drakonitischer Zyklus:''' 
** 249,83&amp;nbsp;'''drakonitische Monate''' = 6798,38&amp;nbsp;Tage = 18,613&amp;nbsp;tropische Sonnenjahre, bestimmt durch die ekliptikalen Längen der auf- und absteigenden Knoten der Mondbahn: Zyklus der Mondwenden und Sternbedeckungen (Nutationsperiode)
* '''Saros-Zyklus:'''
** 242&amp;nbsp;'''drakonitische Monate''' = 6585,3&amp;nbsp;Tage = 18,03&amp;nbsp;tropische Sonnenjahre (respektive 18&amp;nbsp;Jahre und 11&amp;nbsp;Tage): Zyklen der Sonnen- und Mondfinsternisse
** 223&amp;nbsp;'''synodische Monate''' = 6585,4&amp;nbsp;Tage, bestimmt durch die Mondphasen mit Neumonden und Vollmonden.

[[Datei:Meton-Zyklus.2023.4x5.png|mini|links|hochkant=4|Der 19-jährige Meton-Zyklus vom Januar&amp;nbsp;2023 bis zum Januar&amp;nbsp;2042. Die Zeit schreitet in horizontaler Richtung jeweils um einen halben Tag pro Bildpunkt voran.&lt;br/&gt;Im unteren Teil des Diagramms sind die kleinen und großen Mondwenden für die geographische Breite 52,5&amp;nbsp;Bogengrad (zum Beispiel in Berlin) dargestellt.]]
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;
[[Datei:Herbstaequinoktium.kleine.Mondwende.2033.png|mini|rechts|hochkant=1|Herbstäquinoktium (orange) und Sonnenfinsternis bei aufsteigendem (rot) Neumond am 23.&amp;nbsp;September 2033 (orangefarbene Linie), Mondfinsternis bei absteigendem (blau) Vollmond am 8.&amp;nbsp;Oktober 2033 und Wintersonnenwende (türkis) mit kleiner Mondwende bei Neumond am 21.&amp;nbsp;Dezember 2033 (grüne Linie).]]

Der '''Vollmond''' (weiß) erscheint sowohl zu Beginn der Darstellung am 6.&amp;nbsp;Januar 2023 als auch nach genau 19 Jahren am 6.&amp;nbsp;Januar 2042. Dieser Sachverhalt ergibt sich daraus, dass nach dem Durchlauf eines Meton-Zyklus eine ganzzahlige Anzahl von 235&amp;nbsp;synodischen Perioden durchlaufen wird (gleiche '''Elongation''' des Mondes). Diese Vollmonde stehen bei der gleichen ekliptikalen Länge im Sternbild Zwillinge (Gemini). Dieser Sachverhalt ergibt sich daraus, dass nach dem Durchlauf eines Meton-Zyklus eine ganzzahlige Anzahl von 254&amp;nbsp;siderischen Perioden durchlaufen wird. Gleichzeitig steht auch die Sonne nach 19&amp;nbsp;tropischen Sonnenjahren auf dem Zodiak bei der gleichen ekliptikalen Länge und somit erneut genau gegenüber vom Mond im Sternbild Schütze (Sagittarius). Da die Meton-Periode nur gut einen halben Tag länger ist als 255&amp;nbsp;drakonitische Perioden, stehen diese beiden Vollmonde bei fast der gleichen ekliptikalen Breite nördlich vom Stern Mebsuta (ε&amp;nbsp;Geminorum).

'''Große Mondwenden''' mit maximaler Höhe des Mondes und längstem Bogen über dem Horizont folgen stets dem aufsteigenden Mondknoten (rot), und '''kleine Mondwenden''' mit minimaler Höhe des Mondes und kürzestem Bogen über dem Horizont folgen stets dem absteigenden Mondknoten (blau).

[[Datei:KleinsteMondwende.23.6.2024.HDR.png|mini|hochkant=2|'''Kleinste Mondwende um die Mittsommernacht 2024''': Der Vollmond (scheinbarer Durchmesser = 31,8&amp;nbsp;Minuten) am 23.&amp;nbsp;Juni 2024 nach ein Uhr und kurz vor der oberen Kulmination auf dem südlichen Meridian von Berlin-Lankwitz (nördliche geographische Breite = 52,44&amp;nbsp;Bogengrad) aus gesehen. Die ekliptikale Breite hatte einen Minimalwert, der fast 6&amp;nbsp;Bogengrad südliche Breite betrug und somit zu einer extrem geringen maximalen Höhe über dem Horizont von nur 8,5&amp;nbsp;Bogengrad führte. Im norwegischen Trondheim (nördliche geographische Breite = 63,44&amp;nbsp;Bogengrad, also drei Breitengrade südlich vom nördlichen Polarkreis) oder im isländischen Reykjavik (nördliche geographische Breite = 64,15&amp;nbsp;Bogengrad) war in diesen Tagen weder die Mitternachtssonne noch der Vollmond zu sehen. Der helle Stern rechts oberhalb der Mondscheibe ist Nunki im Schützen (σ Sagittarius, visuell 2,7&lt;sup&gt;m&lt;/sup&gt;), unterhalb ist Asella (ζ Sagittarius, visuell 4,2&lt;sup&gt;m&lt;/sup&gt;) zu sehen.]]

Die '''größte Mondwende''' bei Vollmond tritt nur zur Wintersonnenwende und die '''kleinste Mondwende''' bei Vollmond tritt nur zur Sommersonnenwende auf. Je nach ekliptikaler Breite des Mondes schwanken die absoluten Werte für die Horizontwinkel um das doppelte der Inklination der Mondbahn, das heißt insgesamt um bis zu 10,29&amp;nbsp;Bogengrad. Die ekliptikale Breite bezieht sich auf den Erdmittelpunkt, da dieser in der Ekliptikebene liegt. Die von der Erdoberfläche aus beobachtete ekliptikale Breite des im Mittel nur zirka 383100&amp;nbsp;Kilometer entfernten Mondes hängt zusätzlich vom jeweiligen geographischen Breitengrad der Beobachtung ab. Der in Bezug auf die Ekliptik nördlichste und südlichste Punkt auf der Erdoberfläche liegen um den Erdradius von gut 6350&amp;nbsp;Kilometer oberhalb (nördlich) beziehungsweise unterhalb (südlich) der Ekliptikebene. Daraus resultiert für die beobachtete ekliptikale Breite ein zusätzlicher Winkel von knapp einem Bogengrad:

:&lt;math&gt;\Delta \beta = \arctan \frac {\pm 6350} {383100} \approx \pm 0,95^\circ&lt;/math&gt;

Die '''größte Mondwende bei Vollmond''' (weiß) tritt bei maximaler ekliptikaler Breite des Mondes um die Wintersonnenwende (türkis, siehe Dezember&amp;nbsp;2023) auf. Die '''kleinste Mondwende bei Vollmond''' (weiß) tritt bei minimaler ekliptikaler Breite des Mondes um die Sommersonnenwende (gelb, siehe Juni 2024).

Im 19-jährigen Diagramm (siehe oben) ist gut zu erkennen, wie sich die Konstellation zwischen Mondknoten (rot und blau) und Mondphasen (weiß und schwarz) nach den 19&amp;nbsp;Jahren des '''Meton-Zyklus''' wiederholt (vergleiche Januar&amp;nbsp;2023 und Januar&amp;nbsp;2042).

Der erste aufsteigende Mondknoten (rot) wird fünf Tage vor Vollmond am 2.&amp;nbsp;Januar 2023 erreicht. Nach einer vollständigen '''Saros-Periode''' von 18&amp;nbsp;Jahren und 11&amp;nbsp;Tagen, also am 12.&amp;nbsp;Januar 2041 wird fünf Tage vor Vollmond ebenfalls wieder ein aufsteigender Mondknoten erreicht.

Eine Besonderheit gibt es im März 2038: Die Tag-und-Nacht-Gleiche erfolgt bereits am 20.&amp;nbsp;März 2038 (Samstag) und der erste Frühlingsvollmond nur einige Stunden später am 21.&amp;nbsp;März 2038 (Sonntag). Grundsätzlich müsste also der darauffolgende Sonntag, nämlich der 28.&amp;nbsp;März 2038, das '''Osterdatum''' sein. In diesem Fall greift die abweichende Regel, dass erst der Vollmond nach dem 21.&amp;nbsp;März als Frühlingsvollmond zu rechnen ist, was erst am 19.&amp;nbsp;April 2038 (Montag) der Fall ist. Demzufolge ist das Osterdatum auf den 25.&amp;nbsp;April 2038 (Sonntag) festgelegt.

Eine '''Sonnenfinsternis '''tritt immer dann auf, wenn ein Neumond (weiß) zeitnah durch einen aufsteigenden (rot) oder absteigenden (blau) Mondknoten läuft. Dies ist im obigen Diagramm an den folgenden Tagen der Fall:

* 20.&amp;nbsp;April 2023, 14.&amp;nbsp;Oktober 2023, 8.&amp;nbsp;April 2024, 2.&amp;nbsp;Oktober 2024, 29.&amp;nbsp;März 2025, '''21.&amp;nbsp;September 2025''' (Herbstäquinoktium), 17.&amp;nbsp;Februar 2026, 12.&amp;nbsp;August 2026, 6.&amp;nbsp;Februar 2027, 2.&amp;nbsp;August 2027, 26.&amp;nbsp;Januar 2028, 22.&amp;nbsp;Juli 2028, 14.&amp;nbsp;Januar 2029, 12.&amp;nbsp;Juni 2029, 11.&amp;nbsp;Juli 2029, 5.&amp;nbsp;Dezember 2029, 1.&amp;nbsp;Juni 2030, 25.&amp;nbsp;November 2030, 21.&amp;nbsp;Mai 2031, 14.&amp;nbsp;November 2031, 9.&amp;nbsp;Mai 2032, 3.&amp;nbsp;November 2032, 30.&amp;nbsp;März 2033, '''23.&amp;nbsp;September 2033''' (Herbstäquinoktium), '''20.&amp;nbsp;März 2034''' (Frühlingsäquinoktium), 12.&amp;nbsp;September 2034, 9.&amp;nbsp;März 2035, 2.&amp;nbsp;September 2035, 27.&amp;nbsp;Februar 2036, 23.&amp;nbsp;Juli 2036, 21.&amp;nbsp;August 2036, 16.&amp;nbsp;Januar 2037, 13.&amp;nbsp;Juli 2037, 5.&amp;nbsp;Januar 2038, 2.&amp;nbsp;Juli 2038, 26.&amp;nbsp;Dezember 2038, '''21.&amp;nbsp;Juni 2039''' (Sommersonnenwende), 15.&amp;nbsp;Dezember 2039, 11.&amp;nbsp;Mai 2040, 4.&amp;nbsp;November 2040, 30.&amp;nbsp;April 2041, 25.&amp;nbsp;Oktober 2041

Genau neunzehn Jahre nach den ersten beiden genannten Sonnenfinsternissen im Jahr&amp;nbsp;2023 treten an den gleichen Kalendertagen erneut zwei Sonnenfinsternisse auf, nämlich am 20.&amp;nbsp;April 2042 und am 14.&amp;nbsp;Oktober 2042.

Neunzehn Jahre vor den sechs ersten aufgeführten Sonnenfinsternissen in den Jahren&amp;nbsp;2023 bis&amp;nbsp;2025 traten an fast immer den gleichen Kalendertagen ebenfalls Sonnenfinsternisse auf, nämlich am 19.&amp;nbsp;April 2004, am 14.&amp;nbsp;Oktober 2004, am 8.&amp;nbsp;April 2005, am 3.&amp;nbsp;Oktober 2005, am 29.&amp;nbsp;März 2006 und am 22.&amp;nbsp;September 2006.

Eine '''Mondfinsternis '''tritt immer dann auf, wenn ein Vollmond (weiß) zeitnah durch einen aufsteigenden (rot) oder absteigenden (blau) Mondknoten läuft. Dies ist im obigen Diagramm an den folgenden Tagen der Fall:

* 5.&amp;nbsp;Mai 2023, 28.&amp;nbsp;Oktober 2023, 25.&amp;nbsp;März 2024, 18.&amp;nbsp;September 2024, 14.&amp;nbsp;März 2025, 7.&amp;nbsp;September 2025, 3.&amp;nbsp;März 2026, 28.&amp;nbsp;August 2026, 20.&amp;nbsp;Februar 2027, 18.&amp;nbsp;Juli 2027, 17.&amp;nbsp;August 2027, 12.&amp;nbsp;Januar 2028, 6.&amp;nbsp;Juli 2028, 31.&amp;nbsp;Dezember 2028, 26.&amp;nbsp;Juni 2029, '''20.&amp;nbsp;Dezember 2029''' (Wintersonnenwende), 15.&amp;nbsp;Juni 2030, 9.&amp;nbsp;Dezember 2030, 7.&amp;nbsp;Mai 2031, 5.&amp;nbsp;Juni 2031, 30.&amp;nbsp;Oktober 2031, 25.&amp;nbsp;April 2032, 18.&amp;nbsp;Oktober 2032, 14.&amp;nbsp;April 2033, 8.&amp;nbsp;Oktober 2033, 3.&amp;nbsp;April 2034, 28.&amp;nbsp;September 2034, 22.&amp;nbsp;Februar 2035, 19.&amp;nbsp;August 2035, 11.&amp;nbsp;Februar 2036, 7.&amp;nbsp;August 2036, 31.&amp;nbsp;Januar 2037, 27.&amp;nbsp;Juli 2037, 21.&amp;nbsp;Januar 2038, '''17.&amp;nbsp;Juni 2038''' (Sommersonnenwende), 16.&amp;nbsp;Juli 2038, 11.&amp;nbsp;Dezember 2038, 6.&amp;nbsp;Juni 2039, 30.&amp;nbsp;November 2039, 26.&amp;nbsp;Mai 2040, 18.&amp;nbsp;November 2040, 16.&amp;nbsp;Mai 2041, 8.&amp;nbsp;November 2041

&lt;gallery caption=&quot;Finsternisse&quot; perrow=&quot;1&quot; widths=&quot;1024&quot; heights=&quot;470&quot;&gt;
Finsternisse.2025.png|Die Finsternisse im Jahr 2025 liegen in der Nähe der Tag-und-Nacht-Gleichen, wo mittlere Mondwenden vorliegen. Der Mond geht im Osten auf und im Westen unter.
Finsternisse.2029.png|Die Finsternisse im Jahr 2029 liegen in der Nähe der Sonnenwenden. Bei der Sonnenfinsternis im Juni kommt es bei Neumond zu einer großen Mondwende, und bei der darauffolgenden Mondfinsternis kommt es bei Vollmond zu einer kleinen Mondwende. Bei der Sonnenfinsternis im Dezember kommt es bei Neumond zu einer kleinen Mondwende, und bei der darauffolgenden Mondfinsternis kommt es bei Vollmond zu einer großen Mondwende.
&lt;/gallery&gt;

==Der Kalenderstein vom Tempel Mnajdra==
Auf Malta wurde im Hypogäum von Ħal-Saflieni beim Ort Tarxien ein annähernd kreisrunder Stein aus der Tempelperiode der Insel mit zirka sechs Zentimeter Durchmesser gefunden, der wie die Darstellung einer Vollmondscheibe aussieht.&lt;ref&gt;Daniel Cilia: [http://web.infinito.it/utenti/m/malta_mega_temples/TempleFig/%20Pres,Misc/pages/face.htm Found in a house at Hal Saflieni, stone, c.6 cm wide], The megalithic temples of Malta - the world's most ancient stone architectur, DSCF9754&lt;/ref&gt; Im maltesischen Tempel Mnajdra sind an der südlichen Küste Maltas zirka zehn Kilometer entfernt davon zwei große Kalendersteine gefunden worden, die ebenfalls aus dieser Zeit stammen.

&lt;gallery caption=&quot;Die Ruinen der Tempelanlage von Mnajdra&quot; widths=&quot;300&quot; heights=&quot;300&quot; mode=&quot;packed&quot;&gt;
Plan_der_Tempel_von_Mnajdra.png|Plan der Tempelanlage. Die beiden Kalendersteine befinden sich in der Mitte des Urtempels im Osten der Anlage (Buchstabe &quot;A&quot;), die aus dem vierten vorchristlichen Jahrtausend stammt.
Mini_Europa_Brüssel-2125_Tempel_von_Mnajdra.jpg|Modell der Tempelanlage im Park &quot;Mini-Europa&quot; in Brüssel. Die Kalendersteine befinden sich links und rechts hinter der Frauenfigur auf der rechten Seite.
Malta_-_Qrendi_-_Hagar_Qim_and_Mnajdra_Archaeological_Park_-_Mnajdra_16_ies.jpg|Darstellung der Lochreihen der beiden Kalendersteine auf einer Schautafel der archäologischen Stätte.
Mnajdra_East_Temple_1_(6799974274).jpg|Blick vom Eingang des Osttempels auf die beiden aufrechtstehenden Kalendersteine – links der westliche und rechts der östliche Kalenderstein.
Mnajdra_Temple_-_Chris_Brown.jpg|Blick über die Kalendersteine – links der östliche und rechts der westliche Kalenderstein, den Eingang des Osttempels und die Südküste Maltas auf das Mittelmeer mit der vorgelagerten Insel Filfla.
&lt;/gallery&gt;

Auf dem östlichen Kalenderstein gibt es mehrere Lochreihen, deren Lochzahlen alle mit lunaren und solaren Kalendern in Zusammenhang gebracht werden können. In der heute zusammengestellten Anordnung der Steine können nicht alle Löcher gebohrt worden sein, da diese teilweise von anderen Steinen verdeckt sind. Die Bohrungen sind heute in horizontaler Richtung ausgerichtet, wurden damals vermutlich unter Ausnutzung der Gravitation senkrecht nach unten auf dem noch liegenden Stein ausgeführt. In dieser Ausrichtung des Steins wäre es auch leicht möglich gewesen, für Markierungs- oder Zählzwecke zum Beispiel kugelförmige Gegenstände in die Löcher zu legen. Steckkalender aus Stein mit Bohrungen (bei den Griechen hießen sie '''Parapegmata''') waren im Altertum an vielen Orten in Verwendung.

Am Kopf des Steins gibt es mehrere hundert, flächenhaft angeordnete Löcher, die eventuell für die einzelnen Monate oder Jahre einer langfristigen Beobachtung stehen. Darunter tauchen rechtsbündig sieben horizontale Lochreihen auf, die in der Skizze mit den Buchstaben A bis G gekennzeichnet sind, wobei die beiden Teilreihengruppen B1 und B2 sowie C1, C2 und C3 zusammengefasst betrachtet werden:

[[Datei:Kalenderstein.Mnajdra.labelled.png|mini|links|hochkant=3|Skizze der Lochreihen auf dem Kalenderstein von Mnajdra nach Ventura und Hoskin.&lt;ref name=&quot;Ventura&quot;&gt;Frank Ventura, Michael Hoskin: [[doi:10.1007/978-1-4614-6141-8_133|Temples of Malta]], in: Clive Ruggles (Herausgeber), ''Handbook of Archaeoastronomy and Ethnoastronomy'', 7. Juli 2014, Seiten 1421-1430, Springer, New York, ISBN 978-1-4614-6140-1&lt;/ref&gt;]]

{| class=&quot;wikitable&quot;
|+ Lochreihen auf dem östlichen Kalenderstein vom Tempel Mnajdra auf Malta
!title=&quot;Reihe&quot;| Reihe
!title=&quot;Anzahl der Löcher&quot;| Anzahl der Löcher
!title=&quot;Mögliche Verwendung&quot;| Mögliche Verwendung
|-
| A || 19 || Für die jeweilige Goldene Zahl jedes Sonnenjahres innerhalb des 19-jährigen '''Meton-Zyklus''' (235&amp;nbsp;synodische, 255&amp;nbsp;drakonitische, 254&amp;nbsp;siderische Monate beziehungsweise 6940&amp;nbsp;Tage).&lt;br/&gt;Nach einem Sonnenjahr hat die Sonne wieder die gleiche ekliptikalen Länge. Nach Ablauf der gesamten Meton-Periode hat der Mond wieder die gleiche Mondphase '''und''' die gleiche ekliptikalen Breite '''und''' die gleiche ekliptikalen Länge (zum Beispiel im Goldenen Tor der Ekliptik oder im Frühlingspunkt).
|-
| rowspan=2 | B || B&lt;sub&gt;1&lt;/sub&gt;: 13 (links) || rowspan=2 | In Summe 29, für die Anzahl der vollständigen Tage in einem '''synodischen Monat''' (29,5&amp;nbsp;Tage). Nach dieser Zeit hat der Mond wieder die gleiche Mondphase erreicht.&lt;br/&gt;Vom Altlicht des Mondes bis zum Vollmond sind es 16&amp;nbsp;Tage, und danach sind es 13&amp;nbsp;Tage bis zum nächsten Altlicht.&lt;br/&gt;Nachdem die Doppelreihe vervollständigt wurde, gibt es dafür einen Übertrag in die Reihe&amp;nbsp;E und wenn diese bereits voll ist, für das nächste beginnende Jahr mit der nächstfolgenden '''Goldenen Zahl''' einen Übertrag in die Reihe&amp;nbsp;A.
|-
| B&lt;sub&gt;2&lt;/sub&gt;: 16 (rechts darunter)
|-
| rowspan=3 | C || C&lt;sub&gt;1&lt;/sub&gt;: 3 (rechts oben) || rowspan=2 | Für die sieben vollständigen Tage eines '''Mondviertels''' (≈7,4&amp;nbsp;Tage) respektive einer '''Woche'''.&lt;br/&gt;Wenn diese Doppelreihe gefüllt ist, gibt es für die Vervollständigung einer neuen Woche einen Übertrag in die Reihe&amp;nbsp;G für die Wochen in einem Jahr.&lt;br/&gt;Alternativ könnten hier jeweils die drei Monate in den vier Jahreszeiten markiert und gezählt worden sein.&lt;br/&gt;Ein weiterer Zusammenhang besteht eventuell mit der Tatsache, dass in 19 Jahren (siehe Reihe A) sieben synodische Schaltmonate erforderlich sind, um in einem lunisolaren Kalender den Lauf von Sonne und Mond bis auf wenige Stunden genau zu synchronisieren (siehe hierzu auch''' [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|Plejaden-Schaltregeln]]''').
|-
| C&lt;sub&gt;2&lt;/sub&gt;: 4 (rechts unten)
|-
| C&lt;sub&gt;3&lt;/sub&gt;: 3 (links) || Für die drei nach Neumond '''vollendeten Mondviertel''' innerhalb eines laufenden synodischen Monats.&lt;/br&gt;Beim Erreichen eines Neumonds, eines abnehmenden Halbmonds, eines Vollmonds oder eines abnehmenden Halbmonds gibt es jeweils einen Übertrag in die Reihe&amp;nbsp;D oder in die Reihe&amp;nbsp;F (siehe unten).
|-
| D || 25 || Für die 25&amp;nbsp;'''vollendeten Mondviertel''' in der ersten Hälfte eines Sonnenjahres, oder entweder für alle '''zunehmenden Mondviertel''' (wenn der Mond zu Beginn des Jahres zunehmend war) oder für alle '''abnehmenden Mondviertel''' (wenn der Mond zu Beginn des Jahres abnehmend war) eines Sonnenjahres (vergleiche Reihe&amp;nbsp;F).
|-
| E || 11 || Nachdem die Doppelreihe B vollständig durchlaufen wurde, gibt es einen Übertrag in diese Reihe. Diese elf Mulden stehen dann für '''überzähligen Tage''' in einem Sonnenjahr (365,2&amp;nbsp;Tage) im Vergleich zu zwölf synodischen Monaten (354,4&amp;nbsp;Tage). Wenn diese Reihe bereits voll ist, gibt es für das nächste beginnende Jahr mit der nächstfolgenden '''Goldenen Zahl''' einen Übertrag in die Reihe&amp;nbsp;A.
|-
| F || 24 + 1 = 25 || Für die 24 bis 25 '''vollendeten Mondviertel''' in der zweiten Hälfte eines Sonnenjahres, oder entweder für alle '''abnehmenden Mondviertel''' (wenn der Mond zu Beginn des Jahres zunehmend war) oder für alle '''zunehmenden Mondviertel''' (wenn der Mond zu Beginn des Jahres abnehmend war) eines Sonnenjahres (vergleiche Reihe&amp;nbsp;D). Das 25.&amp;nbsp;Loch ist etwas abgesetzt, da es für ein am Ende des Jahres eingeschaltetes 50.&amp;nbsp;Mondviertel (Dauer = 7,38265&amp;nbsp;Tage) steht, das nur in ungefähr jedem zweiten Sonnenjahr auftritt:&lt;br/&gt;
:49 x 7,38265 Tage ≈ 361,75 Tage beziehungsweise 50 x 7,38265 Tage ≈ 369,13 Tage&lt;br/&gt;
:365,242 Tage - 361,75 Tage ≈ 3,5 Tage beziehungsweise 365,242 Tage - 369,13 Tage ≈ -3,9 Tage
|-
| G || 53 || Für die begonnenen 53 '''Siebentagewochen''' in einem Sonnenjahr (Dauer = 365,242&amp;nbsp;Tage) beziehungsweise von einem heliakischen Auf- oder akronychischen Untergang der Plejaden zum nächsten.
|}

[[Datei:Altlicht.16.9.2020.P1079087.jpg|mini|rechts|Über dem östlichen Horizont beim Morgenletzt gerade noch sichtbares Altlicht des abnehmenden Mondes 33 Stunden vor Neumond mit der vom Erdschein beleuchteten Nachtseite des Mondes. Die Aufnahme entstand kurz vor Herbstbeginn, als die Ekliptik morgens fast senkrecht auf dem Horizont stand.]]

Zu der Doppelreihe&amp;nbsp;B sei angemerkt, dass auch im altägyptischen Mondkalender, der im Neolithikum in Verwendung war, der Monat nicht mit dem unsichtbaren Neumond, sondern mit dem gerade noch sichtbaren Altlicht des Morgenletztes des Mondes begann, also gut einen Tag vor Neumond.&lt;ref&gt;Joachim Friedrich Quack: [https://core.ac.uk/download/pdf/35120251.pdf Zwischen Sonne und Mond - Zeitrechnung im Alten Ägypten], Seite 38, in: Harry Falk (Herausgeber), ''Vom Herrscher zur Dynastie. Zum Wesen kontinuierlicher Zeitrechnung in Antike und Gegenwart'', Bremen 2002&lt;/ref&gt; Die beiden letzten Löcher sind etwas nach links abgesetzt, was mit folgendem Sachverhalt im Einklang steht: zwei Tage vor dem Ende einer synodischen Periode, also schon nach gut 27&amp;nbsp;Tagen, ist ein siderischer Monat vorüber, nach welchem der Mond die gleiche ekliptikale Länge erreicht hat. Das heißt bereits nach gut 27&amp;nbsp;Tagen steht der Mond zum Beispiel wieder im Goldenen Tor der Ekliptik, bevor er erst nach gut 29&amp;nbsp;Tagen erneut sein Altlicht erreicht (gut einen Tag vor Neumond). Die Sonne ist innerhalb des synodischen Monats durch die Bewegung der Erde um die Sonne gegenüber dem Fixsternhimmel um knapp 30&amp;nbsp;Bogengrad weiter nach links gezogen.

Die 25&amp;nbsp;Wochen des abnehmenden Mondes werden zum Beispiel auch im 79.&amp;nbsp;Kapitel des ungefähr 2000&amp;nbsp;Jahre alten {{w|Äthiopisches Henochbuch|äthiopischen Henochbuches}} erwähnt.&lt;ref&gt;Siehe auch {{s|Henochbuch_(oder_Erster_Henoch)#Der_dritte_Teil_72–82_Das_astronomische_Buch|Wikisource, Henochbuch, Teil 3, Kapitel 71 bis 82}}&lt;/ref&gt; Alternativ könnten die 50&amp;nbsp;Löcher in Reihen&amp;nbsp;D und F eventuell auch für die 50 vollständigen Siebentagewochen (350&amp;nbsp;Tage) innerhalb von zwölf synodischen Perioden stehen, die eine Dauer von 50,6&amp;nbsp;Wochen beziehungsweise 354,4&amp;nbsp;Tagen haben.

Zur Zahl Elf (Reihe&amp;nbsp;E) ist noch festzuhalten, dass die Erde innerhalb eines siderischen Jahres des Planeten Jupiter (zwölf Erdenjahre) elf Mal mit diesem in Opposition steht. Zu diesen Zeitpunkten ist der Abstand zwischen Erde und Jupiter am geringsten, der Jupiter hat steht in seinem größten Glanz und er kulminiert um Mitternacht auf dem südlichen Meridian.

[[Datei:Mnajdra East Temple 2 (6946102161).jpg|rechts|mini|Detail des westlichen Kalendersteins aus dem Osttempel von Mnajdra.]]

Auch auf einem weiteren, sogenannten westlichen und heute ebenfalls aufgerichteten Stein der Tempelanlage sind mehrere Lochreihen zu sehen, die aus 16, 12, 19, 7, 30, 31, 32, 35, 37, 12 und 13 Löchern bestehen.&lt;ref&gt;David Humiston Kelley, Eugene Frank Milone: ''Exploring Ancient Skies: A Survey of Ancient and Cultural Astronomy'', Part II ''Astronomy in Cultures'', 6 ''Paleolithic and Neolithic Cultures'', 6.2 ''Megalithic Cultures'', 6.2.18 ''Mediterranean and North African Megalithic Sites'', 6.2.18.1 ''Malta'', pages 201 and 202, Springer, 2011, ISBN 9781441976246&lt;/ref&gt; Einige dieser Zahlen tauchen auch im Zusammenhang mit dem östlichen Stein auf oder sind ebenfalls leicht mit lunaren oder solaren Kalendertagen in Verbindung zu bringen:

* 16: Anzahl der Tage vom Altlicht bis zum Vollmond.
* 12: Anzahl der vollständigen Monate pro Jahr.
* 19: Anzahl der tropischen Jahre pro Meton-Periode.
* 7: Anzahl der vollständigen Tage pro Mondviertel respektive der Tage pro Woche.
* 30: aufgerundete Anzahl der Tage pro synodische Periode respektive der Tage pro Monat.

→ In Bezug auf die Bedeutung von bestimmten Zahlen in der Astronomie siehe auch '''[[Quadriviale Kuriositäten‎/ Zahlen|Exkurs „Zahlen“]]'''.
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

==Malereien in der Höhle von Magura==
In der schon im Neolithikum genutzten Magura-Höhle im Nordwesten des heutigen Bulgariens gibt es nicht nur eine sehr alte bildliche Darstellung eines Schöpfungsmythos, sondern ebenfalls Hinweise darauf, dass verschiedene Mondzyklen bekannt waren. Unter den Darstellungen befindet sich insbesondere eine Reihe von Strichen, mit denen die 16&amp;nbsp;Tage vom Altlicht des Mondes bis zu Vollmond gezählt worden sein können.

→ Weitere Erläuterungen finden sich im '''[[Die_Höhlenmalerei_in_der_Magura-Höhle|Wikibook „Die Höhlenmalerei in der Magura-Höhle“]]'''.

[[Datei:Magura.Altlicht.Vollmond.png|links|mini|hochkant=4|Erste Hälfte des synodischen Monats in einer Darstellung der Höhlenmalerei von Magura. Rechts ist die schmale, liegende Mondsichel des Altlichts beim Morgenletzt zu sehen. Ein bis zwei Tage später ist Neumond, danach nimmt der Mond wieder zu, und nach insgesamt sechzehn Tagen wird der Vollmond erreicht (links).]]
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

== Kontrastverhältnisse bei aschgrauem Mondlicht ==
[[Datei:Aschgraues.Mondlicht.P1162513.jpg|mini|hochkant=2|Die vom Erdschein beleuchtete Nachtseite des Mondes wird neben der schmalen Mondsichel (11&amp;nbsp;Prozent, Mondalter = 3,3&amp;nbsp;Tage) mit ''aschgrauem Mondlicht'' sichtbar. Aufnahme über dem westlichen Abendhimmel kurz nach dem Äquinoktium im Frühjahr bei besonders steiler Ekliptik von Berlin aus gesehen. Links der Stern Omikron Arietis (37 Ari, 6,2&lt;sup&gt;m&lt;/sup&gt;) im Sternbild Widder.&lt;br/&gt;&lt;br/&gt;
Mit bloßen Augen ist das aschgraue Licht im Mondschatten nur unter sehr guten atmosphärischen Bedingungen und mit voller menschlicher Sehkraft gerade noch erkennbar. Der Mond hat nur einen Winkeldurchmesser von 0,5 Bogengrad, was bei ausgestrecktem Arm nur ungefähr einem Viertel der Breite eines Fingers entspricht. Die hier gezeigte Aufnahme ist sehr hell belichtet, so dass die Kontraste im Mondschatten einfacher wahrzunehmen sind als in der Natur:
[[Datei:Aschgraues.Mondlicht.P1162513.jpg|90px|zentriert]]
]]

Das '''aschgraue Mondlicht''' kann wenige Tage vor und nach Neumond im Schattenbereich des Mondes beobachtet werden, wenn die Sonne unter dem Horizont steht. Der Schattenbereich wird hierbei durch den '''Erdschein''' beleuchtet und hebt sich deutlich sichtbar vom Himmel ab, der den Mond umgibt. Der Erdschein hängt vom Albedo der vom direkten Sonnenlicht getroffenen Erde ab und kann insbesondere durch den Anteil an Wolken in der Atmosphäre sowie an Eis- und Schneeflächen auf der Erdoberfläche schwanken.

=== Historische Beobachtungen ===
Bereits die Babylonier haben im sechsten vorchristlichen Jahrhundert diesen visuellen Effekt in bildlichen Darstellungen auf Steinreliefs mit dem König Nabonid vor der Mondsichel mit aschgrauem Licht festgehalten:&lt;ref&gt;Friedhelm Pedde: ''[https://wfs.berlin/wp-content/uploads/2021/09/BROplanet-12-okt2021ff_www.pdf Götter und Planeten im Alten Orient - Sin und der Mond]'', Mitteilungen, Ausgabe 12, Seite 6 und 7, Oktober 2021, Wilhelm-Foerster-Sternwarte e.V. / Zeiss-Planetarium am Insulaner&lt;/ref&gt;

&lt;gallery caption=&quot;&quot; mode=&quot;packed&quot; widths=&quot;600&quot; heights=&quot;400&quot;&gt;
Urfa museum King Nabonid embossed inscription Iron age - 5026.jpg|Darstellung des letzten Königs des Neubabylonischen Reiches, Nabonid, vor der Mondsichel mit aschgrauem Mondlicht am Kopf einer babylonischen Stele aus Harran im Archäologischen Museum Şanlıurfa in der Türkei aus dem sechsten vorchristlichen Jahrhundert.
Nabonidus.jpg|Darstellung des letzten Königs des Neubabylonischen Reiches, Nabonid, vor der Mondsichel mit aschgrauem Mondlicht am Kopf einer babylonischen Stele im Britischen Museum.
Voynich.68r.Mondsichel.Erdschein.png|Darstellung der Mondsichel mit einem Gesicht im Schattenbereich des Mondes im astronomischen Abschnitt des Voynich-Manuskripts aus dem 15.&amp;nbsp;Jahrhundert.
Caspar David Friedrich - Zwei Männer in Betrachtung des Mondes.jpg|Zwei Männer am Abend bei der Betrachtung des Neulichts von Caspar David Friedrich (1819/1820), Öl auf Leinwand, Albertinum, Dresden. Eine in dieser Darstellung ähnliche Konstellation zwischen einer solchen Mondsichel und dem Planeten Jupiter fand am Abend des 28.&amp;nbsp;Märzes 1811 im Sternbild Stier (Taurus) statt. Eine Woche nach der Tag-und-Nacht-Gleiche des Frühjahrs stand der Mond wie im Bild dargestellt mit stark geneigter Sichel etwas tiefer als der Jupiter über dem westlichen Horizont.
Moon - Artemis II - April 6 2026 (55193552739).jpg|Die Aufnahme der Artemis-II-Besatzung während ihres Mondvorbeiflugs am 6.&amp;nbsp;April 2026 zeigt eine Sonnenfinsternis. Am linken Rand der Mondscheibe ist das schwache Leuchten des aschgrauen Mondlichts zu erkennen, das vom Erdschein der links vom Mond befindlichen Erde hervorgerufen wurde.
&lt;/gallery&gt;

=== Bestimmung der Kontraste ===
[[Datei:Altlicht.Mond.P1116624.jpg|mini|rechts|hochkant=2|Altlicht des Mondes am 3.&amp;nbsp;November&amp;nbsp;2021 mit aschgrauem Licht im Schattenbereich des Mondes von Berlin aus gesehen.]]

Das nebenstehende Bild des Altlichts (Mondalter 27,7 von 29,5 Tagen) im Sternbild Jungfrau wurde am 3.&amp;nbsp;November&amp;nbsp;2021 um 7:05&amp;nbsp;Uhr morgens mit einem hochwertigen Teleobjektiv mit guter Kontrastübertragung über dem ostsüdöstlichen Horizont (Azimut 122&amp;nbsp;Bogengrad) in Berlin aufgenom­men. Die Sonne stand zum Zeitpunkt der Aufnahme noch gut ein Bogengrad unter dem Hori­zont, der Mond hatte eine nördliche ekliptikale Breite von gut 3&amp;nbsp;Bogengrad und eine Elongation von 22&amp;nbsp;Bogengrad, so dass er bei wolkenlosem Himmel und bei einer Höhe von 17,5&amp;nbsp;Bogengrad über dem Horizont gut zu beobachten war. Die Mondscheibe war mit bloßem Auge vollständig sichtbar und war zu 3,7&amp;nbsp;Prozent vom direkten Sonnenlicht beleuchtet.

Die aufgenommenen Rohdaten wurden für diese Auswertung mit einer Software mit mög­lichst neutralen Einstellungen zu einer Schwarz-Weiß-Aufnahme entwickelt (Kontrast = 1, Gamma = 1, Farbtemperatur = 4100&amp;nbsp;Kelvin, Farbsättigung = 0). Anhand der Bilddaten können die Luminanzwerte (Helligkeiten) im Bild bestimmt werden, um aus beliebigen paarweisen Luminanzwerten den jeweiligen Kontrast zu berechnen. Der '''Michelson-Kontrast''' &lt;math&gt;M&lt;/math&gt; (auch '''Modulation'''), der sich aus zwei benachbarten Luminanzwerten &lt;math&gt;L_2&lt;/math&gt; und &lt;math&gt;L_1&lt;/math&gt; ergibt (Bedingung: &lt;math&gt;L_2 \ge L_1 \ge 0&lt;/math&gt;), liegt immer zwischen 0 (&lt;math&gt;L_2 = L_1&lt;/math&gt;, also kein Kontrast) und 1 beziehungsweise 100&amp;nbsp;Prozent (&lt;math&gt;L_1 = 0&lt;/math&gt;, also maxi­maler Kontrast):

:&lt;math&gt;M = \frac {L_2 - L_1} {L_2 + L_1}&lt;/math&gt;

→ Siehe auch [[Digitale_bildgebende_Verfahren:_Grundlagen#Modulation|Wikibook '''Digitale bildgebende Verfahren''', Kapitel '''Grundlagen''', Abschnitt '''Modulation''']].

Die Sichel ist in der ausgewerteten Aufnahme nicht überbelichtet, hat im Scheitel einen mittleren Luminanzwert von:

:&lt;math&gt;L_{Sichel} = 236&lt;/math&gt;

Der den Mond umgebende Himmel hat durch das vorhandene Streulicht in der Troposphäre einen mittleren Luminanzwert von:

:&lt;math&gt;L_{Himmel} = 15&lt;/math&gt;

Daraus resultiert ein entsprechend hoher Michelson-Kontrast &lt;math&gt;M&lt;/math&gt;:

:&lt;math&gt;M_{Sichel,Himmel} = \frac {L_{Sichel} - L_{Himmel}} {L_{Sichel} + L_{Himmel}} = \frac {236 - 15} {236 + 15} = \frac {221} {251} = 0,88&lt;/math&gt;

Im aschgrauen Licht in der Schattenseite des abnehmenden Mondes (dessen gesamte scheinbare Helligkeit beträgt bei der in der Abbildung sichtbaren Mondphase übrigens ungefähr -3&lt;sup&gt;m&lt;/sup&gt;), die vom Erdschein beleuchtet wird, ergibt sich für die etwas variierende Reflektivität der Mondoberfläche ein mittlerer Luminanzwert von:

:&lt;math&gt;L_{Schatten} = 24,5&lt;/math&gt;

Im Vergleich zur hellen Mondsichel ergibt sich daraus ein etwas geringerer Kontrast zwischen Mondsichel und Mondschatten als zwischen Mondsichel und Nachthimmel:

:&lt;math&gt;M_{Sichel,Schatten} = \frac {L_{Sichel} - L_{Schatten}} {L_{Sichel} + L_{Schatten}} = \frac {236 - 24,5} {236 + 24,5} = \frac {211,5} {260,5} = 0,81&lt;/math&gt;

Die Standardabweichung beträgt in der Schattenseite des abnehmenden Mondes:

:&lt;math&gt;L_{Abweichung} = 2,5&lt;/math&gt;.

Innerhalb der sichtbaren Schattenseite des Mondes resultiert aus den dort mit einer Standardabweichung um den Mittelwert herum auftretenden Luminanzwerten für das aschgraue Licht ein Kontrast von nur 10&amp;nbsp;Prozent:

:&lt;math&gt;M_{Schatten} = \frac {(L_{Schatten} + L_{Abweichung}) - (L_{Schatten} - L_{Abweichung})} {(L_{Schatten} + L_{Abweichung}) + (L_{Schatten} - L_{Abweichung})} = \frac {L_{Abweichung}} {L_{Schatten}}= \frac {2,5} {24,5} = 0,10&lt;/math&gt;

Dieser Kontrastwert ergibt sich im Übrigen im gleichen Maße auch auf der von der Sonne voll beleuchteten und dann jedoch insgesamt erheblich helleren Oberfläche des Vollmonds (die scheinbare Helligkeit beträgt dann ungefähr -13&lt;sup&gt;m&lt;/sup&gt;).

:'''Anmerkung''': ''Die Sinnhaftigkeit der Kontrastbestimmung mit der Standardabweichung begründet sich in der Tatsache, dass eine perfekte schwarz-weiße Kante mit einem maximalen Luminanzwert &lt;math&gt;L_{max}&lt;/math&gt; im hellen Bereich und einem Luminanzwert von Null im dunklen Bereich eine Modulation &lt;math&gt;M&lt;/math&gt; von eins hat, sofern die weiße und die schwarze Teilfläche gleich groß sind und jeweils &lt;math&gt;\frac {n} {2}&lt;/math&gt; Messwerte beinhalten. Sowohl der Mittelwert aller &lt;math&gt;n&lt;/math&gt; Luminanzwerte als auch die Standardabweichung aller &lt;math&gt;n&lt;/math&gt; Luminanzwerte sind dann beide genau halb so groß wie der maximale Luminanzwert:''

::&lt;math&gt;L_{Mittelwert} = \sum_{i=1}^n L_{i} = \sum_{i=1}^{\frac {n} {2}} 0 + \sum_{i=1}^{\frac {n} {2}} L_{max} = \frac {L_{max}} {2}&lt;/math&gt; 
::&lt;math&gt;L_{Standardabweichung} = \sqrt {\frac {\sum_{i=1}^n (L_{i} - L_{Mittelwert})^2} {n}} = \sqrt {\frac {\sum_{i=1}^n \left( \frac {L_{max}} {2} \right)^2} {n}} = \sqrt {\frac {n \cdot \left( \frac {L_{max}} {2} \right)^2} {n}} = \frac {L_{max}} {2}&lt;/math&gt;

:''Der Mittelwert zuzüglich der Standardabweichung entspricht dann dem maximalen Luminanzwert:''

::&lt;math&gt;L_{Mittelwert} + L_{Standardabweichung} = \frac {L_{max}} {2} + \frac {L_{max}} {2} = L_{max}&lt;/math&gt;

:''Und der Mittelwert abzüglich der Standardabweichung hat dann den Wert Null:''

::&lt;math&gt;L_{Mittelwert} - L_{Standardabweichung} = \frac {L_{max}} {2} - \frac {L_{max}} {2} = 0&lt;/math&gt;

:''Der auf diesem Weg bestimmte Kontrast stimmt mit dem oben genannten Kontrast an der Kante überein:''

::&lt;math&gt;M = \frac {L_{max} - 0} {L_{max} + 0} = \frac {L_{max}} {L_{max}} = 1&lt;/math&gt;

Schließlich kann auch noch der Kontrast an der Außenkante der nur vom Erdschein beleuch­teten Mondscheibe bestimmt werden, also zwischen aschgrauem Mondlicht und Himmel:

:&lt;math&gt;M_{Schatten,Himmel} = \frac {L_{Schatten} - L_{Himmel}} {L_{Schatten} + L_{Himmel}} = \frac {24,5 - 15} {24,5 + 15} = \frac {9,5} {39,5} = 0,24&lt;/math&gt;

Dieser Kontrast ist also deutlich höher als der innerhalb des Mondschattenbereichs. Die Helligkeit wechselt an der Kante der Mondscheibe zudem schlagartig und ist deswegen besser wahrnehmbar als die Helligkeitsunterschiede innerhalb des Schattenbereiches, wie im Folgenden ausgeführt wird.

=== Wahrnehmungsphysiologie ===
[[Datei:CSF.against.angular.frequency.in.cycles.per.degree.png|mini|rechts|hochkant=2|Kontrastempfindlichkeitsfunktion (englisch: Contrast Sensitivity Function, CSF) des menschlichen Auges über der Ortsfrequenz &lt;math&gt;f_a&lt;/math&gt; in Linienpaaren pro Grad.]]

Strukturen, bei denen sich die Helligkeit innerhalb eines achtel Bogengrades (7,5&amp;nbsp;Bogen­minuten) ändert, werden von einem gesunden menschlichen Auge nahezu perfekt auf die Netzhaut übertragen und sind deshalb am besten wahrzunehmen. Weichere Strukturen mit sich langsamer und kontinuierlich ändernder Helligkeit oder kleinere Strukturen sind bei gleichem Objektkontrast schwieriger zu erkennen. Ob ein bestimmter Objektkontrast mit bloßem Auge wahrgenommen werden kann, kann mit Hilfe der Kontrastempfindlichkeits­funktion (Contrast Sensitivity Function (CSF)) des menschlichen Auges ermittelt werden, bei der die Kontrastübertragung von einem Objekt auf die Netzhaut des Auges über der Ortsfrequenz in Linienpaaren pro Bogengrad angegeben ist:

→ Siehe auch [[Digitale_bildgebende_Verfahren:_Grundlagen#Kontrastempfindlichkeitsfunktion|Wikibook '''Digitale bildgebende Verfahren''', Kapitel '''Grundlagen''', Abschnitt '''Kontrastempfindlichkeitsfunktion''']].

[[Datei:CSF.UHD.png|mini|rechts|hochkant=2|Zur Kontrastempfindlichkeitsfunktion des menschlichen Auges mit den Ortsfrequenzen von 2&amp;nbsp;sinusmodulierten Linienpaaren pro Bildbreite (linke Bildhälfte) bis hin zu 1024&amp;nbsp;Linienpaaren pro Bildbreite (rechts am Bildrand), Bildgröße 3860&amp;nbsp;mal 2160&amp;nbsp;Bildpunkte (16:9) mit maximalem Kontrast unten, ohne Kontrast oben.]]

Das nebenstehende Diagramm und die darunter befindliche unfarbige Graphik mit den sinusförmigen Helligkeitsmodulationen visualisieren dies. Von links nach rechts wächst die Ortsfrequenz ausgehend von zwei Linienpaaren pro Bildbreite immer weiter, und der Kontrast ändert sich in vertikaler Richtung kontinuierlich zwischen den Extremwerten 0&amp;nbsp;und&amp;nbsp;1. Bei großen und sehr kleinen Ortsfrequenzen sind geringe Kontraste nicht so gut zu erkennen wie im mittleren Bereich. Die maximale Empfindlichkeit wird bei acht Linienpaaren pro Bogengrad erreicht und hängt bei einem gegebenen Objekt demzufolge vom Betrachtungsabstand ab.

Das Auge kann nach dieser Kontrastempfindlichkeitsfunktion innerhalb eines Bogengrades maximal bis zu 80&amp;nbsp;Linien mit maximalem Objektkontrast (also 40&amp;nbsp;Linienpaare mit dem Kontrast&amp;nbsp;1) wahrnehmen. In diesem Fall liegt der wahrgenommene Kontrast zwischen den benachbarten Linien bei ungefähr 5&amp;nbsp;Prozent. Bei 120&amp;nbsp;Linien mit maximalem Objektkontrast (also 60&amp;nbsp;Linienpaare mit dem Kontrast&amp;nbsp;1) sinkt der wahrgenommene Kontrast auf unter ein Prozent und ist somit praktisch nicht mehr wahrnehmbar. Wegen des scheinbaren Winkeldurchmessers der Mondscheibe von 0,5&amp;nbsp;Bogengrad, kann das Auge innerhalb des Monddurchmessers also maximal 20&amp;nbsp;Linienpaare beziehungsweise 40&amp;nbsp;Linien unterscheiden. Insbesondere an der scharfen Kante der Mondscheibe ist eine ins Auge nahezu verlustfrei übertragene Ortfrequenz von acht Linienpaaren pro Bogengrad stark vertreten, so dass der in der obigen Aufnahme des Mondes vorhandene Objektkontrast von 24&amp;nbsp;Prozent zwischen Mondschatten und Himmel (siehe oben) gut wahrgenommen werden kann.

Etwas schwieriger gestaltet sich dies innerhalb des Schattenbereichs des Mondes. In der obigen Aufnah­me tauchen die stärksten Kontraste entlang einer Linie von oben nach unten auf, wo die helleren Mondebenen mit den Kratern Copernicus und Tycho durch die dunkleren Maria Imbrium und Nubium unterbrochen werden. Daraus resultiert eine Ortsfrequenz mit fünf Linienpaaren pro Bogengrad, wo die Kontrastempfindlichkeitsfunktion ebenfalls einen recht hohen Wert von 0,9&amp;nbsp;beziehungsweise 90&amp;nbsp;Prozent erreicht. Dies schwächt den auf der Mond­oberfläche vorhandenen Objektkontrast von 10&amp;nbsp;Prozent im vom Auge auf die Netzhaut übertragenen Bildkontrast nur geringfügig ab.

Aus diesen Überlegungen resultiert, dass die im aschgrauen Licht des Mondes wahrnehmba­ren Kontraste knapp 10 Prozent betragen. Diese sind zwar geringer als der Kontrast von 24&amp;nbsp;Prozent zwischen dem aschgrauen Mondlicht und dem den Mond umgebenden Himmel, sie liegen allerdings noch in einem wahrnehmbaren Bereich. Somit ist erwiesen, dass ein gesundes Auge unter idealen Beobachtungsbedingungen auch völlig ohne optische Hilfsmittel die Helligkeitsunterschiede und Strukturen im nur durch den Erdschein erhellten Schattenbereich des Mondes erkennen kann.

Es gibt jedoch zahlreiche Faktoren, die den wahrnehmbaren Kontrast deutlich herabsetzen oder die Möglichkeit der Wahrnehmung verhindern können. Je älter ein Mensch wird, desto mehr Streulicht wird durch kleinste Verletzungen beziehungsweise Narben in der Hornhaut oder in der Linse des Auges erzeugt. Dieses Streulicht erzeugt einen mehr oder weniger gleichmäßigen Lichtschleier, der auch die dunklen Stellen auf der Netzhaut beleuchtet. Dies führt in jedem Fall zu einer Herabsetzung des wahrnehmbaren Kontrastes und verhindert somit das Erkennen von schwachen Kontrasten.

=== Begrenzende Einflüsse ===
Aber auch in der Natur gibt es viele begrenzende Faktoren. Hierzu gehört das natürliche Streulicht durch die Sonne in der Troposphäre, wenn diese zu dicht am Mond oder zu dicht unter dem Horizont oder gar über dem Horizont steht. In bewohnten Gegenden kommt als großer Störfaktor noch die Lichtverschmutzung hinzu. Ferner wird der Objektkontrast durch atmosphärische Störungen vermindert. Diese ergeben sich zum einen durch Dunst, Nebel oder Staub in der Atmosphäre, und zum anderen aus den langen Wegstrecken, die das Licht bei einer Beobachtung eines Himmelsobjekts durch die Troposphäre zurücklegen muss, wenn dieses sehr dicht über dem Horizont steht. Hierbei wird das den Beobachter erreichende Licht nicht nur abgeschwächt ('''Extinktion'''), sondern auch durch das Licht aller möglichen anderen Lichtquellen angereichert, das an den Luftmolekülen gestreut oder durch Mikroturbulenzen abgelenkt wurde, so dass sich die minimal vorhandene Helligkeit vergrößert und der Kontrast somit verringert. In bewohnten Regionen ist zudem mit erheblicher Lichtverschmutzung durch künstliche Lichtquellen zu rechnen.

Auf der anderen Seite wird insbesondere in Horizontnähe der blaue Lichtanteil von astronomischen Objekten auf dem Lichtweg durch die Troposphäre durch die stark wellenlängenabhängige '''Rayleigh-Streuung''' seitlich abgelenkt, so dass es praktisch gar nicht mehr zum Beobachter gelangt. Dies führt zu den rötlichen Auf- und Untergängen von Sonne und Mond sowie zur Blaufärbung des Taghimmels.

Unter Umständen muss das Licht mehrere hundert Kilometer durch die Atmosphäre zurücklegen, wie in der folgenden Abbildung zu erkennen ist:

[[Datei:Troposphaerische.Laengen.png|mini|zentriert|hochkant=4|Weglängen für Lichtstrahlen in der 15&amp;nbsp;Kilometer hohen Troposphäre in Abhängigkeit von der Zenitdistanz.]]

=== Beobachtung ===
Die Beobachtungsmöglichkeiten des aschgrauen Lichts werden grundsätzlich durch die folgenden, sich teilweise widerstrebenden Bedingungen verbessert:

* Die '''Lichtverschmutzung''' in der Atmosphäre ist gering.
* Das '''Mondalter''' beträgt wenige Tage vor oder nach Neumond.
* Die '''Sonne''' steht möglichst weit unter dem Horizont.
* Der '''Mond''' hat eine möglichst große Höhe über dem Horizont.
* Die '''Mondsichel''' ist möglichst klein, um möglichst wenig Streulicht zu verursachen.

Für die Beobachtung aus nördlichen geographischen Breiten gilt insbesondere:

* Der Mond hat eine möglichst große '''nördliche ekliptikale Breite''' zwischen seinem aufsteigenden und seinem absteigenden Knoten.
* Die '''Ekliptik''' steht möglichst steil auf dem Horizont. Dies ist bei den Tag-und-Nacht-Gleichen der Fall, besonders gut
** abends im Frühjahr beim '''Neulicht''' des Mondes nach Sonnenuntergang im Westen.
** morgens im Herbst beim '''Altlicht''' des Mondes vor Sonnenaufgang im Osten.

=== Farbigkeit ===
[[Datei:Neulicht.21.3.2026.HDR.1024.png|mini|hochkant=2|Die Abbildung zeigt eine Hochkontrastaufnahme des Erdscheins im Mondschatten zum Frühlingbeginn drei Tage nach Neumond mit Sternen bis zur zehnten Größenklasse (10&lt;sup&gt;m&lt;/sup&gt;) in der Umgebung. Die Sichel zeigte einen Tag nach der Tag-und-Nacht-Gleiche im Frühjahr 2026 und zwei Tage vor der großen Mondwende bei einer nördlichen ekliptikalen Breite des Mondes von vier Bogengrad eine besonders starke Neigung. Die Sonne war zuvor im Westen untergegangen und stand bereits elf Bogengrad unter dem Horizont. Die Symmetrieachse der Mondsichel (-7&lt;sup&gt;m&lt;/sup&gt;) auf der zu 9,3&amp;nbsp;Prozent beleuchteten Mondscheibe zeigt nach rechts unten in Richtung der Sonne (Farbtemperatur = 4100 Kelvin, Belichtungsreihe mit sieben Bildern in ganzen Blendenstufen).]]

Bei genauer Betrachtung und Beobachtung ist das sogenannte aschgraue Licht gar nicht farbneutral, sondern spiegelt einen mittleren Farbton der von der Sonne beleuchteten Erdoberfläche wider, von der wiederum der Mondschatten beleuchtet wird. Je niedriger der Bewölkungsgrad, desto stärker ist zudem der Einfluss der farbigen Oberfläche der Erde. Die Farben der Erdoberfläche schwanken hierbei deutlich zwischen den Ozeanen, Wäldern oder Wüsten. In der nebenstehenden Hochkontrastaufnahme zeigt der Mondschatten im HSV-Farbraum einen mittleren Farbwert mit dem Farbwinkel 202°, was als Farbton blaucyan übersetzt werden kann. Dies entspricht recht gut dem mittleren Farbton der der Sonne zugewandten Seite der Erde (&quot;Blue Marble&quot;) während der Aufnahme, der für das hier gezeigte Beispielbild im HSV-Farbraum einen mittleren Farbwert mit dem Farbwinkel 201° hat. Der Farbwinkel ist von der Sättigung oder der Helligkeit nicht abhängig.

[[Datei:Neulicht.21.3.2026.HDR.Original.Durchschnitt.gesaettigt.aufgehellt.png|mini|links|hochkant=4|Sichtbarmachung des Farbwerts mit dem Farbwinkel 202° des aschgrauen Mondlichts in einer Hochkontrastaufnahme des Erdscheins im Mondschatten zum Frühlingbeginn drei Tage nach Neumond.&lt;br/&gt;Von links nach rechts:&lt;br/&gt;1. Originalaufnahme&lt;br/&gt;2. Mittelwert&lt;br/&gt;3. Farbe gesättigt&lt;br/&gt;4. aufgehellt]]
[[Datei:North America from low orbiting satellite Suomi NPP.Original.Durchschnitt.gesaettigt.abgedunkelt.png|mini|links|hochkant=4|Sichtbarmachung des Farbwerts mit dem Farbwinkel 201° der Erdoberfläche im Bereich von Nordamerika und dem südöstlichen Pazifik.&lt;br/&gt;Von links nach rechts:&lt;br/&gt;1. Originalaufnahme&lt;br/&gt;2. Mittelwert&lt;br/&gt;3. Farbe gesättigt&lt;br/&gt;4. abgedunkelt]]
&lt;div style=&quot;clear:both&quot;&gt;&lt;/div&gt;

==Einzelnachweise==
&lt;references&gt;&lt;/references&gt;

&lt;noinclude&gt;
[[Kategorie:Astronomische Kuriositäten]]
&lt;/noinclude&gt;</text>
      <sha1>9n6md8ass9me5gxv9skob8y6r3f73cs</sha1>
    </revision>
  </page>
  <page>
    <title>Gödel</title>
    <ns>0</ns>
    <id>117878</id>
    <revision>
      <id>1092180</id>
      <parentid>1092163</parentid>
      <timestamp>2026-10-17T07:47:47Z</timestamp>
      <contributor>
        <username>Santiago</username>
        <id>19191</id>
      </contributor>
      <comment>/* Kurt GÖDEL und der sog. ‚ontologische Gottesbeweis‘ */ Zusatz</comment>
      <origin>1092180</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="268986" sha1="mkn3w8o3mr2vd6sxq6b9xgbr3123bbb" xml:space="preserve">[[Kategorie: Buch]] 

{{Regal|ort=Philosophie}}
{{Vorlage:StatusBuch|9}}

==&lt;div class=&quot;center&quot;&gt;&lt;span style=&quot;color:#660066&quot;&gt;'''Kurt GÖDEL und der sog. ‚ontologische Gottesbeweis‘'''&lt;/span&gt;&lt;/div&gt;==

&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;&lt;div class=&quot;center&quot;&gt;לַמְנַצֵּ֗חַ לְדָ֫וִ֥ד אָ֘מַ֤ר נָבָ֣ל בְּ֭לִבּוֹ אֵ֣ין אֱלֹהִ֑ים הִֽשְׁחִ֗יתוּ הִֽתְעִ֥יבוּ עֲלִילָ֗ה אֵ֣ין עֹֽשֵׂה־טֽוֹב׃
(Psalm 14,1)&lt;/div&gt;&lt;/big&gt;&lt;/span&gt;

----


===&lt;div class=&quot;center&quot;&gt;&lt;span style=&quot;color:#660066&quot;&gt;Vorwort&lt;/span&gt;&lt;/div&gt;===

Zur Orientierung ''':''' Die Diskussion um GOTT, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''G'''‘ —&lt;/span&gt;, läuft schon über zweitausend Jahren. Vor etwa tausend Jahren hat sich ein gewisser ANSELM gesagt ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Ich glaube an GOTT'' … &lt;span style=&quot;color:#00B000&quot;&gt;[ sonst wäre er sicher 
nicht Erzbischof von Canterbury geworden ]&lt;/span&gt; … ''aber ich möchte auch wissen und verstehen, ob das stimmt und sinnvoll ist, was ich da glaube '''!''''' «&lt;/span&gt; Dann hat er seine Überlegungen dazu aufgeschrieben, und das kann man in seinen Schriften auch heute noch lesen. Der sehr geschätzte deutsche Professor und Philosoph aus Königsberg, Immanuel KANT, hat das, was ANSELM da aufgeschrieben hat, gelesen, &lt;span style=&quot;color:#00B000&quot;&gt;(vermittelt durch CARTESIUS)&lt;/span&gt;, und das dann den &lt;span style=&quot;color:#FF6000&quot;&gt;„ontologischen Gottesbeweis“&lt;/span&gt; genannt, &lt;span style=&quot;color:#00B000&quot;&gt;(obwohl es in Wirklichkeit gar kein Gottesbeweis ist; genauer ''':''' es ist kein Beweis für die Existenz GOTTES)&lt;/span&gt;, und dieser große KANT hat dann großartig bewiesen, das, was ANSELM da aufgeschrieben hat, sei falsch. Es sei &lt;span style=&quot;color:#FF6000&quot;&gt;„ja gar kein“&lt;/span&gt; Gottesbeweis '''!''' &lt;span style=&quot;color:#00B000&quot;&gt;( Naja, was denn sonst '''?''' )&lt;/span&gt; Wobei er den Fehler gemacht hat, dass er den, an sich, unvergleichbaren GOTT mit hundert Talern in seinem Vermögenszustande verglichen hat. &lt;span style=&quot;color:#00B000&quot;&gt;(Das ist aber eine andere Geschichte.)&lt;/span&gt; Hundert Taler und GOTT haben ,an sich‘ nichts gemeinsam, außer, wenn KANT ,wirklich‘ hundert Taler hat, und GOTT auch ,wirklich‘ existiert, &lt;span style=&quot;color:#00B000&quot;&gt;(wie ANSELM und gläubige Menschen glauben)&lt;/span&gt;, dann gibt es GOTT und die Taler eben ,wirklich‘. Aber damit ist man nicht schlauer geworden. Seit KANT läuft die ganze Diskussion um GOTT immer nur als Diskussion um den &lt;span style=&quot;color:#00B000&quot;&gt;(von KANT)&lt;/span&gt; so genannten &lt;span style=&quot;color:#FF6000&quot;&gt;„ontologischen, &lt;span style=&quot;color:#00B000&quot;&gt;[ kosmologischen, teleologischen etc. ]&lt;/span&gt; Gottesbeweis“&lt;/span&gt; —, obwohl es niemals einen Beweis für die Existenz GOTTES geben kann und niemals geben wird. &lt;span style=&quot;color:#00B000&quot;&gt;(Das haben Wissenschaftler jeder Richtung und Philosophen aller Weltanschauungen uns immer wieder nachdrücklich versucht zu sagen, weil keiner dieser sog. Beweise für die Existenz eines GOTTES stringent ist. ,Existenz‘, an sich, ist, — nach ARISTOTELES — ,unbeweisbar‘. Sie ist, als frei wählbare Prämisse, immer nur der fixe und nicht hinterfragbare Ausgangspunkt einer möglichen logischen Beweisführung. Auf die Existenz kann man nur ,hinweisen‘.)&lt;/span&gt; Für ANSELM selbst, wäre es ,Unsinn‘, einen Beweis für die Existenz GOTTES verlangen zu wollen. Beweisen, bzw. darauf ,hinweisen‘, kann man, z. B. auf die Existenz von Naturgesetzen. Die sind unveränderlich und fix, immer und überall. Jeder vernünftige Mensch muss sie akzeptieren. Man kann darüber nicht diskutieren und sie dann mit Mehrheitenbeschlüsse verändern. Wenn GOTT ebenso ,bewiesen‘ werden könnte, dann wäre jeder vernünftige Mensch gezwungen, die Existenz GOTTES wie ein Naturgesetz anzunehmen. Gott ist aber kein Naturgesetz. GOTT ist &lt;span style=&quot;color:#FF6000&quot;&gt;„Person“&lt;/span&gt;, — für Christgläubige ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;„ein GOTT in drei Personen“&lt;/span&gt;. Und GOTT ist &lt;span style=&quot;color:#FF6000&quot;&gt;„Geist“&lt;/span&gt;. Das besagt, dass GOTT nicht mit materiellen Dingen aus unserer Welt verglichen werden darf; &lt;span style=&quot;color:#00B000&quot;&gt;(was sowohl THOMAS von Aquin als auch Immanuel KANT doch getan haben)&lt;/span&gt;. Und ganz wesentlich ''':''' der Zugang zu GOTT läuft nicht über den Beweis, sondern immer nur über den Glauben. Wer an GOTT glauben will, dem antwortet GOTT auf seine Weise — nämlich &lt;span style=&quot;color:#FF6000&quot;&gt;„geistig“&lt;/span&gt; bzw. &lt;span style=&quot;color:#FF6000&quot;&gt;„geistlich“&lt;/span&gt;. Wer nicht an GOTT glauben will, dessen Entscheidung respektiert GOTT, und drängt sich nicht auf. Glaube ist immer eine freie Entscheidung des Menschen für GOTT. Niemand darf gezwungen werden. Wenn es einen ,Beweis‘ für GOTT gäbe, wäre jeder vernünftige Mensch gezwungen, an GOTT zu glauben. Und das widerspricht ganz entschieden der Freiheit des Glaubens. Daher gibt es nie und nimmermehr einen Existenzbeweis für GOTT '''!!!''' ... Daher darf man das Kalkül des Logiker GÖDEL, &lt;span style=&quot;color:#00B000&quot;&gt;(und das Theorem ANSELMS)&lt;/span&gt;, auch nicht als einen Existenzbeweis für GOTT lesen. Sowohl ANSELM als auch GÖDEL setzen die Existenz GOTTES notwendig als gegeben schon voraus. Das GÖDEL-System, und auch das Theorem ANSELMS, sind bloß die logische Bestätigung der Widerspruchsfreiheit und Sinnhaftigkeit der Glaubensüberzeugung eines Menschen, der sich schon entschieden hat, an GOTT zu glauben; und nicht der Grund für seine Entscheidung. Alle sogenannten ,Gottesbeweise‘, sind in Wirklichkeit nichts anderes, als nachträgliche Evaluierungen eines GOTT-Glaubens, bzw. ,Wege‘, &lt;span style=&quot;color:#00B000&quot;&gt;(bei THOMAS von Aquin)&lt;/span&gt;, die aufzeigen, dass der GOTT-Glaube widerspruchsfrei, sinnvoll, und  &lt;span style=&quot;color:#FF6000&quot;&gt;»''mit allen bekannten Tatsachen durchaus vereinbar ist''«&lt;/span&gt;, wie GÖDEL sagt. GOTT hat es nicht nötig, ,bewiesen‘ &lt;span style=&quot;color:#00B000&quot;&gt;( ╞ )&lt;/span&gt; zu werden.


===&lt;div class=&quot;center&quot;&gt;&lt;span style=&quot;color:#660066&quot;&gt;Einleitung&lt;/span&gt;&lt;/div&gt;===

Eine Studie zum GÖDEL-Kalkül. Der Logiker Kurt GÖDEL &lt;span style=&quot;color:#00B000&quot;&gt;(1906-1978)&lt;/span&gt; hat mit diesem Kalkül eine moderne Rekonstruktion des, &lt;span style=&quot;color:#00B000&quot;&gt;(von KANT)&lt;/span&gt;, so genannten ‚ontologischen Gottesbeweises‘ nach ANSELM von Canterbury auf modal-logischer Basis vorgelegt. Damit hat er die &lt;span style=&quot;color:#FF6000&quot;&gt;„Rede von GOTT“&lt;/span&gt; auf eine ‚vernünftige Basis‘ gestellt, d.h. sie soll für jeden Menschen nachvollziehbar sein, &lt;span style=&quot;color:#FF6000&quot;&gt;»''rein verstandesmäßig, (ohne sich auf den Glauben an irgendeine Religion zu stützen)''«&lt;/span&gt;, wie er sagt. GÖDEL ,nimmt‘ als Logiker, angeregt durch den Philosophen und Mathematiker Gottfried Wilhelm LEIBNIZ, rein theoretisch, fürs Erste, einmal ‚an‘, &lt;span style=&quot;color:#00B000&quot;&gt;(als Prämisse, d.i. der Term :01: im 3. Beweisgang zum Theorem ANSELMS im Anhang)&lt;/span&gt;, dass es GOTT gibt ''':''' d.i. ein sog. ,methodologischer GOTT-Glaube‘, und untersucht die logischen Konsequenzen. Dabei zeigt sich, beim genaueren Hinsehen, dass der ‚Nicht-GOTT-Glaube‘, der ‚dezidierte‘ Atheismus,  &lt;span style=&quot;color:#00B000&quot;&gt;(im Beweisgang ,Widerlegung‘ im Anhang)&lt;/span&gt;, überraschender Weise, zu einem Widerspruch führt, und damit logisch ,falsch‘ ist. Jedoch, GÖDEL kann und will mit seinem Kalkül keinen ,GOTT-Glauben‘ ,erzeugen‘, d.h. das GÖDEL-Kalkül ist kein &lt;span style=&quot;color:#FF6000&quot;&gt;„Existenz-Beweis&quot;&lt;/span&gt; für den GOTT der Bibel, sondern, es setzt die Existenz eines GOTTES, einfach als gegeben, schon voraus. GÖDEL beweist dann mit seinem System, dass der traditionelle abendländische ,GOTT-Glaube‘, &lt;span style=&quot;color:#FF6000&quot;&gt;»''die theologische Weltanschauung''«&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(d.i. die Kalkül-Prämisse, und das, daraus ,regulär‘ (├ ) abgeleitete, Theorem ANSELMS)&lt;/span&gt;, mit den Maßstäben der modernen Logik &lt;span style=&quot;color:#FF6000&quot;&gt;»''durchaus vereinbar''«&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;(d.h. logisch ,richtig‘)&lt;/span&gt; ist, im Gegensatz zum ,Nicht-GOTT-Glauben‘, der davon ausgeht, dass es keinen GOTT gibt. GÖDEL beweist mit seinem System ''':''' der traditionelle GOTT-Glaube ist, — mit &lt;span style=&quot;color:#FF6000&quot;&gt;»''mathematisch-logischer Evidenz''«&lt;/span&gt; —, widerspruchfrei und daher wahr. &lt;span style=&quot;color:#00B000&quot;&gt;(Der Beweis aus dem Widerspruch des Gegenteils ist ein ,indirekter Beweis‘ und kein ,Zirkelbeweis‘ '''!''' )&lt;/span&gt; GÖDEL blieb bis zu seinem Tod ohne ein dezidiertes religiöses Bekenntnis. &lt;span style=&quot;color:#00B000&quot;&gt;(Das Leben ist nicht immer ,logisch‘.)&lt;/span&gt;

Entsprechend der &lt;span style=&quot;color:#FF6000&quot;&gt;»''theologischen Weltanschauung''«&lt;/span&gt; ist GOTT der Größte, &lt;span style=&quot;color:#FF6000&quot;&gt;»''über dem nichts Größeres mehr gedacht werden kann''«&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(ANSELM)&lt;/span&gt;; bzw. &lt;span style=&quot;color:#FF6000&quot;&gt;»''GOTT ist ein Wesen von äußerster Größe und Vollkommenheit, das alle Grade derselben in sich schließt''«&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(LEIBNIZ)&lt;/span&gt;, und der  für uns immer schon ,da‘ ist. Das ist die methodologische Prämisse des GÖDEL-Kalküls. Davon ausgehend, zeigen Axiom-1 und Axiom-2, dass es zu einem Widerspruch führt, falls man ,annimmt‘, es sei nicht möglich, dass es &lt;span style=&quot;color:#FF6000&quot;&gt;„GOTT“&lt;/span&gt;, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''G'''‘ —&lt;/span&gt; gibt. Aus dem Widerspruch des Gegenteils wird von GÖDEL, mit dem &lt;span style=&quot;color:#4C58FF&quot;&gt;[ Modus tollendo tollens ] :: [ A → B, ¬B ├ ¬A ]&lt;/span&gt;, dann ,bewiesen‘ &lt;span style=&quot;color:#00B000&quot;&gt;( ╞ )&lt;/span&gt; ''':''' es ist doch möglich, dass es &lt;span style=&quot;color:#FF6000&quot;&gt;„GOTT“&lt;/span&gt; wirklich gibt. Somit ist der Glaube an &lt;span style=&quot;color:#FF6000&quot;&gt;„GOTT“&lt;/span&gt;, — weil widerspruchsfrei —, mit den Worten GÖDELS ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''mit allen bekannten Tatsachen durchaus vereinbar''«&lt;/span&gt;. 

Immanuel KANT &lt;span style=&quot;color:#00B000&quot;&gt;(1724-1804)&lt;/span&gt; scheint diesen Fall vorausgesehen zu haben, dass versucht werden könnte, die ,Möglichkeit‘ GOTTES aus einem Widerspruch zu ,beweisen‘ ''':'''
::&lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;[ Angenommen, es gibt ]&lt;/span&gt; ''doch einen und zwar nur diesen '''Einen''' Begriff'' &lt;span style=&quot;color:#00B000&quot;&gt;[ ,GOTT‘,  so dass ]&lt;/span&gt; ''das Nichtsein oder das Aufheben seines Gegenstandes'' &lt;span style=&quot;color:#00B000&quot;&gt;[ GOTT ]&lt;/span&gt;, ''in ,sich selbst‘ widersprechend sei; und dieses ist der Begriff des allerrealsten Wesens. Es hat, sagt ihr, alle Realität'', &lt;span style=&quot;color:#00B000&quot;&gt;[ bzw. alle Vollkommenheit ]&lt;/span&gt;, ''und ihr seid berechtigt, ein solches Wesen als ,möglich‘ anzunehmen'' ... &lt;span style=&quot;color:#00B000&quot;&gt;[ denn das GÖDEL-Kalkül ,beweist‘ ( ╞  ) in der ,Widerlegung‘ im Anhang, wie auch im 1. Beweisgang, aus einem Widerspruch, dass die Existenz GOTTES definitiv logisch ,möglich‘ ist. ]&lt;/span&gt; … ''obgleich der sich nicht widersprechende'', &lt;span style=&quot;color:#00B000&quot;&gt;[ ,mögliche‘ ]&lt;/span&gt;, ''Begriff'', &lt;span style=&quot;color:#00B000&quot;&gt;[ ,GOTT‘ ]&lt;/span&gt;, ''noch lange nicht die'' &lt;span style=&quot;color:#00B000&quot;&gt;[ reale ]&lt;/span&gt; ''Möglichkeit des Gegenstandes'', &lt;span style=&quot;color:#00B000&quot;&gt;[ GOTT ]&lt;/span&gt;, ''beweiset. … Das ist eine Warnung, von der Möglichkeit der Begriffe (logische)'', &lt;span style=&quot;color:#4C58FF&quot;&gt;— '''◇''' —&lt;/span&gt;, ''nicht sofort auf die Möglichkeit der Dinge (reale)'', &lt;span style=&quot;color:#4C58FF&quot;&gt;— '''□''' —&lt;/span&gt;, ''zu schließen''&lt;ref&gt;vgl. ‚''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;Kritik  der reinen Vernunft&lt;/big&gt;&lt;/span&gt;''‘, Seite 399; https://www.korpora.org/kant/aa03/399.html&lt;/ref&gt;. &lt;span style=&quot;color:#00B000&quot;&gt;[ Trotz dieser Warnung, wird dieser Schluss dennoch im Theorem ANSELMS vollzogen, bzw. mit GÖDEL im 3. Beweisgang ''':'''  &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''◇∃xGx→□∃xGx'''‘ —&lt;/span&gt; '''!''' ]&lt;/span&gt;. &lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;
Warum das &lt;span style=&quot;color:#FF6000&quot;&gt;»''mit allen bekannten Tatsachen durchaus vereinbar''«&lt;/span&gt; ist, und inwieweit KANT sich irrt, wird in dieser Studie gezeigt.


===&lt;div class=&quot;center&quot;&gt;&lt;span style=&quot;color:#660066&quot;&gt;Der Schlüsselbegriff im Kalkül&lt;/span&gt;&lt;/div&gt;===

Der ‚Schlüsselbegriff‘ in diesem Kalkül ist &lt;span style=&quot;color:#FF6000&quot;&gt;„positive Eigenschaft“&lt;/span&gt;, bzw. &lt;span style=&quot;color:#FF6000&quot;&gt;„Perfektion“, „Vollkommenheit“&lt;/span&gt; ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''P'''‘ —&lt;/span&gt;. Für diesen wichtigen Begriff gibt es aber im Kalkül selbst keine explizite Definition, sondern er wird nur durch seine Verwendung innerhalb des Kalküls indirekt ‚definiert‘. &lt;span style=&quot;color:#00B000&quot;&gt;(Das heißt ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''P'''‘ — &lt;/span&gt; bezeichnet ein System von ,Eigenschaften‘, die ,positiv‘, bzw. ,vollkommen‘ | ,perfekt‘ | genannt werden, von denen im Kalkül wohl beweisbar ist, dass sie sich gegenseitig ,nicht widersprechen‘, weil sie im System als solche ,gleichwertig‘, bzw. gleich ,wahr‘ sind, jedoch ohne sie erschöpfend aufzählen zu können, oder auch nur sagen zu können, was sie alle im einzelnen bedeuten, außer, dass sie kompatibel sind.)&lt;/span&gt; Mit der Wahl dieses Schlüsselbegriffes hat GÖDEL eine wesentliche Vorentscheidung für die Ergebnisse des Kalküls getroffen '''!''' In seinen Notizen zum ‚ontologischen Beweis‘ vom 10. Februar 1970 gibt GÖDEL, — für die nachträgliche Interpretation dieses Begriffes &lt;span style=&quot;color:#00B000&quot;&gt;(und auch für das Kalkül selbst)&lt;/span&gt; —, die richtungsweisende Erklärung ''':'''

::&lt;span style=&quot;color:#FF6000&quot;&gt;»''Positiv bedeutet positiv im moralisch ästhetischen Sinne...''«&lt;/span&gt; 
::Und er fügt in Klammer hinzu ''':'''
::&lt;span style=&quot;color:#FF6000&quot;&gt;»...''(unabhängig von der zufälligen Struktur der Welt). Nur dann sind die Axiome wahr''.«&lt;/span&gt;&lt;ref&gt;GÖDEL, Kurt, ''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;‚Ontological proof‘&lt;/big&gt;&lt;/span&gt;'' in ''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;‚Collected Works‘&lt;/big&gt;&lt;/span&gt;'', vol. III, ed. S.FEFERMAN et al., Oxford (U.P.), 1995; 403–404.&lt;/ref&gt; 

GÖDEL-Axiom-1 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚('''PX &lt;small&gt;&lt;math&gt;{  \color{Blue} \dot\lor}&lt;/math&gt;&lt;/small&gt; P¬X''')‘ ↔&lt;span style=&quot;color:#00B000&quot;&gt; ‚('''¬PX ↔ P¬X''')‘&lt;/span&gt; — &lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt; »''Entweder die Eigenschaft'' &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''X'''‘&lt;/span&gt; ''oder ihre Negation'' &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''¬X'''‘&lt;/span&gt; ''ist positiv''«&lt;/span&gt;. Hier ist der Hauptkritikpunkt, dass es Eigenschaften gibt, die ,an sich‘ weder positiv noch negativ sind. Beispiele wären ''':''' ‚rothaarig‘ oder ‚schwerwiegend‘; solche Eigenschaften können aber ,für mich‘ entweder positiv oder negativ sein, abhängig von meiner Betrachtungsweise und subjektiven Vorlieben. Diese Eigenschaften, wie ‚rothaarig‘ an sich, oder meine positiv-negativen ‚Betrachtungsweisen‘, sind jedoch der &lt;span style=&quot;color:#FF6000&quot;&gt;»''zufälligen Struktur der Welt''«&lt;/span&gt; entnommen und treffen nicht den &lt;span style=&quot;color:#FF6000&quot;&gt;»''moralisch ästhetischen Sinn''«&lt;/span&gt; von &lt;span style=&quot;color:#FF6000&quot;&gt;»''positiv''«&lt;/span&gt; bei GÖDEL. Er orientierte sich an LEIBNIZ, welcher im Bezug zum ‚ontologischen Beweis‘ definiert ''':'''
::&lt;span style=&quot;color:#FF6000&quot;&gt;»''Vollkommenheit'' &lt;span style=&quot;color:#00B000&quot;&gt;[ GOTTES ]&lt;/span&gt; ''nenne ich jede einfache Eigenschaft, die sowohl positiv als auch absolut ist, oder dasjenige, was sie ausdrückt, ohne jede Begrenzung ausdrückt''.«&lt;/span&gt;&lt;ref&gt;Zitiert nach Thomas GAWLICK, in ''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;‚Was sind und was sollen mathematische Gottesbeweise ?‘&lt;/big&gt;&lt;/span&gt;'', Predigt vom 8.1.2012 in der Kreuzkirche zu Hannover. https://web.archive.org/web/20130524164359/http://www.idmp.uni-hannover.de/fileadmin/institut/IDMP-Studium-Mathematik/downloads/Gawlick/Predigt_Gawlick_Gottesbeweise.pdf&lt;/ref&gt; 

Die Seins-Eigentümlichkeiten &lt;span style=&quot;color:#00B000&quot;&gt;(Daseinsmodi, Perfektionen)&lt;/span&gt; wie ‚wahr‘, ‚gut‘, ‚edel‘ usw. entsprechen dem &lt;span style=&quot;color:#FF6000&quot;&gt;»''moralisch ästhetischen Sinn''«&lt;/span&gt; von &lt;span style=&quot;color:#FF6000&quot;&gt;»''positiv''«&lt;/span&gt; bei GÖDEL. Das sind Beispiele für ‚absolut‘ positive Begriffe aus der Lehre der Seinsanalogie ''':''' &lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;‚verissimum‘, ‚optimum‘, ‚nobilissimum‘&lt;/big&gt;&lt;/span&gt;, usw., die, an sich, &lt;span style=&quot;color:#FF6000&quot;&gt;»''ohne jede Begrenzung gelten''«&lt;/span&gt;; zu finden in der &lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;‚Via quarta‘&lt;/big&gt;&lt;/span&gt;, bei THOMAS von Aquin, über die &lt;span style=&quot;color:#FF6000&quot;&gt;„analoge&quot;&lt;/span&gt; Abstufung im ‚Sein‘ der Dinge. Diese &lt;span style=&quot;color:#FF6000&quot;&gt;„analoge&quot;&lt;/span&gt; ‚Abstufung‘ ist dann die faktische Begrenztheit &lt;span style=&quot;color:#00B000&quot;&gt;(d.h. Unvollkommenheit)&lt;/span&gt; im &lt;span style=&quot;color:#FF6000&quot;&gt;»''zufälligen''«&lt;/span&gt; ‚Sein‘ der Dinge —. Die &lt;span style=&quot;color:#FF6000&quot;&gt;„positiven Eigenschaften“&lt;/span&gt; GÖDELS ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''P'''‘ —&lt;/span&gt;, wie Wahrheit, Einheit, Gutheit, &lt;span style=&quot;color:#00B000&quot;&gt;(von ,Güte‘)&lt;/span&gt;, Schönheit, Adel, &lt;span style=&quot;color:#00B000&quot;&gt;(von ,edel‘)&lt;/span&gt;, Gleichheit, Andersheit, Wirklichkeit, ,Sein‘ im Sinne von Etwas-sein, etc. werden &lt;span style=&quot;color:#FF6000&quot;&gt;„Perfektionen“&lt;/span&gt;, oder auch &lt;span style=&quot;color:#FF6000&quot;&gt;„Transzendentalia“&lt;/span&gt; genannt, &lt;span style=&quot;color:#00B000&quot;&gt;(von lateinisch ''':''' &lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;transcendere&lt;/big&gt;&lt;/span&gt;, &lt;span style=&quot;color:#FF6000&quot;&gt;„übersteigen“&lt;/span&gt;)&lt;/span&gt;. In der mittelalterlichen Scholastik sind Transzendentalien die Grundbegriffe, die allem Seienden als &lt;span style=&quot;color:#FF6000&quot;&gt;„Modus“&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(d.h. ,Eigentümlichkeit‘, als allgemeine Seinsweisen)&lt;/span&gt;, zukommen. Wegen ihrer Allgemeinheit ,übersteigen‘ sie die besonderen Seinsweisen, welche ARISTOTELES die ,Kategorien‘ nannte. Ontologisch betrachtet, werden die Transzendentalien als das allem Seienden Gemeinsame aufgefasst, da sie von allem ausgesagt werden können. Von der KI werden sie, nicht unpassend,  als &lt;span style=&quot;color:#FF6000&quot;&gt;„ultimative Eigenschaften des Seins“&lt;/span&gt; bezeichnet, die &lt;span style=&quot;color:#FF6000&quot;&gt;„jenseits der materiellen Welt existieren“&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(da sie ,ultimativ‘ nur von GOTT, als den unbegrenzt Vollkommenen, ausgesagt werden können, die jedoch, auch von allen übrigen Seienden, wegen deren seinsmäßigen Unvollkommenheit und Begrenztheit, abgestuft, d.h. &lt;span style=&quot;color:#FF6000&quot;&gt;„analog&quot;&lt;/span&gt;, ausgesagt werden)&lt;/span&gt;. Diese Transzendentalien sind ,inakzident‘, das heißt, sie entstehen nicht aus anderen Begriffen, sondern sind erste, unteilbare ,Bestimmungen‘ &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''X'''‘ —&lt;/span&gt; des Denkens und des Seins, die ,allen Seienden‘ &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''∀x'''‘ —&lt;/span&gt;, unabhängig von ihren speziellen Eigenschaften, als ,relative‘ Vollkommenheiten, &lt;span style=&quot;color:#00B000&quot;&gt;(bzw. Unvollkommenheiten)&lt;/span&gt;, mit ,modaler‘ Notwendigkeit, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚□‘ —&lt;/span&gt;, &lt;span style=&quot;color:#FF6000&quot;&gt;„analogisch&quot;&lt;/span&gt; zukommen ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□∀xXx'''‘ —&lt;/span&gt;, d.h. sie sind in allen Seienden, seinsmäßig abgestuft und abgegrenzt, ,relativ‘ zum unbegrenzt Unendlichen ihrer selbst, und &lt;span style=&quot;color:#FF6000&quot;&gt;»''dasjenige, was sie ausdrücken, drücken sie ohne jede Begrenzung aus''«&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(LEIBNIZ)&lt;/span&gt;; und damit stehen sie ontologisch in einer &lt;span style=&quot;color:#FF6000&quot;&gt;„analogen&quot;&lt;/span&gt; ,Beziehung‘ zu GOTT, dem absolut Vollkommenen und unbegrenzt Unendlichen. In der Erkenntnisordnung wirken sie als die ersten Begriffe des menschlichen Verstehens, die eine Basis für alle weiteren wissenschaftlichen Erkenntnisse bilden. In der Seinsordnung sind die Transzendentalien ontologisch eins, gleichwertig, &lt;span style=&quot;color:#00B000&quot;&gt;(,mathematisch äquivalent‘)&lt;/span&gt;, und daher konvertierbar, d.h. austauschbar, &lt;span style=&quot;color:#00B000&quot;&gt;(vgl. z. B. den scholastischen ,Merksatz‘ ''':''' &lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;,ens et verum convertuntur‘&lt;/big&gt;&lt;/span&gt;)&lt;/span&gt;. Damit sind sie auch von einander abhängig, was GÖDEL sowohl im Axiom-2 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PX ∧ □∀x(Xx→Yx)→PY'''‘ —&lt;/span&gt;, für positive Eigenschaften, als auch in der Definition-2 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''X'''&lt;sub&gt;ess&lt;/sub&gt;'''x ↔ Xx ∧ ∀Y(Yx→ □∀y(Xy→Yy))'''‘ —&lt;/span&gt;, für die Wesenseigenschaften, syntaktisch formalisiert hat mit dem Term-Element ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□∀x(Xx→Yx)'''‘ —&lt;/span&gt;, weil sie sich wechselseitig, — mit ,modaler‘ Notwendigkeit —, gleichwertig ,implizieren‘, d.h. einschließen, &lt;span style=&quot;color:#00B000&quot;&gt;(im Axiom-2 mit der Individuum-Variable &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''x'''‘ —&lt;/span&gt;, und in der Definition-2 mit der Individuum-Variable &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''y'''‘ — &lt;/span&gt;, die, als noch unbestimmte Variablen, frei austauschbar sind)&lt;/span&gt;. Man kann die Transzendentalia, &lt;span style=&quot;color:#00B000&quot;&gt;(wie GÖDEL)&lt;/span&gt;, auch ,Wesenseigenschaften‘ ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''X'''&lt;sub&gt;ess&lt;/sub&gt;‘ —&lt;/span&gt;, nennen, weil sie allem Seienden &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□∀y'''‘ —&lt;/span&gt; &lt;span style=&quot;color:#FF6000&quot;&gt;„wesentlich, &lt;span style=&quot;color:#00B000&quot;&gt;[ ,notwendig‘ ]&lt;/span&gt;, analog&quot;&lt;/span&gt; zukommen. Weil Transzendentalien ebenfalls miteinander austauschbar sind, sind sie auch widerspruchsfrei, was GÖDEL mit Axiom-1 syntaktisch darstellt. Die Gültigkeit und Wahrheit, d.h. die mathematisch-logische Evidenz von Axiom-1 und Axiom-2, beruht auf der ontologischen Allgemeinheit und Gültigkeit der Transzendentalia, die GÖDEL mit Definition-2, in sein Kalkül explizit eingeführt und als Wesenseigenschaften ,bestimmt‘ hat. &lt;span style=&quot;color:#00B000&quot;&gt;(Definitionen werden formal-syntaktisch durch das Äquivalenzzeichen &lt;span style=&quot;color:#4C58FF&quot;&gt;,'''↔'''‘&lt;/span&gt; angezeigt, gelesen als &lt;span style=&quot;color:#FF6000&quot;&gt;„...ist genau dann ... wenn...“&lt;/span&gt;)&lt;/span&gt; Die GÖDEL-Axiome und -Definitionen werden jedoch sofort &lt;span style=&quot;color:#FF6000&quot;&gt;„modal falsch&quot;&lt;/span&gt;, wenn ihre Eigenschafts-Variablen, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''X'''‘ —&lt;/span&gt; und &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Y'''‘ —&lt;/span&gt;, mit ,Nicht-Transzendentalia‘, wie z. B. ,rot‘ oder ,schwer‘, belegt werden. &lt;span style=&quot;color:#00B000&quot;&gt;(Dieser ,Sachverhalt‘ wird von Kritikern des GÖDEL-Systems, — zu vorschnell —, verwendet, um ihre Behauptungen zu ,belegen‘, das GÖDEL-Kalkül und seine Konsequenzen seien ,falsch‘.)&lt;/span&gt;

Zum Überblick ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;„Transzendentalia“&lt;/span&gt; sind universale, alles Seiende charakterisierende Begriffe, die über kategoriale Einteilungen hinausgehen, und sowohl in der klassischen Scholastik, als auch in der modernen Philosophie, &lt;span style=&quot;color:#00B000&quot;&gt;(KANT, Uwe MEIXNER&lt;ref&gt;vgl. die ,transzendentalen‘ Bedingungen möglicher Erkenntnisse bei  KANT; und auch in der ,Axiomatischen Ontologie‘ bei Uwe MEIXNER&lt;/ref&gt;)&lt;/span&gt;, als Grundlage der Metaphysik und Erkenntnistheorie dienen. Sie sind die &lt;span style=&quot;color:#FF6000&quot;&gt;„ersten Begriffe des Seins“&lt;/span&gt;, die jedem Ding als ,relative‘ Vollkommenheiten, &lt;span style=&quot;color:#00B000&quot;&gt;(Perfektionen)&lt;/span&gt;, inhärent sind, &lt;span style=&quot;color:#FF6000&quot;&gt;„analogisch&quot;&lt;/span&gt; abgestuft, auf einen ,ultimativ‘-unbegrenzten Bezugspunkt ausgerichtet, und die sich im Denken, &lt;span style=&quot;color:#00B000&quot;&gt;(für uns als wahr)&lt;/span&gt;, und in der moralischen Wertung, &lt;span style=&quot;color:#00B000&quot;&gt;(für uns als gut und edel)&lt;/span&gt;, manifestieren, relativ zum ,ultimativ‘-unbegrenzten Bezugspunkt ihrer selbst. Die faktische, zusätzliche Unvollkommenheit, die sich generell in der notwendigen, und unausweichlichen Vergänglichkeit aller Dinge zeigt, ist einem ontologischen Defekt ,geschuldet‘, der stark zeitabhängig ist, d.h. der einen Anfang und ein Ende hat.

Das GÖDEL-Axiom-5 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''PE'''&lt;sub&gt;not&lt;/sub&gt;‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Notwendige Existenz ist eine positive Eigenschaft''«&lt;/span&gt;, ist immer falsch, wenn es auf etwas aus der &lt;span style=&quot;color:#FF6000&quot;&gt;»''zufälligen Struktur der Welt''«&lt;/span&gt; angewendet wird, wie z. B. auf einen &lt;span style=&quot;color:#FF6000&quot;&gt;„Tsunami“&lt;/span&gt;, dessen ‚Existenz‘ für uns nicht ‚positiv‘ ist. KANT hat schon festgestellt ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;„Existenz ist keine Eigenschaft“&lt;/span&gt;. Das gilt für alles, was &lt;span style=&quot;color:#FF6000&quot;&gt;„existiert“&lt;/span&gt;. Das Axiom-5 hat nur dann seine Gültigkeit, ist nur dann ,wahr‘, wenn &lt;span style=&quot;color:#FF6000&quot;&gt;„Dasein“&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;(Existenz)&lt;/span&gt; und &lt;span style=&quot;color:#FF6000&quot;&gt;„Wesenseigenschaften“&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;(Essenz)&lt;/span&gt; in eins zusammenfallen. Bei allen Dingen, die ‚da‘ sind, ist ihr ‚Da-Sein‘ ontologisch immer verschieden zu dem ‚was‘ sie sind ''':''' zu ihrem ,Was-Sein‘. In der philosophischen Tradition, seit ARISTOTELES, wird die ontologische Identität, d.i. die &lt;span style=&quot;color:#FF6000&quot;&gt;„Koinzidenz“&lt;/span&gt;, der innere Zusammenhang von ‚Sein‘ und ‚Wesen‘ allein nur dem &lt;span style=&quot;color:#FF6000&quot;&gt;„selbst ‚unbewegten‘ Erstbewegenden“&lt;/span&gt; zugeschrieben, dem &lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;πρῶτον κινοῦν ἀκίνητον&lt;/big&gt;&lt;/span&gt;“&lt;/span&gt;&lt;span style=&quot;color:#00B000&quot;&gt; | ,prôton kinoûn akinêton‘&lt;/span&gt;, von dem ARISTOTELES etwas später sagt ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''denn dies ist der Gott''«&lt;/span&gt; und dann hinzufügt ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''so sagen wir ja''«&lt;/span&gt;; d.h. das ist eine Interpretation aus dem Glaubenskontext des ARISTOTELES. Er war ein Gott-gläubiger Grieche. Wer an GOTT glaubt, kann das nachvollziehen. GÖDEL musste dieses Axiom-5 postulieren, sonst wäre sein Kalkül nicht aufgegangen, ohne dass er deswegen schon an GOTT glauben müsste. Er hat für sein Kalkül das ontologische Theorem von der Identität von ‚Sein‘ und ‚Wesen‘ im ‚unbewegten Erstbeweger‘ des ARISTOTELES benutzt, ohne diese Herkunft explizit referenziert zu haben. &lt;span style=&quot;color:#00B000&quot;&gt;(Gilt auch für Axiom-3 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PG'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Göttlichkeit, das GOTT-Sein, das ‚Dasein‘ GOTTES, ist eine positive Wesenseigenschaft, eine Perfektion; d.h. ist das ‚Wesen‘ GOTTES ''':''' GOTT ist perfekt''«&lt;/span&gt;)&lt;/span&gt;. Die ontologische Identität von Sein und Wesen, Existenz und Essenz, wie auch die &lt;span style=&quot;color:#FF6000&quot;&gt;„Koinzidenz“&lt;/span&gt; von Möglichkeit und Wirklichkeit, von Ursache und Wirkung, sowie auch die ontologische Einheit von &lt;span style=&quot;color:#00B000&quot;&gt;(Erkenntnis-)&lt;/span&gt;Subjekt und &lt;span style=&quot;color:#00B000&quot;&gt;(Erkenntnis-)&lt;/span&gt;Objekt im &lt;span style=&quot;color:#FF6000&quot;&gt;»''Erkennen seiner Erkenntnis''&lt;span style=&quot;color:#00B000&quot;&gt;[-Tätigkeit ]&lt;/span&gt;«&lt;span style=&quot;color:#00B000&quot;&gt; | &lt;/span&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;νοήσεως νόησις&lt;/big&gt;&lt;/span&gt;“&lt;/span&gt;&lt;span style=&quot;color:#00B000&quot;&gt; | ,noêseôs noêsis‘ &lt;small&gt;(&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;,''Metaphysik''‘&lt;/big&gt;&lt;/span&gt; XII 9, 1074b34)&lt;/small&gt;&lt;/span&gt;, und der innere Zusammenhang der &lt;span style=&quot;color:#FF6000&quot;&gt;„ultimativen Transzendentalia“&lt;/span&gt;, gilt nur in der &lt;span style=&quot;color:#FF6000&quot;&gt;„unverursachten Letztursache&quot;&lt;/span&gt;, auf die ARISTOTELES bei seiner Prinzipienforschung gestoßen ist.

Es gibt verschiedene Versuche, die GÖDEL-Axiome durch sog. ,Modelle‘, relativ zu einfacheren ,Welten‘, zu verifizieren, um damit ihre relative Konsistenz nachzuweisen. Für GÖDEL aber &lt;span style=&quot;color:#FF6000&quot;&gt;»''sind die Axiome nur dann'' &lt;span style=&quot;color:#00B000&quot;&gt;[ in unserer ,realen‘ Welt ]&lt;/span&gt; ''wahr'' &lt;span style=&quot;color:#00B000&quot;&gt;[ und annehmbar ]&lt;/span&gt;«&lt;/span&gt;, wenn sie &lt;span style=&quot;color:#FF6000&quot;&gt;»''unabhängig von der zufälligen Struktur der Welt'' &lt;span style=&quot;color:#00B000&quot;&gt;[ d.h. jeder auch nur ,möglichen‘ Welt ]&lt;/span&gt; ''sind''«&lt;/span&gt;. Diese Bedingung verweist jede Verifikation und jede Interpretation der Axiome auf das  ,Nicht-Zufällige‘, das ,Notwendige‘, ,Absolute‘, in dem die Axiome und Definitionen des GÖDEL-Kalküls erst dadurch ihren Sinn und ihre Bedeutung bekommen, wenn sie vom ,Absoluten‘ und ,Unendlichen‘ her erklärt und verstanden werden. Damit insistiert GÖDEL auf eine genuin &lt;span style=&quot;color:#4C58FF&quot;&gt;,theologische‘&lt;/span&gt; Interpretation seines Kalküls, mit der &lt;span style=&quot;color:#4C58FF&quot;&gt;„Theologie“&lt;/span&gt; zum Begriff GOTT, dem unbegrenzt Unendlichen, als Verifikationskriterium. Das entspricht auch der ,methodologischen‘ Prämisse seines Kalküls. Die wichtigsten Axiome und Definitionen im GÖDEL-Kalkül sind jedoch bloße ,Annahmen‘, deren Evidenz, sowohl die ,mathematische‘ als auch die &lt;span style=&quot;color:#4C58FF&quot;&gt;,theologische‘&lt;/span&gt;, erst evaluiert, d.h. ,bewiesen‘ &lt;span style=&quot;color:#00B000&quot;&gt;( ╞ )&lt;/span&gt; werden muss. Das bedeutet ''':''' die logische Verifikation der Axiome und Definitionen von GOTT und seinen Vollkommenheiten kann nur Kalkül-intern durch den Aufweis ihrer Widerspruchsfreiheit erfolgen, d.i. &lt;span style=&quot;color:#FF6000&quot;&gt;»''unabhängig von der zufälligen Struktur der Welt''«&lt;/span&gt;. Logisch evaluierte und verifizierte Axiome und Definitionen sind dann die ,modal‘ notwendigen, d.h. die ,transzendentalen‘ Voraussetzungen für die Ergebnisse eines Kalküls, damit seine Theoreme und Korollare in unserer ,realen‘ Welt als logisch ,wahr‘ und damit für uns auch als ,annehmbar‘ gelten können, während die Prämissen eines Kalküls, &lt;span style=&quot;color:#00B000&quot;&gt;(die Argument Einführung, &lt;span style=&quot;color:#4C58FF&quot;&gt;— '''AE:''' —&lt;/span&gt; )&lt;/span&gt;, nicht notwendige, und somit ,modal‘ frei gewählte ,Annahmen‘ sind. Jedoch aus diesen ,modal‘ frei gewählten, ,möglichen‘ &lt;span style=&quot;color:#00B000&quot;&gt;( &lt;span style=&quot;color:#4C58FF&quot;&gt;'''◇'''&lt;/span&gt; )&lt;/span&gt; Prämissen folgen mit Hilfe der ,bewiesenen‘ &lt;span style=&quot;color:#00B000&quot;&gt;( ╞ )&lt;/span&gt; Axiome und Definitionen die Ergebnisse mit ,modaler‘ Notwendigkeit &lt;span style=&quot;color:#00B000&quot;&gt;( &lt;span style=&quot;color:#4C58FF&quot;&gt;'''□'''&lt;/span&gt; )&lt;/span&gt;.

Die Logik des GÖDEL-Systems ist eine ,Prädikatenlogik‘ zweiter Stufe, in der die Quantoren nicht nur Individuum-Variable, sondern auch Eigenschafts-Variable, &lt;span style=&quot;color:#00B000&quot;&gt;(als noch ,unbestimmte‘ Prädikate im Allgemeinen)&lt;/span&gt;, binden können. Die formale Struktur des GÖDEL-Kalküls besteht aus fünf Axiomen und drei Definitionen, mit deren Hilfe in drei Beweisgängen drei Theoreme und mehrere Korollare aus seiner ,methodologischen‘ Prämisse ,regulär‘ &lt;span style=&quot;color:#00B000&quot;&gt;(├ )&lt;/span&gt; abgeleitet werden können, wobei die beiden ersten Beweisgänge, mit ihren Ergebnissen, den dritten vorbereiten, in dem es dann um das Theorem ANSELMS geht. Die Prämisse des GÖDEL-Kalküls in allen Beweisgängen ist der traditionelle ,GOTT-Glaube‘, in der Formulierung speziell nach LEIBNIZ. Ein Axiom, eine Definition, zwei Theoreme und alle Korollare im GÖDEL-Kalkül sind Aussagen über &lt;span style=&quot;color:#FF6000&quot;&gt;„GOTT“&lt;/span&gt;, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''G'''‘ —&lt;/span&gt;. Alle fünf Axiome, eine Definition und ein Theorem, &lt;span style=&quot;color:#00B000&quot;&gt;(und das Korollar aus Axiom-4)&lt;/span&gt;, sind auch Aussagen über die Eigenschaft &lt;span style=&quot;color:#FF6000&quot;&gt;„Vollkommenheit“, „Perfektion“&lt;/span&gt;, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''P'''‘ —&lt;/span&gt;, die in der &lt;span style=&quot;color:#FF6000&quot;&gt;»''theologischen Weltanschauung''«&lt;/span&gt; als die Wesenseigenschaft GOTTES gilt ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PG'''‘ —&lt;/span&gt;, &lt;span style=&quot;color:#FF6000&quot;&gt;»''GOTT ist vollkommen''«&lt;/span&gt; bzw. &lt;span style=&quot;color:#FF6000&quot;&gt;»''GOTT ist das Vollkommenste der Wesen''«&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(DESCARTES)&lt;/span&gt;. Zwei Definitionen sind Aussagen über die allgemeinen Wesenseigenschaften aller Seienden, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''X'''&lt;sub&gt;ess&lt;/sub&gt;‘ —&lt;/span&gt;, die Transzendentalien, die, als notwendige Existenz, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''E'''&lt;sub&gt;not&lt;/sub&gt;‘ —&lt;/span&gt;, auch GOTT zugeordnet werden, mit der Besonderheit bei GOTT, dass sowohl alle Eigenschaften, als auch alle anderen Zuordnungen, wie Sein und Wesen, wie Ursache und Wirkung, usw., im Unendlichen, GOTT, &lt;span style=&quot;color:#FF6000&quot;&gt;„koinzident“&lt;/span&gt; sind, d.h. in GOTT paarweise perspektivisch in ,eins‘ zusammenfallen, und die auch, als Transzendentalia, konvertierbar, d.h. austauschbar sind. Diese Sachverhalte machen deutlich, dass eine spezifische ,Verifikation‘ und sachgerechte ,Evaluierung‘ der GÖDEL-Axiomatik nur genuin &lt;span style=&quot;color:#4C58FF&quot;&gt;,theologisch‘&lt;/span&gt; erfolgen kann. Die Evaluierung der &lt;span style=&quot;color:#FF6000&quot;&gt;»''mathematischen Evidenz''«&lt;/span&gt; des GÖDEL-Systems, im Allgemeinen, muss jedoch entsprechend der Maßstäbe einer modalen Prädikatenlogik zweiter Stufe durchgeführt werden.

Das GÖDEL-Kalkül unterscheidet &lt;span style=&quot;color:#00B000&quot;&gt;(in Definition-3 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''E'''&lt;sub&gt;not&lt;/sub&gt;'''x ↔ ∀X(X'''&lt;sub&gt;ess&lt;/sub&gt;'''x →□∃yXy)'''‘ —&lt;/span&gt;)&lt;/span&gt; formal-syntaktisch zwischen der Eigenschaft ,Existenz‘, &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''E'''‘ —&lt;/span&gt;, die nur GOTT zugeordnet werden kann, und dem Existenz-Operator, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''∃'''‘ —&lt;/span&gt;, der auch allem Übrigen, das nicht GOTT ist, zugeordnet wird. Es gibt hier auch den formal-syntaktischen Unterschied zwischen der, &lt;span style=&quot;color:#00B000&quot;&gt;(von mir notierten, jedoch von GÖDEL schon intendierten und angesprochenen)&lt;/span&gt;, speziellen ,Notwendigkeit‘, &lt;span style=&quot;color:#4C58FF&quot;&gt; — &lt;sub&gt;not&lt;/sub&gt; —&lt;/span&gt;, die nur der Existenz GOTTES zugeordnet ist, und der modalen ,Notwendigkeit‘, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□'''‘ —&lt;/span&gt;, die auf Verschiedenes bezogen werden kann. Diese Unterschiede sind Hinweise, dass GÖDEL in seiner Kalkül-Logik und -Syntax, die Außerordentlichkeit und Eigenständigkeit GOTTES berücksichtigt, der, als Schöpfer der Welt, prinzipiell und absolut &lt;span style=&quot;color:#FF6000&quot;&gt;»''unabhängig von der zufälligen Struktur der Welt''«&lt;/span&gt; ist, die erst durch GOTT auch das ist, was sie ist.


===&lt;div class=&quot;center&quot;&gt;&lt;span style=&quot;color:#660066&quot;&gt;Die Genese des Kalküls&lt;/span&gt;&lt;/div&gt;===

Wie kommt GÖDEL zu seinem Kalkül '''?''' Sein Gewährsmann war Gottfried Wilhelm LEIBNIZ, &lt;span style=&quot;color:#00B000&quot;&gt;(1646-1716)&lt;/span&gt;, den er sehr schätzte. Die rekonstruierbare Genese seines Kalküls findet man in LEIBNIZ ''':'''  ''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;‚Neue Abhandlungen über den menschlichen Verstand‘&lt;/big&gt;&lt;/span&gt;'', &lt;span style=&quot;color:#00B000&quot;&gt;(1704)&lt;/span&gt;‚ ''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;Viertes Buch, Kapitel X ''':''' ‚Von unserer Erkenntnis des Daseins Gottes‘&lt;/big&gt;&lt;/span&gt;'', Seite 475f.

Hier der &lt;span style=&quot;color:#00B000&quot;&gt;[ kommentierte ]&lt;/span&gt; Textausschnitt zum sog. ontologischen ‚Gottesbeweis‘''':'''
::&lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;''Folgendes etwa ist der Gang seines'' &lt;span style=&quot;color:#00B000&quot;&gt;[ d.h. ANSELMS, Erzbischof von Canterbury; 1033-1109, ]&lt;/span&gt; ''Beweises ''':''' GOTT ist das Größte'', &lt;span style=&quot;color:#00B000&quot;&gt;[ ANSELM spricht vom biblischen GOTT des Glaubens, als ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''den, über dem ,Größeres‘'' | &lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;‚maius‘&lt;/big&gt;&lt;/span&gt; |  ''nicht mehr gedacht werden kann''«&lt;/span&gt; ]&lt;/span&gt;, ''oder, wie DESCARTES es ausdrückt ''':''' das Vollkommenste der Wesen oder auch ein Wesen von äußerster Größe und Vollkommenheit'' ''':''' &lt;span style=&quot;color:#00B000&quot;&gt; [ GÖDEL ''':''' &lt;/span&gt;&lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''P'''‘&lt;/span&gt;  &lt;span style=&quot;color:#00B000&quot;&gt;:= ‚Perfektion‘, ‚positive Eigenschaft‘ ]&lt;/span&gt;, ''das alle Grade derselben in sich schließt.''&lt;span style=&quot;color:#00B000&quot;&gt; [ GÖDEL-Definition-1 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx↔∀X(PX→Xx)'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Das Individuum'' &lt;span style=&quot;color:#4C58FF&quot;&gt;,'''x'''‘&lt;/span&gt; ''ist genau dann GOTT'', &lt;span style=&quot;color:#4C58FF&quot;&gt;,'''G'''‘&lt;/span&gt;, ''wenn'' &lt;span style=&quot;color:#4C58FF&quot;&gt;,'''x'''‘&lt;/span&gt; ''alle Vollkommenheiten'', &lt;span style=&quot;color:#4C58FF&quot;&gt;,'''P'''‘&lt;/span&gt;, ''in sich schließt''«&lt;/span&gt;. Definition-1 bildet die traditionelle Vorstellung von GOTT ab. ]&lt;/span&gt; ''Dies also ist der Begriff GOTTES.'' &lt;span style=&quot;color:#00B000&quot;&gt;[ Der Term &lt;span style=&quot;color:#4C58FF&quot;&gt;— ,'''G'''‘ —&lt;/span&gt; steht hier für den biblischen ‚Begriff‘  &lt;span style=&quot;color:#FF6000&quot;&gt;„GOTT“&lt;/span&gt; als ,Individuumname‘ '''!''' ]&lt;/span&gt; ''Sehen wir nun, wie aus diesem Begriff das ‚Dasein’ folgt.''&lt;span style=&quot;color:#00B000&quot;&gt; [ GÖDEL ''':'''  &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□∃xGx'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''GOTT ist notwendig aus sich ‚da‘''«&lt;/span&gt; ''':''' Term :10:, 1. Hauptergebnis im 3. Beweisgang. ]&lt;/span&gt; ''Es ist etwas &lt;u&gt;mehr&lt;/u&gt;, ‚da‘ zu sein, als nicht ‚da‘ zu sein, oder auch das ‚Dasein‘ fügt der Größe oder der Vollkommenheit'' &lt;span style=&quot;color:#00B000&quot;&gt;[ GOTTES ]&lt;/span&gt; ''einen Grad hinzu, und wie DESCARTES es ausspricht, das ‚Dasein‘ ist selbst eine Vollkommenheit.''&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt; 

&lt;span style=&quot;color:#00B000&quot;&gt;(Diesen Ausspruch DESCARTES übernimmt GÖDEL im Axiom-5 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''PE'''&lt;sub&gt;not&lt;/sub&gt;‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''notwendige Existenz''&lt;/span&gt; [ alias ‚Dasein GOTTES’ ] &lt;span style=&quot;color:#FF6000&quot;&gt;''ist eine positive Eigenschaft''&lt;/span&gt; [ alias Vollkommenheit ]&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;. Dem widerspricht KANT ''':'''  &lt;span style=&quot;color:#FF6000&quot;&gt;„Existenz ist keine Eigenschaft“&lt;/span&gt;, bzw. &lt;span style=&quot;color:#FF6000&quot;&gt;»''Sein ist kein reales Prädikat''«&lt;/span&gt;. Das Axiom-5 ist daher nur dann ‚wahr‘, wenn ‚Wirklichsein‘ | &lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;ἐνέργεια οὖσα&lt;/big&gt;&lt;/span&gt;“&lt;/span&gt; | ‚enérgeia oúsa‘ | d.h. ‚Dasein‘ und ‚Wesen‘ | &lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;οὐσία&lt;/big&gt;&lt;/span&gt;“&lt;/span&gt; | ‚ousía‘ | — genauer ''':''' ‚Wesenseigenschaften’ —, ontologisch ,eins‘ sind, d.h. wenn &lt;span style=&quot;color:#FF6000&quot;&gt;„Existieren“&lt;/span&gt; immer schon die &lt;span style=&quot;color:#FF6000&quot;&gt;„Wesenseigenschaft“&lt;/span&gt; GOTTES ist. Was nach ARISTOTELES nur im &lt;span style=&quot;color:#FF6000&quot;&gt;„unbewegten Erstbeweger“&lt;/span&gt; der Fall ist; bzw. mit LEIBNIZ ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''was das Privilegium der Gottheit allein ist''«&lt;/span&gt; '''!''' Aus der ,methodologischen‘ ,Annahme‘ im 2. Beweisgang GÖDELS ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''das'' &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''x'''‘&lt;/span&gt; ''steht für den GOTT der Christen''«&lt;/span&gt;, und mit Hilfe von Axiom-3 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PG'''‘ —&lt;/span&gt;  ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Göttlichkeit  ist eine positive Eigenschaft''«&lt;/span&gt;, bzw. &lt;span style=&quot;color:#FF6000&quot;&gt;»''GOTT ist perfekt''«&lt;/span&gt;, mit Axiom-4 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PX → □PX'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Positive Eigenschaften sind notwendig aus sich, — von Natur aus —, positiv''«&lt;/span&gt;, mit  Definition-2 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''X'''&lt;sub&gt;ess&lt;/sub&gt;'''x ↔ Xx ∧ ∀Y(Yx→ □∀y(Xy→Yy))'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Zum Wesen gehören notwendig auch alle Konsequenzen aus einer Wesenseigenschaft''«&lt;/span&gt;, und mit Axiom-1 und der Definition für GOTT, folgt nach einigen logischen Umformungen das GÖDEL-Theorem-2 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx↔G'''&lt;sub&gt;ess&lt;/sub&gt;'''x'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Das'' &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''x'''‘&lt;/span&gt; ''ist genau dann der GOTT der Christen, wenn das Wesen dieses GOTTES sein eigenes Sein ist''«&lt;/span&gt;. Dasein und Wesen sind im Unendlichen, GOTT &lt;span style=&quot;color:#FF6000&quot;&gt;„koinzident“&lt;/span&gt; ,eins‘, übereinstimmend mit dem Theorem des ARISTOTELES. Mit diesem, im Kalkül &lt;u&gt;ohne&lt;/u&gt;  Axiom-5 ,regulär‘ (├ ) abgeleiteten Theorem, widerlegt er KANT für den individuellen Spezialfall &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''G'''‘&lt;/span&gt; := &lt;span style=&quot;color:#FF6000&quot;&gt;„GOTT“&lt;/span&gt;. Nachprüfbar im Anhang ''':''' im ‚ontologischen‘ Beweis für das Basis-Theorem-2. Somit ist Axiom-5 ,wahr‘, und KANT, der &lt;span style=&quot;color:#FF6000&quot;&gt;»''eine Abneigung gegen das Gebet hatte''«&lt;/span&gt; und auch &lt;span style=&quot;color:#FF6000&quot;&gt;»''nie zu den sonntäglichen Kirchgängern zählte''«&lt;/span&gt;&lt;ref&gt;Uwe SCHULTZ ''':''' ‚''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;Immanuel Kant&lt;/big&gt;&lt;/span&gt;''‘, Rowohlt Monographie 50659, Seite 12&lt;/ref&gt;, hat sich hier, im Bezug auf GOTT, geirrt. &lt;span style=&quot;color:#4C58FF&quot;&gt;„Theologie“&lt;/span&gt;, als Wissenschaft von GOTT, war für KANT nie eine ernstzunehmende Option. Die &lt;span style=&quot;color:#4C58FF&quot;&gt;„Theologie“&lt;/span&gt;, als Wissenschaft von GOTT, die natürlich immer auch verbunden sein muss mit der täglichen ,Erfahrung‘ einer Glaubens-Praxis, im Gebet und in den Gottesdienst-Feiern des &lt;span style=&quot;color:#4C58FF&quot;&gt;„Theologen“&lt;/span&gt;, und die daraus entsteht, ist eine ziemlich ,ausgereifte‘ Disziplin. Es haben sich, durch Jahrhunderte hindurch, viele gläubige und auch gescheite Menschen, schon im Judentum, und dann im Christentum, und ebenfalls im Islam, darum bemüht.)&lt;/span&gt; 

:: &lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;''Darum ist dieser Grad von Größe und Vollkommenheit oder auch diese Vollkommenheit, welche im ‚Dasein‘ besteht, in diesem höchsten, durchaus großen, ganz vollkommenen Wesen, denn sonst würde ihm ein Grad fehlen, was gegen seine Definition wäre. Und folglich ist dies höchste Wesen ‚da‘. Die Scholastiker, ohne selbst ihren'' &lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;doctor angelicus&lt;/big&gt;&lt;/span&gt;  &lt;span style=&quot;color:#00B000&quot;&gt;[ := THOMAS von Aquin ]&lt;/span&gt; ''auszunehmen, haben diesen Beweis verachtet'', &lt;span style=&quot;color:#00B000&quot;&gt;[ wie später auch Immanuel KANT ]&lt;/span&gt;, ''und ihn als einen Paralogismus'' &lt;span style=&quot;color:#00B000&quot;&gt;[ := Fehlschluss ]&lt;/span&gt; ''betrachtet, worin sie sehr unrecht gehabt haben; und DESCARTES, welcher die scholastische Philosophie im Kolleg der Jesuiten zu La Flèche lange genug studiert hatte, hat sehr recht gehabt, ihn wieder zu Ehren zu bringen. Es ist nicht ein Paralogismus, sondern ein unvollständiger Beweis'', &lt;span style=&quot;color:#00B000&quot;&gt;[ den GÖDEL vervollständigt hat ]&lt;/span&gt;, ''der etwas voraussetzt, was man noch hätte beweisen sollen, um ihm mathematische Evidenz zu verleihen — nämlich, dass man dabei stillschweigend voraussetzt, diese Vorstellung des durchaus großen oder durchaus vollkommenen Wesens sei möglich und enthalte keinen Widerspruch'' &lt;span style=&quot;color:#00B000&quot;&gt;[ '''::''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— '''◇''' —&lt;/span&gt; '''::''' ,möglich‘, ,konsistent‘, ,denkbar‘; GÖDEL beweist im 1. Beweisgang Theorem-1 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PX→◇∃xXx'''‘ —&lt;/span&gt;, &lt;span style=&quot;color:#FF6000&quot;&gt;»''positive Eigenschaften'', &lt;span style=&quot;color:#00B000&quot;&gt;[ die allgemeinen Transzendentalien ]&lt;/span&gt;, ''sind widerspruchsfrei''«&lt;/span&gt;, und mit Axiom-3 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PG'''‘ —&lt;/span&gt;, folgt Korollar-1 ''':'''  &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''◇∃xGx'''‘ —&lt;/span&gt;, &lt;span style=&quot;color:#FF6000&quot;&gt;»''GOTT ist widerspruchsfrei möglich''«&lt;/span&gt; ]&lt;/span&gt;. ''Und es ist schon etwas, dass man durch diese Bemerkung beweist ''':''' gesetzt, dass GOTT'' &lt;span style=&quot;color:#00B000&quot;&gt;['' &lt;span style=&quot;color:#FF6000&quot;&gt;»widerspruchsfrei«&lt;/span&gt; '']&lt;/span&gt; '',möglich‘ ist, so ‚ist‘ er'' &lt;span style=&quot;color:#00B000&quot;&gt;[ ,notwendig‘ '''::''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— '''□''' —&lt;/span&gt; '''::''' für jede mögliche Welt auch wirklich aus sich ‚da‘ ]&lt;/span&gt;, ''was das Privilegium der Gottheit allein ist'' ''':''' &lt;span style=&quot;color:#00B000&quot;&gt;[ Im 3. Beweisgang, Theorem-3 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''◇∃xGx→□∃xGx'''‘ —&lt;/span&gt; ''':''' ‚ANSELMS Prinzip‘ ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Weil GOTT widerspruchsfrei ,möglich‘ ist, darum ist auch der Glaube widerspruchsfrei, der annimmt, dass GOTT aus sich ,notwendig‘ da ist''«&lt;/span&gt;; mit dem Korollar-3, das A. FUHRMANN konzipiert hat ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□∃xGx ∧ □∀y(Gy→x=y)'''‘ —&lt;/span&gt;, &lt;span style=&quot;color:#FF6000&quot;&gt;»''Es gibt notwendig nur einen einzigen GOTT''«&lt;/span&gt;. Damit ist auch der Monotheïsmus bewiesen. ]&lt;/span&gt; ''Man hat recht, die Möglichkeit eines jeden Wesens anzunehmen und vor allem die GOTTES, bis ein anderer das Gegenteil beweist''. &lt;span style=&quot;color:#00B000&quot;&gt;[ Das Gegenteil besagt, dass GOTT ,unmöglich‘ ist. Hier setzt der Möglichkeitsbeweis im GÖDEL-Kalkül an, und beweist, dass diese Aussage zu einem Widerspruch führt, im Anhang ''':''' ,Widerlegung‘. ]&lt;/span&gt; ''Somit gibt dieser metaphysische Beweis schon einen moralischen zwingenden Schluss ab, wonach wir dem gegenwärtigen Stande unserer Erkenntnisse zufolge urteilen müssen, dass GOTT ‚da‘ sei, und demgemäß handeln.'' &lt;span style=&quot;color:#00B000&quot;&gt;[ Aber nicht logisch zwingend '''!''' Denn die Interpretation &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''G'''‘ —&lt;/span&gt; mit dem GOTT der Bibel, als ,methodologische‘ Kalkül-Prämisse, ist nicht zwingend, jedoch ,modal‘ möglich, &lt;span style=&quot;color:#4C58FF&quot;&gt;— '''◇''' —&lt;/span&gt;, und im christlichen Glaubenskontext sinnvoll, was mit einer stimmigen &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologischen“&lt;/span&gt; Interpretation des GÖDEL-Kalküls gezeigt werden kann. Damit wäre dann auch die Frage beantwortet, ob das GÖDEL-System sich plausibel als eine Theorie von GOTT und seinen Eigenschaften interpretieren lässt, bzw. als eine &lt;span style=&quot;color:#FF6000&quot;&gt;»''axiomatische''«&lt;/span&gt; &lt;span style=&quot;color:#4C58FF&quot;&gt;„Theologie“&lt;/span&gt;, wie sie André FUHRMANN apostrophiert. Das &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''G'''‘ —&lt;/span&gt; ist der ,Individuumname‘ für den GOTT der Bibel, — ,GOTT‘ groß geschrieben —, im monotheïstischen, christlichen Glaubenskontext, den auch LEIBNIZ teilt. Dann steht der ,Name‘ auch synonym für das ,existierende‘ Individuum, d.h. für dessen ,Existenz‘. ]&lt;/span&gt; ''Es wäre aber doch zu wünschen, dass gescheite Männer'' &lt;span style=&quot;color:#00B000&quot;&gt;[ sic ! ]&lt;/span&gt; ''den Beweis mit der Strenge einer mathematischen Evidenz vollendeten'', &lt;span style=&quot;color:#00B000&quot;&gt;[ was GÖDEL veranlasst hat, seine Version eines ‚ontologischen Beweises’ zu kreieren, dessen &lt;span style=&quot;color:#FF6000&quot;&gt;»''mathematische Evidenz''«&lt;/span&gt; man heute mit Computerprogrammen&lt;ref&gt;siehe Fußnote 12&lt;/ref&gt; schon nachgewiesen hat ]&lt;/span&gt; ... &lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;. 

Für GÖDEL war dieser Text eine intellektuelle Herausforderung, und er hat sie angenommen. Das war für GÖDEL sicher keine Glaubensangelegenheit. GOTT hat es ja auch nicht nötig, ‚bewiesen‘ zu werden. Wer &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''G'''‘ —&lt;/span&gt; z. B. mit dem sog. ‚Urknall‘ gleich setzt, macht die &lt;span style=&quot;color:#FF6000&quot;&gt;»''zufällige Struktur der Welt''«&lt;/span&gt; im ‚Urknall‘, &lt;span style=&quot;color:#00B000&quot;&gt;(pantheistisch)&lt;/span&gt; zu einem ,Gott‘, was GÖDEL dezidiert für sein Kalkül ausgeschlossen haben wollte. 

Kurt GÖDEL schreibt 1961 in einem Brief, in Anlehnung an den obigen Text ''':'''
::&lt;span style=&quot;color:#FF6000&quot;&gt;»...''ich glaube, schon heute dürfte es möglich sein, rein verstandesmäßig ''&lt;span style=&quot;color:#00B000&quot;&gt;[ sic '''!''' ]&lt;/span&gt;, ''(ohne sich auf den Glauben an irgendeine Religion zu stützen) einzusehen, dass die theologische Weltanschauung'', &lt;span style=&quot;color:#00B000&quot;&gt;[ dass es GOTT gibt ]&lt;/span&gt;, ''mit allen bekannten Tatsachen'', &lt;span style=&quot;color:#00B000&quot;&gt;[ z. B. mit den Maßstäben einer modernen Logik ]&lt;/span&gt;, ''durchaus vereinbar ist. Das hat schon vor 250 Jahren der berühmte Philosoph und Mathematiker LEIBNIZ versucht''.«&lt;/span&gt;&lt;ref&gt;Zitiert nach SCHIMANOVICH-GALIDESCU, M.-E. ''':''' ‚''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;Princeton–Wien 1946–1966. Briefe an die Mutter&lt;/big&gt;&lt;/span&gt;''‘, in ‚''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;Kurt Gödel – Leben und Werk&lt;/big&gt;&lt;/span&gt;''‘, Hg. B.BULDT et alia, Wien (HÖLDER–PICHLER–TEMSKY), 2001, Band 1&lt;/ref&gt;


===&lt;div class=&quot;center&quot;&gt;&lt;span style=&quot;color:#660066&quot;&gt;Die Interpretation des Kalküls&lt;/span&gt;&lt;/div&gt;===

Wenn man sich das GÖDEL-Kalkül ansieht, wie es heute formalisiert vorliegt, stellt sich die Frage ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;„Lässt sich dieses System plausibel als eine Theorie von GOTT &lt;span style=&quot;color:#00B000&quot;&gt;(als eine ‚Rede von GOTT’ := &lt;span style=&quot;color:#4C58FF&quot;&gt;,Theologie’&lt;/span&gt;)&lt;/span&gt; und seiner Eigenschaften verstehen  '''?'''  “ — „Ist hier eine genuin &lt;span style=&quot;color:#4C58FF&quot;&gt;,theologische’&lt;/span&gt; Interpretation möglich '''?''' “&lt;/span&gt; Seine Herkunft aus der intellektuellen Auseinandersetzung des Logikers GÖDEL mit dem GOTT-gläubigen Philosophen LEIBNIZ und dem christlichen Theologen und Erzbischof ANSELM rechtfertigt diese Frage. Die &lt;span style=&quot;color:#FF6000&quot;&gt;„mathematische Evidenz“&lt;/span&gt; des GÖDEL-Formalismus, &lt;span style=&quot;color:#00B000&quot;&gt;(im Anhang nachgestellt)&lt;/span&gt;, ist allgemein anerkannt, &lt;span style=&quot;color:#00B000&quot;&gt;(Vorbehalte dagegen gibt es nur bei der Interpretation seiner Syntax, d.h. ob die Axiome und Definitionen, wie GÖDEL sie konzipiert hat, bzw. ob die Theoreme und Korollare, die aus diesen Axiomen ,regulär’ (├ ) abgeleitet werden, auch in unserer realen Welt ,wahr’ und ,annehmbar’ sind)&lt;/span&gt;. Die &lt;span style=&quot;color:#FF6000&quot;&gt;„theologische Evidenz“&lt;/span&gt; des GÖDEL-Systems wird durch eine ,Verankerung’ der Axiome und Definitionen in den &lt;span style=&quot;color:#4C58FF&quot;&gt;,theologisch’&lt;/span&gt;-philosophischen Diskurs über GOTT evaluiert, der schon seit zweieinhalbtausend Jahren läuft. In diesen zweieinhalbtausend Jahren hat sich, — gegen ARISTOTELES und die antike Philosophie —, die Erkenntnis durchgesetzt, dass GOTT &lt;span style=&quot;color:#FF6000&quot;&gt;»''unabhängig''«&lt;/span&gt; von der &lt;span style=&quot;color:#FF6000&quot;&gt;»''zufälligen''«&lt;/span&gt; Raum-Zeit-Struktur unserer vergänglichen Welt ist. In meiner Darstellung des GÖDEL-Kalküls folge ich, &lt;span style=&quot;color:#00B000&quot;&gt;(im Unterschied zum Autographen GÖDELS, vom 10. Feb 1970)&lt;/span&gt;, in der Axiom-Formulierung und -Nummerierung, in der Syntax, und in der Beweis-Struktur, der Arbeit von André FUHRMANN ''':''' ''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;‚Existenz und Notwendigkeit. Kurt Gödels axiomatische Theologie‘&lt;/big&gt;&lt;/span&gt;'' in ''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;‚Logik in der Philosophie‘&lt;/big&gt;&lt;/span&gt;'' Hg. SCHROEDER-HEISTER, SPOHN und OLSSON, 2005, Synchron, Heidelberg, Seite 349–374. &lt;span style=&quot;color:#00B000&quot;&gt;(Die tiefer gestellte Notation der spezifischen ,Eigenschaft‘ einer Eigenschaft ist meine Ergänzung zur formalen Syntax, z. B. ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''G'''&lt;sub&gt;ess&lt;/sub&gt;'''x'''‘ — &lt;/span&gt;, angeregt durch die indizierende Schreibweise GÖDELS ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ,'''G''' Ess. '''x'''’ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''das'' &lt;span style=&quot;color:#4C58FF&quot;&gt;,'''x'''’&lt;/span&gt; ''ist wesentlich göttlich''«&lt;/span&gt;, m.a.W. &lt;span style=&quot;color:#FF6000&quot;&gt;»''das Individuum'' &lt;span style=&quot;color:#4C58FF&quot;&gt;,'''x'''’&lt;/span&gt; ''hat die Wesenseigenschaft, GOTT zu sein''«&lt;/span&gt;.)&lt;/span&gt; Die Erkenntnisse zur Straffung und Präzisierung der GÖDEL-Syntax, &lt;span style=&quot;color:#00B000&quot;&gt;(besonders im Möglichkeitsbeweis)&lt;/span&gt;, stammen aus der Arbeit von Günther J. WIRSCHING ''':''' ,''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;Der Gödelsche Gottesbeweis&lt;/big&gt;&lt;/span&gt;''‘, im Web &lt;ref&gt;https://edoc.ku.de/id/eprint/10243/1/OntBw.pdf&lt;/ref&gt;. &lt;span style=&quot;color:#00B000&quot;&gt;(Auch der Hinweis auf AVICENNA kommt von WIRSCHING.)&lt;/span&gt; Die Zitate von THOMAS von Aquin´s Stellungnahme zum Theorem ANSELMS, und von Georg Wilhelm Friedrich HEGEL zur Immanuel KANTS Ablehnung des Theorem ANSELMS, befinden sich in Franz SCHUPP, ,&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;''Geschichte der Philosophie im Überblick''&lt;/big&gt;&lt;/span&gt;‘, Band 2 ‚&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;''Christliche Antike, Mittelalter''&lt;/big&gt;&lt;/span&gt;‘, Hamburg 2003, Seite 168 und Seite 170.

Meines Erachtens ist der entscheidende Ansatzpunkt einer &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologischen“&lt;/span&gt; Interpretation das GÖDEL-Axiom-5 ''':'''  &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PE'''&lt;sub&gt;not&lt;/sub&gt;‘ —&lt;/span&gt;, &lt;span style=&quot;color:#FF6000&quot;&gt;»''notwendige Existenz ist eine positive Eigenschaft''«&lt;/span&gt;.    

‚Frei‘ nach KANT ‚formuliere‘ ich ‚kurz‘ ''':'''  &lt;span style=&quot;color:#FF6000&quot;&gt;„Existenz ist keine Eigenschaft“&lt;/span&gt;. Hier die Positionen KANTS zum Thema ‚Existenz‘ und ‚Eigenschaften‘ ''':''' 
::&lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;''… unbeschadet der wirklichen Existenz äußerer Dinge'', &lt;span style=&quot;color:#00B000&quot;&gt;[ kann man ]&lt;/span&gt; ''von einer Menge ihrer Prädikate'', &lt;span style=&quot;color:#00B000&quot;&gt;[ d.h. Eigenschaften ],&lt;/span&gt;  ''sagen'' … ''':'''  ''sie gehöreten nicht zu diesen ‚Dingen an sich selbst‘, sondern nur zu ihren Erscheinungen, und hätten außer unserer Vorstellung'' &lt;span style=&quot;color:#00B000&quot;&gt;[ ihrer, als ,wirklich‘ gedachten Erscheinung, ]&lt;/span&gt; ''keine eigene Existenz, … weil ich finde, dass …  '''alle Eigenschaften, die die Anschauung eines Körpers ausmachen''', bloß zu seiner Erscheinung gehören; denn die Existenz des Dinges, was erscheint, wird dadurch nicht … aufgehoben, sondern nur gezeigt, dass wir es'', &lt;span style=&quot;color:#00B000&quot;&gt;[ das Ding ]&lt;/span&gt;, ''wie es ‚an sich selbst‘ sei'', &lt;span style=&quot;color:#00B000&quot;&gt;[ d.h. existiert ]&lt;/span&gt;, ''durch Sinne gar nicht erkennen können''.&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;&lt;ref&gt;vgl. ‚''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;Prolegomena zu einer jeden künftigen Metaphysik, die als Wissenschaft wird auftreten können&lt;/big&gt;&lt;/span&gt;''‘, Seite 289; https://www.korpora.org/kant/aa04/289.html&lt;/ref&gt; &lt;span style=&quot;color:#00B000&quot;&gt;&lt;small&gt;(Hervorhebung durch KANT.)&lt;/small&gt; [ Seine Prädikate, d.h. Eigenschaften, jedoch können wir mit unseren Sinnen ,anschauen‘, aber nur in Kombination mit unserer Vorstellung ihrer, als ,wirklich‘ gedachten Erscheinung, vermittelt durch den sog. ,transzendentalen Schematismus‘ unserer Einbildungskraft ''':'''&lt;/span&gt; &lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;''Eine verborgene Kunst in den Tiefen der menschlichen Seele''&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;jedoch auch eines der ,dunkelsten‘ Kapitel in der K.d.r.V., bedingt durch KANTS Konzept von ,Wirklichkeit‘, bzw. ,Sein‘. ]&lt;/span&gt;

Mit anderen Worten, man kann die ‚Existenz‘, bzw. das ‚Sein‘ der Dinge, &lt;span style=&quot;color:#00B000&quot;&gt;(das ‚Ding an sich’ bei KANT)&lt;/span&gt;, nicht unter dem Mikroskop finden. Die ‚Existenz‘ bzw. das ‚Sein‘ ist keine sinnlich registrierbare ‚Eigenschaft‘ z. B. des rekonstruierten ‚Stadt-Schlosses‘ in Berlin. &lt;span style=&quot;color:#00B000&quot;&gt;(‚Sein‘ ist kein reales ‚Prädikat‘.)&lt;/span&gt; Dafür haben wir andere Fähigkeiten ''':''' Ich kann seine ‚Existenz‘ mit meinem Verstand einsehen, weil auch ich selbst ‚existiere‘. Seine ‚Ansicht‘, wie ‚gefällig‘ es ist, und auch weitere ‚Eigenschaften‘, die mir auffallen, kann ich mit einem Handy-Foto dokumentieren. Diese ‚Eigenschaften‘ sind nicht die Ursache, dass das ‚Berliner Schloss‘ existiert. Wohl aber die Rekonstruktion dieses Schlosses ist die ‚Ursache‘, dass es ,existiert‘, und jetzt so aussieht. Insofern ist ‚Existenz‘ keine ‚Eigenschaft‘, sondern die ‚Existenz‘ des Dinges ist die Voraussetzung, der ‚Grund‘, dass ich die ‚Eigenschaften‘ des Dinges mit meinen Sinnen feststellen kann. 

In einer Auseinandersetzung mit CARTESIUS schreibt KANT, philosophisch ‚tiefgründig‘ und logisch ‚exakt‘, über dessen &lt;span style=&quot;color:#FF6000&quot;&gt;&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;„Cogito, ergo sum“&lt;/big&gt;&lt;/span&gt;&lt;/span&gt; ''':'''  
::&lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;''Das ‚Ich denke‘ ist ein empirischer Satz, und hält den Satz ‚Ich existiere‘ in sich. Ich kann aber nicht sagen ''':''' ‚Alles, was denkt, existiert‘; denn da würde die Eigenschaft des Denkens'', &lt;span style=&quot;color:#00B000&quot;&gt;[ eine essentielle Eigenschaft ]&lt;/span&gt;, ''alle Wesen, die sie besitzen, zu notwendigen'' &lt;span style=&quot;color:#00B000&quot;&gt;[ d.h. notwendig existierenden ]&lt;/span&gt; ''Wesen machen''. &lt;span style=&quot;color:#00B000&quot;&gt;[ Was allein nur von GOTT ausgesagt werden kann; mit AVICENNA, als anerkannter ARISTOTELES-Kommentator ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''GOTT ist das einzige Sein, bei dem Essenz'' &lt;span style=&quot;color:#00B000&quot;&gt;[ ‚Wesenseigenschaften‘ ]&lt;/span&gt; ''und Existenz'' &lt;span style=&quot;color:#00B000&quot;&gt;[ ‚Dasein‘ ]&lt;/span&gt; ''nicht zu trennen sind und das daher notwendig an sich da ist''«, &lt;span style=&quot;color:#00B000&quot;&gt;— konform mit GÖDEL ''':'''&lt;/span&gt;  »''notwendige Existenz ist eine positive'' &lt;span style=&quot;color:#00B000&quot;&gt;[ essentielle ]&lt;/span&gt; ''Eigenschaft''«&lt;/span&gt; ].&lt;/span&gt; ''Daher kann meine Existenz auch nicht aus dem Satz, ‚Ich denke‘, als'' &lt;span style=&quot;color:#00B000&quot;&gt;[ logisch ]&lt;/span&gt; ''gefolgert angesehen werden, wie CARTESIUS dafür hielt (weil sonst der Obersatz : ‚Alles, was denkt, existiert‘, vorausgehen müsste), sondern ist mit ihm identisch.'' &lt;span style=&quot;color:#00B000&quot;&gt;[ Eine einfache Schlussfolgerung ''':''' meine ‚Existenz‘ ist auch nicht von meiner ‚Eigenschaft‘ Denken ‚verursacht‘. ,Existenz‘ ist nicht bloß ein ,Gedanke‘ von mir. ]&lt;/span&gt;&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;(Aus der Anmerkung 41 zu den ‚''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;Paralogismen der reinen Vernunft&lt;/big&gt;&lt;/span&gt;''‘, in ‚''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;Kritik der reinen Vernunft&lt;/big&gt;&lt;/span&gt;''‘, Seite 275,&lt;ref&gt;https://korpora.org/kant/aa03/275.html&lt;/ref&gt; mit meinem Einschub des AVICENNA-Zitat aus Wikipedia.&lt;ref&gt;{{w|Avicenna#Metaphysik}}&lt;/ref&gt;)&lt;/span&gt; 

Mit anderen Worten ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;„Die Eigenschaft, dass ich denken kann, ist nicht die Ursache meiner ‚Existenz‘“&lt;/span&gt;, sondern, &lt;span style=&quot;color:#FF6000&quot;&gt;„Die Liebe meiner Eltern und ihre Entscheidung füreinander ist die Ursache meiner ‚Existenz‘. Daher ‚bin’ ich. Und weil ich ein Mensch ‚bin‘, kann ich denken.“&lt;/span&gt; Auch mit diesen Anmerkungen ist leicht einsehbar, dass ‚Existenz‘ keine ‚Eigenschaft‘ ist — außer bei GOTT. In GOTT ist ‚Dasein‘ die ‚Wesenseigenschaft‘ GOTTES, d.h. ‚Dasein‘ und ‚Wesen‘ sind in GOTT untrennbar verbunden; sind &lt;span style=&quot;color:#FF6000&quot;&gt;„koinzident“&lt;/span&gt; ‚eins‘. Das ist die Einzigartigkeit im Wesen GOTTES, dass GOTT immer schon ‚da‘ ist. Die Frage nach dem ‚Wesen‘ GOTTES lautet ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;„Was bist du ? “&lt;/span&gt;/&lt;span style=&quot;color:#CC66FF&quot;&gt;„Wer bist Du ? “&lt;/span&gt; Antwort, Exodus 3,14 ''':''' &lt;span style=&quot;color:#CC66FF&quot;&gt;»''Ich bin der ‚Ich-Bin-Da‘'' &lt;span style=&quot;color:#00B000&quot;&gt;[ für euch und für immer ]&lt;/span&gt;«.&lt;/span&gt; Weil GOTT für uns immer schon ‚da‘ ist, — &lt;span style=&quot;color:#CC66FF&quot;&gt;„von Ewigkeit zu Ewigkeit“&lt;/span&gt; —, hat GOTT es nicht nötig, ‚bewiesen‘ zu werden. &lt;span style=&quot;color:#00B000&quot;&gt;(In der Mathematik ist ein ‚Satz‘ erst dann ‚wahr‘ und ‚existent‘, wenn er bewiesen ist. Bei GOTT ist es jedoch nicht so ''':''' GOTTES ‚Existenz‘ ist nicht erst dann ‚wahr‘, wenn seine ‚Existenz‘ von uns ‚bewiesen‘ ist. Sein ‚Dasein‘ ist jedem unserer ‚Beweisversuche‘ immer schon voraus. Der Zugang zu GOTT ist nicht der ,Beweis‘, sondern der ,Glaube‘. Wer an GOTT glauben ,will‘, dem antwortet GOTT. Wer nicht an GOTT glauben ,will‘, dessen Entscheidung respektiert GOTT, und drängt sich nicht auf. Die Glaubens-Entscheidung hat jedoch für jeden Menschen eine existenzielle Konsequenz ''':''' &lt;span style=&quot;color:#CC66FF&quot;&gt;»''Wer glaubt und sich taufen lässt, wird gerettet; wer aber nicht glaubt'', &lt;span style=&quot;color:#00B000&quot;&gt;[ und diese Entscheidung auch im Augenblick der ,Wahrheit‘, im Tod, in der sog. ,Endentscheidung‘, nicht widerruft ]&lt;/span&gt;, ''wird verurteilt werden''«,&lt;/span&gt; &lt;small&gt;({{Bibel | Markus Evangelium |16|16|EU}})&lt;/small&gt;. Das Urteil lautet ''':''' &lt;span style=&quot;color:#CC66FF&quot;&gt;»''zweiter Tod ''':''' der Feuersee''«&lt;/span&gt;, &lt;small&gt;({{Bibel | Offenbarung |20|14f|EU}})&lt;/small&gt;, ohne Berufungsmöglichkeit. &lt;span style=&quot;color:#CC66FF&quot;&gt;»''Ohne Glauben aber ist es unmöglich, Gott zu gefallen; denn wer zu Gott kommen will, muss glauben, dass er ist und dass er denen, die ihn suchen, ihren Lohn geben wird''«.&lt;/span&gt; &lt;small&gt;({{Bibel | Hebräer Brief |11|6|LUT}})&lt;/small&gt;)&lt;/span&gt;

Das GÖDEL-Axiom-5 ist m.E. der entscheidende Ansatzpunkt einer stimmigen &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologischen“&lt;/span&gt; Interpretation der GÖDEL-Axiomatik.


===&lt;div class=&quot;center&quot;&gt;&lt;span style=&quot;color:#660066&quot;&gt;Das Kalkül ist kein Existenz-Beweis für GOTT&lt;/span&gt;&lt;/div&gt;=== 

Die allgemeine &lt;span style=&quot;color:#FF6000&quot;&gt;»''mathematische Evidenz''«&lt;/span&gt; des GÖDEL-Formalismus, d.h. seine ‚Schlusskraft‘, ist von kompetenten Leuten&lt;ref&gt;„GÖDELS Argumentationskette ist nachweisbar korrekt – so viel hat der Computer nach Ansicht der Wissenschaftler Christoph BENZMÜLLER und Bruno WOLTZENLOGEL-PALEO nun gezeigt;“ vgl. https://www.fu-berlin.de/presse/informationen/fup/2013/fup_13_308/index.html&lt;/ref&gt; schon festgestellt worden, &lt;span style=&quot;color:#00B000&quot;&gt;(im Anhang ‚nachrechenbar‘ mit den Regeln und Gesetzen einer modalen Prädikatenlogik 2. Stufe)&lt;/span&gt;. Das GÖDEL-Kalkül ist jedoch kein ‚moderner‘&lt;span style=&quot;color:#FF6000&quot;&gt;„Existenz-Beweis“&lt;/span&gt; für GOTT, wofür es gehalten oder meistens bezweifelt wird, sondern setzt, &lt;span style=&quot;color:#00B000&quot;&gt;(theoretisch methodisch)&lt;/span&gt;, den &lt;span style=&quot;color:#FF6000&quot;&gt;„Glauben an die Existenz GOTTES“&lt;/span&gt; schon voraus, ohne ihn zu hinterfragen. Das &lt;span style=&quot;color:#FF6000&quot;&gt;„Dasein“&lt;/span&gt; bzw. die &lt;span style=&quot;color:#FF6000&quot;&gt;„Existenz“&lt;/span&gt; GOTTES wird mit der Definition-1 für &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx'''‘ —&lt;/span&gt;, bzw. mit dem Axiom-3 ''':'''  &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PG'''‘ — &lt;/span&gt;, im Kalkül ‚definitorisch‘ bzw. ‚axiomatisch‘ als  Kalkül-,Annahme‘, als &lt;span style=&quot;color:#FF6000&quot;&gt;„Prämisse“&lt;/span&gt;, eingeführt, unter der Voraussetzung, dass die ‚Eigenschaft‘ &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''G'''‘ := &lt;/span&gt;&lt;span style=&quot;color:#FF6000&quot;&gt;„Göttlichkeit“&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;(Essenz)&lt;/span&gt; und das &lt;span style=&quot;color:#FF6000&quot;&gt;„Dasein GOTTES“&lt;/span&gt;, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''G'''‘ —&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;(Existenz)&lt;/span&gt;, ontologisch ‚identisch‘, genauer ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;„koinzident“&lt;/span&gt; sind, was GÖDEL im Axiom-5 definitiv für sein System vorschreibt ''':'''  &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PE'''&lt;sub&gt;not&lt;/sub&gt;‘ — &lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''notwendige Existenz ist eine positive Eigenschaft''«&lt;/span&gt;. Das &lt;span style=&quot;color:#FF6000&quot;&gt;„Dasein GOTTES“&lt;/span&gt; ist faktisch äquivalent zur &lt;span style=&quot;color:#FF6000&quot;&gt;„notwendigen Existenz als GOTT“&lt;/span&gt;; und &lt;span style=&quot;color:#FF6000&quot;&gt;„Göttlichkeit“&lt;/span&gt; ist die &lt;span style=&quot;color:#FF6000&quot;&gt;„positive Eigenschaft in GOTT“&lt;/span&gt;. Beides ist nach Axiom-5 ‚identisch‘, d.h. dem ‚Sein nach‘ dasselbe, und daher konvertierbar. Beide, &lt;span style=&quot;color:#00B000&quot;&gt;(sowohl die Essenz, als auch die Existenz GOTTES)&lt;/span&gt;, werden daher auch mit demselben Term ''':'''  &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''G'''‘ —&lt;/span&gt; im Kalkül dargestellt. Der traditionelle, christliche ,GOTT-Glaube‘ wird ,systematisch‘ mit diesem Term &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''G'''‘ := &lt;/span&gt; &lt;span style=&quot;color:#FF6000&quot;&gt;„GOTT“ &lt;span style=&quot;color:#00B000&quot;&gt;|&lt;/span&gt; „göttlich“&lt;/span&gt;, im 2. Beweisgang, dem Basisbeweis, und im 3. Beweisgang für das Theorem ANSELMS, jeweils als ,methodologische‘ Prämisse :01: &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx'''‘ —&lt;/span&gt; regulär &lt;span style=&quot;color:#00B000&quot;&gt;( ├ )&lt;/span&gt; und explizit eingeführt ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Das'' &lt;span style=&quot;color:#4C58FF&quot;&gt;,'''x'''‘&lt;/span&gt; ''steht für den GOTT'' &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''G'''‘&lt;/span&gt; ''der Christen''«&lt;/span&gt;. Das ist die ,modal‘-frei gewählte, &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologische“&lt;/span&gt; Kalkül-,Annahme‘, &lt;span style=&quot;color:#00B000&quot;&gt;(als ,Argument-Einführung‘ := &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''AE:'''‘&lt;/span&gt; )&lt;/span&gt;, und wird dann mit Definition-1 näher ,bestimmt‘ ''':'''  &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx↔∀X(PX→Xx)'''‘ — &lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt; »''Das'' &lt;span style=&quot;color:#4C58FF&quot;&gt;,'''x'''‘&lt;/span&gt; ''steht genau dann für ‚GOTT‘'' &lt;span style=&quot;color:#00B000&quot;&gt;|&lt;/span&gt; ''‚göttlich‘'', &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''G'''‘&lt;/span&gt;, ''wenn'' &lt;span style=&quot;color:#4C58FF&quot;&gt;,'''x'''‘&lt;/span&gt; ''alle positiven Eigenschaften, bzw. Vollkommenheiten'', &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''PX'''‘&lt;/span&gt;, ''hat''«&lt;/span&gt;, entsprechend dem ‚Quelltext‘ bei LEIBNIZ. &lt;span style=&quot;color:#00B000&quot;&gt;(Das ,postulierte‘ Axiom-3 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''PG'''‘ —&lt;/span&gt;, wird standardmäßig gelesen als &lt;span style=&quot;color:#FF6000&quot;&gt;»''Göttlichkeit ist eine positive Eigenschaft''«&lt;/span&gt;, hat aber auch die alternative Leseart ''':'''  &lt;span style=&quot;color:#FF6000&quot;&gt;»''GOTT ist perfekt d.h. vollkommen''«&lt;/span&gt;, was &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologisch“&lt;/span&gt; auch richtig ist; mit &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''P'''‘ &lt;/span&gt; := &lt;span style=&quot;color:#FF6000&quot;&gt;„Perfektion“/„Vollkommenheit“&lt;/span&gt; ist dann die Summe aller &lt;span style=&quot;color:#FF6000&quot;&gt;„positiven Eigenschaften“&lt;/span&gt;.)&lt;/span&gt; Mit Axiom-3, — in dieser &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologischen“&lt;/span&gt; Leseart —, ist der ‚Wenn-Satz‘ in Definition-1 ‚aufgelöst‘ ''':'''  &lt;span style=&quot;color:#FF6000&quot;&gt;»''GOTT hat alle positiven Eigenschaften, weil er ‚perfekt‘ ist''«&lt;/span&gt;.

In Definition-3 ''':'''  &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''E'''&lt;sub&gt;not&lt;/sub&gt;'''x ↔ ∀X(X'''&lt;sub&gt;ess&lt;/sub&gt;'''x →□∃yXy)'''‘ —&lt;/span&gt;, wird die ,für  uns‘ &lt;span style=&quot;color:#FF6000&quot;&gt;„notwendige Existenz“&lt;/span&gt; ''':'''  &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''E'''&lt;sub&gt;not&lt;/sub&gt;‘ —, &lt;/span&gt; durch die ,aus sich‘ &lt;span style=&quot;color:#FF6000&quot;&gt;„notwendig“&lt;/span&gt; &lt;span style=&quot;color:#4C58FF&quot;&gt;— '''□''' —&lt;/span&gt; instanziierten &lt;span style=&quot;color:#FF6000&quot;&gt;„Wesenseigenschaften“&lt;/span&gt;, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''X'''&lt;sub&gt;ess&lt;/sub&gt;‘ —&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(als zu den Transzendentalia gehörig)&lt;/span&gt;, ,bestimmt‘. Das GÖDEL-Kalkül setzt sowohl in Definition-3 als auch im Axiom-5 das ,Theorem‘ des ARISTOTELES von der ,ontologischen Identität‘, d.i. die ,Koinzidenz‘ von &lt;span style=&quot;color:#FF6000&quot;&gt;„Dasein“&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(Existenz)&lt;/span&gt; und &lt;span style=&quot;color:#FF6000&quot;&gt;„Wesenseigenschaften“&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(Essenz)&lt;/span&gt; im prinzipiell &lt;span style=&quot;color:#FF6000&quot;&gt;„unbewegten Erstbewegenden“&lt;/span&gt;  voraus. Ohne diese Annahme bzw. ohne Axiom-5, würde das GÖDEL-Kalkül nicht ‚funktionieren‘. Das GÖDEL-Theorem-2.1 ''':'''  &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx→G'''&lt;sub&gt;ess&lt;/sub&gt;'''x'''‘ —&lt;/span&gt;, kann unter dieser Voraussetzung dann, &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologisch“&lt;/span&gt; richtig und eindeutig, so gelesen werden ''':'''  &lt;span style=&quot;color:#FF6000&quot;&gt;»''Wenn'' &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''x'''‘&lt;/span&gt; ''für den GOTT der Christen'', &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''G'''‘&lt;/span&gt;, ''als Individuum steht, dann ist GOTT-Sein'', &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''G'''‘&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(,Existenz‘)&lt;/span&gt;, ''die Wesenseigenschaft'', &lt;span style=&quot;color:#4C58FF&quot;&gt;—&lt;sub&gt;ess&lt;/sub&gt;—, &lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;(,Essenz‘)&lt;/span&gt;, ''dieses GOTTES'' &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''x'''‘&lt;/span&gt;«&lt;/span&gt;&lt;ref&gt;vgl. z.B. THOMAS von Aquin ''':''' ,''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;De Ente et Essentia&lt;/big&gt;&lt;/span&gt;''’, Kapitel 5 ''':''' „Deus, cuius essentia est ipsummet suum esse“ ''':''' „GOTT, dessen Wesen sein eigenes Sein ist“.&lt;/ref&gt;, statt der &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologisch“&lt;/span&gt; unrichtigen Lesearten in der Wikipedia ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Göttlich ist eine essentielle Eigenschaft jedes göttlichen Wesens''«&lt;/span&gt;&lt;ref&gt;{{w|Gottesbeweis#Kurt_Gödel|Gottesbeweis 2.1.2, Theorem 2}}; Version vom 10.09.2025&lt;/ref&gt;, oder bei Christoph BENZMÜLLER et alia, im sog. ,Theorembeweiser‘ ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Gottähnlich zu sein ist eine Essenz von jeder gottähnlichen Entität''«&lt;/span&gt;&lt;ref&gt;[https://www.fu-berlin.de/presse/informationen/fup/2013/fup_13_308/index.html  ‚Gödels „Gottesbeweis“ bestätigt’, Theorem 2]&lt;/ref&gt;, mit der suggestiven Annahme, es gäbe polytheïstisch, mehrere ,göttliche Wesen‘, bzw. ,gottähnliche Entitäten‘, was der monotheïstischen, abendländischen Tradition, bzw. dem &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologischen“&lt;/span&gt; Theorem von der ,Unvergleichlichkeit‘ und ,Einzigartigkeit‘ GOTTES widerspricht, das im GÖDEL-Kalkül mit dem FUHRMANN-Korollar-3 bestätigt wird. &lt;span style=&quot;color:#00B000&quot;&gt;(Die Interpretation &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''G'''‘ :=&lt;/span&gt; &lt;span style=&quot;color:#FF6000&quot;&gt;„GOTT“&lt;/span&gt;, als ,Individuumname‘, ist synonym zum &lt;span style=&quot;color:#FF6000&quot;&gt;„Dasein &lt;span style=&quot;color:#00B000&quot;&gt;(Existenz)&lt;/span&gt; GOTTES“&lt;/span&gt;, und äquivalent zur ‚positiven Eigenschaft‘ &lt;span style=&quot;color:#FF6000&quot;&gt;„Göttlichkeit“&lt;/span&gt;, alias &lt;span style=&quot;color:#FF6000&quot;&gt;„göttlich zu sein“&lt;/span&gt; = &lt;span style=&quot;color:#FF6000&quot;&gt;„GOTT zu sein“&lt;/span&gt; = &lt;span style=&quot;color:#FF6000&quot;&gt;„GOTT-Sein“&lt;/span&gt;; und mit dem GÖDEL-Term ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''G'''&lt;sub&gt;ess&lt;/sub&gt;‘ :=&lt;/span&gt; &lt;span style=&quot;color:#FF6000&quot;&gt;„das Wesen &lt;span style=&quot;color:#00B000&quot;&gt;(Essenz)&lt;/span&gt; GOTTES“&lt;/span&gt;.)&lt;/span&gt;

&lt;div class=&quot;center&quot;&gt;&lt;span style=&quot;color:#FF6000&quot;&gt;&lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''G'''‘ :=&lt;/span&gt; „'''G'''öttlichkeit“ &lt;span style=&quot;color:#4C58FF&quot;&gt;↔&lt;/span&gt; „'''G'''OTT“ &lt;span style=&quot;color:#4C58FF&quot;&gt;↔&lt;/span&gt; „'''G'''OTT-Sein“&lt;/span&gt; &lt;/div&gt;

Die Rechtfertigung für diese &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologische“&lt;/span&gt; Dreifach-Äquivalenz für &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''G'''‘ —&lt;/span&gt;, im GÖDEL-Kalkül, gibt Axiom-5 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PE'''&lt;sub&gt;not&lt;/sub&gt;‘ — &lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''die positive &lt;u&gt;Eigenschaft&lt;/u&gt;'', &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''P'''‘ —&lt;/span&gt;, ''Göttlichkeit'', &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''G'''‘ —&lt;/span&gt;, ''äquivalent zu GOTT als Individuum-Name'', &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''G'''‘ —&lt;/span&gt;, ''ist auch äquivalent zum Dasein GOTTES'', &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''G'''‘ —&lt;/span&gt;, ''gleichbedeutend mit notwendiger &lt;u&gt;Existenz&lt;/u&gt;'', &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''E'''&lt;sub&gt;not&lt;/sub&gt;‘ —&lt;/span&gt;'', dem &lt;u&gt;Sein&lt;/u&gt; GOTTES für uns''«&lt;/span&gt;. Hier hat GÖDEL explizit &lt;span style=&quot;color:#FF6000&quot;&gt;„Eigenschaft“&lt;/span&gt; mit &lt;span style=&quot;color:#FF6000&quot;&gt;„Existenz“&lt;/span&gt; bzw. &lt;span style=&quot;color:#FF6000&quot;&gt;„Sein“&lt;/span&gt; gleichgesetzt; &lt;span style=&quot;color:#00B000&quot;&gt;(was jedoch nach KANT für alles, was in unserer Welt ‚existiert‘, bzw. für alles, was zur &lt;span style=&quot;color:#FF6000&quot;&gt;»''zufälligen Struktur der Welt''«&lt;/span&gt; gehört, wie GÖDEL selbst sagt, in jedem Fall ‚unstatthaft‘ ist ''':'''  &lt;span style=&quot;color:#FF6000&quot;&gt;„Existenz ist keine Eigenschaft“&lt;/span&gt;, bzw. &lt;span style=&quot;color:#FF6000&quot;&gt;»''Sein ist kein reales Prädikat''«&lt;/span&gt;)&lt;/span&gt;. Jedoch wegen dieser ‚Gleichsetzung‘, die einzig und allein, der aristotelisch-&lt;span style=&quot;color:#4C58FF&quot;&gt;,theologischen‘&lt;/span&gt; Tradition entsprechend, singulär nur in GOTT ‚statthaft‘ ist, kann jetzt die ‚positive Eigenschaft‘ &lt;span style=&quot;color:#00B000&quot;&gt;(Essenz)&lt;/span&gt; &lt;span style=&quot;color:#FF6000&quot;&gt;„Göttlichkeit“&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;(ontologisch korrekt)&lt;/span&gt; gelesen werden als &lt;span style=&quot;color:#FF6000&quot;&gt;„das, was GOTT zu dem macht, ‚was‘ GOTT an sich selbst ist“&lt;/span&gt;, nämlich zu seinem &lt;span style=&quot;color:#FF6000&quot;&gt;„GOTT-Sein“&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;(Existenz)&lt;/span&gt;, zu seinem &lt;span style=&quot;color:#FF6000&quot;&gt;„Dasein als GOTT“&lt;/span&gt;; zur Tatsache, dass &lt;span style=&quot;color:#FF6000&quot;&gt;„GOTT GOTT ist“&lt;/span&gt;, d.h. dass &lt;span style=&quot;color:#FF6000&quot;&gt;„GOTT als GOTT ‚da‘ ist“&lt;/span&gt;. Das ist, &lt;span style=&quot;color:#00B000&quot;&gt;(und da folgt ARISTOTELES seinem Lehrer PLATO)&lt;/span&gt;, nach traditioneller Auslegung, die übliche, ontologische Funktion des ‚Wesens‘&lt;span style=&quot;color:#00B000&quot;&gt; | &lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;οὐσία&lt;/big&gt;&lt;/span&gt;“&lt;/span&gt; | ‚ousía‘ |&lt;/span&gt; eines Seienden ''':'''  es ‚macht‘ das Seiende zu dem, ‚was‘ es ist; es ist die ‚Ursache‘ dafür, dass das Seiende, das ‚ist‘, ‚was‘ es ist | ‚Was-Sein‘ — ‚Wesen‘. &lt;span style=&quot;color:#00B000&quot;&gt;(ARISTOTELES lokalisiert jedoch das ,Wesen‘ im Seienden, im Gegensatz zu PLATO, der das ,Wesen‘, — ,getrennt‘ vom Seienden —, in den allgemeinen ,Ideen‘ lokalisiert.)&lt;/span&gt;

Da aber in ‚Gott‘, &lt;span style=&quot;color:#00B000&quot;&gt;(dem &lt;span style=&quot;color:#FF6000&quot;&gt;„unbewegten, ‚unverursachten‘ Erstbeweger“&lt;/span&gt;)&lt;/span&gt;, Prozesshaftes, ‚Ursächliches‘ auszuschließen ist, ist die übliche prozesshafte, ‚ursächliche‘ Funktion von &lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;οὐσία&lt;/big&gt;&lt;/span&gt;“&lt;/span&gt;&lt;span style=&quot;color:#00B000&quot;&gt; | ‚ousía‘ |&lt;/span&gt; ,Wesen‘ im &lt;span style=&quot;color:#FF6000&quot;&gt;„Erstbewegenden“&lt;/span&gt; nach ARISTOTELES, sozusagen, schon ‚zum Abschluss‘ gekommen, schon ‚verwirklicht‘, — &lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;ἐν-έργεια οὖσα&lt;/big&gt;&lt;/span&gt;“&lt;/span&gt;&lt;span style=&quot;color:#00B000&quot;&gt; | ‚en-érgeia oúsa‘&lt;/span&gt; —, schon ‚ins-Werk‘ gesetzt; &lt;span style=&quot;color:#00B000&quot;&gt;(&lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;τὸ ἔργον&lt;/big&gt;&lt;/span&gt;“&lt;/span&gt; | ‚to érgon‘ | ‚das Werk‘; &lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;ἐνέργεια&lt;/big&gt;&lt;/span&gt;“&lt;/span&gt; | ‚enérgeia‘ | ,Wirksamkeit‘, ,Wirklichkeit‘, ,Aktualität‘, ,Energie‘; und &lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;οὖσα&lt;/big&gt;&lt;/span&gt;“&lt;/span&gt; | ,oúsa‘ | feminin Nominativ Singular von &lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;ὤν&lt;/big&gt;&lt;/span&gt;“&lt;/span&gt; | ‚ón‘ | ‚seiend‘)&lt;/span&gt;. Sein ,Wesen‘ ist im ,Dasein‘ vollendet, ist ,wirkliches, verwirklichendes Sein‘, ‚seiende Aktualität‘, &lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;actus purus&lt;/big&gt;&lt;/span&gt;“&lt;/span&gt; ''':''' sein Wesen ist ‚reine Tätigkeit‘, ,reine verwirklichende Gegenwärtigkeit‘, d.h. ,existent‘, reine ,Aktualität‘, ohne jede prozesshafte ‚Potenzialität‘. Aus der wichtigen und richtigen Erkenntnis, dass GOTT &lt;span style=&quot;color:#FF6000&quot;&gt;»''unabhängig von der zufälligen'' &lt;span style=&quot;color:#00B000&quot;&gt;[ Raum-Zeit-]&lt;/span&gt;''Struktur unserer Welt''«&lt;/span&gt; ist, folgt mit der ontologischen Identität von ,Dasein‘ und ,Wesen‘ in GOTT ''':''' Der zeitlos ewige GOTT ist &lt;span style=&quot;color:#FF6000&quot;&gt;»''notwendig aus sich'' &lt;span style=&quot;color:#00B000&quot;&gt;(von Natur aus)&lt;/span&gt; ''immer schon da''«&lt;/span&gt;, m.a.W. ist &lt;span style=&quot;color:#FF6000&quot;&gt;„zeitlos-ursprungslos“&lt;/span&gt;. Insofern ist &lt;span style=&quot;color:#FF6000&quot;&gt;„Göttlichkeit“&lt;/span&gt; die &lt;span style=&quot;color:#FF6000&quot;&gt;„Wesenseigenschaft“&lt;/span&gt;, die im &lt;span style=&quot;color:#FF6000&quot;&gt;„Dasein GOTTES“&lt;/span&gt; d.h. in &lt;span style=&quot;color:#FF6000&quot;&gt;„GOTT“&lt;/span&gt;, schon ihr ‚Ziel‘, ihre Vollendung, — &lt;span style=&quot;color:#FF6000&quot;&gt;„Perfektion“&lt;/span&gt;, Axiom-3 ''':'''  &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PG'''‘ —&lt;/span&gt;, erreicht hat. GOTT ist  &lt;span style=&quot;color:#FF6000&quot;&gt;»''vollkommen''«&lt;/span&gt; und darum auch  &lt;span style=&quot;color:#FF6000&quot;&gt;»''notwendig für uns immer schon ‚da‘''«&lt;/span&gt; ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''E'''&lt;sub&gt;not&lt;/sub&gt;'''x'''‘ — &lt;/span&gt;. GOTT ist in seinem ‚zeitlosen Wesen‘ &lt;span style=&quot;color:#FF6000&quot;&gt;„unverursacht“&lt;/span&gt;, da er &lt;span style=&quot;color:#FF6000&quot;&gt;»''notwendig aus sich'' &lt;span style=&quot;color:#00B000&quot;&gt;(von Natur aus)&lt;/span&gt; ''vollkommen''«&lt;/span&gt; ist ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□PG'''‘ —&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(eine Instanz von Axiom-4)&lt;/span&gt;. &lt;span style=&quot;color:#FF6000&quot;&gt;„Vollkommenheit“&lt;/span&gt;, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''P'''‘ —&lt;/span&gt;, ist die &lt;span style=&quot;color:#FF6000&quot;&gt;„Wesenseigenschaft“&lt;/span&gt;, bzw. das &lt;span style=&quot;color:#FF6000&quot;&gt;„Wesen GOTTES“&lt;/span&gt; ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''G'''&lt;sub&gt;ess&lt;/sub&gt;‘ —&lt;/span&gt;. &lt;span style=&quot;color:#FF6000&quot;&gt;»''GOTT ist ,der‘ Vollkommenste''«&lt;/span&gt; ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PG'''‘ —&lt;/span&gt;, d.h. &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''G'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''GOTT ist die unbegrenzte Summe der unendlichen Vollkommenheiten''«&lt;/span&gt;. Und zur absoluten  &lt;span style=&quot;color:#FF6000&quot;&gt;„Vollkommenheit“&lt;/span&gt; gehört  &lt;span style=&quot;color:#FF6000&quot;&gt;„notwendig“&lt;/span&gt; auch das  &lt;span style=&quot;color:#FF6000&quot;&gt;„Existieren“&lt;/span&gt; ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PE'''&lt;sub&gt;not&lt;/sub&gt;‘ — &lt;/span&gt;. &lt;span style=&quot;color:#FF6000&quot;&gt;»''Notwendige Existenz''«&lt;/span&gt; gehört zu den ,ultimativen‘ Transzendentalia in GOTT, was GÖDEL mit Definition-3 ''':'''  &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''E'''&lt;sub&gt;not&lt;/sub&gt;'''x ↔ ∀X(X'''&lt;sub&gt;ess&lt;/sub&gt;'''x →□∃yXy)'''‘ —&lt;/span&gt; syntaktisch formalisiert hat, wenn sowohl das &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''x'''‘ —&lt;/span&gt;, als dann auch alle &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''∀y'''‘ —&lt;/span&gt; im Kalkül, für den Dreifaltigen GOTT der Christen stehen, was im FUHRMANN-Korollar-3 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□(∃xGx ∧ ∀y(Gy→x=y))'''‘ —&lt;/span&gt;, mit der syntaktischen Identität, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''x=y'''‘ —&lt;/span&gt;, bzw. der ,Koinzidenz‘ beider Individuum-Variablen, explizit gezeigt wird.

Entscheidend für diese Interpretation des GÖDEL-Systems ist ''':''' nur unter der ,modal‘ notwendigen Voraussetzung der ontologischen ‚Identität‘ von &lt;span style=&quot;color:#FF6000&quot;&gt;„Sein“&lt;/span&gt; und &lt;span style=&quot;color:#FF6000&quot;&gt;„Wesen“&lt;/span&gt; in GOTT, Theorem-2 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt; — '''Gx↔G'''&lt;sub&gt;ess&lt;/sub&gt;'''x'''‘ —&lt;/span&gt;, bzw. der ‚Gleichsetzung‘, &lt;span style=&quot;color:#00B000&quot;&gt;(Koinzidenz)&lt;/span&gt;, von &lt;span style=&quot;color:#FF6000&quot;&gt;„notwendiger Existenz“&lt;/span&gt; mit den ‚positiven‘ Wesenseigenschaften, der &lt;span style=&quot;color:#FF6000&quot;&gt;„Essenz“&lt;/span&gt; in GOTT, Axiom-5 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PE'''&lt;sub&gt;not&lt;/sub&gt;‘ —&lt;/span&gt;, ‚funktioniert‘ die GÖDEL-Axiomatik '''!'''  Diese ‚Identität‘, bzw. ,Koinzidenz‘ wird in ARISTOTELES, ‚''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;Metaphysik&lt;/big&gt;&lt;/span&gt;''‘, Buch XII 7, in einem Indizienbeweis erbracht, der mit der Methode der philosophischen Induktion zum Ergebnis kommt ''':'''  

::&lt;span style=&quot;color:#FF6000&quot;&gt;» … ''es muss'' &lt;span style=&quot;color:#00B000&quot;&gt;[ notwendig ]&lt;/span&gt; ''etwas geben, das, ohne selbst ‚bewegt‘'' &lt;span style=&quot;color:#00B000&quot;&gt;[ &lt;/span&gt;''worden''&lt;span style=&quot;color:#00B000&quot;&gt; ]&lt;/span&gt; ''zu sein'', &lt;span style=&quot;color:#00B000&quot;&gt;[ ‚unentstanden‘ ]&lt;/span&gt;, ''alles Übrige wie ein Geliebtes ‚bewegt‘'' &lt;span style=&quot;color:#00B000&quot;&gt;[ ‚entstehen lässt‘ ]&lt;/span&gt;«&lt;/span&gt;, das darum selbst ‚zugleich‘ &lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;αἴδιον καί οὐσία καί ἐνέργεια οὖσα&lt;/big&gt;&lt;/span&gt;“ &lt;span style=&quot;color:#00B000&quot;&gt;| ,aídion kai ousía kai enérgeia oúsa‘ |&lt;/span&gt; »&lt;span style=&quot;color:#00B000&quot;&gt;[ zeitlich-]&lt;/span&gt;''ewig, sowohl &lt;u&gt;Wesen&lt;/u&gt;'', &lt;span style=&quot;color:#00B000&quot;&gt;[ etwas Konkretes, Essentielles ]&lt;/span&gt;, ''als auch seiende Wirksamkeit — ''&lt;span style=&quot;color:#00B000&quot;&gt;[ &lt;/span&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;actus purus&lt;/big&gt;&lt;/span&gt;“, „reine Tätigkeit“&lt;span style=&quot;color:#00B000&quot;&gt; ]&lt;/span&gt; ''— verwirklichendes, wirkliches &lt;u&gt;Sein&lt;/u&gt; ist'', &lt;span style=&quot;color:#00B000&quot;&gt;[ ein Existierendes, das alles Übrige ,zur Existenz‘ bringen kann ]&lt;/span&gt; «&lt;/span&gt;, bzw. &lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;ὀρεκτόν καί νοητόν&lt;/big&gt;&lt;/span&gt;“ &lt;span style=&quot;color:#00B000&quot;&gt; | ,orektón kai noêtón‘ | &lt;/span&gt;»''das ersehnt und erkennbar ist''.«&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;(''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;vgl. ,Metaphysik&lt;/big&gt;&lt;/span&gt;''‘ XII 7, 1072a,23 – 1072b,4)&lt;/span&gt; 

Was &lt;span style=&quot;color:#FF6000&quot;&gt;»''alles Übrige''«&lt;/span&gt; ,zur Existenz‘ bringen kann, bzw. ,verwirklichen‘ kann, ohne selbst ,entstanden‘ zu sein, muß auch selbst, als etwas Konkretes, Essentielles, immer schon ,existieren‘, bzw. ,wirklich sein‘. Die, daraus abgeleitete, und damit ,erkannte‘, ontologische ‚Identität‘, — ,Koinzidenz‘ —,  von ‚Wesen‘ und ‚Sein‘, &lt;span style=&quot;color:#00B000&quot;&gt;(Ziel aller Sehnsucht und jedes Erkenntnisstrebens)&lt;/span&gt;, &lt;span style=&quot;color:#FF6000&quot;&gt;»''ist das Privilegium der Gottheit allein''«&lt;/span&gt; ''':'''  mit Gottfried Wilhelm LEIBNIZ interpretiert, entsprechend einer adäquaten, aristotelisch-&lt;span style=&quot;color:#4C58FF&quot;&gt;,theologischen‘&lt;/span&gt; Tradition. Dieses induktive, ‚ontologisch‘ a-posteriori Ergebnis aus der ‚Prinzipienforschung‘ des ARISTOTELES ist die metaphysische und logische Voraussetzung, dass GÖDEL seine Axiomatik im Kalkül des sog. ‚ontologischen Gottesbeweises‘ a-priori des ANSELM von Canterbury, und nach LEIBNIZ, deduktiv korrekt formulieren konnte; &lt;span style=&quot;color:#00B000&quot;&gt;(vgl. 3. Beweisgang)&lt;/span&gt;.

Angenommen, die Variable &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''x'''‘ —&lt;/span&gt; steht für den  &lt;span style=&quot;color:#FF6000&quot;&gt;„GOTT“&lt;/span&gt;, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''G'''‘ —&lt;/span&gt;, der Christen, &lt;span style=&quot;color:#00B000&quot;&gt;(siehe Anhang, Term :01: im 2. Beweisgang)&lt;/span&gt;, dann ist, — auf Grund von diesem Beweisgang —, in unserer Welt ,wahr‘ und evident ''':''' sowohl die ‚positive Eigenschaft‘ &lt;span style=&quot;color:#FF6000&quot;&gt;»''Göttlichkeit''«&lt;/span&gt;, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''G'''‘ —&lt;/span&gt;, als auch das faktische &lt;span style=&quot;color:#FF6000&quot;&gt;»''‚Da‘-Sein'' &lt;span style=&quot;color:#00B000&quot;&gt;[ Existenz ]&lt;/span&gt; ''GOTTES''«&lt;/span&gt;, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''G'''‘ —&lt;/span&gt;, ‚benennen‘, ontologisch ident, denselben Sachverhalt ''':''' nämlich das, was wir das &lt;span style=&quot;color:#FF6000&quot;&gt;»''Wesen'' &lt;span style=&quot;color:#00B000&quot;&gt;[ Essenz ]&lt;/span&gt; ''GOTTES''«&lt;/span&gt;, &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''G'''&lt;sub&gt;ess&lt;/sub&gt;‘ —&lt;/span&gt;, nennen. &lt;span style=&quot;color:#FF6000&quot;&gt;»''Göttlichkeit'', bzw. ''GOTT-‚Sein‘ ist das Wesen GOTTES''«&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(Theorem-2.1)&lt;/span&gt;, und dann umgedreht und äquivalent ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Das Wesen GOTTES ist sein ‚Da‘-Sein als GOTT'', bzw. ''seine Göttlichkeit''«&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(Theorem-2.2)&lt;/span&gt;, m.a.W. ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''GOTT ist wesentlich ‚grundlos‘'' &lt;span style=&quot;color:#00B000&quot;&gt;[ d.h. &lt;/span&gt; ''notwendig aus sich''&lt;span style=&quot;color:#00B000&quot;&gt; ]&lt;/span&gt; ''‚da‘''«&lt;/span&gt;. Das ist das Einzigartige im &lt;span style=&quot;color:#FF6000&quot;&gt;»''Wesen GOTTES''«&lt;/span&gt; ''':''' GOTT ist ohne zeitlichen Anfang, zeitlos-ewig, für uns immer schon ‚da‘, und das ‚ist‘ sein &lt;span style=&quot;color:#FF6000&quot;&gt;»''Wesen''«&lt;/span&gt;; vorausgesetzt, ,angenommen‘, man glaubt an GOTT ''':''' Term :01:. &lt;span style=&quot;color:#00B000&quot;&gt;(Der schon von GÖDEL indizierte Term &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''G'''&lt;sub&gt;ess&lt;/sub&gt;‘ — &lt;/span&gt; ,expliziert‘ nur eine der drei Lesearten, die der Term &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''G'''‘ — „theologisch“&lt;/span&gt; ,impliziert‘.)&lt;/span&gt;  Theorem-2 hat somit die syntaktische Form einer Definition ''':'''

&lt;div class=&quot;center&quot;&gt;&lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''Gx↔G'''&lt;sub&gt;ess&lt;/sub&gt;'''x'''‘ — &lt;/span&gt;&lt;/div&gt;

Somit kann GOTT ‚explizit‘ &lt;span style=&quot;color:#00B000&quot;&gt;(aus einer bewiesenen Kalkül-Definition)&lt;/span&gt; ontologisch-&lt;span style=&quot;color:#4C58FF&quot;&gt;„theologisch“&lt;/span&gt; genauer ‚bestimmt‘ werden ''':'''  &lt;span style=&quot;color:#FF6000&quot;&gt;»''GOTT ist gerade deswegen GOTT, weil sein überzeitlich-ewiges und an sich ‚grundloses‘'' &lt;span style=&quot;color:#00B000&quot;&gt;[ aber für uns notwendiges ]&lt;/span&gt; ''Dasein'' &lt;span style=&quot;color:#00B000&quot;&gt;[ Existenz ]&lt;/span&gt; ''als GOTT, ontologisch, — dem Sein nach —, identisch ist mit seinem persönlichen und für uns liebevollen Wesen'' &lt;span style=&quot;color:#00B000&quot;&gt;[ Essenz ]&lt;/span&gt; ''als GOTT; diese Identität von Dasein und Wesen gilt einzig und allein nur bei GOTT.''«&lt;/span&gt; Damit hat GÖDEL ein altes &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologisches“&lt;/span&gt; Theorem, philosophisch der Vergessenheit entrissen. Die philosophische Frage nach dem &lt;span style=&quot;color:#FF6000&quot;&gt;„Wesen GOTTES“&lt;/span&gt; lautet, &lt;span style=&quot;color:#00B000&quot;&gt;(auf die Person bezogen)&lt;/span&gt; ''':'''  &lt;span style=&quot;color:#FF6000&quot;&gt;„Was bist du ? “&lt;/span&gt; Sie ist äquivalent zur &lt;span style=&quot;color:#4C58FF&quot;&gt;,theologisch’&lt;/span&gt;-biblischen Frage des MOSE ''':'''  &lt;span style=&quot;color:#CC66FF&quot;&gt;„Wer bist Du ? “&lt;/span&gt; Die bekannte Antwort des GOTTES-JHWH aus ‚Exodus 3,14‘, im Dornbusch, thematisiert das persönliche, für uns liebevolle und für immer notwendige &lt;span style=&quot;color:#FF6000&quot;&gt;„Dasein GOTTES“&lt;/span&gt; ''':''' &lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;‘אֶֽהְיֶ֖ה אֲשֶׁ֣ר אֶֽהְיֶ֑ה‚&lt;/big&gt;&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;| ‚eh'jeh asher eh'jeh‘ |&lt;/span&gt; &lt;span style=&quot;color:#CC66FF&quot;&gt;»''Ich bin der ‚Ich-Bin-Da‘'', &lt;span style=&quot;color:#00B000&quot;&gt;[ für euch und für immer ]&lt;/span&gt;«.&lt;/span&gt; Mit diesem Zitat aus der Bibel ist die GÖDEL-Axiomatik, sozusagen, &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologisch“&lt;/span&gt; ‚verifiziert‘. Sie hat einerseits im Theorem-2 ihren philosophischen ‚Abschluss’ erreicht, und andererseits damit formal-syntaktisch den ‚Anschluss‘ an eine allgemeine Basis-Glaubensaussage gefunden, die ‚an sich‘ für jeden CHRIST-gläubigen Menschen ‚selbstverständlich‘ ist. Was in der Metaphysik des ARISTOTELES das Ergebnis einer  philosophischen ,Induktion‘ a-posteriori ist ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;„,Dasein‘ ist das ,Wesen‘ GOTTES“&lt;/span&gt;, — &lt;span style=&quot;color:#00B000&quot;&gt;(das mit Theorem-2, auch ein Ergebnis der deduktiven GÖDEL-Axiomatik a-priori ist ''':''' die Beweisgrundlage für den Konsequenz-Teil im Theorem AMSELMS)&lt;/span&gt;, — das ist in der Bibel die Grundüberzeugung jedes Menschen, der an GOTT glaubt ''':''' GOTT ist für uns immer schon &lt;span style=&quot;color:#FF6000&quot;&gt;„da“&lt;/span&gt;, weil er uns liebt. Das ist das, &lt;span style=&quot;color:#FF6000&quot;&gt;„was“&lt;/span&gt; GOTT für uns als GOTT ausmacht, — sein Wesen ''':''' &lt;span style=&quot;color:#CC66FF&quot;&gt;»''Wir haben die Liebe, die GOTT zu uns hat, erkannt und gläubig angenommen. GOTT ist Liebe, und wer in der Liebe bleibt, bleibt in GOTT und GOTT bleibt in ihm''«&lt;/span&gt;, &lt;small&gt;({{Bibel | 1. Johannesbrief |4|16|EU}})&lt;/small&gt;.

Das eigentliche Ergebnis der GÖDEL-Axiomatik ist somit die ‚triviale‘ Erkenntnis, dass GOTT, &lt;span style=&quot;color:#FF6000&quot;&gt;„unverursacht“ &lt;span style=&quot;color:#00B000&quot;&gt;|&lt;/span&gt; „grundlos“&lt;/span&gt;, für uns immer schon ‚da‘ ist, — &lt;span style=&quot;color:#CC66FF&quot;&gt;„von Ewigkeit zu Ewigkeit“&lt;/span&gt; —, vorausgesetzt &lt;span style=&quot;color:#00B000&quot;&gt;(‚angenommen‘)&lt;/span&gt;, man ‚glaubt‘ an den zeitlos-ewigen GOTT ''':''' &lt;span style=&quot;color:#CC66FF&quot;&gt;»''Ehe die Berge geboren wurden, ehe die Erde entstand und das Weltall erschaffen wurde, bist du, o GOTT, von Ewigkeit zu Ewigkeit''«&lt;/span&gt;, &lt;small&gt;({{Bibel | Psalm |90|2|LUT}})&lt;/small&gt;. &lt;span style=&quot;color:#00B000&quot;&gt;(Der Glaube an die Zeitlosigkeit GOTTES ist mit der ‚Annahme‘ von Axiom-3 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PG'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''GOTT ist perfekt''«&lt;/span&gt;, und der ‚Annahme‘ der Definition-1 für &lt;span style=&quot;color:#4C58FF&quot;&gt; ‚'''Gx'''‘ := &lt;/span&gt; den &lt;span style=&quot;color:#FF6000&quot;&gt;„GOTT der Christen“&lt;/span&gt;, im Kalkül ‚implizit‘ schon eingeführt, da die Axiome und Definitionen, — nach GÖDEL —, nur dann &lt;span style=&quot;color:#FF6000&quot;&gt;»''wahr''«&lt;/span&gt; sind, wenn sie &lt;span style=&quot;color:#FF6000&quot;&gt;»''unabhängig von der zufälligen''&lt;/span&gt; [ Raum-Zeit-]&lt;span style=&quot;color:#FF6000&quot;&gt;''Struktur''«&lt;/span&gt; unserer Welt sind. Das ,impliziert‘ auch, dass der GOTT von Axiom-3 und Definition-1 ebenfalls &lt;span style=&quot;color:#FF6000&quot;&gt;»''unabhängig''«&lt;/span&gt; von Raum und Zeit, d.h. zeitlos-ewig ist '''!''' )&lt;/span&gt; 

Wer an den GOTT der Bibel glaubt, kann sich von der ‚Vernünftigkeit‘ seines Glaubens mit Hilfe des sog. ,ontologischen‘ Gottesbeweises nach ANSELM von Canterbury, mit Kurt GÖDEL &lt;span style=&quot;color:#FF6000&quot;&gt;»''rein verstandesmäßig''«&lt;/span&gt;, überzeugen. &lt;span style=&quot;color:#00B000&quot;&gt;(Das war auch die Absicht ANSEMS '''!''' )&lt;/span&gt; Die Annahme, es sei ‚unmöglich‘, dass es GOTT gibt ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''¬◇∃xGx'''‘ —&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(dezidierter Atheismus)&lt;/span&gt;, führt im GÖDEL-Kalkül formal zu einem logischen Widerspruch; vgl. z. B. ‚''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;Gödels Möglichkeitsbeweis&lt;/big&gt;&lt;/span&gt;''‘, in ‚''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;Der Gödelsche Gottesbeweis&lt;/big&gt;&lt;/span&gt;''‘, Seite 17, von Günther J. WIRSCHING; (https://edoc.ku.de/id/eprint/10243/1/OntBw.pdf), d.h. es ist also nicht ‚unmöglich‘, dass es GOTT gibt. Der GOTT-Glaube ist mit den Maßstäben einer modernen Logik &lt;span style=&quot;color:#FF6000&quot;&gt;»''durchaus vereinbar''«&lt;/span&gt; und darum ,vernünftig‘. Damit steht fest ''':''' das GÖDEL-Kalkül ist kein moderner ‚Existenz-Beweis‘ für den GOTT der Bibel, sondern es setzt,  &lt;span style=&quot;color:#FF6000&quot;&gt;»''rein verstandesmäßig''«&lt;/span&gt;, ,methodologisch‘, den Glauben an die Existenz eines zeitlos-ewigen GOTTES voraus, der, — &lt;span style=&quot;color:#FF6000&quot;&gt;»''unabhängig von der zufälligen'' &lt;span style=&quot;color:#00B000&quot;&gt;[ Raum-Zeit-]&lt;/span&gt;''Struktur unserer '' &lt;span style=&quot;color:#00B000&quot;&gt;[ vergänglichen ]&lt;/span&gt; ''Welt''«&lt;/span&gt; —, für uns immer schon ‚da‘ ist. Wenn aber einmal als fix ‚angenommen‘ worden ist, &lt;span style=&quot;color:#00B000&quot;&gt;(als Prämisse)&lt;/span&gt;, dass es wahr ist, dass GOTT ‚existiert‘, dann ist natürlich die ‚Annahme‘, dass GOTT ‚nicht existiert‘, falsch. Aber sie ist auch ,unlogisch‘ und ,unsinnig‘, weil die Annahme ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Es ist unmöglich, dass es einen GOTT gibt''«&lt;/span&gt;, offensichtlich und eindeutig zu einem Widerspruch führt; was z. B. Günther J. WIRSCHING mit seiner Version des &lt;span style=&quot;color:#00B000&quot;&gt;(nicht umkehrbaren)&lt;/span&gt; ‚Möglichkeitsbeweises‘ für ,GOTT‘, explizit vorexerziert hat; &lt;span style=&quot;color:#00B000&quot;&gt;( nachgestellt im Anhang ''':''' GÖDELS ‚Möglichkeitsbeweis‘ als ,Widerlegung‘ eines Nicht-GOTT-Glaubens; in Entsprechung zu Psalm 14,1 und Psalm 53,2 ''':''' &lt;span style=&quot;color:#CC66FF&quot;&gt;»''Der'' &lt;span style=&quot;color:#00B000&quot;&gt;[ ,unvernünftige‘ ]&lt;/span&gt; ''Tor sagt in seinem Herzen ''':''' Es gibt keinen Gott. Sie handeln verderbt, handeln abscheulich; da ist keiner, der Gutes tut''«&lt;/span&gt;. Historischer Hintergrund zu diesem Psalm-Text ''':''' Die Zerstörung des Tempels in Jerusalem 586 v.Ch. durch die Truppen des NEBUKADNEZZAR II.)&lt;/span&gt; Der Logiker GÖDEL hat in seinem System zum ,ontologischen Beweis‘ keine ‚formale Unentscheidbarkeit‘ &lt;span style=&quot;color:#00B000&quot;&gt;(Agnostizismus)&lt;/span&gt; feststellen können,  wie auf einem anderen Feld seiner Forschungsarbeiten.

Das GÖDEL-Konsequenz-Teil von der ‚Notwendigkeit‘ GOTTES ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□∃xGx'''‘ —&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(die ‚Konsequenz’ aus dem ‚widerspruchsfreien‘ Korollar-1 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''◇∃xGx'''‘ —,&lt;/span&gt;)&lt;/span&gt; im ‚Theorem ANSELMS‘, ist &lt;span style=&quot;color:#00B000&quot;&gt;(im 3. Beweisgang, Term :10:)&lt;/span&gt; dann auch eine weitere Explikation des Basis-Theorems-2 des Kalküls ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''Gx↔G'''&lt;sub&gt;ess&lt;/sub&gt;'''x'''‘ — &lt;/span&gt;, über die ‚ontologische Identität‘ vom &lt;span style=&quot;color:#FF6000&quot;&gt;„Dasein GOTTES“&lt;/span&gt; ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''G'''‘ —&lt;/span&gt;, mit seinem &lt;span style=&quot;color:#FF6000&quot;&gt;„Wesen“&lt;/span&gt; ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt; — &lt;sub&gt;ess&lt;/sub&gt; —&lt;/span&gt;, nach einem &lt;span style=&quot;color:#4C58FF&quot;&gt;[ Modus ponens ]&lt;/span&gt;, dargestellt mit Term :09:. 

&lt;span style=&quot;color:#00B000&quot;&gt;(Die ontologische Identität von Dasein und Wesen in GOTT, ist die, für uns, &lt;span style=&quot;color:#FF6000&quot;&gt;„notwendige Präsenz &lt;span style=&quot;color:#00B000&quot;&gt;[ das Sein, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''E'''‘ —&lt;/span&gt;]&lt;/span&gt; GOTTES“&lt;/span&gt; ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''E'''&lt;sub&gt;not&lt;/sub&gt;'''x'''‘ —&lt;/span&gt;, die äquivalent, bzw. koinzident ist zur &lt;span style=&quot;color:#FF6000&quot;&gt;„Vollkommenheit &lt;span style=&quot;color:#00B000&quot;&gt;[ das Wesen, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''P'''‘ —&lt;/span&gt;]&lt;/span&gt; GOTTES“&lt;/span&gt; ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PG'''‘ —&lt;/span&gt;. Diese Identität von Sein und Wesen in GOTT ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PE'''&lt;sub&gt;not&lt;/sub&gt; —&lt;/span&gt;, bedeutet &lt;span style=&quot;color:#4C58FF&quot;&gt;,theologisch‘&lt;/span&gt; konkret ''':''' die, für uns, notwendige Gegenwärtigkeit GOTTES, [ sein Dasein ], ist verwirklicht worden in der liebevollen [ Wesens-]Zuwendung GOTTES zu uns Menschen, in seiner Kindwerdung in Bethlehem, durch die Jungfrau MARIA ''':''' GOTTES Wesen ist ,Sein-mit-uns‘ ''':''' &lt;span style=&quot;color:#CC66FF&quot;&gt;»''sein Name'', &lt;span style=&quot;color:#00B000&quot;&gt;[ sein Wesen ]&lt;/span&gt;, ''ist IMMANUEL, das heiß übersetzt ''':''' GOTT-ist-mit-uns'', &lt;span style=&quot;color:#00B000&quot;&gt;[ d.i. sein Dasein mit und für uns ]&lt;/span&gt;«, &lt;small&gt;({{Bibel | Matthäus Evangelium |1|23|EU}})&lt;/small&gt;&lt;/span&gt;, der unsere Not-,wenden‘-wird, d.h. der uns und die Welt von der Korruption der Sünde und des Todes &lt;span style=&quot;color:#4C58FF&quot;&gt;,erlösen‘&lt;/span&gt; will und wird; jedoch nicht ohne unsere Zustimmung. Die &lt;span style=&quot;color:#4C58FF&quot;&gt;„Menschwerdung“&lt;/span&gt; GOTTES in JESUS CHRISTUS, die &lt;span style=&quot;color:#4C58FF&quot;&gt;„Hypostatische Union“&lt;/span&gt;, bzw. diese außergewöhnliche und einzigartige &lt;span style=&quot;color:#FF6000&quot;&gt;„Koinzidenz“&lt;/span&gt; von GOTT und Mensch, ist der wirkliche und historische Beginn der &lt;span style=&quot;color:#4C58FF&quot;&gt;„Erlösung“&lt;/span&gt; des Menschen und der Welt; vergegenwärtigt für jede Generation der Menschen in und durch die &lt;span style=&quot;color:#4C58FF&quot;&gt;„Kirche“&lt;/span&gt; JESU CHRISTI. Damit bekommt jede Generation die Chance, die &lt;span style=&quot;color:#4C58FF&quot;&gt;„Erlösung“&lt;/span&gt; durch JESUS CHRISTUS für sich ,annehmen‘ zu können.)&lt;/span&gt; 

Die, von GÖDEL im 1. Beweisgang, als Prämissen schon vorausgesetzten und ,angenommenen‘ Perfektionen, bzw. Vollkommenheiten, &lt;span style=&quot;color:#00B000&quot;&gt;(das sind die allgemeinen ,Transzendentalia‘ für alles Nicht-Göttliche in der Welt, durch Beispiele belegbar)&lt;/span&gt;, werden im ersten Teil des 2. Beweisganges, mit Term :13: &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PY'''‘ —&lt;/span&gt;, dann auch als &lt;span style=&quot;color:#FF6000&quot;&gt;„positive Wesenseigenschaften“&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(als die ultimativen ,Transzendentalia‘)&lt;/span&gt;, in GOTT ‚definitiv‘ &lt;span style=&quot;color:#00B000&quot;&gt;( ╞ )&lt;/span&gt;  bestätigt; &lt;span style=&quot;color:#00B000&quot;&gt;(siehe Anhang, 2. Beweisgang, Anmerkung-2)&lt;/span&gt;. 

Im 3. Beweisgang ist das Basis-Theorem-2 die ,modal‘ notwendige, bzw. transzendentale, Voraussetzung, sowohl für das &lt;span style=&quot;color:#FF6000&quot;&gt;„an sich notwendige Dasein GOTTES“&lt;/span&gt;, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□∃xGx'''‘ —&lt;/span&gt;, im Term :10:, als auch für die &lt;span style=&quot;color:#FF6000&quot;&gt;„für uns notwendige Existenz GOTTES“&lt;/span&gt;, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''E'''&lt;sub&gt;not&lt;/sub&gt;'''x'''‘ —&lt;/span&gt;, in den Ressourcen dieses Beweisganges ''':''' in der Definition-3, und im Axiom-5 für &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PE'''&lt;sub&gt;not&lt;/sub&gt;‘ —&lt;/span&gt;; und das bedeutet auch eine Äquivalenz beider Terme ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□∃xGx ↔ E'''&lt;sub&gt;not&lt;/sub&gt;'''x'''‘ —&lt;/span&gt;, bzw. mit &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PE'''&lt;sub&gt;not&lt;/sub&gt;‘ —&lt;/span&gt;; &lt;span style=&quot;color:#00B000&quot;&gt;(das &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''E'''‘ —&lt;/span&gt; wird nur GOTT zugeordnet, vgl. auch Anhang, 3. Beweisgang, Anmerkung-4)&lt;/span&gt;. Dieses Basis-Theorem-2 ist auch zugleich die Antwort auf die Frage nach dem ‚Ursprung‘ GOTTES ''':''' GOTT ist &lt;span style=&quot;color:#FF6000&quot;&gt;„unverursacht“ &lt;span style=&quot;color:#00B000&quot;&gt;|&lt;/span&gt; „ursprungslos“&lt;/span&gt; ‚da‘, von &lt;span style=&quot;color:#CC66FF&quot;&gt;„Ewigkeit zu Ewigkeit“&lt;/span&gt;, denn es ‚ist‘ sein &lt;span style=&quot;color:#FF6000&quot;&gt;„Wesen“&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(überzeitlich-ewig)&lt;/span&gt; für uns immer schon ‚da‘ zu sein. Weitere ‚Einzelheiten‘ über Wesen und Eigenschaften GOTTES gehören in die Mystik, bzw. in die &lt;span style=&quot;color:#4C58FF&quot;&gt;„Theologie“&lt;/span&gt;.


===&lt;div class=&quot;center&quot;&gt;&lt;span style=&quot;color:#660066&quot;&gt;Die Bedeutung des Kalküls&lt;/span&gt;&lt;/div&gt;===

&lt;div class=&quot;center&quot;&gt;Immanuel KANT und Kurt GÖDEL im ‚Dialog‘&lt;/div&gt;
KANT sagt ''':'''  
::&lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;'''''Sein''' ist offenbar kein reales Prädikat''. ... ''Es ist bloß die'' &lt;span style=&quot;color:#00B000&quot;&gt;[ gedachte ]&lt;/span&gt;'' Position'' &lt;span style=&quot;color:#00B000&quot;&gt;[ latinisiert, deutsch für ''':''' ,Setzung‘ ]&lt;/span&gt; ''eines Dinges ... Nehme ich nun das Subjekt (Gott) mit allen seinen Prädikaten'' &lt;span style=&quot;color:#00B000&quot;&gt;[ d.h. Eigenschaften ]&lt;/span&gt; ''(worunter auch die Allmacht gehört) zusammen, und sage ''':''' ‚'''Gott ist'''‘'', &lt;span style=&quot;color:#00B000&quot;&gt;[ ,GOTT existiert wirklich‘ ]&lt;/span&gt;, ''oder ‚es ist ein Gott‘, so &lt;u&gt;setze&lt;/u&gt; ich kein neues Prädikat'' &lt;span style=&quot;color:#00B000&quot;&gt;[ keine neue Eigenschaft ]&lt;/span&gt; ''zum ‚Begriffe‘ von Gott ''':''''' &lt;span style=&quot;color:#00B000&quot;&gt;[ &lt;span style=&quot;color:#0000FF; background-color:#FFFF00&quot;&gt;‚Sein’ ist kein ‚reales Prädikat’ in GOTT&lt;/span&gt;; ‚Existenz‘ ist in GOTT keine ‚Eigenschaft‘ ],&lt;/span&gt; ... ''es kann daher zu dem Begriffe'', &lt;span style=&quot;color:#00B000&quot;&gt;[ ,GOTT‘ ]&lt;/span&gt;, ''der bloß die'' &lt;span style=&quot;color:#00B000&quot;&gt;[ gedachte ]&lt;/span&gt;'' Möglichkeit ausdrückt, darum, dass ich dessen Gegenstand'', &lt;span style=&quot;color:#00B000&quot;&gt;[ GOTT ]&lt;/span&gt;, ''als schlechthin gegeben (durch den Ausdruck ''':''' er ist'', &lt;span style=&quot;color:#00B000&quot;&gt;[ GOTT ist wirklich ]&lt;/span&gt;'' ) &lt;u&gt;denke&lt;/u&gt;, nichts weiter hinzukommen.'' &lt;span style=&quot;color:#00B000&quot;&gt;[ Beides ist ,bloß gedacht‘ '''!''' ]&lt;/span&gt; ''Und so enthält das Wirkliche &lt;u&gt;nichts mehr&lt;/u&gt; als das bloß Mögliche. Hundert ‚wirkliche‘ Taler enthalten nicht das mindeste &lt;u&gt;mehr&lt;/u&gt;, als hundert ‚mögliche‘. Denn, da diese'', &lt;span style=&quot;color:#00B000&quot;&gt;[ die ,Möglichen‘ ]&lt;/span&gt;, ''den'' &lt;span style=&quot;color:#00B000&quot;&gt;[ gedachten ]&lt;/span&gt;'' ‚Begriff‘, jene'', &lt;span style=&quot;color:#00B000&quot;&gt;[ die ,Wirklichen‘ ]&lt;/span&gt;, ''aber den Gegenstand und dessen'' &lt;span style=&quot;color:#00B000&quot;&gt;[ gedachte ]&lt;/span&gt;'' Position an sich selbst bedeuten, so würde, im Fall dieser'', &lt;span style=&quot;color:#00B000&quot;&gt;[ die 100, als ,wirklich‘ bloß gedachten Taler ]&lt;/span&gt;, ''&lt;u&gt;mehr&lt;/u&gt; enthielte als jener,'' &lt;span style=&quot;color:#00B000&quot;&gt;[ als ihr ‚gedachter‘ Begriff im Verstand, wie ΑNSELM von Canterbury für GOTT, als ‚wirklich‘  Existierenden, argumentierte, …''so würde'' ]&lt;/span&gt; ''mein ‚Begriff‘'' &lt;span style=&quot;color:#00B000&quot;&gt;[ die 100 im Verstand ‚gedachten‘ Taler ]&lt;/span&gt; ''nicht den ganzen Gegenstand ausdrücken, und also auch &lt;u&gt;nicht der angemessene Begriff&lt;/u&gt; von ihm sein. Aber in meinem Vermögenszustande ist &lt;u&gt;mehr&lt;/u&gt; bei hundert ‚wirklichen‘ Talern, als bei dem bloßen Begriffe derselben'', &lt;span style=&quot;color:#00B000&quot;&gt;[ als bei 100 bloß ‚gedachten‘ Talern ]&lt;/span&gt; ... &lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;&lt;ref&gt;‚''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;Kritik der reinen Vernunft&lt;/big&gt;&lt;/span&gt;''‘, Seite 401; https://www.korpora.org/kant/aa03/401.html&lt;/ref&gt;&lt;/span&gt;. 

GÖDEL würde darauf &lt;span style=&quot;color:#00B000&quot;&gt;(korrespondierend zur aristotelisch-&lt;span style=&quot;color:#4C58FF&quot;&gt;,theologischen‘&lt;/span&gt; Tradition von der Identität von Sein und Wesen in GOTT)&lt;/span&gt; antworten ''':'''  
::&lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;Die &lt;span style=&quot;color:#FF6000&quot;&gt;„100 Taler“&lt;/span&gt; sind der &lt;span style=&quot;color:#FF6000&quot;&gt;»''zufälligen Struktur der'' &lt;span style=&quot;color:#00B000&quot;&gt;[ vergänglichen ]&lt;/span&gt; ''Welt''«&lt;/span&gt; entnommen, und sind daher nicht mit GOTT vergleichbar, der, &lt;span style=&quot;color:#FF6000&quot;&gt;»''unabhängig von der zufälligen'' &lt;span style=&quot;color:#00B000&quot;&gt;[ Raum-Zeit-]&lt;/span&gt;''Struktur''«&lt;/span&gt; unserer Welt, &lt;span style=&quot;color:#FF6000&quot;&gt;„über“&lt;/span&gt; dieser Welt steht. Einzig und allein nur von GOTT gilt ''':''' Der mit Dingen aus unserer Welt ,nicht vergleichbare‘ GOTT, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx'''‘ —&lt;/span&gt;, &lt;span style=&quot;color:#FF6000&quot;&gt;„existiert notwendig für uns“&lt;/span&gt;, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''E'''&lt;sub&gt;not&lt;/sub&gt;'''x'''‘ —&lt;/span&gt;, und &lt;span style=&quot;color:#FF6000&quot;&gt;„notwendiges Existieren, &lt;u&gt;Sein&lt;/u&gt;“&lt;/span&gt; ,ist‘ die &lt;span style=&quot;color:#FF6000&quot;&gt;„positive &lt;u&gt;Wesen&lt;/u&gt;seigenschaft“&lt;/span&gt; in GOTT ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PE'''&lt;sub&gt;not&lt;/sub&gt;‘ —&lt;/span&gt;, weil GOTT aus sich &lt;span style=&quot;color:#FF6000&quot;&gt;„vollkommen“ &lt;span style=&quot;color:#00B000&quot;&gt;|&lt;/span&gt; „perfekt“&lt;/span&gt; ist, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PG'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#0000FF; background-color:#FFFF00&quot;&gt;‚Sein‘ ist in GOTT ein ‚reales Prädikat‘&lt;/span&gt;; &lt;span style=&quot;color:#00B000&quot;&gt;(notwendige ‚Existenz’ ist eine positive ‚Wesenseigenschaft’ in GOTT)&lt;/span&gt;, und nur bei GOTT '''!''' Zum zeitlos-ewigen GOTT der Christen ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx'''‘ —&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(als methodologische Kalkül-Prämisse)&lt;/span&gt;, kann man sagen ''':''' Weil es, wegen Axiom-1 und Axiom-2, &lt;span style=&quot;color:#FF6000&quot;&gt;„widerspruchsfrei möglich&quot;&lt;/span&gt; ist, dass es GOTT gibt ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''◇∃xGx'''‘ —&lt;/span&gt;, darum ist GOTT auch das ‚einzige‘ &lt;span style=&quot;color:#FF6000&quot;&gt;„Wesen“&lt;/span&gt;, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''∃x'''‘ —&lt;/span&gt;, von dem ein Christ sagen kann, dass es sowohl &lt;span style=&quot;color:#FF6000&quot;&gt;„notwendig aus sich“&lt;/span&gt; ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□∃xGx'''‘ —&lt;/span&gt;, d.h. &lt;span style=&quot;color:#FF6000&quot;&gt;„grundlos“ &lt;span style=&quot;color:#00B000&quot;&gt;|&lt;/span&gt; „unverursacht“&lt;/span&gt;, als auch &lt;span style=&quot;color:#FF6000&quot;&gt;„notwendig für uns“&lt;/span&gt; ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''E'''&lt;sub&gt;not&lt;/sub&gt;'''x'''‘ —&lt;/span&gt;, immer schon ‚da’ war und immer ,da’ sein wird; und zusätzlich gilt ''':''' Es gibt für jede mögliche Welt ‚nur‘ diesen einen GOTT ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□∃xGx ∧ □∀y(Gy→x=y)'''‘ — &lt;/span&gt;&lt;span style=&quot;color:#00B000&quot;&gt;(Monotheïsmus, Korollar-3)&lt;/span&gt;; vorausgesetzt, man geht von der ,Existenz’ dieses GOTTES aus, wobei diese Annahme für GÖDEL &lt;span style=&quot;color:#FF6000&quot;&gt;»''mit allen bekannten Tatsachen durchaus vereinbar''«&lt;/span&gt; ist.&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;

Eine Beobachtung ''':''' KANT sagt, gleichsam als ,krönenden‘ Abschluss seiner Widerlegung des, — von ihm so genannten —, ,ontologischen Gottesbeweises‘ ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;''Aber in meinem Vermögenszustande ist &lt;u&gt;mehr&lt;/u&gt; bei hundert ‚wirklichen‘ Talern, als bei dem bloßen Begriffe derselben, (d.i. ihrer Möglichkeit).''&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt; Diese Feststellung KANTS entspricht jedoch genau der Argumentation ANSELMS ''':''' GOTT &lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;esse et in re&lt;/big&gt;&lt;/span&gt;“&lt;/span&gt;, d.h. GOTT ,existiert auch in Wirklichkeit‘, &lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;quod maius est&lt;/big&gt;&lt;/span&gt;“&lt;/span&gt;, was &lt;u&gt;mehr&lt;/u&gt; ist, als &lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;esse solo in intellectu&lt;/big&gt;&lt;/span&gt;“&lt;/span&gt;, als nur ein bloßer Begriff ,im Verstand zu sein‘. Der ,Mehr-Wert‘ ergibt sich in beiden Fällen, sowohl bei den Talern als auch bei GOTT, aus der ,Wirklichkeit‘ ihrer Existenz, im Gegensatz zur bloßen, &lt;span style=&quot;color:#00B000&quot;&gt;(im Begriff gedachten)&lt;/span&gt;, ,Möglichkeit‘ ihrer Existenz, so dass, in jedem Fall, der ,Begriff‘ im Verstand ohne Abstriche &lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;''den ganzen Gegenstand ausdrückt''&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;, und von diesem auch &lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;''der angemessene Begriff''&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt; ist. Alles andere wäre eine ,Lüge‘. Mit dieser ,Beobachtung‘ ist das implizit ,Widersprüchliche‘ in KANTS Argumentation aufgedeckt ''':''' Das Wirkliche in KANTS Vermögenszustande enthält &lt;span style=&quot;color:#FF6000&quot;&gt;,doch mehr‘&lt;/span&gt; als das bloß Mögliche, konträr zu seiner vorigen Behauptung ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;''das Wirkliche''&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt; enthalte &lt;span style=&quot;color:#FF6000&quot;&gt;»'',nichts mehr‘&lt;/span&gt; als das bloß Mögliche''&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;. Diese Behauptung ist offensichtlich falsch. Das ist somit ein indirekter Beweis und damit eine Bestätigung für die analoge Argumentation ANSELMS aus dem Widerspruch des Gegenteils, am Beispiel KANTS &lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;''Vermögenzustandes bei hundert wirklichen Talern''&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;, in dem in Wirklichkeit &lt;span style=&quot;color:#FF6000&quot;&gt;,doch mehr‘&lt;/span&gt; ist, &lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;''als bei dem bloßen Begriffe derselben''&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;. 

&lt;span style=&quot;color:#00B000&quot;&gt;(Diese ,Beobachtung‘ ist zugleich auch das entscheidende Indiz dafür, dass das systembedingte Konzept KANTS von der ,Existenz‘, bzw. vom ,Sein‘ eines jeden Gegenstandes, als&lt;/span&gt; &lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;''dessen bloße Position''&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;d.i. als seine ,Setzung‘ bloß im- und durch den Verstand, ,falsch‘ ist, — d.h. im Klartext ''':''' für KANT ist das ,Sein‘ eines Gegenstandes bloß ein ,Gedanke‘ in uns, wenn er meint, dass uns ein Gegenstand erst dann wirklich ,gegeben‘ sei, wenn wir uns den&lt;/span&gt; &lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;''Gegenstand als schlechthin gegeben (durch den Ausdruck : &lt;u&gt;er ist&lt;/u&gt;) &lt;u&gt;denken&lt;/u&gt;''&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;was nur dem Irrtum einer falschen System-Konzeption geschuldet sein kann. Auf Grund dieser Konzeption ist das&lt;/span&gt; &lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;''Ding, wie es an sich selbst ist''&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;für KANT systembedingt weder ,anschaubar‘, noch ,erkennbar‘. Diese falsche Konzeption über die ,Existenz‘, bzw. das ,Sein‘ eines Dinges, als&lt;/span&gt; &lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;''dessen bloße Position''&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;ist für KANT letztendlich auch die Beweisgrundlage und Voraussetzung für seine Ablehnung des ontologischen Argumentes für GOTT im Theorem ANSELMS. Wenn das ,wirkliche‘ Sein eines Dinges nichts anderes ist, als&lt;/span&gt; &lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;''dessen'' &lt;span style=&quot;color:#00B000&quot;&gt;[ bloß gedachte ]&lt;/span&gt; ''Position''&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;d.h. als seine ,mögliche Setzung‘ bloß im- und durch den Verstand, — das ist das, als ,wirklich‘ bloß nur ,gedachte‘ Ding —, dann&lt;/span&gt; &lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;''enthält''&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;natürlich&lt;/span&gt; &lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;''das Wirkliche''&lt;span style=&quot;color:#00B000&quot;&gt;, [ als die bloß gedachte Existenz ],&lt;/span&gt; ''nichts mehr als das bloß Mögliche''&lt;span style=&quot;color:#00B000&quot;&gt;, [ als der gedachte Begriff ]&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;, was offensichtlich unhaltbar ist. &lt;span style=&quot;color:#4C58FF&quot;&gt;[ Modus tollendo tollens ] &lt;/span&gt; ''':''' Wenn die Konsequenz einer Wenn-Dann-Folgerung ,falsch‘ ist, dann ist auch ihre Voraussetzung, das System-Konzept KANTS, ,falsch‘ ''':''' d.i. seine ,Kopernikanische Wende‘ für die Metaphysik, soweit sie KANTS ,Sein’-Konzept betrifft. Korrekt und ,wahr‘ ist in jedem Fall ''':''' Das Wirkliche enthält &lt;span style=&quot;color:#FF6000&quot;&gt;,doch mehr‘&lt;/span&gt; als das bloß Mögliche, und die Dinge ,existieren‘ schon immer unabhängig von unserem Denken. ,Existenz‘, das ,Sein‘, ist &lt;span style=&quot;color:#FF6000&quot;&gt;,doch mehr‘&lt;/span&gt;, als bloß ein ,Gedanke‘ von uns.)&lt;/span&gt; 

Somit ist die Argumentation KANTS gegen den ontologischen Beweis ANSELMS für GOTT ,falsch‘ und unhaltbar, weil sie auf der ,falschen‘ Voraussetzung beruht ''':''' die ,Existenz‘, bzw. das ,Sein‘ eines jeden ,Gegenstandes‘, — wie z. B. auch die Existenz bei GOTT —, sei bloß dessen gedachte ,Position‘ an sich selbst, d.h. bloß seine ,Setzung‘ im- und durch den Verstand. Damit ,macht‘ er GOTT außerdem zu einem ,Ding‘ unter den vielen ,Dingen‘ dieser Welt, und verkennt so, — wie vor ihm THOMAS von Aquin —, auch die Einzigartigkeit und Exklusivität GOTTES im Theorem ANSELMS.


&lt;div class=&quot;center&quot;&gt;Die &lt;span style=&quot;color:#FF6000&quot;&gt;„Rede von GOTT“&lt;/span&gt; in der philosophischen Tradition&lt;/div&gt;

Wenn man die philosophische Tradition der &lt;span style=&quot;color:#FF6000&quot;&gt;„Rede von GOTT“&lt;/span&gt; im Lichte der Ergebnisse der &lt;span style=&quot;color:#4C58FF&quot;&gt;„axiomatischen Theologie“&lt;/span&gt; GÖDELS liest, dann stellt sie sich am Beispiel bei ARISTOTELES, — AVICENNA, — ANSELM, und bei GÖDEL wie folgt dar ''':''' 

&lt;span style=&quot;color:#FF6000&quot;&gt;»''Das Erstbewegende,'' (&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;,πρῶτον κινοῦν‘&lt;/big&gt;&lt;/span&gt;), ''das, ohne selbst ‚bewegt‘ zu sein'',  (&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;,ἀκίνητον‘&lt;/big&gt;&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;| ''unverursacht, ,entstehungslos‘'' |&lt;/span&gt; ), ''alles Übrige wie ein Geliebtes ‚bewegt‘'', (&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;,κινεῖ δὴ ὡς ἐρώμενον‘&lt;/big&gt;&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt; | ''-verursacht, ,entstehen‘ lässt'' |&lt;/span&gt; ), ''ist sowohl'' &lt;span style=&quot;color:#00B000&quot;&gt;[ zeitlich-]&lt;/span&gt;''ewiges ‚Wesen‘'', (&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;,ἀΐδιον καί οὐσία‘&lt;/big&gt;&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;| ''‚Substanz‘'' |&lt;/span&gt; ), ''als auch'' &lt;span style=&quot;color:#00B000&quot;&gt;[ zeitlich-]&lt;/span&gt;''ewiges ‚wirksames, verwirklichendes Sein‘'', (&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;‚ἀΐδιον καί ἐνέργεια οὖσα‘ = ‚actus purus‘&lt;/big&gt;&lt;/span&gt;&lt;span style=&quot;color:#00B000&quot;&gt; | '',reine Tätigkeit‘'' |&lt;/span&gt; ), … ''ersehnt'', (&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;,ὀρεκτόν‘&lt;/big&gt;&lt;/span&gt;), ''und erkennbar'', (&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;,νοητόν‘&lt;/big&gt;&lt;/span&gt;), ... ''denn dies ist der ‚Gott‘'', (&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;,τοῦτο γὰρ ὁ θεός‘&lt;/big&gt;&lt;/span&gt;), &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx'''‘ —&lt;/span&gt;, ''der'' &lt;span style=&quot;color:#00B000&quot;&gt;[ zeitlich-]&lt;/span&gt;''Ewige'', (&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;,ἀΐδιον‘&lt;/big&gt;&lt;/span&gt;), — ''der Unvergleichliche'', (&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;,ἄριστον‘&lt;/big&gt;&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;| ''‚der Beste‘'' |&lt;/span&gt; ), — ''der Lebendige'', (&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;,ζῷον‘&lt;/big&gt;&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;| ,''das Leben selbst‘'' |&lt;/span&gt; ), — ... ''so sagen wir ja'', (&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;,φαμὲν δὴ‘&lt;/big&gt;&lt;/span&gt;), — ...«&lt;/span&gt; ''':''' &lt;span style=&quot;color:#00B000&quot;&gt;(ARISTOTELES — Grieche)&lt;/span&gt;. 

Der ‚Begriff’ &lt;span style=&quot;color:#FF6000&quot;&gt;„GOTT“&lt;/span&gt;, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''G'''‘ —&lt;/span&gt;, als ,Individuumname‘, ist synonym mit &lt;span style=&quot;color:#FF6000&quot;&gt;„göttliches ‚Da-Sein’“&lt;/span&gt;, das sowohl &lt;span style=&quot;color:#FF6000&quot;&gt;„aus sich vollkommen“&lt;/span&gt;, als auch &lt;span style=&quot;color:#FF6000&quot;&gt;„notwendig für uns“&lt;/span&gt; ‚da‘ ist; &lt;span style=&quot;color:#00B000&quot;&gt;(das ist das, an sich, vollkommene ‚Was-Sein‘ GOTTES ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PG'''‘ — &lt;/span&gt;, das zugleich, für uns, das notwendige ‚Da-Sein‘ GOTTES ''':'''  &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''E'''&lt;sub&gt;not&lt;/sub&gt;'''x'''‘&lt;/span&gt; — ist)&lt;/span&gt;; &lt;span style=&quot;color:#CC66FF&quot;&gt;„von Ewigkeit zu Ewigkeit“&lt;/span&gt;. Das ist der &lt;u&gt;angemessene Begriff&lt;/u&gt; von GOTT, und gilt ‚nur‘ von GOTT. Weil GOTT &lt;span style=&quot;color:#FF6000&quot;&gt;„vollkommen“&lt;/span&gt; ist, ist &lt;span style=&quot;color:#FF6000&quot;&gt;„Da-Sein“ &lt;span style=&quot;color:#00B000&quot;&gt;|&lt;/span&gt; „GOTT-Sein“ &lt;span style=&quot;color:#00B000&quot;&gt;|&lt;/span&gt; „Göttlichkeit“&lt;/span&gt; das &lt;span style=&quot;color:#FF6000&quot;&gt;„Wesen“&lt;/span&gt; GOTTES ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx↔G'''&lt;sub&gt;ess&lt;/sub&gt;'''x'''‘ —&lt;/span&gt;. Im Unendlichen, GOTT, sind &lt;span style=&quot;color:#FF6000&quot;&gt;„Essenz“&lt;/span&gt; und &lt;span style=&quot;color:#FF6000&quot;&gt;„Existenz“&lt;/span&gt; koinzident ,eins‘, und daher untrennbar, und &lt;span style=&quot;color:#FF6000&quot;&gt;»''darum ist GOTT das einzige ‚Sein’, das notwendig an sich ‚da‘ ist''«&lt;/span&gt; ''':'''  &lt;span style=&quot;color:#00B000&quot;&gt;(ABU ALI SINA alias AVICENNA — Muslim)&lt;/span&gt;. 

Der &lt;span style=&quot;color:#00B000&quot;&gt;(gedachte)&lt;/span&gt; ‚Eigenschafts-Begriff‘ &lt;span style=&quot;color:#FF6000&quot;&gt;„Vollkommenheit (die Größe) GOTTES“&lt;/span&gt;, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PG'''‘ —&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(‚Perfektion‘, die unbegrenzte Summe aller ‚positiven Eigenschaften‘ in GOTT)&lt;/span&gt; schließt koinzident die ‚Eigenschaft’ &lt;span style=&quot;color:#FF6000&quot;&gt;„notwendige Existenz für uns“&lt;/span&gt; mit ein ''':'''  &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PE'''&lt;sub&gt;not&lt;/sub&gt;‘ —&lt;/span&gt;. GOTT wäre nicht &lt;span style=&quot;color:#FF6000&quot;&gt;„vollkommen“&lt;/span&gt;, wenn er nicht auch real für uns ‚da‘ wäre, wenn er nicht ,immer schon’ &lt;span style=&quot;color:#FF6000&quot;&gt;„existierte“&lt;/span&gt;. ‚Sein’ ist &lt;u&gt;mehr&lt;/u&gt; als ‚Nicht-Sein’. ,Sein’, bzw. ,Existenz’ gehört in GOTT zu den ,Transzendentalia’. Das sind die &lt;span style=&quot;color:#00B000&quot;&gt;(ultimativen)&lt;/span&gt; ,Wesenseigenschaften’ in GOTT. Der unbegrenzt Unendliche, GOTT, ist daher das &lt;span style=&quot;color:#FF6000&quot;&gt;»''vollkommenste Wesen, über das nichts ,Größeres‘ d.h. Vollkommeneres &lt;u&gt;mehr&lt;/u&gt; ‚gedacht‘ werden kann''«&lt;/span&gt; ''':''' &lt;span style=&quot;color:#00B000&quot;&gt;(ANSELM von Canterbury — Christ)&lt;/span&gt;.  

Der ‚Begriff’ &lt;span style=&quot;color:#FF6000&quot;&gt;„Perfektion GOTTES“&lt;/span&gt;, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PG'''‘ —&lt;/span&gt;, schließt koinzident das &lt;span style=&quot;color:#FF6000&quot;&gt;„notwendige Dasein GOTTES“&lt;/span&gt;, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''E'''&lt;sub&gt;not&lt;/sub&gt;'''x'''‘&lt;/span&gt; —, für uns mit ein, ohne einen zeitlichen Anfang und ohne ein zeitliches Ende. Das ist die ‚zeitlos-ewige‘, an sich absolute, und &lt;span style=&quot;color:#FF6000&quot;&gt;„für uns notwendige Existenz GOTTES“&lt;/span&gt; ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx→E'''&lt;sub&gt;not&lt;/sub&gt;'''x'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#00B000&quot;&gt;(Das ist ein ,regulär‘-mögliches Korollar im 2. Beweisgang aus Term :16: ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gy→Yy'''‘ —&lt;/span&gt;, mit der &lt;span style=&quot;color:#4C58FF&quot;&gt;[ Instanz(Y:=E&lt;sub&gt;not&lt;/sub&gt;) ]&lt;/span&gt;, und der &lt;span style=&quot;color:#4C58FF&quot;&gt;[ FUB(y:=x) ]&lt;/span&gt;; und auch ein ,regulär‘-mögliches Korollar im 3. Beweisgang ''':''' entsprechend der &lt;span style=&quot;color:#FF6000&quot;&gt;„logischen Implikation”&lt;/span&gt; :: &lt;span style=&quot;color:#4C58FF&quot;&gt;[├ A ├ B ╞ A → B ]&lt;/span&gt; von Term :01: &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx'''‘ — &lt;/span&gt; und Term :05: &lt;span style=&quot;color:#4C58FF&quot;&gt; —‚'''E'''&lt;sub&gt;not&lt;/sub&gt;'''x'''‘ —&lt;/span&gt; aus diesem Beweisgang. In Worten ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;''Angenommen, '' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''x'''‘ —&lt;/span&gt; ''steht für den GOTT der Christen'' ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''G'''‘ — &lt;/span&gt;, ''dann existiert dieser GOTT'', &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''x'''‘ —&lt;/span&gt;, ''für uns notwendig'', &lt;span style=&quot;color:#4C58FF&quot;&gt;— &lt;sub&gt;not&lt;/sub&gt; —&lt;/span&gt; &lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;.)&lt;/span&gt; Der Unendliche, GOTT, ist &lt;span style=&quot;color:#FF6000&quot;&gt;»''unabhängig von der zufälligen'' &lt;span style=&quot;color:#00B000&quot;&gt;[ Raum-Zeit-]&lt;/span&gt;''Struktur''«&lt;/span&gt; unserer ‚vergänglichen‘, ,endlichen‘ Welt, welche prinzipiell vom dreidimensionalen Raum und von der unwiederbringlich ‚vergehenden‘ Zeit geprägt ist. Der ,GOTT der Christen‘ ist &lt;span style=&quot;color:#FF6000&quot;&gt;»''unabhängig''«&lt;/span&gt; von dieser &lt;span style=&quot;color:#FF6600&quot;&gt;„vergehenden Raum-Zeit“, — »''jenes rätselhafte und anscheinend in sich widersprüchliche Etwas''« &lt;span style=&quot;color:#00B000&quot;&gt;(GÖDEL)&lt;ref&gt;Kurt GÖDEL, ‚''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;Eine Bemerkung über die Beziehungen zwischen der Relativitätstheorie und der idealistischen Philosophie‘&lt;/big&gt;&lt;/span&gt;'', in P.A.SCHILPP (Hg.): ‚''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;Albert Einstein, Philosoph und Naturforscher‘&lt;/big&gt;&lt;/span&gt;'', Seite 406&lt;/ref&gt;&lt;/span&gt; —&lt;/span&gt;. Ohne ‚Zeit‘ gibt es keinen zeitlichen Unterschied zwischen ‚Ursache‘ und  ‚Wirkung‘, &lt;span style=&quot;color:#00B000&quot;&gt;(beides ist zeitlos ,eins‘)&lt;/span&gt;, und so ist der zeitlos-ewige GOTT, der &lt;span style=&quot;color:#FF6000&quot;&gt;»''notwendig aus sich ,existiert‘'' «&lt;/span&gt;  ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□∃xGx'''‘ — &lt;/span&gt;, &lt;span style=&quot;color:#FF6000&quot;&gt;„unverursacht“ &lt;span style=&quot;color:#00B000&quot;&gt;|&lt;/span&gt; „ursprungslos“&lt;/span&gt; für uns immer schon ‚da‘ ''':''' &lt;span style=&quot;color:#00B000&quot;&gt;(GÖDEL — ohne religiöses Bekenntnis)&lt;/span&gt;.

Mit dem GÖDEL-Kalkül ist die &lt;span style=&quot;color:#FF6000&quot;&gt;„Rede von GOTT“&lt;/span&gt; auf eine ‚vernünftige Basis‘ gestellt worden, und ist somit für jeden Menschen nachvollziehbar, &lt;span style=&quot;color:#FF6000&quot;&gt;»''rein verstandesmäßig, (ohne sich auf den Glauben an irgendeine Religion zu stützen)''«&lt;/span&gt;, wie obige Beispiele zeigen.


'''Resümee :'''  

Das GÖDEL-Kalkül zeigt mit &lt;span style=&quot;color:#FF6000&quot;&gt;»''mathematischer Evidenz''«&lt;/span&gt;, was notwendig folgt, wenn die Axiome ‚wahr‘ sind, &lt;span style=&quot;color:#00B000&quot;&gt;(die Axiome bilden formal-syntaktisch &lt;span style=&quot;color:#FF6000&quot;&gt;»''die theologische Weltanschauung''«&lt;/span&gt; ab)&lt;/span&gt;, unter der Voraussetzung, dass die Axiome &lt;span style=&quot;color:#FF6000&quot;&gt;»''unabhängig von der zufälligen'' &lt;span style=&quot;color:#00B000&quot;&gt;[ Raum-Zeit-]&lt;/span&gt;'' Struktur''«&lt;/span&gt; unserer Welt sind. Die ,Verifikation‘ der Axiome und Definitionen von GOTT und seiner Vollkommenheiten gelingt GÖDEL, — entsprechend seiner Unabhängigkeits-Bedingung —, durch den Aufweis ihrer Widerspruchsfreiheit ''':''' sie sind somit ,wahr‘ und, — im Kontext einer &lt;span style=&quot;color:#FF6000&quot;&gt;»''theologischen Weltanschauung''«&lt;/span&gt; —, auch ,annehmbar‘ in unserer ,realen‘ Welt ''':''' &lt;span style=&quot;color:#00B000&quot;&gt;(siehe Anhang, 2. Beweisgang und Anmerkung-2)&lt;/span&gt;. Er vermeidet damit den Fehler, der immer wieder im Diskurs über Gottesbeweise gemacht wird ''':''' GOTT mit seinen Geschöpfen zu vergleichen. Diese logisch-philosophische Rede von GOTT &lt;span style=&quot;color:#00B000&quot;&gt;(&lt;span style=&quot;color:#FF6000&quot;&gt;»''ohne sich auf den Glauben an irgendeine Religion zu stützen''«&lt;/span&gt;)&lt;/span&gt; hat eine &lt;u&gt;mehr&lt;/u&gt; als zweitausendjährige Tradition hinter sich. Der &lt;span style=&quot;color:#FF6000&quot;&gt;„100-Taler-Gott“&lt;/span&gt; des Philosophen KANT, hat heute, nachdem der Logiker und Systemtheoretiker GÖDEL sein System vorgelegt hat, an ‚Strahlkraft‘ verloren. 

Kurt GÖDEL ''':'''  
::&lt;span style=&quot;color:#FF6000&quot;&gt;» ''Die theologische Weltanschauung'', &lt;span style=&quot;color:#00B000&quot;&gt;[ dass GOTT für uns immer schon ‚da‘ ist ]&lt;/span&gt;, ''ist rein verstandesmäßig mit allen bekannten Tatsachen durchaus vereinbar'';«&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;[ d.h. sie ist das ,Resultat‘ der, — vom Glauben geleiteten —,  ‚theoretischen Vernunft‘, alias ‚reinen Vernunft‘, und nicht bloß das ‚Postulat‘ einer ‚praktischen Vernunft‘, wie KANT meint ]. &lt;span style=&quot;color:#FF6000&quot;&gt;»''Der'' &lt;span style=&quot;color:#00B000&quot;&gt;[ christliche ]&lt;/span&gt; ''Glaube ist die ‚Pupille‘ im ‚Auge‘ unseres Verstandes.''«&lt;/span&gt; (Heilige KATHARINA von Siena, Lehrerin der Kirche, Patronin Europas&lt;ref&gt;vgl. &lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;''Gebet 7 ‚Für die neuen Kardinäle‘, Rom, 21. Dezember 1378,''&lt;/big&gt;&lt;/span&gt; aus &lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;''Caterina von Siena ,Die Gebete‘.''&lt;/big&gt;&lt;/span&gt; Kleinhain 2019, online: https://caterina.at/werke/gebete/gebete-detailansicht/gebet-7.html&lt;/ref&gt; )&lt;/span&gt;

Der sonst so rationale  KANT, hier doch etwas emotionell, &lt;span style=&quot;color:#00B000&quot;&gt;(als wolle er die Ergebnisse im GÖDEL-Kalkül nicht wahr haben, die belegen, dass er sich bei GOTT geirrt, und die Funktion des christlichen Glaubens für die Philosophie falsch eingeschätzt hat)&lt;/span&gt; ''':'''
::&lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt; ''Es war etwas ganz Unnatürliches und eine bloße Neuerung des Schulwitzes, aus einer ganz willkürlich entworfenen Idee das Dasein des ihr entsprechenden Gegenstandes selbst ausklauben zu wollen''&lt;ref&gt;vgl. ‚''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;Kritik  der reinen Vernunft&lt;/big&gt;&lt;/span&gt;''‘, Seite 403. https://www.korpora.org/kant/aa03/403.html&lt;/ref&gt;.&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;

Für KANT, für die Scholastiker, &lt;span style=&quot;color:#00B000&quot;&gt;(und auch für uns)&lt;/span&gt;, ist es natürlich ‚logisch‘, dass aus einem als ‚möglich’ gedachten Begriff, &lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;''aus einer ganz willkürlich entworfenen Idee''&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;, keine Existenzaussage abgeleitet werden kann. &lt;span style=&quot;color:#00B000&quot;&gt;(Aus dem bloß gedachten Begriff ,goldene Berge‘ folgt natürlich nicht, dass es solche in Wirklichkeit auch gibt.)&lt;/span&gt; In der philosophisch-&lt;span style=&quot;color:#4C58FF&quot;&gt;,theologischen’&lt;/span&gt; Tradition, die von ARISTOTELES herkommt, ist der Begriff &lt;span style=&quot;color:#FF6000&quot;&gt;»''GOTT''«&lt;/span&gt; jedoch von allen anderen Begriffen so verschieden, so dass für GOTT diese Logik KANTS nicht mehr gilt. GOTT ist ,unvergleichlich‘ und ,einzigartig‘.

Dazu der Kommentar von HEGEL ''':'''  
::&lt;span style=&quot;color:#FF6000&quot;&gt;»''Wenn KANT sagt, man könne aus dem Begriff'' &lt;span style=&quot;color:#00B000&quot;&gt;[ ‚GOTT‘ ]&lt;/span&gt; ''die Realität nicht ,herausklauben‘, so ist da der Begriff als endlich gefasst''.« &lt;span style=&quot;color:#00B000&quot;&gt;[ In der Endlichkeit unserer Welt trifft die Logik KANTS zu, dass dem ‚Begriff‘ nicht ,notwendig‘ das ‚Sein‘ folgt, denn es gibt in ihr die ,Lüge‘, die das ,Wirklich-Sein‘ im Begriff bloß behauptet, ohne dass es ,in Wirklichkeit‘ zutrifft, was sie behauptet. Es gilt hier nach KANT ''':''' »''Sein ist kein reales Prädikat''«. Somit ist ]&lt;/span&gt; »''...der Begriff ohne'' &lt;span style=&quot;color:#00B000&quot;&gt;[ reales ]&lt;/span&gt; ''Sein ein Einseitiges und Unwahres, und ebenso das Sein, in dem kein Begriff ist'', &lt;span style=&quot;color:#00B000&quot;&gt;[ ist ]&lt;/span&gt; ''das begrifflose Sein,'' &lt;span style=&quot;color:#00B000&quot;&gt;[ d.i. das relative ,Noch-Nicht-Begriffene‘ ]&lt;/span&gt;.'' Dieser Gegensatz, der in die Endlichkeit fällt'' &lt;span style=&quot;color:#00B000&quot;&gt;[ im Endlichen zutrifft ]&lt;/span&gt;, ''kann bei dem Unendlichen, GOTT, gar nicht statthaben''&lt;ref&gt;Georg Wilhelm Friedrich HEGEL, ‚&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;''Ausführungen des ontologischen Beweises''&lt;/big&gt;&lt;/span&gt;‘ in den  ‚&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;''Vorlesungen über die Philosophie der Religion vom Jahr 1831''&lt;/big&gt;&lt;/span&gt;‘ . Hamburg 1966, Seiten  175 bzw. 174&lt;/ref&gt;; &lt;span style=&quot;color:#00B000&quot;&gt;[ denn ,Begriff‘, bzw. ,Denken‘ und ,Sein‘ sind in dem Unendlichen, GOTT,  untrennbar und real immer dasselbe. Auf Grund dieser ontologischen Identität ,personifiziert‘ und ,repräsentiert‘ GOTT die ,Wahrheit‘ ''':''' GOTT ist die ,Wahrheit‘. In GOTT, dem &lt;span style=&quot;color:#FF6000&quot;&gt;„Schöpfer der Welt“&lt;/span&gt;, folgt dem ,Begriff‘ immer ,notwendig‘ das ,Sein‘ ''':''' &lt;span style=&quot;color:#CC66FF&quot;&gt;»''GOTT sprach ''':''' Es werde ,Licht‘. Und es wurde Licht''«, &lt;small&gt;{{Bibel | Genesis |1|3|EU}}&lt;/small&gt;;&lt;/span&gt; oder auch ''':''' &lt;span style=&quot;color:#CC66FF&quot;&gt;»''Der Herr sprach, und sogleich geschah es; er gebot, und alles war da''«,&lt;/span&gt; &lt;small&gt;{{Bibel | Psalm |33|9|EU}}&lt;/small&gt;.]&lt;/span&gt;«&lt;/span&gt; 

Das Entscheidende bei der &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologischen“&lt;/span&gt; Interpretation des GÖDEL-Kalküls ist, dass der &lt;span style=&quot;color:#00B000&quot;&gt;(Begriff)&lt;/span&gt; GOTT der Christen ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx'''‘ —&lt;/span&gt;, nicht auf die Ebene seiner ,endlichen‘ Geschöpfe und unserer Welt gestellt wird, &lt;span style=&quot;color:#00B000&quot;&gt;(d.i. das ‚Universum‘ im ,Urknall‘, die ‚100-Taler‘, ein ‚Tsunami‘, auch ,einfache Modelle‘ von unserer Welt, etc.)&lt;/span&gt;, und damit verglichen wird, sondern, dass der GOTT der Christen in seiner Einzigartigkeit und Besonderheit als &lt;span style=&quot;color:#FF6000&quot;&gt;»''der Unendliche''«&lt;/span&gt; belassen und als &lt;span style=&quot;color:#FF6000&quot;&gt;»''unabhängig von der zufälligen'' &lt;span style=&quot;color:#00B000&quot;&gt;[ Raum-Zeit-]&lt;/span&gt;''Struktur''«&lt;/span&gt; unserer vergänglichen Welt, — als &lt;span style=&quot;color:#FF6000&quot;&gt;»''der Unvergleichliche''«&lt;/span&gt; —, verstanden wird. &lt;span style=&quot;color:#00B000&quot;&gt;(Alle Kritiken des sog. ,ontologischen‘ Gottesbeweises übersehen die Einzigartigkeit und Besonderheit des &lt;span style=&quot;color:#FF6000&quot;&gt;»''Unendlichen''«&lt;/span&gt;, und/oder wollen diese nicht ,wahr‘ haben.)&lt;/span&gt;  Auch THOMAS von Aquin ,verortet‘ den GOTT ANSELMS, — in seiner Kritik an dessen Theorem —, irrtümlich unter die ,Dinge‘ der uns umgebenden ,Natur‘, wenn er sagt ''':''' GOTT &lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;esse in rerum natura&lt;/big&gt;&lt;/span&gt;“&lt;/span&gt;, d.h. wörtlich, dass der GOTT ANSELMS &lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;''in der Natur der Dinge'' &lt;span style=&quot;color:#00B000&quot;&gt;(unserer Welt)&lt;/span&gt; ''existiert''&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;, und verkennt somit, — wie nach ihm auch KANT —, die ,Unvergleichlichkeit‘ GOTTES, &lt;span style=&quot;color:#00B000&quot;&gt;(vgl. STh I q.2 a.1 ad 2&lt;ref&gt;„Deus … illud quo maius cogitari non potest; non tamen propter hoc sequitur quod intelligat id quod significatur per nomen, esse in rerum natura; sed in apprehensione intellectus tantum.“ ——— »''GOTT ist'' (nach ANSELM) ''der, über den Größeres nicht mehr gedacht werden kann. Aber nicht deswegen, weil er'', (der Narr von Psalm 14.1, den ANSELM zitiert), ''das versteht, was durch diesen Namen,'' (d.h. mit dem Begriff ,GOTT‘, als der ,Größte‘ über allem, im Theorem ANSELMS), ''bezeichnet wird, folgt daraus'', (wie ANSELM meint), ''dass er auch versteht, dass er'', (der GOTT ANSELMS), ''auch in der ,Natur‘ der Dinge'' (unserer Welt) ''existiert''; &lt;span style=&quot;color:#00B000&quot;&gt;[ was ANSELM so nie gesagt hat, und auch nie ,gemeint‘ hat ]&lt;/span&gt;. ''Daraus folgt nur, dass er'', (als ,GOTT‘), ''bloß in der Auffassung seines Verstandes'', (d.h. nur im Denken des Narren als ,Begriff‘), ''existiert.''« ——— Hier ,verortet‘ THOMAS einerseits den unendlichen GOTT, von dem das Theorem ANSELMS spricht, irrtümlich unter die endlichen Dinge der uns umgebenden ,Natur‘, was sachlich dem theologischen Theorem der Unvergleichlichkeit GOTTES widerspricht, der nicht unter die Dinge unserer Welt eingereiht werden darf. Anderseits verliert er dadurch auch den ,Blick‘ für die Außerordentlichkeit und Besonderheit GOTTES, dessen Natur völlig verschieden und unabhängig von der ,Natur‘ unserer raum-zeitlichen Welt ist. GÖDEL beweist jedoch, mit ANSELM, weil es notwendig, ohne Widerspruch, (»''bloß in der Auffassung unseres Verstandes''«), möglich ist, dass GOTT existiert, ist es korrekt, daraus auch mit Notwendigkeit zu folgern, dass der Glaube des Erzbischofs ANSELM, und der Glaube seiner Anvertrauten, von der Wirklichkeit GOTTES, widerspruchsfrei, logisch richtig, und damit rational sinnvoll ist; denn Möglichkeit  und Wirklichkeit sind in GOTT koinzident ,eins‘. Das ist das Privilegium GOTTES allein, der einzigartig und unvergleichlich ist. Damit zeigt er auf, dass THOMAS die Unvergleichlichkeit und Einzigartigkeit GOTTES in seinem Vorhalt nicht bedacht hat; und außerdem ANSELM missverstanden hat.&lt;/ref&gt;)&lt;/span&gt;; jedenfalls hier in der Auseinandersetzung mit ANSELM.  Dagegen spricht ANSELM im ,''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;Proslogion&lt;/big&gt;&lt;/span&gt;''‘, Seite 85f, nur von einem &lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;esse et in re&lt;/big&gt;&lt;/span&gt;“&lt;/span&gt; GOTTES, d.h. dass GOTT ,auch in Wirklichkeit existiert‘, &lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;quod maius est&lt;/big&gt;&lt;/span&gt;“&lt;/span&gt;, was ,größer‘, bzw. ,mehr‘ ist, als &lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;esse solo in intellectu&lt;/big&gt;&lt;/span&gt;“&lt;/span&gt;, als nur ,im Verstand zu sein‘; wobei die ,zeitlose-überzeitliche‘ Wirklichkeit, &lt;span style=&quot;color:#00B000&quot;&gt;(&lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;re&lt;/big&gt;&lt;/span&gt;“&lt;/span&gt;, die Natur)&lt;/span&gt;, GOTTES jedoch völlig verschieden und &lt;span style=&quot;color:#FF6000&quot;&gt;»''unabhängig von der zufälligen''«&lt;/span&gt; Wirklichkeit, &lt;span style=&quot;color:#00B000&quot;&gt;(die ,Natur‘, &lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;natura rerum&lt;/big&gt;&lt;/span&gt;“&lt;/span&gt;)&lt;/span&gt;, der ,raum-zeitlichen‘ Welt der Dinge ist. Daher ist sie mit dieser auch nicht vergleichbar. GOTT ist &lt;span style=&quot;color:#FF6000&quot;&gt;„vollkommen“&lt;/span&gt; und alle &lt;span style=&quot;color:#FF6000&quot;&gt;„Vollkommenheiten“&lt;/span&gt; in GOTT, &lt;span style=&quot;color:#00B000&quot;&gt;(die ultimativen ,Transzendentalia‘ und alle Zuschreibungen)&lt;/span&gt;, sind koinzident ,eins‘, — ,fallen &lt;span style=&quot;color:#FF6000&quot;&gt;„notwendig“&lt;/span&gt; perspektivisch in eins zusammen‘, und sind daher konvertierbar. Darum ist auch die Wirklichkeit, &lt;span style=&quot;color:#00B000&quot;&gt;(Natur)&lt;/span&gt;, GOTTES ,einzigartig‘ und ,unvergleichlich‘.

Mit dem FUHRMANN-Korollar-3 ist die Exklusivität und Außerordentlichkeit GOTTES definitiv im Kalkül ,bewiesen‘ &lt;span style=&quot;color:#00B000&quot;&gt;( ╞ )&lt;/span&gt;. Der abendländische Monotheïsmus ist somit eine ,logische‘ Konsequenz aus den GÖDEL-Axiomen. &lt;span style=&quot;color:#00B000&quot;&gt;(Das &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologische“&lt;/span&gt; Theorem von der ,Einzigartigkeit‘ und Exklusivität GOTTES, d.h. hier im Kontext ''':''' die exklusive Einheit von GOTT und Mensch in JESUS CHRISTUS; von Vater, Sohn und Geist im &lt;span style=&quot;color:#4C58FF&quot;&gt;„Dreifaltigen“&lt;/span&gt;; die Einheit von Essenz und Existenz, von Begriff und Sein, von Ursache und Wirkung, von Subjekt und Objekt, von Möglichkeit und Wirklichkeit, und die unbegrenzte Summeneinheit und Koinzidenz der unendlichen Transzendentalien in GOTT, ist, — mit HEGEL —, die Voraussetzung und Bedingung jeder Philosophie ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Die Einheit muss am Anfang der Philosophie stehen''«&lt;/span&gt;; und ist zugleich auch ihr gesuchtes und bewiesenes Endergebnis und Ziel ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Diese Einheit muss auch das Resultat der Philosophie sein''«&lt;/span&gt;&lt;ref&gt;https://hegel-system.de/de/gottesbeweis.htm#hegels-kritik-an-kant&lt;/ref&gt;, was hier im GÖDEL-Kalkül ,logisch‘ mit Korollar-3 verifiziert wird ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□(∃xGx ∧ ∀y(Gy→x=y))'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''GOTT ist exklusiv einzigartig''«&lt;/span&gt;.)&lt;/span&gt; 

Die Einzigartigkeit GOTTES bedingt die Koinzidenz, den inneren Zusammenhang aller seiner Vollkommenheiten und Zuschreibungen, &lt;span style=&quot;color:#00B000&quot;&gt;(Axiom-2)&lt;/span&gt;, d.h. ihr paarweise, perspektivisches ,Zusammenfallen in eins‘ im Unendlichen, GOTT. ——— Aus der Notwendigkeit aller positiven Eigenschaften und Zuschreibungen, &lt;span style=&quot;color:#00B000&quot;&gt;(d.h. aus den, an sich, notwendigen, ultimativen Transzendentalien, Axiom-4)&lt;/span&gt;, die in GOTT paarweise, als ,Wesenseigenschaften‘ koinzident ,eins‘ sind, &lt;span style=&quot;color:#00B000&quot;&gt;(Definition-2)&lt;/span&gt;, ist die Einzigkeit GOTTES für uns erschließbar, &lt;span style=&quot;color:#00B000&quot;&gt;(Korollar-3)&lt;/span&gt;. Axiom-4 ist die erste, ,modal‘ &lt;span style=&quot;color:#FF6000&quot;&gt;„notwendige“&lt;/span&gt;, d.h. die transzendentale Voraussetzung für Korollar-3.

Wenn im FUHRMANN-Korollar-3 das &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''x'''‘ —&lt;/span&gt; z. B. für GOTT, dem ,Vater‘ der Christen, und das &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''y'''‘ —&lt;/span&gt; für GOTT, dem ,Sohn‘, d.h. für ,JESUS CHRISTUS‘ steht, oder — zugleich — für den ,HEILIGEN GEIST‘, &lt;span style=&quot;color:#00B000&quot;&gt;(den ,Dreifaltigen GOTT‘ der Christenheit)&lt;/span&gt;; oder auch zugleich für die Gottesbezeichnung ,GOTT-ADONAI‘ der Juden, oder zugleich für die Gottesbezeichnung ,ALLAH‘ der Muslime steht, dann weist dieses Korollar, für &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''∀y'''‘ —&lt;/span&gt;, mit der ,ontologischen Identität‘ ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''x=y'''‘ —&lt;/span&gt;, auf die ,Koinzidenz‘ des &lt;span style=&quot;color:#4C58FF&quot;&gt;„Dreifaltigen“&lt;/span&gt;, und auf die &lt;span style=&quot;color:#4C58FF&quot;&gt;„Hypostatische Union“&lt;/span&gt; der Naturen von GOTT und Mensch in JESUS CHRISTUS, bzw. auch auf den inneren Zusammenhang der drei Buch-Religionen hin.


===&lt;div class=&quot;center&quot;&gt;&lt;span style=&quot;color:#660066&quot;&gt;Anhang : das GÖDEL-Kalkül&lt;/span&gt;&lt;/div&gt;===

In der ,Legende zum GÖDEL-Kalkül‘ wird an einige Basics erinnert, und diese für die operative Praxis im anstehenden Kalkül, mit Hilfe von logischen Meta-Terme, adaptiert. Zusätzliche, notwendige Regeln und Gesetze werden dann ,benannt‘, wenn sie in der Kalkül-Durchführung auftreten.

{|class=&quot;wikitable&quot;
|-
! &lt;div class=&quot;center&quot;&gt;&lt;span style=&quot;color:#660066&quot;&gt;Legende zum GÖDEL-Kalkül&lt;/span&gt;&lt;/div&gt;
|-
|
&lt;small&gt;
&lt;math&gt;\begin{align}

{\color{blue}\text{ ◇}} \text{ :: konsistent ↔ widerspruchsfrei ↔ möglich ↔ denkbar,  } &amp; {\color{blue}\text{ □}} \text{ :: notwendig ↔ wirklich, für jede mögliche Welt ↔ exklusiv} \\
\text{logischer Meta-Term ::} {\color{blue}\text{ [ A ├ B ]}} \text{ ::} &amp; \text{„aus A folgt im Kalkül ,regulär‘ (├ ) B.“} \\
\text{ A, B sind Aussagen über Eigenschaften, (A ist keine Eigenschaft);} &amp; \text{die Aussage, z.B. in der Kalkül-Zeile 10, wird als ,Term :10:‘ bezeichnet} \\
{\color{blue}\text{ AE}} \text{ ::} &amp; \text{Argument Einführung, Prämisse, Postulat } \\
{\color{blue}\text{ Xx}} \text{ ::} &amp; \text{„X ist eine Eigenschaft der Individuum-Variable x.“ } \\
{\color{blue}\text{ ¬PX}} \text{ ::} &amp; \text{„X ist keine positive Eigenschaft, ist keine Perfektion, ist nicht vollkommen.“ } \\
{\color{blue}\text{ Instanz(X := Y)}} \text{ ::} &amp; \text{Substitution der Eigenschaft X durch die ,bestimmte‘ Eigenschaft Y } \\
\text{ (Eine ,Instanz‘ ist ein Exemplar aus einer Menge gleichartiger Dinge;} &amp; \text{hier die ,bestimmte‘ Eigenschaft Y, als Ersatz für das unbestimmte X.) } \\
{\color{blue}\text{ FUB(x := y)}} \text{ ::} &amp; \text{Freie-Um-Benennung der Individuum-Variable x in y } \\
\text{ ,modal‘-frei gewählte Kalkül-Prämisse ::} {\color{blue}\text{ Gx}} \text{ ::} &amp; \text{„Die Variable x steht für den GOTT der Christen.“ } \\
{\color{blue}\text{ [ G(y) ├ ⱯyG(y) ]}}\text{ ::} &amp; \text{All-Operator-Einführung der Variable y für GOTT } \\
\text{ „Angenommen, die Variable y steht für GOTT, dann} &amp; \text{folgt ,regulär‘ (├ ), dass auch jedes y im Kalkül für GOTT steht.“}\\
{\color{blue}\text{[ ⱯXA(X) ├ A(X) ]}}\text{ ::} &amp; \text{ All-Operator-Beseitigung für die substituierte Eigenschaft X } \\
\text{ „Wenn X durch eine ,bestimmte‘ Eigenschaft ,instanziiert‘ ist oder} &amp; \text{wird, dann kann der All-Operator von X ,regulär‘ (├ ) beseitigt werden.“}\\
{\color{blue}\text{ KOMM(↔)}}\text{ ::} &amp; \;{\color{blue}\text{[ (A ↔ B) ↔ (B ↔ A) ]}} \text{ :: Kommutativgesetz für (↔)}\\
{\color{blue}\text{ DIST(□∧)}}\text{ ::} &amp; \;{\color{blue}\text{[ (□A ∧ □B) ↔ □(A ∧ B) ]}} \text{ :: Distributivgesetz für (□∧)} \\
\text{ (hypothetischer Syllogismus, häufige logische Schlussregel) ::} &amp; \;{\color{blue}\text{[ A → B, A ├ B ]}} \text{ :: (Modus ponendo ponens) :: Abtrennregel.} \\
\text{ „Wenn es wahr ist, dass aus A ein B folgt, und wenn A wahr ist,} &amp; \text{dann ist im Kalkül ,regulär‘ (├ ) ableitbar, dass auch B wahr ist.“} \\
\text{ (negativer hypothetischer Syllogismus) ::} &amp; \;{\color{blue}\text{[ A → B, ¬B ├ ¬A ]}} \text{ :: (Modus tollendo tollens)} \\
\text{ „Wenn es wahr ist, dass aus A ein B folgt, und wenn B falsch ist,} &amp; \text{dann ist im Kalkül ,regulär‘ (├ ) ableitbar, dass auch A falsch ist.“} \\
\text{''KONDITIONALER BEWEIS“ ::} &amp; \;{\color{blue}\text{[ ├ A ├ B ╞ A → B ]}} \text{ :: (logische Implikation)} \\
\text{ „Angenommen, A ist ,regulär‘ Axiom oder Prämisse, und B ist im} &amp; \text{Kalkül ,regulär‘ abgeleitet, dann ist ,bewiesen‘ ( ╞ ) : A impliziert B, ist wahr.“} \\
\text{''INDIREKTER BEWEIS“ ::} &amp; \;{\color{blue}\text{[ ├ ¬A → F ╞ A ]}} \text{ :: (Reductio ad absurdum)} \\
\text{ „Wenn im Kalkül aus ¬A ,regulär‘ eine Kontradiktion F} &amp; \text{folgt, dann ist A ,bewiesen‘ ( ╞ ) : A ist ,wahr‘.“} \\

\end{align}&lt;/math&gt;
&lt;/small&gt;
|}
A. FUHRMANN ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt; ''Eine Prädikatenlogik zweiter Stufe ist eine Logik, in der die Quantoren auch Eigenschaftsausdrücke &lt;span style=&quot;color:#00B000&quot;&gt;(&lt;span style=&quot;color:#FF6000&quot;&gt;„Prädikate”&lt;/span&gt;)&lt;/span&gt; binden können''. &lt;span style=&quot;color:#00B000&quot;&gt;[ Die ,Prädikate‘ werden in einem Kalkül dieser Logik durch Definitionen ,bestimmt‘ ]&lt;/span&gt;. ''Wir werden uns im folgenden recht frei einer dafür geeigneten formalen Sprache bedienen. Äußere Quantoren werden meist weggelassen und wir schreiben kurz'' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Xx'''‘ — &lt;/span&gt; ''bzw.'' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PX'''‘ — &lt;/span&gt; ''um auszudrücken, dass das Individuum'' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''x'''‘ — &lt;/span&gt; ''die Eigenschaft'' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''X'''‘ — &lt;/span&gt; ''hat, bzw. dass die Eigenschaft'' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''X'''‘ — &lt;/span&gt; ''die höherstufige Eigenschaft'' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''P'''‘ — &lt;/span&gt; ''&lt;span style=&quot;color:#00B000&quot;&gt;(für &lt;span style=&quot;color:#FF6000&quot;&gt;„positiv”&lt;/span&gt;)&lt;/span&gt; hat;'' &lt;span style=&quot;color:#00B000&quot;&gt; [ wobei die Eigenschaft &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''P'''‘ — &lt;/span&gt; als einzige im Kalkül ,unbestimmt‘ bleibt ]&lt;/span&gt;. &lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;&lt;ref&gt;A. FUHRMANN ‚''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;‚G‘ wie Gödel. Kurt Gödels axiomatische Theologie&lt;/big&gt;&lt;/span&gt;''‘, Seite 6, Anmerkung 3. Konform mit seinem Artikel in ‚''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;Logik in der Philosophie&lt;/big&gt;&lt;/span&gt;''‘ hg. v. P. SCHROEDER-HEISTER, W. SPOHN und E. OLSSON. 2005, Synchron, Heidelberg.&lt;/ref&gt; 

Der All-Quantor für Eigenschaften, hier im GÖDEL-Kalkül der ,modalen‘ Prädikatenlogik zweiter Stufe, bindet die ,unbestimmte‘ Eigenschafts-Variable &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''X'''‘ —&lt;/span&gt; ausschließlich nur in den Definitionen im 2. und 3. Beweisgang; &lt;span style=&quot;color:#00B000&quot;&gt;(im ersten Beweisgang gibt es keine Definition)&lt;/span&gt;. Wobei diese Definitionen auch nur dann &lt;span style=&quot;color:#FF6000&quot;&gt;„wahr und widerspruchsfrei”&lt;/span&gt; sind, wenn ihre Eigenschafts-Variablen ausschließlich mit ,Transzendentalien‘ belegt werden. Andernfalls sind sie sofort &lt;span style=&quot;color:#FF6000&quot;&gt;„modal falsch”&lt;/span&gt;. Dieser All-Quantor wird dann jedes Mal in der Beweis-Durchführung durch die Substitution ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt; [ Instanz(X:= ..) ]&lt;/span&gt; mit ,bestimmte‘ Eigenschafts-Konstanten wie &lt;span style=&quot;color:#4C58FF&quot;&gt;— (X:= G) —&lt;/span&gt;, bzw. &lt;span style=&quot;color:#4C58FF&quot;&gt;— (X:= ¬Y) —&lt;/span&gt;, oder &lt;span style=&quot;color:#4C58FF&quot;&gt;— (X:= E&lt;sub&gt;not&lt;/sub&gt;) —&lt;/span&gt;  ,regulär‘ &lt;span style=&quot;color:#00B000&quot;&gt;(├ )&lt;/span&gt; beseitigt ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt; [ ⱯXA(X) ├  A(X) ]&lt;/span&gt;; wobei die Eigenschafts-Konstante im Kalkül entweder als Zwischenergebnis ,regulär‘ abgeleitet, &lt;span style=&quot;color:#00B000&quot;&gt;(,errechnet‘)&lt;/span&gt;, oder mit einer Definition schon ,bestimmt‘ worden ist. 

Die spezifische ‚Eigenschaft‘ einer Eigenschaft wird hier, in der formalen Syntax der ,modalen‘ Prädikatenlogik zweiter Stufe, als eine tiefer gestellte Abkürzung &lt;span style=&quot;color:#00B000&quot;&gt;(als Index)&lt;/span&gt; an ihre Trägereigenschaft angehängt, wie z. B. ‚wesentlich‘, bzw. ‚essentiell‘ durch &lt;span style=&quot;color:#4C58FF&quot;&gt; — &lt;sub&gt;ess&lt;/sub&gt; —&lt;/span&gt;, oder ‚notwendig‘ durch &lt;span style=&quot;color:#4C58FF&quot;&gt; — &lt;sub&gt;not&lt;/sub&gt; —&lt;/span&gt;. In der Definition-3 steht der Term ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt; —‚'''E'''&lt;sub&gt;not&lt;/sub&gt;'''x'''‘ —&lt;/span&gt;, um auszudrücken, dass das Individuum &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''x'''‘ —&lt;/span&gt; notwendig &lt;span style=&quot;color:#4C58FF&quot;&gt;— &lt;sub&gt;not&lt;/sub&gt; —&lt;/span&gt; die Eigenschaft ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''E'''‘ —&lt;/span&gt;, für ,Existenz‘, hat, d.h. &lt;span style=&quot;color:#FF6000&quot;&gt;»''das &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''x'''‘&lt;/span&gt; existiert notwendig''«&lt;/span&gt;. Der schon von GÖDEL indizierte Term ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;—‚'''G'''&lt;sub&gt;ess&lt;/sub&gt;'''x'''‘ —&lt;/span&gt; kann gelesen werden als ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Das Individuum &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''x'''‘&lt;/span&gt; hat die Wesenseigenschaft, &lt;span style=&quot;color:#4C58FF&quot;&gt; — &lt;sub&gt;ess&lt;/sub&gt; — &lt;/span&gt; ''':''' GOTT zu sein, &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''G'''‘ &lt;/span&gt;''«&lt;/span&gt;, statt der ,an sich‘ konformen, aber &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologisch“&lt;/span&gt; etwas ungenauen Formulierung ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''das'' &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''x'''‘&lt;/span&gt; ''ist wesentlich göttlich''«&lt;/span&gt;; oder mit der Voraussetzung ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx'''→'''G'''&lt;sub&gt;ess&lt;/sub&gt;'''x'''‘ — &lt;/span&gt; deutlicher und &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologisch“&lt;/span&gt; korrekt ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Wenn'' &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''x'''‘&lt;/span&gt; ''für den GOTT der Christen'', &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''G'''‘&lt;/span&gt;, ''steht, dann ist GOTT-Sein'', &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''G'''‘&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(,Existenz‘)&lt;/span&gt; ''das Wesen dieses GOTTES'', &lt;span style=&quot;color:#4C58FF&quot;&gt;— &lt;sub&gt;ess&lt;/sub&gt;‚'''x'''‘ —&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(,Essenz‘)&lt;/span&gt;«&lt;/span&gt;; wobei, — entsprechend der ,methodologischen‘ Prämisse des Kalküls &lt;span style=&quot;color:#00B000&quot;&gt;(&lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx'''‘ — &lt;/span&gt; ''':''' das &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''x'''‘&lt;/span&gt; steht für den ,GOTT der Christen‘)&lt;/span&gt; —, bei der Interpretation der Terme dieses besonderen Kalküls, die &lt;span style=&quot;color:#4C58FF&quot;&gt;„christliche Theologie”&lt;/span&gt; für den Begriff &lt;span style=&quot;color:#FF6000&quot;&gt;„GOTT”&lt;/span&gt;, Korrektur und die leitende Instanz ist. Dabei muss die Dreifach-Äquivalenz von &lt;span style=&quot;color:#4C58FF&quot;&gt;&lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''G'''‘ — &lt;/span&gt;&lt;/span&gt;berücksichtigt werden. Welche der drei Äquivalenzen, bzw. Lesearten von &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''G'''‘ —&lt;/span&gt; bei einem bestimmten Term im Kalkül zulässig ist, muss &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologisch”&lt;/span&gt; überprüft und evaluiert werden. Bei manchen können sogar alle drei Lesearten &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologisch”&lt;/span&gt; zulässig sein.

Warum es in der modalen Prädikatenlogik zweiter Stufe, im GÖDEL-System, ,Definitionen‘ gibt, erklärt GÖDEL formal-syntaktisch ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Definitionen dienen ja nur der kürzeren Schreibwelse und sind daher prinzipiell überflüssig.''«&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;(Aus der Anmerkung 6 in seinem Hauptwerk ''':''' ,''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;Über formal unentscheidbare Sätze der Principia Mathematica und verwandter Systeme I&lt;/big&gt;&lt;/span&gt;''‘.)&lt;/span&gt; Für die &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologische”&lt;/span&gt; Interpretation und Hermeneutik seines Kalküls, sind die ,Definitionen‘ im GÖDEL-System jedoch wesentlich, und letztlich entscheidend. Erst dadurch wird sein Axiomensystem zur &lt;span style=&quot;color:#4C58FF&quot;&gt;„axiomatischen Theologie”&lt;/span&gt;. GÖDEL gibt selbst den hermeneutischen Hinweis dazu, wenn er über den höherstufigen Eigenschaftsbegriff &lt;span style=&quot;color:#FF6000&quot;&gt;»''positiv''«&lt;/span&gt; sagt, der nur ,indirekt‘ definiert wird, jedoch mit seinem gesamten Axiomensystem ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Positiv bedeutet positiv im moralisch ästhetischen Sinne, (unabhängig von der zufälligen Struktur der Welt). Nur dann sind die Axiome wahr''.«&lt;/span&gt; Die Deutung dieses ,höherstufigen‘ Begriffs als ein anderes Wort für &lt;span style=&quot;color:#FF6000&quot;&gt;„Transzendentalia“&lt;/span&gt; ergibt sich aus der &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologischen”&lt;/span&gt; Evaluierung, d.h. der Einordnung des GÖDEL-Systems in die ,laufende‘ &lt;span style=&quot;color:#FF6000&quot;&gt;„Rede von GOTT“&lt;/span&gt;, seit Menschen, sich über den Sinn der Welt und unseres Lebens in ihr, Gedanken machen. GOTT, der ,transzendent‘, — unabhängig —, zur Welt ist, ist Thema im Theorem ANSELMS, um das es ja im GÖDEL-Kalkül geht. Eine &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologische”&lt;/span&gt; Hermeneutik des GÖDEL-Systems ist daher legitim, die, als ein Bemühen um ein überzeugendes Verstehen, aus dem &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologischen”&lt;/span&gt; Vorwissen vieler Generationen schöpft. Dieses ,Vorwissen‘ ist ,vorgängig‘ zum GÖDEL-System, und hat daher, — ,sachlich‘, und nicht nur ,zeitlich‘, — Priorität zum syntaktischen System GÖDELS; und ist damit legitim auch Interpretations-Vorgabe. &lt;span style=&quot;color:#4C58FF&quot;&gt;„Theologie”&lt;/span&gt;, als Wissenschaft von GOTT, hat hier Interpretations-Vorrang.

Um philosophische, und sogar &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologische”&lt;/span&gt; Theoreme exakt zu formulieren, und untersuchen zu können, hat der Ausnahmelogiker GÖDEL, im 20. Jahrhundert, ein Tor aufgestoßen, das uns ermöglichen kann, &lt;span style=&quot;color:#FF6000&quot;&gt;»''mathematisch evident''«&lt;/span&gt;, und logisch objektiv nachprüfbar, in diesen Disziplinen zu argumentieren. Mit seiner modalen Prädikatenlogik zweiter Stufe, &lt;span style=&quot;color:#00B000&quot;&gt;(mit den Definitionen, speziell ,zugeschnitten‘ auf seinen ,ontologischen‘ Beweis)&lt;/span&gt;, hat GÖDEL dem alten Wunsch eines Raimundus LULLUS, eines Gottfried Wilhelm LEIBNIZ, eines Immanuel KANT, und anderer, nach einer nachprüfbaren ,Universalsprache‘ in den Geisteswissenschaften, entsprochen; analog zur Mathematik, als Universalsprache in den Naturwissenschaften. Der sog. ,Theorembeweiser‘ der Wissenschaftler Christoph BENZMÜLLER und Bruno WOLTZENLOGEL-PALEO, mit Hilfe eines Computers, im 21. Jahrhundert, ist die kongeniale und logische Folge aus diesem Quanten-Schritt GÖDELS.

In der folgenden Neu-Kalkülisierung, wird jeder einzelne operative Logik-Schritt des Kalküls in der '''linken Spalte''' nummeriert und als Term-Ergebnis angezeigt, und in der '''rechten Spalte''' werden die dafür benötigten Term-Komponenten und die dabei angewendeten Logik-Regeln und -Gesetze, mit Meta-Terme, dokumentiert. Am Anfang stehen die Ressourcen und das angestrebte Ziel des Beweisganges, &lt;span style=&quot;color:#00B000&quot;&gt;(das Theorem)&lt;/span&gt;. Die GÖDEL Axiome und Definitionen, die Theoreme und Korollare, die Zwischenergebnisse, das Endergebnis, und die logischen Meta-Terme, &lt;span style=&quot;color:#00B000&quot;&gt;[ in eckigen Klammern ]&lt;/span&gt;, werden kontextabhängig, &lt;span style=&quot;color:#00B000&quot;&gt;(durch ''„Benennungen“'')&lt;/span&gt;, interpretiert, &lt;span style=&quot;color:#00B000&quot;&gt;(angezeigt durch ,Interpretationspunkte‘ — '''::''' —, falls nötig)&lt;/span&gt;. Der jeweilige Beweisgang wird in den Anmerkungen ausführlich und umfassend kommentiert. Die Kalkül-Prämissen, &lt;span style=&quot;color:#00B000&quot;&gt;(&lt;span style=&quot;color:#4C58FF&quot;&gt;'''AE:'''&lt;/span&gt; Argument Einführung)&lt;/span&gt;, sind der modal-frei gewählte Einstieg in das Kalkül. Sie dokumentieren, zusammen mit dem angestrebten Beweis-Ziel, eine bestimmte Problemlage in einem externen Diskurs, der mit dem modalen Logik-System hier, formal-syntaktisch überprüft, und gegebenenfalls, verifiziert oder falsifiziert werden soll. Korollare sind einfache, logische Folgerungen aus dem jeweiligen Beweisgang. Theoreme und Korollare sind ,modal‘ gleichwertig.


====&lt;div class=&quot;center&quot;&gt;&lt;span style=&quot;color:#660066&quot;&gt;1. Beweisgang&lt;/span&gt;&lt;/div&gt;====
{|class=&quot;wikitable&quot;
|-
! &lt;div class=&quot;center&quot;&gt;&lt;span style=&quot;color:#660066&quot;&gt;GÖDELS ontologischer Beweis für Theorem 1, (Möglichkeitsbeweis)&lt;/span&gt;&lt;/div&gt;
|-
! &lt;span style=&quot;color:#00B000&quot;&gt;''Terme der erweiterten Prädikatenlogik zweiter Stufe__________ „Benennungen“ und durchgeführte Logik-Operationen''&lt;/span&gt;
|-
|
&lt;small&gt;
&lt;math&gt;\begin{align}

\text{(Axiom 1.1)} &amp; \quad P \neg X \;\Longrightarrow\;\ \neg P\ X\ &amp; \ &amp; \text{„Wenn die Negation von X positiv ist, dann ist die Eigenschaft X nicht positiv“} \\
\text{(Axiom 2)} &amp; \quad (P\ X \wedge \;\Box \;\forall x (\ X\ x \Longrightarrow \ Y\ x)) \Longrightarrow \ P\ Y &amp; \ &amp; \text{„Die Eigenschaften Y, die aus einer positiven Eigenschaft X modal} \\
\text{ } &amp; \quad &amp; \ &amp; \; \; \text{notwendig folgen, sind auch positive Eigenschaften“} \\
\text{(Axiom 3)} &amp; \quad  P\ G \ &amp; \ &amp; \text{„Göttlichkeit, GOTT-Sein, ist eine pos. Eigenschaft“ ↔ „GOTT ist perfekt“} \\
\text{[RK]} &amp;\quad \Box\; \forall x A \;\Longrightarrow\;\Box\; \forall x B\; \text{ ├ }\;\Box \; \forall x (A \Longrightarrow\; B)\ &amp; \ &amp; \; \text{( :: Modales Prinzip KRIPKE-Γ-Ɐx)} \\
\text{(Theorem 1)} &amp;\quad  P\ X \;\Longrightarrow\; \Diamond \; \exists x \ X \ x \ &amp; \ &amp; \text{ (◇  :: „möglich“ ↔ „konsistent“ ↔ „denkbar“;  □ :: „notwendig“) } \\ 
\text{ } &amp; \text{„Positive Eigenschaften sind konsistent“} &amp; \ &amp; \Longleftarrow\; \text{was zu beweisen ist !} \\
\text{01} &amp; \quad  P\ X \ &amp; \ &amp; \text{ AE: „Angenommen, es gibt positive Eigenschaften, Perfektionen“} \\ 
\text{02} &amp; \quad  P\ X \;\Rightarrow\; \neg \Diamond \; \exists x \ X \ x \ &amp; \ &amp; \text{ AE: „Angenommen, positive Eigenschaften sind nicht konsistent“} \\
\text{03} &amp; \quad (\neg x = .. )\ &amp; \ &amp; \text{ AE: „Es gibt die Eigenschaft, nicht mit x identisch zu sein“ :: (ungleich)} \\
\text{04} &amp; \quad (\ x = .. )\ &amp; \ &amp; \text{ AE: „Es gibt die Eigenschaft, mit x identisch zu sein“ :: (gleich)} \\
\text{05} &amp; \quad  \text{ ├ }\; \neg \Diamond \; \exists x \ X \ x \ &amp; \ &amp; \text{:01:02:[Modus ponendo ponens] :: [A, A→B├ B] :AE:} \\
\text{06} &amp; \quad  \neg\neg \Box \neg \exists x \ X \ x \ &amp; \ &amp; \text{:05:[ ◇A ↔ ¬□¬A] :: (Modalregel)} \\
\text{07} &amp; \quad \neg\neg \Box \neg\neg \forall x \neg X \ x \ &amp; \ &amp; \text{:06:[∃xA ↔ ¬Ɐx¬A] :: (Quantoren Regel)} \\
\text{08} &amp; \quad  \text{ ├ }\;  \Box \; \forall x \neg X \ x \ &amp; \ &amp; \text{:07:NEG :: [¬¬A↔A] :: (Gesetz der Aussagenlogik)} \\
\text{09} &amp; \quad \Box \; \forall x \neg X \ x \Leftrightarrow\ W &amp; \ &amp; \text{:02:08:[(:02:↔W) → (├:08:↔W)] :: (Kalkülregel)} \\
\text{10} &amp; \quad \Box \; \forall x \ X \ x \Leftrightarrow\ F &amp; \ &amp; \text{:09:[(¬A↔W)↔(A↔F)] :: (Regel für Wahrheitswerte)} \\
\text{11} &amp; \quad \Box \; \forall x (\neg x = x ) \Leftrightarrow \ F \; \ &amp; \text{ } &amp; \text{□ⱯxXx:03:Instanz(X:=(¬x=..)) ⇒ Kontradiktion !} \\
\text{12} &amp; \quad \Box \; \forall x (\ X \ x \Rightarrow\; (\neg x = x)) &amp; \text{ } &amp; \text{:10:11:[(:10:↔F) → (:11:↔F)] :: „ex falso sequitur quotlibet“ :[RK]} \\

\text{13} &amp; \quad \ P\ X \wedge \;\Box \; \forall x (\ X \ x \Rightarrow\; (\neg x = x)) &amp; \ &amp; \text{:01:12:[Konjunktion] :: [A, B ├ A∧B]} \\
\text{14} &amp; \quad \ (P\ X \wedge \;\Box \; \forall x (\ X \ x \Rightarrow \; (\neg x = x)))  \Rightarrow \; P (\neg x = .. ) &amp; \ &amp; \text{(A2):Instanz(Y:=( ¬x= ..)) :: (Substitution für Eigenschaften)} \\
\text{15} &amp; \quad \ P (\neg x = .. ) &amp; \ &amp; \text{:13:14:[Modus ponens] :: (logische Schlussregel)} \\
\text{16} &amp; \quad \ P (\neg x = .. )\;\Rightarrow\ \neg P (\ x = .. )\ &amp; \ &amp; \text{(A1.1):Instanz(X:=(x=..))}\\
\text{17} &amp; \quad \neg P (\ x = .. )\ &amp; \ &amp; \text{:15:16:[Modus ponens]}\\
\text{18} &amp; \quad \Box \; \forall x \ (x = x ) \Leftrightarrow \ W \; \ &amp; \ &amp; \text{□ⱯxXx:04:Instanz(X:=(x=..)) ⇒ Tautologie !} \\
\text{19} &amp; \quad \Box \; \forall x (\ X \ x \Rightarrow\; (x = x)) &amp; \text{ } &amp; \text{:10:18:[(:10:↔F) → (:18:↔W)] :: „ex falso sequitur etiam verum“ :[RK]} \\
\text{20} &amp; \quad \ P\ X \wedge \;\Box \; \forall x (\ X \ x \Rightarrow\; (x = x)) &amp; \ &amp; \text{:01:19:[Konjunktion] } \\
\text{21} &amp; \quad \ (P\ X \wedge \;\Box \; \forall x (\ X \ x \Rightarrow\;  (x = x)))  \Rightarrow \ P (x = .. ) &amp; \ &amp; \text{(A2):Instanz(Y:=(x=..))} \\
\text{22} &amp; \quad \ P (\ x = .. )\ &amp; \ &amp; \text{:20:21:[Modus ponens]}\\
\text{23} &amp; \quad  \text{ ├ }\; (\neg P (\ x = .. )\ \wedge \ P (\ x = .. )) \Leftrightarrow\ F &amp; \ &amp; \text{:17:22:[Konjunktion] ⇒ Kontradiktion !}\\
\text{24} &amp; \quad \neg \Diamond \; \exists x \ X \ x \Rightarrow (\neg P (\ x = .. )\ \wedge \ P (\ x = .. )) &amp; \ &amp; \text{:05:23:[├A├B╞ A→B] :: ''KONDITIONALER BEWEIS''}\\
\text{25} &amp; \quad \neg\neg \Diamond \; \exists x \ X \ x &amp; \ &amp; \text{:24:23:[Modus tollendo tollens] :: [A→B,¬B ├ ¬A]}\\
\text{26} &amp; \quad \text{ ├ }\; \Diamond \; \exists x \ X \ x &amp; \ &amp; \text{:25:NEG; bzw. :05:23:[├¬A→F ╞ A] :: ''INDIREKTER BEWEIS''}\\
\text{27} &amp; \quad  \ P\ X \;\Longrightarrow\; \Diamond \; \exists x \ X \ x \ &amp; \ &amp; \text{:01:26:[├A├B ╞ A→B]} \\
\text{(Theorem 1)} &amp; \;\text{„Positive Eigenschaften sind konsistent“} &amp; \ &amp; \Longleftarrow\; \text{was zu beweisen war !} \\
\text{28} &amp; \quad \ P\ G \;\Longrightarrow\; \Diamond \; \exists x \ G \ x \ &amp; \ &amp; \text{:27:Instanz(X:=G) } \\
\text{29} &amp; \quad \Diamond \; \exists x \ G \ x \ &amp; \ &amp; \text{(A3):28:[Modus ponens]} \\
\text{(Korollar 1)} &amp; \;\text{„Das Dasein GOTTES ist definitiv denkbar“} &amp; \ &amp; \text{„Es ist widerspruchsfrei möglich, dass es GOTT gibt“} \\

\end{align}&lt;/math&gt;
&lt;/small&gt;
|}

Anmerkung-1 ''':''' &lt;span style=&quot;color:#00B000&quot;&gt;(Der GÖDEL-Term &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PX'''‘ —&lt;/span&gt;, im Axiom-2 ist an sich überflüssig, da dieser hier als Prämisse :01: ohnehin ,angenommen‘ wird. Der Beweisgang kommt mit Axiom-2 auch ohne diesen GÖDEL-Term zum selben Ergebnis, und verkürzt sich damit sogar um zwei Schritte ''':''' Zeile 13 und Zeile 20 sind dann unnötig.)&lt;/span&gt; 

Der Beweisgang geht mit Axiom-3 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PG'''‘ —&lt;/span&gt;, als Kalkül-Ressource, prinzipiell von der Existenz eines GOTTES aus. Mit der Prämisse :01: &lt;span style=&quot;color:#00B000&quot;&gt;(hier im 1. Beweisgang)&lt;/span&gt; postuliert GÖDEL vorerst allgemein, dass es &lt;span style=&quot;color:#FF6000&quot;&gt;»''Vollkommenheit, d.h. positive Eigenschaften''«&lt;/span&gt; in unserer Welt gibt ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PX'''‘ —&lt;/span&gt;, ohne hier zu definieren, was darunter zu verstehen ist. Definiert wird &lt;span style=&quot;color:#00B000&quot;&gt;(im 2. Beweisgang)&lt;/span&gt;, was eine &lt;span style=&quot;color:#FF6000&quot;&gt;»''wesentliche Eigenschaft''«&lt;/span&gt; ist ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''X'''&lt;sub&gt;ess&lt;/sub&gt;‘ —&lt;/span&gt;,  &lt;span style=&quot;color:#00B000&quot;&gt;(die &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologisch“&lt;/span&gt; als ,Transzendentalia‘ evaluiert wird)&lt;/span&gt;; und mit Hilfe dieser Eigenschaft definiert GÖDEL &lt;span style=&quot;color:#00B000&quot;&gt;(im 3. Beweisgang)&lt;/span&gt;, was eine &lt;span style=&quot;color:#FF6000&quot;&gt;»''notwendige Existenz''«&lt;/span&gt; ist ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''E'''&lt;sub&gt;not&lt;/sub&gt;‘ —&lt;/span&gt;, die er &lt;span style=&quot;color:#00B000&quot;&gt;(im selben Beweisgang)&lt;/span&gt; axiomatisch mit den &lt;span style=&quot;color:#FF6000&quot;&gt;»''positiven Eigenschaften in GOTT''«&lt;/span&gt; gleich setzt ''':''' Axiom-5 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt; —‚'''PE'''&lt;sub&gt;not&lt;/sub&gt;‘ —&lt;/span&gt;. Erst im 2. Beweisgang wird mit Term :13:, nach einer &lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;,Reductio ad absurdum‘&lt;/big&gt;&lt;/span&gt;, definitiv bewiesen &lt;span style=&quot;color:#00B000&quot;&gt;( ╞ )&lt;/span&gt;, dass die, von GÖDEL, hier postulierten, &lt;span style=&quot;color:#00B000&quot;&gt;(allgemeinen)&lt;/span&gt;, positiven Eigenschaften, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PX'''‘ —&lt;/span&gt;, tatsächlich auch in GOTT &lt;span style=&quot;color:#FF6000&quot;&gt;»''positive Eigenschaften''«&lt;/span&gt;, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PG'''‘ —&lt;/span&gt;, sind; &lt;span style=&quot;color:#00B000&quot;&gt;(das sind die ultimativen ,Transzendentalia‘ in GOTT)&lt;/span&gt;. Jetzt aber muss vorerst der ,Wunsch‘, bzw. die LEIBNIZ-Frage beantwortet werden ''':''' Ob, mit &lt;span style=&quot;color:#FF6000&quot;&gt;»''mathematischer Evidenz''«&lt;/span&gt;, &lt;span style=&quot;color:#FF6000&quot;&gt;»''GOTT''«&lt;/span&gt; ,möglich‘ ist, der, nach traditioneller Auffassung, &lt;span style=&quot;color:#FF6000&quot;&gt;»''ein Wesen von äußerster Größe und Vollkommenheit'' &lt;span style=&quot;color:#00B000&quot;&gt;[ ist ]&lt;/span&gt;, ''das alle Grade derselben in sich schließt''«&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(nach LEIBNIZ; was GÖDEL mit Definition-1 ,abbildet‘)&lt;/span&gt;. Wenn man also beweisen will, dass die Existenz eines solchen ''&lt;span style=&quot;color:#FF6000&quot;&gt;»GOTTES«&lt;/span&gt;'' ,möglich‘ sein soll, dann muss man beweisen, dass dieses postulierte System der &lt;span style=&quot;color:#FF6000&quot;&gt;»''positiven Eigenschaften in GOTT''«&lt;/span&gt; möglich und formal ,widerspruchsfrei‘ ist. Das Ergebnis des 1. Beweisganges, das ,Theorem-1‘, &lt;span style=&quot;color:#00B000&quot;&gt;(,Erster Satz‘)&lt;/span&gt;, fasst A. FUHRMANN zusammen als ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Positive Eigenschaften sind konsistent''«&lt;/span&gt;. Wenn sie nicht konsistent wären, käme es zu unlösbaren Widersprüchen, &lt;span style=&quot;color:#00B000&quot;&gt;(Term :24:)&lt;/span&gt;. Term :27: ,besagt‘ ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Es ist definitiv, d.h. ohne Widerspruch möglich, dass es positive Eigenschaften gibt''«&lt;/span&gt;; denn die Behauptung, &lt;span style=&quot;color:#00B000&quot;&gt;(Prämisse :02:)&lt;/span&gt;, es sei nicht möglich, dass es positive Eigenschaften, &lt;span style=&quot;color:#00B000&quot;&gt;(,Transzendentalia‘)&lt;/span&gt;, in unserer Welt gibt, führt zu einem Widerspruch, &lt;span style=&quot;color:#00B000&quot;&gt;(Term :24:)&lt;/span&gt;, und ist daher falsch und ,unlogisch’. Einmal Axiom-1 und zweimal Axiom-2, &lt;span style=&quot;color:#00B000&quot;&gt;(das die Gleichwertigkeit aller positiven Eigenschaften nachdrücklich klarstellt)&lt;/span&gt;, sichern hier die Konsistenz &lt;span style=&quot;color:#FF6000&quot;&gt;»''aller positiven Eigenschaften in der Welt'', &lt;span style=&quot;color:#00B000&quot;&gt;[ die ,Transzendentalien‘ ]&lt;/span&gt;, ''und damit auch die, die in GOTT sind''«&lt;/span&gt;. &lt;span style=&quot;color:#00B000&quot;&gt;(Der 2. Beweisgang bestätigt, dass es in GOTT tatsächlich positive Eigenschaften gibt.)&lt;/span&gt; Die ,Gleichwertigkeit‘ aller Transzendentalia, &lt;span style=&quot;color:#00B000&quot;&gt;(ihre ,Äquivalenz‘)&lt;/span&gt;, ist formal-syntaktisch daran erkennbar, dass die beiden Eigenschafts-Variablen &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''X'''‘ —&lt;/span&gt; und &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Y'''‘ —&lt;/span&gt; im Axiom-2 für beliebige, unterschiedliche ,positive‘ Eigenschaften gegenseitig austauschbar, &lt;span style=&quot;color:#00B000&quot;&gt;(,konvertierbar‘)&lt;/span&gt;, sind. Das heißt, dass beliebige, unterschiedliche ,positive‘ Eigenschaften, für die diese Variablen stehen, sich paarweise, wechselseitig ,implizieren‘, einschließen, und damit notwendig voneinander abhängen, d.h. koinzident ,eins‘ sind, konvertierbar, und somit gleichwertig sind; entsprechend dem Theorem von den Transzendentalia. Zu Term :29:, dem Korollar zu Theorem-1, notiert GÖDEL am 10. Feb. 1970, &lt;span style=&quot;color:#00B000&quot;&gt;(übersetzt von Joachim BROMAND)&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''◇∃xG(x) besagt, dass das System aller positiver Eigenschaften kompatibel ist'',&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;[ d.h. miteinander verträglich, weil ohne Widersprüche ].&lt;/span&gt; &lt;span style=&quot;color:#FF6000&quot;&gt;''Dies ist ,wahr‘ auf Grund von Axiom-2,'' &lt;span style=&quot;color:#00B000&quot;&gt;[ weil alle positiven Eigenschaften, d.h. die Transzendentalien, koinzident gleichwertig und konvertierbar sind ]&lt;/span&gt;.«&lt;/span&gt; Darum ist es definitiv ,möglich‘, dass es diesen GOTT gibt, der &lt;span style=&quot;color:#FF6000&quot;&gt;»''alle Grade der Vollkommenheit in sich schließt''«&lt;/span&gt; und &lt;span style=&quot;color:#FF6000&quot;&gt;»''über dem ,Größeres‘ nicht mehr gedacht werden kann''«&lt;/span&gt;, und, in weiterer Konsequenz, ist der GOTT-Glaube deshalb ,notwendig‘ widerspruchsfrei und sinnvoll, nach Theorem-3 ''':''' &lt;u&gt;Wenn&lt;/u&gt; es ,ohne Widerspruch‘ ''&lt;span style=&quot;color:#FF6000&quot;&gt;»möglich, bzw. denkbar«&lt;/span&gt;'' ist, dass es ''&lt;span style=&quot;color:#FF6000&quot;&gt;»GOTT«&lt;/span&gt;'' gibt, &lt;u&gt;dann&lt;/u&gt; folgt daraus ''&lt;span style=&quot;color:#FF6000&quot;&gt;»notwendig«&lt;/span&gt;'' ''':''' es ist auch ,widerspruchsfrei‘, wenn man als Voraussetzung ,annimmt‘, dass es ''&lt;span style=&quot;color:#FF6000&quot;&gt;»GOTT wirklich, für jede mögliche Welt«&lt;/span&gt;'' gibt ''':'''  Term :11: im 3. Beweisgang. Der Wenn-Satz ist hier mit Korollar-1 bewiesen; der Dann-Satz wird im 3. Beweisgang bewiesen &lt;span style=&quot;color:#00B000&quot;&gt;( ╞ )&lt;/span&gt;, d.i. die Widerspruchsfreiheit und Sinnhaftigkeit des GOTT-Glaubens.

Die ontologische ,Identität‘, d.h. die ,Gleichsetzung‘, bzw. die ,Koinzidenz‘ von Strukturen, die in der Endlichkeit für uns verschieden sind, jedoch in dem unbegrenzt Unendlichen, GOTT, paarweise, perspektivisch in eins zusammenfallen, wie ,Sein‘ und ,Wesen‘, wie ,Ursache‘ und ,Wirkung‘ usw., und auch die Äquivalenz und Austauschbarkeit der Transzendentalien, haben im GÖDEL-Kalkül die logisch-syntaktische Form einer, aus sich, ,modal‘ notwendigen Implikation zwischen zwei verschiedenen, gegenseitig austauschbaren Eigenschafts-Variablen ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□∀x(Xx→Yx)'''‘ —&lt;/span&gt;. Dieses Term-Element stellt formal-syntaktisch die Gleichwertigkeit, &lt;span style=&quot;color:#00B000&quot;&gt;(Äquivalenz)&lt;/span&gt;, bzw. die paarweise Koinzidenz aller positiven Eigenschaften und Zuordnungen in GOTT dar; sowohl hier im Axiom-2, als auch in der Definition-2 über die ,Wesenseigenschaften‘, im 2. Beweisgang, mit jeweils verschiedenen, frei umbenennbaren, Individuum-Variablen. Dieses Term-Element ,gilt‘, mit Notwendigkeit, allgemein, in allen Seienden ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□∀x'''‘ —&lt;/span&gt;, jedoch nur für ihre ,positiven Eigenschaften‘, alias ,Transzendentalia‘, und wird sofort &lt;span style=&quot;color:#FF6000&quot;&gt;„modal falsch“&lt;/span&gt;, wenn für &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''X'''‘ —&lt;/span&gt;, oder &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Y'''‘ —&lt;/span&gt;, Eigenschaften eingesetzt werden, die, — von Natur aus —, weder positiv noch negativ sind, wie z. B. ,rot‘ oder ,schwer‘. Die wechselseitige Austauschbarkeit der noch ,unbestimmten‘ Eigenschafts-Variablen, für beliebige positive Eigenschaften, ist formal äquivalent zur freien Umbenennung der noch ,unbestimmten‘ Individuum-Variablen ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;[ FUB(x:=y) ]&lt;/span&gt;. Der formale, gegenseitige, allgemeine Austausch der positiven Eigenschafts-Variablen, bzw. die formale Gleichsetzung beliebiger positiver Eigenschaften, kann, auf Grund der Äquivalenz aller Vollkommenheiten, bzw. ,Transzendentalia‘, auch dann noch durchgeführt werden, wenn eine, von zwei Eigenschafts-Variablen, durch eine Definition oder eine Schlussfolgerung ,bestimmt‘ worden ist, und dadurch zu einer positiven Eigenschafts-Konstante, d.h. zu einer ,bestimmten‘, positiven Eigenschaft geworden ist. Das ist z. B. bei einer instanziierenden Substitution der Fall ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;[ Instanz(X:=..) ]&lt;/span&gt;. Das ist eine spezifische Eigenheit der GÖDEL-Axiomatik, weil alle relevanten, positiven Eigenschaften und Zuordnungen in GOTT, als &lt;span style=&quot;color:#FF6000&quot;&gt;„ultimative Transzendentalia“&lt;/span&gt;, ,bestimmt‘ oder ,unbestimmt‘, immer auch miteinander kompatibel sind. Mit dem Term-Element ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□∀x(Xx→Yx)'''‘ —&lt;/span&gt;, wird formal die &lt;span style=&quot;color:#FF6000&quot;&gt;„Koinzidenz“&lt;/span&gt; aller ,Transzententalia‘ in der Welt, und auch der ,Zusammenfall‘ aller Gegensätze in GOTT, abgebildet.

Da die Variable &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''x'''‘&lt;/span&gt; für GOTT steht, &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''G'''‘&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(im Korollar-1)&lt;/span&gt;, ist die Eigenschaft ''':''' ''&lt;span style=&quot;color:#FF6000&quot;&gt;„nicht mit x identisch zu sein“&lt;/span&gt;'' ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;(¬x=..)&lt;/span&gt;, d.h. das &lt;span style=&quot;color:#FF6000&quot;&gt;„Ungleichsein“&lt;/span&gt;, das &lt;span style=&quot;color:#FF6000&quot;&gt;„Anderssein“&lt;/span&gt; GOTTES, &lt;span style=&quot;color:#00B000&quot;&gt;(Prämisse :03:)&lt;/span&gt;, die entscheidende Voraussetzung und Norm für jeden Diskurs über GOTT ''':''' um der &lt;span style=&quot;color:#FF6000&quot;&gt;„Unvergleichlichkeit“&lt;/span&gt; 
GOTTES gerecht zu werden, darf GOTT niemals mit etwas aus der ''&lt;span style=&quot;color:#FF6000&quot;&gt;»zufälligen Struktur der Welt«&lt;/span&gt;'' verglichen, d.h. gleich gesetzt werden. Der Term :18: &lt;span style=&quot;color:#4C58FF&quot;&gt;(x=x) ↔ W&lt;/span&gt; erinnert an die Selbstbezeichnung des GOTTES-JHWH in Exodus 3,14 ''':''' &lt;span style=&quot;color:#CC66FF&quot;&gt;»''Ich bin der ‚Ich-Bin‘''«&lt;/span&gt;. &lt;span style=&quot;color:#00B000&quot;&gt;(In der mystischen Tradition, in der ''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;‚Legenda Maior‘&lt;/big&gt;&lt;/span&gt;'' 92, über das Leben der Heiligen KATHARINA von Siena, Mystikerin und Lehrerin der Kirche, sagt GOTT-VATER zur KATHARINA ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Weißt du, Meine Tochter, wer du bist und wer Ich bin'' '''?''' ''Du bist die, die nicht ist'', &lt;span style=&quot;color:#00B000&quot;&gt;[ aus dir selbst ]&lt;/span&gt;, ''Ich aber bin derjenige, der IST'', &lt;span style=&quot;color:#00B000&quot;&gt;[ aus mir selbst ]&lt;/span&gt;.«&lt;/span&gt; Das ist eine wichtige, deutende Ergänzung, und die authentische &lt;span style=&quot;color:#4C58FF&quot;&gt;,theologische‘&lt;/span&gt; Interpretation dieser Exodus Text-Stelle. Das ist der Grund für die &lt;span style=&quot;color:#FF6000&quot;&gt;„Unvergleichbarkeit“&lt;/span&gt; GOTTES.)&lt;/span&gt;

Zum Term :03: notiert A. FUHRMANN ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt; ''Die Notation'' &lt;span style=&quot;color:#4C58FF&quot;&gt;(¬x=..)&lt;/span&gt; ''für die Eigenschaft ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;„nicht mit x identisch zu sein“&lt;/span&gt;'', &lt;span style=&quot;color:#00B000&quot;&gt;[ d.h. &lt;span style=&quot;color:#FF6000&quot;&gt;„Ungleichheit“, „Anderssein“&lt;/span&gt;, bzw. die Notation &lt;span style=&quot;color:#4C58FF&quot;&gt;(x=..)&lt;/span&gt; für den Existenzmodus-Perfektion ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;„Gleichheit“, „Idendität“&lt;/span&gt; ]&lt;/span&gt;, ''ist suggestiv und informell und ersetzt hier einen formal korrekten Abstraktionsausdruck wie'' &lt;span style=&quot;color:#4C58FF&quot;&gt;λy.(¬x=y)&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;[ bzw. &lt;span style=&quot;color:#4C58FF&quot;&gt;λy.(x=y)&lt;/span&gt; ]&lt;/span&gt;. ''Für die formal korrektere Notation bedarf es der zusätzlichen Vereinbarung, dass der Ausdruck'' &lt;span style=&quot;color:#4C58FF&quot;&gt;λy.(¬x=y)&lt;/span&gt; ''gleichbedeutend sei mit dem Ausdruck'' &lt;span style=&quot;color:#4C58FF&quot;&gt;¬λy.(x=y)&lt;/span&gt;.  ''Diese Vereinbarung ist harmlos, da wir aufgrund der Regel der λ–Konversion'' ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;λy.Xy.x ↔ Xx&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;[ mit der &lt;span style=&quot;color:#4C58FF&quot;&gt;Instanz(X:=(¬x=..))&lt;/span&gt; ]&lt;/span&gt;, ''so schließen dürfen'' ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;λy.(¬x=y).x ↔ ¬x=x ↔ &lt;span style=&quot;color:#00B000&quot;&gt;¬(x=x)&lt;/span&gt; ↔ ¬λy.(x=y).x&lt;/span&gt; .&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt; &lt;ref&gt;A. FUHRMANN a.a.O. Seite 7, Anmerkung 4 (von mir korrigiert und ergänzt)&lt;/ref&gt;

In der Kalkül-Zeile 29 wird das Möglichkeits-Korollar-1 durch einen &lt;span style=&quot;color:#4C58FF&quot;&gt;[ Modus ponens ]&lt;/span&gt; mit Axiom-3 von der Kalkül-Prämisse-Term :01: ,abgekoppelt‘, d.h. es ist nicht mehr vom Term :01: &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PX'''‘ —&lt;/span&gt; logisch abhängig. Das Möglichkeits-Korollar-1 behält jedoch die bewiesene Widerspruchsfreiheit von Theorem-1, und ist damit nur mehr von Axiom-1 und Axiom-2 abhängig, was für das Theorem-ANSELMS am Schluss entscheidend ist. Erklärung zu Term :05: Das Ergebnis einer Logik-Operation zwischen Prämissen ist ,regulär‘ &lt;span style=&quot;color:#00B000&quot;&gt;(├ )&lt;/span&gt; den Prämissen zuzurechnen.

Das Modale-Prinzip KRIPKE-Γ-Ɐx, &lt;span style=&quot;color:#4C58FF&quot;&gt;['''RK''']&lt;/span&gt;, in Worten ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Wenn mit ,modaler‘ Notwendigkeit'' &lt;span style=&quot;color:#00B000&quot;&gt;( □ )&lt;/span&gt;, ''für alle'' &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''x'''‘&lt;/span&gt; ''die Aussage'' &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''A'''‘&lt;/span&gt; ''gilt, und daraus logisch folgt, dass mit ,modaler‘ Notwendigkeit'' &lt;span style=&quot;color:#00B000&quot;&gt;( □ )&lt;/span&gt;, ''für alle'' &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''x'''‘&lt;/span&gt; ''auch die Aussage'' &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''B'''‘&lt;/span&gt; ''gilt, dann ist in einem Kalkül regulär'' &lt;span style=&quot;color:#00B000&quot;&gt;( ├ )&lt;/span&gt; ''ableitbar'' ''':''' ''es ist wahr, dass mit ,modaler‘ Notwendigkeit'' &lt;span style=&quot;color:#00B000&quot;&gt;( □ )&lt;/span&gt;, ''für alle'' &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''x'''‘&lt;/span&gt; ''aus der Aussage'' &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''A'''‘&lt;/span&gt; ''die Aussage'' &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''B'''‘&lt;/span&gt; ''logisch folgt''«&lt;/span&gt;. Der Term &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□∀xXx'''‘ —&lt;/span&gt; in der rechten Spalte der Zeile 11 und der Zeile 18, &lt;span style=&quot;color:#00B000&quot;&gt;(gleichlautend mit Term :10:)&lt;/span&gt;, steht formal-syndaktisch, allgemein nur für ,Transzendentalia‘, und ist für alle ,Nicht-Transzendentalia‘ &lt;span style=&quot;color:#FF6000&quot;&gt;„modal falsch“&lt;/span&gt;. Dasselbe gilt auch für das Prinzip &lt;span style=&quot;color:#4C58FF&quot;&gt;['''RK''']&lt;/span&gt;.


====&lt;div class=&quot;center&quot;&gt;&lt;span style=&quot;color:#660066&quot;&gt;2. Beweisgang&lt;/span&gt;&lt;/div&gt;====

{|class=&quot;wikitable&quot;
|-
! &lt;div class=&quot;center&quot;&gt;&lt;span style=&quot;color:#660066&quot;&gt;GÖDELS ontologischer Beweis für Theorem 2, (,Basisbeweis‘)&lt;/span&gt;&lt;/div&gt;
|-
! &lt;span style=&quot;color:#00B000&quot;&gt;''Terme der erweiterten Prädikatenlogik zweiter Stufe____________„Benennungen“ und durchgeführte Logik-Operationen''&lt;/span&gt;
|-
|
&lt;small&gt;
&lt;math&gt;\begin{align}

\text{(Axiom 1.2)} &amp; \quad \neg P\ X \;\Longrightarrow\;\ P\neg X\ &amp; \ &amp; \text{„Wenn X nicht positiv ist, dann ist die Negation ¬X positiv“} \\
\text{(Axiom 3)} &amp; \quad \ P\ G \ &amp; \ &amp; \text{„Göttlichkeit, GOTT-Sein, ist eine pos. Eigenschaft“ ↔ „GOTT ist perfekt“} \\
\text{(Axiom 4)} &amp; \quad \ P\ X \;\Longrightarrow\; \Box \ P\ X \ &amp; \ &amp; \text{„Positive Eigenschaften sind notwendig aus sich positiv“} \\
\text{(Definition 1)} &amp;\quad \ G\ x \;\Longleftrightarrow\; \forall X(\ P \ X \Longrightarrow \ X \ x)\ &amp; \ &amp; \text{„x ist genau dann GOTT, wenn x alle positiven Eigenschaften hat“} \\ 
\text{(Definition 2)} &amp; \quad \ X_{ess}\ x \;\Leftrightarrow X\ x \wedge \forall Y \left(\ Y\ x \Rightarrow \Box \; \forall y (\ X\ y \Rightarrow \ Y\ y)\right) &amp; \ &amp; \text{„X ist genau dann eine wesentliche Eigenschaft von x, wenn x sie hat, und} \\
\text{ } &amp; \quad &amp; \text { } &amp; \;\;\text{alle anderen Eigenschaften Y von x notwendig aus dieser Eigenschaft X folgen“} \\
\text{[RM]} &amp;\quad \ A \;\Longrightarrow\;\ B\; \text{ ├ }\;\Box \; A \Longrightarrow\;\Box\; \ B\ &amp; \ &amp; \text{( :: Modales Prinzip)} \\ 
\text{(Theorem 2)} &amp;\quad \ G\ x \;\Longleftrightarrow\; \ G_{ess}\ x \  &amp; \ &amp; \text{(,G‘ :: „Göttlichkeit“ ↔ „GOTT“ ↔ „Dasein GOTTES“)} \\ 
\text{ } &amp;\;\text{„Das Wesen GOTTES ist sein Dasein“} &amp; \ &amp; \Longleftarrow\; \text{was zu beweisen ist !} \\
\text{01} &amp;\quad  \ G\ x \  &amp; \ &amp; \text{ AE: „Angenommen, x steht für den GOTT der Christen“} \\ 
\text{02} &amp;\quad  \ Y\ x \  &amp; \ &amp; \text{ AE: „Angenommen, GOTT hat die Eigenschaften Y“} \\ 
\text{03} &amp;\quad \neg P\ Y &amp; \ &amp; \text{ AE: „Angenommen, die Y in GOTT sind nicht positiv“} \\
\text{04} &amp;\quad \neg P \ Y \Rightarrow \ P \neg Y\ &amp; \ &amp;\text{(A1.2):Instanz(X:=Y) :: (Substitution für Eigenschaften) } \\
\text{05} &amp;\quad \ P \neg  Y \  &amp; \ &amp; \text {:03:04:[Modus ponens] :: [A, A→B ├ B] } \\ 
\text{06} &amp;\quad \forall X(\ P \ X \Rightarrow \ X \ x)\ &amp; \ &amp;\text{(D1):01:[Modus ponens] :: (logische Schlussregel)} \\
\text{07} &amp;\quad  \ P \ X \Rightarrow \ X \ x\ &amp; \ &amp;\text{:06:[ⱯXA(X) ├ A(X)] :: (Quantorenregel)} \\
\text{08} &amp;\quad  \ P \neg  Y \Rightarrow \neg Y \ x\ &amp; \ &amp;\text{:07:Instanz(X:=¬Y)} \\
\text{09} &amp;\quad  \neg Y \ x\  &amp; \ &amp;\text{:05:08:[Modus ponens]} \\
\text{10} &amp;\quad  \text{ ├ }\; (Y\ x \wedge \neg Y \ x) \;\Leftrightarrow\;\ F\ &amp; \ &amp; \text{:02:09:[Konjunktion] ⇒ Kontradiktion !} \\
\text{11} &amp;\quad \neg P\ Y \; \Rightarrow \; (Y\ x \wedge \neg Y \ x )\ &amp; \ &amp;\text{:03:10:[├A├B ╞ A→B] :: ''KONDITIONALER BEWEIS''} \\
\text{12} &amp;\quad  \neg\neg P\  Y \  &amp; \ &amp;\text{:11:10:[Modus tollendo tollens] :: [A→B,¬B ├ ¬A]} \\
\text{13} &amp;\quad  \text{ ├ }\; P\ Y \  &amp; \ &amp;\text{:12:NEG; bzw. :03:10:[├¬A→F ╞ A] :: ''INDIREKTER BEWEIS'' :AE:} \\
\text{14} &amp;\quad  \ P\ Y \;\Rightarrow\;\Box \ P\ Y \ &amp; \ &amp; \text{(A4):Instanz(X:=Y)} \\
\text{15} &amp;\quad  \Box \ P\ Y \ &amp; \ &amp; \text{:13:14:[Modus ponens]} \\
\text{16} &amp;\quad  \ G \ y \Rightarrow \ Y \ y\  &amp; \ &amp;\text{:01:02:[├A├B ╞ A→B]:FUB(x:=y)} \\
\text{17} &amp;\quad  \text{ ├ }\; \forall y(\ G \ y \Rightarrow \ Y \ y)\  &amp; \ &amp;\text{:16:[G(y) ├ ⱯyG(y)]} \\
\text{18} &amp;\quad  \Box \ P\ Y \;\Rightarrow\; \Box \; \forall y(\ G \ y \Rightarrow \ Y \ y)\  &amp; \ &amp;\text{:13:17:[├A├B ╞ A→B]:[RM]} \\
\text{19} &amp;\quad  \text{ ├ }\; \Box \; \forall y(\ G \ y \Rightarrow \ Y \ y)\  &amp; \ &amp;\text{:15:18:[Modus ponens]} \\
\text{20} &amp;\quad  \ Y\ x \;\Rightarrow\; \Box \; \forall y(\ G \ y \Rightarrow \ Y \ y)\  &amp; \ &amp;\text{:02:19:[├A├B ╞ A→B]} \\
\text{21} &amp;\quad  \ (Y\ x \;\Rightarrow\; \Box \; \forall y(\ G \ y \Rightarrow \ Y \ y)) \wedge \ G \ x &amp; \ &amp;\text{:20:01:[Konjunktion] :: [A,B ├ A∧B]} \\
\text{22} &amp;\quad  \ (Y\ x \;\Rightarrow\; \Box \; \forall y(\ X \ y \Rightarrow \ Y \ y)) \wedge \ X \ x\;\Leftrightarrow\; X_{ess}\ x \ &amp; \ &amp;\text{(D2):KOMM(↔):KOMM(∧):[ⱯYA(Y) ├ A(Y)] wegen :13:} \\
\text{23} &amp;\quad  \ (Y\ x \;\Rightarrow\; \Box \; \forall y(\ G \ y \Rightarrow \ Y \ y)) \wedge \ G \ x\;\Leftrightarrow\; G_{ess}\ x \ &amp; \ &amp;\text{:22:Instanz(X:=G)} \\
\text{24} &amp; \quad  \text{ ├ }\; G_{ess}\ x \ &amp; \ &amp;\text{:21:23:[Modus ponens]:AE: wegen :30:} \\
\text{25} &amp;\quad  \ G\ x \;\Rightarrow\; \ G_{ess}\ x \  &amp; \ &amp; \text{:01:24:[├A├B ╞ A→B] :: Theorem 2.1} \\
\text{26} &amp;\quad  \forall X(\ P \ X \Rightarrow \ X \ x)\ &amp; \ &amp;\text{(D1):01:[Modus ponens] } \\
\text{27} &amp;\quad  \ P \ X \Rightarrow \ X \ x\ &amp; \ &amp;\text{:26:[ⱯXA(X) ├ A(X)]} \\
\text{28} &amp;\quad  \ P \ G \Rightarrow \ G \ x\ &amp; \ &amp;\text{:27:Instanz(X:=G)} \\
\text{29} &amp;\quad  \text{ ├ }\;  G \ x\  &amp; \ &amp;\text{(A3):28:[Modus ponens]} \\
\text{30} &amp;\quad  \ G_{ess}\ x \;\Rightarrow \ G \ x\  &amp; \ &amp;\text{:24:29:[├A├B ╞ A→B] :: Theorem 2.2 } \\
\text{31} &amp;\quad  \ G\ x \;\Longleftrightarrow\; \ G_{ess}\ x \  &amp; \ &amp; \text{:25:30:[Konjunktion]:BIKONDITIONAL :: [(A→B) ∧ (B→A) ↔ (A↔B)] } \\
\text{(Theorem 2)} &amp;\; \text{„Dasein ist das Wesen GOTTES“} &amp; \ &amp; \Longleftarrow\; \text{was zu beweisen war ! } \\
\text{32} &amp;\quad  \text{ ├ }\; \Box \; \forall y(\ G \ y \Rightarrow \ (x = y))\  &amp; \ &amp; \text{:19:Instanz(Y:=(x=..))} \\
\text{33} &amp;\quad \ G\ x \;\Rightarrow\; \Box \; \forall y(\ G \ y \Rightarrow \ (x = y))\  &amp; \ &amp; \text{:01:32:[├A├B ╞ A→B]} \\
\text{(Korollar 2)} &amp; \;\text{„Es gibt notwendig höchstens einen GOTT“} &amp; \ &amp; \text{„Wenn es GOTT gibt, dann gibt es für jede mögliche Welt nur einen GOTT“} \\

\end{align}&lt;/math&gt;
&lt;/small&gt;
|}

&lt;span style=&quot;color:#00B000&quot;&gt;&lt;small&gt;(In den Kalkül-Zeilen 16, 18, 31 mussten zwei-, und in Zeile 22 drei Kalkül-Schritte, d.h. Logik-Operationen in eine Zeile zusammengezogen werden, weil der Parser dieser speziellen Mathematik-Funktion in Wikibooks jedes Mal wegen Puffer-Überlauf abstürzt, wenn zu den bestehenden Zeilen noch eine neue Zeile, oder ein Text-Element, zusätzlich eingefügt wird. Das vermindert etwas die Transparenz des Kalküls.)&lt;/small&gt;&lt;/span&gt;

Anmerkung-2 ''':''' &lt;span style=&quot;color:#00B000&quot;&gt;(Dieser Beweisgang kommt auch ohne das ,unbestimmte‘ Konjunkt &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''Xx'''‘ —&lt;/span&gt; in der Definition-2 zum gleichen Ergebnis, und wird dadurch um eine Zeile verkürzt ''':''' Zeile 21 entfällt, und &lt;span style=&quot;color:#4C58FF&quot;&gt;[ KOMM(∧) ]&lt;/span&gt; ist dann unnötig. Dieses Konjunkt wird hier ebenfalls schon in der Kalkül-Prämisse :01: &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''Gx'''‘ —&lt;/span&gt;, als ,Annahme‘ gesetzt, vorentschieden und ,bestimmt‘ mit der &lt;span style=&quot;color:#4C58FF&quot;&gt;[ Instanz(X:=G) ]&lt;/span&gt;. Es war also logisch korrekt, dass GÖDEL, in seiner Notiz vom 10. Feb. 1970 zum ontologischen Beweis, dieses Konjunkt weggelassen hat, was ihm von Kommentatoren als ein Flüchtigkeitsfehler angerechnet worden war. Der gesamte 2. Beweisgang bewegt sich im Geltungsbereich der Prämisse Term :01:, d.h. ist in jeder Zeile von der Annahme abhängig ''':''' die Variable &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''x'''‘ —&lt;/span&gt; steht für den GOTT der Christen. In der Kalkül-Zeile 33 wird, mit Korollar-2, diese Abhängigkeit, für den Term :32:, explizit dargestellt.)&lt;/span&gt; 

Der Beweisgang geht mit der Prämisse :01: prinzipiell, als ,modal‘ freigewählte Voraussetzung, von der Existenz eines GOTTES aus. Im 1. Beweisgang wurde bewiesen, dass die von GÖDEL ,postulierten‘ &lt;span style=&quot;color:#FF6000&quot;&gt;»''allgemeinen positiven Eigenschaften, Vollkommenheiten, Perfektionen'', &lt;span style=&quot;color:#00B000&quot;&gt;[ die sog. ,Transzendentalien‘ ]&lt;/span&gt; ''konsistent''«&lt;/span&gt;, d.i. widerspruchsfrei sind. Hier, in diesem Beweisgang wird nun die Prämisse vom 1. Beweisgang, &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''PX'''‘ —&lt;/span&gt;, im Bezug auf GOTT hinterfragt ''':''' Gibt es in GOTT auch so Etwas, wie &lt;span style=&quot;color:#FF6000&quot;&gt;»''Vollkommenheit, Positives, Perfektes''«&lt;/span&gt; '''?'''  Die ,Annahme‘ jedoch, dass es &lt;span style=&quot;color:#FF6000&quot;&gt;»''in GOTT keine Vollkommenheit, nichts Positives, nichts Perfektes''«&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;(keine Transzendentalien)&lt;/span&gt; gibt, &lt;span style=&quot;color:#00B000&quot;&gt;(Prämisse Term :03:)&lt;/span&gt;,&lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''¬PY'''‘ —&lt;/span&gt;, d.h. dass die &lt;span style=&quot;color:#00B000&quot;&gt;(wesentlichen)&lt;/span&gt; Eigenschaften in GOTT keine &lt;span style=&quot;color:#FF6000&quot;&gt;„Vollkommenheiten“&lt;/span&gt; seien, führt aber zu einem unlösbaren Widerspruch, &lt;span style=&quot;color:#00B000&quot;&gt;(Term :10:)&lt;/span&gt;.  Mit Term :13:, als 1. Hauptergebnis, ist damit, — als ,neue‘ Prämisse, &lt;span style=&quot;color:#00B000&quot;&gt;(ersetzt Term :03:)&lt;/span&gt; —, definitiv ,bewiesen‘ &lt;span style=&quot;color:#00B000&quot;&gt;( ╞ , d.h. es ist ,wahr‘ und ,widerspruchsfrei‘)&lt;/span&gt;, dass alle Eigenschaften, die hier mit &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Y'''‘ —&lt;/span&gt; symbolisiert werden, &lt;span style=&quot;color:#FF6000&quot;&gt;„positive Eigenschaften“&lt;/span&gt;, d.h. &lt;span style=&quot;color:#FF6000&quot;&gt;„Perfektionen“&lt;/span&gt; sind, von denen das Kalkül ,annimmt‘, &lt;span style=&quot;color:#00B000&quot;&gt;(Prämissen Term :01:, Term :02: und speziell Term :16:)&lt;/span&gt;, dass der GOTT der Christen sie besitzt. Alle ,Wesenseigenschaften‘ in GOTT ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Y'''&lt;sub&gt;ess&lt;/sub&gt;‘ —&lt;/span&gt;, die durch den Term :13:, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PY'''‘ —, &lt;/span&gt; dargestellt werden, sind somit &lt;span style=&quot;color:#FF6000&quot;&gt;„Vollkommenheiten“&lt;/span&gt; ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''P'''‘ —&lt;/span&gt;&lt;span style=&quot;color:#00B000&quot;&gt;, (,ultimative Transzendentalien‘, aller ,Grade‘)&lt;/span&gt;. Damit ist definitiv ‚bestätigt‘, &lt;span style=&quot;color:#00B000&quot;&gt;( ╞ , es ist ,wahr‘ und ,widerspruchsfrei‘)&lt;/span&gt;,  was mit Axiom-3 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PG'''‘ —&lt;/span&gt;, schon ‚angenommen‘ worden ist ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''GOTT ist perfekt; er hat alle positiven Eigenschaften''«&lt;/span&gt;; und auch Definition-1 ist damit ,verifiziert‘ ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''GOTT ist genau deswegen GOTT, weil er, als GOTT, positive Eigenschaften aller Grade in sich schließt''«&lt;/span&gt;; entsprechend dem Quelltext bei LEIBNIZ ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''GOTT ist ein Wesen von äußerster Größe und Vollkommenheit, das alle Grade derselben in sich schließt''«&lt;/span&gt;. Immer vorausgesetzt, &lt;span style=&quot;color:#00B000&quot;&gt;(,angenommen‘)&lt;/span&gt;, man glaubt an GOTT ''':''' &lt;span style=&quot;color:#00B000&quot;&gt;(Term :01:)&lt;/span&gt;. &lt;span style=&quot;color:#00B000&quot;&gt;(Der ,Schlüsselbegriff‘ &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''P'''‘ —&lt;/span&gt; ist der ,Schlüssel‘ zur Erkenntnis, dass GOTT ,notwendig‘,  sowohl ,wesentlich‘ für uns, als auch an sich ,grundlos‘, immer schon ,da‘ ist.)&lt;/span&gt; Hier, &lt;span style=&quot;color:#00B000&quot;&gt;(im 2. Beweisgang)&lt;/span&gt;, hat Axiom-1, &lt;span style=&quot;color:#00B000&quot;&gt;(im Term :04:)&lt;/span&gt;, sicher gestellt,  dass die Eigenschaften in GOTT, &lt;span style=&quot;color:#00B000&quot;&gt;(Definition-1; Term :06:)&lt;/span&gt;, tatsächlich &lt;span style=&quot;color:#FF6000&quot;&gt;„ultimativ positiv, perfekt und vollkommen“&lt;/span&gt; sind ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PY'''‘ —&lt;/span&gt;. Das GÖDEL-Axiom-1 bezieht seine ,Potenz‘ aus dem Prinzip vom ,auszuschließenden‘ Widerspruch ''':''' eine Eigenschaft kann nicht zugleich ,positiv‘ und ,nicht positiv‘ sein '''!''' 

Formal lässt sich das 2. Hauptergebnis, Theorem-2 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx'''↔'''G'''&lt;sub&gt;ess&lt;/sub&gt;'''x'''‘ — &lt;/span&gt; ''':''' schon aus Term :23: in diesem Beweisgang mit der &lt;span style=&quot;color:#4C58FF&quot;&gt;[ Vereinfachung ] :: [ A∧B ├ B ]&lt;/span&gt; ohne Weiteres ,regulär‘ erschließen, — analog zu den Vorgehensweisen bei A. FUHRMANN und G.J. WIRSCHING. &lt;span style=&quot;color:#00B000&quot;&gt;(Beide Aussagen dieser ,Konjunktion‘ sind ,gleichwertig‘ und wahr, daher partizipiert das Theorem-2 auch am Ergebnis der Widerspruchsfreiheit von Term :13:, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PY'''‘ —&lt;/span&gt;, dem 1. Hauptergebnis. Beide, mit ,und‘, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''∧'''‘ —&lt;/span&gt;, verbundene, Aussagen im Term :23: interpretieren sich gegenseitig.)&lt;/span&gt; Der hier gewählte, etwas längere Weg zum Ergebnis, soll die innere Struktur und Abhängigkeit der Ergebnisse von bestimmten Voraussetzungen offen legen, und ihren ,Zweck‘ verdeutlichen. Die beiden Hauptergebnisse im Basisbeweis gehen vom vorgefundenen  und traditionell vorgegebenen Begriff von ,GOTT‘ aus, &lt;span style=&quot;color:#00B000&quot;&gt;(Term :06:, Term :16: und Term :26:)&lt;/span&gt;. Das ,bewiesene‘ &lt;span style=&quot;color:#00B000&quot;&gt;( ╞ )&lt;/span&gt; 1. Hauptergebnis, hier im 2. Beweisgang, Term :13: &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PY'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''alle Eigenschaften in GOTT sind vollkommen, d.h. sind die ultimativen Transzendentalia''«&lt;/span&gt;, rechtfertigt, bzw. verifiziert sowohl Axiom-3 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PG'''‘ —&lt;/span&gt;, als auch die Definition-1 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx↔∀X(PX→Xx)'''‘ —&lt;/span&gt;, für die Annahme ''':''' den ,GOTT der Christen‘, der deswegen GOTT ist, weil er alle Grade der Vollkommenheit in sich schließt. Und das ebenfalls ,bewiesene‘ &lt;span style=&quot;color:#00B000&quot;&gt;( ╞ )&lt;/span&gt; 2. Hauptergebnis, hier im selben Beweisgang, Theorem-2 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx'''↔'''G'''&lt;sub&gt;ess&lt;/sub&gt;'''x'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''das Wesen GOTTES ist sein eigenes Sein''«&lt;/span&gt;, rechtfertigt, bzw. verifiziert sowohl Axiom-5 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''PE'''&lt;sub&gt;not&lt;/sub&gt;‘ —&lt;/span&gt;, als auch die Definition-3 ''':'''  &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''E'''&lt;sub&gt;not&lt;/sub&gt;'''x ↔ ∀X(X'''&lt;sub&gt;ess&lt;/sub&gt;'''x →□∃yXy)'''‘ —&lt;/span&gt;, für die Wesenseigenschaft ''':''' ,notwendige Existenz‘, und widerlegt den Einwand KANTS, für den Spezialfall ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''x'''‘ —&lt;/span&gt; steht für den ,GOTT‘ der Christen. Zwei Axiome und zwei Definitionen von GOTT und seinen Vollkommenheiten werden durch die Ergebnisse im Basisbeweis des GÖDEL-Kalküls in unserer realen Welt als ,wahr‘, &lt;span style=&quot;color:#00B000&quot;&gt;(genauer als ,widerspruchsfrei‘)&lt;/span&gt;, und, — im Rahmen des christlichen Glaubens —, als ,annehmbar‘ bestätigt. &lt;span style=&quot;color:#00B000&quot;&gt;(Anmerkung zu Term :24: ''':''' eine Prämisse ist regulär-,modal‘ immer ,frei‘ wählbar.)&lt;/span&gt;

Zusammengefasst heißt das ''':''' die ,strittige‘ Begründung der ,methodologischen‘ Prämisse des GÖDEL-Kalküls ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#00B000&quot;&gt;(Prämisse, Term :01:)&lt;/span&gt;, weil &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''◇∃xGx'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#00B000&quot;&gt;(Korollar-1)&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Das &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''x'''‘&lt;/span&gt; steht für den GOTT der Christen, für den es ohne Widerspruch denkbar ist, dass es ihn gibt''«&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(ANSELMS Prinzip, trotz der ,Warnung‘ KANTS)&lt;/span&gt;, ist ,wahr‘ und für uns ,annehmbar, denn es ist auch, auf Grund der Ergebnisse des 2. Beweisganges, in unserer realen Welt ,wahr‘ und ,annehmbar‘, weil schon als ,widerspruchsfrei‘ verifiziert ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Der GOTT der Christen'' &lt;span style=&quot;color:#00B000&quot;&gt;(Term :01:)&lt;/span&gt; '',existiert‘ für uns ,notwendig‘''«&lt;/span&gt; ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;   — ‚'''Gx→E'''&lt;sub&gt;not&lt;/sub&gt;'''x'''‘ —&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(d.i. das ,regulär‘-mögliche Korollar sowohl im 2. als auch im 3. Beweisgang)&lt;/span&gt;, denn dieser GOTT ist aus sich ,vollkommen‘ ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''PG'''‘ —&lt;/span&gt;, und zu seiner ,Vollkommenheit‘ &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''P'''‘ —&lt;/span&gt; gehört auch notwendig sein ,Existieren‘ ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''PE'''&lt;sub&gt;not&lt;/sub&gt;‘ —&lt;/span&gt;. &lt;span style=&quot;color:#00B000&quot;&gt;(Jeder dieser Terme ist im-, und durch den 2. Beweisgang, im Geltungsbereich der Prämisse Term :01:, als ,wahr‘ und ,annehmbar‘ bewiesen, bzw. verifiziert.)&lt;/span&gt; Das ist der ,Kern‘ des ontologischen Arguments, und somit ist auch diese ,strittige‘ Begründung der Prämisse des GÖDEL-Kalküls mit den Maßstäben der modernen Logik &lt;span style=&quot;color:#FF6000&quot;&gt;»''durchaus vereinbar''«&lt;/span&gt;, d.h. sie ist logisch ,richtig‘ und, im Kontext des christlichen Glaubens, vernünftig. Die Annahme des Gegenteils zu dieser Prämisse ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''¬◇∃xGx'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Es ist undenkbar, dass es diesen GOTT gibt''«&lt;/span&gt;, führt jedoch, unabhängig von jeder Glaubensüberzeugung, zu einem Widerspruch — ist unlogisch und daher ,falsch‘, &lt;span style=&quot;color:#00B000&quot;&gt;(siehe Anhang  ''':''' Widerlegung)&lt;/span&gt;. Die Behauptung einer ,formalen Unentscheidbarkeit‘ zu den Annahmen über die Existenz GOTTES, ob oder nicht, &lt;span style=&quot;color:#00B000&quot;&gt;(d.h. ein ,methodologischer‘ Agnostizismus)&lt;/span&gt;, ist gegen jede ,Logik‘; und ist auch ,falsch‘, d.h. der Agnostizismus ist einfach nur ein ,logischer Irrtum‘. Denn aus dem, im Kalkül abgeleiteten, Widerspruch aus der einen Annahme, und damit ihrer Unrichtigkeit, folgt notwendig die Richtigkeit der gegenteiligen Annahme. Damit ist eine klare Entscheidung getroffen.

Das Modale-Prinzip &lt;span style=&quot;color:#4C58FF&quot;&gt;['''RM''']&lt;/span&gt; in Worten ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Wenn es wahr ist, dass aus'' &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''A'''‘ —&lt;/span&gt; ''ein'' &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''B'''‘ —&lt;/span&gt; ''logisch folgt, dann ist in einem Kalkül regulär'' &lt;span style=&quot;color:#00B000&quot;&gt;( ├ )&lt;/span&gt; ''ableitbar, dass, wenn'' &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''A'''‘ —&lt;/span&gt; '',modal‘ notwendig'' &lt;span style=&quot;color:#00B000&quot;&gt;( □ )&lt;/span&gt; ''ist, auch'' &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''B'''‘ —&lt;/span&gt; '',modal‘ notwendig'' &lt;span style=&quot;color:#00B000&quot;&gt;( □ )&lt;/span&gt; ''ist''«&lt;/span&gt;. &lt;span style=&quot;color:#00B000&quot;&gt;(Das &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''A'''‘ —&lt;/span&gt; in Term :18: ist als ,modal notwendig‘ durch den Term :15: verifiziert '''!''' )&lt;/span&gt;

Mit dem 2. Hauptergebnis, Theorem-2 ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»'',Dasein‘ ist das ,Wesen‘ GOTTES''«&lt;/span&gt;, folgt die GÖDEL-Axiomatik der philosophisch-&lt;span style=&quot;color:#4C58FF&quot;&gt;,theologischen‘&lt;/span&gt; Tradition der ,Rede von GOTT‘ seit ARISTOTELES, und schließt sich damit formal-syntaktisch zugleich auch der religiösen Überzeugung der Christen an, die glauben, dass GOTT, als unser Vater, aus Liebe, in seinem Sohn, JESUS CHRISTUS, für uns immer schon &lt;span style=&quot;color:#FF6000&quot;&gt;»''da''«&lt;/span&gt; ist, &lt;span style=&quot;color:#00B000&quot;&gt;(der Sohn ist koinzident ,eins‘ mit GOTT, dem Vater und dem GEIST)&lt;/span&gt;, wirksam in und durch seine &lt;span style=&quot;color:#4C58F0&quot;&gt;„Kirche“&lt;/span&gt;, im HEILIGEN GEIST, bis ans Ende der Zeit. Das ist das, &lt;span style=&quot;color:#FF6000&quot;&gt;»''was''«&lt;/span&gt; GOTT eigentlich für uns ausmacht, — die Selbstmitteilung seines unergründlichen Wesens in den Sakramenten der &lt;span style=&quot;color:#4C58F0&quot;&gt;„Kirche“&lt;/span&gt; ''':''' &lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;‘אֶֽהְיֶ֖ה אֲשֶׁ֣ר אֶֽהְיֶ֑ה‚&lt;/big&gt;&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;| ‚eh'jeh asher eh'jeh‘ |&lt;/span&gt; &lt;span style=&quot;color:#CC66FF&quot;&gt;»''Ich bin da für euch und für immer, als der ich ''&lt;span style=&quot;color:#00B000&quot;&gt;[ immer schon gewesen ]&lt;/span&gt; ''bin''«&lt;/span&gt;; &lt;span style=&quot;color:#00B000&quot;&gt;(d.i. das &lt;span style=&quot;color:#4C58FF&quot;&gt;,theologisch‘&lt;/span&gt;-exegetische ,Axiom‘ der Christen, und eine &lt;span style=&quot;color:#4C58FF&quot;&gt;,theologisch‘&lt;/span&gt; korrekte Explikation der ,regulären‘ Kalkül-Prämisse Term :01: &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''Gx'''‘ —&lt;/span&gt;, jeweils im 2. und 3. Beweisgang)&lt;/span&gt;. Das heißt aber nicht, dass der Autor des Kalküls sich mit diesem Glauben identifiziert hat, &lt;span style=&quot;color:#00B000&quot;&gt;(,hat‘ er auch nicht)&lt;/span&gt;, oder dass der Leser des ontologischen Beweises von Kurt GÖDEL sich damit identifizieren muss, wenn er dessen &lt;span style=&quot;color:#FF6000&quot;&gt;»''mathematische Evidenz''«&lt;/span&gt; anerkennt. 

Zur erweiterten &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologischen“&lt;/span&gt; Explikation der Kalkül-Prämisse ''':''' Die  &lt;span style=&quot;color:#4C58F0&quot;&gt;„Kirche“&lt;/span&gt; ist das ,Meisterwerk‘ GOTTES ''':''' In ihr ist es GOTT gelungen, etwas Göttliches und Unzerstörbares in unsere korrupte Welt einzupflanzen ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''Gx→E'''&lt;sub&gt;not&lt;/sub&gt;'''x'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Etwas Göttliches existiert notwendig, d.h. ,unzerstörbar‘ in unserer Welt''«&lt;/span&gt;. Sie ist, durch die Menschwerdung des GOTTES Sohnes, JESUS CHRISTUS, dessen &lt;span style=&quot;color:#4C58F0&quot;&gt;„Leib“&lt;/span&gt; die &lt;span style=&quot;color:#4C58F0&quot;&gt;„Kirche“&lt;/span&gt; ist, untrennbar mit Menschen verbunden, die schon, von allem Anfang an, und jetzt immer noch, durch die Sünde korrumpiert sind. Mit ihr will und wird GOTT unsere Welt und die Menschheit, bis ans Ende der Zeit, von der Sünde und von deren Konsequenz, dem &lt;span style=&quot;color:#00B000&quot;&gt;(ewigen)&lt;/span&gt; Tod &lt;span style=&quot;color:#4C58FF&quot;&gt;„erlösen“&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(jedoch nicht ohne die Zustimmung des Menschen)&lt;/span&gt;. Mit dieser Explikation wird die Tragweite des ontologischen Arguments ANSELMS, und damit auch die &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologische“&lt;/span&gt; Relevanz der GÖDEL-Axiomatik erkennbar. Immer vorausgesetzt, &lt;span style=&quot;color:#00B000&quot;&gt;(,angenommen‘)&lt;/span&gt;, man glaubt an GOTT, &lt;span style=&quot;color:#00B000&quot;&gt;(Term :01:)&lt;/span&gt;.


====&lt;div class=&quot;center&quot;&gt;&lt;span style=&quot;color:#660066&quot;&gt;3. Beweisgang&lt;/span&gt;&lt;/div&gt;====

{|class=&quot;wikitable&quot;
|-
! &lt;div class=&quot;center&quot;&gt;&lt;span style=&quot;color:#660066&quot;&gt;GÖDELS ontologischer Beweis für Theorem 3, (ANSELMS Theorem)&lt;/span&gt;&lt;/div&gt;
|-
! &lt;span style=&quot;color:#00B000&quot;&gt;''Terme der erweiterten Prädikatenlogik zweiter Stufe___________________„Benennungen“ und durchgeführte Logik-Operationen''&lt;/span&gt;
|-
|
&lt;small&gt;
&lt;math&gt;\begin{align}

\text{(Axiom 5)} &amp; \quad  P\ E_{not}\; \ &amp; \text { } &amp; \text{„Notwendige Existenz ist eine positive Eigenschaft“} \\
\text{ } &amp; \text{( :: Das ist nur dann wahr, wenn ,Dasein‘ und ,Wesen‘ } &amp; \ &amp; \text{( :: dagegen KANT : ,Existenz‘ ist keine ,Eigenschaft‘,} \\
\text{ } &amp; \;\;\text{in eins zusammenfallen ! ARISTOTELES : Theorem-2)}\ &amp; \ &amp; \;\;\text{,Sein‘ ist für alles, was existiert, kein ,reales Prädikat‘ ! )} \\
\text{(Definition 1)} &amp;\quad \ G\ x \;\Longleftrightarrow\; \forall X(\ P \ X \Longrightarrow \ X \ x)\  &amp; \ &amp; \text{„x ist genau dann GOTT, wenn x alle positiven Eigenschaften hat“} \\ 
\text{(Definition 3)} &amp; \quad \ E_{not}\ x \;\Longleftrightarrow\;\ \forall X \left(\ X_{ess}\ x \Longrightarrow \Box \; \exists y \ X\ y \right) &amp; \ &amp; \text{„Notwendige Existenz  ist genau dann eine Eigenschaft von x, wenn} \\
\text{ } &amp; \quad &amp; \ &amp; \;\;\text{alle wesentl. Eigenschaften von x notwendig instanziiert sind“} \\
\text{(Korollar 1)} &amp; \quad \Diamond \; \exists x \ G \ x \ &amp; \ &amp; \text{„Es ist widespruchsfrei möglich, dass es GOTT gibt“} \\
\text{(Theorem 2)} &amp;\quad \ G\ x \;\Longleftrightarrow\; \ G_{ess}\ x \  &amp; \ &amp;\text{„Dasein, GOTT-Sein, Existenz ist das Wesen, die Essenz GOTTES“} \\
\text{(Korollar 2)} &amp;\quad \ G\ x \;\Longrightarrow\; \Box \; \forall y(\ G \ y \Longrightarrow \ (x = y))\  &amp; \ &amp;\text{„Wenn es GOTT gibt, dann gibt es notwendig nur einen GOTT“} \\
\text{(Theorem 3)} &amp; \quad \Diamond \; \exists x \ G \ x \;\Longrightarrow\; \Box \; \exists x \ G \ x \ &amp; \ &amp; \text{( :: ANSELMS Prinzip)} \\
\text{ } &amp; \text{„Weil es widerspruchsfrei möglich ist, dass es GOTT gibt,} &amp; \ &amp; \Longleftarrow\; \text{was zu beweisen ist !} \\
\text{ } &amp; \;\;\text{ist der Glaube, dass es GOTT wirklich gibt, widerspruchsfrei“} \\
\text{01} &amp; \quad  \ G \ x\  &amp; \ &amp; \text{ AE: „Angenommen, x steht für den GOTT der Christen“} \\
\text{02} &amp; \quad   \forall X(\ P \ X \Rightarrow \ X \ x)\  &amp; \ &amp; \text{(D1):01:[Modus ponens] :: (logische Schlussregel)} \\
\text{03} &amp; \quad  \ P \ X \Rightarrow \ X \ x\  &amp; \ &amp; \text{:02:[ⱯXA(X) ├ A(X)] :: (Quantorenregel)} \\
\text{04} &amp; \quad  \ P \ E_{not}\;\Rightarrow \ E_{not}\ x\  &amp; \ &amp; \text{:03:Instanz(X:= Enot) :: (Substitution für Eigenschaften)} \\
\text{05} &amp; \quad  \ E_{not}\ x\  &amp; \ &amp; \text{(A5):04:[Modus ponens] :: [A, A→B ├ B]} \\
\text{06} &amp; \quad  \forall X \left(\ X_{ess}\ x \Rightarrow \Box \; \exists y \ X\ y \right) &amp; \ &amp; \text{(D3):05:[Modus ponens] :: [A→B, A ├ B]} \\
\text{07} &amp; \quad \ X_{ess}\ x \Rightarrow \Box \; \exists y \ X\ y  &amp; \ &amp; \text{:06:[ⱯXA(X) ├ A(X)]} \\
\text{08} &amp; \quad \ G_{ess}\ x \Rightarrow \Box \; \exists y \ G\ y  &amp; \ &amp; \text{:07:Instanz(X:=G)} \\
\text{09} &amp; \quad  \ G_{ess}\ x \ &amp; \ &amp; \text{(Th2):01:[Modus ponens]} \\
\text{10} &amp; \quad  \text{ ├ }\;\Box \; \exists x \ G\ x  &amp; \ &amp; \text{:08:09:[Modus ponens]:FUB(y:=x) :: (Freie-Um-Benennung der Var.)} \\
\text{ } &amp; \text{„Es gibt GOTT wirklich, für jede mögliche Welt“} &amp; \ &amp; \Longleftarrow\; \text{1. Hauptergebnis !} \\
\text{11} &amp; \quad  \;\Diamond \exists x \ G \ x \;\Longrightarrow \; \Box \; \exists x \ G\ x  &amp; \ &amp; \text{(K1):10:[├A├B ╞ A→B] :: ''KONDITIONALER BEWEIS''} \\
\text{(Theorem 3)} &amp; \;\text{„Weil es widerspruchsfrei möglich ist, dass es GOTT gibt,} &amp; \ &amp; \Longleftarrow\; \text{was zu beweisen war ! 2. Hauptergebnis ! } \\
\text{ } &amp; \;\;\text{ist der Glaube, dass es GOTT wirklich gibt, widerspruchsfrei“} \\
\text{12} &amp; \quad  \;\Box \; \forall y(\ G \ y \Longrightarrow \ (x = y))\  &amp; \ &amp;\text{(K2):01:[Modus ponens]} \\
\text{13} &amp; \quad \;\Box \; (\exists x \ G\ x \wedge  \; \forall y(\ G \ y \Longrightarrow \ (x = y)))\  &amp; \ &amp; \text{:10:12:[Konjunktion]:DIST(□∧)} \\ 
\text{(Korollar 3)} &amp; \;\text{„Es gibt notwendig genau nur einen GOTT“} &amp; \ &amp; \text{„Es gibt für jede mögliche Welt nur den GOTT der Christen“} \\

\end{align}&lt;/math&gt;
&lt;/small&gt;
|}

Anmerkung-3 ''':'''  &lt;span style=&quot;color:#00B000&quot;&gt;(Ein Theorem und zwei Korollare, aus den beiden vorhergehenden Beweisgängen, werden hier, im 3. Beweisgang, zu verifizierten ,Axiomen‘, die das Theorem-ANSELMS und sein Korollar mit-verifizieren und bestätigen.)&lt;/span&gt;

Dieser Beweisgang ist das Ziel aller Bemühungen. Hier wird der sog. ,ontologische Gottesbeweis‘ nach ANSELM von Canterbury formal-syntaktisch dargestellt und als logisch nachvollziehbar von GÖDEL bestätigt. Damit hat er aber auch klar gestellt, dass der ontologische Beweis ANSELMS kein Beweis für die ,Existenz‘ des GOTTES der Bibel sein kann, bzw. sein ,will‘ ''':''' Denn mit der Prämisse, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx'''‘ —&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(Term :01:, wie auch schon im ,Basisbeweis‘, und ausformuliert hier in Term :02:, mit der Definition für GOTT)&lt;/span&gt;, wird mit dem traditionellen, abendländischen ,GOTT-Glauben‘, der ,glaubt‘, dass der Gott der Christen tatsächlich existiert, — methodologisch als ,Annahme‘ —, der Beweisgang schon regulär und explizit eröffnet, aus dem sich dann, logisch korrekt, mit Hilfe der GÖDEL-Axiome und Definitionen, das ,Theorem ANSELMS‘ ergibt; &lt;span style=&quot;color:#00B000&quot;&gt;(hier jedoch, mit Günther J. WIRSCHING, ohne den Umweg bei GÖDEL über den &lt;span style=&quot;color:#4C58FF&quot;&gt;[ Modus Barbara ] :: [ A → B, B → C ├ A → C ] &lt;/span&gt;, mit dem modalen Axiom-BECKER ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''◇□A→□A'''‘ —&lt;/span&gt;, als &lt;span style=&quot;color:#4C58FF&quot;&gt;‚B → C‘&lt;/span&gt; im kategorischen Syllogismus, das André FUHRMANN recherchiert hat)&lt;/span&gt;. GÖDEL verwendet zur Darstellung des sog. ,ontologischen Gottesbeweises‘, nach ANSELM, die Struktur eines modal-logischen Kalküls. Ein modal-logisches Kalkül ist ein genau geregeltes Schema, in dem bei bestimmten ,Annahmen‘ &lt;span style=&quot;color:#00B000&quot;&gt;(Axiome, Definitionen, Prämissen)&lt;/span&gt; etwas anderes als das Vorausgesetzte, auf Grund des Vorausgesetzten mit Notwendigkeit folgt. Entsprechend der ,Modalität‘ der sechs ,modal‘ notwendigen, d.h. transzendentalen Voraussetzungen, hier, für den 3. Beweisgang, die in den &lt;span style=&quot;color:#00B000&quot;&gt;(und durch die)&lt;/span&gt; beiden vorhergehenden Beweisgängen schon als &lt;span style=&quot;color:#FF6000&quot;&gt;„modal wahr“&lt;/span&gt;, bzw. als logisch annehmbar, verifiziert und/oder ,bewiesen‘ wurden, sind auch die beiden ,Schlusssätze‘ &lt;span style=&quot;color:#00B000&quot;&gt;(Theorem-3 und Korollar-3)&lt;/span&gt; &lt;span style=&quot;color:#FF6000&quot;&gt;„modal wahr“&lt;/span&gt;, bzw. logisch annehmbar '''!''' Die Wahl der Prämisse :01: dagegen ist nicht ,modal‘ notwendig, sondern beruht auf einer freien Entscheidung, und damit ist auch ihre Interpretation eine ,modal‘ freie Entscheidung, mit der Voraussetzung, dass man das Kalkül mit Theoremen aus der &lt;span style=&quot;color:#4C58FF&quot;&gt;„christlichen Theologie“&lt;/span&gt; evaluieren, und damit interpretieren will. Dazu berechtigt die Genese des Kalküls. Der Glaube an den GOTT der Christen ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx'''‘ —&lt;/span&gt;, beruht immer auf einer freien Entscheidung. Das Kalkül, als solches, unabhängig von jeder Interpretation seiner Syntax, ist genau dann ,allgemein‘ &lt;span style=&quot;color:#FF6000&quot;&gt;»''mathematisch evident''«&lt;/span&gt;, d.h. ,ist allgemein gültig‘, wenn es gültigen Logik-Regeln folgt. Die Bestimmung seiner Syntax jedoch, d.h. seine Interpretation, unterliegt hermeneutischen Kriterien, die nicht von Logik-Regeln abhängen, wie hier ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''(unabhängig von der zufälligen Struktur der Welt). Nur dann sind die Axiome wahr''«&lt;/span&gt;, wie GÖDEL selbst hinzufügt. Mit der, — von GÖDEL eingeforderten —, ‚Unabhängigkeit‘ der Kalkül-Axiome von der zufälligen Struktur der Welt, wird implizit für das Kalkül auch festgelegt, dass &lt;span style=&quot;color:#FF6000&quot;&gt;„GOTT“&lt;/span&gt; ‚unabhängig‘ von der zufälligen &lt;span style=&quot;color:#00B000&quot;&gt;(Raum-Zeit-)&lt;/span&gt;Struktur unserer vergänglichen Welt, und daher ,zeitlos-ewig‘ ist, &lt;span style=&quot;color:#00B000&quot;&gt;(was &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologisch“&lt;/span&gt; korrekt ist)&lt;/span&gt;, begründet durch Definition-1 und Axiom-3. Aus der zeitlosen Ewigkeit GOTTES folgt, dass GOTT, &lt;span style=&quot;color:#FF6000&quot;&gt;„unverursacht“ &lt;span style=&quot;color:#00B000&quot;&gt;|&lt;/span&gt; „grundlos“&lt;/span&gt;, für uns immer schon ‚da‘ ist, denn bei Zeitlosigkeit gibt es keinen ,zeitlichen‘ und damit auch keinen ,ontologischen‘ Unterschied zwischen ‚Ursache‘ und ‚Wirkung‘. Beides ist dann koinzident ,eins‘ ''':''' wie ,Wesen‘ und ,Dasein‘ in GOTT, bzw. wie ,Begriff‘ und ,Sein‘, oder ,Möglichkeit‘ und ,Wirklichkeit‘. &lt;span style=&quot;color:#00B000&quot;&gt;(Man vergleiche damit auch die ,postulierte‘ Einheit von ,Erkenntnisobjekt‘ und ,Erkenntnissubjekt‘ im ,Gott‘ des ARISTOTELES ''':''' im &lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;span style=&quot;color:#00B000&quot;&gt;[ selbstbewussten ]&lt;/span&gt; ''Erkennen seiner Erkenntnis''&lt;span style=&quot;color:#00B000&quot;&gt;[-Tätigkeit ]&lt;/span&gt;«&lt;span style=&quot;color:#00B000&quot;&gt; | &lt;/span&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;νοήσεως νόησις&lt;/big&gt;&lt;/span&gt;“&lt;span style=&quot;color:#00B000&quot;&gt; | &lt;/span&gt;„noêseôs noêsis“&lt;/span&gt; &lt;small&gt;(‚&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;''Metaphysik''&lt;/big&gt;&lt;/span&gt;‘ XII 9, 1074b34)&lt;/small&gt;, im Vollzug seiner Funktion als ,unbewegtes Bewegungsprinzip‘, als &lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;πρῶτον κινοῦν ἀκίνητον&lt;/big&gt;&lt;/span&gt;“&lt;span style=&quot;color:#00B000&quot;&gt; | &lt;/span&gt;„prôton kinoûn akinêton“&lt;/span&gt; der Welt, das alles Übrige &lt;span style=&quot;color:#FF6000&quot;&gt;»''wie ein Geliebtes''«&lt;span style=&quot;color:#00B000&quot;&gt; | &lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;ὡς ἐρώμενον&lt;/big&gt;&lt;/span&gt;“&lt;/span&gt; | &lt;span style=&quot;color:#FF6000&quot;&gt;„hôs erômenon“&lt;/span&gt; bewegt; d.h. christlich ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''aus Liebe''«&lt;/span&gt; ,entstehen‘ lässt.)&lt;/span&gt;

Anmerkung-4 ''':''' Das &lt;span style=&quot;color:#00B000&quot;&gt;(im 2. Beweisgang)&lt;/span&gt; schon bewiesene Theorem-2, d.i. die Koinzidenz von  &lt;span style=&quot;color:#FF6000&quot;&gt;„Sein“&lt;/span&gt; und   &lt;span style=&quot;color:#FF6000&quot;&gt;„Wesen“&lt;/span&gt; in GOTT, &lt;span style=&quot;color:#00B000&quot;&gt;(‚Existenz‘&lt;/span&gt; und &lt;span style=&quot;color:#00B000&quot;&gt;‚Essenz‘)&lt;/span&gt;, rechtfertigt sowohl Axiom-5 als auch die Definition-3, und widerlegt den Einwand KANTS. Somit ist deren Setzung &lt;span style=&quot;color:#00B000&quot;&gt;(hier, im 3. Beweisgang)&lt;/span&gt; korrekt, und durch das Theorem-2 schon vorbestimmt und bestätigt, d.h. beide sind &lt;span style=&quot;color:#FF6000&quot;&gt;„modal wahr“&lt;/span&gt; und ,logisch‘ annehmbar, da sie durch die Gültigkeit von Theorem-2 ,verifiziert‘ worden sind. Damit wird klar erkennbar, dass das Theorem-2 tatsächlich die Basis des GÖDEL-Kalküls ist. Und wenn damit Axiom-5 im GÖDEL-Kalkül ‚gerechtfertigt‘ ist, dann ist auch, &lt;span style=&quot;color:#00B000&quot;&gt;(als Voraussetzung dafür)&lt;/span&gt;, das Axiom-4 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PX → □PX'''‘ — ''':''' &lt;/span&gt; &lt;span style=&quot;color:#FF6000&quot;&gt;»''Positive Eigenschaften'', &lt;span style=&quot;color:#00B000&quot;&gt;[ ,Transzendentalia‘ ]&lt;/span&gt;, ''sind notwendig aus sich'', &lt;span style=&quot;color:#00B000&quot;&gt;[ von Natur aus ]&lt;/span&gt;, ''positiv''«&lt;/span&gt;, im 2. Beweisgang erklärbar, in dem die ‚Positivität‘, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''P'''‘ —&lt;/span&gt;, einer Eigenschaft schon als ‚notwendig‘, &lt;span style=&quot;color:#4C58FF&quot;&gt;— '''□''' —&lt;/span&gt;, charakterisiert worden ist, äquivalent zu Axiom-5 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''PE'''&lt;sub&gt;not&lt;/sub&gt;‘ —&lt;/span&gt;, in dem die ‚Notwendigkeit‘,  &lt;span style=&quot;color:#4C58FF&quot;&gt;— &lt;sub&gt;not&lt;/sub&gt; —&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(der Existenz &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''E'''‘ —&lt;/span&gt;)&lt;/span&gt;, dann als ‚positive‘ Eigenschaft, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''P'''‘ —&lt;/span&gt;, ‚bestimmt‘ wird; &lt;span style=&quot;color:#00B000&quot;&gt;(unter der speziellen Voraussetzung, dass &lt;span style=&quot;color:#FF6000&quot;&gt;„Existieren“&lt;/span&gt; definitiv als eine &lt;span style=&quot;color:#FF6000&quot;&gt;„Wesenseigenschaft“&lt;/span&gt; in GOTT ,instanziiert‘ ist; vgl. Definition-3. Eine ,bestimmte‘ Eigenschaft ist genau dann ,instanziiert‘, wenn sie an einem Träger real ,existiert‘. Definition-3 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''E'''&lt;sub&gt;not&lt;/sub&gt;'''x ↔ ∀X(X'''&lt;sub&gt;ess&lt;/sub&gt;'''x →□∃yXy)'''‘ —&lt;/span&gt;, besagt, dass die, von GÖDEL ,postulierte‘, und im Basis-Theorem-2 verifizierte, &lt;span style=&quot;color:#FF6000&quot;&gt;„notwendige Existenz“&lt;/span&gt; zu den ,ultimativen‘ Transzendentalia in GOTT gehört; genauer ''':''' Sie ist die ,Summe‘ aller Transzendentalia.)&lt;/span&gt; 

Zum Axiom-4, &lt;span style=&quot;color:#00B000&quot;&gt;(bzw. zum Term :14:, im 2. Beweisgang)&lt;/span&gt;, erklärt GÖDEL in seinen Notizen zum Kalkül ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''da es'' &lt;span style=&quot;color:#00B000&quot;&gt;[ das Notwendigsein, &lt;span style=&quot;color:#4C58FF&quot;&gt;— '''□''' —&lt;/span&gt; ]&lt;/span&gt; ''aus der Natur der'' &lt;span style=&quot;color:#00B000&quot;&gt;[ positiven ]&lt;/span&gt; ''Eigenschaft folgt'', &lt;span style=&quot;color:#00B000&quot;&gt;[ deren Positivität, im selben Beweisgang, mit Term :13: vorher schon ,bewiesen‘ (╞ ) worden ist ]&lt;/span&gt;«&lt;/span&gt;. Diese GÖDEL-Erklärung zum Axiom-4 entspricht der Modal-Regel zur sog. ,Nezessisierung‘ in der KRIPKE-Logik, die dort GÖDEL zugeschrieben wird. &lt;span style=&quot;color:#4C58FF&quot;&gt;[ Nezessisierungsregel ] '''::''' [ ├ A →├ □ A ]&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Angenommen'', &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''A'''‘&lt;/span&gt; ''ist in einem Kalkül eine Prämisse, oder darin regulär'' &lt;span style=&quot;color:#4C58FF&quot;&gt;(├ )&lt;/span&gt; ''abgeleitet, dann folgt in diesem Kalkül regulär'' &lt;span style=&quot;color:#4C58FF&quot;&gt;(├ )&lt;/span&gt;, ''dass dieses'' &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''A'''‘&lt;/span&gt; ''auch ,modal‘ notwendig'' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ,□‘ —&lt;/span&gt; ''ist''«&lt;/span&gt;. GÖDEL hat jedoch diese modale Notwendigkeit nur in der ,Natur‘ der positiven Eigenschaften, alias ,Transzendentalia‘, gesehen, und mit den Aussagen im Axiom-4 expliziert ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PX → □PX'''‘ —&lt;/span&gt;, unter der unumgänglichen Bedingung ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''unabhängig von der zufälligen Struktur der Welt, nur dann sind die Axiome wahr''«&lt;/span&gt;. Ob dieselbe modale ,Notwendigkeit‘ auch auf Aussagen über Eigenschaften, wie ,rot‘ oder ,schwer‘, die weder positiv noch negativ sind, zutrifft, ist nicht erwiesen. Hier kann nur von modaler ,Kontingenz‘ gesprochen werden, die universal, alles Seiende innerhalb der &lt;span style=&quot;color:#FF6000&quot;&gt;»''zufälligen Struktur der Welt''«&lt;/span&gt; betrifft. Somit sind die Aussagen &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''A'''‘ —&lt;/span&gt; in der GÖDEL-Regel, nur auf Aussagen über ,positive‘ Eigenschaften eingeschränkt, und nicht allgemein gültig. Die &lt;span style=&quot;color:#4C58FF&quot;&gt;[ Nezessisierungsregel ]&lt;/span&gt; ist nur für &lt;span style=&quot;color:#FF6000&quot;&gt;„Transzendentalia“ „modal wahr“&lt;/span&gt;, und für ,Nicht-Transzendentalia‘ immer &lt;span style=&quot;color:#FF6000&quot;&gt;„modal falsch“&lt;/span&gt;.

Der unbegrenzt Unendliche, GOTT, — im Glauben der Christen —, ist deswegen ,notwendig für uns da‘ ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx→E'''&lt;sub&gt;not&lt;/sub&gt;'''x'''‘ —&lt;/span&gt;, weil er als GOTT  ,vollkommen‘, ,perfekt‘ und absolut ,positiv‘, d.h. absolut ,gut allein‘  ist, ohne jede Negativität ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PG'''‘ —&lt;/span&gt;; &lt;span style=&quot;color:#00B000&quot;&gt;(was auch schon im 2. Beweisgang mit Term :13: verifiziert wurde)&lt;/span&gt;. Und wenn GOTT ,vollkommen‘, ,perfekt‘, ,positiv‘, und absolut ,gut‘ ist, dann ist er das auch ,notwendig aus sich‘ ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PG → □PG'''‘ — ::&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;(als Zusatz-Korollar im 2. Beweisgang mit Axiom-4 und der &lt;span style=&quot;color:#4C58FF&quot;&gt;[ Instanz(X:=G) ]&lt;/span&gt;)&lt;/span&gt;, d.h. ,aus seinem Wesen‘. Das ist gerade das, ,was‘ GOTT als GOTT ausmacht ''':''' sein ,Wesen‘, bzw. seine &lt;span style=&quot;color:#FF6000&quot;&gt;„Natur“&lt;/span&gt;. Zusammen mit der Definition-1 für GOTT, &lt;span style=&quot;color:#00B000&quot;&gt;(und der Definition-2 ''':''' Alle Wesenseigenschaften hängen notwendig gleichwertig aus sich zusammen)&lt;/span&gt;, ist dieses, aus der &lt;span style=&quot;color:#FF6000&quot;&gt;„Natur“&lt;/span&gt; GOTTES sich ergebende, ‚Notwendigsein‘, &lt;span style=&quot;color:#4C58FF&quot;&gt;— '''□''' —&lt;/span&gt;, aller ‚positiven‘ Eigenschaften im Axiom-4, und ihr logischer Zusammenhang, d.i. die Koinzidenz aller ,Vollkommenheiten‘ und ,Zuschreibungen‘ im Unendlichen, GOTT, ihr ,Zusammenfallen in eins‘, die entscheidende Voraussetzung, aus der sich dann für GÖDEL &lt;span style=&quot;color:#00B000&quot;&gt;(im 2. Beweisgang)&lt;/span&gt; auch der logische Zusammenhang, bzw. die ontologische Identität, &lt;span style=&quot;color:#00B000&quot;&gt;(die Koinzidenz)&lt;/span&gt;, von &lt;span style=&quot;color:#FF6000&quot;&gt;„Dasein“&lt;/span&gt; und &lt;span style=&quot;color:#FF6000&quot;&gt;„Wesen“&lt;/span&gt; in GOTT, im Basis-Theorem-2 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''Gx↔G'''&lt;sub&gt;ess&lt;/sub&gt;'''x'''‘ —&lt;/span&gt; mit Notwendigkeit ergibt. Dieses Theorem-2 ist dann, in weiterer Folge, die ,modal‘ notwendige, d.h. die transzendentale Voraussetzung auch für den Konsequenz-Teil im Theorem ANSELMS, &lt;span style=&quot;color:#00B000&quot;&gt;(Term :09: hier im 3. Beweisgang)&lt;/span&gt;. &lt;span style=&quot;color:#FF6000&quot;&gt;„Positive Eigenschaften“&lt;span style=&quot;color:#00B000&quot;&gt; | &lt;/span&gt;„Vollkommenheiten“&lt;/span&gt; sind ,immer‘ auch &lt;span style=&quot;color:#FF6000&quot;&gt;„notwendige Eigenschaften“&lt;/span&gt;, daher ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''PE'''&lt;sub&gt;not&lt;/sub&gt;‘ —&lt;/span&gt;. Das ,Dasein‘, die &lt;span style=&quot;color:#FF6000&quot;&gt;„Existenz“&lt;/span&gt; ist ,immer‘ etwas &lt;span style=&quot;color:#FF6000&quot;&gt;„Positives“&lt;/span&gt;, speziell in GOTT, dem Schöpfer jeder ,Existenz‘, bzw. allen ,Seins‘. Axiom-4 begründet im GÖDEL-Kalkül das Basis-Theorem-2, &lt;span style=&quot;color:#00B000&quot;&gt;(wie auch das Korollar-3 von der exklusiven Einzigartigkeit GOTTES)&lt;/span&gt;, und ,verankert‘ diese Theoreme damit zugleich in der &lt;span style=&quot;color:#4C58FF&quot;&gt;,theologisch‘&lt;/span&gt;-philosophischen Tradition der ,Rede von GOTT‘ bei ARISTOTELES, — AVICENNA, — ANSELM, — DESCARTES, — LEIBNIZ, — HEGEL, — und bei GÖDEL mit äußerster ,logischer‘ Klarheit.

Anmerkung-5 ''':''' Der ‚Schlüsselbegriff‘ in diesem Kalkül ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;„positive Eigenschaft“&lt;/span&gt;, bzw. &lt;span style=&quot;color:#FF6000&quot;&gt;„Vollkommenheit“&lt;span style=&quot;color:#00B000&quot;&gt; | &lt;/span&gt;„Perfektion“&lt;/span&gt;, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''P'''‘ —&lt;/span&gt;, dominiert alle Axiome des GÖDEL-Kalküls, jedoch ohne inhaltlich genauer ‚bestimmt‘ worden zu sein. Für &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''P'''‘ — &lt;/span&gt; gibt es keine explizite Definition '''!''' &lt;span style=&quot;color:#00B000&quot;&gt;(Das Theorem-1 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PX→◇∃xXx'''‘ —&lt;/span&gt;, besagt nur, dass die ,postulierten‘, positiven Eigenschaften, die &lt;span style=&quot;color:#FF6000&quot;&gt;„Transzendentalia“&lt;/span&gt;, formal miteinander verträglich, d.h. ‚widerspruchsfrei‘ sind, wegen Axiom-1 und Axiom-2. Axiom-2 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PX ∧ □∀x(Xx→Yx)→PY'''‘ —&lt;/span&gt;, besagt, dass positive Eigenschaften ,gleichwertig‘ sind, d.h. gleich ,wahr‘ sind, weil sie ,notwendig‘, &lt;span style=&quot;color:#4C58FF&quot;&gt;— '''□''' —&lt;/span&gt;, aus sich, alle paarweise mit- und voneinander ,impliziert‘ sind, sich gegenseitig ,einschließen‘, und damit eine Einheit bilden, d.h. auch in GOTT ,eins‘ sind. Axiom-2 ist somit zugleich eine ,indirekte‘ Definition für ,positive‘ Eigenschaften ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''P'''‘ —&lt;/span&gt;. Definition-2 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''X'''&lt;sub&gt;ess&lt;/sub&gt;'''x ↔ Xx ∧ ∀Y(Yx→ □∀y(Xy→Yy))'''‘ —&lt;/span&gt;, besagt ''':''' Weil die ,gleichwertigen‘, positiven Eigenschaften sich gegenseitig implizieren, und damit notwendig von einander abhängen, d.h. koinzident in GOTT ,eins‘ sind, — wenn &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''x'''‘&lt;/span&gt; für GOTT steht —, dann sind sie somit auch die ,wesentlichen‘ Eigenschaften, die &lt;span style=&quot;color:#FF6000&quot;&gt;„ultimativen Transzendentalia“&lt;/span&gt;, in GOTT, der, wesentlich und exklusiv, notwendig ,Einer‘ ist. Die Definition-2 ist nur dann &lt;span style=&quot;color:#FF6000&quot;&gt;„modal wahr“&lt;/span&gt;, wenn ihre Eigenschafts-Variablen, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''X'''‘ —&lt;/span&gt; und &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Y'''‘ —&lt;/span&gt;, mit positive Eigenschaften, d.h. mit &lt;span style=&quot;color:#FF6000&quot;&gt;„Transzendentalien“&lt;/span&gt;, besetzt werden. Diese Definition ist jedoch sofort &lt;span style=&quot;color:#FF6000&quot;&gt;„modal falsch“&lt;/span&gt;, wenn ihre Variablen mit nicht-positive Eigenschaften, wie ,rot‘ oder ,schwer‘ belegt werden, die nicht ,transzendental‘-allgemein gültig sind. Fußnote zu Definition-2 in der GÖDEL-Notiz ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''any two essences of x are nec. equivalent''«&lt;/span&gt;. Diese paarweise, notwendige Äquivalenz von zwei beliebigen Wesenseigenschaften der Individuum-Variable &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''x'''‘&lt;/span&gt;, wird hier, spezifisch für GOTT, d.h. wenn &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''x'''‘&lt;/span&gt; für GOTT, dem ,Einen‘, steht, zur &lt;span style=&quot;color:#FF6000&quot;&gt;„Koinzidenz“&lt;/span&gt;, — zum paarweise ,Zusammenfallen aller Gegensätze in Einem‘ —, dem inneren Zusammenhang aller seiner &lt;span style=&quot;color:#FF6000&quot;&gt;„ultimativen“&lt;/span&gt; Vollkommenheiten, d.h. aller &lt;span style=&quot;color:#FF6000&quot;&gt;„Transzendentalia“&lt;/span&gt; und Zuschreibungen, in dem unbegrenzt Unendlichen, GOTT, den schon der Philosoph und Kardinal NIKOLAUS von Kues als &lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;,coincidentia oppositorum‘&lt;/big&gt;&lt;/span&gt; verstanden hat.)&lt;/span&gt; 

In den entscheidenden ‚Schlusssätzen‘ des Kalküls ist der ‚Schlüsselbegriff‘ verschwunden. Hier ist nur mehr von GOTT, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''G'''‘ —&lt;/span&gt;, die Rede ''':''' Korollar-1, &lt;span style=&quot;color:#FF6000&quot;&gt;»''Es ist definitiv denkbar, dass es GOTT gibt''«&lt;/span&gt;, Theorem-2, &lt;span style=&quot;color:#FF6000&quot;&gt;»''Dasein, GOTT-Sein, Göttlichkeit ist das Wesen GOTTES''«&lt;/span&gt;, Theorem-3, &lt;span style=&quot;color:#FF6000&quot;&gt;»''Weil GOTT definitiv denkbar, d.h. widerspruchsfrei möglich ist, darum ist auch der Glaube an GOTT widerspruchsfrei, logisch richtig und mathematisch evident, der annimmt, dass es GOTT, mit Notwendigkeit, wirklich gibt''«&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(nach ANSELM von Canterbury, und was spezifisch das &lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;''Privilegium der Gottheit allein''&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt; ist, nach LEIBNIZ)&lt;/span&gt;, und Korollar-3, &lt;span style=&quot;color:#FF6000&quot;&gt;»''Es gibt notwendig aus sich, d.i. unverursacht, nur einen GOTT''«&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(nach A. FUHRMANN)&lt;/span&gt;. Das GÖDEL-Kalkül ist zu diesen Erkenntnissen gekommen, ohne die Eigenschaften, bzw. die ‚Vollkommenheiten‘ GOTTES, d.h. wer oder was GOTT ‚an sich‘ selbst ist, genauer bestimmen zu müssen, &lt;span style=&quot;color:#00B000&quot;&gt;(was ,für uns‘ ohnehin ,unmöglich‘ ist)&lt;/span&gt;; außer im Theorem-2, in dem das &lt;span style=&quot;color:#FF6000&quot;&gt;„Dasein“&lt;/span&gt; GOTTES als die ‚für uns‘ bestimmende und wichtigste &lt;span style=&quot;color:#FF6000&quot;&gt;„Wesenseigenschaft“&lt;/span&gt; in GOTT erkannt worden ist, — immer vorausgesetzt &lt;span style=&quot;color:#00B000&quot;&gt;(,angenommen‘)&lt;/span&gt;, man ‚glaubt‘ an den zeitlos-ewigen GOTT ''':''' &lt;span style=&quot;color:#00B000&quot;&gt;(Term :01:)&lt;/span&gt;. Der GOTT des GÖDEL-Kalküls ist nicht mehr der an Raum und Zeit gebundene ‚Gott‘ des ARISTOTELES, sondern der von Raum und Zeit &lt;span style=&quot;color:#FF6000&quot;&gt;»''unabhängige''«&lt;/span&gt; GOTT der Bibel bei ANSELM und bei LEIBNIZ. Das GÖDEL-Kalkül, &lt;span style=&quot;color:#00B000&quot;&gt;(wie ja auch der sog. ‚ontologische Gottesbeweis‘ ANSELMS)&lt;/span&gt;, kann jedoch, — bei aller ‚Coolness‘ —, keinen GOTT-Glauben ‚erzeugen‘, sondern setzt vielmehr die Existenz GOTTES notwendig als gegeben schon voraus. Das Kalkül des Logiker GÖDEL beweist aber, dass der traditionelle ‚GOTT-Glaube‘, &lt;span style=&quot;color:#FF6000&quot;&gt;»''die theologische Weltanschauung''«&lt;/span&gt;,  mit den Maßstäben der modernen Logik &lt;span style=&quot;color:#FF6000&quot;&gt;»''durchaus vereinbar''«&lt;/span&gt;, d.h. logisch ,richtig‘ und &lt;span style=&quot;color:#FF6000&quot;&gt;»''mathematisch evident''«&lt;/span&gt; ist, weil der ‚Nicht-GOTT-Glaube‘, &lt;span style=&quot;color:#FF6000&quot;&gt;»''die atheistische Weltanschauung''«&lt;/span&gt;, im Möglichkeitsbeweis notwendig zu unlösbaren Widersprüchen führt, und somit logisch ,falsch‘ und unsinnig ist. &lt;span style=&quot;color:#00B000&quot;&gt;(Die ,Logik‘ hat aber, — bekanntlich —, bei allen wichtigen, persönlichen Entscheidungen immer nur eine untergeordnete Rolle '''!''' )&lt;/span&gt;

Anmerkung-6 ''':''' Das erste, ,regulär‘ &lt;span style=&quot;color:#00B000&quot;&gt;(├ )&lt;/span&gt; abgeleitete, Hauptergebnis im 3. Beweisgang, Term :10: &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□∃xGx'''‘ —&lt;/span&gt; ''':''' der Glaube, dass GOTT ,notwendig‘ existiert, ist die logische Konsequenz aus der Prämisse, Term :1: &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx'''‘ —&lt;/span&gt;. Dieses erste Hauptergebnis hat also den überlieferten, traditionellen GOTT-Glauben zur Voraussetzung, und ist daher davon ,abhängig‘, d.h. Term :10: ist der Ausdruck einer ,Glaubensüberzeugung‘. Das zweite Hauptergebnis im 3. Beweisgang, das Theorem ANSELMS ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''◇∃xGx→□∃xGx'''‘ —&lt;/span&gt;, dagegen, ist die Darstellung der Abhängigkeit des ersten Hauptergebnisses von dem, vorher schon bewiesenen, ,Axiom‘ von der ,möglichen‘ Existenz GOTTES ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''◇∃xGx'''‘ —&lt;/span&gt;, dem Möglichkeits-Korollar-1 aus dem 1. Beweisgang. Dem geht folgende Beobachtung voraus ''':''' Der Term ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□∃xGx'''‘ —&lt;/span&gt;, hat in seiner syntaktischen Stellung hier, im Theorem-3, nicht mehr den überlieferten, traditionellen GOTT-Glauben zur Voraussetzung, und ist damit, in seiner Position als Konsequenz-Teil im Theorem ANSELMS, auch nicht mehr davon syntaktisch abhängig, sondern stützt sich formal-syntaktisch nur auf die behauptete Möglichkeit GOTTES; daher muss diese ,angenommene‘ Möglichkeit noch bewiesen &lt;span style=&quot;color:#00B000&quot;&gt;( ╞ )&lt;/span&gt; werden. Dazu die Feststellung LEIBNIZ‘, der diesen Zusammenhang, und seinen Mangel, erkannt hat ''':''' 

::Das Theorem ANSELMS ist &lt;span style=&quot;color:#FF6000&quot;&gt;» ''ein unvollständiger Beweis, der etwas voraussetzt, was man noch hätte beweisen'' &lt;span style=&quot;color:#00B000&quot;&gt;( ╞ )&lt;/span&gt; ''sollen, um ihm mathematische Evidenz zu verleihen — nämlich, dass man dabei stillschweigend voraussetzt, diese Vorstellung des durchaus großen oder durchaus vollkommenen Wesens sei möglich und enthalte keinen Widerspruch'' «&lt;/span&gt;. 

Diesen &lt;span style=&quot;color:#FF6000&quot;&gt;»''unvollständigen Beweis''«&lt;/span&gt; hat GÖDEL im 1. Beweisgang mit dem ,regulär‘ &lt;span style=&quot;color:#00B000&quot;&gt;(├ )&lt;/span&gt; abgeleiteten, und widerspruchfreien Möglichkeits-Korollar-1, vervollständigt, und damit hat er mit &lt;span style=&quot;color:#FF6000&quot;&gt;»''mathematischer Evidenz''«&lt;/span&gt; bewiesen ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Diese Vorstellung des durchaus  großen oder durchaus vollkommenen Wesens''«&lt;/span&gt; enthält &lt;span style=&quot;color:#FF6000&quot;&gt;»''keinen Widerspruch''«&lt;/span&gt; '''!''' &lt;span style=&quot;color:#00B000&quot;&gt;(Diese Ergebnis-Zusammenfassung ist eine Vorwegnahme und die Bestätigung für meine Interpretation des Glaubens-Theorem ANSELMS, hier im 3. Beweisgang ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Weil es widerspruchsfrei möglich ist, dass es GOTT gibt, ist der Glaube, dass es GOTT wirklich gibt, widerspruchsfrei''«&lt;/span&gt;.)&lt;/span&gt; Das Möglichkeits-Korollar-1 ist ,regulär‘ nur vom logischen Axiom-1 der Widerspruchsfreiheit, und von der mathematischen Äquivalenz der Perfektionen, &lt;span style=&quot;color:#00B000&quot;&gt;(der Transzendentalien)&lt;/span&gt;, im Axiom-2 ,abhängig‘, und nicht mehr von der ,methodologischen‘ Kalkül-Prämisse, dem traditionellen GOTT-Glauben. Damit hat das Glaubens-Theorem ANSELMS die gesuchte &lt;span style=&quot;color:#FF6000&quot;&gt;»''mathematische Evidenz''«&lt;/span&gt; erreicht, unabhängig von jeder Glaubensüberzeugung. Entscheidend dafür ist der mathematisch-logische Beweis GÖDELS, dass der Nicht-GOTT-Glaube zu einem Widerspruch führt.

Zusammenfassung ''':'''

Theorem-1 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PX→◇∃xXx'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Positive Eigenschaften sind konsistent''«&lt;/span&gt;, ist die logische Konsequenz aus der Prämisse im 1. Beweisgang, Term :01: &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''PX'''‘ —&lt;/span&gt;, den, — &lt;u&gt;modal-frei&lt;/u&gt; — gewählten, ,angenommenen‘ positiven Eigenschaften, bzw. ,Transzendentalia‘, &lt;span style=&quot;color:#00B000&quot;&gt;(die konkret durch Beispiele ,belegbar‘ sind)&lt;/span&gt;. 

Theorem-2 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt; — ‚'''Gx↔G'''&lt;sub&gt;ess&lt;/sub&gt;'''x'''‘ — &lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»'',Da‘-Sein ist das Wesen GOTTES''«&lt;/span&gt;, ist die logische Konsequenz aus der Prämisse im 2. Beweisgang, Term :01: &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx'''‘ —&lt;/span&gt;, dem, — &lt;u&gt;modal-frei&lt;/u&gt; — gewählten, ,angenommenen‘ GOTT-Glauben der Christen, &lt;span style=&quot;color:#00B000&quot;&gt;(konkret durch Verweise auf soziologische Gegebenheiten ,belegbar‘, und auch &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologisch“&lt;/span&gt; verifizierbar)&lt;/span&gt;. 

Im Unterschied dazu ist im 3. Beweisgang, das Theorem-3 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''◇∃xGx→□∃xGx'''‘ —&lt;/span&gt; ''':''' der Glaube, dass es einen GOTT notwendig gibt ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□∃xGx'''‘ —&lt;/span&gt;, die logische Konsequenz aus dem, — &lt;u&gt;modal-notwendig&lt;/u&gt; — als widerspruchsfrei ,bewiesenen‘, Möglichkeits-Korollar-1 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''◇∃xGx'''‘ —&lt;/span&gt;, im 1. Beweisgang, &lt;span style=&quot;color:#00B000&quot;&gt;(auch im Beweisgang ,Widerlegung‘ im Anhang)&lt;/span&gt;, und damit ist das Glaubens-Theorem-3, als ganzes, ,widerspruchsfrei‘. Das Theorem ANSELMS ist, mit Korollar-1, nur vom logischen Axiom-1 der Widerspruchsfreiheit, und der paarweisen, mathematischen Äquivalenz beliebiger positiver Eigenschaften, &lt;span style=&quot;color:#00B000&quot;&gt;(aller Transzendentalia)&lt;/span&gt;, im Axiom-2, abhängig, und nicht mehr von der ,methodologischen‘ Glaubensprämisse ''':''' Term :01:. Damit ist die Bedingung für die geforderte, spezielle &lt;span style=&quot;color:#FF6000&quot;&gt;»''mathematische Evidenz''«&lt;/span&gt;, und auch für die Widerspruchsfreiheit im Glaubens-Theorem ANSELMS erfüllt; unabhängig von jeder Glaubensüberzeugung. Weil es &lt;span style=&quot;color:#FF6000&quot;&gt;„modal wahr“&lt;/span&gt; ist, dass die Transzendentalien, bzw. die Vollkommenheiten ontologisch, — dem Sein nach —‚ alle &lt;span style=&quot;color:#00B000&quot;&gt;(gegenseitig)&lt;/span&gt; widerspruchsfrei, und alle &lt;span style=&quot;color:#00B000&quot;&gt;(miteinander)&lt;/span&gt; gleichwertig sind, ist es auch &lt;span style=&quot;color:#FF6000&quot;&gt;„modal wahr“&lt;/span&gt;, dass es möglich ist, dass GOTT, — dem Sein nach —‚ da ist, &lt;span style=&quot;color:#00B000&quot;&gt;(d.h. existiert)&lt;/span&gt;, der die unbegrenzte Summe aller ultimativen Transzendentalia, bzw. der unendlichen Vollkommenheiten allen Grades ist, wie es der ,christliche Glaube‘ des Erzbischofs ANSELM und seiner Anvertrauten ,annimmt‘.


====&lt;div class=&quot;center&quot;&gt;&lt;span style=&quot;color:#660066&quot;&gt;Widerlegung&lt;/span&gt;&lt;/div&gt;====

{|class=&quot;wikitable&quot;
|-
! &lt;div class=&quot;center&quot;&gt;&lt;span style=&quot;color:#660066&quot;&gt;GÖDEL-Kalkül : der Möglichkeitsbeweis als Widerlegung des Nicht-GOTT-Glaubens&lt;/span&gt;&lt;/div&gt;
|-
! &lt;span style=&quot;color:#00B000&quot;&gt;''Terme der erweiterten Prädikatenlogik zweiter Stufe_____________ „Benennungen“ und durchgeführte Logik-Operationen''&lt;/span&gt;
|-
|
&lt;small&gt;
&lt;math&gt;\begin{align}

\text{(Axiom 1.1)} &amp; \quad P \neg X \;\Longrightarrow\;\ \neg P\ X\ &amp; \ &amp; \text{„Wenn die Negation von X positiv ist, dann ist X nicht positiv“} \\
\text{(Axiom 2)} &amp; \quad \Box \;\forall x (\ X\ x \Longrightarrow \ Y\ x) \Longrightarrow \ P\ Y &amp; \ &amp; \text{„Die Eigenschaft Y in allen x, die aus der Eigenschaft X in allen x} \\
\text{ } &amp; \quad &amp; \ &amp; \; \; \text{mit modaler Notwendigkeit folgt, ist eine positive Eigenschaft“} \\
\text{[RK]} &amp;\quad \Box\; \forall x A \;\Longrightarrow\;\Box\; \forall x B\; \text{ ├ }\;\Box \; \forall x (A \Longrightarrow\; B)\ &amp; \ &amp; \; \; \text{( :: Modales Prinzip KRIPKE-Γ-Ɐx)} \\
\text{(Korollar-1)} &amp;\quad  \Diamond \; \exists x \ G \ x \ &amp; \ &amp; \; \; \text{( „das —,x‘— steht für den GOTT, —,G‘—, der Christen“ )} \\ 
\text{ } &amp; \text{„Es ist möglich, dass es den GOTT der Christen gibt“} &amp; \ &amp; \Longleftarrow\; \text{was zu beweisen ist !} \\
\text{01} &amp; \quad  \; \neg \Diamond \; \exists x \ G \ x \ &amp; \ &amp; \text{ AE: „Es ist unmöglich, dass es diesen GOTT gibt“ (dezidierter Atheismus)} \\
\text{02} &amp; \quad (\neg x = .. )\ &amp; \ &amp; \text{ AE: „Es gibt die Eigenschaft, nicht mit x identisch zu sein“ :: (ungleich)} \\
\text{03} &amp; \quad (\ x = .. )\ &amp; \ &amp; \text{ AE: „Es gibt die Eigenschaft, mit x identisch zu sein“ :: (gleich)} \\
\text{04} &amp; \quad  \neg\neg \Box \neg \exists x \ G \ x \ &amp; \ &amp; \text{:01:[ ◇A ↔ ¬□¬A ] :: (Modalregel) } \\
\text{05} &amp; \quad \neg\neg \Box \neg\neg \forall x \neg \ G \ x \ &amp; \ &amp; \text{:04:[ ∃xA ↔ ¬Ɐx¬A ] :: (Quantorenregel) } \\
\text{06} &amp; \quad  \text{ ├ }\;  \Box \; \forall x \neg G \ x \ &amp; \ &amp; \text{:05:NEG :: [ ¬¬A↔A ] :: (Gesetz der Aussagenlogik) } \\
\text{07} &amp; \quad \Box \; \forall x \neg G \ x \Leftrightarrow\ W &amp; \ &amp; \text{:01:06:[ (:01:↔W) → (├:06:↔W) ] :: (Kalkülregel) } \\
\text{08} &amp; \quad \Box \; \forall x \ G \ x \Leftrightarrow\ F &amp; \ &amp; \text{:07:[ (¬A↔W) ↔ (A↔F) ] :: (Regel für Wahrheitswerte)} \\
\text{ } &amp; \text{„Jeder GOTT-Glaube ist notwendig falsch ! “} &amp; \ &amp; \Longleftarrow\; \text{die logische Konsequenz aus der Prämisse :01: !} \\
\text{09} &amp; \quad \Box \; \forall x (\neg x = x ) \Leftrightarrow \ F \; \ &amp; \text{ } &amp; \text{□ⱯxXx:02:Instanz(X:=(¬x=..)) ⇒ Kontradiktion !} \\
\text{10} &amp; \quad \Box \; \forall x (\ G \ x \Rightarrow\; (\neg x = x)) &amp; \text { } &amp; \text{:08:09:[ (:08:↔F) → (:09:↔F) ] :: „ex falso sequitur quotlibet“ :[RK]} \\
\text{11} &amp; \quad \Box \; \forall x (\ G \ x \Rightarrow \; (\neg x = x))  \Rightarrow \; P (\neg x = .. ) &amp; \ &amp; \text{(A2):Instanz(X:=G):Instanz(Y:=(¬x= ..)) } \\
\text{12} &amp; \quad \ P (\neg x = .. ) &amp; \ &amp; \text{:10:11:[ Modus ponens ] :: [ A, A→B ├ B ]} \\
\text{13} &amp; \quad \ P (\neg x = .. )\;\Rightarrow\ \neg P (\ x = .. )\ &amp; \ &amp; \text{(A1.1):Instanz(X:=(x=..))}\\
\text{14} &amp; \quad \neg P (\ x = .. )\ &amp; \ &amp; \text{:12:13:[ Modus ponens ] :: (log. Schlussregel)}\\
\text{15} &amp; \quad \Box \; \forall x \ (x = x ) \Leftrightarrow \ W \; \ &amp; \ &amp; \text{□ⱯxXx:03:Instanz(X:=(x=..)) ⇒ Tautologie !} \\
\text{16} &amp; \quad \Box \; \forall x (\ G \ x \Rightarrow\; (x = x)) &amp; \ &amp; \text{:08:15:[ (:08:↔F) → (:15:↔W) ] :: „ex falso sequitur etiam verum“ :[RK]} \\
\text{17} &amp; \quad \Box \; \forall x (\ G \ x \Rightarrow\;  (x = x))  \Rightarrow \ P (x = .. ) &amp; \ &amp; \text{(A2):Instanz(X:=G):Instanz(Y:=( x= ..))} \\
\text{18} &amp; \quad \ P (\ x = .. )\ &amp; \ &amp; \text{:16:17:[ Modus ponens ]}\\
\text{19} &amp; \quad  \text{ ├ }\; (\neg P (\ x = .. )\ \wedge \ P (\ x = .. )) \Leftrightarrow\ F &amp; \ &amp; \text{:14:18:[ Konjunktion ] ⇒ Kontradiktion !}\\
\text{20} &amp; \quad \neg \Diamond \; \exists x \ G \ x \Rightarrow (\neg P (\ x = .. )\ \wedge \ P (\ x = .. )) &amp; \ &amp; \text{:01:19:[ ├A├B ╞ A→B ] :: ''KONDITIONALER BEWEIS''}\\
\text{ } &amp; {\color{RedOrange}\text{Der Atheismus führt zu einem logischen Widerspruch ! }} &amp; \ &amp; \Longleftarrow\; \text{was mit Term :20: bewiesen ist !} \\
\text{21} &amp; \quad \neg\neg \Diamond \; \exists x \ G \ x &amp; \ &amp; \text{:20:19:[ Modus tollendo tollens ] :: [ A→B,¬B ├ ¬A ]}\\
\text{22} &amp; \quad \; \Diamond \; \exists x \ G \ x &amp; \ &amp; \text{:21:NEG }\\
\text{(Korollar-1)} &amp; \;\text{„Es ist definitiv möglich, dass es diesen GOTT gibt“} &amp; \ &amp; \Longleftarrow\; \text{was zu beweisen war !} \\

\end{align}&lt;/math&gt;
&lt;/small&gt;
|}

Anmerkung-7 ''':''' &lt;span style=&quot;color:#00B000&quot;&gt;( Dieser Beweisgang ist praktisch identisch mit dem 1. Beweisgang, jedoch gestrafft und präzisiert nach G.J.WIRSCHING. Diese Widerlegung des Nicht-GOTT-Glaubens beginnt sofort mit dem Korollar-1 &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''◇∃xGx'''‘ —&lt;/span&gt; aus dem 1. Beweisgang, als in Frage gestelltes ,Theorem‘, und beweist, ohne das Axiom-3 &lt;span style=&quot;color:#4C58FF&quot;&gt;— ,'''PG'''‘ —&lt;/span&gt;, und ohne die GÖDEL-Prämisse &lt;span style=&quot;color:#4C58FF&quot;&gt;— ,'''PX'''‘ —&lt;/span&gt;, in einem Zwischenergebnis, die innere Widersprüchlichkeit und damit auch die Unhaltbarkeit der atheistischen Glaubens-Annahme, aus rein logischen ,Gründen‘, bzw. Axiomen. )&lt;/span&gt;

Dieser Beweisgang geht von der Existenz GOTTES, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ,'''G'''‘ —&lt;/span&gt;, als Glaubens-Annahme, aus,  wobei aber die Möglichkeit seiner Existenz, und damit die Sinnhaftigkeit des Glaubens an GOTT, durch die Prämisse :01: in Frage gestellt wird, und daher im Kalkül überprüft werden muss. Denn mit der Behauptung der Existenz GOTTES allein ist es nicht getan. Es muss auch seine ,Möglichkeit‘, d.h. die Sinnhaftigkeit des Glaubens an GOTT bewiesen werden. LEIBNIZ hat als erster, &lt;span style=&quot;color:#00B000&quot;&gt;(nach ANSELM)&lt;/span&gt;, dieses Problem gesehen, und GÖDEL hat dafür die Lösung gefunden. Dieser Beweisgang, &lt;span style=&quot;color:#00B000&quot;&gt;(analog zum Möglichkeitsbeweis von Günther J. WIRSCHING konzipiert)&lt;/span&gt;, setzt in den Axiomen, genau wie im 1. Beweisgang, die Existenz von etwas &lt;span style=&quot;color:#FF6000&quot;&gt;„Positiven“, „Perfekten“, „Vollkommenen“&lt;/span&gt;, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ,'''P'''‘ —&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(d.h. die Transzendentalien)&lt;/span&gt;, allgemein für die Welt voraus, &lt;span style=&quot;color:#00B000&quot;&gt;(was im Axiom-3 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ,'''PG'''‘ —&lt;/span&gt;, auch GOTT ultimativ zugeordnet wird ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''GOTT ist absolut positiv, perfekt und vollkommen''«&lt;/span&gt;)&lt;/span&gt;; das dann im 2. Beweisgang mit Term :13: als widerspruchsfrei, &lt;span style=&quot;color:#00B000&quot;&gt;(als ,wahr‘ und ,annehmbar‘ im Kontext des christlichen Glaubens)&lt;/span&gt;, schon ,bewiesen‘ &lt;span style=&quot;color:#00B000&quot;&gt;( ╞ )&lt;/span&gt; worden ist. Die Existenz von ,Transzendentalien‘ in der Welt, ist ein, mit Beispielen belegbares, allgemeines Faktum; ihre Existenz auch in GOTT ist mit dem Term :13: des 2. Beweisganges bewiesen, die jedoch im Unendlichen, GOTT, als Transzendentalia, auch in ,ultimativer‘ Form vorliegen. Axiom-1 ,besagt‘, dass Eigenschaften nicht zugleich, vollkommen und nicht vollkommen, sein können. Axiom-2 ,besagt‘, dass, allgemein, alle Vollkommenheiten, &lt;span style=&quot;color:#00B000&quot;&gt;(alle Transzendentalien)&lt;/span&gt;, gleichwertig, &lt;span style=&quot;color:#00B000&quot;&gt;(mathematisch äquivalent)&lt;/span&gt;, sind. &lt;span style=&quot;color:#00B000&quot;&gt;(Axiom-2 wird hier um das GÖDEL-Konjunkt &lt;span style=&quot;color:#4C58FF&quot;&gt;— ,'''PX'''‘ —&lt;/span&gt; verkürzt dargestellt. Damit ist auch Axiom-3 für diesen Beweisgang unnötig geworden, ohne dass sich wegen dieser Kürzung am Ergebnis etwas ändert. Das Axiom-2 wird jedoch sofort &lt;span style=&quot;color:#FF6000&quot;&gt;„modal falsch“&lt;/span&gt;, wenn seine Variablen mit nicht-positive Eigenschaften, wie ,rot‘ oder ,schwer‘ belegt werden, die nicht ,transzendental‘-allgemein gültig sind, die keine ,Transzendentalia‘ sind.)&lt;/span&gt; Die Eigenschaft &lt;span style=&quot;color:#4C58FF&quot;&gt;— (¬x=..) —&lt;/span&gt; ,besagt‘, dass GOTT &lt;span style=&quot;color:#FF6000&quot;&gt;„unvergleichlich“&lt;/span&gt; ist, wenn &lt;span style=&quot;color:#4C58FF&quot;&gt;,'''x'''‘&lt;/span&gt; für GOTT steht. &lt;span style=&quot;color:#00B000&quot;&gt;(Der informelle Term, &lt;span style=&quot;color:#4C58FF&quot;&gt;— (¬x=..) —&lt;/span&gt;, ersetzt hier, wie bei A. FUHRMANN, den formal korrekten Abstraktionsausdruck ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— λy.(¬x=y) —&lt;/span&gt;, aus dem Lambda-Kalkül.)&lt;/span&gt; Der Term :16: &lt;span style=&quot;color:#4C58FF&quot;&gt;— (x=x) ↔ W —&lt;/span&gt; steht auch für die Selbstbezeichnung des GOTTES-JHWH in Exodus 3,14 ''':''' &lt;span style=&quot;color:#CC66FF&quot;&gt;»''Ich bin derjenige, der ‚IST‘'' &lt;span style=&quot;color:#00B000&quot;&gt;[ aus mir selbst ]&lt;/span&gt;«&lt;/span&gt;, der Grund für die &lt;span style=&quot;color:#FF6000&quot;&gt;„Unvergleichbarkeit“&lt;/span&gt; GOTTES. Der GOTT der abendländischen, christlichen Tradition wird mit &lt;span style=&quot;color:#4C58FF&quot;&gt;— ,'''G'''‘ —&lt;/span&gt; bezeichnet ''':''' d.i. der &lt;span style=&quot;color:#FF6000&quot;&gt;„GOTT der Christen“&lt;/span&gt;, entsprechend der ,methodologischen‘ Prämisse und der ,Genese‘ des Kalküls, syntaktisch formalisiert in der Definition-1 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx↔∀X(PX→Xx)'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Das Individuum'' &lt;span style=&quot;color:#4C58FF&quot;&gt;,'''x'''‘&lt;/span&gt; ''ist genau dann GOTT'', &lt;span style=&quot;color:#4C58FF&quot;&gt;,'''G'''‘&lt;/span&gt;, ''wenn es alle Vollkommenheiten'', &lt;span style=&quot;color:#4C58FF&quot;&gt;,'''P'''‘&lt;/span&gt;, ''in sich schließt''«&lt;/span&gt;, nach der Vorgabe von LEIBNIZ ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''GOTT ist ein Wesen von äußerster Größe und Vollkommenheit, das alle Grade derselben in sich schließt''«&lt;/span&gt;. Mit Korollar-1 hat dieser Beweisgang dasselbe Endergebnis, wie der 1. Beweisgang. Der Beweis, dass der dezidierte Atheismus zu einem logischen Widerspruch führt, und damit falsch und unsinnig ist, ist ein Zwischenergebnis in diesem Beweisgang, und begründet mit &lt;span style=&quot;color:#FF6000&quot;&gt;»''mathematischer Evidenz''«&lt;/span&gt;, und unabhängig von jeder Glaubensüberzeugung, den, von LEIBNIZ gesuchten, Möglichkeitsbeweis für die Existenz GOTTES im Argument des Erzbischofs, und bestätigt damit die Sinnhaftigkeit des GOTT-Glaubens. Einmal Axiom-1 und zweimal Axiom-2 sichern hier das Ergebnis des Kalküls ''':''' das Möglichkeits-Korollar-1 ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''◇∃xGx'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Es ist definitiv möglich, dass es den GOTT der Christen gibt''«&lt;/span&gt;. Axiom-1 beruht auf der gegenseitigen Widerspruchsfreiheit aller Transzendentalia. Axiom-2 beruht auf der wechselseitigen Äquivalenz, bzw. der Gleichwertigkeit aller Transzendentalia. Diese zwei Axiome sind die einzigen, und modal-notwendigen, d.h. die transzendentalen Voraussetzungen und Bedingungen für das Endergebnis ''':''' der Widerspruchsfreiheit und Sinnhaftigkeit des Glaubens der Christen an GOTT; &lt;span style=&quot;color:#00B000&quot;&gt;(dasselbe gilt natürlich auch für die &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologische“&lt;/span&gt; Weltanschauung jeder monotheïstischen Religion '''!''' Dem Erzbischof ANSELM ging es damals nur um seinen Glauben an GOTT.)&lt;/span&gt;. Die Existenz der Transzendentalien ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□∀xXx'''‘ —&lt;/span&gt;, ist ein Faktum unserer Welt, das mit Beispielen belegbar ist ''':''' Transzendentalien gibt es, als ,empirisch‘-sprachliche Grundlage des ontologischen ,Beweises‘, genau so, wie es auch Sterne gibt. Darauf beruht die Stringenz der &lt;span style=&quot;color:#4C58FF&quot;&gt;»''axiomatischen Theologie''«&lt;/span&gt; GÖDELS. Damit ist es ihm endgültig gelungen, eine eminent geisteswissenschaftliche Frage, die Jahrhunderte hindurch, lang kontrovers war, einer Lösung zuzuführen, die nun unwiderruflich gültig ist, und es auch bleiben wird.

Die Logik-Regel &lt;span style=&quot;color:#FF6000&quot;&gt;&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;„ex falso sequitur quotlibet, etiam verum“&lt;/big&gt;&lt;/span&gt;&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(‚Aus Falschem folgt irgendetwas, auch Wahres‘)&lt;/span&gt;, ist der scholastische Ausdruck für die ‚Implikation‘ &lt;span style=&quot;color:#00B000&quot;&gt;(Folgerung)&lt;/span&gt; von Aussagen, die nur dann falsch, &lt;span style=&quot;color:#4C58FF&quot;&gt;— F —&lt;/span&gt; ist, wenn das Antezedens wahr, &lt;span style=&quot;color:#4C58FF&quot;&gt;— W —&lt;/span&gt;, und die Konsequenz falsch, &lt;span style=&quot;color:#4C58FF&quot;&gt;— F —&lt;/span&gt; ist. Andernfalls ist sie immer wahr, &lt;span style=&quot;color:#4C58FF&quot;&gt;— W —&lt;/span&gt;, auch wenn die Voraussetzung  falsch, &lt;span style=&quot;color:#4C58FF&quot;&gt;— F —&lt;/span&gt; ist ''':''' ‚Modern‘ darstellbar durch die ‚Wahrheitswertetafel‘ für die ‚materiale Implikation‘, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ,(A → B)‘ —&lt;/span&gt; &lt;span style=&quot;color:#FF6000&quot;&gt;„wenn A, dann B“&lt;/span&gt;. Damit ist auch der &lt;span style=&quot;color:#4C58FF&quot;&gt;[ Modus tollendo tollens ] :: [ A → B, ¬B ├ ¬A ] &lt;/span&gt;  verstehbar; &lt;span style=&quot;color:#00B000&quot;&gt;(vgl. die vierte Zeile der ‚materialen Implikation‘)&lt;/span&gt;. Der positive hypothetische Syllogismus ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;[ Modus ponendo ponens ] :: [ A → B, A ├ B ] &lt;/span&gt; ist aus der ersten Zeile ablesbar.

Die folgende Tabelle gibt für jeden ,Wahrheitswert‘ der Aussagen &lt;math&gt;A&lt;/math&gt; und &lt;math&gt;B&lt;/math&gt; das Resultat einiger zweiwertiger Verknüpfungen an ''':'''
{|class=&quot;wikitable hintergrundfarbe2&quot; style=&quot;text-align:center;&quot;
|-
!colspan=&quot;2&quot;|''Belegung''!!Konjunktion!!Disjunktion!!materiale&lt;br /&gt; Implikation!!Äquivalenz&lt;br /&gt; Bikonditional!!kopulative&lt;br /&gt; Konjunktion
|-
!&lt;math&gt;A&lt;/math&gt;
!&lt;math&gt;B&lt;/math&gt;
!&lt;math&gt;A&lt;/math&gt; und &lt;math&gt;B&lt;/math&gt;
!&lt;math&gt;A&lt;/math&gt; oder &lt;math&gt;B&lt;/math&gt;
!wenn &lt;math&gt;A&lt;/math&gt; dann &lt;math&gt;B&lt;/math&gt;
!sowohl &lt;math&gt;A&lt;/math&gt; als auch &lt;math&gt;B&lt;/math&gt;
!entweder &lt;math&gt;A&lt;/math&gt; oder &lt;math&gt;B&lt;/math&gt;
|-
!W!!W
|W||W||W||W||F
|-
!W!!F
|F||W||F||F||W
|-
!F!!W
|F||W||W||F||W
|-
!F!!F
|F||F||W||W||F
|}

&lt;span style=&quot;color:#00B000&quot;&gt;(Eine ‚Konjunktion‘ ist nur dann ,wahr‘, wenn beide Aussagen einer  ‚Konjunktion‘ wahr sind. Eine ‚kopulative Konjunktion‘ ist nur dann ,wahr‘, wenn entweder die eine, oder die andere Aussage der ‚kopulativen Konjunktion‘ wahr ist. Es besteht also eine Wenn-Dann-Verbindung zwischen beiden Aussagen — eine ,Kopplung‘. Das ist die logische Grundlage von Axiom-1 im GÖDEL-Formalismus)&lt;/span&gt;

Um das Widersprüchliche der ,Annahme‘ nachzuweisen, dass positive Eigenschaften ,nicht konsistent‘ seien, &lt;span style=&quot;color:#00B000&quot;&gt;(im 1. Beweisgang)&lt;/span&gt;, bzw. um das Unlogische und Sinnwidrige der ,Annahme‘ klarzustellen, es sei ,unmöglich‘, dass es einen GOTT gibt, &lt;span style=&quot;color:#00B000&quot;&gt;(hier, in der Widerlegung)&lt;/span&gt;, verwendet das GÖDEL-Kalkül den Gegensatz ''':''' wahr, &lt;span style=&quot;color:#4C58FF&quot;&gt;— W —&lt;/span&gt;, falsch, &lt;span style=&quot;color:#4C58FF&quot;&gt;— F —&lt;/span&gt;, zwischen der dritten und vierten Zeile der Wahrheitswertetafel, für zwei ,wahre‘ &lt;span style=&quot;color:#4C58FF&quot;&gt;— W —&lt;/span&gt; ,materiale Implikationen‘, in denen die Voraussetzung jeweils falsch, &lt;span style=&quot;color:#4C58FF&quot;&gt;— F —&lt;/span&gt;, ist, entsprechend der Regel &lt;span style=&quot;color:#FF6000&quot;&gt;&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;„ex falso, &lt;span style=&quot;color:#4C58FF&quot;&gt;— F —&lt;/span&gt;, sequitur quotlibet, &lt;span style=&quot;color:#4C58FF&quot;&gt;— F —&lt;/span&gt;, etiam verum, &lt;span style=&quot;color:#4C58FF&quot;&gt;— W —&lt;/span&gt;“&lt;/big&gt;&lt;/span&gt;&lt;/span&gt;, jeweils mit der Hilfe von Axiom-1 und Axiom-2, in einer &lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;,Reductio ad absurdum‘&lt;/big&gt;&lt;/span&gt;; hier unabhängig von jeder Glaubensüberzeugung. Im Gegensatz dazu, wird, &lt;span style=&quot;color:#00B000&quot;&gt;(im 2. Beweisgang)&lt;/span&gt;, aus dem Glauben an GOTT, auch mit einer &lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;,Reductio ad absurdum‘&lt;/big&gt;&lt;/span&gt;, speziell mit Axiom-1, das Widersprüchliche in der ,Annahme‘ nachgewiesen, es gäbe in GOTT &lt;span style=&quot;color:#FF6000&quot;&gt;»''keine Vollkommenheit, nichts Positives, nichts Perfektes''«&lt;/span&gt;, d.h. keine ,ultimativen Transzendentalia‘. In dieser &lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;,Reductio ad absurdum‘&lt;/big&gt;&lt;/span&gt;, im 2. Beweisgang,  wird vorausgesetzt &lt;span style=&quot;color:#00B000&quot;&gt;(,angenommen‘)&lt;/span&gt; ''':''' es gibt den GOTT der Christen, &lt;span style=&quot;color:#00B000&quot;&gt;(als Prämisse :01:)&lt;/span&gt;, der ,unvergleichlich‘ und ,einzigartig‘ ist, und in dem auch alle ,Transzendentalia‘ &lt;span style=&quot;color:#FF6000&quot;&gt;„koinzident“&lt;/span&gt; ,eins‘ sind, entsprechend Axiom-2. 

Für KANT entsteht ein Widerspruch in den Prädikaten eines Satzes.
::&lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt; ''Wenn ich das Prädicat in einem identischen Urtheile aufhebe'', &lt;span style=&quot;color:#00B000&quot;&gt;[ durch eine Negation ]&lt;/span&gt;, ''und behalte das Subject, so entspringt ein Widerspruch''. &lt;span style=&quot;color:#00B000&quot;&gt;[ Wenn ich sage ''':''' ,''GOTT ist nicht allmächtig''‘, entsteht ein Widerspruch zur richtigen Aussage ''':''' ,''GOTT ist allmächtig''‘. ]&lt;/span&gt; … ''Wenn ihr aber sagt ''':''' ,GOTT ist nicht‘, so ist weder die Allmacht, noch irgendein anderes seiner Prädicate gegeben; denn sie sind alle zusammt dem Subjecte aufgehoben'', &lt;span style=&quot;color:#00B000&quot;&gt;[ negiert ]&lt;/span&gt;, ''und es zeigt sich in diesem Gedanken nicht der mindeste Widerspruch.'' &lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;&lt;ref&gt;vgl. ‚''&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;Kritik der reinen Vernunft&lt;/big&gt;&lt;/span&gt;''‘, Seite 398f; https://www.korpora.org/kant/aa03/398.html&lt;/ref&gt;
Es ist richtig, wie KANT sagt, der Widerspruch entsteht nicht in dem Gedanken ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;''GOTT ist nicht''&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;. GÖDEL zeigt daher, dass der Widerspruch erst dann entsteht, wenn von der Annahme ausgegangen wird ''':''' ''&lt;span style=&quot;color:#FF6000&quot;&gt;»&lt;/span&gt;Es ist unmöglich, dass GOTT ist''&lt;span style=&quot;color:#FF6000&quot;&gt;«&lt;/span&gt;. Daraus folgt dann ,regulär‘, mit Hilfe von Axiom-1 und Axiom-2, &lt;span style=&quot;color:#00B000&quot;&gt;(d.h. mit den Theoremen von den Transzendentalien)&lt;/span&gt;, die logische ,Möglichkeit‘ GOTTES, unabhängig von jeder Glaubensüberzeugung. Wie LEIBNIZ klar erkannt hat, muss zuerst, &lt;span style=&quot;color:#00B000&quot;&gt;(mit GÖDEL ''':''' aus dem Widerspruch des Gegenteils)&lt;/span&gt;, die logische ,Möglichkeit‘, &lt;span style=&quot;color:#00B000&quot;&gt;(die Konsistenz)&lt;/span&gt;, der Existenz GOTTES bewiesen werden ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''◇∃xGx'''‘ —&lt;/span&gt;, bevor daraus die reale ,Notwendigkeit‘ GOTTES abgeleitet werden kann ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□∃xGx'''‘ —&lt;/span&gt;, dessen ,Existenz‘ jedoch, aus dem ,Glauben‘, im Voraus, schon angenommen worden ist. Dieser Sachverhalt ist das ausschließliche Spezifikum GOTTES, &lt;span style=&quot;color:#00B000&quot;&gt;(das &lt;span style=&quot;color:#FF6000&quot;&gt;»''Privilegium der Gottheit allein''«&lt;/span&gt;)&lt;/span&gt;, und gilt nur bei GOTT, als dem Unvergleichlichen und Einzigartigen. Dieses ,Spezifikum‘ wird im Theorem ANSELMS abgebildet ''':'''  &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''◇∃xGx→□∃xGx'''‘ —&lt;/span&gt;, auf Grund von Axiom-2, das den inneren Zusammenhang, die Koinzidenz auch von ,Möglichkeit‘ und ,Notwendigkeit‘ im Unendlichen, GOTT, erkennen lässt. Bis Zeile 10, im 3. Beweisgang, reicht der Geltungsbereich der ,modal‘-frei gewählten Kalkül-Prämisse :01:, der ,methodologische‘ GOTT-Glaube. In Zeile 11 liegt der ,Schwerpunkt‘ des ontologischen Beweises dann aber am, — modal als notwendig — ,bewiesenen‘ Widerspruch des Gegenteils zum GOTT-Glauben, &lt;span style=&quot;color:#00B000&quot;&gt; (formal-syntaktisch dargestellt als widerspruchfreies Antezedens, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''◇∃xGx'''‘ —&lt;/span&gt;, dem Möglichkeits-Korollar-1 aus dem 1. Beweisgang)&lt;/span&gt;, und nicht mehr am ,angenommenen‘ GOTT-Glauben der Kalkül-Voraussetzung, &lt;span style=&quot;color:#00B000&quot;&gt;(nun dargestellt als Konsequenz &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□∃xGx'''‘ —&lt;/span&gt; im Theorem ANSELMS)&lt;/span&gt;. Das Möglichkeits-Korollar-1 muss jetzt immer, wie folgt, gelesen werden ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Es ist &lt;u&gt;widerspruchsfrei&lt;/u&gt; möglich, dass GOTT ist''«&lt;/span&gt;. Damit hat GÖDEL, — angeregt durch LEIBNIZ, und mit ihm —, die fast einhellig akzeptierte Fehldeutung des ontologisch-&lt;span style=&quot;color:#4C58FF&quot;&gt;„theologischen“&lt;/span&gt; Arguments ANSELMS für GOTT durch gewichtige philosophische, &lt;span style=&quot;color:#00B000&quot;&gt;(KANT&lt;ref&gt;GOTT ist absolut einzigartig und unvergleichlich. KANT macht GOTT jedoch zu einem ,Ding‘ unter den vielen ,Dingen‘ dieser Welt, indem er die Existenz, bzw. das ,Sein‘ GOTTES mit dem ,Sein der Dinge‘ gleich setzt. Eine solche Gleichsetzung ist bei GOTT unangebracht und daher unzulässig! KANT verkennt damit die Einzigartigkeit und Besonderheit GOTTES. Das ,Sein‘ der Dinge ist, — wie KANT sagt —, kein ,reales Prädikat’, d.h. Existenz ist keine Eigenschaft. Jedoch in GOTT ist ,Sein‘ ein ,reales Prädikat‘, d.h. Existieren ist ,real‘ die Wesenseigenschaft GOTTES, denn GOTT ist der, der für uns, — aus Liebe —, immer schon ,da‘ ist ''':''' in der ,Hypostatischen Union‘, sowohl als GOTT von Ewigkeit zu Ewigkeit, als auch als Mensch in unserer Zeitlichkeit. Das ist das, was GOTT für uns ausmacht —, sein Wesen. Eine ,Theologie‘, die solches sagt, und die, auch als vertrauenswürdige ,Wissenschaft von GOTT‘, akzeptiert wird, hat Interpretations-Vorrang, jedesmal, wenn es um die ,Rede von GOTT‘ geht. Das war für KANT jedoch ,methodologisch‘ weder denkbar, noch nachvollziehbar.&lt;/ref&gt;)&lt;/span&gt;, und &lt;span style=&quot;color:#4C58FF&quot;&gt;„theologische“&lt;/span&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(THOMAS&lt;ref&gt;GOTT ist absolut einzigartig und unvergleichlich. THOMAS unterscheidet die ,Natur GOTTES‘ nicht von der ,Natur der Dinge‘, indem er die ,Natur‘ des GOTTES ANSELMS irrtümlich mit der ,Natur‘ der Dinge gleich setzt. Damit reiht er GOTT unter die vielen Dinge unserer Welt ein, indem er für den GOTT ANSELMS annimmt ''':''' GOTT ,esse in rerum natura‘, d.h. wörtlich, dass der GOTT ANSELMS in der ,Natur‘ der Dinge existiert, &lt;span style=&quot;color:#00B000&quot;&gt;(was ANSELM nie gesagt hat)&lt;/span&gt;. Eine solche Gleichsetzung ist bei GOTT unangebracht und daher unzulässig! Die ,zeitlose-überzeitliche‘ Wirklichkeit, (Natur), GOTTES ist völlig verschieden und unabhängig von der zufälligen Wirklichkeit, (die ,Natur‘), unserer ,raum-zeitlichen‘ Welt. Daher ist sie mit dieser auch nicht vergleichbar. Thomas verkennt damit die Einzigartigkeit und Besonderheit GOTTES.&lt;/ref&gt;)&lt;/span&gt;, Autoritäten zurechtgerückt, welche die Einzigartigkeit und Unvergleichlichkeit des Unendlichen, GOTT, bei ihrer Beurteilung des Theorem ANSELMS nicht berücksichtigt, sondern den Unendlichen, &lt;span style=&quot;color:#00B000&quot;&gt;(irrtümlich)&lt;/span&gt;, unter die endlichen Dinge unserer Welt eingereiht haben. Weder THOMAS, noch KANT, haben verstanden, worum es ANSELM, mit der Aufstellung seines Theorems, eigentlich ging. Beide meinten &lt;span style=&quot;color:#00B000&quot;&gt;(irrtümlich)&lt;/span&gt;, ANSELM wolle mit seinem Theorem die ,Existenz‘ GOTTES ,beweisen‘. Die Existenz GOTTES wurde von ANSELM nie in Frage gestellt. Für ANSELM wäre es rationaler ,Unsinn‘, einen Beweis für die Existenz GOTTES verlangen zu wollen. Mit ,Beweisen‘ wird es niemals möglich sein, einen GOTT-Glauben ,erzeugen‘, bzw. ,lukrieren‘ zu können, &lt;span style=&quot;color:#00B000&quot;&gt;(was man ohnehin weiss, und immer schon gewusst hat; Glaube ist ein Geschenk, das man erhält, wenn man darum bittet)&lt;/span&gt;. Für ANSELM ging es vielmehr um die Frage, ob es logisch ,sinnvoll‘ und ,vernünftig‘ ist, an GOTT zu glauben; und kein ,Sprung‘ ins Ungewisse, d.h. ob &lt;u&gt;der Glaube&lt;/u&gt; rational und ,zweifellos‘ vertrauenswürdig ist, und das heißt auch, ob &lt;span style=&quot;color:#4C58FF&quot;&gt;„Theologie“&lt;/span&gt; ,rational‘ und vertrauenswürdig als Wissenschaft betrieben werden kann. GÖDEL hat mit dem bewiesenen Widerspruch des Gegenteils zum GOTT-Glauben, den Beweis für die &lt;span style=&quot;color:#FF6000&quot;&gt;»''mathematisch-logische Evidenz''«&lt;/span&gt;, und damit auch für die ,Vernünftigkeit‘, bzw. ,Rationalität‘ des Theorem ANSELMS geliefert, was, nach LEIBNIZ, für die Akzeptanz dieses Theorems noch gefehlt hat. Das Theorem ANSELMS besagt universell ''':''' Die &lt;span style=&quot;color:#FF6000&quot;&gt;»''theologische Weltanschauung'', &lt;span style=&quot;color:#00B000&quot;&gt;[ d.h. auch ''':''' der ,GOTT-Glaube‘ ]&lt;/span&gt;«&lt;/span&gt;  der Juden, Christen und Muslime, &lt;span style=&quot;color:#00B000&quot;&gt;(und auch des ägyptischen Pharaos ECHNATON und seiner Frau NOFRETETE)&lt;/span&gt;, die ,annehmen‘, dass es mit ,Notwendigkeit‘ &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□'''‘ —&lt;/span&gt; &lt;span style=&quot;color:#00B000&quot;&gt;(nur)&lt;/span&gt; einen GOTT gibt, ist logisch richtig, ,vernünftig‘, und &lt;span style=&quot;color:#FF6000&quot;&gt;»''mathematisch evident''«&lt;/span&gt;, weil es &lt;u&gt;ohne Widerspruch&lt;/u&gt; ,denkbar‘ &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''◇'''‘ —&lt;/span&gt; ist, dass es GOTT gibt ''':''' Nicht mehr und nicht weniger, &lt;span style=&quot;color:#FF6000&quot;&gt;»''rein verstandesmäßig, (ohne sich auf den Glauben an irgendeine Religion zu stützen)''«&lt;/span&gt;. Das ist auch eine Rechtfertigung der &lt;span style=&quot;color:#4C58FF&quot;&gt;„Theologie“&lt;/span&gt; als seriöse, &lt;span style=&quot;color:#FF6000&quot;&gt;»''rein verstandesmäßige''«&lt;/span&gt; Wissenschaft.

Es geht hier bei GÖDEL nicht um Theoriefindung oder ähnliches. GÖDEL ist kein ,spekulierender‘ Theoretiker. GÖDEL ist Logiker und Mathematiker. Was er sagt, ist mathematisch wahr und logisch richtig. Wenn er sagt, dass die Aussage ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''◇∃xGx'''‘ — »''wahr''«&lt;/span&gt; ist ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''es ist möglich, dass es Gott gibt'' ''':''' ''das ist ,wahr‘ wegen Axiom-2 (und Axiom-1)''«&lt;/span&gt;, dann spricht er hier von der mathematischen Wahrheit. Logischerweise ist dann die konträre Aussage ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''¬◇∃xGx'''‘ — »''falsch''«&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''es ist nicht möglich, dass es einen Gott gibt''«&lt;/span&gt;, und zwar mathematisch falsch, weil sich aus dieser Aussage ein Widerspruch ergibt. Jeder, der die mathematische Logik GÖDELS lesen kann, kann das sehen und verstehen ''':''' Das Zwischenergebnis, &lt;span style=&quot;color:#00B000&quot;&gt;(Term :20:)&lt;/span&gt;, in dieser Kalkül-Ableitung, die logische Konsequenz aus der Annahme des dezidierten Atheismus, es sei unmöglich, dass es GOTT gibt, ist der faktische, nachprüfbare, und für jeden Menschen sichtbare Beweis dafür, dass diese Annahme in einen Widerspruch mündet, und damit falsch und unlogisch ist. Das bedeutet, es ist eine Tatsache, bzw. es ist ein allgemein gültiges Faktum unserer Welt, dass der Atheismus, — mit &lt;span style=&quot;color:#FF6000&quot;&gt;»''mathematisch-logischer Evidenz''«&lt;/span&gt; —, wirklich falsch und rational unsinnig ist, und daher, mit Recht, als ,Unsinn‘ bezeichnet werden darf '''!''' Das ist nicht bloß als eine Theoriefindung, oder als eine Interpretation eines Autors zu verstehen. Das ist vielmehr genau so wahr und &lt;span style=&quot;color:#FF6000&quot;&gt;»''mathematisch evident''«&lt;/span&gt;, wie, dass zwei mal zwei vier ergibt, und wirklich genau so logisch richtig, wie, dass die Erde sich um die Sonne dreht. Das ist gerade das Überraschende und Unerwartete am Gödel-Kalkül. Es geht hier nicht mehr um Theoriefindung oder Interpretationen, denen man zustimmen kann oder nicht. Es geht hier &lt;span style=&quot;color:#FF6000&quot;&gt;»''rein verstandesmäßig''«&lt;/span&gt; um mathematisch-logische Fakten. Damit steht GÖDEL, in seiner Bedeutung, in gewisser Weise, neben KOPERNIKUS, weil seine Kalkül-Ergebnisse, wie die Berechnungs-Ergebnisse dieses Pioniers der damaligen Zeitenwende, heute, in unserem Äon, ebenfalls mit eingefleischte Vorurteile aufräumen, ohne aber, dass GÖDEL für sich selbst, im Glauben, logisch konsequent gewesen wäre. &lt;span style=&quot;color:#00B000&quot;&gt;(Er ist sich der Tragweite und der Konsequenzen seiner &lt;span style=&quot;color:#4C58FF&quot;&gt;„axiomatischen Theologie“&lt;/span&gt; anscheinend nicht bewusst gewesen, wenn er sagt ''':''' Man sei &lt;span style=&quot;color:#FF6000&quot;&gt;»''heute noch weit davon entfernt, das theologische Weltbild wissenschaftlich begründen zu können''«&lt;/span&gt;, nachdem sein Kalkül das &lt;span style=&quot;color:#FF6000&quot;&gt;„atheistische Weltbild“&lt;/span&gt; fundamental ins Wanken gebracht und als irrationalen ,Unsinn‘ entlarvt hat. Sein Kalkül ,beweist‘ ( ╞ ) indirekt, dass das &lt;span style=&quot;color:#FF6000&quot;&gt;»''theologische Weltbild''«&lt;/span&gt;, im Beweisgang ,Widerlegung‘, aus dem Widerspruch des Gegenteils, mit &lt;span style=&quot;color:#FF6000&quot;&gt;»''mathematisch-logischer Evidenz''«&lt;/span&gt;, offensichtlich doch, wissenschaftlich begründet werden kann)&lt;/span&gt;.

----
 Kurt GÖDEL ist auch deswegen ein Ausnahmelogiker.
----


===&lt;div class=&quot;center&quot;&gt;&lt;span style=&quot;color:#660066&quot;&gt;Epilog für Skeptiker&lt;/span&gt;&lt;/div&gt;===

Wenn man das GÖDEL-Argument genau liest, dann ist nur die Annahme ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt; „es ist möglich, dass es GOTT gibt“&lt;/span&gt; bewiesen, weil aus der Annahme ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;„es ist unmöglich, dass es GOTT gibt“&lt;/span&gt; ein logischer Widerspruch ableitbar ist. Die Aussage ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;„es gibt GOTT“&lt;/span&gt; ist dagegen schon eine Glaubensaussage, und damit ist das auch die ,Grundannahme‘ eines gläubigen Menschen, der dann aus der ,bewiesenen Möglichkeit‘, dass es Gott gibt, ableiten kann ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''es gibt GOTT wirklich''«&lt;/span&gt;, wenn er will ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''Es stimmt also, was ich glaube '''!''''' «&lt;/span&gt; Das ist das Argument ANSELMS, der ein christlicher Amtsträger war, und der daher von dieser Grundannahme auch ausgeht. Solange in den Voraussetzungen des Möglichkeitsbeweises im GÖDEL-Kalkül kein Widerspruch nachweisbar ist, und solange in der logischen Durchführung dieses Beweises keine schweren Mängel festgestellt werden können, ist das Ergebnis des Möglichkeitsbeweises, wie GÖDEL ihn durchgeführt hat, korrekt, und die Folgerungen daraus, logisch richtig, dass es sich hier um &lt;span style=&quot;color:#FF6000&quot;&gt;»''mathematische Evidenz''«&lt;/span&gt; handelt, &lt;span style=&quot;color:#00B000&quot;&gt;(z. B. wie 2 x 2 = 4)&lt;/span&gt;. Aber niemand ist gezwungen, aus der Möglichkeit, dass es GOTT gibt, daraus zu schließen, dass es GOTT auch mit Notwendigkeit gibt, wie das im Argument ANSELMS geschieht, außer, er akzeptiert auch die Grundannahme, dass es den Unendlichen und Unvergleichlichen tatsächlich gibt. Dann kann er mit LEIBNIZ, der selbst an GOTT geglaubt hat, mit Bestimmtheit sagen ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''gesetzt, dass GOTT möglich ist, so ist er, was das Privilegium der Gottheit allein ist''«&lt;/span&gt;, weil GÖDEL mit seinem Kalkül den noch ausstehenden Beweis der Widerspruchsfreiheit dafür geliefert hat.

Wenn Du den 3. Beweisgang des GÖDEL-Kalküls genauer anschaust, dann siehst Du, dass der Konsequenz-Teil im Argument ANSELMS ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''◇∃xGx→□∃xGx'''‘ —&lt;/span&gt;, der identisch ist mit dem Term in der Zeile 10, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''□∃xGx'''‘ —&lt;/span&gt;, immer noch logisch, &lt;span style=&quot;color:#00B000&quot;&gt;(jedoch nicht syntaktisch)&lt;/span&gt;, abhängig ist von der methodologischen Glaubens-Prämisse, Term :01:, &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''das'' &lt;span style=&quot;color:#4C58FF&quot;&gt;‚'''x'''‘&lt;/span&gt; ''steht für den Gott der Christen''«&lt;/span&gt;. Diese Abhängigkeit ist bis zur Zeile 10 offensichtlich und logisch korrekt. &lt;span style=&quot;color:#00B000&quot;&gt;(Man könnte nach dieser Zeile, ohne Weiteres, ,regulär‘ die &lt;span style=&quot;color:#FF6000&quot;&gt;„logische Implikation”&lt;/span&gt; :: &lt;span style=&quot;color:#4C58FF&quot;&gt;[├ A ├ B ╞ A→B ]&lt;/span&gt; mit Term :01: und  Term :10: als ein mögliches Korollar bilden ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''Gx→□∃xGx'''‘ — &lt;/span&gt;)&lt;/span&gt;.  Das bedeutet, der Konsequenz-Teil im Theorem ANSELMS, der in diesem ,regulär‘-möglichen Korollar an zweiter Stelle steht, ist damit in seiner Formal-Struktur offensichtlich ,regulär‘ von der Glaubens-Prämisse, Term :01:, abhängig, d.h. er ist der Ausdruck einer Glaubensüberzeugung, als 1. Hauptergebnis. Damit ist syntaktisch bewiesen, die Existenz GOTTES ist die ,notwendige‘ &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚□‘ —&lt;/span&gt; Konsequenz aus dem ,methodologischen‘ Glauben im Term :01:. Im Theorem ANSELMS steht dieses 1. Hauptergebnis nun, in der Zeile 11, als Konsequenz-Teil, auch an zweiter Stelle, hat aber nicht mehr seine Glaubens-Prämisse, als seine ,notwendige‘ Bedingung, an erster Stelle vor sich, die seinen Inhalt bestätigt, wie vorhin, im ,regulär‘-möglichen Korollar. Jetzt steht eine neue und andere Voraussetzung als syntaktische Begründung vor ihm. Der Schwerpunkt des Argument ANSELMS liegt damit am Begründungs-Teil des ANSELM-Theorems, der jetzt die erste Stelle im Theorem einnimmt ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''◇∃xGx'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''es ist möglich, dass es GOTT gibt''«&lt;/span&gt;, der erst dadurch entstanden ist, und davon abhängig ist, weil sein Gegenteil ''':''' &lt;span style=&quot;color:#4C58FF&quot;&gt;— ‚'''¬◇∃xGx'''‘ —&lt;/span&gt; ''':''' &lt;span style=&quot;color:#FF6000&quot;&gt;»''es ist unmöglich, dass es GOTT gibt''«&lt;/span&gt;, zu einem Widerspruch geführt hat. Dieser Begründungs-Teil, das Antezedens, im Argument ANSELMS, ist daher nicht mehr von der ,methodologischen‘ Glaubens-Prämisse, Term :01:, abhängig, sondern nur vom Axiom-1, der Widerspruchsfreiheit, und von der paarweisen, mathematischen Äquivalenz beliebiger positiver Eigenschaften im Axiom-2, die im 1. Beweisgang, bzw. im Beweisgang ,Widerlegung‘, mit dem  &lt;span style=&quot;color:#4C58FF&quot;&gt;[ Modus tollendo tollens ] :: [ A → B, ¬B ├ ¬A ]&lt;/span&gt;, die Widerspruchsfreiheit der Möglichkeit des GOTT-Glaubens mit Notwendigkeit herbeigeführt haben. Daraus ergibt sich eine logische Verschiebung in der Argumentationskette, denn dieser Begründungs-Teil, der jetzt die Widerspruchsfreiheit für den Konsequenz-Teil liefert, ist selbst unabhängig und frei von jeder Glaubensüberzeugung. Weil widerspruchsfrei und &lt;span style=&quot;color:#FF6000&quot;&gt;»''mathematisch evident''«&lt;/span&gt; und frei von jeder Glaubensüberzeugung, muss er als rein logische Begründung für die Widerspruchsfreiheit, und als Beweis für die &lt;span style=&quot;color:#FF6000&quot;&gt;»''mathematische Evidenz''«&lt;/span&gt; des Konsequenz-Teils gelesen werden, und damit bestätigt er die Widerspruchsfreiheit und Sinnhaftigkeit der Glaubensüberzeugung eines gläubigen Menschen, &lt;span style=&quot;color:#00B000&quot;&gt;(was auch das Ziel ANSELMS war)&lt;/span&gt;. Das Antezedens im Argument ANSELMS kann jedoch nie die persönliche Entscheidung zum Glauben, z. B. an den GOTT der Christen, im Menschen ersetzen. Das Argument ANSELMS besagt also ''':''' der Glaube eines gläubigen Menschen ist logisch widerspruchsfrei und sinnvoll, und enthält keinen Zirkelschluss, weil sein Gegenteil, der Nicht-GOTT-Glaube, zu einem Widerspruch führt; &lt;span style=&quot;color:#00B000&quot;&gt;(das hat GÖDEL mit seinem Kalkül-System bewiesen, dessen Argumentationskette mit einem Computer-Programm, dem sog. ,Theorembeweiser‘, überprüft worden ist, und als &lt;span style=&quot;color:#FF6000&quot;&gt;»''nachweisbar korrekt''«&lt;/span&gt; befunden wurde)&lt;/span&gt;. Das Theorem ANSELMS beweist, nach GÖDEL, dass der Glaube an GOTT, mit &lt;span style=&quot;color:#FF6000&quot;&gt;»''mathematische Evidenz''«&lt;/span&gt; notwendig widerspruchsfrei und sinnvoll ist, weil der Nicht-GOTT-Glaube notwendig zu einem Widerspruch führt. &lt;u&gt;Das Theorem beweist jedoch nicht, dass die Existenz GOTTES notwendig ist&lt;/u&gt;, &lt;span style=&quot;color:#00B000&quot;&gt;(wie es fast immer fälschlich gelesen wurde und wird; auch von A. FUHRMANN, wie auch von G. J. WIRSCHING)&lt;/span&gt;, sondern, das Theorem ANSELMS geht davon aus, als nicht hinterfragtes Faktum des GOTT-Glaubens, dass GOTT notwendig, schon immer existiert, &lt;span style=&quot;color:#00B000&quot;&gt;(was mit dem 1. Hauptergebnis im 3. Beweisgang noch einmal bestätigt wird)&lt;/span&gt;. Die ,Notwendigkeit‘ GOTTES ist immer schon eine ,vorgängig‘ entschiedene Glaubensaussage. Das GÖDEL-Kalkül beweist, &lt;span style=&quot;color:#00B000&quot;&gt;(mit dem Antezedens im 2. Hauptergebnis)&lt;/span&gt;, dass diese Grundüberzeugung des GOTT-Glaubens widerspruchsfrei und sinnvoll, und &lt;span style=&quot;color:#FF6000&quot;&gt;»''mit allen bekannten Tatsachen durchaus vereinbar ist''«&lt;/span&gt;, wie GÖDEL abschließend sagt. GOTT hat es ja auch nicht ,nötig‘, bewiesen zu werden. Für den Erzbischof ANSELM war die Existenz GOTTES, überall und jederzeit, die ungefragte und für ihn die selbstverständlichste Voraussetzung aller seiner Bemühungen, in seinem Leben, und in seinem Beruf als christlicher Amtsträger, und auch als &lt;span style=&quot;color:#4C58FF&quot;&gt;„Theologe“&lt;/span&gt; in den philosophischen Überlegungen über seinen Glauben. Mit diesen Überlegungen hat er, mit GÖDEL, bewiesen ''':''' Glaube ist nicht irrational, kein Sprung ins Unbekannte, sondern eine freie, vernünftige Entscheidung. Glaube ist rational, und seine &lt;span style=&quot;color:#4C58FF&quot;&gt;„Theologie“&lt;/span&gt; ist ,vertrauenswürdig‘.

Zusammengefasst heißt das Ergebnis dieser Bemühungen ANSELMS ''':''' Wenn Du an GOTT glauben willst, dann kannst Du das unbedenklich tun, denn Dein Glaube ist auch logisch in der &lt;u&gt;bewiesenen Möglichkeit&lt;/u&gt;, dass es GOTT geben kann, begründet, und damit ist er widerspruchsfrei, sinnvoll und kein Zirkelschluss. Dein Glaube an GOTT beruht jedoch, nach wie vor und in erster Linie, auf Deiner freien Entscheidung für GOTT, und nicht auf dem Zwang einer ,logischen‘ Argumentation. Wenn Du nicht an GOTT glauben willst, dann &lt;u&gt;musst Du, und sollst Du, auch nicht deswegen&lt;/u&gt; an GOTT glauben, weil der Nicht-GOTT-Glaube zu einem Widerspruch führt, und damit falsch und unlogisch ist. Denn der Glaube an GOTT muss immer eine freie und Deine ganz persönliche Entscheidung für GOTT sein und bleiben. Niemand darf zum Glauben an GOTT gezwungen werden, auch nicht mit ,logischen‘ Argumenten. Warum '''?''' Weil GOTT die Liebe ist '''!''' Und die Liebe duldet keinen Zwang '''!'''

Zum Abschluss, und für eine bessere Verständlichkeit dieser Studie, hat die KI, der ich diese Studie für die Erstellung eines Podcast übergeben habe, eine, — sogar für Kinder —, verständliche Metapher kreiert. Sie sagt, man stelle sich vor ''':''' Es sei irgendwo ein ,Schatz’ vergraben, und es gäbe auch eine ,Schatzkarte’ für diesen ,Schatz’. Kurt GÖDEL ist nun gekommen, und hat mit seinem Kalkül bewiesen, dass diese ,Schatzkarte’ korrekt ist und fehlerfrei. Ob aber jemand, mit Hilfe dieser ,Schatzkarte’ auf ,Schatzsuche’ gehen will oder nicht ''':''' das ist und bleibt jedem selbst überlassen, und ist immer eine freie, und ganz persönliche Entscheidung. Damit hat die KI erstaunlich treffend, sowohl die Bedeutung, als auch die reale Funktion des GOTT-Glaubens in der Lebens-Wirklichkeit unserer Welt und Zeit charakterisiert, in Übereinstimmung mit der Gleichniserzählung JESU vom ,Schatz im Acker’; &lt;small&gt;&lt;span style=&quot;color:#00B000&quot;&gt;( vgl. {{Bibel | Matthäus-Evangelium |13|44|EU}} )&lt;/span&gt;&lt;/small&gt;. Der ,Schatz’ ist die &lt;span style=&quot;color:#FF6000&quot;&gt;„&lt;span style=&quot;font-family: Times;&quot;&gt;&lt;big&gt;Βασιλεία του Θεού&lt;/big&gt;&lt;/span&gt;“&lt;/span&gt;&lt;span style=&quot;color:#00B000&quot;&gt; | ,Basileía tou Theoú’&lt;/span&gt;, d.h. das &lt;span style=&quot;color:#CC66FF&quot;&gt;»''Königtum GOTTES''«&lt;/span&gt;, oder auch das &lt;span style=&quot;color:#CC66FF&quot;&gt;»''Himmelreich''«&lt;/span&gt;. Die ,Schatzkarte’ ist der Glaube an GOTT. Die ,Schatzsuche’ ist der Weg des Glaubens in der Nachfolge JESU, der uns den Weg zeigt zum Ziel, zur Erfüllung aller unserer Sehnsüchte und Wünsche ''':''' zur Teilhabe am &lt;span style=&quot;color:#CC66FF&quot;&gt;»''Königtum GOTTES''«&lt;/span&gt;.

----


----
;Fußnoten
&lt;references /&gt;</text>
      <sha1>mkn3w8o3mr2vd6sxq6b9xgbr3123bbb</sha1>
    </revision>
  </page>
  <page>
    <title>Ing Mathematik: Python</title>
    <ns>0</ns>
    <id>117969</id>
    <revision>
      <id>1092165</id>
      <parentid>1092094</parentid>
      <timestamp>2026-10-16T13:10:24Z</timestamp>
      <contributor>
        <username>Intruder</username>
        <id>1513</id>
      </contributor>
      <comment>/* Allgemeines */</comment>
      <origin>1092165</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="189222" sha1="hw5cfwefetrmz40yszan87oq12zpua0" xml:space="preserve">{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}


= Hallo Welt und allgemeine Hinweise =
== Was ist Python ==
* Python ist eine universelle höhere Programmiersprache.
* Python ist objektorientiert.
* Python ist Open-Source (Python Software Foundation License).
* Python ist für viele Betriebssysteme erhältlich (z.B. für Linux, MS Windows, macOS).
* Python ist ein Interpreter.
* Python ist durch Module fast beliebig erweiterbar.
* Python als Programmiersprache ist case-sensitive - d.h. Groß- und Kleinschreibung ist relevant bei der Eingabe von Befehlen.
* Python ist in etlichen Anwendungsprogrammen (z.B. {{W|FreeCAD}}, {{W|LibreOffice}}, {{W|GIMP}}, {{W|Blender (Software) | Blender}}) als Makrosprache verwendbar.

{{Wikipedia | Python (Programmiersprache)}}

== Python installieren ==
=== MS Windows ===
Laden Sie das aktuelle Python-Paket von der Webseite [https://www.python.org/] herunter. Weiter geht es wie bei jedem anderen größeren zu installierenden Programm. Einfach das Installationsprogramm im Explorer doppelklicken und den Anweisungen des Setup-Programmes folgen.

=== Linux ===
Entweder ist Python bereits standardmäßig installiert, ansonsten ist die Installation mittels Paketmanagementsystem einfach möglich. Aber auch die Spyder-Entwicklungsumgebung ([https://www.spyder-ide.org]) bietet einen guten Einstieg mit Python (das gilt auch für MS Windows). Spyder bringt auch schon etliche wichtige Module standardmäßig mit.

== Python starten ==
=== MS Windows ===
Das Icon für das Python-Programm doppelklicken. Und schon startet das Programm.

[[Datei:PythonIng_start1.jpg]]

Python im interaktiven Modus präsentiert sich dann so:

 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

Alternativ kann das Programm auch über die Eingabeaufforderung oder die PowerShell gestartet werden:

 c:\devel\Python&gt;python.exe
 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

=== Linux ===
Tippen Sie einfach das Wort „python“ (oder unter openSUSE Tumbleweed z.B. auch „python3.11“ oder „python3.13“) in einem Linux-Terminal ein, schließen den Befehl mit der RETURN-Taste ab, und schon startet Python im interaktiven Modus:
 
 Python 3.13.12 (main, Feb 09 2026, 22:37:44) [GCC] on linux
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt; 

Es gibt auch noch andere Möglichkeiten Python zwecks Programmausführung zu starten, z.&amp;nbsp;B. den {{W|Shebang}} (&lt;code&gt;#!&lt;/code&gt;) am Beginn eines Python-Scripts. Das Script sei als Script.py gespeichert. Dann kann das Script mit ./Script.py ausgeführt werden. Für openSUSE Tumbleweed sei nachfolgend ein lauffähiges &quot;Hallo Welt!&quot;-Script angegeben. Es wird in diesem Script der Python-Interpreter in der Version 3.13 verwendet :

 #!/usr/bin/python3.13
 print(&quot;Hallo Welt!&quot;)

Die Berechtigungen zum Ausführen der Datei müssen natürlich noch richtig gesetzt werden, z.B. mittels &lt;code&gt;chmod 777 Script.py&lt;/code&gt;. &lt;small&gt;&lt;code&gt;chmod&lt;/code&gt; ist die Abkürzung für&quot;'''ch'''ange file '''mod'''e bits&quot;.&lt;/small&gt; 

&lt;small&gt;Die &quot;Maske&quot; &lt;code&gt;777&lt;/code&gt; ist nur für Testzwecke sinnvoll, weil sie leicht zu merken ist und für alle Benutzer alle Zugriffsberechtigungen ('''r'''ead/'''w'''rite/e'''x'''ecute für owner/group/others) setzt. Im richtigen Einsatz wird man das aus Sicherheitsgründen nicht so handhaben, sondern nur die Berechtigungen setzen, die unbedingt erforderlich sind. Welche Zugriffsberechtigungen gesetzt sind, kann man z.B. mit dem Befehl &lt;code&gt;ls -l&lt;/code&gt; oder &lt;code&gt;ll&lt;/code&gt; ('''l'''i'''s'''t directory contents) erfragen. Aber dazu im Moment genug. Erfahrene Linux-Nutzer kennen das ohnehin und Anfänger sollen jetzt nicht mit Linux-Interna überfordert werden. Bei Bedarf siehe die Linux-Man-Pages oder dezidierte Bücher zu Linux.&lt;/code&gt;&lt;/small&gt;

&lt;small&gt;Oder das Script wird in einen Pfad verschoben, in dem sich ausführbare Programme generell befinden (welche Verzeichnisse im PATH liegen, kann bspw. mit &lt;code&gt;echo $PATH&lt;/code&gt; abgefragt werden). Das Script kann dann wie ein normales Programm ohne weitere Angaben mit Script.py gestartet werden. Alternativ wird nicht das Script an sich verschoben, sondern nur ein symbolischer Link angelegt, z.B. mit &lt;code&gt;ln -s ~/tmp/Script.py ~/.local/bin/Script.py&lt;/code&gt;. &lt;code&gt;~/.local/bin&lt;/code&gt; sei ein im PATH gelegenes Verzeichnis. Dies sind aber schon Features für fortgeschrittene Linux-Benutzer und werden am Anfang eher selten benötigt.&lt;/small&gt;

== Ein paar Worte zur Erklärung ==
=== Tests ===
Getestet wurden die Beispiele unter den Betriebssystemen 
* MS Windows 10 mit der Python-Version 3.12.0 (teilweise auch mit 3.12.2 und 3.13.1; nur die Inhalte die bis spätestens Juli 2025 erstellt wurden) 
* MS Windows 11 ab der Python-Version 3.13.4 (nur zum Teil; ab Juli 2025)
* openSUSE Leap 15.6 mit der Python-Version 3.11.12 (Spyder, nur vereinzelt) und zum Teil mit 3.12.11 (ab Juli 2025 bis November 2025).
* openSUSE Tumbleweed ab der Python-Version 3.13.9 (nur vereinzelt, ab November 2025)

=== Popularität ===
* An Beliebtheit rangiert Python mit Stand September 2026 mit einem Rating von 17,76% an 1. Stelle vor C und C++ (lt. [https://www.tiobe.com/tiobe-index/ TPCI - TIOBE Programming Community Index]). 
* Lt. [https://innovationgraph.github.com/global-metrics/programming-languages GitHub Top 50 Programming Languages Globally] lag Python im Q1/2026 auf Rang 2, vor TypeScript und hinter JavaScript. 
* [https://pypl.github.io/PYPL.html PYPL] (Popularity of Programming Language Index) ist ein anderer Popularitätsindex für Programmiersprachen. Auch hier liegt Python mit großem Vorsprung auf dem ersten Platz (52,08%), gefolgt von Java (13,34%) und C/C++ (7,99%) (Stand September 2026). 

=== Namensgebung ===
Der Name &quot;Python&quot; rührt von der Komikertruppe {{W|Monty Python}} her. Die Icons für Python (z.B. Python selbst, Eric IDE, IDLE) sind aber durch die Python-Schlangenart symbolisiert.

&lt;gallery&gt;
Python-logo-notext.svg|Python-Logo
Guido van Rossum in PyConUS24.jpg|{{W|Guido van Rossum}} (geb. 1956), der Erfinder von Python
&lt;/gallery&gt;

== Ein erstes Programm ==
Kommentare werden in Python mit der Raute (#) eingeleitet. Sie werden vom Python-Interpreter ignoriert. Text kann mit der print-Funktion ausgegeben werden. Starten Sie Python und geben sie folgende Anweisungen zeilenweise ein

 &gt;&gt;&gt; # Das ist ein Kommentar
 &gt;&gt;&gt; print(&quot;Hallo Welt!&quot;)

Als Ergebnis erhalten Sie

 Hallo Welt!

Der Prompt (&gt;&gt;&gt;) ist selbstverständlich nicht einzutippen, sondern wird vom Python-System geliefert.

Strings können in Python entweder in Anführungszeichen (&quot;) gesetzt werden oder in Hochkommatas('). In diesem Text wird die erste Variante bevorzugt eingesetzt.

Im Gegensatz zu Julia ist es hier egal, ob zwischen &lt;code&gt;print&lt;/code&gt; und der öffnenden Klammer Leerzeichen stehen.

= Python als Taschenrechner =
== Allgemeines ==
Wir wollen 3 * 5 berechnen. Dazu starten wir Python im interaktiven Modus. Geben Sie dann die Formel  

 &gt;&gt;&gt; 3 * 5

ein, drücken die Taste ENTER/RETURN ({{Taste|↵}}) und erhalten als Ergebnis

 15

Auch kompliziertere Ausdrücke sind möglich. Beispielsweise mit Winkelfunktionen, Quadratwurzeln etc. Wir wollen nun den Ausdruck &lt;math&gt;\sin\sqrt{15}&lt;/math&gt; berechnen :

 &gt;&gt;&gt; import math
 &gt;&gt;&gt; math.sin(math.sqrt(15))
 -0.6679052983383519

Als erstes wird das math-Modul importiert. Dann wird der mathematische Ausdruck berechnet.

Eine andere Variante, die dasselbe Ergebnis liefert, ist

 &gt;&gt;&gt; from math import *
 &gt;&gt;&gt; sin(sqrt(15))
 -0.6679052983383519

Es wird also aus dem Modul &lt;code&gt;math&lt;/code&gt; alles importiert (erkennbar am &lt;code&gt;*&lt;/code&gt;). Will man nicht alles importieren, so kann man das auch einschränken:

 &gt;&gt;&gt; from math import sin, sqrt

Beenden lässt sich das Python-Programm durch Eingabe von &lt;code&gt;exit()&lt;/code&gt; (und natürlich ist zur Bestätigung die RETURN-Taste zu drücken). &lt;code&gt;exit&lt;/code&gt; (ohne Klammern) oder &lt;code&gt;quit&lt;/code&gt; werden auch akzeptiert.

== Die Hilfefunktion von Python ==
Bei Eingabe der Anweisung &lt;code&gt;help&lt;/code&gt; oder &lt;code&gt;help()&lt;/code&gt; springt Python in den Hilfemodus. 

Eingabe:
 &gt;&gt;&gt; help()
 
Eingabe:
 help&gt; math.sin

Ausgabe:
 Help on built-in function sin in math:
 
 math.sin = sin(x, /)
     Return the sine of x (measured in radians).

Für die komplette Python-Dokumentation siehe [https://docs.python.org/3/]. Verlassen kann man den Hilfemodus durch das Drücken von STRG-C, bzw. der Eingabe von q, quit oder exit mit anschließendem Drücken der RETURN-Taste.

== Aufgaben ==
* Erkunden Sie die Tangensfunktion &quot;tan&quot; mittels Python-Hilfe (vergessen Sie nicht das math-Modul zu importieren und das &lt;code&gt;math.&lt;/code&gt; vor &lt;code&gt;tan&lt;/code&gt;)
* Berechnen Sie mit Python den Ausdruck &lt;math&gt;\frac{1}{2}\cdot \text{e}^2 \cdot \tan(\pi/3)&lt;/math&gt;. Siehe für die Exponentialfunktion im Python-Hilfesystem auch den Befehl &lt;code&gt;math.exp&lt;/code&gt;. Alternativ kann auch die Konstante &lt;code&gt;math.e&lt;/code&gt; eingesetzt werden. Potenzieren kann man bei Python mit dem **-Operator (z.B. 2**3 = 8). Für &lt;math&gt;\pi&lt;/math&gt; gibt es &lt;code&gt;math.pi&lt;/code&gt;.

= Python als Scriptsprache =
Häufig wird man aber kompliziertere Anweisungsfolgen verarbeiten müssen. Diese will man normalerweise nicht jedesmal neu eingeben, sondern in einer Datei speichern und diese Datei dann zur Ausführung bringen. Speichern Sie dazu folgenden Code in einer Textdatei, z.B. unter MS Windows als c:\tmp\test1.py

 # Das ist ein Kommentar
 print(&quot;Hallo Welt!&quot;)

Python-Dateien werden mit der Dateiendung .py versehen. Achten Sie darauf, dass vor dem print keine Leerzeichen vorhanden sind. Das ist eine Python-Eigenheit. Wie wir später sehen werden, nutzt Python Einrückungen als syntaktisches Mittel, z.B. um bei Schleifen den Schleifenkörper zu kennzeichnen. 

Danach bringen Sie die Skriptdatei test1.py (sozusagen das Hauptprogramm) folgendermaßen zur Ausführung:

1) Starten Sie unter MS Windows die Eingabeaufforderung (oder alternativ auch die Windows PowerShell). Das sieht dann etwa so aus:

 Microsoft Windows [Version 10.0.19045.3693]
 (c) Microsoft Corporation. Alle Rechte vorbehalten.
 
 C:\Users\xyz&gt;

: &lt;small&gt;Falls jemand nicht weiß, wie man die Eingabeaufforderung startet: Eine Möglichkeit ist, einfach in der Taskleiste von Windows das &quot;Start&quot;-Symbol &amp;nbsp;([[Image:Windows_logo_-_2021_(Black).svg|10px]])&amp;nbsp; mit der rechten Maustaste anklicken. &quot;Ausführen&quot; auswählen (oder alternativ für die PowerShell unter Windows 10 den Eintrag &quot;Windows PowerShell&quot;, unter Windows 11 den Eintrag &quot;Terminal&quot;). Im sich öffnenden Dialogfenster gibt man in die &quot;Öffnen&quot;-Zeile das Wort &lt;code&gt;cmd&lt;/code&gt; ein und mit &quot;OK&quot; wird das Ganze bestätigt.&lt;/small&gt; 
 
2) Wechseln Sie mittels &lt;code&gt;cd c:\tmp&lt;/code&gt; in das Verzeichnis c:\tmp

3) Angenommen, Sie haben Python unter dem Pfad &lt;code&gt;c:\devel\Python\&lt;/code&gt; installiert. Starten Sie das Programm so (der Prompt &lt;code&gt;c:\tmp&gt;&lt;/code&gt;ist natürlich nicht mit einzutippen): 

 c:\tmp&gt;c:\devel\Python\python.exe test1.py

4) Wie erwartet ergibt sich folgende Ausgabe am Bildschirm

 Hallo Welt!

Die Vorgehensweise unter Linux ist prinzipiell gleich. Die kleinen Unterschiede, wie z.B. der Slash statt dem Backslash in Pfadangaben, sollten für Linux-Benutzer keine Hürde darstellen.

== Variablen ==
Variablenbezeichner können aus Buchstaben (A-Za-z), Ziffern (0-9) und Underscores (_) bestehen, dürfen aber nicht mit einer Zahl beginnen. Führende Underscores haben u.a. im Kontext mit der Objektorientierten Programmierung eine spezielle Bedeutung und sollten nicht für &quot;normale&quot; Variablenbezeichner verwendet werden.

Gültige Variablenbezeichner wären also:
 xyz
 x1
 _wert
 name_anzahl

Theoretisch kann man auch Umlaute, griechische Buchstaben u.ä. in Variablenbezeichnern nutzen, z.B.

 ößÜ = 16
 α = 134 
 print(ößÜ)
 print(α)

Ausgabe:
 16
 134

Davon wird aber aus offensichtlichen Gründen ({{W|Englisch als Lingua franca}}) abgeraten. Das Eurozeichen (€) etc. darf man ohnehin nicht in Variablenbezeichnern verwenden, dies ergäbe einen Syntaxfehler. Siehe dazu auch [https://peps.python.org/pep-3131/].

Es gibt in Python etliche Schlüsselwörter (z.B. for, if oder return). Diese dürfen nicht als eigene Variablenbezeichner verwendet werden. Eine Liste aller Schlüsselwörter liefert das Script

 import keyword
 print(keyword.kwlist)

&lt;small&gt;Übung: Speichern Sie dieses Script in eine Datei, z.B. in c:\tmp\test1.py. Führen Sie diese Datei aus, um die Liste der Schlüsselwörter auszugeben.&lt;/small&gt;

Da Python case-sensitiv ist, repräsentieren folgende Bezeichner verschiedene Variablen:
 xyz
 XYZ
 xYz

Werte werden an Variablen mittels Gleich-Zeichen (=) zugewiesen. Im Folgenden wird der Code immer in der Datei c:\tmp\test1.py gespeichert.

 x = 5
 y = 10
 z = x*y
 print(z)

Bringen Sie die Datei test1.py zur Ausführung, so erhalten Sie folgende Bildschirmausgabe

 50

Sie können auch mehrere Anweisungen in einer Zeile durch Semikolon getrennt schreiben. Dies führt aber zu unübersichtlichem Code.

 x = 5; y = 10; z = x*y; print(z)

Ausgabe:
 50

Auch aus der Programmiersprache C/C++ oder Java bekannte Konstrukte können Sie verwenden, z.B.
 x = 5
 # x = x - 2
 x -= 2
 print(x)

Bildschirmausgabe:

 3
 
Beachten Sie, dass mit dem =-Zeichen eine Wertezuweisung durchgeführt wird. Dies ist nicht äquivalent zum mathematischen =-Zeichen, wie am vorigen Beispiel zu ersehen ist. Den Inkrement-/Dekrementoperator (z.B. x++ oder x--) aus C/C++ oder Java kennt Python aber nicht.

Variablen sind nicht an einen bestimmten Datentyp gebunden, folgendes ist mit Python problemlos möglich:

 import math
 wert = 10
 print(wert)
 wert = 35.5
 print(wert)
 wert = &quot;Hallo&quot;
 print(wert)
 wert = math.pi
 print(wert)

Ausgabe:
 10
 35.5
 Hallo
 3.141592653589793

== Physische und logische Zeilen ==
In Python muss eine Anweisung in einer logischen Zeile Platz finden. Wird eine Anweisung aber zu lang für eine Zeile, dann kann sie in mehrere physische Zeilen unterteilt werden. Dies kann einerseits durch einen Backslash am Ende einer Zeile geschehen, z.B.

 a = 2 + \
 5
 
Dies stellt eine logische Zeile dar, die in zwei physische Zeilen unterbrochen ist.

Geklammerte Ausdrücke werden automatisch zu einer logischen Zeile verbunden, z.B.

 a = (2 + 
 5)
 
Achtung: Im ersten Beispiel darf nach dem Backslash nichts mehr stehen, auch kein Kommentar. Dies trifft im zweiten Bespiel nicht zu, hier könnte noch ein Kommentar folgen, z.B.

 a = (2 +    # Kommentar 
 5)

Auch für Strings gibt es Möglichkeiten, diese auf mehrere Zeilen aufzuspalten.

 # Kurzer String
 str1 = &quot;ABC&quot;
 
 # Langer String
 str2 = &quot;&quot;&quot;Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle&quot;&quot;&quot;
 
 # Backslash
 str3 = &quot;UVW\
 XYZ&quot;
 
 # Mit Klammern
 str4 = (&quot;Sehr langer Text, der automatisch .............. &quot;
         &quot;in einer einzigen Variable zusammengefügt wird.&quot;
 )
 
 print(str1)
 print(str2)
 print(str3)
 print(str4)

Ausgabe:

 ABC
 Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle
 UVWXYZ
 Sehr langer Text, der automatisch .............. in einer einzigen Variable zusammengefügt wird.

==Hexadezimale, oktale, binäre und andere Zahlen==
 d = 1050         # Dezimalzahl
 h = 0xAA2        # Hexadezimalzahl
 o = 0o12         # Oktalzahl
 b = 0b100001101  # Binärzahl
 
 print(d)
 print(h)
 print(o)
 print(b)

Ausgabe:
 1050
 2722
 10
 269

Groß- und Kleinbuchstaben sind in obigen Literalen übrigens egal. So kann man z.B. statt &lt;code&gt;0b1001&lt;/code&gt; auch &lt;code&gt;0B1001&lt;/code&gt; schreiben (siehe dazu [https://docs.python.org/3/reference/lexical_analysis.html#integer-literals]).

Sie können auch dezimale in hexadezimale Zahlen umwandeln, usw.:
 h = hex(1050)    # Dezimalzahl -&gt; Hexadezimalzahl
 b = bin(1050)    # Dezimalzahl -&gt; Binärzahl
 o = oct(1050)    # Dezimalzahl -&gt; Oktalzahl
 print(h)
 print(b)
 print(o)

Ausgabe:
 0x41a
 0b10000011010
 0o2032

Gegeben sei die Zahl 121 zur Basis 3. Diese soll in eine Dezimalzahl umgewandelt werden. Das kann so geschehen:

 z = int(&quot;121&quot;, 3)
 print(z)

Ausgabe:
 16

Dass dies richtig ist, davon kann man sich folgendermaßen überzeugen:
 &lt;math&gt; 1 \cdot 3^2 + 2 \cdot 3^1 + 1 \cdot 3^0 = 9 + 6+ 1 = 16 &lt;/math&gt;

Zahlen übersichtlicher schreiben kann man auch mittels Underscore, z.B.:

 print(&quot;Eine Million (Variante 1) =&quot;, 1000000)
 print(&quot;Eine Million (Variante 2) =&quot;, 1_000_000)
 print(&quot;Eine Rechnung:&quot;, 2_000 * 400_000);

Es ergibt sich bei beiden Varianten die gleiche Ausgabe. Variante 2 ist aber im Sourcecode leichter lesbar, detto die Zahlen in der Rechnung:

 Eine Million (Variante 1) = 1000000
 Eine Million (Variante 2) = 1000000
 Eine Rechnung: 800000000

== Strings und Platzhalter==
Ein paar einfache Beispiele:

 print(&quot;Hallo {}&quot; . format(&quot;Hugo&quot;))     # new style string formatting
 print(&quot;Hallo {:s}&quot; . format(&quot;Hugo&quot;))   # new style string formatting
 print(&quot;Hallo %s&quot; % &quot;Hugo&quot;)             # %-String

Ausgabe:

 Hallo Hugo
 Hallo Hugo
 Hallo Hugo

Python-Code (formatted string literals, Beispiel 1):
 str1 = &quot;Hallo&quot;
 str2 = &quot;Hugo&quot;
 print(f&quot;{str1} {str2}&quot;)

Ausgabe:
 Hallo Hugo

f-Strings (ab Python 3.6) sind die modernere Variante gegenüber %-Strings oder das ''new style string formatting''. Sie sind in der Regel auch schneller.

Python-Code (formatted string literals, Beispiel 2):
 wert = 11.567
 print(f&quot;Ausgabe: {wert:.5f}&quot;)

Ausgabe:
 Ausgabe: 11.56700

Komplexere Beispiele:

 print(&quot;Hallo {} und {}&quot; . format(&quot;Hugo&quot;, &quot;Mike&quot;))
 print(&quot;Hallo {name1} und {name2}&quot; . format(name2=&quot;Hugo&quot;, name1=&quot;Mike&quot;))
 # Füllzeichen: *
 # Bündigkeit: &gt; (=rechts), &lt; (=links), ^ (=zentriert)
 # Feldweite: 10
 # Typ: s (=String), f (=Gleitkommazahl), d (=Dezimalzahl) etc.
 print(&quot;Hallo {:*&gt;10s}&quot; . format(&quot;Hugo&quot;))
 print(&quot;Hallo {:*&lt;10s}&quot; . format(&quot;Hugo&quot;))

Ausgabe:

 Hallo Hugo und Mike
 Hallo Mike und Hugo
 Hallo ******Hugo
 Hallo Hugo******

Python-Code:
 str = &quot;Hallo\t%s\t%7.2f\t%10.2e\t%i&quot; % (&quot;Hugo&quot;, 12.34567, 34.567, 264)
 print(str)

Ausgabe:
 Hallo	Hugo	  12.35	  3.46e+01	264

== Unicode ==
Neben den bekannten ASCII-Zeichen lassen sich Zeichen auch mittels Unicode beschreiben. Griechische Buchstaben oder komplexere mathematische Operatoren - all das sollte kein Problem sein. Siehe auch {{W|Unicode}}, {{W|Liste der Unicodeblöcke}} und {{W|Unicodeblock Mathematische Operatoren}}. Im Folgenden werden ein paar Zeichen (Allquantor, Nabla-Operator, Existenzquantor), die man aus der Mathematik kennt, erzeugt. 
 
 ch1 = &quot;\N{FOR ALL}&quot;
 ch2 = &quot;\N{NABLA}&quot;
 ch3 = &quot;\u2203&quot;
 print(ch1, ch2, ch3)

Ausgabe:
 ∀ ∇ ∃

&lt;small&gt;Diese Ausgabe ergibt sich z.B. mit der IDLE-Shell oder mit Cygwin. Beim Ausführen über die Windows-Eingabeaufforderung oder Windows PowerShell unter MS Windows 10 erfolgt keine korrekte Darstellung. IDLE ist die mit Python mitgelieferte IDE ('''I'''ntegrated '''D'''evelopment '''E'''nvironment, Integrierte Entwicklungsumgebung). Gegen Ende dieses Textes wird IDLE kurz beschrieben.
Das Problem mit der Windows Eingabeaufforderung lässt sich aber umgehen. Man muss nur eine Schriftart auswählen, die die Zeichen kennt, z.B. &quot;DejaVu Sans Mono&quot;. Dazu klicken Sie einfach bei der Eingabeaufforderung mit der rechten Maustaste oben auf die weiße Leiste und wählen im aufpoppenden Fenster den Menüpunkt &quot;Eigenschaften&quot;. Es öffnet sich ein Dialogfenster. Über den Reiter &quot;Schriftart&quot; lässt sich nun die Schriftart einstellen. Unter MS Windows 11 oder openSUSE Leap 15.6 (bash-Konsole) gibt es dieses Problem ohnehin nicht.&lt;/small&gt;

== Reguläre Ausdrücke ==
Python kennt auch {{W|Regulärer Ausdruck|reguläre Ausdrücke}}. Dazu gibt es in Python das Modul &lt;code&gt;re&lt;/code&gt;. Beipielsweise sollen alle Zahlen (&lt;math&gt;\text{zahl}\in\mathbb{N}_0&lt;/math&gt;) in einem String gesucht und ausgegeben werden. Als String sei gegeben: &lt;code&gt;3x Grüße und 100 Kekse.&lt;/code&gt; Das Muster (Pattern) ist &lt;code&gt;\d+&lt;/code&gt;. &lt;code&gt;\d&lt;/code&gt; steht für eine Dezimalziffer 0-9. Das Plus-Zeichen (+) steht symbolisch für ein oder mehrere Zeichen des vorherigen Ausdrucks. Hier also ein oder mehrere Dezimalziffern. Es wird die Funktion &lt;code&gt;findall&lt;/code&gt; aus dem Modul &lt;code&gt;re&lt;/code&gt;verwendet.

Python-Code:
 from re import findall
 
 str = &quot;3x Grüße und 100 Kekse.&quot;
 pat = &quot;\\d+&quot;  # Doppel-Backslashes müssen verwendet werden, sonst gibt Python eine Warnung aus!
               # alternativ: pat = r&quot;\d+&quot; 
               # oder: pat = &quot;[0-9]+&quot;
 
 numb = findall(pat, str)
 print(numb)

Ausgabe:
 ['3', '100']

Python kennt noch viele weitere Möglichkeiten mittels regulärer Ausdrücke zu hantieren. Dies soll hier aber nicht vertieft werden, da das Thema schon ziemlich speziell und komplex ist. Bei Bedarf siehe aber z.B. die Bücher ''Weigend, Seite 380ff'' und ''Ernesti, Kaiser'' [https://openbook.rheinwerk-verlag.de/python/28_001.html] oder die Python-Dokumentation [https://docs.python.org/3/library/re.html]. Auch [[Python unter Linux: Reguläre Ausdrücke]] liefert ein umfangreiches und brauchbares Python-2-Kapitel zu den regulären Ausdrücken. Die dort gelisteten Beispiele müssten ggf. vor Verwendung auf Python-3 umgeschrieben werden. &lt;small&gt;Wie macht  man das? Dazu siehe z.B. [https://openbook.rheinwerk-verlag.de/python/43_001.html], [https://portingguide.readthedocs.io/en/latest/] oder [https://www.digitalocean.com/community/tutorials/how-to-port-python-2-code-to-python-3]&lt;/small&gt;

&lt;small&gt;Es gibt auch ein externes Modul ''regex'', das bei Bedarf extra installiert werden muss ([https://pypi.org/project/regex/]). Es bietet zusätzliche Funktionalität und gründlicheren Unicode-Support. Dies sei hier aber nur der Vollständigkeit halber erwähnt.&lt;/small&gt;

== Verzweigungen ==
=== if ===
Die IF-Verzweigung sei aus anderen Programmiersprachen bereits bekannt. In {{W|Pseudocode}} lässt sie sich folgendermaßen darstellen:

 WENN bedingung TRUE
   führe block1 aus
 SONST
   führe block2 aus
 ENDE 

Als {{W|Aktivitätsdiagramm|UML-Aktivitätsdiagramm}} sieht das in etwa so aus:

[[File:If-Then-Else-diagram.svg|200px]]

Und als {{W|Nassi-Shneiderman-Diagramm|Nassi-Shneiderman-Struktogramm}} so:

[[File:Zweiseitige Auswahl.png|250px]]

In Python gibt es keinen expliziten ENDE-Kennzeichner. Stattdessen wird der Code durch Einrückungen strukturiert. Alles mit der gleichen Einrückungstiefe gehört zum selben Block. Dies zeichnet Python vor anderen Programmiersprachen aus.

Die test1.py-Datei laute also wie folgt:

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
   print(&quot;x ist groesser oder gleich 4&quot;)  

Ausgabe:

 Der else-Zweig wird ausgefuehrt
 x ist groesser oder gleich 4

Man achte auch auf die Doppelpunkte in der if- und else-Zeile. Darauf vergisst man gerne, wenn man von anderen Programmiersprachen kommt.

Folgendes wäre in Python ein Fehler (genauer gesagt ein IndentationError).

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
     print(&quot;x ist groesser oder gleich 4&quot;)  

Auch Nachstehendes würde nicht zum gewünschten Ergebnis führen (löst aber keine Fehlermeldung aus). Der letzte print-Befehl ist schon außerhalb der IF-ELSE-Verzweigung.

 x = 3
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
 print(&quot;x ist groesser oder gleich 4&quot;)

Ausgabe:

 x ist kleiner als 4
 x ist groesser oder gleich 4

Python kennt eine Reihe von Vergleichs- und Verknüpfungsoperatoren:

    &lt;, &lt;= ... kleiner (gleich)
    &gt;, &gt;= ... größer (gleich)
    == ... gleich
    != ... ungleich
    is ... identisch
    is not ... nicht identisch
    and ... AND
    or ... OR
    not ... NOT

Beispielsweise:

 a = 5
 b = 9
 
 if a&lt;=10 and b!=7:
   print(&quot;OK&quot;)
 else
   print(&quot;Nicht OK&quot;)

Ausgabe:

 OK

Der else-Block kann übrigens auch ersatzlos entfallen. Als Pseudocode sieht das so aus

 WENN bedingung TRUE
   führe block aus
 ENDE

Mehrfache Verzweigungen werden durch das elif-Konstrukt erstellt. In Pseudocode:

 WENN bedingung1 TRUE
   führe block1 aus
 SONST WENN bedingung2 TRUE
   führe block2 aus
 SONST WENN bedingung3 TRUE
   führe block3 aus
 SONST
   führe block4 aus
 ENDE

Ein Python-Beispiel:
 a = 14
 
 if a&lt;=10:   
   print(&quot;&lt;=5&quot;)
 elif a&gt;11 and a&lt;15:
   print(&quot;11 bis 15&quot;)
 elif a&gt;16 and a&lt;20:
   print(&quot;16 bis 20&quot;)
 else:
   print(&quot;&gt;=20&quot;)

Ausgabe:

 11 bis 15

In Python gibt es auch die Schlüsselwörter &lt;code&gt;True&lt;/code&gt; (für wahr) und &lt;code&gt;False&lt;/code&gt; (für falsch). Man beachte, dass sie mit Großbuchstaben beginnen. Andere Schreibweisen wären ein Fehler. Sie gehören zum Datentyp &lt;code&gt;bool&lt;/code&gt;. Ihnen sind auch die Zahlen &lt;code&gt;1&lt;/code&gt; und &lt;code&gt;0&lt;/code&gt; zugewiesen.

Man beachte, dass {{W|Rundungsfehler}} auftreten können. D.h. man sollte  bei der Verwendung von {{W|Gleitkommazahl|Gleitpunktzahlen}} niemals auf absolute Genauigkeit prüfen, sondern eine Toleranz (einen &lt;math&gt;\varepsilon&lt;/math&gt;-Wert) vorgeben.
 
Ein klassisches Beispiel, das ein falsches Ergebnis liefert, ist:

 i = 0.1 + 0.2
 
 print(i)
 
 if i == 0.3:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 NOK

Und das, obwohl man schon in der Volksschule lernt, dass 0.1 + 0.2 gleich 0.3 ist.

Korrekt muss das obige Beispiel z.B. so umgeschrieben werden:

 ist = 0.1 + 0.2
 soll = 0.3
 epsilon = 0.000001
 
 print(ist)
 
 if abs(ist-soll) &lt; epsilon:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 OK

Alternativ kann auch die &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion verwendet werden. Das sei aber hier nur erwähnt und nicht konkret ausgeführt.

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet zum Thema &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion.

=== match ===
Ab Python 3.10 gibt es auch die match-Anweisung. Dies ist das Python-Pendant für die switch-Anweisung in anderen Programmiersprachen, geht aber bei näherer Betrachtung weit darüber hinaus. Hier nur ein einfaches Beispiel:

 x = &quot;Hello&quot;
 
 match x:
     case &quot;Servus&quot; | &quot;Ciao&quot;:         # or
         print(&quot;Servus an alle&quot;)
     case &quot;Grüetzi&quot;:
         print(&quot;Grüetzi Schwyzer&quot;)  
     case _:                         # other, default, sonstiges ...
         print(&quot;Hallo Welt&quot;)

Ausgabe: 
 Hallo Welt

Als Struktogramm sieht das in etwa so aus:

[[File:Mehrseitige Auswahl.png|250px]]

Für nähere Details siehe z.B. [https://www.geeksforgeeks.org/python-match-case-statement/], [https://learnpython.com/blog/python-match-case-statement/], [https://docs.python.org/3/tutorial/controlflow.html#match-statements] und das Python Enhancement Proposal (PEP) 636 – Structural Pattern Matching: Tutorial [https://peps.python.org/pep-0636] und dort insbesondere den Anhang A - Quick Intro.

&lt;small&gt;&lt;code&gt;match, case, _&lt;/code&gt; etc. sind sogenannte ''soft keywords''. Im Gegensatz zu den normalen Schlüsselwörtern dürfen ihnen auch Werte zugewiesen werden. Eine Liste der weichen Schlüsselwörter lässt sich durch &lt;code&gt;keyword.softkwlist&lt;/code&gt; erstellen (die Anweisung gibt es seit Python 3.9). Siehe dazu auch [https://stackoverflow.com/questions/65800344/what-are-soft-keywords] und [https://docs.python.org/3/library/keyword.html#keyword.softkwlist].&lt;/small&gt;

== Schleifen ==
Kopfgesteuerte Schleife, Endlosschleife und fußgesteuerte Schleife:

[[File:Programmingloops.svg|450px]]

=== while ===
Die WHILE-Schleife ist kopfgesteuert. Sie funktioniert wie aus anderen Programmiersprachen bekannt. 

In Pseudocode:
 SOLANGE bedingung TRUE
   führe block aus
 ENDE

In Python:
 x = 0
 
 while x &lt;= 10:
   print(x)
   x += 1

Ausgabe:
 0
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10

Eine Endlosschleife ergibt sich z.B. so:
 i = 5
 
 while True:
     print(i)
     i-=1

Beendet werden kann sie mit der Tastenkombination STRG-C.

Eine fußgesteuerte Schleife kann so simuliert werden:
 i = 5
 
 while True:
     print(i)
     i-=1
 
     if i&lt;=0:
         print(&quot;Fire&quot;)
         break

Ausgabe:
 5
 4
 3
 2
 1
 Fire

Der &lt;code&gt;break&lt;/code&gt;-Befehl wird etwas später noch einmal kurz thematisiert.

=== for ===
Struktogramm einer for-Schleife:

[[File:Zählschleife.png|200px]]

In Python bspw. so:

 for x in range(6):
   print(x*2)

Ausgabe:
 0
 2
 4
 6
 8
 10

Die Schleife läuft von 0 bis 5. Ausgegeben wird jeweils der Wert x*2. Aquivalent kann diese Schleife auch so geschrieben werden:
 for x in range(0, 11, 2):
   print(x)

Die Ausgabe ist wie oben. Der Startwert sei 0, der Endwert ist 11-1 und die Schrittweite ist 2.

Ein anderes Beispiel sei
 for x in &quot;text&quot;:
   print(x)

Ausgabe:
 t
 e
 x
 t

== Schleifen abbrechen ==
=== break ===
&lt;code&gt;break&lt;/code&gt; bricht die Schleife ab und setzt mit dem nächsten Befehl außerhalb der Schleife fort.

 for var in range(100):
   print(var) 
   if var == 5:
     break

Ausgabe:
 0
 1
 2
 3
 4
 5

=== continue ===
&lt;code&gt;continue&lt;/code&gt; bricht den aktuellen Schleifendurchlauf ab und setzt mit dem nächsten Schleifendurchlauf fort.

 for var in range (11):
   if var == 5:
     continue
   print(var)

Ausgabe:
 0
 1
 2 
 3
 4
 6
 7
 8
 9
 10

== try - except ==
 try:
     z1 = 12 / 0
     print(z1)
 except ZeroDivisionError:
     print(&quot;Das Ergebnis ist unendlich&quot;)
 except:
     print(&quot;Kann nicht berechnet werden!&quot;)
     print(&quot;Bitte die Formel korrigieren!&quot;)
 
 print(&quot;Setze Programm fort!&quot;)

Ausgabe:
 Das Ergebnis ist unendlich
 Setze Programm fort!

Es wird versucht, eine Zahl durch Null zu dividieren. Das ist nicht möglich, es wird eine Ausnahme ausgelöst. Das Programm springt daher in den except-ZeroDivisionError-Block und führt die dort gelisteten Anweisungen aus (in unserem Fall eine print-Anweisung). Danach wird das Programm fortgesetzt. Würden wir dieses Programm ohne try-except ausführen, so ergibt sich aus

 z1 = 12 / 0
 print(z1)

folgende Fehlermeldung und ein unmittelbarer Programmabbruch

 Traceback (most recent call last):
   File &quot;C:\tmp\test1.py&quot;, line 1, in &lt;module&gt;
     z1 = 12 / 0
 ZeroDivisionError: division by zero

Mit dem try-except-Mechanismus können also Ausnahmen oder Fehler aufgefangen und behandelt werden. In unserem Beispiel ist das eher trivial, aber bei größeren Programmen kann das durchaus Sinn machen.

Neu in Python 3.14 ist, dass mehrere Ausnahmen auch ohne Klammern angegeben werden können, z.B.:

bis inkl. Python 3.13 nur:
 except (ZeroDivisionError, ValueError):

ab Python 3.14 auch:
 except ZeroDivisionError, ValueError:

== pass ==
Ein leerer Block muss in Python mittels dem Schlüsselwort &lt;code&gt;pass&lt;/code&gt; dargestellt werden. Z.B.

 x = 2
 
 if x == 1:
     print(&quot;Wert ist &quot;, x)
 else:
     pass

Würde man das &lt;code&gt;pass&lt;/code&gt; im else-Block weglassen, so würde man eine Fehlermeldung erhalten:

 IndentationError: expected an indented block after 'else' statement on line 5

= Funktionen =
== Aufrufen von Funktionen ==
Funktionen sind uns im Rahmen dieses Kurses schon zuhauf begegnet. Sei es die print()-, die math.sin()- oder die hex()-Funktion. All diese Funktionen werden von Python zur Verfügung gestellt, ohne dass man sie explizit programmieren müsste. Aufgerufen werden diese Funktionen, indem man ihren Namen eintippt, gefolgt von runden Klammern. In diesen Klammern können noch Argumente übergeben werden. Auch Rückgabewerte sind möglich.

== Funktionen selber schreiben ==
Funktionen werden mit dem def-Schlüsselwort (man definiert die Funktion) eingeleitet, danach folgt der Funktionsname, danach wiederum runde Klammern, in denen formale Argumente stehen können. Abgeschlossen wird die def-Zeile mit einem Doppelpunkt. Danach folgt der Funktionskörper. Dieser Funktionskörper muss wiederum eingerückt werden (wie von den Verzweigungen und Schleifen bekannt). Aufgerufen wird diese Funktion, indem man ihren Funktionsnamen eingibt, gefolgt von runden Klammern (ggf. mit den aktuellen Parametern). Z.B.

 # Funktion definieren
 def halloWelt(i):
     # i ... beliebige Ganzzahl
     print(&quot;Hallo &quot; * i, end=&quot;&quot;)
     print(&quot;Welt!&quot;)
    
 # Funktion aufrufen
 halloWelt(3)

Ausgabe:
 Hallo Hallo Hallo Welt!

Unterschied zwischen formalen und aktuellen Parametern:

[[Datei:PythonIng_func1.jpg]]

&lt;small&gt;Aktuelle Parameter werden auch Argumente genannt.&lt;/small&gt;

Rückgabe von Funktionswerten:
 # Funktion definieren
 def mathFunc(a, b):
     r1 = a + b
     r2 = a * b
     return r1, r2
    
 # Funktion aufrufen
 c, d = mathFunc(3, 5)
 
 # Ausgabe der zurückgegebenen Werte
 print(c)
 print(d)

Ausgabe:
 8
 15

Es werden r1 und r2 zurückgegeben und den Variablen c und d zugewiesen. (r1, r2) und (c, d) sind Tupel. Was Tupel konkret sind, siehe etwas später in diesem Kapitel. 3 und 5 sind die aktuellen Parameter (die Argumente). a und b sind die formalen Parameter. Die Zuweisung der aktuellen zu den formalen Parametern erfolgt in der gegebenen Reihenfolge, also die Zahl 3 wird an a übergeben und die Zahl 5 an b.

Vorgabeparameter, z.B.:
 def mathFunc(a=10, b=20):
     r1 = a + b
     r2 = a * b
     return r1, r2
 
 c, d = mathFunc(3, 5)
 print(c)
 print(d) 
 
 e, f = mathFunc(5)
 print(e)
 print(f)
 
 g, h = mathFunc(b=6)
 print(g)
 print(h)

Ausgabe:
 8
 15
 25
 100
 16
 60

Erklärung:
* Erster &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es werden, wie weiter oben, die Argumente 3 und 5 an die formalen Parameter a und b übergeben. Die Rückgabewerte r1 und r2 werden an c und d übergeben. Somit ist c=8 und d=15.
* Zweiter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur das Argment 5 an a übergeben. b behält den Vorgabewert 20. D.h. e= 25 und f=100.
* Dritter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur die Zahl 6 an b übergeben, a behält seinen Vorgabewert 10. Somit ergibt sich g=16 und h=60.

Beispiel (Schlüsselwortargumente vs. Positionsargumente):
 def mathFunc(a, b):
     r1 = a - b
     r2 = a / b
     return r1, r2
 
 c, d = mathFunc(b=3, a=5)  # Schlüsselwortargumente
 e, f = mathFunc(3, 5)      # Positionsargumente

 print(c)
 print(d)
 print(e)
 print(f)

Ausgabe:
 2
 1.6666666666666667
 -2
 0.6

Durch die Verwendung von Schlüsselwortargumenten können die Argumente in beliebiger Reihenfolge angegeben werden. Bei den Positionsargumenten ist die Reihenfolge vorgegeben. Daraus resultiert auch der Unterschied bei den obigen Ausgaben. Werden beide Arten in einem Aufruf gemischt, so müssen die Positionsargumente zuerst angegeben werden. Den Unterschied zwischen beiden Argumentarten zu kennen ist wichtig, nicht nur bei selbst erstellten Funktionen. Auch beim Aufruf von Python-Funktionen verfolgt einen die Mischung von Schlüsselwort- und Positionsargumenten auf Schritt und Tritt, z.B. beim etwas später folgenden Abschnitt über &quot;Grafiken zeichnen&quot;:

 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)

Bei dieser &lt;code&gt;plot&lt;/code&gt;-Funktion aus dem Modul &lt;code&gt;matplotlib.pyplot&lt;/code&gt; sind &lt;code&gt;x&lt;/code&gt; und &lt;code&gt;y1&lt;/code&gt; Positionsargumente. &lt;code&gt;label, lw&lt;/code&gt; und &lt;code&gt;ls&lt;/code&gt; sind die Namen der Schlüsselwortargumente. Die Schlüsselwortargumente könnten auch in anderer Reihenfolge angeschrieben werden, nicht jedoch die Positionsargumente!
Siehe zu &lt;code&gt;matplotlib.pyplot.plot&lt;/code&gt; auch die Seite [https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html].

== Lambda-Funktionen ==
 print((lambda a, b: a*b) (3, 5))

Ausgabe:
 15

Eingeleitet wird eine Lambda-Funktion (auch Lambda-Form, Lambda-Operator oder anonyme Funktion genannt) mit dem Schlüsselwort &lt;code&gt;lambda&lt;/code&gt;. Es folgen die formalen Argumente, danach ein Doppelpunkt, die Berechnungsvorschrift und ggf. abschliessend in Klammern die aktuellen Parameter.

Man kann einer Lambda-Funktion auch einen Funktionsnamen geben und die Funktion über diesen Namen aufrufen, z.B.

 prod = lambda a, b: a*b
 print(prod(3, 5))

Als Ausgabe wird wieder die Zahl 15 geliefert.

== Rekursive Funktionen ==
Funktionen können wiederum andere Funktionen aufrufen. Von einem {{W|Rekursion|rekursiven Funktionsaufruf}} spricht man, wenn die aufgerufene Funktion gleich der aufrufenden ist. 

 def printFunc(i):
     if (i &gt;= 5):
         return 
     else:
         print(&quot;Hallo Welt&quot;)
         printFunc(i+1)
         
 printFunc(1)

Ausgabe:
 Hallo Welt
 Hallo Welt
 Hallo Welt
 Hallo Welt

Typische Beispiele für die Abarbeitung als rekursive Funktionen sind die {{W|Fibonacci-Folge}} und die {{W|Fakultät_(Mathematik)|Fakultät}}. Jedoch ist der iterative Ansatz (mit konventionellen Schleifen) meist schneller und speicherplatzschonender.

== Funktionsannotationen ==
Python ist sehr flexibel, was Typen angeht. Im Vorhergehenden haben wir generell keine Typangaben gemacht. Will man Typen angeben, so bietet Python das Konzept der Funktionsannotation.

 def calcFunc(a: int, b: int) -&gt; int:
     return a+b
 
 r1 = calcFunc(8, 9)
 r2 = calcFunc(8.0, 9.0)
 r3 = calcFunc(&quot;Hallo&quot;, &quot;Welt&quot;)
 
 print(r1)
 print(r2)
 print(r3)

Ausgabe:
 17
 17.0
 HalloWelt

Jetzt sieht man auf den ersten Blick, welche Typen der Programmierer im Sinn hatte, als er die Funktion erstellte. Das Problem dabei ist nur, dass es Python ziemlich egal ist, welche Typen man im Endeffekt eingibt. Im obigen Beispiel können statt Integer-Typen u.a. auch Float- oder String-Typen eingegeben werden.

&lt;small&gt;
Siehe zum Thema &quot;Type Checking&quot; aber auch den später folgenden Abschnitt [[Ing_Mathematik:_Python#Type_Checker]].
&lt;/small&gt;

== Variadische Funktionen ==
Python-Code:

 def test1(a, *b):
     print(a);
      
     for c in b:
         print(c);
        
 test1(&quot;Hallo&quot;, &quot;Welt&quot;, &quot;Schweizer&quot;, &quot;und alle anderen&quot;)

Ausgabe:

 Hallo
 Welt
 Schweizer
 und alle anderen

Mit dem Stern (auch als Splat-Operator bezeichnet) in der formalen Parameterliste bei der Funktion &lt;code&gt;test1&lt;/code&gt; wird angezeigt, dass eine beliebige Anzahl von Argumenten übergeben wird. &lt;small&gt; Dies entspricht in etwa dem, was in anderen Programmiersprachen (PHP etc.) mittels Ellipse (&lt;code&gt;...&lt;/code&gt;) angezeigt wird.&lt;/small&gt;

= Tupel, Listen und andere =
[[Datei:Python 3. The standard type hierarchy.png|mini|hochkant=1.7|Datentypen und Strukturen]]

== Tupel und Listen ==
Tupel, Listen und einige andere sind Datenstrukturen oder Sequenzen.

Listen (z.B. eine Einkaufsliste) sind veränderbar (mutable). Ein Tupel kann dagegen nicht verändert werden (immutable). Listen werden beim Anlegen in eckige Klammern eingeschlossen, Tupel in runde Klammern. Beim Tupel können die Klammern auch weggelassen werden. Ein Tupel mit nur einem Element muss mit einem Beistrich abgeschlossen werden. Der Grund ist, dass Python sonst nicht entscheiden kann, ob ein Tupel angelegt werden soll, oder nur ein geklammerter Wert. 

Als Gedächtnisstütze kann man sich den Unterschied zwischen Tupel und Liste ev. so leichter merken:
: T'''u'''pel ... r'''u'''nde Klammern, '''u'''nveränderlich
: L'''i'''ste ... eck'''i'''ge Klammern, veränderl'''i'''ch.

Nachfolgend werden einige Operationen mit Listen und Tupel dargestellt.

 # Liste und Tupel
 liste = [1, 2, &quot;Hallo&quot;]
 tupel = (1, 2, &quot;Hallo&quot;) 
 
 # Ausgabe von liste und tupel
 print(liste)
 print(tupel)
 
 # Ausgabe von Einzelelementen
 print(liste[1])
 print(tupel[2])
 
 # Element an Liste anhängen und einfügen 
 liste.append(55)
 liste.insert(4, &quot;Welt&quot;)
 print(liste)
 
 # Element aus Liste entfernen
 liste.remove(1)
 print(liste)
 
 # einige weitere Beispiele
 liste2 = [1,]
 tupel2 = 1, 2
 tupel3 = (1,) 
 print(liste2)
 print(tupel2)
 print(tupel3)

Ausgabe:
 [1, 2, 'Hallo']
 (1, 2, 'Hallo')
 2
 Hallo
 [1, 2, 'Hallo', 55, 'Welt']
 [2, 'Hallo', 55, 'Welt']
 [1]
 (1, 2)
 (1,)

Beispiel (eine Liste von Wörtern zu einem einzigen zusammenhängenden Text verbinden):

 woerter = [&quot;Hallo&quot;, &quot;Welt&quot;]
 satz = &quot; &quot;.join(woerter)
 print(satz)

Ausgabe:

 Hallo Welt

== Dictionaries und Mengen ==
Zu den Datenstrukturen gehören weiters auch Mengen und Dictionaries. Mengen sind von der Mathematik bekannt, sie sind ungeordnet und es kommen keine mehrfachen Elemente vor. Dictionaries sind durch Schlüssel :Wert-Paare gekennzeichnet. Mengen werden beim Anlegen wie Dictionaries in geschweifte Klammern eingeschlossen.

 dict = {&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot; }
 menge = {1, 1, 3, 4, 4, 4, &quot;Hallo&quot;}
 
 print(dict)
 print(menge)
 print(dict[&quot;vorname&quot;])

Ausgabe:
 {'vorname': 'Hugo', 'nachname': 'Meister'}
 {1, 3, 4, 'Hallo'}
 Hugo

Geschweifte Klammern ohne Inhalt stellen Dictionaries dar und keine Mengen:

 di = {}
 print(type(di))

Ausgabe:
 &lt;class 'dict'&gt;

Leere Mengen lassen sich mit &lt;code&gt;set()&lt;/code&gt; erzeugen:

 menge = set()      # leere Menge
 print(menge)
 menge.add(&quot;Hallo&quot;) # Element hinzufügen
 print(menge)

Ausgabe:
 set()
 {'Hallo'}

Beispiel (einige Mengenoperationen):
 mengeA = {&quot;Hallo&quot;, &quot;Welt&quot;}
 mengeB = {1, 2, &quot;Welt&quot;, 3}
 
 # Vereinigung
 print(mengeA | mengeB)
 print(mengeA.union(mengeB))
 
 # Durchschnitt
 print(mengeA &amp; mengeB)
 print(mengeA.intersection(mengeB))
 
 # Differenz
 print(mengeA - mengeB)
 print(mengeA.difference(mengeB))
 
 # Symmetrische Differenz
 print(mengeA ^ mengeB)
 print(mengeA.symmetric_difference(mengeB))
 
 # Teilmenge
 print(mengeA.issubset(mengeB))
 
 # Mehrere Elemente hinzu
 mengeA.update([&quot;Super&quot;, 67, 125])
 print(mengeA)
 
 # Element löschen
 mengeA.discard(&quot;Hallo&quot;)
 print(mengeA)

Ausgabe:
 {1, 2, 3, 'Welt', 'Hallo'}
 {1, 2, 3, 'Welt', 'Hallo'}
 {'Welt'}
 {'Welt'}
 {'Hallo'}
 {'Hallo'}
 {1, 2, 3, 'Hallo'}
 {1, 2, 3, 'Hallo'}
 False
 {67, 'Super', 'Welt', 'Hallo', 125}
 {67, 'Super', 'Welt', 125}

Es gibt schon seit &quot;ewigen&quot; Zeiten unveränderbare Mengen, die mittels &lt;code&gt;frozenset&lt;/code&gt; eingeleitet werden. Neu ab Python 3.15 ist dagegen das Pendant &lt;code&gt;frozendict&lt;/code&gt;, das unveränderbare Dictionaries darstellt.

 fdict = frozendict({&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot;})
 fset = frozenset({&quot;A&quot;, 1, &quot;A&quot;})
 
 print(fdict)
 print(fdict[&quot;vorname&quot;])
 print (fset) 
 
 try:
     fdict[&quot;vorname&quot;] = &quot;Max&quot;
     print(fdict[&quot;vorname&quot;])
 except TypeError as e:
     print(f&quot;Fehler: {e}&quot;)
 
 try:
     fset.add(&quot;B&quot;)
     print(fset)
 except AttributeError as e:
     print(f&quot;Fehler: {e}&quot;)

Ausgabe:
 frozendict({'vorname': 'Hugo', 'nachname': 'Meister'})
 Hugo
 frozenset({1, 'A'})
 Fehler: 'frozendict' object does not support item assignment
 Fehler: 'frozenset' object has no attribute 'add'

== List Comprehensions ==
Aus einer Eingabeliste soll eine Ausgabeliste erzeugt werden. Das kann folgendermaßen geschehen.

Mathematische Schreibweise: &lt;math&gt;lc = \{2x|x\in\ \mathbb{N}, 1\le x &lt; 11\}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11)]
 print(lc)

Ausgabe:
 [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Mathematische Schreibweise: &lt;math&gt;lc = \{2x | x \in \mathbb{N}, 1\le x &lt; 11, x \bmod 2 = 0 \}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11) if x%2 == 0]
 print(lc)

Ausgabe:
 [4, 8, 12, 16, 20]

Siehe auch {{W|List Comprehension}}.

== Set Comprehensions ==
Dies ist sehr ähnlich wie im vorigen Abschnitt beschrieben. Es wird aber keine Liste, sondern eine Menge erzeugt.

 sc = {x*2 for x in range(1,11)}
 print(sc)

Ausgabe:
 {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}

== Listen zusammenführen - zip() ==
 li1 = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]
 li2 = [1, 2, 3, 4]
 li3 = [5.5, 6.6, 7.7, 8.8]
 
 z = zip(li1, li2, li3)
 print(z)
 
 li4 = list(z)
 print(li4)

Ausgabe:
 &lt;zip object at 0x00000283B6C6AC80&gt;
 [('A', 1, 5.5), ('B', 2, 6.6), ('C', 3, 7.7), ('D', 4, 8.8)]

== Generatorausdruck ==
 g = (i*2 for i in range(1,11))
 print(g)
 t = tuple(g)
 print(t)
 print(t[1:3])

Ausgabe:
 &lt;generator object &lt;genexpr&gt; at 0x00000241D2A4A5A0&gt;
 (2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
 (4, 6)

== Slicing ==
slice ... Scheibe, Teil, in Scheiben schneiden

Beispiel: Zugriff auf Elemente eines geordneten sequentiellen Objekttyps (Liste, Tupel oder String):

 str1 = &quot;Hallo&quot;
 # Das erste Element wird mit dem Index 0 angesprochen
 # [start (inkl.) : stop (exkl.) : step (default=1)]
 str2 = str1[0:2]
 # Alternativ auch: str2 = str1[:2] 
 print(str2)
 
 tup1 = (0,1,2,3)
 # Das letzte Element hat auch den Index -1, das vorletzte den Index -2 usw.
 tup2 = tup1[-3:-1]
 print(tup2)
 
 lst1 = [[1,  5,  10, 20],
         [30, 40, 50, 60]]
 lst2 = lst1[1][1]
 print(lst2)
 
Ausgabe:
 Ha
 (1, 2)
 40

Beispiel:

 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2])
 print(x[-3]) 
 print(x)
 print(x[:])
 print(x[2:])
 print(x[:2])
 print(x[::-1])

Ausgabe:

 c
 c
 ('a', 'b', 'c', 'd', 'e')
 ('a', 'b', 'c', 'd', 'e')
 ('c', 'd', 'e')
 ('a', 'b')
 ('e', 'd', 'c', 'b', 'a')

Visualisierung:

    '''a'''     '''b'''     '''c'''     '''d'''     '''e'''
 +-----------------------------+
 |  0  |  1  |//'''2'''//|  3  |  4  |
 +-----------------------------+
 | -5  | -4  |/'''-3'''//| -2  | -1  | 
 +-----------------------------+
 |/////////////////////////////|
 +-----------------------------+
 |/////////////''':'''///////////////|
 +-----------------------------+
 |     |     |///////'''2:'''////////|
 +-----------------------------+
 |////''':2'''/////|     |     |     |
 +-----------------------------+
 |\\\\\&lt;--\\\\\'''::-1'''\\\\&lt;--\\\\\|
 +-----------------------------+

Beispiel:
 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2::2])
 print(x[2::-1])
 print(x[2:0:-1])

Ausgabe:

 ('c', 'e')
 ('c', 'b', 'a')
 ('c', 'b')

Hier sieht man sehr schön, dass beim letzen &lt;code&gt;print&lt;/code&gt;-Befehl die 0, die in diesem Fall den Buchstaben &quot;a&quot; repräsentiert, als letzer Wert nicht mehr dazugehört (wie weiter oben angedeutet ist der End- oder Stoppwert exklusiv). Will man den Buchstaben &quot;a&quot; dazunehmen, so ist die vorletzte Zeile die richtige.

Beispiel: Umdrehen von Strings

 str1 = &quot;Hallo&quot;
 str2 = str1[::-1]
 print(str2)

Ausgabe:
 ollaH

Mit zweidimensionalen Listen/Tupels wird das Ganze schon bedeutend komplexer.

Beispiel: Verkettetes Slicing

 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
     
 print(A[2::][::2])

Ausgabe:

 [['20', '21', '22', '23'], ['40', '41', '42', '43']]

Das erste Slicing erstellt folgenden Slice:

 [[&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
  [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
  [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]

Das zweite Slicing wird dann auf diesen Slice angewendet und ergibt das genannte Endergebnis. Will man Spalten statt Zeilen, so funktioniert dieser direkte Weg nicht. Man verwendet dann List Comprehensions oder die NumPy-Bibliothek. Diese Bibliothek erlaubt [[Ing_Mathematik:_Python#Zugriff_auf_Matrizenelemente|zweidimensionales Slicing]]. Sie wird erst später bei den Grafiken eingeführt. Deshalb wird hier dazu noch kein Beispiel gezeigt.

= Objektorientierte Programmierung =
{{Wikipedia|Objektorientierte Programmierung}}

* {{W|Klasse (Objektorientierung)|Klasse}} ... die Schablone oder der Bauplan, enthält Methoden und Attribute
* {{W|Objekt (Programmierung)|Objekt}} ... eine Klasseninstanz (die konkrete Ausprägung der Klasse)
* {{W|Attribut (Programmierung)|Attribute}} ... die Eigenschaften eines Objekts
* {{W|Methode (Programmierung)|Methoden}} ... die Aktionen (Operationen), die ein Objekt ausführen kann
* {{W|Vererbung (Programmierung)|Vererbung}} ... neue Klassen (Subklassen, Unterklassen, abgeleitete Klassen) aus vorhandenen Klassen (Superklassen, Oberklassen, Basisklassen, Elternklassen) ableiten. Ermöglicht den Aufbau von Klassenhierarchien. Die Subklasse &quot;erbt&quot; Attribute und Methoden von der Superklasse. Python unterstützt (so wie C++, aber im Gegensatz zu Java) Mehrfachvererbung.

== UML ==
* {{W|Unified Modeling Language|UML}} ... '''U'''nified '''M'''odeling '''L'''anguage, eine Modellierungssprache. Die UML enthält zahlreiche Diagrammarten, um Programme zu modellieren. Im Nachfolgenden wird nur das {{W|Klassendiagramm}} verwendet.

[[File:UmlCd Klasse-3.svg|300px]]

* {{W|Sichtbarkeit (Programmierung)|Sichtbarkeit}}:
** + ... public (öffentlich)
** - ... private
** # ... protected 

* {{W|Attribut_(UML)#Attribute_für_Instanzen_und_für_Klassen|Klassenattribute}} (statische Attribute): Werden nur einmal pro Klasse angelegt. Im Klassendiagramm werden sie unterstrichen.

[[File:Attribute-3.png|200px]]

* Vererbung:

&lt;gallery&gt;
InheritancePgmUML.svg | Abgeleitete Klasse erbt von Basisklasse (Einfachvererbung)
Diamond inheritance.svg | D erbt von B und C (Mehrfachvererbung). B und C erben von A (Einfachvererbung)
&lt;/gallery&gt;

Für weitergehende Betrachtungen zur UML wird auf Spezialliteratur verwiesen, z.B.:
* Seidl et al.: UML@Classroom. dpunkt, 2012, ISBN 978-3-89864-776-2
* Rupp et al.: UML 2 glasklar. Hanser, 4. Aufl., 2012, ISBN 978-3-446-43057-0

== Eine einfache Klasse ==

[[Datei:PythonIng_uml1.svg | 200px]]

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
 
 fahr = Fahrzeug(150, 90)
 
 print(fahr.convertGeschw())
 
Ausgabe:
 41.666666666666664

Die Klasse Fahrzeug wird durch das class-Schlüsselwort eingeleitet. raeder ist ein Klassenattribut und public. __init__ wird bei der Objekterzeugung automatisch aufgerufen (ist der sogenannte Konstruktor). Man achte darauf, dass diese Methode immer mit zwei Unterstrichen eingeleitet und abgeschlossen wird. Instanzattributen wird das Wort self vorangestellt. Wir sehen uns z.B. das Attribut self.__geschwind an. Auch hier werden zwei Unterstriche verwendet. Das bedeutet, dass dieses Attribut strikt/stark private ist. Wird nur ein Unterstrich verwendet, so deutet dies auf schwach/weakly private hin. Letzteres wird in Python deutlich häufiger verwendet. Bei den Methoden wird immer self als erster Parameter angegeben. Beim Aufruf der entsprechenden Funktion wird das self aber nicht berücksichtigt.

Besonderheiten bei stark und schwach private:
* '''stark private''':
** zwei führende Unterstriche
** Name Mangling: Name wird zu &lt;code&gt;_Klassenname__variablenname&lt;/code&gt;
** Schutz vor Namenskollisionen bei Vererbung
** am Ende des Namens dürfen keine zwei Unterstriche verwendet werden. Das wären dann Magic Methods oder Dunder-Methods (z.B. __init__). Diese sind public.

* '''schwach private''':
** ein führender Unterstrich
** Name bleibt gleich
** ist nur ein Hinweis an die Programmierer, kein starker Schutz
** &lt;code&gt;from modul import *&lt;/code&gt;: Objekte mit einem führenden Unterstrich werden standardmäßig nicht importiert
** Standard für die Kapselung bei Python. Schätzung: Weit mehr als 80% der nicht-öffentlichen Attribute/Methoden werden als schwach private deklariert. Weniger als 5-10% als stark private (Quelle: Google KI)

== Klassen importieren ==
Häufig ist es sinnvoll und übersichtlicher Klassen in eigenen Dateien zu speichern. Das sind dann eigene Module. Abgespeichert werden Sie mit der Endung py, wie bisher auch praktiziert. Aufgerufen werden Sie mit der import-Anweisung. Dann ist aber nur der Dateiname ohne Endung py zu verwenden. Klarer wird das mit einem Beispiel.

Datei c:\tmp\fahrzeug.py

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6

Datei c:\tmp\test1.py

 import fahrzeug
 fahr = fahrzeug.Fahrzeug(150, 90)
 print(fahr.convertGeschw())

Ausgabe:
 41.666666666666664

Die üblichen import-Anweisungen lauten wie folgt:
{| {{prettytable}}
! import-Befehl
! Instanz
|-
| import xyz      || xyz.Klasse
|-
| import xyz as x || x.Klasse
|-
| from xyz import Klasse || Klasse
|-
| from xyz import * || Klasse 
|}

Der Vorteil der ersten beiden import-Anweisungen ist, dass es kaum zu Namenskollisionen kommen kann. Dafür hat man bei den letzten beiden Varianten weniger Tipparbeit.

== Vererbung ==
=== Einfachvererbung ===

[[Datei:PythonIng_uml2.svg | 200px]]

Datei fahrzeug.py:
 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
        
     def setLeistung(self, leistung):
         self.__leistung = leistung
        
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
        
 class Luftfahrzeug(Fahrzeug):
     def __init__(self, geschwindigkeit, leistung, fluegel):
         super().__init__(geschwindigkeit, leistung)
         self.__flueg = fluegel
     
     def getFlueg(self):
         return self.__flueg

Datei test1.py:
 import fahrzeug
 fahr = fahrzeug.Luftfahrzeug(150, 90, 4)
 print(fahr.getFlueg())

Ausgabe:
 4

=== Mehrfachvererbung ===
Mit Python ist auch Mehrfachvererbung möglich, z.B.:

 class A:
     def _printA(self):
         print(&quot;Klasse A&quot;)
 
 class B:
     def _printB(self):
         print(&quot;Klasse B&quot;)
 
 class C(A,B):
     def __init__(self):
         self._printA()
         self._printB()
 
 c = C()

Ausgabe:

 Klasse A
 Klasse B

Die Klasse C erbt von A und B. In UML sieht das in etwa so aus:

 +-----------------------------+   +-------------------------+
 |            A                |   |          B              |
 +-----------------------------+   +-------------------------+
 |                             |   |                         |
 +-----------------------------+   +-------------------------+
 | # printA()                  |   | # printB()              |
 +-----------------------------+   +-------------------------+
                           .              .
                          / \            / \
                          ---            ---
                           |              |
                           |              |
                        +---------------------+
                        |          C          |
                        +---------------------+
                        |                     |
                        +---------------------+
                        |                     |
                        +---------------------+

&lt;code&gt;printA()&lt;/code&gt; und &lt;code&gt;printB()&lt;/code&gt; sind schwach private (in UML als &lt;code&gt;protected&lt;/code&gt; mit einem # dargestellt). Es ist aber zu beachten, dass schwach private nur Konvention ist. Praktisch könnte man auch von außerhalb auf diese Methoden zugreifen. Das soll man aber nicht tun, und das wird in Python durch einen Unterstrich angedeutet.

== Statische Attribute, statische Methoden und Klassenmethoden ==
Beispiel:

 class Math:
     pi = 3.14159265
     cnt = 0
     
     @staticmethod
     def expo():
         return 2.71828183
    
     @classmethod    
     def counterPlus(cls):
         cls.cnt += 1
        
 print(Math.pi)
 print(Math.expo())
 
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)

Ausgabe:

 3.14159265
 2.71828183
 1
 2
 3

Statische Attribute und Methoden, bzw. Klassenmethoden, sind direkt einer Klasse zugeordnet und nicht einem Objekt. Der Unterschied zwischen statischen Methoden und Klassenmethoden ist, dass statische Methoden nicht auf Klassenattribute (bzw. statische Attribute) zugreifen können, Klassenmethoden aber schon. &lt;code&gt;pi&lt;/code&gt; und &lt;code&gt;cnt&lt;/code&gt; sind statische Attribute. &lt;code&gt;expo()&lt;/code&gt; ist eine statische Methode. &lt;code&gt;counterPlus(cls)&lt;/code&gt; ist eine Klassenmethode. Die Bezeichnung des Parameters als &lt;code&gt;cls&lt;/code&gt; ist reine Konvention, man sollte sich aber daran halten.

= Grafiken zeichnen =
Für das Zeichnen von Grafiken wird hier das Modul &lt;code&gt;matplotlib&lt;/code&gt; verwendet. &lt;code&gt;matplotlib&lt;/code&gt; ist ein externes Modul und muss vor der ersten Verwendung installiert werden. Das geht so:

# Starten Sie ein Terminal (bei Windows die Eingabeaufforderung).
# Führen Sie darin folgenden Befehl aus &lt;code&gt;c:\devel\Python\Scripts\pip.exe install matplotlib&lt;/code&gt;

pip ist übrigens der Paketmanager von Python ({{W|Pip_(Python)}}). 

Optimalerweise installieren wir auch gleich das Modul &lt;code&gt;numpy&lt;/code&gt; (Numerical Python). Wir werden es im Folgenden oft benötigen (nicht nur bei den Grafiken). Das funktioniert vom Prinzip her genauso, wie für &lt;code&gt;matplotlib&lt;/code&gt; gezeigt.

&lt;small&gt;Verwenden Sie Spyder, so sind diese Schritte nicht nötig. Spyder inkludiert diese Pakete standardmäßig. Unter openSUSE Tumbleweed lassen sich diese Pakete mittels YaST oder zypper installieren.&lt;/small&gt;

== 2D ==
=== Graph einer Funktion ===
Es soll die cosh-Funktion im Intervall &lt;math&gt;x\in[-3,3]&lt;/math&gt; gezeichnet werden. Der Programmcode lautet in der einfachsten Form:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x)
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:PythonIng_cosh1.jpg]]

Der Code ist quasi selbsterklärend. Das Untermodul pyplot des matplotlib-Moduls und das numpy-Modul werden importiert. x läuft von -3 bis +3. y wird für jeden x-Wert per Formel ausgerechnet. &quot;plt.plot()&quot; ist der Zeichenbefehl. &quot;plt.show&quot; ist notwendig, um das Fenster mit der Grafik anzuzeigen.
Die Schrittweite 0.1 wurde so gewählt, um einen ausreichend glatten Verlauf des Graphen zu gewährleisten. Das ist immer ein Kompromiss zwischen Berechnungszeit und Ansehnlichkeit. Testen Sie einfach ein paar verschiedene Werte, um ein Gefühl dafür zu zu bekommen. &quot;plt.grid()&quot; zeichnet ein Gitter in die Grafik (kann auch weggelassen werden).
Die Bezeichnungen plt und np könnten auch anders gewählt werden. Es ist aber Konvention, diese so wie hier gezeigt zu wählen. Die &quot;arange&quot;-Funktion aus der NumPy-Bibliothek wird später ein bisschen genauer behandelt (siehe [[Ing_Mathematik:_Python#Zahlenfolgen|Zahlenfolgen]]).  

&lt;small&gt;Mit der im obigen Bild gezeigten Menüleiste kann die dargestellte Grafik nachträglich noch geändert werden (Zoom, Pan, Achsenparameter, Kurvenparameter etc.). Natürlich kann man das alles auch direkt programmieren. Wie das funktioniert wird ansatzweise etwas später gezeigt.&lt;/small&gt;

Ein etwas komplexeres Beispiel ist Folgendes:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x) + 2**x
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:
[[Datei:PythonIng_cosh4.png]]

Man beachte, dass im Gegensatz zu Octave und Julia der ominöse Punkt (.) bei 2**x mit Python nicht benötigt wird. Das macht das Programmiererleben etwas einfacher.

Die Farbe des Graphen kann man über den &lt;code&gt;color&lt;/code&gt;-Schalter einstellen, z.B. auf rot setzen:
 plt.plot(x, y, color=&quot;red&quot;)

Das ist nur eine Möglichkeit, es gibt auch andere, z.B. mittels
* hexadezimaler Zahl, z.B. &lt;code&gt;color=&quot;#ff0000&quot;&lt;/code&gt;
* Kurzform, z.B. &lt;code&gt;&quot;r&quot;&lt;/code&gt;

Statt &lt;code&gt;color&lt;/code&gt; kann auch die Kurzform &lt;code&gt;c&lt;/code&gt; verwendet werden.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie diese &quot;Farbspielereien&quot; am Computer aus.

=== Graphen mehrerer Funktionen und weiteres ===
==== Mehrere Funktionen in einen Plot zeichnen ==== 
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh2.png]]

Um die Linienstile etwas individueller zu gestalten, ist folgender Programmcode gedacht: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;, lw=3, ls=&quot;--&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh3.png]]

Einige weitere Bespiele zu &lt;code&gt;ls&lt;/code&gt;&lt;/code&gt;:
* - ... durchgezogene Linie
* -. ... Strichpunkt-Linie
* dashed ... gestrichelte Linie 

==== Marker ====
Desweiteren kann man Marker verwenden.

Beispiel:

 import matplotlib.pyplot as plt
 
 plt.plot(10, 10, &quot;ob&quot;, markersize=30)
 plt.plot(20,20, &quot;.r&quot;)
 plt.plot(30,30, &quot;Dg&quot;, ms=15)
 plt.plot(40, 40, &quot;ok&quot;, ms=20, mec=&quot;#FF5733&quot;, mew=3)
 plt.plot(50, 50, &quot;vk&quot;, ms=20, mec=&quot;yellow&quot;, mew=3)
 plt.grid()
 plt.show()


Das erste Zeichen im String nach den Koordinaten im plot-Befehl symbolisiert die Form (z.B. o für einen Kreis). Das zweite Zeichen steht für die Farbe (z.B. b für blue). &lt;code&gt;markersize&lt;/code&gt; oder &lt;code&gt;ms&lt;/code&gt; setzt die Größe des Markers.

Ausgabe:

[[Bild:PythonIng_formatpara1.svg|200px]]

Einige weitere Marker:
* * ... Stern
* + ... Plus
* h oder H ... Sechseck

Man kann mit den Parametern 
* &lt;code&gt;markeredgecolor&lt;/code&gt; oder kurz &lt;code&gt;mec&lt;/code&gt; die Farbe des Markerrandes
* &lt;code&gt;markeredgewidth&lt;/code&gt; oder kurz &lt;code&gt;mew&lt;/code&gt; die Dicke des Randes
* &lt;code&gt;markerfacecolor&lt;/code&gt; oder kurz &lt;code&gt;mfc&lt;/code&gt; die Innenfarbe des Markers
bestimmen.

=== Funktion in Parameterdarstellung ===
Es soll die archimedische Spirale &lt;math&gt;x = t \cos(t), y = t  \sin(t)&lt;/math&gt; im Intervall &lt;math&gt;[0, 6\pi[&lt;/math&gt; gezeichnet werden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
  
 plt.show()

[[Datei:PythonIng_spirale1.png]]

Diese Darstellung erscheint verzerrt. Will man gleiche Achsenskalierungen, so kann man den plt.axis()-Befehl verwenden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
 plt.axis(&quot;equal&quot;)
 
 plt.show()
 
[[Datei:PythonIng_spirale2.png]]

=== Funktion in Polardarstellung ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 fig = plt.figure()
 ax = fig.add_subplot(projection=&quot;polar&quot;)
 r = np.arange(0, 1, 0.01)
 theta = r**3
 line = ax.plot(theta, r)
 
 plt.show()

[[Datei:PythonIng_polar1.png]]

=== Logarithmische Achsenskalierung ===
==== Semilog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.semilogy()
 plt.show()

Ausgabe:

[[Datei:PythonIng_semilog1.png]]

==== LogLog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.loglog()
 plt.show()

[[Datei:PythonIng_loglog1.png]]

=== Gefüllte Fläche ===
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.arange(0, 3, 0.1)
 
 y1 = 3*x - 1
 y2 = x**2
 
 plt.plot(x, y1, x, y2, color='black')
 plt.fill_between(x, y1, y2, where=y1&gt;=y2)
 
 plt.show()

[[Datei:PythonIng_gefuellt.png]]

=== Linien, Pfeile, Rechtecke, Kreise und Texte ===
 import matplotlib as mpl
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 r = mpl.patches.Rectangle((0, 0), 3, 3, angle=30, fill=False)
 c = mpl.patches.Circle((4, 4), 2, fill=False)
 
 ax.add_patch(r)
 ax.add_patch(c)
 ax.plot([-2, 7], [-2, 0], color=&quot;black&quot;)
 ax.arrow(0, 7, 5, 0, length_includes_head=True, head_width=0.5, head_length=1.5,
          color=&quot;black&quot;)
 
 ax.set_aspect(&quot;equal&quot;)
 
 plt.axis([-3, 8, -3, 8])
 plt.show() 

[[Datei:PythonIng_linien_pfeile_etc.png]]

Text kann mit &lt;code&gt;ax.text(x, y, &quot;Text&quot;)&lt;/code&gt; hinzugefügt werden, bspw.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 ax.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

Oder einfacher auch ohne &lt;code&gt;subplots&lt;/code&gt;

 import matplotlib.pyplot as plt
 
 plt.text(0.1, 0.1, &quot;Hallo&quot;)
 plt.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

[[Datei:PythonIng_text1.png]]

Auch Sonderzeichen (griechische Buchstaben etc.) können verwendet werden (siehe dazu auch [https://matplotlib.org/stable/users/explain/text/mathtext.html]).

 import matplotlib.pyplot as plt
 
 plt.text(.3, .5,
          r'$\Omega\ \psi\ \oint\ \nabla\ \dot a\ \frac{a}{b}\ a_b$',
          size=&quot;20&quot;)
 plt.show() 

[[Datei:PythonIng_text20.svg]]

Jetzt wird noch gezeigt, wofür &lt;code&gt;subplots&lt;/code&gt; sinnvoll eingesetzt werden können.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(0.1, 0.1, &quot;Hallo&quot;)
 ax[1].text(0.1, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
            rotation=30.0)
 
 plt.show()

[[Datei:PythonIng_text2.png]]

=== Anmerkungen hinzufügen ===
Anmerkungen (engl. annotations) lassen sich mit matplotlib einfach hinzufügen. Unter Anmerkung wird hier ein Pfeil mit Text verstanden.

Beispiel:

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 ax.plot([1,10], [1,10])
 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
             arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0))
 plt.show()

Ausgabe:

[[Datei: PythonIng_ann1.svg|400px]]

&lt;code&gt;shrink&lt;/code&gt; verkürzt den Pfeil. Sinnvoll sind beim obigen Beispiel Werte irgendwo zwischen 0.0 und 0.3.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie verschiedene Pfeillängen aus. 

Die Schriftgröße verändern können Sie übrigens mit &lt;code&gt;fontsize&lt;/code&gt; oder &lt;code&gt;size&lt;/code&gt;, z.B.

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0), fontsize=25)

Eine andere Schreibweise für Dictionaries, die wir weiter oben schon kennengelernt haben, die wir aber nochmals explizit aufschreiben wollen, ist

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops={&quot;facecolor&quot;:&quot;red&quot;, &quot;shrink&quot;:0.0})

=== Figure, Axes etc.===
[[Bild:PythonIng_figure33.svg|350px]]

* fig (figure) ... das übergeordnete Fenster
* ax (axes) ... &quot;Plot&quot;, das eigentliche Zeichenfenster
* axis ... die Koordinatenachsen
* spine ... Begrenzungslinien des Zeichenfensters
* tick ... Markierung an den Achsen des Zeichenfensters

Beispiel (eine figure mit 6 axes, ax-Titel, y-axis-Titel):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=3, ncols=2)
 
 ax[0][0].text(0.1, 0.5, &quot;11&quot;)
 ax[0][1].text(0.1, 0.5, &quot;12&quot;)
 ax[1][0].text(0.1, 0.5, &quot;21&quot;)
 ax[1][1].text(0.1, 0.5, &quot;22&quot;)
 ax[2][0].text(0.1, 0.5, &quot;31&quot;)
 ax[2][1].text(0.1, 0.5, &quot;32&quot;)
 
 ax[0][0].set(ylabel=&quot;y-label&quot;, title=&quot;axes 1&quot;)
 
 plt.show()

[[Bild:PythonIng_figure34.png|350px]]

Beispiel (Achsenbereiche setzen):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 
 ax[0].axis((-1, 10, 1, 12))
 
 plt.show()

[[Bild:PythonIng_figure35.svg|350px]]

Beispiel (Gitter einschalten): 

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 ax[0].axis((-5, 10, 1, 12))
 ax[0].minorticks_on()
 ax[0].grid(which='minor')
 ax[1].grid(which='major')
 plt.show()

[[Bild:PythonIng_figure36.svg|350px]]

Beispiel (ticks setzen)

 import matplotlib.pyplot as plt
 import matplotlib.ticker as tick
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 pos = [0, .2, .5]
 lab = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
 
 ax.xaxis.set_major_locator(tick.FixedLocator(pos))
 ax.xaxis.set_major_formatter(tick.FixedFormatter(lab))
 
 plt.show()

[[Bild:PythonIng_figure37.svg|350px]]

Beispiel (Achsenkreuz beliebig setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 ax.spines['top'].set_color('none')
 ax.spines['right'].set_color('none')
 ax.spines['bottom'].set_position(('data', 0.3))
 ax.spines['left'].set_position(('data', 0.5))
 
 plt.show()

[[Bild:PythonIng_figure38.svg|350px]]

Beispiel (Inset):

 import matplotlib.pyplot as plt
 
 # Hauptplot erstellen
 fig, ax = plt.subplots()
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 
 # Inset hinzu:
 axin = ax.inset_axes([0.4, 0.4, 0.3, 0.3])
 axin.text(0, 0, &quot;Servus&quot;)
 axin.plot()
 
 plt.show()

[[Bild:PythonIng_figure40.svg|350px]]

Beispiel (Hintergrundfarben setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.set_facecolor(&quot;green&quot;)
 fig.set_facecolor(&quot;yellow&quot;)
 
 plt.plot([1, 3], [6, 8])
 plt.show()

[[Bild:PythonIng_figure39.svg|300px]]

=== GridSpec ===
Mit figures und axes lassen sich schon jede Menge an Grafikdetails einstellen. GridSpec ist dann der Turbo oder Raketenantrieb den matplotlib eingebaut hat. Naja, vielleicht ist das etwas übertrieben, aber GridSpec ist sozusagen ein flexibler Layout-Manager. Bisher haben wir immer gleich große axes gezeichnet. Mit GridSpec können wir Subplots über mehrere Zeilen und Spalten ziehen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 gs = fig.add_gridspec(3, 3)
 
 ax1 = fig.add_subplot(gs[0, :])
 ax1.set_title(&quot;Bereich 1: gs[0, :]&quot;)
 
 ax2 = fig.add_subplot(gs[1:, 0])
 ax2.set_title(&quot;Bereich 2: gs[1:, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 1:])
 ax3.set_title(&quot;Bereich 3: gs[1, 1:]&quot;)
 
 ax4 = fig.add_subplot(gs[2, 1:])
 ax4.set_title(&quot;Bereich 4: gs[2, 1:]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec1.svg|350px]]

Erklärung zu &lt;code&gt;(gs[zeile, spalte])&lt;/code&gt;: Slicing; damit legen Sie fest, welche Zellen ein Subplot belegt. Achtung! Die Indizes beginnen bei 0 und nicht bei 1 (d.h., die erste Zeile/Spalte hat den Index 0)
* : ... alle 
* 1: ... 1 bis Ende
* etc.

&lt;code&gt;constrained_layout=True&lt;/code&gt; sorgt dafür, dass sich die Subplots nicht überlappen.

Aber auch die Spaltenbreiten und Zeilenhöhen lassen sich anpassen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 
 # Verhältnis erste zu zweite Zeile = 1.5:1
 # Verhältnis erste zu zweite Spalte  = 1:4
 gs = fig.add_gridspec(2, 2, figure=fig, height_ratios=[1.5, 1], width_ratios=[1, 4])
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax1.set_title(&quot;Bereich 1: gs[0, 0]&quot;)
 
 ax2 = fig.add_subplot(gs[0, 1])
 ax2.set_title(&quot;Bereich 2: gs[0, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 0])
 ax3.set_title(&quot;Bereich 3: gs[1, 0]&quot;)
 
 ax4 = fig.add_subplot(gs[1, 1:])
 ax4.set_title(&quot;Bereich 4: gs[1, 1]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec2.svg|350px]]

Auch die Ränder lassen sich einstellen.

Beispiel 1:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.1, right=0.9, bottom=0.1,
                        top=0.9, wspace=0.2, hspace=0.2)
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec3.svg|300px]]

* hspace ... height space, vertikaler Abstand zwischen den Zeilen
* wspace ... width space, horizontaler Abstand zwischen den Spalten

Und im Vergleich dazu Beispiel 2:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.3, right=0.7, bottom=0.3, 
                        top=0.7, wspace=0.3, hspace=0.3) 
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec4.svg|300px]]

Es gibt noch einige weitere Details, die sich mit GridSpec variieren lassen (z.B. SubGridSpec ... verschachtelte Grid-Layouts). Aber wir belassen es vorerst dabei. Das bisher Gezeigte sollte für die meisten Probleme ausreichend sein.

=== Aufgaben ===
* Zeichnen Sie die Strophoide &lt;math&gt;x = \frac{a(t^2-1)}{t^2+1}, y = \frac{at(t^2-1)}{t^2+1}, a = 2, -3 \leq t \leq 3&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_strophoide.jpg|300px|center]]

* Zeichnen Sie die verschlungene Hypozykloide &lt;math&gt;x = (R-r)\cos t + c\cos\frac{R-r}{r}t, y = (R-r)\sin t - c\sin\frac{R-r}{r}t, c = 3, r = 2, R = 6, -15 \leq t \leq 15&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_hypozykloide.jpg|300px|center]]

* Testen Sie bei den obigen Übungsaufgaben verschiedene Linienstile und Farben. Farben können mit dem plt.plot()-Parameter color gewählt werden.

* Testen Sie bei den obigen Übungsaufgaben verschiedene Werte für a, c, r und R.

* Zeichnen Sie folgendes Bild (die Achsenbeschriftungen positionieren Sie z.B. mit den Befehlen &lt;code&gt;ax.set_xlabel(&quot;x&quot;, loc=&quot;right&quot;); ax.set_ylabel(&quot;y&quot;, loc=&quot;top&quot;)&lt;/code&gt;):

[[Bild:PythonIng_aufgabe24.svg|400px|center]] 

* Zeichnen Sie mit Python, matplotlib und NumPy folgendes Bild:

[[Bild:PythonIng_figure41.svg|400px|center]]

* Zeichnen Sie mit GridSpec ein Layout, das in etwa wie folgendes aussieht (&lt;code&gt;height_ratios=[1, 2], width_ratios=[2, 1]&lt;/code&gt;):

[[Bild:PythonIng_aufgabe23.svg|300px|center]]

== 3D ==
=== Räumliche Kurven ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0, 6*np.pi, 0.1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 z = t
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot(x, y, z)
 
 plt.show()

[[Datei:PythonIng_raumkurve1.png]]

=== Flächen ===
 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche1.png]]

Das Ganze in Netzdarstellung läßt sich so programmieren: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.5)
 y = np.arange(0, 10, 0.5)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_wireframe(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche2.png]]

Ein etwas komplexeres Beispiel:

 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0.1, 10, 0.1)
 y = np.arange(0.1, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z1 = np.sin(x) + 3 * np.cos(y)
 z2 = np.sin(x) + np.log(y)
 z3 = x + np.cos(y)
 z4 = x**2 - y
  
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;}, nrows=2, ncols=2)
 
 ax[0][0].plot_surface(x, y, z1)
 ax[0][1].plot_surface(x, y, z2)
 ax[1][0].plot_surface(x, y, z3)
 ax[1][1].plot_surface(x, y, z4)
 
 plt.show()

[[Datei:PythonIng_subplot1.png]]

Man beachte, dass man die Unterbilder im Bild nach dem Ausführen des Scripts z.B. mit der mittleren Maustaste einzeln drehen, oder über die Einträge in der Menüzeile einzeln bearbeiten kann. Mit ein paar Zeilen Programmtext lässt sich also eine Menge an Funktionalität generieren.

Die Farbgebung lässt sich über &lt;code&gt;colormaps&lt;/code&gt; variieren.

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm)
 
 plt.show()

[[Datei:PythonIng_colormap1.png]]

Es gibt eine Menge an Colormaps, z.B. &lt;code&gt;plasma, Greys, Dark2, ocean&lt;/code&gt;. Zwecks detaillierterer Infos siehe die matplotlib-Dokumentation. &lt;small&gt;Verwendet man die IDE namens IDLE, so gibt es dort auch die automatische Codevervollständigung. D.h. es werden alle Möglichkeiten (in unserem Fall nach dem Eintippen von &lt;code&gt;cm.&lt;/code&gt; alle verfügbaren Colormaps) angezeigt.&lt;/small&gt;

Die &quot;edgecolor&quot; und Linienbreite können auch frei gewählt werden:

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm, edgecolor=&quot;black&quot;, linewidth=1.0)
 
 plt.show()

[[Datei:PythonIng_colormap2.png]]

=== Höhenlinien ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 ax.contour(x, y, z)
 
 plt.show()

[[Datei:PythonIng_höhenlinien1.png|400px]]

Etwas abgewandelt sieht das so aus: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contour(x, y, z)
 ax.clabel(hl, inline = True)
 
 plt.show()

[[Datei:PythonIng_höhenlinien2.png|400px]]

Und noch eine Variante (mit einem Farbbalken) sei gezeigt. 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contourf(x, y, z)
 fig.colorbar(hl) 
 
 plt.show()

[[Datei:PythonIng_höhenlinien5.svg|400px]]

=== Aufgaben ===
* Zeichnen Sie die räumliche Kurve &lt;math&gt;x = 2 \cdot \cosh(t)&lt;/math&gt;, &lt;math&gt;y = 5 \cdot \sin(t)&lt;/math&gt;, &lt;math&gt; z = t^{2} - t&lt;/math&gt;, &lt;math&gt;0 \leq t \leq 3\pi&lt;/math&gt;.
* Zeichnen Sie die Fläche &lt;math&gt;z = \log(x) + \cos(y)&lt;/math&gt;.

== Animationen und fortgeschrittenes 3D ==
=== Mit matplotlib ===
Auch mit matplotlib sind Animationen möglich. Das ist ein bisschen komplizierter und wird deshalb hier nur mit einem sehr einfachen Beispiel dargestellt (bei Interesse siehe z.B. auch das [https://matplotlib.org/stable/users/explain/animations/animations.html#animations Animations using Matplotlib-Tutorial]).

 import matplotlib.pyplot as plt
 import matplotlib.animation as ani
 import matplotlib
 import numpy as np
 
 def update(frame):
     line.set_xdata(x[:frame])
     line.set_ydata(y[:frame])
     return (line)
 
 fig, ax = plt.subplots()
 
 x = np.arange(0, 10, .1)
 y = np.sin(x)
 
 line, = ax.plot(x[0], y[0])
 ax.set(xlim=[0, 10], ylim=[-1, 1])
 
 a = ani.FuncAnimation(fig=fig, func=update, frames=100, interval=20)
 plt.show()
 
 # Speichere die Animation in einem animierten GIF (optional)
 a.save(filename=&quot;c:/tmp/PythonIng_anim5.gif&quot;, writer=&quot;pillow&quot;)

[[Datei:PythonIng_anim5.gif]]

Es wird eine Sinuskurve auf den Bildschirm gezeichnet. In der letzten Zeile wird diese Animation in ein animiertes GIF gespeichert. Das ist natürlich optional und kann auch weggelassen werden.

=== Mit VPython ===
Aber auch mit dem Modul VPython lassen sich einfache 3D-Animationen erstellen. VPython ist ein externes Modul, das vorab installiert werden muss. Unter openSUSE Tumbleweed gibt es dzt. kein entsprechendes rpm-Paket. Die übliche Methode der Installation mittels YaST oder zypper ist somit nicht möglich. Auch eine direkte Verwendung von pip führt nur zu einer Fehlermeldung (&lt;code&gt;error: externally-managed-environment&lt;/code&gt;). Es empfiehlt sich dort folgende Vorgehensweise:
# Erstelle zuerst eine virtuelle Umgebung, z.B.: &lt;code&gt;python3.11 -m venv ~/tmp/venv1&lt;/code&gt;
# Wechsle das Verzeichnis: &lt;code&gt;cd ~/tmp/venv1/bin&lt;/code&gt;
# Installiere das entsprechende Paket: &lt;code&gt;./pip install vpython&lt;/code&gt;
# Führe das entsprechende Skript aus: &lt;code&gt;./python ~/tmp/test1.py&lt;/code&gt;

Aktuell (März 2026) ist dieses Programmpaket lt. der [https://vpython.org/presentation2018/install.html VPython-Homepage] nur für die Python-Versionen 3.8 bis 3.12 verfügbar.

Ein Beispiel zu einer einfachen Animation wird nachfolgend geliefert.

 from vpython import *
 
 scene.width = 1200
 scene.height = 600
 scene.center = vector(20,0,0)
 scene.background = color.white
 
 cylinder(pos=vector(0,0,0), axis=vector(20,0,0), radius=5, 
         color=color.blue)
 cone(pos=vector(0,0,0), axis=vector(-10,0,0), radius=5, 
         color=color.blue)
 helix(pos=vector(20,0,0), axis=vector(40,0,0), radius=2, 
         coils=10, thickness=0.5, color=color.blue)
 
 ball = sphere(pos=vector(20,0,0), color = color.green, radius = 1)
 ball.p = vector(0.15, 0, 0)
 
 toc = True
 
 while True:
     rate(200)
     if(ball.pos.x &lt;= 60 and toc == True):
         ball.pos += ball.p
     else:
         toc = False
         ball.pos -= ball.p
         if(ball.pos.x &lt;= 20 and toc == False):
             toc = True

[[Datei:PythonIng_vpython_anim.JPG]]

Idealerweise öffnet sich beim Ausführen des Scripts ein Browserfenster. Darin wird die programmierte Animation gezeigt (siehe auch den obigen Screenshot). Eine Größenänderung können Sie mit der mittleren Maustaste initiieren. Die Szenerie drehen können Sie mit der rechten Maustaste.

=== Mit build123d ===
Hiermit lassen sich einfach 3D-Modelle für CAD-Systeme erstellen. [https://build123d.readthedocs.io/en/latest/ build123d] ist ein externes Modul und muss vorab, wie schon für mehrere andere Module gezeigt, installiert werden (pip, venv etc.).

Beispielcode:

 from build123d import *
 
 # Bauteil
 with BuildPart() as bauteil: 
     # Zylinder erstellen
     Cylinder(100, 60)
        
     # Bohrung
     with BuildSketch(bauteil.faces().sort_by(Axis.Z)[-1]) as loch:
         Circle(radius=10)
     # negativ extrudieren
     extrude(amount=-60, mode=Mode.SUBTRACT)
     
     # Dem Bauteil z.B. die Farbe rot zuweisen
     # bauteil.part.color = Color(&quot;red&quot;, alpha=1.0)
 
     # Fertiges Modell exportieren
     export_step(bauteil.part, &quot;bauteil.step&quot;)

Ausgabe ({{W|Standard for the exchange of product model data | STEP}}-Datei, z.B. in {{W|FreeCAD}} importiert, Screenshot):

[[Datei:PythonIng_build123d.jpg | 300px]]

FreeCAD ist ein freies 3D-CAD-System. Die [[Ing_Mathematik:_Python#FreeCAD | Makroprogrammierung]] in diesem System wird später noch gezeigt. STEP steht für &quot;'''St'''andard for the '''e'''xchange of '''p'''roduct model data&quot; und ist ein Datenaustauschformat.

=== Mit VTK ===
Komplexer, aber auch mächtiger als VPython ist die Verwendung von VTK ('''V'''isualization '''T'''ool'''k'''it). Genauer gesagt des Python-Wrappers von VTK. Dieses externe Python-Modul muss vorab installiert werden (z.B. mittels YaST, pip oder in eine virtuelle Umgebung). VTK ist eine Softwarebibliothek zur 3D-Visualisierung und wurde ursprünglich in C++ geschrieben. Verbreitet eingesetzt wird diese Bibliothek in der Wissenschaft und Forschung, z.B. 
* in der medizinischen Bildgebung
* für Strömungssimulationen
* für Klimadaten

VTK funktioniert nach dem {{W|Grafikpipeline|Pipeline-Prinzip}}:

 Source (Quellen) -&gt;  Filter -&gt; Mapper (Senken) -&gt; Actor/Renderer

Daten fließen von den Quellen zu den Senken.

Als einfaches Beispiel wird die Darstellung eines Zylinders gezeigt, der mit den Maustasten gedreht oder in der Größe geändert werden kann:

 import vtk
 
 # Zylinder erzeugen
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 # Geometrie in darstellbare Daten umwandeln
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 # Objekt in der Szene
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 # Szene verwalten
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 # Render-Fenster
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 # Maus/Tastatur-Steuerung
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 # Starten
 render_window.Render()
 interactor.Start()

Ausgabe:

[[Datei:PythonIng_VTK_1.png]]

Gleiches Beispiel wie oben, aber mit einer Animationssequenz:

 import vtk
 import time
 
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     render_window.Render()
     time.sleep(0.01)

Das Grafikfenster schließt sich nach Ablauf der Schleife. Das Fenster bleibt geöffnet, wenn Sie am Programmende folgenden Befehl hinschreiben

 interactor.Start()

Um den animierten Zylinder grün einzufärben, müssen Sie Folgendes im obigen Programm ergänzen (Farbnamen):

 colors = vtk.vtkNamedColors()
 actor.GetProperty().SetColor(colors.GetColor3d(&quot;Green&quot;))

Als Namen können Sie u.a. die CSS3 Web-Farben verwenden (siehe z.B. [https://wiki.selfhtml.org/wiki/Farbe/Farbangaben] und {{W|Webfarbe#CSS_3}}).

Alternativ funktioniert auch das ({{W|RGB-Farbraum|RGB}}):

 actor.GetProperty().SetColor(0.0, 0.6, 0.0)

Wie der Zylinder mit einer Textur versehen wird, zeigt folgendes Programm:

 import vtk
 import time
 
 cylinder = vtk.vtkCylinderSource()
 cylinder.SetResolution(30)
 cylinder.SetHeight(3.0)
 cylinder.SetRadius(1.0)
 cylinder.CappingOn()
 
 texture_coords = vtk.vtkTextureMapToCylinder()
 texture_coords.SetInputConnection(cylinder.GetOutputPort())
 texture_coords.PreventSeamOn()
 
 reader = vtk.vtkJPEGReader()
 reader.SetFileName(&quot;PythonIng_textur.jpg&quot;)
 
 texture = vtk.vtkTexture()
 texture.SetInputConnection(reader.GetOutputPort()) 
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(texture_coords.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 actor.SetTexture(texture)
 
 renderer = vtk.vtkRenderer()
 renderWindow = vtk.vtkRenderWindow()
 renderWindow.AddRenderer(renderer)
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(renderWindow)
 
 renderer.AddActor(actor)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     renderWindow.Render()
     time.sleep(0.01)
 
 interactor.Start()

&lt;gallery&gt;
PythonIng_textur.jpg | Textur-Datei
PythonIng_VTK_2.png | Ausgabe (Screenshot)
&lt;/gallery&gt;

== Sonstige Grafikbibliotheken ==
=== Py5 ===
Im Buch ''Iacono et al.: Programmieren trainieren, mit über 150 Workouts in Java und Python; 3. Aufl., Hanser, 2023'' werden zahlreiche Aufgaben gestellt, die u.a. mit Processing zu lösen sind.  Processing ist eine einfache Programmiersprache und Entwicklungsumgebung. Warum ich das erwähne? Weil in älteren Processing-Versionen auch die Programmiersprache Python 2 abgedeckt war. Bei neueren Versionen gibt es keine Python-Anbindung mehr (getestet nur mit openSUSE Tumbleweed und Python 3). Somit funktioniert der Python-Teil im genannten Buch zum Teil nicht mehr. Ist das tragisch, oder kann das Buch weggeschmissen werden? Nein! Es gibt Alternativen zu Processing. Zum einen die im Buch selbst genannten Bibliotheken tkinter oder pygame. Pygame wird dort auch kurz anhand eines Beispiels thematisiert. Aber noch besser ist es, die py5-Bibliothek zu verwenden (lt. Google KI vom 30. Sept. 2026: ''Der echte, moderne „spirituelle Nachfolger“''). Damit ist die Funktionalität von Processing gewährleistet. Man kann aber beliebige Editoren oder IDEs zur Programmerstellung verwenden, ohne an Processing als IDE gebunden zu sein. Nachfolgend werden ein paar Beispiele zu dieser externen Bibliothek gegeben. Der erste Schritt ist wieder, die py5-Bibliothek zu installieren (z.B. mittels pip in eine virtuelle Umgebung; Python&gt;=3.10 und ein JDK&gt;=17 müssen auch installiert sein (Stand Okt. 2026)). Dann kann es schon mit dem Programmieren losgehen.

Beispiel (angelehnt an die ''Aufgabe W.2.3 Haus'' des genannten Buchs, jedoch etwas erweitert):

 import py5
 
 def setup():
     py5.size(600, 600)            # Fenstergröße 600px x 600px 
     py5.background(255, 255, 255) # Hintergrundfarbe ... weiss
     
 def draw():
     # Haus zeichnen
     py5.fill(255, 255, 255)       # Hintergrundfarbe ... weiss
     py5.stroke(255, 0, 0)         # Linienfarbe ... rot 
     py5.stroke_weight(3)          # Linienbreite ... 3px
     py5.rect(150, 200, 300, 300)  # Rechteck zeichnen (x, y, b, h)
     py5.triangle(150, 200, 300, 100, 450, 200) # Dreieck zeichnen
     py5.circle(250, 300, 70)      # Kreis zeichnen (x, y, d)   
     
     # Bemassung zeichnen
     py5.stroke(0, 255, 0)
     py5.stroke_weight(1)
     py5.line(300, 100, 550, 100)  # Linie zeichnen
     py5.line(450, 200, 550, 200) 
     py5.line(450, 500, 550, 500) 
     py5.line(150, 500, 150, 550)
     py5.line(450, 500, 450, 550)
     py5.text_size(20)             # Textgroesse
     py5.fill(0, 255, 0)           # Textfarbe
     py5.text(&quot;300&quot;, 280, 550)     # Text zeichnen
     py5.text(&quot;100&quot;, 500, 150)
     py5.text(&quot;300&quot;, 500, 350)  
 
     # Gedrehtes Rechteck zeichnen
     py5.stroke(255, 255, 0)
     py5.stroke_weight(3)
     py5.fill(200, 200, 200) 
     py5.translate(320, 260)  
     py5.rotate(0.3)               # Drehung (in Radiant)
     py5.rect(0, 0, 100, 50)
 
 # Startet den Sketch
 py5.run_sketch()


Ausgabe:

[[Datei:PythonIng_py5_1.png|300px]]

Das skizzierte Haus ist mit einer rudimentären Bemaßung versehen und hat zwei Fenster, ein rundes und ein gedrehtes, trübes rechteckiges. 

Beispiel (Mausoperationen):

 import py5
 
 def setup():
     py5.size(600, 600)            
     py5.background(255, 255, 255)
 
 def draw():
     pass
    
 def mouse_pressed():
     py5.text_size(15) 
     py5.fill(0, 0, 255)
     x = py5.mouse_x
     y = py5.mouse_y
     py5.text(&quot;(%d, %d)&quot; %(x, y), x, y) # Positionsdaten bei Maus-Klick schreiben
 
 py5.run_sketch()

Ausgabe:

[[Datei:PythonIng_py5_2.png|300px]]

Obiges Bild zeigt das Resultat nach einigen Mausklicks. Man erkennt, dass links-oben der Koordinatennullpunkt ist. Die x-Achse zeigt nach rechts, die y-Achse nach unten.

Beispiel (Fünfeck):

 import py5
 import random 
 
 def setup():
     py5.size(400, 400)
     py5.no_loop()       # statisches Bild (schont die Ressourcen)
 
 def draw():
     py5.translate(py5.width / 2, py5.height / 2)  # KS setzen
 
     radius = 150
     eck_anzahl = 5
 
     py5.fill(random.randint(0, 255), random.randint(0, 255), 
              random.randint(0, 255))    # Füllfarbe auf Zufallswert setzen
     py5.stroke(155, 0, 0)            
     py5.stroke_weight(5)     
     
     # Fünfeck als Polygon zeichnen
     py5.begin_shape()
     for i in range(eck_anzahl):
         winkel = i * py5.TWO_PI / eck_anzahl - py5.HALF_PI
         x = py5.cos(winkel) * radius
         y = py5.sin(winkel) * radius
         py5.vertex(x, y)
     py5.end_shape(py5.CLOSE)
 
 py5.run_sketch()

Ausgabe, bspw.:

[[Datei:PythonIng_py5_5.png|200px]]

&lt;u&gt;Kleine Aufgaben:&lt;/u&gt;
* Um die Funktionsweise von &lt;code&gt;py5.no_loop()&lt;/code&gt; zu verstehen, kommentieren Sie die Anweisung im Beispiel einfach aus, und starten Sie das Programm erneut.
* Zeichnen Sie ein Siebeneck.
* Was passiert, wenn man &lt;code&gt;py5.CLOSE&lt;/code&gt; im &lt;code&gt;py5.end_shape()&lt;/code&gt;-Befehl weglässt?

Beispiel (Grafik laden und zeichnen):

 import py5
 
 image1 = None
 
 def setup():
     global image1
     py5.size(600, 600)
     py5.no_loop()
     image1 = py5.load_image(&quot;PythonIng_py5_1.png&quot;)
 
 def draw():
     py5.image(image1, 0, 0)
 
 py5.run_sketch()

Hier wird einfach das Bild vom Haus-Beispiel (Screenshot von weiter oben) geladen und gezeichnet.

Beispiel (angelehnt an ''W.5.10 Wurfparabel'' des genannten Buches; mit OOP erstellt):

 import py5
 
 class Wurfparabel(py5.Sketch):
     def __init__(self, v0, angle):
         super().__init__()
         self.v0 = v0
         self.angle = self.radians(angle)
         self.g = 9.81
         self.t = 0.0
         self.scale = 1.5
 
     def settings(self):
         self.size(800, 600)
 
     def setup(self):        
         self.background(0, 0, 0)
         
     def draw(self):
         self.t += 0.1
 
         self.translate(50, 500)
       
         # KS Zeichnen
         self.fill(255, 255, 0)
         self.stroke(255, 255, 0)
         self.stroke_weight(1)
         self.line(0, 0, 0, -300)
         self.line(0, 0, 700, 0)
 
         # Punkt zeichnen
         cx = self.v0 * self.cos(self.angle) * self.t * self.scale
         cy = -(self.v0 * self.sin(self.angle) * self.t - \
                self.g/2 * self.t**2) * self.scale
         self.fill(255, 0, 0)
         self.stroke(255, 0, 0)
         self.circle(cx, cy, 3)
        
         # Stoppen bei Bodenkontakt
         if cy &gt;= -5:
             self.no_loop()
            
 def wurfparabel(v0=50, angle=45):
     sketch = Wurfparabel(v0, angle)
     sketch.run_sketch()
 
 v0 = float(input(&quot;v0 = &quot;))
 winkel = float(input(&quot;winkel = &quot;))
 wurfparabel(v0=v0, angle=winkel)

Eingabe auf der Konsole:

 v0 = 60
 winkel = 45

Ausgabe:

[[Datei:PythonIng_py5_13.png|200px]]

Die benötigten Formeln der Bewegungsgleichung kann man leicht herleiten, bzw. man benutzt folgende Grafik als Hilfestellung:

[[Datei:Wurfparabel_Zusammenfassung_aktualisierung.png|700px]]

&lt;u&gt;Aufgabe:&lt;/u&gt; Berechnen Sie den Scheitelpunkt und die Wurfweite bei gegebener Anfangsgeschwindigkeit und gegebenem Abwurfwinkel. Die Abwurfhöhe &lt;math&gt;y_0&lt;/math&gt; sei 0. Der Wurf soll auf der Erde stattfinden (g = 9.81 m/s²). Die dazu benötigten Formeln können aus obiger Grafik entnommen werden (oder Sie leiten sie selbst her). Geben Sie die Ergebnisse auf der Konsole aus.

Beispiel (eine einfache Animation):

 import py5
 
 i = 0
 
 def setup():
     py5.size(600, 600)
     py5.frame_rate(5)
     py5.stroke_weight(20)
 
 def draw():
     global i
     
     py5.background(255, 255, 255)
     py5.translate(py5.width/2, py5.height/2)
     py5.rotate(py5.PI/8 * i)    
 
     py5.line(-100, 0, 100, 0)
     i += 1
 
 py5.run_sketch()

Es wird eine rotierende Linie gezeichnet (z.B. wie bei einem Installationsprozess verwendet - zeigt an, dass der Installationsfortschritt nicht eingefroren ist). Hierbei ist nur aufzupassen, dass der Hintergrund in &lt;code&gt;draw()&lt;/code&gt; gesetzt wird, ansonsten würden die Linien additiv gezeichnet. Das ist zwar auch schön, aber eben nicht das gewünschte Resultat.

Hiermit belassen wir es mit der py5-Bibliothek und wenden uns wieder &quot;mathematischeren&quot; Themen zu.

= Vektoren und Matrizen =
== Zahlenfolgen ==
Für das Erstellen von Zahlenfolgen bieten sich die Funktionen &lt;code&gt;arange&lt;/code&gt; und &lt;code&gt;linspace&lt;/code&gt; aus dem &lt;code&gt;numpy&lt;/code&gt;-Modul an.

 from numpy import *
 
 start = 0
 stop = 10
 step = 2
 num = 10
 
 r = arange(start, stop, step)   # step ... Schrittweite
 l = linspace(start, stop, num)  # num ... Anzahl der Werte
 
 print(&quot;r = &quot;, r)
 print(&quot;l = &quot;, l)

Ausgabe:
 r =  [0 2 4 6 8]
 l =  [ 0.          1.11111111  2.22222222  3.33333333  4.44444444  5.55555556
   6.66666667  7.77777778  8.88888889 10.        ]

Bei &lt;code&gt;arange&lt;/code&gt; ist der &lt;code&gt;stop&lt;/code&gt;-Wert nicht im Ergebnis enthalten, bei &lt;code&gt;linspace&lt;/code&gt; standardmäßig aber sehr wohl. Jedoch kann man das bei &lt;code&gt;linspace&lt;/code&gt; auch ändern. Dann ist der Stoppwert nicht mehr enthalten: 

 linspace(start, stop, num, endpoint=False)

== Vektoren ==
Vektoren sollten jedem aus der Linearen Algebra bekannt sein. 

=== Arrays ===
In Python mit NumPy kann man Vektoren durch die Funktion array erzeugen.

 import numpy as np
 
 l1 = (-5, 3, 2)
 l2 = (1, 1, 4)
 
 a1 = np.array(l1)
 a2 = np.array(l2)
 
 a3 = a1 + a2
 a4 = 2 * a2
 
 print(a1)
 print(a2)
 print(a3)
 print(a3[2])
 print(a4)

Ausgabe:
 [-5  3  2]
 [1 1 4]
 [-4  4  6]
 6
 [2 2 8]

=== Zeilen- und Spaltenvektoren ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 print(z)
 print(s)

Ausgabe:
 [ [-5  3  2] ]
 [[1]
  [1]
  [4]]

=== Skalarprodukt ===
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4))
 
 skalarprodukt = np.dot(a1, a2)  
 
 print(skalarprodukt)

Ausgabe:
 6

=== Vektorprodukt ===
&lt;math&gt;a\ast b=\left(\begin{array}{c}
a_{1}\\
a_{2}\\
a_{3}
\end{array}\right)\ast\left(\begin{array}{c}
b_{1}\\
b_{2}\\
b_{3}
\end{array}\right)=\left(\begin{array}{c}
a_{2}b_{3}-a_{3}b_{2}\\
a_{3}b_{1}-a_{1}b_{3}\\
a_{1}b_{2}-a_{2}b_{1}
\end{array}\right)
&lt;/math&gt; 

Python-Code:
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4)) 
 
 vektorprodukt = np.cross(a1, a2) 
 
 print(vektorprodukt)

Ausgabe:
 [10 22 -8]

=== Transponierter Vektor ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 # transponierter Vektor
 z_tp = np.transpose(z)
 # transponierter Vektor
 s_tp = np.transpose(s)
 
 print(z_tp)
 print(s_tp)

Ausgabe:
 [[-5]
  [ 3]
  [ 2]]
 [ [1 1 4] ]

=== Vektorfelder visualisieren ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 # Daten generieren
 x = np.arange(0, 10, 1)
 y = np.arange(0, 10, 1)
 X, Y = np.meshgrid(x, y)
 U = X * Y
 V = Y + X
 
 # Plotten
 fig, ax = plt.subplots()
 
 ax.quiver(X, Y, U, V, angles='xy')
 
 plt.show()

Ausgabe:

[[Datei:PythonIng_quiver1.png]]

== Matrizen==
 import numpy as np
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 print(m1)

Ausgabe:
 [[1 2 3]
  [4 5 6]]

=== Zugriff auf Matrizenelemente ===
Beispiel:

 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 
 # Element aus Zeile 2 und Spalte 3 (Achtung! Index startet bei Null)
 print(m1[1,2])

Ausgabe:
 6

Visualisierung:
  
     0   1   2
   +-----------+
 0 | 1 | 2 | 3 |
   +-----------+
 1 | 4 | 5 | '''6''' |
   +-----------+


Beispiel:

 import numpy as np
 
 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
 
 B = np.matrix(A)     
 
 print(B[2::, ::2])

Ausgabe:

 [['20' '22']
  ['30' '32']
  ['40' '42']]

Mit der NumPy-Bibliothek funktioniert das zweidimensionale Slicing. Mit normalen Listen/Tupels geht das nicht, was wir schon früher thematisiert haben.

=== Addition und Subtraktion von Matrizen ===
 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 m2 = np.matrix([[0, 0, 2], [1, 3, 2]])
 
 print(m1 + m2)
 print(m1 - m2)

Ausgabe:
 [[1 2 5]
  [5 8 8]]
 [[1 2 1]
  [3 2 4]]

=== Transponierte Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 2, 3], [4, 5, 6]])
 mt = np.transpose(m) 
 
 print(m)
 print(mt)

Ausgabe:
 [[1 2 3]
  [4 5 6]]
 [[1 4]
  [2 5]
  [3 6]]

=== Rang einer Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 rg = np.linalg.matrix_rank(m)
 
 print(rg)

Ausgabe:
 2

=== Inverse Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 mi = np.linalg.inv(m)
 
 print(mi)

Ausgabe:
 [[ 1.   0.6]
  [-0.  -0.2]]

=== Multiplikation von Matrizen (falksches Schema) ===
 import numpy as np
 
 m1 = np.matrix([[1, 3, 4],  [0, -5, 1]])
 m2 = np.matrix([[1, 2], [2, 3], [0, 2]])
 
 print(m1 @ m2)

Ausgabe:
 [[  7  19]
  [-10 -13]]

=== Eigenwerte und Eigenvektoren ===
 import numpy as np
 
 m = np.matrix([[5, 8],  [1, 3]])
 D,V = np.linalg.eig(m)
 
 # Eigenwerte
 print(D)
 # Eigenvektoren
 print(V)

Ausgabe:
 [7. 1.]
 [[ 0.9701425  -0.89442719]
  [ 0.24253563  0.4472136 ]]

=== Teilmatrizen ===
 import numpy as np
 m = np.matrix([[1, 3, 4],  [0, -5, 1]])
 print(&quot;m = &quot;, m)
 
 # Erste Zeile extrahieren
 m1 = m[0,:]
 print(&quot;m1 = &quot;, m1)
 
 # Das Element aus der 1. Zeile und der 2. Spalte extrahieren
 m2 = m[0,1]
 print(&quot;m2 = &quot;, m2)
 
 # Zweite Spalte extrahieren
 m3 = m[:, 1]
 print(&quot;m3 = &quot;, m3)

Ausgabe:
 m =  [[ 1  3  4]
  [ 0 -5  1]]
 m1 =  [ [1 3 4] ]
 m2 =  3
 m3 =  [[ 3]
  [-5]]

=== Spezielle Matrizen ===
==== Nullmatrix ====
 import numpy as np
 z = np.zeros((3, 2))
 print(z)

Ausgabe:
 [[0. 0.]
  [0. 0.]
  [0. 0.]]

==== Einheitsmatrix ====
 import numpy as np
 z = np.eye(3)
 print(z)

Ausgabe:
 [[1. 0. 0.]
  [0. 1. 0.]
  [0. 0. 1.]]

==== Matrix mit lauter Einsen ====
 import numpy as np
 z = np.ones((3, 2))
 print(z)

Ausgabe:
 [[1. 1.]
  [1. 1.]
  [1. 1.]]

=== Spärlich besetzte Matrizen ===
Das Thema spärlich besetzter Matrizen wird hier nur kurz angerissen. Nähere Details siehe unter dem Weblink  [https://docs.scipy.org/doc/scipy/reference/sparse.html#module-scipy.sparse]. 

Beispiel:

 import numpy as np
 import scipy
 
 A = scipy.sparse.csr_array(np.eye(5))
 
 print(A)

Ausgabe:
 &lt;Compressed Sparse Row sparse array of dtype 'float64'
         with 5 stored elements and shape (5, 5)&gt;
   Coords        Values
   (0, 0)        1.0
   (1, 1)        1.0
   (2, 2)        1.0
   (3, 3)        1.0
   (4, 4)        1.0

csr steht für '''c'''ompressed '''s'''parse '''r'''ow.

Andere Möglichkeiten:
* coo-Format ('''coo'''rdinate Format): &lt;code&gt;scipy.sparse.coo_array()&lt;/code&gt;
* lil-Format ('''li'''st of '''l'''ists): &lt;code&gt;scipy.sparse.lil_array()&lt;/code&gt;
* csc-Format ('''c'''ompressed '''s'''parse '''c'''olumn): &lt;code&gt;scipy.sparse.csc_array()&lt;/code&gt;

Es gibt auch &lt;code&gt;scipy.sparse.csr_matrix()&lt;/code&gt; etc. Diese Befehle sind aber veraltet und es wird empfohlen, statt dessen die &lt;code&gt;..._array()&lt;/code&gt;-Funktionen zu verwenden.

&lt;u&gt;Aufgaben:&lt;/u&gt; 
Recherchieren Sie im Internet 
* generell zum Thema &quot;spärlich besetzte Matrizen mit Python&quot;.
* Was sind die Vor-/Nachteile von csr-arrays gegenüber coo- und lil-arrays?
* Wann verwendet man sinnvollerweise csr- und wann csc-arrays?
* Wie wandelt man coo-arrays in csr-arrays um?

= Lineare Gleichungssysteme =
Sei &lt;math&gt;Ax = b&lt;/math&gt; ein lineares Gleichungssystem. &lt;math&gt;A&lt;/math&gt; sei die Koeffizientenmatrix, &lt;math&gt;x&lt;/math&gt; der Lösungsvektor und &lt;math&gt;b&lt;/math&gt; ein bekannter Vektor.

Beispiel:
 import numpy as np
 
 A = np.array([[5, 1], [0, 2]])
 b = np.array([1, 2])
 
 x = np.linalg.solve(A, b)
 
 print(x)

Ausgabe:
 [0. 1.]

Siehe dazu auch das Kapitel [[Ing Mathematik: Numerisches Lösen von linearen Gleichungssystemen]]. Dort wird dieses Themengebiet u.a. mit weitergehenden Python-Skripten vertieft.

== Aufgabe ==
* Lösen Sie folgendes Gleichungssystem mittels Python (und zur Kontrolle auch händisch): 
 5x + 6y - 2z = 12
 3x - y  - 3z = 6
 2x + 2y + 4z = 5

= Polynome =
== Ein erstes einfaches Beispiel ==
Gegeben sei das Polynom &lt;math&gt;7x^3+5x^2+1&lt;/math&gt;. In Python:

 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p)

Ausgabe:
    3     2
 7 x + 5 x + 1

== Einzelne Polynomwerte berechnen ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p(1.5))

Ausgabe:
 35.875

== Polynome integrieren und differenzieren ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 
 # 1. Ableitung
 p1 = p.deriv()
 p2 = p.deriv(1)
 
 # 2. Ableitung
 p3 = p.deriv(2)
 
 # Integral
 p4 = p.integ()
 
 print(p1)
 print(p2)
 print(p3)
 print(p4)

Ausgabe:
     2
 21 x + 10 x
     2
 21 x + 10 x
 
 42 x + 10
       4         3
 1.75 x + 1.667 x + 1 x

== Nullstellen bestimmen ==
 import numpy as np
 
 p = np.poly1d([2, 5, 0, 4])
 r = np.roots(p)
 
 print(r)

Ausgabe:
 [-2.7621427 +0.j          0.13107135+0.84077099j  0.13107135-0.84077099j]

== Aufgaben ==
* Berechnen Sie den Wert für x = 3 des Polynoms &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Differenzieren und integrieren Sie das Polynom &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Berechnen Sie die Nullstellen von &lt;math&gt;y = 7x^5 - 3x^2 + 12&lt;/math&gt;.

= Nichtlineare Gleichungen und Gleichungssysteme =
== Nullstellenbestimmung ==
Löse eine beliebige Gleichung f(x) = 0, z.B. &lt;math&gt; f(x) = x^2 - 5\cos(x) - 10 = 0 &lt;/math&gt;:
 import scipy
 import numpy as np
 
 def f(x):
     return x**2 - 5*np.cos(x) - 10
    
 xstart = [-1, 1]        # Startwerte
 xn = scipy.optimize.root(f, xstart)
 
 print(xn.x)

Ausgabe:
 [-2.46813009  2.46813009]

Funktionsgraph:

[[Datei:octave_nichtlin2.jpg]]

== Gleichungssysteme ==
SymPy ist ein externes Modul, das symbolisches Rechnen ('''Sym'''bolic '''Py'''thon) ermöglicht. 

Folgende Aufgabe ist dem Buch &quot;Knorrenschild: Numerische Mathematik, Hanser, 2017, Seite 72&quot; entnommen. Zu lösen ist das nichtlineare Gleichungssystem

&lt;math&gt;f_1 = 2x_1 + 4x_2 = 0 &lt;/math&gt;

&lt;math&gt;f_2 = 4x_1 + 8x_2^3 = 0&lt;/math&gt;

Mit Python ist das so möglich:
 import sympy
 
 x1, x2 = sympy.symbols(&quot;x1 x2&quot;) 
 
 f1 = 2*x1 + 4*x2
 f2 = 4*x1 + 8*x2**3
 
 s = sympy.solve((f1, f2), x1, x2) 
 
 print(s)

Ausgabe:
 [(-2, 1), (0, 0), (2, -1)]

Plot:

[[Datei:IngPython_nl_gleichung1.svg|500px]]

= Komplexe Zahlen =
Die imaginäre Einheit wird in Python durch den Buchstaben &lt;code&gt;j&lt;/code&gt; symbolisiert. Darstellen kann man eine komplexe Zahl bekannterweise in mehreren Formen:
* Kartesische Darstellung &lt;math&gt;z = \Re(z) + j \cdot \Im(z)&lt;/math&gt;
* Polardarstellungen &lt;math&gt;z = r \cdot (\cos(\phi) + j \cdot \sin(\phi)) = r \cdot e^{j\cdot \phi}&lt;/math&gt;

Die konjugiert komplexe Zahl ist &lt;math&gt;z^* = \Re(z) - j \cdot \Im(z)&lt;/math&gt;

Nachfolgend einige mathematische Operationen mit Python und NumPy.

 import numpy as np
 
 z1 = 2 + 5j           # kartesische Darstellung
 z2 = 3 * np.exp(3j)   # Polardarstellung
  
 # Addition
 res = z1 + z2
 print(&quot;z1 + z2 = &quot;, res)
 
 # Multiplikation
 res = z1 * z2
 print(&quot;z1 * z2 = &quot;, res)
 
 # Realteil
 res = np.real(z2)
 print(&quot;Realteil von z2 = &quot;, res)
 
 # Imaginärteil
 res = np.imag(z2)
 print(&quot;Imaginaerteil von z2 = &quot;, res)
 
 # Betrag
 res = np.abs(z1)
 print(&quot;Betrag von z1 = &quot;, res)
 
 # Argument
 res = np.angle(z1)
 print(&quot;Argument von z1 = &quot;, res)
 
 # Konjugiert komplexe Zahl
 res = np.conj(z1)
 print(&quot;Konjugiert komplexe Zahl von z1 = &quot;, res)

Ausgabe:
 z1 + z2 =  (-0.9699774898013365+5.423360024179601j)
 z1 * z2 =  (-8.05675510050068-14.003167400647481j)
 Realteil von z2 =  -2.9699774898013365
 Imaginaerteil von z2 =  0.4233600241796016
 Betrag von z1 =  5.385164807134504
 Argument von z1 =  1.1902899496825317
 Konjugiert komplexe Zahl von z1 =  (2-5j)

= Interpolation =
 import numpy as np
 import scipy
 import matplotlib.pyplot as plt
 
 # Stützpunkte
 xp = np.arange(1, 6)
 yp = (0, -5, 2, 7, 6)
 
 ti = np.arange(1, 5, 0.01)
 
 i1 = scipy.interpolate.interp1d(xp, yp, kind = &quot;linear&quot;)
 i2 = scipy.interpolate.interp1d(xp, yp, kind = &quot;cubic&quot;) 
 
 plt.plot(xp, yp, &quot;rx&quot;)
 plt.plot(xp, i1(xp))
 plt.plot(ti, i2(ti))
 plt.show()

Ausgabe:

[[Datei:PythonIng_interpol1.png]]

= Differenzialrechnung =
== Numerisches Differenzieren ==
Als Beispiel differenzieren wir &lt;math&gt;y = 5x\sin{x}&lt;/math&gt; und stellen das Ganze grafisch dar.

 from findiff import Diff
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.linspace(0, 10, 1000)
 f = 5 * x * np.sin(x)
 dx = x[1] - x[0]
 
 # Ableitung
 d_dx = Diff(0, dx)
 df_dx = d_dx(f)
 
 # Grafik
 plt.plot(x, f, label = &quot;y&quot;)
 plt.plot(x, df_dx, label = &quot;y'&quot;)
 plt.grid()
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

Ausgabe:

[[Datei:octave_diff1.jpg]]

&lt;small&gt;findiff ist ein externes Modul. Dieses muss installiert werden (z.B. so: ...\Python\Scripts\pip.exe install --upgrade findiff). Für die Vorgehensweise unter openSUSE Tumbleweed siehe das Kapitel [[Ing_Mathematik:_Python#Mit_VPython | VPython]], nur dass das Ganze mit einer aktuelleren Python-Version exekutiert wird, z.B. mit Python 3.13.  Das im Buch &quot;Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler, Rheinwerk&quot; verwendete Modul &quot;scipy.misc&quot; ist veraltet (deprecated ... missbilligt). Lt. [https://docs.scipy.org/doc/scipy-1.17.0/dev/roadmap-detailed.html#misc SciPy-Dokumentation für die Version 1.17.0] wurden alle entsprechenden Features schon entfernt.&lt;/small&gt;

== Symbolisches Differenzieren ==
Differenzieren Sie die Funktionen &lt;math&gt;f_1(x) = x^2&lt;/math&gt; und &lt;math&gt;f_2(x) = \sin(x)\cos\left(\frac{x}{2}\right)&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2;
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 d1 = sympy.diff(f1, x)
 d2 = sympy.diff(f2, x)
 
 print(d1)
 print(d2)

Ausgabe:
 2*x
 -0.5*sin(0.5*x)*sin(x) + cos(0.5*x)*cos(x)

== Aufgaben ==
* Differenzieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.
* Differenzieren Sie die Funktion &lt;math&gt;y = \frac{\sinh(x)}{(1+x)}&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.

= Integralrechnung =
== Numerisches Integrieren ==
Berechnen Sie das Integral &lt;math&gt;\int_{0}^{3}x^2 dx&lt;/math&gt;.

 import scipy
 
 def f(x):
     return x**2
    
 i = scipy.integrate.quad(f, 0, 3)
 print(i)

Ausgabe:
 (9.000000000000002, 9.992007221626411e-14)

Das trifft den exakten Wert 9.0 ziemlich genau.

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} dx&lt;/math&gt;.

 import scipy
 import numpy as np
 
 def f(x):
     return 2**(-x)
   
 i = scipy.integrate.quad(f, 0, np.inf)
 print(i)

Ausgabe:
 (1.4426950408889556, 4.486558477977586e-09)

== Symbolisches Integrieren ==
Berechnen Sie &lt;math&gt;\int x^2 \text{d}x&lt;/math&gt; und &lt;math&gt;\int \sin{x}\cos{\frac{x}{2}} \text{d}x&lt;/math&gt;.
 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 i1 = sympy.integrate(f1, x)
 i2 = sympy.integrate(f2, x)
 
 print(i1)
 print(i2)

Ausgabe:
 x**3/3
 -0.666666666666667*sin(0.5*x)*sin(x) - 1.33333333333333*cos(0.5*x)*cos(x)

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} \text{d}x&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f = 2**(-x)
 i = sympy.integrate(f, (x, 0, sympy.oo))
 print(i)

Ausgabe:
 1/log(2)

&lt;code&gt;sympy.oo&lt;/code&gt; steht für das {{W|Unendlichzeichen}} &lt;math&gt;\infty&lt;/math&gt; (die liegende Acht oder das Möbiusband). Mit &lt;code&gt;sympy.pprint(i)&lt;/code&gt; ließe sich letzere Ausgabe etwas schöner schreiben:

   1   
 ──────
 log(2)

Man beachtete, &lt;code&gt;log&lt;/code&gt; steht hier für den natürlichen Logarithmus &lt;code&gt;ln&lt;/code&gt;.

== Aufgaben ==
* Integrieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; von 1 bis 5.
* Integrieren Sie die Funktion &lt;math&gt;y = x^3&lt;/math&gt; von 0 bis 4.
* Integrieren Sie &lt;math&gt;\int x^x(\log (x) + 1)\mathrm dx&lt;/math&gt; symbolisch.

= Gewöhnliche Differenzialgleichungen =
== DGL numerisch lösen ==
Für die Lösung von Differenzialgleichungen steht u.a. die Funktion scipy.integrate.solve_ivp() zur Verfügung. Diese Funktion implementiert auch das Runge-Kutta-Verfahren (RK45).

{{Wikipedia | Runge-Kutta-Verfahren}}

Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import scipy
 import numpy as np
 import matplotlib.pyplot as plt
 
 def dy_dx(x, y):
     return x**2 + y**3
 
 y0 = [1]
 xi = [0, 1]
 x = np.arange(0, 1, 0.01)
 
 z = scipy.integrate.solve_ivp(dy_dx, xi, y0, method=&quot;RK45&quot;, dense_output=True)
 y = z.sol(x)
 
 plt.plot(x, y.T)
 plt.grid()
 plt.show()

[[Datei:PythonIng_dgl1.png]]

== DGL symbolisch lösen ==
Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 print(lsg)

Ausgabe:
 [Eq(f(x), (-x**2)**(1/3)), Eq(f(x), (-x**2)**(1/3)*(-1 - sqrt(3)*I)/2), Eq(f(x), (-x**2)**(1/3)*(-1 + sqrt(3)*I)/2)]

Mit &lt;code&gt;sympy.pprint&lt;/code&gt; (pretty print) lässt sich die Ausgabe etwas übersichtlicher darstellen.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 sympy.pprint(lsg)

Ausgabe:
 ⎡                           _____                        _____            ⎤
 ⎢          _____         3 ╱   2                      3 ╱   2             ⎥
 ⎢       3 ╱   2          ╲╱  -x  ⋅(-1 - √3⋅ⅈ)         ╲╱  -x  ⋅(-1 + √3⋅ⅈ)⎥
 ⎢f(x) = ╲╱  -x  , f(x) = ────────────────────, f(x) = ────────────────────⎥
 ⎣                                 2                            2          ⎦

== Aufgaben ==
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \frac{1}{x\cdot y}&lt;/math&gt; mit Python. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;m' = -k\cdot m&lt;/math&gt;. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \sqrt{|y|}&lt;/math&gt;.

=Laplace-Transformation=
Laplace-Transformation:

&lt;math&gt;F(s) =\mathcal{L} \left\{f\right\}(s) = \int_{0}^{\infty} f(t) \mathrm e^{-st} \,\mathrm{d}t, \qquad s\in\mathbb{C}
&lt;/math&gt;

Inverse Laplace-Transformation:

&lt;math&gt;\mathcal{L}^{-1} \left\{F\right\}(t)
  = \frac{1}{2 \pi \mathrm j} \int_{ \gamma - \mathrm j \infty}^{ \gamma + \mathrm j \infty} \mathrm e^{st} F(s)\,\mathrm ds 
= \begin{cases}
      f(t) &amp; \text{für } t \geq 0 \\
      0    &amp; \text{für } t &lt; 0
    \end{cases}
&lt;/math&gt;

Siehe auch [[Ing_Mathematik:_Laplace-Transformation]]

Code:
 import sympy
 from sympy.abc import t, s
 
 # Laplace-Transformation der Funktion f(t) = 1 (Heaviside-Fkt.)
 f = 1
 # alternativ: f = sympy.Heaviside(t)
 F = sympy.laplace_transform(f, t, s, noconds=True)
 print(&quot;Laplace-Transformierte F(s):&quot;, F) 
 
 # Inverse Laplace-Transformation zurück in den Zeitbereich
 f_inv = sympy.inverse_laplace_transform(F, s, t)
 print(&quot;Inverse Transformation f(t):&quot;, f_inv)

Ausgabe:
 Laplace-Transformierte F(s): 1/s
 Inverse Transformation f(t): Heaviside(t)

Die Zeile

 from sympy.abc import t, s

steht alternativ für

 t = sympy.symbols(&quot;t&quot;)
 s = sympy.symbols(&quot;s&quot;)

&lt;u&gt;Aufgaben&lt;/u&gt;: Ermitteln Sie mittels SymPy die &lt;math&gt;\mathcal{L}&lt;/math&gt;-Transformierten und dann wieder die  &lt;math&gt;\mathcal{L}^{-1}&lt;/math&gt;-Transformationen (ähnlich wie beim obigen Beispiel):
* &lt;math&gt;\sin(t) \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;t^3 \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;\text{e}^{\omega t} \circ\! -\! \bullet \ ?&lt;/math&gt;

=Fourier-Reihen=
&lt;math&gt;
f(x)\approx \frac{a_{0}}{2}+\sum_{k=1}^{\infty}\left(a_{k}\cos\left(kx\right)+b_{k}\sin\left(kx\right)\right)
&lt;/math&gt;

&lt;math&gt;
a_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\cos\left(kx\right)\mathrm dx\quad\text{für }k\geq0
&lt;/math&gt;

&lt;math&gt;
b_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\sin\left(kx\right)\mathrm dx\quad\text{für }k\geq1
&lt;/math&gt;

Für die Sägezahnfunktion &lt;math&gt;y=x;\, 0 &lt; x &lt; 2\pi&lt;/math&gt; sei die Fourierreihe mit einem Python-Programm (unter Mithilfe von sympy) hergeleitet.

Code:

 from sympy import fourier_series, pi, symbols, pprint
 
 x = symbols('x')
 f = x
 s = fourier_series(f, (x, 0, 2*pi))
 pprint(s.truncate(n=4))

Ausgabe:

                        2⋅sin(3⋅x)    
 -2⋅sin(x) - sin(2⋅x) - ────────── + π
                            3

Siehe auch [[Ing Mathematik: Fourierreihen]].

Ein komplizierteres Beispiel:

[[Datei:IngMath fourier bsp13.svg | 300px]]

&lt;math&gt;0\le t &lt; T/2\text{:}\quad f(t) = H&lt;/math&gt;

&lt;math&gt;T/2 \le t \le T\text{:}\quad f(t) = \frac{2H}{T}\left( t-\frac{T}{2}\right)&lt;/math&gt;

Code:

 import sympy as sp
 
 H = sp.Symbol('H', positive=True)
 T = sp.Symbol('T', positive=True)
 t = sp.Symbol('t')
 
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T/2)),
     (2*H/T*(t-T/2), (t &gt; T/2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Ausgabe:

      ⎛2⋅π⋅t⎞        ⎛4⋅π⋅t⎞        ⎛6⋅π⋅t⎞          ⎛2⋅π⋅t⎞          ⎛6⋅π⋅t⎞      
 H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   2⋅H⋅cos⎜─────⎟   2⋅H⋅cos⎜─────⎟      
      ⎝  T  ⎠        ⎝  T  ⎠        ⎝  T  ⎠          ⎝  T  ⎠          ⎝  T  ⎠   3⋅H
 ──────────── - ──────────── + ──────────── + ────────────── + ────────────── + ───
      π             2⋅π            3⋅π               2                 2         4 
                                                    π               9⋅π

=Rechnen mit wirklich großen Zahlen=
Bekannt ist, dass Python kaum Einschränkungen beim Wertebereich von Ganzzahlen hat, z.B.

 print(10**300)

Ausgabe (gekürzt):

 100000000000000000000...00000000000000000000000000000000000000000000000000000000000000000000000

Ähnliches geht auch mit Gleitpunktzahlen, z.B. durch die Verwendung des Moduls [https://mpmath.org/ mpmath]:

 import mpmath
 print(mpmath.mpf(1500.4)**mpmath.mpf(300))

Ausgabe:

 7.27975299218612e+952

Anderes Beispiel:

 from mpmath import mp, pi
 mp.dps = 100
 print(pi)

Ausgabe:

 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068

mpmath kann noch einiges mehr, dazu sei aber auf die entsprechende Dokumentation auf der mpmath-Homepage verwiesen. mpmath ist Bestandteil von SymPy, kann aber auch separat installiert werden.

Aber auch Python selbst besitzt eine Möglichkeit, um mit großen bzw. exakten Gleitpunktzahlen zu rechnen, nämlich das interne Modul decimal. Dieses hat einige Vorteile gegenüber mpmath, aber auch gravierende Nachteile. Diese seien hier nicht detailliert aufgezählt. Grob gesagt hat decimal im Finanzwesen seine Berechtigung. Für wissenschaftliche Anwendungen wird aber mpmath vorzuziehen sein, da es u.a. vielfältige mathematische Funktionen bereit stellt. Nachfolgend ein einfaches Beispiel mit decimal:

 import decimal
 print(&quot;Potenzierung:&quot;, decimal.Decimal(1500.4) ** decimal.Decimal(300.0))
 print(&quot;Einfache Addition:&quot;, 0.1 + 0.2)
 decimal.getcontext().prec = 50
 print(&quot;Addition mit decimal:&quot;, decimal.Decimal(&quot;0.1&quot;) + decimal.Decimal(&quot;0.2&quot;))

Ausgabe:

 Potenzierung: 7.279752992186121551039839134E+952
 Einfache Addition: 0.30000000000000004
 Addition mit decimal: 0.3

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet die genauen Vor- und Nachteile von decimal und mpmath. Verwenden Sie dazu auch KI (z.B. von Google, chatgpt).

= pint - mit physikalischen Größen rechnen = 
[[File:Pint-Glas_UK.jpg|right|100px]]
pint ist ein externes Python-Paket zur Manipulation von physikalischen Einheiten. Es muss vor der ersten Benutzung installiert werden (Vorgehensweise wie immer: pip, YaST, via venv etc.).

Beispiel:

 import pint
 import numpy as np
 
 ureg = pint.UnitRegistry()
 
 # Einfache Berechnung
 print(3 * ureg.meter + 4 * ureg.cm)
 
 # Mit NumPy
 npeinzel = [3, 4] * ureg.meter + [2, 5] * ureg.cm
 print(npeinzel)
 npsum = np.sum(npeinzel)
 print(npsum)
 
 # Konvertierung von Einheiten
 npsum_inch = npsum.to(ureg.inch)
 print(npsum_inch)
 
 print(npeinzel.magnitude)
 print(npeinzel.units)
 print(npeinzel.dimensionality)

Ausgabe:

 3.04 meter
 [3.02 4.05] meter
 7.07 meter
 278.3464566929134 inch
 [3.02 4.05]
 meter
 [length]

Die Dokumentation zu pint findet sich auf [https://pint.readthedocs.io/en/stable/].

=Regelungstechnische Aufgabenstellungen=
Für regelungstechnische Aufgaben gibt es u.a. das externe Paket &lt;code&gt;control&lt;/code&gt;. Hier soll nicht detailliert darauf eingegangen werden. Anhand eines Beispiels soll anschließend nur die Visualisierung in Form eines Bode-Diagramms und der Sprungantwort gezeigt werden. Gegeben sei ein P-Regler mit &lt;math&gt;R = \frac{5}{2}&lt;/math&gt; und eine Strecke &lt;math&gt;S= \frac{1}{30s^3+20s^2+10s+1,5}&lt;/math&gt;. Gesucht sei vorerst ein Bode-Diagramm für den offenen Regelkreis und das Führungsverhalten.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke  # oder: G0 = ct.series(regler, strecke)
 Gw = ct.feedback(G0)
 
 ct.bode_plot(G0, label='G0')
 ct.bode_plot(Gw, label='Gw')
 plt.show()

[[Datei:PythonIng_bode1.svg]]

Nun noch für obiges Beispiel die Sprungantwort. Diese zeigt einige große Überschwinger, d.h. der Regler kann sicher noch optimiert werden.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke 
 Gw = ct.feedback(G0) 
 
 t, y = ct.step_response(Gw)
 
 plt.plot(t,y)
 plt.title('Sprungantwort')
 plt.xlabel('t')
 plt.ylabel('h(t)')
 plt.grid()
 plt.show()

[[Datei:PythonIng_bode3.svg]]

Einige weitere wichtige Daten (Phasenreserve, Amplitudenreserve, Durchtrittsfrequenz) lassen sich mittels der &lt;code&gt;control&lt;/code&gt;-Funktion &lt;code&gt;margin()&lt;/code&gt; ermitteln. Die Ortskurve lässt sich mit der Funktion &lt;code&gt;nyquist_plot()&lt;/code&gt; zeichnen. Dies sei hier aber nicht weiter ausgeführt.

==Aufgaben==
* Zeichen Sie mit Python die Ortskurve für obiges Beispiel.
* Was passiert, wenn man die Reglerverstärkung weiter aufdreht (z.B. auf &lt;math&gt;R = \frac{25}{2}&lt;/math&gt;)?
* Wie sehen das Bode-Diagramm und die Sprungantwort aus, wenn ein PI-Regler verwendet wird?

= Stereostatik etc. =
Das Modul SymPy bietet einige Möglichkeiten einfache Bauwerke zu berechnen, z.B. Balken oder Fachwerke. Nachfolgend wird ein einfaches Fachwerk berechnet und gezeichnet.

Python-Code:
 from sympy.physics.continuum_mechanics.truss import Truss 
 
 t = Truss()
 # Knoten
 t.add_node((&quot;A&quot;, -3, 0), (&quot;B&quot;, 0, 0), (&quot;C&quot;, 4, 0), (&quot;D&quot;, 7, 0),
            (&quot;E&quot;, 6, 1.5), (&quot;F&quot;, 2, 3), (&quot;G&quot;, -2, 1.5))
 # Stäbe
 t.add_member((&quot;AB&quot;,&quot;A&quot;,&quot;B&quot;), (&quot;BC&quot;,&quot;B&quot;,&quot;C&quot;), (&quot;CD&quot;,&quot;C&quot;,&quot;D&quot;))
 t.add_member((&quot;AG&quot;,&quot;A&quot;,&quot;G&quot;), (&quot;GB&quot;,&quot;G&quot;,&quot;B&quot;), (&quot;GF&quot;,&quot;G&quot;,&quot;F&quot;))
 t.add_member((&quot;BF&quot;,&quot;B&quot;,&quot;F&quot;), (&quot;FC&quot;,&quot;F&quot;,&quot;C&quot;), (&quot;CE&quot;,&quot;C&quot;,&quot;E&quot;))
 t.add_member((&quot;FE&quot;,&quot;F&quot;,&quot;E&quot;), (&quot;DE&quot;,&quot;D&quot;,&quot;E&quot;))
 # Auflager; roller ... Loslager, pinned ... Festlager
 t.apply_support((&quot;A&quot;,&quot;roller&quot;), (&quot;D&quot;,&quot;pinned&quot;))
 # Einwirkende Kräfte
 t.apply_load((&quot;G&quot;, 5, 270), (&quot;E&quot;, 3, 90))
 
 # Berechnung 
 t.solve()
 print(&quot;Reaction Forces: &quot;, t.reaction_loads)
 print(&quot;Internal Forces: &quot;, t.internal_forces)
 
 # Fachwerk zeichnen
 p = t.draw()
 p.show()

Ausgabe auf der Konsole:

 Reaction Forces:  {'R_A_y': 4.20000000000000, 'R_D_x': 0, 'R_D_y': -2.20000000000000}
 Internal Forces:  {'AB': 2.80000000000000, 'BC': 0.333333333333333, 'CD': -1.46666666666667, 
 'AG': -5.04777178564958, 'GB': -2.05555555555556, 'GF': -1.23413387432364, 
 'BF': 0.411111111111111*sqrt(13), 'FC': -0.3*sqrt(13), 'CE': 1.50000000000000, 
 'FE': 0.284800124843917, 'DE': 2.64407093534026}

Zeichnung:

[[File:PythonIng_fachwerk1.svg|300px]]

Details zu diesem Thema siehe z.B. [https://docs.sympy.org/latest/modules/physics/continuum_mechanics/index.html Continuum Mechanics] oder [https://docs.sympy.org/latest/tutorials/physics/continuum_mechanics/index.html Continuum Mechanics Tutorials]. Auch andere mechanische Probleme werden von SymPy abgehandelt ([https://docs.sympy.org/latest/tutorials/physics/index.html Physics Tutorials]).

== Aufgabe ==
Gegeben sei ein einseitig eingespannter Kragträger. Belastet wird er durch eine Einzellast am Trägerende. Für die Daten siehe folgende ASCII-Skizze:

                            | 20 kN  
    //|---&gt; x               |
    //|                     V
    //|----------------------
    //|         10 m        |
 
 Elastizitätsmodul E = 2,1*10⁵ N/mm²
 Flächenträgheitsmoment I = 0.001 m⁴

Berechnen Sie die Auflagerreaktionen, den Querkraft- und Biegemomentenverlauf, sowie die Verformungen.
Stellen Sie dies mit Hilfe von SymPy graphisch und auch mittels Formeln dar. Verwenden Sie dazu auch pprint (pretty print) aus dem SymPy-Modul. Zwecks Lösungsansatz siehe die oben aufgeführte Seite &quot;Continuum Mechanics Tutorials&quot;. Achten Sie auch auf die Einheiten! Kontrollieren Sie das Ganze mittels händischer Rechnung. In dem genannten Tutorial ist von &quot;Singularity Functions&quot; die Rede. Gemeint ist damit in diesem Kontext die {{W|Föppl-Klammer}}.

Einige Python-Programme, vorrangig zu Maschinenelementen, finden sich auf [https://baymp.de/download_python.html BayMP für Python] (Balken, Zahnräder, Stabknickung usw.).

=Thermodynamik= 
== PYroMat ==
Für thermodynamische Aufgabenstellungen gibt es verschiedene externe Module. Eines davon ist PYroMat (siehe auch [http://pyromat.org]). Damit lassen sich thermodynamische Stoffdaten für viele Substanzen berechnen.

Beispiel (einige Stoffdaten für Wasser bei 400°C und 20 bar berechnen):

 import pyromat as pm
 
 # Wasserdaten laden:
 H2O = pm.get('mp.H2O')
 
 # Stoffdaten berechnen:
 T = 673.15  # Temperatur in Kelvin
 p = 20      # Druck in bar
 v = H2O.v(T, p)
 h = H2O.h(T, p)
 s = H2O.s(T, p)
 print(f&quot;Spezifisches Volumen: {v} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {h} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {s} kJ/(kg K)&quot;)

Ausgabe:

 Spezifisches Volumen: [0.1512163] m³/kg
 Spezifische Enthalpie: [3248.3789473] kJ/kg
 Spezifische Entropie: [7.12924142] kJ/(kg K)

&lt;small&gt;
PYroMat muss vorab installiert werden (z.B. mittels pip, in eine virtuelle Umgebung)
&lt;/small&gt;

&lt;code&gt;mp&lt;/code&gt; steht für &quot;multi phase&quot;. Für ein ideales Gas wäre &lt;code&gt;ig&lt;/code&gt; zuständig, z.B. &lt;code&gt;'ig.O2'&lt;/code&gt;.

Beispiel (T-s-Diagramm für Wasser zeichnen):
 import numpy as np
 import matplotlib.pyplot as plt
 import pyromat as pm
 
 # Konfigurieren
 pm.config[&quot;unit_pressure&quot;] = &quot;bar&quot;
 pm.config[&quot;unit_temperature&quot;] = &quot;K&quot;
 fluid = pm.get(&quot;mp.H2O&quot;)
 
 # Temperaturbereich für das Nassdampfgebiet
 T_tripel = 273.16
 T_crit = 647.096
 T = np.linspace(T_tripel, T_crit - 0.1, 200)
 
 # Sättigungslinien berechnen und zeichnen
 for x in np.linspace(0.0, 1.0, 5):
     s = fluid.s(T=T, x=x)
     if(x&lt;=0.0):
         plt.plot(s, T, label=&quot;Siedelinie x=%3.1f&quot; % x, linewidth=2.0)
     elif(x&gt;=1.0):
         plt.plot(s, T, label=&quot;Taulinie x=%3.1f&quot; % x, linewidth=2.0)
     else:
         plt.plot(s, T, label=&quot;x=%3.1f&quot; % x, linewidth=1.0)
 
 # Isobaren zeichnen
 p_values = [0.1, 1, 10, 50, 100]
 T_isobar = np.linspace(T_tripel, 1000, 200)
 t = 0.7
 
 for p in p_values:
     s_iso = fluid.s(T=T_isobar, p=p)
     plt.plot(s_iso, T_isobar, 'k-', alpha=0.8, linewidth=0.8)
 
     t += .05
     idx = int(len(s_iso) * t)
     plt.text(s_iso[idx], T_isobar[idx], f&quot;{p} bar&quot;, fontsize=9, alpha=0.8)
 
 # Diagramm zeichnen
 plt.title(&quot;T-s-Diagramm für Wasser&quot;)
 plt.xlabel(&quot;Spezifische Entropie s in kJ/kg K&quot;, fontsize=10)
 plt.ylabel(&quot;Temperatur T in K&quot;, fontsize=10)
 plt.legend(loc=&quot;best&quot;)
 plt.grid(True)
 plt.show()

Ausgabe (in etwa so):

[[Datei:T-s-Diagramm fuer Wasser.svg|400px]]

== CoolProp ==
Auch mit CoolProp können Stoffdaten berechnet werden. Siehe auch [https://coolprop.org/coolprop/wrappers/Python/index.html]

Beispiel (Wasser bei 20bar und 400°C):
 import CoolProp.CoolProp as CP
 
 fluid = 'Water'
 T = 673.15   # Temperatur in Kelvin
 P = 20e5     # Druck in Pascal
 
 dichte = CP.PropsSI('D', 'T', T, 'P', P, fluid)
 enthalpie = CP.PropsSI('H', 'T', T, 'P', P, fluid)
 entropie = CP.PropsSI('S', 'T', T, 'P', P, fluid)
 
 print(f&quot;Spez. Volumen: {1/dichte:.6f} m³/kg&quot;)
 print(f&quot;Spez. Enthalpie: {enthalpie:.2f} J/kg&quot;)
 print(f&quot;Spez. Entropie: {entropie:.2f} J/kgK&quot;)

Ausgabe:
 Spez. Volumen: 0.151215 m³/kg
 Spez. Enthalpie: 3248344.02 J/kg
 Spez. Entropie: 7129.16 J/kgK

== iapws ==
Um Werte für Wasser(dampf) zu erhalten (IAPWS; '''I'''nternational '''A'''ssociation for the '''P'''roperties of '''W'''ater and '''S'''team) gibt es die Bibliothek iapws. Siehe auch [https://iapws.org/] und [https://pypi.org/project/iapws/]

Beispiel (Wasser für 20bar und 400°C):
 from iapws import IAPWS97
 
 dampf = IAPWS97(P=2.0, T=673.15)
 
 print(f&quot;Spezifisches Volumen: {dampf.v:.6f} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {dampf.h:.2f} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {dampf.s:.4f} kJ/(kgK)&quot;)
 print(f&quot;Phase: {dampf.phase}&quot;)

Ausgabe:
 Spezifisches Volumen: 0.151208 m³/kg
 Spezifische Enthalpie: 3248.23 kJ/kg
 Spezifische Entropie: 7.1290 kJ/(kgK)
 Phase: Gas

== TESPy ==
Ein anderes Modul für einen anderen Aufgabenzweck ist TESPy ('''T'''hermal '''E'''ngineering '''S'''ystems in '''Py'''thon). Dieses Modul ist für die Anlagensimulation zuständig. Für nähere Informationen siehe [https://tespy.readthedocs.io/en/main/getting_started/introduction.html]. Als Beipiel sei hier vorerst Code, der von der Google KI generiert wurde, angeführt. Der Code wurde überarbeitet, damit keine Warnungen auftreten. Bitte aber den Code trotzdem mit Vorsicht genießen, auch KI-generierter Code kann Fehler aufweisen. Eine Pumpe wird berechnet:

 from tespy.components import Sink, Source, Pump
 from tespy.connections import Connection
 from tespy.networks import Network
 
 # 1. Netzwerk definieren (Zentrales Steuerungselement)
 # Wir wählen Wasser als Fluid und bar/Celsius als Einheiten
 nw = Network(fluids=[&quot;water&quot;])
 nw.units.set_defaults(pressure=&quot;bar&quot;, pressure_difference=&quot;bar&quot;, 
                       temperature=&quot;°C&quot;, enthalpy=&quot;kJ / kg&quot;)
 
 # 2. Komponenten erstellen
 eingang = Source(&quot;Wasserquelle&quot;)
 ausgang = Sink(&quot;Wasserspeicher&quot;)
 pumpe = Pump(&quot;Speisewasserpumpe&quot;)
 
 # 3. Verbindungen definieren (Komponenten miteinander verknüpfen)
 c1 = Connection(eingang, &quot;out1&quot;, pumpe, &quot;in1&quot;)
 c2 = Connection(pumpe, &quot;out1&quot;, ausgang, &quot;in1&quot;)
 
 # Verbindungen dem Netzwerk hinzufügen
 nw.add_conns(c1, c2)
 
 # 4. Randbedingungen und Parameter festlegen
 # Zustand am Eingang (Druck, Temperatur, Massenstrom, Fluid-Zusammensetzung)
 c1.set_attr(
     v=1,  # Massenstrom: 1 kg/s
     T=20,  # Temperatur: 20 °C
     p=1,  # Druck: 1 bar
     fluid={&quot;water&quot;: 1},  # 100% Wasser
 )
 
 # Zustand am Ausgang / Zielwerte der Pumpe
 c2.set_attr(p=10)  # Ziel-Druck nach der Pumpe: 10 bar
 
 # Pumpeneigenschaften festlegen
 pumpe.set_attr(eta_s=0.8)  # Isentroper Wirkungsgrad von 80%
 
 # 5. Simulation ausführen
 nw.solve(mode=&quot;design&quot;)
 
 # 6. Ergebnisse ausgeben
 nw.print_results()
 
 # Spezifische Werte direkt auslesen
 print(&quot;\n--- Auswertung ---&quot;)
 print(f&quot;Erforderliche Pumpenleistung: {pumpe.P.val / 1000:.2f} kW&quot;)
 print(f&quot;Temperatur nach der Pumpe: {c2.T.val:.2f} °C&quot;)

Ausgabe (gekürzt):
  iter  | residual   | progress   | massflow   | pressure   | enthalpy   | fluid      | component  
 -------+------------+------------+------------+------------+------------+------------+------------
  1     | 7.04e+04   | 12 %       | 9.96e+02   | 0.00e+00   | 8.81e+04   | 0.00e+00   | 0.00e+00   
  2     | 5.91e-12   | 100 %      | 1.11e-13   | 0.00e+00   | 7.39e-12   | 0.00e+00   | 0.00e+00   
  3     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
  4     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
 Total iterations: 4, Calculation time: 0.01 s, Iterations per second: 480.85
 
 ##### RESULTS (Pump) #####
 +-------------------+----------+----------+-----------+----------+----------+----------+
 |                   |        P |       pr |        dp |      eta |    eta_s |     head |
 |-------------------+----------+----------+-----------+----------+----------+----------|
 | Speisewasserpumpe | 1.12e+06 | 1.00e+01 | -9.00e+00 | 8.00e-01 | 8.00e-01 | 9.19e+01 |
 +-------------------+----------+----------+-----------+----------+----------+----------+
 ...
 ...
 --- Auswertung ---
 Erforderliche Pumpenleistung: 1124.77 kW
 Temperatur nach der Pumpe: 20.07 °C

= Stochastik =
Die {{W|Stochastik}} ist ein sehr weites Feld. Hier werden etliche wichtige Themen kurz angerissen. Python stellt mit den Moduln math und statistics Software zu diesem Zwecke bereit. math und statistics sind bereits im Lieferumfang von Python enthalten. Aber auch mit den externen Modulen NumPy, SciPy, stochastic und pandas kann man Stochastik in Python betreiben. Die Theorie der Wahrscheinlichkeitsrechnung und Statistik soll etwas später in Band 5 dieser Buchreihe behandelt werden.

== Lageparameter == 
 import statistics
 
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 
 m1 = statistics.mean(werte)
 m2 = statistics.mode(werte)
 m3 = statistics.median(werte)
 
 print(&quot;Arithmetischer Mittelwert = &quot;, m1)
 print(&quot;Modalwert = &quot;, m2)
 print(&quot;Median = &quot;, m3)

Ausgabe:
 Arithmetischer Mittelwert =  3.5
 Modalwert =  1
 Median =  3.0

== Streuungsparameter ==
Beispiel (Berechnung der Standardabweichung):
 import statistics
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 s = statistics.stdev(werte)
 print(&quot;Standardabweichung = &quot;, s)

Ausgabe:
 Standardabweichung =  2.6770630673681683

Beispiel (Berechnung des Variationskoeffizienten V = Standardabweichung/Mittelwert)
 import numpy as np
 from scipy import stats
 import statistics
 
 k = 50
 
 dat1 = [14, 21, 18, 25, 30, 17, 20]
 dat = np.array(dat1)
 
 # Mit SciPy
 v = stats.variation(dat)
 vddof = stats.variation(dat, ddof=1)
 print(&quot;V SciPy: &quot;, v)
 print(&quot;V DDOF SciPy: &quot;, vddof)
 print(k*&quot;-&quot;)
 
 # mit NumPy
 mittelwert1 = np.mean(dat)
 std_abw1 = np.std(dat)
 std_abw1ddof = np.std(dat, ddof=1) 
 v1= std_abw1 / mittelwert1
 v1ddof = std_abw1ddof / mittelwert1
 print(&quot;Mittelwert NumPy: &quot;, mittelwert1)
 print(&quot;Std.abw. NumPy: &quot;, std_abw1)
 print(&quot;Std.abw. DDOF NumPy: &quot;, std_abw1ddof)
 print(&quot;V NumPy: &quot;, v1)
 print(&quot;V DDOF NumPy: &quot;, v1ddof)
 print(k*&quot;-&quot;)
 
 # nur mit reinem Python
 mittelwert2 = statistics.mean(dat1)
 std_abw2 = statistics.stdev(dat1)
 v2 = std_abw2 / mittelwert2
 print(&quot;Mittelwert Python: &quot;, mittelwert2)
 print(&quot;Std.abw. Python: &quot;, std_abw2)
 print(&quot;V Python:&quot;, v2)
 print(k*&quot;-&quot;)

Ausgabe:
 V SciPy:  0.23890355966467272
 V DDOF SciPy:  0.25804533701889254
 --------------------------------------------------
 Mittelwert NumPy:  20.714285714285715
 Std.abw. NumPy:  4.948716593053935
 Std.abw. DDOF NumPy:  5.3452248382484875
 V NumPy:  0.23890355966467272
 V DDOF NumPy:  0.2580453370188925
 --------------------------------------------------
 Mittelwert Python:  20.714285714285715
 Std.abw. Python:  5.3452248382484875
 V Python: 0.2580453370188925
 --------------------------------------------------

Der Unterschied bei der Standardabweichung zwischen reinem Python und den externen Bibliotheken SciPy und NumPy entsteht dadurch, dass einmal durch (n-1) und das andere Mal nur durch n dividiert wird. Dies kann bei NumPy und SciPy dadurch entschärft werden, indem &lt;code&gt;ddof=1&lt;/code&gt; gesetzt wird. ddof steht für '''D'''elta '''D'''egrees '''o'''f '''F'''reedom. &lt;small&gt;Je größer die Anzahl der Datensätze n wird, umso weniger spielt das eine Rolle.&lt;/small&gt;

== Kombinatorik ==
Beispiel:

 import math
 
 n = 7
 k = 5
 
 print(&quot;n! = &quot;, math.factorial(n))
 print(&quot;Kombinationen (n über k) = &quot;, math.comb(n, k))

Ausgabe:
 n! =  5040
 Kombinationen (n über k) =  21

Siehe zu diesem Thema auch [[Ing Mathematik: Permutationen, Kombinationen, binomischer Lehrsatz]]. Die Anzahlen lassen sich einfach aus den dortigen Formeln ermitteln, z.B. bei Permutationen mit &lt;math&gt;n!&lt;/math&gt; oder Variationen mit Wiederholungen als &lt;math&gt;n^k&lt;/math&gt;. Will man die Kombinationen oder Variationen aber auch als Liste ausgeben, so kann das Modul &lt;code&gt;itertools&lt;/code&gt; nützlich sein.  

Beispiel (Variationen ohne Wiederholung):

 from itertools import permutations
 
 menge = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]  # n = 4
 k = 3
 
 variationen = list(permutations(menge, k))
 
 for v in variationen:
     print(&quot;&quot;.join(v))
 
 print(50*&quot;-&quot;)
 print(len(variationen))

Ausgabe (gekürzt):
 ABC
 ABD
 ACB
 ...
 DCA
 DCB
 --------------------------------------------------
 24

Siehe zum Modul &lt;code&gt;itertools&lt;/code&gt; auch die Website [https://docs.python.org/3/library/itertools.html].

* Variationen mit Wiederholung: &lt;code&gt;itertools.product()&lt;/code&gt;
* Kombinationen ohne Wiederholung: &lt;code&gt;itertools.combinations()&lt;/code&gt;
* Kombinationen mit Wiederholung: &lt;code&gt;itertools.combinations_with_replacement()&lt;/code&gt;

== Zufallszahlen ==
Beispiel:
 import random
 
 # Ganzzahlige Zufallszahl von 1 bis 10
 zufallszahl1 = random.randint(1, 10)
 
 # Gleitpunktzahlen
 # zwischen 0.0 und 1.0
 zufallszahl2 = random.random()
 # Zahl zwischen 1.5 und 9.5
 zufallszahl3 = random.uniform(1.5, 9.5)
 
 # aus Liste auswählen
 farbe = [&quot;Rot&quot;, &quot;Grün&quot;, &quot;Blau&quot;]
 zufallswert = random.choice(farbe)
 
 print(zufallszahl1)
 print(zufallszahl2)
 print(zufallszahl3)
 print(zufallswert)

Ausgabe, z.B.:
 5
 0.14147945849015753
 6.894003397570905
 Rot

Benötigt man mehrere Zufallszahlen, so ist das Modul &lt;code&gt;numpy&lt;/code&gt; zu bevorzugen, z.B.:
* Normalverteilung: &lt;code&gt;np.random.normal(...)&lt;/code&gt;
* Gleichverteilung: &lt;code&gt;np.random.uniform(...)&lt;/code&gt;

== Histogramm ==
Zum Thema Histogramm siehe {{W|Histogramm}}.

Beispiel (mit Matplotlib):

 import matplotlib.pyplot as plt
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 
 plt.hist(daten, bins=25, edgecolor='darkgray')
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm.svg|300px]]

Beispiel (mit Seaborn):

 import matplotlib.pyplot as plt
 import seaborn as sns
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 sns.set_theme(style=&quot;darkgrid&quot;)
 sns.histplot(data=daten)
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm2.svg|300px]]

Das Kürzel &lt;code&gt;sns&lt;/code&gt; ist Konvention und steht für die fiktive Figur '''S'''amuel '''N'''orman '''S'''eaborn aus der US-Fernsehserie {{W|The West Wing – Im Zentrum der Macht | The West Wing}}.

== Box-Plot ==
[[File:Elements of a boxplot.svg|400px]]

Siehe auch {{W|Box-Plot}}.

Beispiel (mit Seaborn erstellt):
 import seaborn as sns
 import matplotlib.pyplot as plt
 
 df = sns.load_dataset(&quot;tips&quot;)
 sns.boxplot(data=df, x=&quot;day&quot;, y=&quot;tip&quot;, hue=&quot;day&quot;, legend=False)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot.svg|400px]]

Beispiel (mit Matplotlib erstellt):

 import matplotlib.pyplot as plt
 
 daten = [12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25]
 
 plt.boxplot(daten, patch_artist=True)
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot2.svg|300px]]

Um mehrere Box-Plots unterschiedlicher Farbe mit Matplotlib in einem Diagramm zu zeichnen, können Sie folgendermaßen vorgehen:

 import matplotlib.pyplot as plt
 
 daten = [[12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25],
          [10, 19, 20, 21, 20, 30, 19, 40, 11, 17, 19, 21]]
 
 farben = [&quot;green&quot;, &quot;blue&quot;]
 
 boxplot = plt.boxplot(daten, patch_artist=True)
 
 for patch, farbe in zip(boxplot['boxes'], farben):
     patch.set_facecolor(farbe)
 
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

== Regressionsrechnung ==
Beispiel:
 import numpy as np
 import matplotlib.pyplot as plt
 
 # Messpunkte
 x = np.array([1, 3, 5, 6, 8, 10, 20])
 y = np.array([3, 4, 5, 5, 7, 9, 11])
 
 # Regressionskurve (Grad 1 = lineare Regression, 2 = Polynom-Regression 2. Gr.)
 # y = kx + d
 k, d = np.polyfit(x, y, deg=1)
 # y = ax**2 + bx + c
 a, b, c = np.polyfit(x, y, deg=2)
 
 x_l = np.linspace(1, 20, 100)
 y_p = a * x_l**2 + b * x_l + c
 
 # Zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.plot(x, k*x + d, color='blue', label='Regressionsgerade')
 plt.plot(x_l, y_p, color='red', label='Regressionspolynom 2. Gr.')
 plt.xlabel('x')
 plt.ylabel('y')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_regression.svg|400px]]

== Korrelationsrechnung ==
Beispiel:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 # Messdaten
 x = [1, 3, 4, 5, 6]
 y = [2, 4, 6, 8, 5]
 
 daten = {'X': x, 'Y': y}
 df = pd.DataFrame(daten)
 
 # Korrelation
 korr = df['X'].corr(df['Y'])
 print(f&quot;Korrelationskoeff.: {korr}&quot;) 
 
 # Messpunkte zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:
 Korrelationskoeff.: 0.7556096518348252

[[Datei:IngMath_korrelation.svg|300px]]

== Mengen und Venn-Diagramme ==
Beispiel: 
 import matplotlib.pyplot as plt
 from matplotlib_venn import venn2
 
 menge_a = {1, 2, 3, 4, 5, 6}
 menge_b = {4, 5, 6, 7, 8}
 
 vereinigung = menge_a | menge_b
 schnitt = menge_a &amp; menge_b
 print(&quot;Vereinigungsmenge = &quot;, vereinigung)
 print(&quot;Schnittmenge = &quot;, schnitt)
 
 venn2([menge_a, menge_b], set_labels=('Menge A', 'Menge B'))
 plt.show()

Ausgabe:
 Vereinigungsmenge =  {1, 2, 3, 4, 5, 6, 7, 8}
 Schnittmenge =  {4, 5, 6}

[[Datei:IngMath_venn.svg|300px]]

Siehe auch {{W|Mengendiagramm#Venn-Diagramme}}.

== Verteilungs- und Dichtefunktion ==
* CDF ... '''C'''umulative '''D'''istribution '''F'''unction, Verteilungsfunktion
* PDF ... '''P'''robability '''D'''ensity '''F'''unction, Dichtefunktion

Beispiel (Normalverteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 from scipy.stats import norm
 
 my, sigma = 0, 1
 x = np.linspace(-4, 4, 50)
 
 pdf = norm.pdf(x, my, sigma)
 cdf = norm.cdf(x, my, sigma)
 
 plt.plot(x, pdf, lw=2, label=&quot;Dichtefunktion&quot;)
 plt.plot(x, cdf, lw=2, label=&quot;Verteilungsfunktion&quot;)
 plt.legend()
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:IngMath_cdf_pdf.svg|300px]]

Beispiel (&lt;math&gt;\chi^2&lt;/math&gt;-Verteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 import scipy.stats as stats
 
 x = np.linspace(0, 20, 500)
 
 # df ... degree of freedom, Freiheitsgrad
 pdf = (stats.chi2.pdf(x, df=2), stats.chi2.pdf(x, df=5), stats.chi2.pdf(x, df=10))
 
 for i in range(0,3):
     if(i==0):
         lab = &quot;Freiheitsgrad 2&quot;
     elif(i==1):
         lab = &quot;Freiheitsgrad 5&quot;
     else:
         lab = &quot;Freiheitsgrad 10&quot;
 
     plt.plot(x, pdf[i], label=lab, lw=2)
 
 plt.grid()
 plt.legend()
 plt.show()

Ausgabe:

[[Datei:IngMath_chi2.svg | 300px]]

== Schätzen und Testen ==
=== Intervallschätzung ===
Als Beispiel seien Daten gegeben, die von ''Dürr, Mayer: Wahrscheinlichkeitsrechnung und Schließende Statistik; 7. Aufl., Hanser, 2014, Seite 137'' stammen. Und zwar soll das 95%-Vertrauensintervall für den Mittelwert des Kaloriengehalts (kcal/100g) von Hähnchen ermittelt werden. Wir wollen das mit Python inkl. NumPy und SciPy durchführen. Die Stichprobe ist groß (50 Hähnchen):

Python-Code:
 import numpy as np
 import scipy.stats as stats
 
 # Stichprobe
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203]
 
 # Parameter definieren
 konfidenzniveau = 0.95
 mean = np.mean(daten)
 std = np.std(daten, ddof=1)
 stdfehler = stats.sem(daten)
 
 intervall = stats.norm.interval(confidence=konfidenzniveau, loc=mean, scale=stdfehler)
 
 print(f&quot;Mittelwert: {mean}&quot;)
 print(f&quot;Standardabweichung: {std}&quot;)
 print(f&quot;Konfidenzintervall: {intervall}&quot;)

Ausgabe:
 Mittelwert: 215.48
 Standardabweichung: 33.14238915925757
 Konfidenzintervall: (np.float64(206.29356722321992), np.float64(224.66643277678006))

Diese Werte stimmen gerundet mit denen im genannten Buch überein. Zum Code selbst:
* sem steht für '''s'''tandard '''e'''rror of the '''m'''ean.
* &lt;code&gt;scipy.stats.norm&lt;/code&gt; ... Modul für die Normalverteilung.

=== Punktschätzung ===
Gleiche Daten wie oben bei der Intervallschätzung.

Python-Code:
 import numpy as np
 from scipy import stats
 
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203
         ]
 
 mu_hat, sigma_hat = stats.norm.fit(daten) 
 
 print(f&quot;Schätzer für den Erwartungswert (μ): {mu_hat:.4f}&quot;)
 print(f&quot;Schätzer für die Standardabweichung (σ): {sigma_hat:.4f}&quot;)

Ausgabe:
 Schätzer für den Erwartungswert (μ): 215.4800
 Schätzer für die Standardabweichung (σ): 32.8093

=== Hypothesentests ===
Beispiel:

 import numpy as np
 import scipy.stats as stats
 
 x_quer = 12.075      # Stichproben-Mittelwert
 var    = 0.069       # Stichproben-Varianz
 n      = 90          # Stichprobengröße
 my_0   = 12.0        # Nullhypothese
 alpha  = 0.05        # Signifikanzniveau
 
 z_stat = (x_quer - my_0) / np.sqrt(var / n)
 p_val = 2 * (1 - stats.norm.cdf(np.abs(z_stat)))
 
 print(f&quot;Z-Statistik: {z_stat:.4f}&quot;)
 
 if p_val &lt; alpha:
     print(f&quot;p-Wert: {p_val:.6f} &lt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird verworfen.&quot;)
 else:
     print(f&quot;p-Wert: {p_val:.6f} &gt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird nicht verworfen.&quot;)

Ausgabe:

 Z-Statistik: 2.7087
 p-Wert: 0.006755 &lt; alpha: 0.05
 Die Nullhypothese wird verworfen.

== Statistische Qualitätskontrolle ==
Beispiel (Mittelwertkarte):

 import numpy as np
 import matplotlib.pyplot as plt
 
 # Gegeben
 sollwert = 50.0
 varianz = 4.0
 stichproben_umfang = 1
 daten = [49.5, 50.2, 53.0, 48.1, 52.6, 53.4, 49.8]
 
 # Berechnung
 standardabweichung = np.sqrt(varianz)
 streuung = standardabweichung / np.sqrt(stichproben_umfang)
 
 cl = sollwert
 ucl = cl + 3 * streuung
 lcl = cl - 3 * streuung
 
 # Darstellung
 plt.plot(daten, marker='o', linestyle='-', color='b', label='Messdaten')
 plt.axhline(cl, color='green', linestyle='-', label=f'CL: {cl}')
 plt.axhline(ucl, color='red', linestyle='--', label=f'UCL: {ucl:.2f}')
 plt.axhline(lcl, color='red', linestyle='--', label=f'LCL: {lcl:.2f}')
 
 plt.title('Mittelwertkarte')
 plt.xlabel('Stichprobe')
 plt.ylabel('Wert')
 plt.legend(loc='lower left')
 plt.grid(True)
 plt.show()

Ausgabe:

[[Datei:IngMath_mittelwertkarte.svg|300px]]

Siehe auch {{W|Shewhart-Regelkarte}} und {{W|Qualitätsregelkarte}}.

* UCL ... '''U'''pper '''C'''ontrol '''Limit''', Obere Eingriffsgrenze
* LCL ... '''L'''ower '''C'''ontrol '''Limit''', Untere Eingriffsgrenze
* CL ... '''C'''enter '''L'''ine, Mittellinie

= Ein- und Ausgabe =
== print ==
Die Anweisung print haben wir schon oft verwendet. Hier soll anhand von Beispielen kurz beschrieben werden, was der Befehl print leisten kann.

 print(&quot;Hallo&quot;, &quot;Welt&quot;, 1, sep=&quot;-&quot;)
 print(&quot;Hallo&quot;, end=&quot; &quot;)
 print(&quot;Welt&quot;)

Ausgabe:
 Hallo-Welt-1
 Hallo Welt

== input ==
 a = int(input(&quot;Zahl 1: &quot;))
 b = int(input(&quot;Zahl 2: &quot;))
 
 print(&quot;a + b = &quot;, a+b)

Ausgabe (nach Eingabe der beiden Ganzzahlen):
 Zahl 1: 4
 Zahl 2: 5
 a + b =  9

== Aus Dateien lesen ==
Es seinen die datei.txt
 Hallo Welt.
 Wie geht es dir?
 ...

und test1.py
 dat = open(&quot;datei.txt&quot;, mode = &quot;r&quot;)
 print(dat.read())
 dat.close()

Ausgabe
 Hallo Welt.
 Wie geht es dir?
 ...

Mit dem open()-Befehl wird die Datei datei.txt im Lesemodus geöffnet (r ... read). Mit dem read()-Befehl wird die Datei eingelesen und mittels print ausgegeben.

== In Dateien schreiben ==
 dat = open(&quot;datei.txt&quot;, mode = &quot;a&quot;, encoding = &quot;utf-8&quot;)
 dat.write(&quot;Hänge Zeile an\n&quot;)
 dat.close()

Die Datei datei.txt sieht nach Abarbeitung des obigen Skripts nun so aus
 Hallo Welt.
 Wie geht es dir?
 ...
 Hänge Zeile an

Es wird die Datei im Schreibmodus geöffnet (a ... append (anhängend), w ... write (überschreibend)).
write() fügt hier also eine Zeile Text am Dateiende ein. close() schließt die Datei wieder.

Das close() kann man sich mit der with-Anweisung auch sparen.

 with open(&quot;datei.txt&quot;, mode=&quot;a&quot;, encoding=&quot;utf-8&quot;) as dat:
     dat.write(&quot;Hänge Zeile an\n&quot;)

= Benutzeroberflächen erstellen =
== tkinter ==
{{Wikipedia | Tkinter}}

Python bietet standardmäßig das Modul tkinter zur Programmierung von Benutzeroberflächen. Es müssen also bei der Verwendung von tkinter keine externen Module installiert werden. Hier wird eine (sehr) kurze Einführung in das Erstellen von grafischen Oberflächen mittels tkinter gegeben.

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 win.minsize(300, 50)
 but = tk.Button(win, text = &quot;Push the button&quot;)
 but.pack()
 win.mainloop()

Ausgabe:

[[Datei:PythonIng_gui1.jpg]]

Ein etwas komplizierteres Beispiel sei nachfolgend gezeigt. Es sollen zwei Strings miteinander verknüpft und ausgegeben werden. 

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 
 def on_button_clicked():
     str = ent1.get() + ent2.get()
     lab2[&quot;text&quot;] = str
  
 ent1 = tk.Entry(win)
 ent2 = tk.Entry(win)
 lab1 = tk.Label(win, text=&quot;verknuepfen mit&quot;)
 lab2 = tk.Label(win, text=&quot;&quot;) 
 but = tk.Button(win, text = &quot;=&quot;, command=on_button_clicked)
 
 ent1.pack(side=&quot;left&quot;)
 lab1.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 but.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 lab2.pack(side=&quot;left&quot;)
 
 win.mainloop()

Ausgabe  (vor der Eingabe der Teilstrings): 

[[Datei:PythonIng_gui2.jpg]]

Ausgabe (nach der Eingabe der Teilstrings und dem Drücken des =-Buttons): 

[[Datei:PythonIng_gui3.jpg]]

== curses ==
{{Wikipedia | curses}}

Mit dem curses-Modul lassen sich u.a. TUIs ('''T'''ext '''U'''ser '''I'''nterfaces) erstellen. Ein sehr einfaches Beispiel zur allgemeinen Funktionsweise wird nachstehend geliefert.
 
 import curses
 
 stdscr = curses.initscr()
 curses.start_color()
 curses.init_pair(1, curses.COLOR_RED, curses.COLOR_WHITE)
 stdscr.clear()
 
 stdscr.addstr(&quot;Hallo Welt&quot;, curses.color_pair(1))
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()
 
Als Ausgabe sollte &lt;span style=&quot;color:#FF0000;&quot;&gt;Hallo Welt&lt;/span&gt; (rote Schrift auf weißem Hintergrund) auf dem Terminal/der Konsole erscheinen. Getestet wurde dies mit openSUSE Tumbleweed, Python-Version 3.13.12. Das entsprechende Python-curses-Package muss installiert sein.

Allgemeine Informationen zur Terminal-/Konsolengröße und Cursorposition liefert folgendes Programm:
 
 import curses
 
 stdscr = curses.initscr()
 
 stdscr.addstr(3, 5, &quot;LINES: %d&quot; % curses.LINES)
 stdscr.addstr(4, 5, &quot;COLS:  %d&quot; % curses.COLS)
 
 (y,x) = stdscr.getyx()
 stdscr.addstr(5, 5, &quot;Momentane Cursorposition:  [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getbegyx()
 stdscr.addstr(6, 5, &quot;Koordinatenursprung:       [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getmaxyx()
 stdscr.addstr(7, 5, &quot;Fenstergröße:              [%d, %d]&quot; % (y, x))
 
 stdscr.addstr(11, 2, &quot;Taste drücken -&gt; Ende&quot;)
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()

Es sollte sich in etwa folgende Ausgabe ergeben:

     LINES: 44
     COLS:  110
     Momentane Cursorposition:  [4, 15]
     Koordinatenursprung:       [0, 0]
     Fenstergröße:              [44, 110]
 
 
 Taste drücken -&gt; Ende

Zur Funktionsweise von curses siehe auch das Wikibook [[ncurses]]. Zum Verständnis sind dort allerdings elementare Kenntnisse in der Programmiersprache C erforderlich.

== Qt ==
{{Wikipedia | Qt (Bibliothek)}}

Auch für das Qt-Framework gibt es eine Anbindung an Python. Nachfolgend ein einfaches Beispiel.

 import sys
 from PySide6.QtWidgets import QApplication, QLabel
 
 app = QApplication(sys.argv)
 label = QLabel(&quot;Hallo Welt!&quot;)
 label.show()
 sys.exit(app.exec())

Ausgabe:

[[Datei:PythonIng_gui10.png]]

== Gtk ==
{{Wikipedia | GTK (Programmbibliothek)}}

Eine idente Ausgabe, wie oben für Qt gezeigt, erzeugt z.B. folgendes Gtk-Programm:

 import gi
 gi.require_version(&quot;Gtk&quot;, &quot;4.0&quot;)
 from gi.repository import Gtk
 
 def on_activate(app):
     win = Gtk.ApplicationWindow(application=app)
     lab = Gtk.Label(label=&quot;Hallo Welt!&quot;)
     win.set_child(lab)
     win.present()
 
 app = Gtk.Application()
 app.connect('activate', on_activate)
 app.run(None)

Auch für die Benutzung von Qt und Gtk müssen die jeweiligen Packages installiert sein. Getestet wurden die entsprechenden Python-Programme nur unter openSUSE Tumbleweed. Wie das GTK-Paket unter MS Windows 11 installiert wird, siehe z.B. [https://www.gtk.org/docs/installations/windows Setting up GTK for Windows].

Damit sei aber das Thema &quot;Benutzeroberflächen erstellen&quot; hier abgeschlossen, da dies schon ein sehr spezielles Aufgabengebiet ist, das eher Informatiker und nicht so sehr Ingenieure anspricht. Bei Bedarf siehe aber ggf. die entsprechenden Links unten in diesem Tutorial. Dort sind weiterführende Informationen zu finden.

= Pandas kurz erklärt =
Hier wird kurz auf das externe Modul Pandas eingegangen. Pandas steht für '''Pan'''el '''Da'''ta und ist ein Modul für die Datenanalyse und -manipulation.

== Series ==
Vorstellbar ist eine &quot;Series&quot; wie eine einzelne Spalte in einem Tabellenkalkulationsprogramm.

Beispiel (Index implizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5]) # Temperaturwerte
 print(temp)

Ausgabe:
 0     8.5
 1    11.0
 2    12.5
 3    10.0
 4    13.0
 5    11.0
 6    14.5
 dtype: float64

Das Kürzel &lt;code&gt;pd&lt;/code&gt; ist Konvention. Es seien Temperaturwerte gegeben. Die erste Spalte bei der Ausgabe ist der Index. Die zweite Spalte enthält die Werte.

Beispiel (separater Zugriff auf den Index und auf die Werte):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5])
 print(temp.index)
 print(temp.values)

Ausgabe:
 RangeIndex(start=0, stop=7, step=1)
 [ 8.5 11.  12.5 10.  13.  11.  14.5]

Beispiel (Index explizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 print(&quot;*** Die gesamte Series ***&quot;)
 print(temp)
 
 print(&quot;*** Temperatur am Donnerstag ***&quot;)
 print(temp[&quot;Do&quot;])
 
 print(&quot;*** Tage wärmer als 12 Grad ***&quot;)
 temp_gr_12 = temp[temp &gt; 12]
 print(temp_gr_12)

Ausgabe:
 *** Die gesamte Series ***
 Mo     8.5
 Di    11.0
 Mi    12.5
 Do    10.0
 Fr    13.0
 Sa    11.0
 So    14.5
 dtype: float64
 *** Temperatur am Donnerstag ***
 10.0
 *** Tage wärmer als 12 Grad ***
 Mi    12.5
 Fr    13.0
 So    14.5
 dtype: float64

== DataFrame ==
Ein DataFrame entspricht einer Tabelle.

Beispiel (Erzeugen eines DataFrames):
 import pandas as pd
 
 tag   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 v1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=tag)
 v2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=tag)
 v3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=tag)
 
 tab = pd.concat([v1, v2, v3], axis=1)
 tab.columns = stadt
 
 print(tab)
 print(type(tab))

Ausgabe:
     Linz  Salzburg Innsbruck
 Mo     1         8     Hallo
 Di     2         9        16
 Mi     3        10        17
 Do     4        11        18
 Fr     5        12        19
 Sa     6        13        20
 So     7        14        21
 &lt;class 'pandas.core.frame.DataFrame'&gt;

Wir haben hier drei Datenspalten (v1, v2, v3) mit den Spaltennamen &quot;Linz&quot;, &quot;Salzburg&quot; und &quot;Innsbruck&quot;, sowie sieben Zeilen &quot;Mo&quot; bis &quot;So&quot;.

Beispiel (Zugriff auf eine Spalte):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab[&quot;Salzburg&quot;])

Ausgabe:
 Mo     8
 Di     9
 Mi    10
 Do    11
 Fr    12
 Sa    13
 So    14
 Name: Salzburg, dtype: int64

Beispiel (Zugriff auf eine Zeile):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab.loc[&quot;Di&quot;])

Ausgabe:
 Linz          2
 Salzburg      9
 Innsbruck    16
 Name: Di, dtype: object

== Grafiken erstellen ==
Hier sei nur ein Torten- oder Kreisdiagramm gezeichnet:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 expl = [0, 0.2, 0, 0, 0, 0, 0]
 temp.plot.pie(figsize=(5,5), explode=expl)
 plt.show()

Ausgabe:

[[Datei:IngPython_pandas1.svg|350px]]

Die &lt;code&gt;figsize&lt;/code&gt; hat nichts mit der Spaltenanzahl zu tun, sondern setzt die Fenster- oder Diagrammgröße in Inches (Breite * Höhe).
 
Mit Pandas kann man auch noch andere Diagrammarten erstellen, z.B. Linien- oder Balkendiagramme. Dies wird hier aber nicht vorgeführt.

== Arbeiten mit CSV- und LibreOffice-Dateien ==
Gegeben sei eine CSV-Datei test1.csv:
 Mai;Juni;Juli
 12;17;45
 15;65;65
 16;32;23
 4;14;7
 23;17;Keine Daten verfügbar
 67;Keine Daten verfügbar;45
 15;24;12

Lesen von dieser CSV-Datei:
 import pandas as pd
 
 tab = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 print(tab)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Schreiben in eine CSV-Datei test2.csv:
 import pandas as pd
 
 val = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 val.to_csv(&quot;test2.csv&quot;, index=False)

Ausgabedatei:
 Mai,Juni,Juli
 12,17,45
 15,65,65
 16,32,23
 4,14,7
 23,17,Keine Daten verfügbar
 67,Keine Daten verfügbar,45
 15,24,12

Die Ausgabedatei ist beinahe gleich wie die Eingabedatei. Es werden aber Kommas statt Strichpunkten verwendet. Daher kommt auch der Name CSV ('''C'''omma '''S'''eparated '''V'''alue). Will man wieder Strichpunkte, so kann man dies über den Parameter &lt;code&gt;sep=&quot;;&quot;&lt;/code&gt; in der &lt;code&gt;to_csv&lt;/code&gt;-Funktion machen.

Um direkt von einer ODS-Datei (LibreOffice Calc, '''O'''pen '''D'''ocument '''S'''preadsheet) zu lesen muss das Modul odfpy extra installiert sein (per YaST, pip etc.). Gelesen wird dann folgendermaßen:
 import pandas as pd
 
 df = pd.read_excel('test1.ods', engine='odf')
 print(df)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Die Datei &quot;test1.ods&quot; sei die Datei, aus der das obige &quot;test1.csv&quot; generiert wurde. Schreiben kann man ebenfalls in eine ODS-Datei:

 import pandas as pd
 
 daten = {
     &quot;Name&quot;: [&quot;Hugo&quot;, &quot;Richie&quot;, &quot;Wilhelmine&quot;],
     &quot;Alter&quot;: [38, 30, 29],
     &quot;Ort&quot;: [&quot;Linz&quot;, &quot;Innsbruck&quot;, &quot;Salzburg&quot;]
 }
 
 tab = pd.DataFrame(daten)
 
 with pd.ExcelWriter(&quot;test2.ods&quot;, engine=&quot;odf&quot;) as writer:
     tab.to_excel(writer, sheet_name=&quot;Daten&quot;, index=False)

Es ergibt sich eine &quot;test2.ods&quot;-Datei (Screenshot):

[[Datei:IngPython_pandas2.png|250px]]

== Sonstiges ==
Hier seien stichpunktartig einige weitere Features von Pandas angeführt:
* {{W|Pivot-Tabelle|Pivot-Tabellen}} (pivot ... Dreh-, Angelpunkt): Zweck - große Datenmengen schnell zusammenfassen, filtern und analysieren.
* NaN ('''n'''ot '''a''' '''n'''umber): In einem Datensatz fehlt ein Wert oder ist nicht definiert.
* groupby-Funktion: Daten strukturieren, aggregieren oder Zwischensummen bilden. 
* {{W|Binning#Datenverarbeitung_und_-analyse|Binning}}: Klassenbildung.
* Mehrstufige Indizierung (Hierarchical Indexing oder MultiIndex)
* Zeitreihen (Time Series)

Für tiefergehende und weiterführende Informationen wird auf das Buch von ''Klein: Numerisches Python; Hanser, 2023'' und [https://pandas.pydata.org/ pandas] verwiesen.

= Style Guide, flake8, pylint, Black etc. =
== Style Guide ==
Wie man schönen und richtigen Python-Code schreibt, erfahren Sie in
* [https://peps.python.org/pep-0008/ PEP 8 – Style Guide for Python Code]

== Formatter und Linter ==
Ein Modul, das prüft, ob die Richtlinien im Style Guide eingehalten wurden, ist ''flake8'':
* [https://flake8.pycqa.org/en/latest/ Flake8: Your Tool For Style Guide Enforcement]

Code formatieren kann man auch mit [https://pypi.org/project/black/ Black]. Z.B. übersetzt &lt;code&gt;black test1.py&lt;/code&gt; die Datei &lt;code&gt;test1.py&lt;/code&gt;

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)),
     (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

in 

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)), (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Die Programmausgabe ist 

 reformatted test1.py
 
 All done! ✨ 🍰 ✨
 1 file reformatted.

Der Unterschied zwischen Black und Flake8:
* Black ist ein Code-Formatter. Er formatiert Ihren Code um, sodass er im Einklang mit PEP 8 steht.
* Flake8 ist ein {{W|Lint (Programmierwerkzeug) | Code-Linter}}. Flake8 verändert Ihren Code nicht, sondern durchsucht ihn nach potenziellen Fehlern etc.

Am obigen Beispiel sieht man auch, dass flake8 und Black nicht immer einer Meinung sind. Flake8 (&lt;code&gt;flake8 test1.py&lt;/code&gt;) würde standardmäßig den mit Black formatierten Code bemängeln:

 test1.py:8:80: E501 line too long (80 &gt; 79 characters)

Diese Diskrepanz kann beseitigt werden. Da 79 Zeichen auf modernen Bildschirmen meist als zu kurz empfunden werden, ist ein Limit von 88 Zeichen (Black-Standard) oder mehr empfehlenswert. Um dies zu implementieren, erstellen Sie in Ihrem Projektverzeichnis eine &lt;code&gt;.flake8&lt;/code&gt;-Datei mit dem Inhalt

 [flake8]
 max-line-length = 88

Und schon ignoriert Flake8 dieses Problem.

Ein anderer Linter ist pylint. Der würde beim Abarbeiten des obigen Beispiels, z.B. mit &lt;code&gt;pylint test1.py&lt;/code&gt; noch eine Kleinigkeit bemängeln:

 ************* Module test1
 /home/hr/tmp/test1.py:1:0: C0114: Missing module docstring (missing-module-docstring)
 
 ------------------------------------------------------------------
 Your code has been rated at 8.57/10 (previous run: 8.57/10, +0.00)

Auch pylint muss vor der ersten Verwendung installiert werden (z.B. mittels pip, virtuelle Umgebung, YaST). Die Dokumentation zu pylint findet sich auf [https://pylint.readthedocs.io/en/latest/].

&lt;u&gt;Aufgabe:&lt;/u&gt; Fügen Sie einen &quot;module docstring&quot; in die &lt;code&gt;test1.py&lt;/code&gt;-Datei ein und testen Sie erneut mit flake8, Black und pylint. &lt;small&gt;Sehen Sie zum Thema docstrings auch [https://peps.python.org/pep-0257/#what-is-a-docstring PEP 257 – Docstring Conventions].&lt;/small&gt;

Es gibt noch weitere Formatierungswerkzeuge für Python-Code. Z.B. [https://docs.astral.sh/ruff/ Ruff], ein moderner Code-Formatter und -Linter. Mittels &lt;code&gt;ruff check test1.py&lt;/code&gt; würde obiger Code geprüft (Linter). &lt;code&gt;ruff format test1.py&lt;/code&gt; formatiert den Code (Formatter).

== Type Checker ==
&quot;Type Checker&quot; sind z.B.
* mypy
* pyright
* ty

Diese prüfen die Datentypen, z.B. in folgendem Code

 def greetings(name: str) -&gt; str:
     return &quot;Hello, %s&quot; % name
 
 
 print(greetings(42))

Python selbst, flake8, ruff oder black würden diesen Code ohne zu murren akzeptieren. &quot;Type Checker&quot; würden aber sehr wohl Alarm schlagen, z.B. liefert &lt;code&gt;mypy&lt;/code&gt; folgende Ausgabe

 test1.py:5: error: Argument 1 to &quot;greetings&quot; has incompatible type &quot;int&quot;; expected &quot;str&quot;  [arg-type]
 Found 1 error in 1 file (checked 1 source file)

Das funktioniert übrigens nicht nur bei Funktionsannotationen, sondern auch mit Variablen etc.

 from typing import Final
 
 # &quot;Konstante&quot;, ab Python 3.8
 NUMBER: Final = 123
 print(NUMBER)
 NUMBER = 125
 print(NUMBER)
 
 # Variable
 a: int = 345
 print(a)
 a = &quot;Irgendwas&quot;
 print(a)
 
 # Variable (Pipe-Symbol), ab Python 3.10
 b : int|str = 567
 print(b)
 b = &quot;sonstiges&quot;
 print(b)

Ausgabe mit python:
 123
 125
 345
 Irgendwas
 567
 sonstiges

Ausgabe mit mypy:
 test3.py:6: error: Cannot assign to final name &quot;NUMBER&quot;  [misc]
 test3.py:12: error: Incompatible types in assignment (expression has type &quot;str&quot;, variable has type &quot;int&quot;)  [assignment]
 Found 2 errors in 1 file (checked 1 source file)

Python kennt übrigens keine Konstanten. Man kann diese mittels Großbuchstaben andeuten. Das ist aber nur Konvention, hat aber keine sonstigen Auswirkungen. Oder man verwendet wie oben gezeigt &lt;code&gt;Final&lt;/code&gt;. Dann werfen Typchecker Errors aus.

==pydoc==
pydoc ist ein Werkzeug, um Python-Module, -Funktionen und -Klassen zu dokumentieren.

Beispiel &lt;code&gt;test1.py&lt;/code&gt;:
 &quot;&quot;&quot;Rechen-Modul.
 
 Funktionen die von pydoc gelesen werden.
 &quot;&quot;&quot;
 
 def multiply(a, b):
     &quot;&quot;&quot;Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
     
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a * b
     
 def add(a, b):
     &quot;&quot;&quot;Addiert zwei Zahlen und gibt das Ergebnis zurück.
    
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a + b
    
 
 if __name__ == '__main__':
     print(multiply(3, 5))
     print(add(4, 6))

Ausgabe mit &lt;code&gt;python3.13 -m pydoc test1&lt;/code&gt; auf der Konsole:

 Help on module test1:
 
 NAME
     test1 - Rechen-Modul. 
 
 DESCRIPTION
     Funktionen die von pydoc gelesen werden.
 
 FUNCTIONS
     add(a, b)
         Addiert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
     multiply(a, b)
         Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
 FILE
     /home/xyz/tmp/test1.py

Siehe zu diesem Thema z.B. auch [https://docs.python.org/3/library/pydoc.html]. Mittels &lt;code&gt;python3.13 -m pydoc -w test1&lt;/code&gt; kann man auch eine HTML-Dokumentation erstellen.

Wofür &lt;code&gt;if __name__ == '__main__':&lt;/code&gt; steht, siehe z.B. etwas später im Abschnitt [[Ing_Mathematik:_Python#Doctests]].

== Sonstige Tools ==
Andere Tools für die {{W|Statische Code-Analyse|statische Codeanalyse}}, die aber für Ingenieure weniger interessant sein dürften, sind z.B.
* Radon: Liefert verschiedene {{W|Softwaremetrik|Codemetriken}} (Komplexität, Wartbarkeitsindex ...)
* Bandit: Findet Sicherheitslücken

Tools für die {{W|Dynamisches Software-Testverfahren|dynamische Codeanalyse}}, z.B.:
* DynaPyt (Framework zur dynamischen Programmanalyse)
* cProfile (Profiler)
* Memory Profiler (Speicheranalyse)
* Memray (Speicheranalyse)
* tracemalloc (Speicheranalyse)

Paket- und Projektmanagement (pip-Ersatz etc.):
* uv
* Poetry
* Conda
* pipx

Packaging-Tools (Freezer) und {{W|Compiler#Sonderformen|Transpiler}} :
* pyinstaller
** erstellt eigenständige, ausführbare Binärdatei
** kein Cross-Compiler
** kein Schutz vor Reverse-Engineering
** langsam
** packt alles in eine Datei
** sehr große Datei
** Befehl, z.B.: &lt;code&gt;pyinstaller --onefile test1.py&lt;/code&gt;
** GUI: &lt;code&gt;auto-py-to-exe&lt;/code&gt;
* cx_Freeze
* nuitka
** Übersetzt Python-Code in C/C++-Code und weiter in eine ausführbare Datei
** kein Cross-Compiler
** Schutz vor Reverse-Engineering
** Befehl, z.B.: &lt;code&gt;nuitka --standalone --onefile test1.py&lt;/code&gt;
* cython

= Einige Integrierte Entwicklungsumgebungen (IDEs)=
Werden Programmtexte größer und umfangreicher, so ist das Arbeiten mit der interaktiven Programmierumgebung bzw. das direkte Ausführen von Python-Skripten mühsam. Man wünscht sich z.B. Hilfen zum Debuggen oder die automatische Code-Vervollständigung. Zu diesem Zweck wurden IDEs (Integrated Development Environments) geschaffen. Von diesen seinen nachfolgend auszugsweise einige kurz beschrieben. Testen Sie einfach aus, welche davon für Sie bzw. für Ihr Python-Projekt geeignet sind.

== IDLE ==
IDLE ist die mit dem Python-Programmpaket mitgelieferte IDE. Der Name leitet sich einerseits ab vom Monty-Python-Mitglied Eric Idle, andererseits steht es als Abkürzung für &quot;'''I'''ntegrated '''D'''evelopment and '''L'''earning '''E'''nvironment. IDLE ist einfach zu bedienen, bietet aber schon einen beachtlichen Leistungsumfang. Nachfolgend wird ein Screenshot zu IDLE geliefert. Rechts ist das Editor-Fenster zu sehen, links die interaktive Programmierumgebung. Um das Beispiel selbst nachvollziehen zu können, starten Sie IDLE. Das geht ähnlich, wie Sie die interaktive Programmierumgebung von Python starten (nur, dass Sie eben das IDLE-Icon doppelklicken und nicht das Python-Icon. Unter Linux geben Sie einfach in einem Terminal &lt;code&gt;idle3.13&lt;/code&gt; o. Ä. ein). Weiter geht es mit &quot;File - Open - ...&quot;. Die auszuführende Datei auswählen (im konkreten Fall ein &quot;Hallo-Welt&quot;-Programm). Es erscheint das rechte Fenster. Dort &quot;Run - Run Module&quot; auswählen. Und schon wird im linken Fenster &quot;Hallo Welt!&quot; ausgegeben.

[[Datei:PythonIng_idle1.jpg | 600px]]

Siehe auch {{W|IDLE}}.

== PyCharm ==
PyCharm ist ein kommerzielles Produkt. Es gab aber auch eine kostenlose Community Edition. Seit 2025 sind beide Varianten vereint. Für die ersten 30 Tage sind die Pro-Funktionen frei verfügbar, danach nur noch die Kernfunktionalitäten (oder man bezieht kostenpflichtig  die Pro-Version). Zu beziehen ist PyCharm unter dem Weblink [https://www.jetbrains.com/pycharm/]. Nachfolgend ein etwas abgewandeltes &quot;Hallo Welt&quot;-Programm, editiert und ausgeführt mit PyCharm.

[[Datei:PyCharm_IDE_2023_screenshot.png | 600px]]

Siehe auch {{W|PyCharm}}.

== Eric ==
Auch eric ist Open Source und steht unter der  GNU General Public License Version 3 oder später. Zu beziehen ist diese Software unter [https://eric-ide.python-projects.org/].

[[Datei:Screenshot_Eric_4.png | 600px]]

Siehe auch {{W|eric (Software)}}.

&lt;small&gt;
Unter openSUSE Tumbleweed sollte sich eric auch mit YaST installieren lassen. Bei mir gibt es aber dann beim Ausführen des eric-Programms eine Fehlermeldung (Stand März 2026): 
 
 ...
 ModuleNotFoundError: No module named 'PyQt6.QtPdfWidgets'

Umgehen kann man dieses Problem aber wieder mit dem Erstellen einer virtuellen Umgebung, in etwa so

 python3.13 -m venv ~/tmp/venv1
 cd ~/tmp/venv1/bin
 ./python3.13 -m pip install --upgrade --prefer-binary eric-ide
 ./eric7_ide
&lt;/small&gt;

== PyScripter ==
Vom Funktionsumfang vergleichbar mit den vorherigen IDEs ist PyScripter. Auch PyScripter ist Open Source. Die Projekt-Homepage findet sich auf [https://sourceforge.net/projects/pyscripter/]. PyScripter ist nur für MS Windows verfügbar.

[[Datei:PythonIng_pyscripter1.jpg | 600px]]

== Spyder IDE ==
Spyder enthält bereits eine stabile Python-Version und etliche Module (z.B. matplotlib, numpy, control). Ansonsten kann dieses Softwarepaket vom Funktionsumfang her mit den anderen genannten IDEs locker mithalten. Spyder wurde unter der MIT-Lizenz veröffentlicht. Diese Software findet sich auf [https://www.spyder-ide.org].

[[Datei:Spyder-windows-screenshot.png | 600px]]

Siehe auch {{W|Spyder (Software)}}

== Eclipse IDE==
Die {{W|Eclipse_(IDE)|Eclipse-IDE}} kann für Python aufgerüstet werden. Dazu gibt es das PyDev-Plugin. Installiert wird es über 
* Help &gt; Eclipse Marketplace... 
* Find - PyDev - Install
Danach muss noch der Pfad zum Python-Interpreter festgelegt werden 
* Window &gt; Preferences &gt; PyDev &gt; Interpreters &gt; Python Interpreter &gt; New ... 
Das Ergebnis ist ähnlich wie im folgenden Bild, nur dass statt C/C++ Python Verwendung findet. 

[[Datei:Setting Up Eclipse CDT helloout.png | 600px]]

== Sonstige ==
Die genannten IDEs sind nicht die Einzigen. Es gibt, um dem Image Pythons als beliebteste Programmiersprache gerecht zu werden, noch einige andere. Sowohl Open Source-Programme als auch kommerzielle Programme sind im Web zu finden, z.B. Thonny oder {{W|Visual Studio Code}}. Unter Linux kann man auch {{W|KDevelop}}, ausgestattet mit dem Python3-Plugin, einsetzen. Braucht man den Umfang von ausgewachsenen IDEs nicht, so kann man auch normale Texteditoren verwenden (z.B. {{W|Geany}} oder {{W|Kate_(Texteditor)|Kate}}).

= Debuggen und Testen =
Das Debuggen und Testen von Programmen sind wichtige Bestandteile der Programmierung. Syntaxfehler lassen sich i.A. leicht beheben. Schwieriger ist das Eingrenzen von logischen Fehlern, die ev. nur in bestimmten Situationen auftreten und keine explizite Fehlermeldung hervorrufen. Das Programm liefert falsche Ergebnisse oder es stürzt aus heiterem Himmel ab. Um das zu verhindern gibt es verschiedene Werkzeuge, die bei der Fehlersuche behilflich sein können. Vorerst siehe aber zwecks Begriffsklärung noch folgende Links: 
 
* {{W|Debuggen}}
* {{W|Debugger}}
* {{W|Softwaretest}}

&lt;gallery&gt;
First Computer Bug, 1947.jpg
Test ganzheitlich.png
V-Modell.svg
&lt;/gallery&gt;

== Das Modul pdb ==
Python bringt schon ein Modul zum Debuggen mit. Siehe z.B. [https://docs.python.org/3/library/pdb.html pdb — The Python Debugger].
Komfortabler lässt sich das aber mittels Integrierter Entwicklungsumgebungen (IDEs) angehen.

== Debuggen mit IDEs ==
Für die IDEs IDLE und Spyder sei kurz auf die entsprechenden Webseiten verwiesen:

* [https://www.cs.uky.edu/~keen/help/debug-tutorial/debug.html Debugging under IDLE].
* [https://docs.spyder-ide.org/current/panes/debugging.html Spyder Debugger]

Dort wird die Vorgehensweise auch mittels Screenshots erläutert.

== assert ==
assert ... behaupten, zusichern ({{W|Assertion (Informatik)}})

Python-Code:
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10., 0.)

Ausgabe:

 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10., 0.)
   File &quot;/home/hr/Develop/test1.py&quot;, line 4, in print1
     assert y != 0.0
            ^^^^^^^^
 AssertionError
 
Python-Code: 
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)
 
Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(&quot;10.&quot;, &quot;5.&quot;)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError
 
Aber auch bei nachfolgendem Code gibt es eine Fehlermeldung:

 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10, 5)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError

Damit letzteres funktioniert, kann man den Programmcode so umschreiben:
 def print1(x, y):
     assert type(x) == float or type(x) == int
     assert type(y) == float or type(y) == int
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 2.0
 
Und jetzt fangen wir den &lt;code&gt;AssertionError&lt;/code&gt; auf:
 def print1(x, y):
     try:
         assert type(x) == float or type(x) == int
         assert type(y) == float or type(y) == int
         assert y != 0.0
         print(x/y)
     except(AssertionError):
         print(&quot;Hallo&quot;)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)

Ausgabe:
 2.0
 Hallo

Ich hoffe, es ist wenigstens im Ansatz klar geworden, wofür &lt;code&gt;assert&lt;/code&gt; gut sein kann. Ausschalten kann man die &lt;code&gt;assert&lt;/code&gt;-Überprüfung übrigens mit dem Python-Schalter &lt;code&gt;-O&lt;/code&gt;.

== Doctests == 
Innerhalb eines Docstrings kann die Arbeit im interaktiven Modus simuliert werden. Nach den Promptzeichen (&gt;&gt;&gt;) erfolgen dann bei unserem Beispiel innerhalb des Docstrings simulierte Aufrufe der Funktion &lt;code&gt;print1()&lt;/code&gt;. Danach folgen jeweils die Sollresultate. Wird das Modul oder die Datei als Hauptprogramm aufgerufen, so wird die Funktion &lt;code&gt;doctest.testmode()&lt;/code&gt; aufgerufen und ein Bericht auf der Konsole ausgegeben. Wird das Modul nicht als Hauptprogramm aufgerufen, sondern importiert, dann wird diese &lt;code&gt;testmod&lt;/code&gt;-Funktion nicht aufgerufen. D.h. dieser Code kann sowohl für Testzwecke als auch für den produktiven Einsatz verwendet werden. Das ist auch sinnvoll, weil wenn man Teile der Datei immer löschen bzw. einfügen müsste, so würden sich Fehlerquellen auftun. Das würde den Sinn und Zweck von Doctests konterkarieren.  

 def print1(x=0., y=1.):
     &quot;&quot;&quot; Dividiere zwei Zahlen
     Autor: Intruder
     Datum: 12.08.2025
 
     &gt;&gt;&gt; print1(2., 1.)
     2.0
     &gt;&gt;&gt; print1(5., 2.)
     2.5
     &gt;&gt;&gt; print1(5.)
     5.0
     &quot;&quot;&quot;
     print(x/y)
 
 if __name__ == &quot;__main__&quot;:
     import doctest
     doctest.testmod(verbose=True)

Ausgabe:
 Trying:
     print1(2., 1.)
 Expecting:
     2.0
 ok
 Trying:
     print1(5., 2)
 Expecting:
     2.5
 ok
 Trying:
     print1(5.)
 Expecting:
     5.0
 ok
 1 items had no tests:
     __main__
 1 items passed all tests:
    3 tests in __main__.print1
 3 tests in 2 items.
 3 passed and 0 failed.
 Test passed.

Das gezeigte Beispiel ist so ziemlich das einfachste, das es gibt. Für weiterführende Details siehe z.B.:
* [https://peps.python.org/pep-0257/ PEP 257 – Docstring Conventions]
* [https://docs.python.org/3/library/doctest.html doctest — Test interactive Python examples]

''Einschub:'' Ganz ähnlich kann man auch Klassen testen, z.B. in folgendem Code-Fragment

 class Fahrzeug:
   # siehe Abschnitt &quot;Objektorientierte Programmierung&quot;
   # ...
 
 if __name__ == &quot;__main__&quot;:
   vauweh = Fahrzeug(170, 90)
   beemweh = Fahrzeug(200, 120)
   print(vauweh.convertGeschw())
   print(beemweh.convertGeschw())

Wird das Script als Hauptprogramm ausgeführt (z.B. zu Testzwecken), so erfolgt die Ausgabe der zwei, via &lt;code&gt;convertGeschw()&lt;/code&gt;, umgerechneten Geschwindigkeiten. Wird es aber als Modul eingebunden, so wird der letzte Programmabschnitt nicht ausgeführt (&lt;code&gt;__name__ == &quot;__main__&quot;&lt;/code&gt; ergibt &lt;code&gt;False&lt;/code&gt;).

== pytest ==
Siehe zu diesem Thema auch {{W|Modultest}}.

pytest ist ein externes Modul und muss vorab installiert werden, z.B. mittels 
 pip install -U pytest
 pip install -U pytest-html 

Python-Code, Datei test1.py:
 def add(x, y):
     return x + y
 
 def test_answer():
     assert add(1, 1) == 3

Starten von pytest in der Konsole:
 pytest test1.py
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py F                                                                                                            [100%]
 
 ========================================================= FAILURES ==========================================================
 ________________________________________________________ test_answer ________________________________________________________
 
     def test_answer():
 &gt;       assert add(1, 1) == 3
 E       assert 2 == 3
 E        +  where 2 = add(1, 1)
 
 test1.py:6: AssertionError
 ================================================== short test summary info ==================================================
 FAILED test1.py::test_answer - assert 2 == 3
 ===================================================== 1 failed in 0.09s =====================================================

Hier erhalten wir einen Fehler, da 1+1 eindeutig ungleich 3 ist. Aber aus irgendeinem Grund wollte der Programmierer oder Tester in diesem Fall, dass dies so ist. Testfälle werden übrigens mit dem Präfix &lt;code&gt;test_&lt;/code&gt; eingeleitet.

Python-Code:
 def add(x, y):
     return x + y + 1
 
 def test_answer():
     assert add(1, 1) == 3 
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py .                                                                                                            [100%]
 
 ===================================================== 1 passed in 0.01s =====================================================

Jetzt ist alles in Ordnung. Weiterführendes siehe z.B.

* [https://docs.pytest.org/en/stable/ pytest: helps you write better programs]

== unittest ==
Auch unittest dient zur Durchführung von Testreihen, ist aber Bestandteil von Python. Hier wird vorerst nicht näher darauf eingegangen. Siehe z.B. 
* [https://docs.python.org/3/library/unittest.html unittest — Unit testing framework]

Lt. ''Inden: Python Challenge; dpunkt, 2021, Seite 481''  soll unittest weniger komfortabel als pytest sein.

Einen Vergleich von unittest mit pytest findet man in
* [https://knapsackpro.com/testing_frameworks/difference_between/pytest/vs/unittest pytest vs unittest]

= Python und Anwendungsprogramme =
Bisher stand immer alleine die Programmiersprache Python (ev. unter Einbeziehung von Modulen) im Mittelpunkt der Betrachtungen. Aber Python kann auch als Makrosprache für Anwendungsprogramme auftreten. Als Beispiele seien {{W|FreeCAD}} und {{W|LibreOffice}} genannt.

== FreeCAD ==
FreeCAD ist ein freies 3D-CAD-Programm. Hier soll nicht auf die Bedienung dieses CAD-Pakets eingegangen werden, sondern nur auf die Möglichkeit, mittels Python Makros zu schreiben. Als einfacher Einstieg soll ein Makro erstellt werden, welches eine Kugel (rot) und einen Quader (blau) zeichnet. Folgende Vorbereitungsschritte sind erforderlich (es sei vorausgesetzt, dass FreeCAD schon am Rechner installiert ist. Downloaden können Sie das Programm von der Website [https://www.freecad.org/downloads.php?lang=en]):

* FreeCAD starten
* Leere Datei erstellen
* Makro &gt; Makros &gt; Erstellen ...

Es öffnet sich ein leeres Editorfenster, in das Sie folgenden Code eingeben können:

 import FreeCAD
 import Part
 
 doc = FreeCAD.newDocument()
 
 # Kugel
 kugel = Part.makeSphere(10)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Kugel&quot;)
 form_element.Shape = kugel
 kug = FreeCAD.ActiveDocument.getObject(&quot;Kugel&quot;)
 kug.ViewObject.ShapeColor = (1.0, 0.0, 0.0)
 neuePosition = App.Vector(5, 2.5, 2.5)
 kug.Placement = App.Placement(neuePosition, kug.Placement.Rotation)
 
 # Quader
 quader = Part.makeBox(5, 5, 50)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Quader&quot;)
 form_element.Shape = quader
 quad = FreeCAD.ActiveDocument.getObject(&quot;Quader&quot;)
 quad.ViewObject.ShapeColor = (0.0, 0.0, 1.0)
 
 doc.recompute()

Diesen Code können Sie nun ausführen:
* Makro &gt; Makro ausführen

Es ergibt sich folgende Ausgabe (gedreht und gezoomt):

[[Datei: PythonIng_freecad1.png|500px]]

Siehe auch [https://wiki.freecad.org/Python_scripting_tutorial/de# Anleitung Skripterstellung mit Python]. Getestet wurde obiges Beispiel mit FreeCAD 1.1.3 unter Linux und 1.1.1 unter MS Windows.

== LibreOffice ==
LibreOffice ist ein freies Officepaket ([https://de.libreoffice.org/]). Hier soll nur das Tabellenkalkulationsprogramm Calc kurz betrachtet werden. Es seinen in den ersten 3 Zellen (A1 bis A3) Zahlen gegeben. Diese sollen mit einem Python-Makro addiert und das Resultat in der Zelle A5 ausgegeben werden. Auch hier sind Vorbereitungsarbeiten nötig: 
* zuerst muss unter Linux das Verzeichnis &lt;code&gt;~/.config/libreoffice/4/user/Scripts/python&lt;/code&gt; erstellt werden
* für MS Windows ist es das Verzeichnis &lt;code&gt;%APPDATA%\LibreOffice\4\user\Scripts\python&lt;/code&gt; 
** drücken Sie zuerst Win + R (es öffnet sich das Ausführen-Fenster)
** geben Sie &lt;code&gt;%appdata%&lt;/code&gt; ein, danach drücken Sie Enter (es öffnet sich der Explorer)
** navigieren Sie zu dem genannten Verzeichnis bzw. erstellen Sie das Verzeichnis 
* in diesem Verzeichnis wird dann mit einem beliebigen Texteditor das Python-Makro erstellt, in unserem Fall die Datei &lt;code&gt;summiere_zellen.py&lt;/code&gt;:

 import uno
 
 def summiere_zellen(*args):
     # Zugriff auf das aktuelle Dokument und das aktive Tabellenblatt
     ctx = uno.getComponentContext()
     smgr = ctx.getServiceManager()
     desktop = smgr.createInstanceWithContext(&quot;com.sun.star.frame.Desktop&quot;, ctx)
     doc = desktop.getCurrentComponent()
     sheet = doc.getCurrentController().getActiveSheet()
 
     # Werte aus den Zellen A1 bis A3 auslesen
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
 
     # Addition der drei Werte
     summe = w1 + w2 + w3
 
     # Ergebnis in die Zelle A5 schreiben
     sheet.getCellRangeByName(&quot;A5&quot;).Value = summe

* siehe dazu ggf. auch [https://help.libreoffice.org/latest/de/text/sbasic/python/python_locations.html?DbPAR=BASIC].

Weiter geht es in LibreOffice Calc mit dem Menü ''Extras &gt; Makros &gt; Makros verwalten &gt; Python''. Dort wird das Makro &lt;code&gt;summiere_zellen&lt;/code&gt; ausgeführt. Es ergibt sich z.B. folgendes Resultat

[[Datei:PythonIng_libreoffice1.png]]

Das Kürzel &lt;code&gt;uno&lt;/code&gt; steht für '''U'''niversal '''N'''etwork '''O'''bjects. Etwas einfacher geht's auch so:

 def summiere_zellen():
     desktop = XSCRIPTCONTEXT.getDesktop()
     model = desktop.getCurrentComponent()
     sheets = model.getSheets()
     sheet = sheets.getByIndex(0)
     
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
     
     cell = sheet.getCellRangeByName(&quot;A5&quot;)    
     cell.setValue(w1 + w2 + w3) 

Empfohlen wird auch, das Erweiterungspaket APSO ('''A'''lternative '''P'''ython '''S'''cript '''O'''rganizer, apso.oxt) zu installieren. Die Vorgehensweise wird hier nicht gezeigt, sondern nur darauf hingewiesen, dass man das einfach &quot;googeln&quot; kann. Siehe zur Python-Programmierung für LibreOffice auch [https://wiki.documentfoundation.org/Macros/Python_Guide/de Makros/Python-Handbuch]. Getestet wurden obige Beispiele mit LibreOffice 26.2.5.1 unter Linux und 26.2.1.2 unter MS Windows.

= Ausblick =
Dies war eine kurze Einführung in die Berechnungs- und Darstellungsmöglichkeiten mit Python. Es sollten etliche relevante Themen behandelt, oder zumindest kurz angesprochen worden sein. Wem dieser Text nicht ausreichend ist, der sei auf die entsprechenden weiterführenden Weblinks, Bücher und die Python-Hilfefunktion verwiesen. Python kennt noch viel mehr Befehle, als hier dargestellt wurden. Das Themenspektrum ist auch durch die Einbindung externer Module fast beliebig erweiterbar.

= Weblinks=
== Python allgemein ==
* [https://www.python.org/ Python Homepage]

== Externe mathematische Module ==
* [https://numpy.org/ NumPy]
* [https://numpy.org/doc/stable/user/numpy-for-matlab-users.html NumPy for MATLAB users]
* [https://scipy.org/ SciPy]
* [https://www.sympy.org/en/index.html SymPy]
* [https://pandas.pydata.org/ pandas]
* [https://github.com/maroba/findiff findiff]
* [https://mpmath.org/ mpmath]

== Externe Module für Grafiken ==
* [https://matplotlib.org/ Matplotlib]
* [https://vpython.org/ VPython]
* [https://build123d.readthedocs.io/en/latest/ build123d]
* [https://docs.vtk.org/en/latest/api/python.html VTK]
* [https://docs.bokeh.org/en/latest/docs/first_steps.html bokeh]
* [https://py5coding.org/ py5]

== Erstellung von User Interfaces ==
* [https://docs.python.org/3/library/tkinter.html tkinter - Python interface to Tcl/Tk]
* [https://docs.python.org/3/library/curses.html curses - Terminal handling for character-cell displays]
* [https://wiki.qt.io/Qt_for_Python Qt for Python]
* [https://www.gtk.org/docs/language-bindings/python GTK and Python]

== Erstellen virtueller Umgebungen ==
* [https://docs.python.org/3/library/venv.html venv - Creation of virtual environments]

== Sonstige ==
* [https://python-control.readthedocs.io/en/stable/ Python Control Systems Library]
* [https://pypi.org/project/regex/ regex - Regular Expressions]
* [http://pyromat.org/ PYroMat]
* [https://coolprop.org/coolprop/wrappers/Python/index.html CoolProp]
* [https://pypi.org/project/iapws/ iapws]
* [https://tespy.readthedocs.io/en/main/getting_started/introduction.html TESPy - Thermal Engineering Systems in Python]
* [https://pint.readthedocs.io/en/stable/ pint]

= Bücher =
== Gedruckte Bücher, OpenBooks, Magazine ==
* Diverse: c't Python Lernen, Verstehen, Anwenden; Heise, 2022 
* Ernesti, Kaiser: Python3 - das umfassende Handbuch; 5. Aufl., Rheinwerk, [https://openbook.rheinwerk-verlag.de/python/ OpenBook]
* Iacono et al.: Programmieren trainieren; 3. Aufl., Hanser, 2023, ISBN 978-3-446-47766-7
* Inden: Python Challenge; dpunkt, 2021, ISBN 978-3-86490-809-5
* Klein: Numerisches Python; 2. Aufl., Hanser, 2023, ISBN 978-3-446-47170-2 
* Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler; Rheinwerk, 2021, ISBN 978-3-8362-7316-9
* Weigend: Python 3 - Das umfassende Praxisbuch; 9. Aufl., mitp, 2022, ISBN 978-3-7475-0544-1
* Woyand: Python für Ingenieure und Naturwissenschaftler; 4. Aufl., Hanser, 2021, ISBN 978-3-446-46483-4

== Andere Wikibooks ==
* [[:en:Subject:Python_programming_language | Englische Wikibooks zum Thema Python]]
* [[Python|Deutschsprachiges Python-Wikibook]] [[Bild:2von10.png|20%]]
* [[Python unter Linux|Python 2.7 unter Linux]] [[Bild:10von10.png|100%]]


{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}</text>
      <sha1>hw5cfwefetrmz40yszan87oq12zpua0</sha1>
    </revision>
    <revision>
      <id>1092166</id>
      <parentid>1092165</parentid>
      <timestamp>2026-10-16T13:31:30Z</timestamp>
      <contributor>
        <username>Intruder</username>
        <id>1513</id>
      </contributor>
      <minor />
      <comment>/* if */</comment>
      <origin>1092166</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="189223" sha1="4bksmzf0mvkg9bi13htq13lf77lr96u" xml:space="preserve">{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}


= Hallo Welt und allgemeine Hinweise =
== Was ist Python ==
* Python ist eine universelle höhere Programmiersprache.
* Python ist objektorientiert.
* Python ist Open-Source (Python Software Foundation License).
* Python ist für viele Betriebssysteme erhältlich (z.B. für Linux, MS Windows, macOS).
* Python ist ein Interpreter.
* Python ist durch Module fast beliebig erweiterbar.
* Python als Programmiersprache ist case-sensitive - d.h. Groß- und Kleinschreibung ist relevant bei der Eingabe von Befehlen.
* Python ist in etlichen Anwendungsprogrammen (z.B. {{W|FreeCAD}}, {{W|LibreOffice}}, {{W|GIMP}}, {{W|Blender (Software) | Blender}}) als Makrosprache verwendbar.

{{Wikipedia | Python (Programmiersprache)}}

== Python installieren ==
=== MS Windows ===
Laden Sie das aktuelle Python-Paket von der Webseite [https://www.python.org/] herunter. Weiter geht es wie bei jedem anderen größeren zu installierenden Programm. Einfach das Installationsprogramm im Explorer doppelklicken und den Anweisungen des Setup-Programmes folgen.

=== Linux ===
Entweder ist Python bereits standardmäßig installiert, ansonsten ist die Installation mittels Paketmanagementsystem einfach möglich. Aber auch die Spyder-Entwicklungsumgebung ([https://www.spyder-ide.org]) bietet einen guten Einstieg mit Python (das gilt auch für MS Windows). Spyder bringt auch schon etliche wichtige Module standardmäßig mit.

== Python starten ==
=== MS Windows ===
Das Icon für das Python-Programm doppelklicken. Und schon startet das Programm.

[[Datei:PythonIng_start1.jpg]]

Python im interaktiven Modus präsentiert sich dann so:

 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

Alternativ kann das Programm auch über die Eingabeaufforderung oder die PowerShell gestartet werden:

 c:\devel\Python&gt;python.exe
 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

=== Linux ===
Tippen Sie einfach das Wort „python“ (oder unter openSUSE Tumbleweed z.B. auch „python3.11“ oder „python3.13“) in einem Linux-Terminal ein, schließen den Befehl mit der RETURN-Taste ab, und schon startet Python im interaktiven Modus:
 
 Python 3.13.12 (main, Feb 09 2026, 22:37:44) [GCC] on linux
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt; 

Es gibt auch noch andere Möglichkeiten Python zwecks Programmausführung zu starten, z.&amp;nbsp;B. den {{W|Shebang}} (&lt;code&gt;#!&lt;/code&gt;) am Beginn eines Python-Scripts. Das Script sei als Script.py gespeichert. Dann kann das Script mit ./Script.py ausgeführt werden. Für openSUSE Tumbleweed sei nachfolgend ein lauffähiges &quot;Hallo Welt!&quot;-Script angegeben. Es wird in diesem Script der Python-Interpreter in der Version 3.13 verwendet :

 #!/usr/bin/python3.13
 print(&quot;Hallo Welt!&quot;)

Die Berechtigungen zum Ausführen der Datei müssen natürlich noch richtig gesetzt werden, z.B. mittels &lt;code&gt;chmod 777 Script.py&lt;/code&gt;. &lt;small&gt;&lt;code&gt;chmod&lt;/code&gt; ist die Abkürzung für&quot;'''ch'''ange file '''mod'''e bits&quot;.&lt;/small&gt; 

&lt;small&gt;Die &quot;Maske&quot; &lt;code&gt;777&lt;/code&gt; ist nur für Testzwecke sinnvoll, weil sie leicht zu merken ist und für alle Benutzer alle Zugriffsberechtigungen ('''r'''ead/'''w'''rite/e'''x'''ecute für owner/group/others) setzt. Im richtigen Einsatz wird man das aus Sicherheitsgründen nicht so handhaben, sondern nur die Berechtigungen setzen, die unbedingt erforderlich sind. Welche Zugriffsberechtigungen gesetzt sind, kann man z.B. mit dem Befehl &lt;code&gt;ls -l&lt;/code&gt; oder &lt;code&gt;ll&lt;/code&gt; ('''l'''i'''s'''t directory contents) erfragen. Aber dazu im Moment genug. Erfahrene Linux-Nutzer kennen das ohnehin und Anfänger sollen jetzt nicht mit Linux-Interna überfordert werden. Bei Bedarf siehe die Linux-Man-Pages oder dezidierte Bücher zu Linux.&lt;/code&gt;&lt;/small&gt;

&lt;small&gt;Oder das Script wird in einen Pfad verschoben, in dem sich ausführbare Programme generell befinden (welche Verzeichnisse im PATH liegen, kann bspw. mit &lt;code&gt;echo $PATH&lt;/code&gt; abgefragt werden). Das Script kann dann wie ein normales Programm ohne weitere Angaben mit Script.py gestartet werden. Alternativ wird nicht das Script an sich verschoben, sondern nur ein symbolischer Link angelegt, z.B. mit &lt;code&gt;ln -s ~/tmp/Script.py ~/.local/bin/Script.py&lt;/code&gt;. &lt;code&gt;~/.local/bin&lt;/code&gt; sei ein im PATH gelegenes Verzeichnis. Dies sind aber schon Features für fortgeschrittene Linux-Benutzer und werden am Anfang eher selten benötigt.&lt;/small&gt;

== Ein paar Worte zur Erklärung ==
=== Tests ===
Getestet wurden die Beispiele unter den Betriebssystemen 
* MS Windows 10 mit der Python-Version 3.12.0 (teilweise auch mit 3.12.2 und 3.13.1; nur die Inhalte die bis spätestens Juli 2025 erstellt wurden) 
* MS Windows 11 ab der Python-Version 3.13.4 (nur zum Teil; ab Juli 2025)
* openSUSE Leap 15.6 mit der Python-Version 3.11.12 (Spyder, nur vereinzelt) und zum Teil mit 3.12.11 (ab Juli 2025 bis November 2025).
* openSUSE Tumbleweed ab der Python-Version 3.13.9 (nur vereinzelt, ab November 2025)

=== Popularität ===
* An Beliebtheit rangiert Python mit Stand September 2026 mit einem Rating von 17,76% an 1. Stelle vor C und C++ (lt. [https://www.tiobe.com/tiobe-index/ TPCI - TIOBE Programming Community Index]). 
* Lt. [https://innovationgraph.github.com/global-metrics/programming-languages GitHub Top 50 Programming Languages Globally] lag Python im Q1/2026 auf Rang 2, vor TypeScript und hinter JavaScript. 
* [https://pypl.github.io/PYPL.html PYPL] (Popularity of Programming Language Index) ist ein anderer Popularitätsindex für Programmiersprachen. Auch hier liegt Python mit großem Vorsprung auf dem ersten Platz (52,08%), gefolgt von Java (13,34%) und C/C++ (7,99%) (Stand September 2026). 

=== Namensgebung ===
Der Name &quot;Python&quot; rührt von der Komikertruppe {{W|Monty Python}} her. Die Icons für Python (z.B. Python selbst, Eric IDE, IDLE) sind aber durch die Python-Schlangenart symbolisiert.

&lt;gallery&gt;
Python-logo-notext.svg|Python-Logo
Guido van Rossum in PyConUS24.jpg|{{W|Guido van Rossum}} (geb. 1956), der Erfinder von Python
&lt;/gallery&gt;

== Ein erstes Programm ==
Kommentare werden in Python mit der Raute (#) eingeleitet. Sie werden vom Python-Interpreter ignoriert. Text kann mit der print-Funktion ausgegeben werden. Starten Sie Python und geben sie folgende Anweisungen zeilenweise ein

 &gt;&gt;&gt; # Das ist ein Kommentar
 &gt;&gt;&gt; print(&quot;Hallo Welt!&quot;)

Als Ergebnis erhalten Sie

 Hallo Welt!

Der Prompt (&gt;&gt;&gt;) ist selbstverständlich nicht einzutippen, sondern wird vom Python-System geliefert.

Strings können in Python entweder in Anführungszeichen (&quot;) gesetzt werden oder in Hochkommatas('). In diesem Text wird die erste Variante bevorzugt eingesetzt.

Im Gegensatz zu Julia ist es hier egal, ob zwischen &lt;code&gt;print&lt;/code&gt; und der öffnenden Klammer Leerzeichen stehen.

= Python als Taschenrechner =
== Allgemeines ==
Wir wollen 3 * 5 berechnen. Dazu starten wir Python im interaktiven Modus. Geben Sie dann die Formel  

 &gt;&gt;&gt; 3 * 5

ein, drücken die Taste ENTER/RETURN ({{Taste|↵}}) und erhalten als Ergebnis

 15

Auch kompliziertere Ausdrücke sind möglich. Beispielsweise mit Winkelfunktionen, Quadratwurzeln etc. Wir wollen nun den Ausdruck &lt;math&gt;\sin\sqrt{15}&lt;/math&gt; berechnen :

 &gt;&gt;&gt; import math
 &gt;&gt;&gt; math.sin(math.sqrt(15))
 -0.6679052983383519

Als erstes wird das math-Modul importiert. Dann wird der mathematische Ausdruck berechnet.

Eine andere Variante, die dasselbe Ergebnis liefert, ist

 &gt;&gt;&gt; from math import *
 &gt;&gt;&gt; sin(sqrt(15))
 -0.6679052983383519

Es wird also aus dem Modul &lt;code&gt;math&lt;/code&gt; alles importiert (erkennbar am &lt;code&gt;*&lt;/code&gt;). Will man nicht alles importieren, so kann man das auch einschränken:

 &gt;&gt;&gt; from math import sin, sqrt

Beenden lässt sich das Python-Programm durch Eingabe von &lt;code&gt;exit()&lt;/code&gt; (und natürlich ist zur Bestätigung die RETURN-Taste zu drücken). &lt;code&gt;exit&lt;/code&gt; (ohne Klammern) oder &lt;code&gt;quit&lt;/code&gt; werden auch akzeptiert.

== Die Hilfefunktion von Python ==
Bei Eingabe der Anweisung &lt;code&gt;help&lt;/code&gt; oder &lt;code&gt;help()&lt;/code&gt; springt Python in den Hilfemodus. 

Eingabe:
 &gt;&gt;&gt; help()
 
Eingabe:
 help&gt; math.sin

Ausgabe:
 Help on built-in function sin in math:
 
 math.sin = sin(x, /)
     Return the sine of x (measured in radians).

Für die komplette Python-Dokumentation siehe [https://docs.python.org/3/]. Verlassen kann man den Hilfemodus durch das Drücken von STRG-C, bzw. der Eingabe von q, quit oder exit mit anschließendem Drücken der RETURN-Taste.

== Aufgaben ==
* Erkunden Sie die Tangensfunktion &quot;tan&quot; mittels Python-Hilfe (vergessen Sie nicht das math-Modul zu importieren und das &lt;code&gt;math.&lt;/code&gt; vor &lt;code&gt;tan&lt;/code&gt;)
* Berechnen Sie mit Python den Ausdruck &lt;math&gt;\frac{1}{2}\cdot \text{e}^2 \cdot \tan(\pi/3)&lt;/math&gt;. Siehe für die Exponentialfunktion im Python-Hilfesystem auch den Befehl &lt;code&gt;math.exp&lt;/code&gt;. Alternativ kann auch die Konstante &lt;code&gt;math.e&lt;/code&gt; eingesetzt werden. Potenzieren kann man bei Python mit dem **-Operator (z.B. 2**3 = 8). Für &lt;math&gt;\pi&lt;/math&gt; gibt es &lt;code&gt;math.pi&lt;/code&gt;.

= Python als Scriptsprache =
Häufig wird man aber kompliziertere Anweisungsfolgen verarbeiten müssen. Diese will man normalerweise nicht jedesmal neu eingeben, sondern in einer Datei speichern und diese Datei dann zur Ausführung bringen. Speichern Sie dazu folgenden Code in einer Textdatei, z.B. unter MS Windows als c:\tmp\test1.py

 # Das ist ein Kommentar
 print(&quot;Hallo Welt!&quot;)

Python-Dateien werden mit der Dateiendung .py versehen. Achten Sie darauf, dass vor dem print keine Leerzeichen vorhanden sind. Das ist eine Python-Eigenheit. Wie wir später sehen werden, nutzt Python Einrückungen als syntaktisches Mittel, z.B. um bei Schleifen den Schleifenkörper zu kennzeichnen. 

Danach bringen Sie die Skriptdatei test1.py (sozusagen das Hauptprogramm) folgendermaßen zur Ausführung:

1) Starten Sie unter MS Windows die Eingabeaufforderung (oder alternativ auch die Windows PowerShell). Das sieht dann etwa so aus:

 Microsoft Windows [Version 10.0.19045.3693]
 (c) Microsoft Corporation. Alle Rechte vorbehalten.
 
 C:\Users\xyz&gt;

: &lt;small&gt;Falls jemand nicht weiß, wie man die Eingabeaufforderung startet: Eine Möglichkeit ist, einfach in der Taskleiste von Windows das &quot;Start&quot;-Symbol &amp;nbsp;([[Image:Windows_logo_-_2021_(Black).svg|10px]])&amp;nbsp; mit der rechten Maustaste anklicken. &quot;Ausführen&quot; auswählen (oder alternativ für die PowerShell unter Windows 10 den Eintrag &quot;Windows PowerShell&quot;, unter Windows 11 den Eintrag &quot;Terminal&quot;). Im sich öffnenden Dialogfenster gibt man in die &quot;Öffnen&quot;-Zeile das Wort &lt;code&gt;cmd&lt;/code&gt; ein und mit &quot;OK&quot; wird das Ganze bestätigt.&lt;/small&gt; 
 
2) Wechseln Sie mittels &lt;code&gt;cd c:\tmp&lt;/code&gt; in das Verzeichnis c:\tmp

3) Angenommen, Sie haben Python unter dem Pfad &lt;code&gt;c:\devel\Python\&lt;/code&gt; installiert. Starten Sie das Programm so (der Prompt &lt;code&gt;c:\tmp&gt;&lt;/code&gt;ist natürlich nicht mit einzutippen): 

 c:\tmp&gt;c:\devel\Python\python.exe test1.py

4) Wie erwartet ergibt sich folgende Ausgabe am Bildschirm

 Hallo Welt!

Die Vorgehensweise unter Linux ist prinzipiell gleich. Die kleinen Unterschiede, wie z.B. der Slash statt dem Backslash in Pfadangaben, sollten für Linux-Benutzer keine Hürde darstellen.

== Variablen ==
Variablenbezeichner können aus Buchstaben (A-Za-z), Ziffern (0-9) und Underscores (_) bestehen, dürfen aber nicht mit einer Zahl beginnen. Führende Underscores haben u.a. im Kontext mit der Objektorientierten Programmierung eine spezielle Bedeutung und sollten nicht für &quot;normale&quot; Variablenbezeichner verwendet werden.

Gültige Variablenbezeichner wären also:
 xyz
 x1
 _wert
 name_anzahl

Theoretisch kann man auch Umlaute, griechische Buchstaben u.ä. in Variablenbezeichnern nutzen, z.B.

 ößÜ = 16
 α = 134 
 print(ößÜ)
 print(α)

Ausgabe:
 16
 134

Davon wird aber aus offensichtlichen Gründen ({{W|Englisch als Lingua franca}}) abgeraten. Das Eurozeichen (€) etc. darf man ohnehin nicht in Variablenbezeichnern verwenden, dies ergäbe einen Syntaxfehler. Siehe dazu auch [https://peps.python.org/pep-3131/].

Es gibt in Python etliche Schlüsselwörter (z.B. for, if oder return). Diese dürfen nicht als eigene Variablenbezeichner verwendet werden. Eine Liste aller Schlüsselwörter liefert das Script

 import keyword
 print(keyword.kwlist)

&lt;small&gt;Übung: Speichern Sie dieses Script in eine Datei, z.B. in c:\tmp\test1.py. Führen Sie diese Datei aus, um die Liste der Schlüsselwörter auszugeben.&lt;/small&gt;

Da Python case-sensitiv ist, repräsentieren folgende Bezeichner verschiedene Variablen:
 xyz
 XYZ
 xYz

Werte werden an Variablen mittels Gleich-Zeichen (=) zugewiesen. Im Folgenden wird der Code immer in der Datei c:\tmp\test1.py gespeichert.

 x = 5
 y = 10
 z = x*y
 print(z)

Bringen Sie die Datei test1.py zur Ausführung, so erhalten Sie folgende Bildschirmausgabe

 50

Sie können auch mehrere Anweisungen in einer Zeile durch Semikolon getrennt schreiben. Dies führt aber zu unübersichtlichem Code.

 x = 5; y = 10; z = x*y; print(z)

Ausgabe:
 50

Auch aus der Programmiersprache C/C++ oder Java bekannte Konstrukte können Sie verwenden, z.B.
 x = 5
 # x = x - 2
 x -= 2
 print(x)

Bildschirmausgabe:

 3
 
Beachten Sie, dass mit dem =-Zeichen eine Wertezuweisung durchgeführt wird. Dies ist nicht äquivalent zum mathematischen =-Zeichen, wie am vorigen Beispiel zu ersehen ist. Den Inkrement-/Dekrementoperator (z.B. x++ oder x--) aus C/C++ oder Java kennt Python aber nicht.

Variablen sind nicht an einen bestimmten Datentyp gebunden, folgendes ist mit Python problemlos möglich:

 import math
 wert = 10
 print(wert)
 wert = 35.5
 print(wert)
 wert = &quot;Hallo&quot;
 print(wert)
 wert = math.pi
 print(wert)

Ausgabe:
 10
 35.5
 Hallo
 3.141592653589793

== Physische und logische Zeilen ==
In Python muss eine Anweisung in einer logischen Zeile Platz finden. Wird eine Anweisung aber zu lang für eine Zeile, dann kann sie in mehrere physische Zeilen unterteilt werden. Dies kann einerseits durch einen Backslash am Ende einer Zeile geschehen, z.B.

 a = 2 + \
 5
 
Dies stellt eine logische Zeile dar, die in zwei physische Zeilen unterbrochen ist.

Geklammerte Ausdrücke werden automatisch zu einer logischen Zeile verbunden, z.B.

 a = (2 + 
 5)
 
Achtung: Im ersten Beispiel darf nach dem Backslash nichts mehr stehen, auch kein Kommentar. Dies trifft im zweiten Bespiel nicht zu, hier könnte noch ein Kommentar folgen, z.B.

 a = (2 +    # Kommentar 
 5)

Auch für Strings gibt es Möglichkeiten, diese auf mehrere Zeilen aufzuspalten.

 # Kurzer String
 str1 = &quot;ABC&quot;
 
 # Langer String
 str2 = &quot;&quot;&quot;Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle&quot;&quot;&quot;
 
 # Backslash
 str3 = &quot;UVW\
 XYZ&quot;
 
 # Mit Klammern
 str4 = (&quot;Sehr langer Text, der automatisch .............. &quot;
         &quot;in einer einzigen Variable zusammengefügt wird.&quot;
 )
 
 print(str1)
 print(str2)
 print(str3)
 print(str4)

Ausgabe:

 ABC
 Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle
 UVWXYZ
 Sehr langer Text, der automatisch .............. in einer einzigen Variable zusammengefügt wird.

==Hexadezimale, oktale, binäre und andere Zahlen==
 d = 1050         # Dezimalzahl
 h = 0xAA2        # Hexadezimalzahl
 o = 0o12         # Oktalzahl
 b = 0b100001101  # Binärzahl
 
 print(d)
 print(h)
 print(o)
 print(b)

Ausgabe:
 1050
 2722
 10
 269

Groß- und Kleinbuchstaben sind in obigen Literalen übrigens egal. So kann man z.B. statt &lt;code&gt;0b1001&lt;/code&gt; auch &lt;code&gt;0B1001&lt;/code&gt; schreiben (siehe dazu [https://docs.python.org/3/reference/lexical_analysis.html#integer-literals]).

Sie können auch dezimale in hexadezimale Zahlen umwandeln, usw.:
 h = hex(1050)    # Dezimalzahl -&gt; Hexadezimalzahl
 b = bin(1050)    # Dezimalzahl -&gt; Binärzahl
 o = oct(1050)    # Dezimalzahl -&gt; Oktalzahl
 print(h)
 print(b)
 print(o)

Ausgabe:
 0x41a
 0b10000011010
 0o2032

Gegeben sei die Zahl 121 zur Basis 3. Diese soll in eine Dezimalzahl umgewandelt werden. Das kann so geschehen:

 z = int(&quot;121&quot;, 3)
 print(z)

Ausgabe:
 16

Dass dies richtig ist, davon kann man sich folgendermaßen überzeugen:
 &lt;math&gt; 1 \cdot 3^2 + 2 \cdot 3^1 + 1 \cdot 3^0 = 9 + 6+ 1 = 16 &lt;/math&gt;

Zahlen übersichtlicher schreiben kann man auch mittels Underscore, z.B.:

 print(&quot;Eine Million (Variante 1) =&quot;, 1000000)
 print(&quot;Eine Million (Variante 2) =&quot;, 1_000_000)
 print(&quot;Eine Rechnung:&quot;, 2_000 * 400_000);

Es ergibt sich bei beiden Varianten die gleiche Ausgabe. Variante 2 ist aber im Sourcecode leichter lesbar, detto die Zahlen in der Rechnung:

 Eine Million (Variante 1) = 1000000
 Eine Million (Variante 2) = 1000000
 Eine Rechnung: 800000000

== Strings und Platzhalter==
Ein paar einfache Beispiele:

 print(&quot;Hallo {}&quot; . format(&quot;Hugo&quot;))     # new style string formatting
 print(&quot;Hallo {:s}&quot; . format(&quot;Hugo&quot;))   # new style string formatting
 print(&quot;Hallo %s&quot; % &quot;Hugo&quot;)             # %-String

Ausgabe:

 Hallo Hugo
 Hallo Hugo
 Hallo Hugo

Python-Code (formatted string literals, Beispiel 1):
 str1 = &quot;Hallo&quot;
 str2 = &quot;Hugo&quot;
 print(f&quot;{str1} {str2}&quot;)

Ausgabe:
 Hallo Hugo

f-Strings (ab Python 3.6) sind die modernere Variante gegenüber %-Strings oder das ''new style string formatting''. Sie sind in der Regel auch schneller.

Python-Code (formatted string literals, Beispiel 2):
 wert = 11.567
 print(f&quot;Ausgabe: {wert:.5f}&quot;)

Ausgabe:
 Ausgabe: 11.56700

Komplexere Beispiele:

 print(&quot;Hallo {} und {}&quot; . format(&quot;Hugo&quot;, &quot;Mike&quot;))
 print(&quot;Hallo {name1} und {name2}&quot; . format(name2=&quot;Hugo&quot;, name1=&quot;Mike&quot;))
 # Füllzeichen: *
 # Bündigkeit: &gt; (=rechts), &lt; (=links), ^ (=zentriert)
 # Feldweite: 10
 # Typ: s (=String), f (=Gleitkommazahl), d (=Dezimalzahl) etc.
 print(&quot;Hallo {:*&gt;10s}&quot; . format(&quot;Hugo&quot;))
 print(&quot;Hallo {:*&lt;10s}&quot; . format(&quot;Hugo&quot;))

Ausgabe:

 Hallo Hugo und Mike
 Hallo Mike und Hugo
 Hallo ******Hugo
 Hallo Hugo******

Python-Code:
 str = &quot;Hallo\t%s\t%7.2f\t%10.2e\t%i&quot; % (&quot;Hugo&quot;, 12.34567, 34.567, 264)
 print(str)

Ausgabe:
 Hallo	Hugo	  12.35	  3.46e+01	264

== Unicode ==
Neben den bekannten ASCII-Zeichen lassen sich Zeichen auch mittels Unicode beschreiben. Griechische Buchstaben oder komplexere mathematische Operatoren - all das sollte kein Problem sein. Siehe auch {{W|Unicode}}, {{W|Liste der Unicodeblöcke}} und {{W|Unicodeblock Mathematische Operatoren}}. Im Folgenden werden ein paar Zeichen (Allquantor, Nabla-Operator, Existenzquantor), die man aus der Mathematik kennt, erzeugt. 
 
 ch1 = &quot;\N{FOR ALL}&quot;
 ch2 = &quot;\N{NABLA}&quot;
 ch3 = &quot;\u2203&quot;
 print(ch1, ch2, ch3)

Ausgabe:
 ∀ ∇ ∃

&lt;small&gt;Diese Ausgabe ergibt sich z.B. mit der IDLE-Shell oder mit Cygwin. Beim Ausführen über die Windows-Eingabeaufforderung oder Windows PowerShell unter MS Windows 10 erfolgt keine korrekte Darstellung. IDLE ist die mit Python mitgelieferte IDE ('''I'''ntegrated '''D'''evelopment '''E'''nvironment, Integrierte Entwicklungsumgebung). Gegen Ende dieses Textes wird IDLE kurz beschrieben.
Das Problem mit der Windows Eingabeaufforderung lässt sich aber umgehen. Man muss nur eine Schriftart auswählen, die die Zeichen kennt, z.B. &quot;DejaVu Sans Mono&quot;. Dazu klicken Sie einfach bei der Eingabeaufforderung mit der rechten Maustaste oben auf die weiße Leiste und wählen im aufpoppenden Fenster den Menüpunkt &quot;Eigenschaften&quot;. Es öffnet sich ein Dialogfenster. Über den Reiter &quot;Schriftart&quot; lässt sich nun die Schriftart einstellen. Unter MS Windows 11 oder openSUSE Leap 15.6 (bash-Konsole) gibt es dieses Problem ohnehin nicht.&lt;/small&gt;

== Reguläre Ausdrücke ==
Python kennt auch {{W|Regulärer Ausdruck|reguläre Ausdrücke}}. Dazu gibt es in Python das Modul &lt;code&gt;re&lt;/code&gt;. Beipielsweise sollen alle Zahlen (&lt;math&gt;\text{zahl}\in\mathbb{N}_0&lt;/math&gt;) in einem String gesucht und ausgegeben werden. Als String sei gegeben: &lt;code&gt;3x Grüße und 100 Kekse.&lt;/code&gt; Das Muster (Pattern) ist &lt;code&gt;\d+&lt;/code&gt;. &lt;code&gt;\d&lt;/code&gt; steht für eine Dezimalziffer 0-9. Das Plus-Zeichen (+) steht symbolisch für ein oder mehrere Zeichen des vorherigen Ausdrucks. Hier also ein oder mehrere Dezimalziffern. Es wird die Funktion &lt;code&gt;findall&lt;/code&gt; aus dem Modul &lt;code&gt;re&lt;/code&gt;verwendet.

Python-Code:
 from re import findall
 
 str = &quot;3x Grüße und 100 Kekse.&quot;
 pat = &quot;\\d+&quot;  # Doppel-Backslashes müssen verwendet werden, sonst gibt Python eine Warnung aus!
               # alternativ: pat = r&quot;\d+&quot; 
               # oder: pat = &quot;[0-9]+&quot;
 
 numb = findall(pat, str)
 print(numb)

Ausgabe:
 ['3', '100']

Python kennt noch viele weitere Möglichkeiten mittels regulärer Ausdrücke zu hantieren. Dies soll hier aber nicht vertieft werden, da das Thema schon ziemlich speziell und komplex ist. Bei Bedarf siehe aber z.B. die Bücher ''Weigend, Seite 380ff'' und ''Ernesti, Kaiser'' [https://openbook.rheinwerk-verlag.de/python/28_001.html] oder die Python-Dokumentation [https://docs.python.org/3/library/re.html]. Auch [[Python unter Linux: Reguläre Ausdrücke]] liefert ein umfangreiches und brauchbares Python-2-Kapitel zu den regulären Ausdrücken. Die dort gelisteten Beispiele müssten ggf. vor Verwendung auf Python-3 umgeschrieben werden. &lt;small&gt;Wie macht  man das? Dazu siehe z.B. [https://openbook.rheinwerk-verlag.de/python/43_001.html], [https://portingguide.readthedocs.io/en/latest/] oder [https://www.digitalocean.com/community/tutorials/how-to-port-python-2-code-to-python-3]&lt;/small&gt;

&lt;small&gt;Es gibt auch ein externes Modul ''regex'', das bei Bedarf extra installiert werden muss ([https://pypi.org/project/regex/]). Es bietet zusätzliche Funktionalität und gründlicheren Unicode-Support. Dies sei hier aber nur der Vollständigkeit halber erwähnt.&lt;/small&gt;

== Verzweigungen ==
=== if ===
Die IF-Verzweigung sei aus anderen Programmiersprachen bereits bekannt. In {{W|Pseudocode}} lässt sie sich folgendermaßen darstellen:

 WENN bedingung TRUE
   führe block1 aus
 SONST
   führe block2 aus
 ENDE 

Als {{W|Aktivitätsdiagramm|UML-Aktivitätsdiagramm}} sieht das in etwa so aus:

[[File:If-Then-Else-diagram.svg|200px]]

Und als {{W|Nassi-Shneiderman-Diagramm|Nassi-Shneiderman-Struktogramm}} so:

[[File:Zweiseitige Auswahl.png|250px]]

In Python gibt es keinen expliziten ENDE-Kennzeichner. Stattdessen wird der Code durch Einrückungen strukturiert. Alles mit der gleichen Einrückungstiefe gehört zum selben Block. Dies zeichnet Python vor anderen Programmiersprachen aus.

Die test1.py-Datei laute also wie folgt:

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
   print(&quot;x ist groesser oder gleich 4&quot;)  

Ausgabe:

 Der else-Zweig wird ausgefuehrt
 x ist groesser oder gleich 4

Man achte auch auf die Doppelpunkte in der if- und else-Zeile. Darauf vergisst man gerne, wenn man von anderen Programmiersprachen kommt.

Folgendes wäre in Python ein Fehler (genauer gesagt ein IndentationError).

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
     print(&quot;x ist groesser oder gleich 4&quot;)  

Auch Nachstehendes würde nicht zum gewünschten Ergebnis führen (löst aber keine Fehlermeldung aus). Der letzte print-Befehl ist schon außerhalb der IF-ELSE-Verzweigung.

 x = 3
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
 print(&quot;x ist groesser oder gleich 4&quot;)

Ausgabe:

 x ist kleiner als 4
 x ist groesser oder gleich 4

Python kennt eine Reihe von Vergleichs- und Verknüpfungsoperatoren:

    &lt;, &lt;= ... kleiner (gleich)
    &gt;, &gt;= ... größer (gleich)
    == ... gleich
    != ... ungleich
    is ... identisch
    is not ... nicht identisch
    and ... AND
    or ... OR
    not ... NOT

Beispielsweise:

 a = 5
 b = 9
 
 if a&lt;=10 and b!=7:
   print(&quot;OK&quot;)
 else
   print(&quot;Nicht OK&quot;)

Ausgabe:

 OK

Der else-Block kann übrigens auch ersatzlos entfallen. Als Pseudocode sieht das so aus

 WENN bedingung TRUE
   führe block aus
 ENDE

Mehrfache Verzweigungen werden durch das elif-Konstrukt erstellt. In Pseudocode:

 WENN bedingung1 TRUE
   führe block1 aus
 SONST WENN bedingung2 TRUE
   führe block2 aus
 SONST WENN bedingung3 TRUE
   führe block3 aus
 SONST
   führe block4 aus
 ENDE

Ein Python-Beispiel:
 a = 14
 
 if a&lt;=10:   
   print(&quot;&lt;=10&quot;)
 elif a&gt;11 and a&lt;15:
   print(&quot;11 bis 15&quot;)
 elif a&gt;16 and a&lt;20:
   print(&quot;16 bis 20&quot;)
 else:
   print(&quot;&gt;=20&quot;)

Ausgabe:

 11 bis 15

In Python gibt es auch die Schlüsselwörter &lt;code&gt;True&lt;/code&gt; (für wahr) und &lt;code&gt;False&lt;/code&gt; (für falsch). Man beachte, dass sie mit Großbuchstaben beginnen. Andere Schreibweisen wären ein Fehler. Sie gehören zum Datentyp &lt;code&gt;bool&lt;/code&gt;. Ihnen sind auch die Zahlen &lt;code&gt;1&lt;/code&gt; und &lt;code&gt;0&lt;/code&gt; zugewiesen.

Man beachte, dass {{W|Rundungsfehler}} auftreten können. D.h. man sollte  bei der Verwendung von {{W|Gleitkommazahl|Gleitpunktzahlen}} niemals auf absolute Genauigkeit prüfen, sondern eine Toleranz (einen &lt;math&gt;\varepsilon&lt;/math&gt;-Wert) vorgeben.
 
Ein klassisches Beispiel, das ein falsches Ergebnis liefert, ist:

 i = 0.1 + 0.2
 
 print(i)
 
 if i == 0.3:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 NOK

Und das, obwohl man schon in der Volksschule lernt, dass 0.1 + 0.2 gleich 0.3 ist.

Korrekt muss das obige Beispiel z.B. so umgeschrieben werden:

 ist = 0.1 + 0.2
 soll = 0.3
 epsilon = 0.000001
 
 print(ist)
 
 if abs(ist-soll) &lt; epsilon:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 OK

Alternativ kann auch die &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion verwendet werden. Das sei aber hier nur erwähnt und nicht konkret ausgeführt.

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet zum Thema &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion.

=== match ===
Ab Python 3.10 gibt es auch die match-Anweisung. Dies ist das Python-Pendant für die switch-Anweisung in anderen Programmiersprachen, geht aber bei näherer Betrachtung weit darüber hinaus. Hier nur ein einfaches Beispiel:

 x = &quot;Hello&quot;
 
 match x:
     case &quot;Servus&quot; | &quot;Ciao&quot;:         # or
         print(&quot;Servus an alle&quot;)
     case &quot;Grüetzi&quot;:
         print(&quot;Grüetzi Schwyzer&quot;)  
     case _:                         # other, default, sonstiges ...
         print(&quot;Hallo Welt&quot;)

Ausgabe: 
 Hallo Welt

Als Struktogramm sieht das in etwa so aus:

[[File:Mehrseitige Auswahl.png|250px]]

Für nähere Details siehe z.B. [https://www.geeksforgeeks.org/python-match-case-statement/], [https://learnpython.com/blog/python-match-case-statement/], [https://docs.python.org/3/tutorial/controlflow.html#match-statements] und das Python Enhancement Proposal (PEP) 636 – Structural Pattern Matching: Tutorial [https://peps.python.org/pep-0636] und dort insbesondere den Anhang A - Quick Intro.

&lt;small&gt;&lt;code&gt;match, case, _&lt;/code&gt; etc. sind sogenannte ''soft keywords''. Im Gegensatz zu den normalen Schlüsselwörtern dürfen ihnen auch Werte zugewiesen werden. Eine Liste der weichen Schlüsselwörter lässt sich durch &lt;code&gt;keyword.softkwlist&lt;/code&gt; erstellen (die Anweisung gibt es seit Python 3.9). Siehe dazu auch [https://stackoverflow.com/questions/65800344/what-are-soft-keywords] und [https://docs.python.org/3/library/keyword.html#keyword.softkwlist].&lt;/small&gt;

== Schleifen ==
Kopfgesteuerte Schleife, Endlosschleife und fußgesteuerte Schleife:

[[File:Programmingloops.svg|450px]]

=== while ===
Die WHILE-Schleife ist kopfgesteuert. Sie funktioniert wie aus anderen Programmiersprachen bekannt. 

In Pseudocode:
 SOLANGE bedingung TRUE
   führe block aus
 ENDE

In Python:
 x = 0
 
 while x &lt;= 10:
   print(x)
   x += 1

Ausgabe:
 0
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10

Eine Endlosschleife ergibt sich z.B. so:
 i = 5
 
 while True:
     print(i)
     i-=1

Beendet werden kann sie mit der Tastenkombination STRG-C.

Eine fußgesteuerte Schleife kann so simuliert werden:
 i = 5
 
 while True:
     print(i)
     i-=1
 
     if i&lt;=0:
         print(&quot;Fire&quot;)
         break

Ausgabe:
 5
 4
 3
 2
 1
 Fire

Der &lt;code&gt;break&lt;/code&gt;-Befehl wird etwas später noch einmal kurz thematisiert.

=== for ===
Struktogramm einer for-Schleife:

[[File:Zählschleife.png|200px]]

In Python bspw. so:

 for x in range(6):
   print(x*2)

Ausgabe:
 0
 2
 4
 6
 8
 10

Die Schleife läuft von 0 bis 5. Ausgegeben wird jeweils der Wert x*2. Aquivalent kann diese Schleife auch so geschrieben werden:
 for x in range(0, 11, 2):
   print(x)

Die Ausgabe ist wie oben. Der Startwert sei 0, der Endwert ist 11-1 und die Schrittweite ist 2.

Ein anderes Beispiel sei
 for x in &quot;text&quot;:
   print(x)

Ausgabe:
 t
 e
 x
 t

== Schleifen abbrechen ==
=== break ===
&lt;code&gt;break&lt;/code&gt; bricht die Schleife ab und setzt mit dem nächsten Befehl außerhalb der Schleife fort.

 for var in range(100):
   print(var) 
   if var == 5:
     break

Ausgabe:
 0
 1
 2
 3
 4
 5

=== continue ===
&lt;code&gt;continue&lt;/code&gt; bricht den aktuellen Schleifendurchlauf ab und setzt mit dem nächsten Schleifendurchlauf fort.

 for var in range (11):
   if var == 5:
     continue
   print(var)

Ausgabe:
 0
 1
 2 
 3
 4
 6
 7
 8
 9
 10

== try - except ==
 try:
     z1 = 12 / 0
     print(z1)
 except ZeroDivisionError:
     print(&quot;Das Ergebnis ist unendlich&quot;)
 except:
     print(&quot;Kann nicht berechnet werden!&quot;)
     print(&quot;Bitte die Formel korrigieren!&quot;)
 
 print(&quot;Setze Programm fort!&quot;)

Ausgabe:
 Das Ergebnis ist unendlich
 Setze Programm fort!

Es wird versucht, eine Zahl durch Null zu dividieren. Das ist nicht möglich, es wird eine Ausnahme ausgelöst. Das Programm springt daher in den except-ZeroDivisionError-Block und führt die dort gelisteten Anweisungen aus (in unserem Fall eine print-Anweisung). Danach wird das Programm fortgesetzt. Würden wir dieses Programm ohne try-except ausführen, so ergibt sich aus

 z1 = 12 / 0
 print(z1)

folgende Fehlermeldung und ein unmittelbarer Programmabbruch

 Traceback (most recent call last):
   File &quot;C:\tmp\test1.py&quot;, line 1, in &lt;module&gt;
     z1 = 12 / 0
 ZeroDivisionError: division by zero

Mit dem try-except-Mechanismus können also Ausnahmen oder Fehler aufgefangen und behandelt werden. In unserem Beispiel ist das eher trivial, aber bei größeren Programmen kann das durchaus Sinn machen.

Neu in Python 3.14 ist, dass mehrere Ausnahmen auch ohne Klammern angegeben werden können, z.B.:

bis inkl. Python 3.13 nur:
 except (ZeroDivisionError, ValueError):

ab Python 3.14 auch:
 except ZeroDivisionError, ValueError:

== pass ==
Ein leerer Block muss in Python mittels dem Schlüsselwort &lt;code&gt;pass&lt;/code&gt; dargestellt werden. Z.B.

 x = 2
 
 if x == 1:
     print(&quot;Wert ist &quot;, x)
 else:
     pass

Würde man das &lt;code&gt;pass&lt;/code&gt; im else-Block weglassen, so würde man eine Fehlermeldung erhalten:

 IndentationError: expected an indented block after 'else' statement on line 5

= Funktionen =
== Aufrufen von Funktionen ==
Funktionen sind uns im Rahmen dieses Kurses schon zuhauf begegnet. Sei es die print()-, die math.sin()- oder die hex()-Funktion. All diese Funktionen werden von Python zur Verfügung gestellt, ohne dass man sie explizit programmieren müsste. Aufgerufen werden diese Funktionen, indem man ihren Namen eintippt, gefolgt von runden Klammern. In diesen Klammern können noch Argumente übergeben werden. Auch Rückgabewerte sind möglich.

== Funktionen selber schreiben ==
Funktionen werden mit dem def-Schlüsselwort (man definiert die Funktion) eingeleitet, danach folgt der Funktionsname, danach wiederum runde Klammern, in denen formale Argumente stehen können. Abgeschlossen wird die def-Zeile mit einem Doppelpunkt. Danach folgt der Funktionskörper. Dieser Funktionskörper muss wiederum eingerückt werden (wie von den Verzweigungen und Schleifen bekannt). Aufgerufen wird diese Funktion, indem man ihren Funktionsnamen eingibt, gefolgt von runden Klammern (ggf. mit den aktuellen Parametern). Z.B.

 # Funktion definieren
 def halloWelt(i):
     # i ... beliebige Ganzzahl
     print(&quot;Hallo &quot; * i, end=&quot;&quot;)
     print(&quot;Welt!&quot;)
    
 # Funktion aufrufen
 halloWelt(3)

Ausgabe:
 Hallo Hallo Hallo Welt!

Unterschied zwischen formalen und aktuellen Parametern:

[[Datei:PythonIng_func1.jpg]]

&lt;small&gt;Aktuelle Parameter werden auch Argumente genannt.&lt;/small&gt;

Rückgabe von Funktionswerten:
 # Funktion definieren
 def mathFunc(a, b):
     r1 = a + b
     r2 = a * b
     return r1, r2
    
 # Funktion aufrufen
 c, d = mathFunc(3, 5)
 
 # Ausgabe der zurückgegebenen Werte
 print(c)
 print(d)

Ausgabe:
 8
 15

Es werden r1 und r2 zurückgegeben und den Variablen c und d zugewiesen. (r1, r2) und (c, d) sind Tupel. Was Tupel konkret sind, siehe etwas später in diesem Kapitel. 3 und 5 sind die aktuellen Parameter (die Argumente). a und b sind die formalen Parameter. Die Zuweisung der aktuellen zu den formalen Parametern erfolgt in der gegebenen Reihenfolge, also die Zahl 3 wird an a übergeben und die Zahl 5 an b.

Vorgabeparameter, z.B.:
 def mathFunc(a=10, b=20):
     r1 = a + b
     r2 = a * b
     return r1, r2
 
 c, d = mathFunc(3, 5)
 print(c)
 print(d) 
 
 e, f = mathFunc(5)
 print(e)
 print(f)
 
 g, h = mathFunc(b=6)
 print(g)
 print(h)

Ausgabe:
 8
 15
 25
 100
 16
 60

Erklärung:
* Erster &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es werden, wie weiter oben, die Argumente 3 und 5 an die formalen Parameter a und b übergeben. Die Rückgabewerte r1 und r2 werden an c und d übergeben. Somit ist c=8 und d=15.
* Zweiter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur das Argment 5 an a übergeben. b behält den Vorgabewert 20. D.h. e= 25 und f=100.
* Dritter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur die Zahl 6 an b übergeben, a behält seinen Vorgabewert 10. Somit ergibt sich g=16 und h=60.

Beispiel (Schlüsselwortargumente vs. Positionsargumente):
 def mathFunc(a, b):
     r1 = a - b
     r2 = a / b
     return r1, r2
 
 c, d = mathFunc(b=3, a=5)  # Schlüsselwortargumente
 e, f = mathFunc(3, 5)      # Positionsargumente

 print(c)
 print(d)
 print(e)
 print(f)

Ausgabe:
 2
 1.6666666666666667
 -2
 0.6

Durch die Verwendung von Schlüsselwortargumenten können die Argumente in beliebiger Reihenfolge angegeben werden. Bei den Positionsargumenten ist die Reihenfolge vorgegeben. Daraus resultiert auch der Unterschied bei den obigen Ausgaben. Werden beide Arten in einem Aufruf gemischt, so müssen die Positionsargumente zuerst angegeben werden. Den Unterschied zwischen beiden Argumentarten zu kennen ist wichtig, nicht nur bei selbst erstellten Funktionen. Auch beim Aufruf von Python-Funktionen verfolgt einen die Mischung von Schlüsselwort- und Positionsargumenten auf Schritt und Tritt, z.B. beim etwas später folgenden Abschnitt über &quot;Grafiken zeichnen&quot;:

 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)

Bei dieser &lt;code&gt;plot&lt;/code&gt;-Funktion aus dem Modul &lt;code&gt;matplotlib.pyplot&lt;/code&gt; sind &lt;code&gt;x&lt;/code&gt; und &lt;code&gt;y1&lt;/code&gt; Positionsargumente. &lt;code&gt;label, lw&lt;/code&gt; und &lt;code&gt;ls&lt;/code&gt; sind die Namen der Schlüsselwortargumente. Die Schlüsselwortargumente könnten auch in anderer Reihenfolge angeschrieben werden, nicht jedoch die Positionsargumente!
Siehe zu &lt;code&gt;matplotlib.pyplot.plot&lt;/code&gt; auch die Seite [https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html].

== Lambda-Funktionen ==
 print((lambda a, b: a*b) (3, 5))

Ausgabe:
 15

Eingeleitet wird eine Lambda-Funktion (auch Lambda-Form, Lambda-Operator oder anonyme Funktion genannt) mit dem Schlüsselwort &lt;code&gt;lambda&lt;/code&gt;. Es folgen die formalen Argumente, danach ein Doppelpunkt, die Berechnungsvorschrift und ggf. abschliessend in Klammern die aktuellen Parameter.

Man kann einer Lambda-Funktion auch einen Funktionsnamen geben und die Funktion über diesen Namen aufrufen, z.B.

 prod = lambda a, b: a*b
 print(prod(3, 5))

Als Ausgabe wird wieder die Zahl 15 geliefert.

== Rekursive Funktionen ==
Funktionen können wiederum andere Funktionen aufrufen. Von einem {{W|Rekursion|rekursiven Funktionsaufruf}} spricht man, wenn die aufgerufene Funktion gleich der aufrufenden ist. 

 def printFunc(i):
     if (i &gt;= 5):
         return 
     else:
         print(&quot;Hallo Welt&quot;)
         printFunc(i+1)
         
 printFunc(1)

Ausgabe:
 Hallo Welt
 Hallo Welt
 Hallo Welt
 Hallo Welt

Typische Beispiele für die Abarbeitung als rekursive Funktionen sind die {{W|Fibonacci-Folge}} und die {{W|Fakultät_(Mathematik)|Fakultät}}. Jedoch ist der iterative Ansatz (mit konventionellen Schleifen) meist schneller und speicherplatzschonender.

== Funktionsannotationen ==
Python ist sehr flexibel, was Typen angeht. Im Vorhergehenden haben wir generell keine Typangaben gemacht. Will man Typen angeben, so bietet Python das Konzept der Funktionsannotation.

 def calcFunc(a: int, b: int) -&gt; int:
     return a+b
 
 r1 = calcFunc(8, 9)
 r2 = calcFunc(8.0, 9.0)
 r3 = calcFunc(&quot;Hallo&quot;, &quot;Welt&quot;)
 
 print(r1)
 print(r2)
 print(r3)

Ausgabe:
 17
 17.0
 HalloWelt

Jetzt sieht man auf den ersten Blick, welche Typen der Programmierer im Sinn hatte, als er die Funktion erstellte. Das Problem dabei ist nur, dass es Python ziemlich egal ist, welche Typen man im Endeffekt eingibt. Im obigen Beispiel können statt Integer-Typen u.a. auch Float- oder String-Typen eingegeben werden.

&lt;small&gt;
Siehe zum Thema &quot;Type Checking&quot; aber auch den später folgenden Abschnitt [[Ing_Mathematik:_Python#Type_Checker]].
&lt;/small&gt;

== Variadische Funktionen ==
Python-Code:

 def test1(a, *b):
     print(a);
      
     for c in b:
         print(c);
        
 test1(&quot;Hallo&quot;, &quot;Welt&quot;, &quot;Schweizer&quot;, &quot;und alle anderen&quot;)

Ausgabe:

 Hallo
 Welt
 Schweizer
 und alle anderen

Mit dem Stern (auch als Splat-Operator bezeichnet) in der formalen Parameterliste bei der Funktion &lt;code&gt;test1&lt;/code&gt; wird angezeigt, dass eine beliebige Anzahl von Argumenten übergeben wird. &lt;small&gt; Dies entspricht in etwa dem, was in anderen Programmiersprachen (PHP etc.) mittels Ellipse (&lt;code&gt;...&lt;/code&gt;) angezeigt wird.&lt;/small&gt;

= Tupel, Listen und andere =
[[Datei:Python 3. The standard type hierarchy.png|mini|hochkant=1.7|Datentypen und Strukturen]]

== Tupel und Listen ==
Tupel, Listen und einige andere sind Datenstrukturen oder Sequenzen.

Listen (z.B. eine Einkaufsliste) sind veränderbar (mutable). Ein Tupel kann dagegen nicht verändert werden (immutable). Listen werden beim Anlegen in eckige Klammern eingeschlossen, Tupel in runde Klammern. Beim Tupel können die Klammern auch weggelassen werden. Ein Tupel mit nur einem Element muss mit einem Beistrich abgeschlossen werden. Der Grund ist, dass Python sonst nicht entscheiden kann, ob ein Tupel angelegt werden soll, oder nur ein geklammerter Wert. 

Als Gedächtnisstütze kann man sich den Unterschied zwischen Tupel und Liste ev. so leichter merken:
: T'''u'''pel ... r'''u'''nde Klammern, '''u'''nveränderlich
: L'''i'''ste ... eck'''i'''ge Klammern, veränderl'''i'''ch.

Nachfolgend werden einige Operationen mit Listen und Tupel dargestellt.

 # Liste und Tupel
 liste = [1, 2, &quot;Hallo&quot;]
 tupel = (1, 2, &quot;Hallo&quot;) 
 
 # Ausgabe von liste und tupel
 print(liste)
 print(tupel)
 
 # Ausgabe von Einzelelementen
 print(liste[1])
 print(tupel[2])
 
 # Element an Liste anhängen und einfügen 
 liste.append(55)
 liste.insert(4, &quot;Welt&quot;)
 print(liste)
 
 # Element aus Liste entfernen
 liste.remove(1)
 print(liste)
 
 # einige weitere Beispiele
 liste2 = [1,]
 tupel2 = 1, 2
 tupel3 = (1,) 
 print(liste2)
 print(tupel2)
 print(tupel3)

Ausgabe:
 [1, 2, 'Hallo']
 (1, 2, 'Hallo')
 2
 Hallo
 [1, 2, 'Hallo', 55, 'Welt']
 [2, 'Hallo', 55, 'Welt']
 [1]
 (1, 2)
 (1,)

Beispiel (eine Liste von Wörtern zu einem einzigen zusammenhängenden Text verbinden):

 woerter = [&quot;Hallo&quot;, &quot;Welt&quot;]
 satz = &quot; &quot;.join(woerter)
 print(satz)

Ausgabe:

 Hallo Welt

== Dictionaries und Mengen ==
Zu den Datenstrukturen gehören weiters auch Mengen und Dictionaries. Mengen sind von der Mathematik bekannt, sie sind ungeordnet und es kommen keine mehrfachen Elemente vor. Dictionaries sind durch Schlüssel :Wert-Paare gekennzeichnet. Mengen werden beim Anlegen wie Dictionaries in geschweifte Klammern eingeschlossen.

 dict = {&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot; }
 menge = {1, 1, 3, 4, 4, 4, &quot;Hallo&quot;}
 
 print(dict)
 print(menge)
 print(dict[&quot;vorname&quot;])

Ausgabe:
 {'vorname': 'Hugo', 'nachname': 'Meister'}
 {1, 3, 4, 'Hallo'}
 Hugo

Geschweifte Klammern ohne Inhalt stellen Dictionaries dar und keine Mengen:

 di = {}
 print(type(di))

Ausgabe:
 &lt;class 'dict'&gt;

Leere Mengen lassen sich mit &lt;code&gt;set()&lt;/code&gt; erzeugen:

 menge = set()      # leere Menge
 print(menge)
 menge.add(&quot;Hallo&quot;) # Element hinzufügen
 print(menge)

Ausgabe:
 set()
 {'Hallo'}

Beispiel (einige Mengenoperationen):
 mengeA = {&quot;Hallo&quot;, &quot;Welt&quot;}
 mengeB = {1, 2, &quot;Welt&quot;, 3}
 
 # Vereinigung
 print(mengeA | mengeB)
 print(mengeA.union(mengeB))
 
 # Durchschnitt
 print(mengeA &amp; mengeB)
 print(mengeA.intersection(mengeB))
 
 # Differenz
 print(mengeA - mengeB)
 print(mengeA.difference(mengeB))
 
 # Symmetrische Differenz
 print(mengeA ^ mengeB)
 print(mengeA.symmetric_difference(mengeB))
 
 # Teilmenge
 print(mengeA.issubset(mengeB))
 
 # Mehrere Elemente hinzu
 mengeA.update([&quot;Super&quot;, 67, 125])
 print(mengeA)
 
 # Element löschen
 mengeA.discard(&quot;Hallo&quot;)
 print(mengeA)

Ausgabe:
 {1, 2, 3, 'Welt', 'Hallo'}
 {1, 2, 3, 'Welt', 'Hallo'}
 {'Welt'}
 {'Welt'}
 {'Hallo'}
 {'Hallo'}
 {1, 2, 3, 'Hallo'}
 {1, 2, 3, 'Hallo'}
 False
 {67, 'Super', 'Welt', 'Hallo', 125}
 {67, 'Super', 'Welt', 125}

Es gibt schon seit &quot;ewigen&quot; Zeiten unveränderbare Mengen, die mittels &lt;code&gt;frozenset&lt;/code&gt; eingeleitet werden. Neu ab Python 3.15 ist dagegen das Pendant &lt;code&gt;frozendict&lt;/code&gt;, das unveränderbare Dictionaries darstellt.

 fdict = frozendict({&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot;})
 fset = frozenset({&quot;A&quot;, 1, &quot;A&quot;})
 
 print(fdict)
 print(fdict[&quot;vorname&quot;])
 print (fset) 
 
 try:
     fdict[&quot;vorname&quot;] = &quot;Max&quot;
     print(fdict[&quot;vorname&quot;])
 except TypeError as e:
     print(f&quot;Fehler: {e}&quot;)
 
 try:
     fset.add(&quot;B&quot;)
     print(fset)
 except AttributeError as e:
     print(f&quot;Fehler: {e}&quot;)

Ausgabe:
 frozendict({'vorname': 'Hugo', 'nachname': 'Meister'})
 Hugo
 frozenset({1, 'A'})
 Fehler: 'frozendict' object does not support item assignment
 Fehler: 'frozenset' object has no attribute 'add'

== List Comprehensions ==
Aus einer Eingabeliste soll eine Ausgabeliste erzeugt werden. Das kann folgendermaßen geschehen.

Mathematische Schreibweise: &lt;math&gt;lc = \{2x|x\in\ \mathbb{N}, 1\le x &lt; 11\}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11)]
 print(lc)

Ausgabe:
 [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Mathematische Schreibweise: &lt;math&gt;lc = \{2x | x \in \mathbb{N}, 1\le x &lt; 11, x \bmod 2 = 0 \}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11) if x%2 == 0]
 print(lc)

Ausgabe:
 [4, 8, 12, 16, 20]

Siehe auch {{W|List Comprehension}}.

== Set Comprehensions ==
Dies ist sehr ähnlich wie im vorigen Abschnitt beschrieben. Es wird aber keine Liste, sondern eine Menge erzeugt.

 sc = {x*2 for x in range(1,11)}
 print(sc)

Ausgabe:
 {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}

== Listen zusammenführen - zip() ==
 li1 = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]
 li2 = [1, 2, 3, 4]
 li3 = [5.5, 6.6, 7.7, 8.8]
 
 z = zip(li1, li2, li3)
 print(z)
 
 li4 = list(z)
 print(li4)

Ausgabe:
 &lt;zip object at 0x00000283B6C6AC80&gt;
 [('A', 1, 5.5), ('B', 2, 6.6), ('C', 3, 7.7), ('D', 4, 8.8)]

== Generatorausdruck ==
 g = (i*2 for i in range(1,11))
 print(g)
 t = tuple(g)
 print(t)
 print(t[1:3])

Ausgabe:
 &lt;generator object &lt;genexpr&gt; at 0x00000241D2A4A5A0&gt;
 (2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
 (4, 6)

== Slicing ==
slice ... Scheibe, Teil, in Scheiben schneiden

Beispiel: Zugriff auf Elemente eines geordneten sequentiellen Objekttyps (Liste, Tupel oder String):

 str1 = &quot;Hallo&quot;
 # Das erste Element wird mit dem Index 0 angesprochen
 # [start (inkl.) : stop (exkl.) : step (default=1)]
 str2 = str1[0:2]
 # Alternativ auch: str2 = str1[:2] 
 print(str2)
 
 tup1 = (0,1,2,3)
 # Das letzte Element hat auch den Index -1, das vorletzte den Index -2 usw.
 tup2 = tup1[-3:-1]
 print(tup2)
 
 lst1 = [[1,  5,  10, 20],
         [30, 40, 50, 60]]
 lst2 = lst1[1][1]
 print(lst2)
 
Ausgabe:
 Ha
 (1, 2)
 40

Beispiel:

 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2])
 print(x[-3]) 
 print(x)
 print(x[:])
 print(x[2:])
 print(x[:2])
 print(x[::-1])

Ausgabe:

 c
 c
 ('a', 'b', 'c', 'd', 'e')
 ('a', 'b', 'c', 'd', 'e')
 ('c', 'd', 'e')
 ('a', 'b')
 ('e', 'd', 'c', 'b', 'a')

Visualisierung:

    '''a'''     '''b'''     '''c'''     '''d'''     '''e'''
 +-----------------------------+
 |  0  |  1  |//'''2'''//|  3  |  4  |
 +-----------------------------+
 | -5  | -4  |/'''-3'''//| -2  | -1  | 
 +-----------------------------+
 |/////////////////////////////|
 +-----------------------------+
 |/////////////''':'''///////////////|
 +-----------------------------+
 |     |     |///////'''2:'''////////|
 +-----------------------------+
 |////''':2'''/////|     |     |     |
 +-----------------------------+
 |\\\\\&lt;--\\\\\'''::-1'''\\\\&lt;--\\\\\|
 +-----------------------------+

Beispiel:
 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2::2])
 print(x[2::-1])
 print(x[2:0:-1])

Ausgabe:

 ('c', 'e')
 ('c', 'b', 'a')
 ('c', 'b')

Hier sieht man sehr schön, dass beim letzen &lt;code&gt;print&lt;/code&gt;-Befehl die 0, die in diesem Fall den Buchstaben &quot;a&quot; repräsentiert, als letzer Wert nicht mehr dazugehört (wie weiter oben angedeutet ist der End- oder Stoppwert exklusiv). Will man den Buchstaben &quot;a&quot; dazunehmen, so ist die vorletzte Zeile die richtige.

Beispiel: Umdrehen von Strings

 str1 = &quot;Hallo&quot;
 str2 = str1[::-1]
 print(str2)

Ausgabe:
 ollaH

Mit zweidimensionalen Listen/Tupels wird das Ganze schon bedeutend komplexer.

Beispiel: Verkettetes Slicing

 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
     
 print(A[2::][::2])

Ausgabe:

 [['20', '21', '22', '23'], ['40', '41', '42', '43']]

Das erste Slicing erstellt folgenden Slice:

 [[&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
  [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
  [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]

Das zweite Slicing wird dann auf diesen Slice angewendet und ergibt das genannte Endergebnis. Will man Spalten statt Zeilen, so funktioniert dieser direkte Weg nicht. Man verwendet dann List Comprehensions oder die NumPy-Bibliothek. Diese Bibliothek erlaubt [[Ing_Mathematik:_Python#Zugriff_auf_Matrizenelemente|zweidimensionales Slicing]]. Sie wird erst später bei den Grafiken eingeführt. Deshalb wird hier dazu noch kein Beispiel gezeigt.

= Objektorientierte Programmierung =
{{Wikipedia|Objektorientierte Programmierung}}

* {{W|Klasse (Objektorientierung)|Klasse}} ... die Schablone oder der Bauplan, enthält Methoden und Attribute
* {{W|Objekt (Programmierung)|Objekt}} ... eine Klasseninstanz (die konkrete Ausprägung der Klasse)
* {{W|Attribut (Programmierung)|Attribute}} ... die Eigenschaften eines Objekts
* {{W|Methode (Programmierung)|Methoden}} ... die Aktionen (Operationen), die ein Objekt ausführen kann
* {{W|Vererbung (Programmierung)|Vererbung}} ... neue Klassen (Subklassen, Unterklassen, abgeleitete Klassen) aus vorhandenen Klassen (Superklassen, Oberklassen, Basisklassen, Elternklassen) ableiten. Ermöglicht den Aufbau von Klassenhierarchien. Die Subklasse &quot;erbt&quot; Attribute und Methoden von der Superklasse. Python unterstützt (so wie C++, aber im Gegensatz zu Java) Mehrfachvererbung.

== UML ==
* {{W|Unified Modeling Language|UML}} ... '''U'''nified '''M'''odeling '''L'''anguage, eine Modellierungssprache. Die UML enthält zahlreiche Diagrammarten, um Programme zu modellieren. Im Nachfolgenden wird nur das {{W|Klassendiagramm}} verwendet.

[[File:UmlCd Klasse-3.svg|300px]]

* {{W|Sichtbarkeit (Programmierung)|Sichtbarkeit}}:
** + ... public (öffentlich)
** - ... private
** # ... protected 

* {{W|Attribut_(UML)#Attribute_für_Instanzen_und_für_Klassen|Klassenattribute}} (statische Attribute): Werden nur einmal pro Klasse angelegt. Im Klassendiagramm werden sie unterstrichen.

[[File:Attribute-3.png|200px]]

* Vererbung:

&lt;gallery&gt;
InheritancePgmUML.svg | Abgeleitete Klasse erbt von Basisklasse (Einfachvererbung)
Diamond inheritance.svg | D erbt von B und C (Mehrfachvererbung). B und C erben von A (Einfachvererbung)
&lt;/gallery&gt;

Für weitergehende Betrachtungen zur UML wird auf Spezialliteratur verwiesen, z.B.:
* Seidl et al.: UML@Classroom. dpunkt, 2012, ISBN 978-3-89864-776-2
* Rupp et al.: UML 2 glasklar. Hanser, 4. Aufl., 2012, ISBN 978-3-446-43057-0

== Eine einfache Klasse ==

[[Datei:PythonIng_uml1.svg | 200px]]

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
 
 fahr = Fahrzeug(150, 90)
 
 print(fahr.convertGeschw())
 
Ausgabe:
 41.666666666666664

Die Klasse Fahrzeug wird durch das class-Schlüsselwort eingeleitet. raeder ist ein Klassenattribut und public. __init__ wird bei der Objekterzeugung automatisch aufgerufen (ist der sogenannte Konstruktor). Man achte darauf, dass diese Methode immer mit zwei Unterstrichen eingeleitet und abgeschlossen wird. Instanzattributen wird das Wort self vorangestellt. Wir sehen uns z.B. das Attribut self.__geschwind an. Auch hier werden zwei Unterstriche verwendet. Das bedeutet, dass dieses Attribut strikt/stark private ist. Wird nur ein Unterstrich verwendet, so deutet dies auf schwach/weakly private hin. Letzteres wird in Python deutlich häufiger verwendet. Bei den Methoden wird immer self als erster Parameter angegeben. Beim Aufruf der entsprechenden Funktion wird das self aber nicht berücksichtigt.

Besonderheiten bei stark und schwach private:
* '''stark private''':
** zwei führende Unterstriche
** Name Mangling: Name wird zu &lt;code&gt;_Klassenname__variablenname&lt;/code&gt;
** Schutz vor Namenskollisionen bei Vererbung
** am Ende des Namens dürfen keine zwei Unterstriche verwendet werden. Das wären dann Magic Methods oder Dunder-Methods (z.B. __init__). Diese sind public.

* '''schwach private''':
** ein führender Unterstrich
** Name bleibt gleich
** ist nur ein Hinweis an die Programmierer, kein starker Schutz
** &lt;code&gt;from modul import *&lt;/code&gt;: Objekte mit einem führenden Unterstrich werden standardmäßig nicht importiert
** Standard für die Kapselung bei Python. Schätzung: Weit mehr als 80% der nicht-öffentlichen Attribute/Methoden werden als schwach private deklariert. Weniger als 5-10% als stark private (Quelle: Google KI)

== Klassen importieren ==
Häufig ist es sinnvoll und übersichtlicher Klassen in eigenen Dateien zu speichern. Das sind dann eigene Module. Abgespeichert werden Sie mit der Endung py, wie bisher auch praktiziert. Aufgerufen werden Sie mit der import-Anweisung. Dann ist aber nur der Dateiname ohne Endung py zu verwenden. Klarer wird das mit einem Beispiel.

Datei c:\tmp\fahrzeug.py

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6

Datei c:\tmp\test1.py

 import fahrzeug
 fahr = fahrzeug.Fahrzeug(150, 90)
 print(fahr.convertGeschw())

Ausgabe:
 41.666666666666664

Die üblichen import-Anweisungen lauten wie folgt:
{| {{prettytable}}
! import-Befehl
! Instanz
|-
| import xyz      || xyz.Klasse
|-
| import xyz as x || x.Klasse
|-
| from xyz import Klasse || Klasse
|-
| from xyz import * || Klasse 
|}

Der Vorteil der ersten beiden import-Anweisungen ist, dass es kaum zu Namenskollisionen kommen kann. Dafür hat man bei den letzten beiden Varianten weniger Tipparbeit.

== Vererbung ==
=== Einfachvererbung ===

[[Datei:PythonIng_uml2.svg | 200px]]

Datei fahrzeug.py:
 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
        
     def setLeistung(self, leistung):
         self.__leistung = leistung
        
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
        
 class Luftfahrzeug(Fahrzeug):
     def __init__(self, geschwindigkeit, leistung, fluegel):
         super().__init__(geschwindigkeit, leistung)
         self.__flueg = fluegel
     
     def getFlueg(self):
         return self.__flueg

Datei test1.py:
 import fahrzeug
 fahr = fahrzeug.Luftfahrzeug(150, 90, 4)
 print(fahr.getFlueg())

Ausgabe:
 4

=== Mehrfachvererbung ===
Mit Python ist auch Mehrfachvererbung möglich, z.B.:

 class A:
     def _printA(self):
         print(&quot;Klasse A&quot;)
 
 class B:
     def _printB(self):
         print(&quot;Klasse B&quot;)
 
 class C(A,B):
     def __init__(self):
         self._printA()
         self._printB()
 
 c = C()

Ausgabe:

 Klasse A
 Klasse B

Die Klasse C erbt von A und B. In UML sieht das in etwa so aus:

 +-----------------------------+   +-------------------------+
 |            A                |   |          B              |
 +-----------------------------+   +-------------------------+
 |                             |   |                         |
 +-----------------------------+   +-------------------------+
 | # printA()                  |   | # printB()              |
 +-----------------------------+   +-------------------------+
                           .              .
                          / \            / \
                          ---            ---
                           |              |
                           |              |
                        +---------------------+
                        |          C          |
                        +---------------------+
                        |                     |
                        +---------------------+
                        |                     |
                        +---------------------+

&lt;code&gt;printA()&lt;/code&gt; und &lt;code&gt;printB()&lt;/code&gt; sind schwach private (in UML als &lt;code&gt;protected&lt;/code&gt; mit einem # dargestellt). Es ist aber zu beachten, dass schwach private nur Konvention ist. Praktisch könnte man auch von außerhalb auf diese Methoden zugreifen. Das soll man aber nicht tun, und das wird in Python durch einen Unterstrich angedeutet.

== Statische Attribute, statische Methoden und Klassenmethoden ==
Beispiel:

 class Math:
     pi = 3.14159265
     cnt = 0
     
     @staticmethod
     def expo():
         return 2.71828183
    
     @classmethod    
     def counterPlus(cls):
         cls.cnt += 1
        
 print(Math.pi)
 print(Math.expo())
 
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)

Ausgabe:

 3.14159265
 2.71828183
 1
 2
 3

Statische Attribute und Methoden, bzw. Klassenmethoden, sind direkt einer Klasse zugeordnet und nicht einem Objekt. Der Unterschied zwischen statischen Methoden und Klassenmethoden ist, dass statische Methoden nicht auf Klassenattribute (bzw. statische Attribute) zugreifen können, Klassenmethoden aber schon. &lt;code&gt;pi&lt;/code&gt; und &lt;code&gt;cnt&lt;/code&gt; sind statische Attribute. &lt;code&gt;expo()&lt;/code&gt; ist eine statische Methode. &lt;code&gt;counterPlus(cls)&lt;/code&gt; ist eine Klassenmethode. Die Bezeichnung des Parameters als &lt;code&gt;cls&lt;/code&gt; ist reine Konvention, man sollte sich aber daran halten.

= Grafiken zeichnen =
Für das Zeichnen von Grafiken wird hier das Modul &lt;code&gt;matplotlib&lt;/code&gt; verwendet. &lt;code&gt;matplotlib&lt;/code&gt; ist ein externes Modul und muss vor der ersten Verwendung installiert werden. Das geht so:

# Starten Sie ein Terminal (bei Windows die Eingabeaufforderung).
# Führen Sie darin folgenden Befehl aus &lt;code&gt;c:\devel\Python\Scripts\pip.exe install matplotlib&lt;/code&gt;

pip ist übrigens der Paketmanager von Python ({{W|Pip_(Python)}}). 

Optimalerweise installieren wir auch gleich das Modul &lt;code&gt;numpy&lt;/code&gt; (Numerical Python). Wir werden es im Folgenden oft benötigen (nicht nur bei den Grafiken). Das funktioniert vom Prinzip her genauso, wie für &lt;code&gt;matplotlib&lt;/code&gt; gezeigt.

&lt;small&gt;Verwenden Sie Spyder, so sind diese Schritte nicht nötig. Spyder inkludiert diese Pakete standardmäßig. Unter openSUSE Tumbleweed lassen sich diese Pakete mittels YaST oder zypper installieren.&lt;/small&gt;

== 2D ==
=== Graph einer Funktion ===
Es soll die cosh-Funktion im Intervall &lt;math&gt;x\in[-3,3]&lt;/math&gt; gezeichnet werden. Der Programmcode lautet in der einfachsten Form:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x)
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:PythonIng_cosh1.jpg]]

Der Code ist quasi selbsterklärend. Das Untermodul pyplot des matplotlib-Moduls und das numpy-Modul werden importiert. x läuft von -3 bis +3. y wird für jeden x-Wert per Formel ausgerechnet. &quot;plt.plot()&quot; ist der Zeichenbefehl. &quot;plt.show&quot; ist notwendig, um das Fenster mit der Grafik anzuzeigen.
Die Schrittweite 0.1 wurde so gewählt, um einen ausreichend glatten Verlauf des Graphen zu gewährleisten. Das ist immer ein Kompromiss zwischen Berechnungszeit und Ansehnlichkeit. Testen Sie einfach ein paar verschiedene Werte, um ein Gefühl dafür zu zu bekommen. &quot;plt.grid()&quot; zeichnet ein Gitter in die Grafik (kann auch weggelassen werden).
Die Bezeichnungen plt und np könnten auch anders gewählt werden. Es ist aber Konvention, diese so wie hier gezeigt zu wählen. Die &quot;arange&quot;-Funktion aus der NumPy-Bibliothek wird später ein bisschen genauer behandelt (siehe [[Ing_Mathematik:_Python#Zahlenfolgen|Zahlenfolgen]]).  

&lt;small&gt;Mit der im obigen Bild gezeigten Menüleiste kann die dargestellte Grafik nachträglich noch geändert werden (Zoom, Pan, Achsenparameter, Kurvenparameter etc.). Natürlich kann man das alles auch direkt programmieren. Wie das funktioniert wird ansatzweise etwas später gezeigt.&lt;/small&gt;

Ein etwas komplexeres Beispiel ist Folgendes:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x) + 2**x
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:
[[Datei:PythonIng_cosh4.png]]

Man beachte, dass im Gegensatz zu Octave und Julia der ominöse Punkt (.) bei 2**x mit Python nicht benötigt wird. Das macht das Programmiererleben etwas einfacher.

Die Farbe des Graphen kann man über den &lt;code&gt;color&lt;/code&gt;-Schalter einstellen, z.B. auf rot setzen:
 plt.plot(x, y, color=&quot;red&quot;)

Das ist nur eine Möglichkeit, es gibt auch andere, z.B. mittels
* hexadezimaler Zahl, z.B. &lt;code&gt;color=&quot;#ff0000&quot;&lt;/code&gt;
* Kurzform, z.B. &lt;code&gt;&quot;r&quot;&lt;/code&gt;

Statt &lt;code&gt;color&lt;/code&gt; kann auch die Kurzform &lt;code&gt;c&lt;/code&gt; verwendet werden.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie diese &quot;Farbspielereien&quot; am Computer aus.

=== Graphen mehrerer Funktionen und weiteres ===
==== Mehrere Funktionen in einen Plot zeichnen ==== 
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh2.png]]

Um die Linienstile etwas individueller zu gestalten, ist folgender Programmcode gedacht: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;, lw=3, ls=&quot;--&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh3.png]]

Einige weitere Bespiele zu &lt;code&gt;ls&lt;/code&gt;&lt;/code&gt;:
* - ... durchgezogene Linie
* -. ... Strichpunkt-Linie
* dashed ... gestrichelte Linie 

==== Marker ====
Desweiteren kann man Marker verwenden.

Beispiel:

 import matplotlib.pyplot as plt
 
 plt.plot(10, 10, &quot;ob&quot;, markersize=30)
 plt.plot(20,20, &quot;.r&quot;)
 plt.plot(30,30, &quot;Dg&quot;, ms=15)
 plt.plot(40, 40, &quot;ok&quot;, ms=20, mec=&quot;#FF5733&quot;, mew=3)
 plt.plot(50, 50, &quot;vk&quot;, ms=20, mec=&quot;yellow&quot;, mew=3)
 plt.grid()
 plt.show()


Das erste Zeichen im String nach den Koordinaten im plot-Befehl symbolisiert die Form (z.B. o für einen Kreis). Das zweite Zeichen steht für die Farbe (z.B. b für blue). &lt;code&gt;markersize&lt;/code&gt; oder &lt;code&gt;ms&lt;/code&gt; setzt die Größe des Markers.

Ausgabe:

[[Bild:PythonIng_formatpara1.svg|200px]]

Einige weitere Marker:
* * ... Stern
* + ... Plus
* h oder H ... Sechseck

Man kann mit den Parametern 
* &lt;code&gt;markeredgecolor&lt;/code&gt; oder kurz &lt;code&gt;mec&lt;/code&gt; die Farbe des Markerrandes
* &lt;code&gt;markeredgewidth&lt;/code&gt; oder kurz &lt;code&gt;mew&lt;/code&gt; die Dicke des Randes
* &lt;code&gt;markerfacecolor&lt;/code&gt; oder kurz &lt;code&gt;mfc&lt;/code&gt; die Innenfarbe des Markers
bestimmen.

=== Funktion in Parameterdarstellung ===
Es soll die archimedische Spirale &lt;math&gt;x = t \cos(t), y = t  \sin(t)&lt;/math&gt; im Intervall &lt;math&gt;[0, 6\pi[&lt;/math&gt; gezeichnet werden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
  
 plt.show()

[[Datei:PythonIng_spirale1.png]]

Diese Darstellung erscheint verzerrt. Will man gleiche Achsenskalierungen, so kann man den plt.axis()-Befehl verwenden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
 plt.axis(&quot;equal&quot;)
 
 plt.show()
 
[[Datei:PythonIng_spirale2.png]]

=== Funktion in Polardarstellung ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 fig = plt.figure()
 ax = fig.add_subplot(projection=&quot;polar&quot;)
 r = np.arange(0, 1, 0.01)
 theta = r**3
 line = ax.plot(theta, r)
 
 plt.show()

[[Datei:PythonIng_polar1.png]]

=== Logarithmische Achsenskalierung ===
==== Semilog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.semilogy()
 plt.show()

Ausgabe:

[[Datei:PythonIng_semilog1.png]]

==== LogLog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.loglog()
 plt.show()

[[Datei:PythonIng_loglog1.png]]

=== Gefüllte Fläche ===
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.arange(0, 3, 0.1)
 
 y1 = 3*x - 1
 y2 = x**2
 
 plt.plot(x, y1, x, y2, color='black')
 plt.fill_between(x, y1, y2, where=y1&gt;=y2)
 
 plt.show()

[[Datei:PythonIng_gefuellt.png]]

=== Linien, Pfeile, Rechtecke, Kreise und Texte ===
 import matplotlib as mpl
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 r = mpl.patches.Rectangle((0, 0), 3, 3, angle=30, fill=False)
 c = mpl.patches.Circle((4, 4), 2, fill=False)
 
 ax.add_patch(r)
 ax.add_patch(c)
 ax.plot([-2, 7], [-2, 0], color=&quot;black&quot;)
 ax.arrow(0, 7, 5, 0, length_includes_head=True, head_width=0.5, head_length=1.5,
          color=&quot;black&quot;)
 
 ax.set_aspect(&quot;equal&quot;)
 
 plt.axis([-3, 8, -3, 8])
 plt.show() 

[[Datei:PythonIng_linien_pfeile_etc.png]]

Text kann mit &lt;code&gt;ax.text(x, y, &quot;Text&quot;)&lt;/code&gt; hinzugefügt werden, bspw.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 ax.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

Oder einfacher auch ohne &lt;code&gt;subplots&lt;/code&gt;

 import matplotlib.pyplot as plt
 
 plt.text(0.1, 0.1, &quot;Hallo&quot;)
 plt.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

[[Datei:PythonIng_text1.png]]

Auch Sonderzeichen (griechische Buchstaben etc.) können verwendet werden (siehe dazu auch [https://matplotlib.org/stable/users/explain/text/mathtext.html]).

 import matplotlib.pyplot as plt
 
 plt.text(.3, .5,
          r'$\Omega\ \psi\ \oint\ \nabla\ \dot a\ \frac{a}{b}\ a_b$',
          size=&quot;20&quot;)
 plt.show() 

[[Datei:PythonIng_text20.svg]]

Jetzt wird noch gezeigt, wofür &lt;code&gt;subplots&lt;/code&gt; sinnvoll eingesetzt werden können.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(0.1, 0.1, &quot;Hallo&quot;)
 ax[1].text(0.1, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
            rotation=30.0)
 
 plt.show()

[[Datei:PythonIng_text2.png]]

=== Anmerkungen hinzufügen ===
Anmerkungen (engl. annotations) lassen sich mit matplotlib einfach hinzufügen. Unter Anmerkung wird hier ein Pfeil mit Text verstanden.

Beispiel:

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 ax.plot([1,10], [1,10])
 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
             arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0))
 plt.show()

Ausgabe:

[[Datei: PythonIng_ann1.svg|400px]]

&lt;code&gt;shrink&lt;/code&gt; verkürzt den Pfeil. Sinnvoll sind beim obigen Beispiel Werte irgendwo zwischen 0.0 und 0.3.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie verschiedene Pfeillängen aus. 

Die Schriftgröße verändern können Sie übrigens mit &lt;code&gt;fontsize&lt;/code&gt; oder &lt;code&gt;size&lt;/code&gt;, z.B.

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0), fontsize=25)

Eine andere Schreibweise für Dictionaries, die wir weiter oben schon kennengelernt haben, die wir aber nochmals explizit aufschreiben wollen, ist

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops={&quot;facecolor&quot;:&quot;red&quot;, &quot;shrink&quot;:0.0})

=== Figure, Axes etc.===
[[Bild:PythonIng_figure33.svg|350px]]

* fig (figure) ... das übergeordnete Fenster
* ax (axes) ... &quot;Plot&quot;, das eigentliche Zeichenfenster
* axis ... die Koordinatenachsen
* spine ... Begrenzungslinien des Zeichenfensters
* tick ... Markierung an den Achsen des Zeichenfensters

Beispiel (eine figure mit 6 axes, ax-Titel, y-axis-Titel):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=3, ncols=2)
 
 ax[0][0].text(0.1, 0.5, &quot;11&quot;)
 ax[0][1].text(0.1, 0.5, &quot;12&quot;)
 ax[1][0].text(0.1, 0.5, &quot;21&quot;)
 ax[1][1].text(0.1, 0.5, &quot;22&quot;)
 ax[2][0].text(0.1, 0.5, &quot;31&quot;)
 ax[2][1].text(0.1, 0.5, &quot;32&quot;)
 
 ax[0][0].set(ylabel=&quot;y-label&quot;, title=&quot;axes 1&quot;)
 
 plt.show()

[[Bild:PythonIng_figure34.png|350px]]

Beispiel (Achsenbereiche setzen):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 
 ax[0].axis((-1, 10, 1, 12))
 
 plt.show()

[[Bild:PythonIng_figure35.svg|350px]]

Beispiel (Gitter einschalten): 

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 ax[0].axis((-5, 10, 1, 12))
 ax[0].minorticks_on()
 ax[0].grid(which='minor')
 ax[1].grid(which='major')
 plt.show()

[[Bild:PythonIng_figure36.svg|350px]]

Beispiel (ticks setzen)

 import matplotlib.pyplot as plt
 import matplotlib.ticker as tick
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 pos = [0, .2, .5]
 lab = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
 
 ax.xaxis.set_major_locator(tick.FixedLocator(pos))
 ax.xaxis.set_major_formatter(tick.FixedFormatter(lab))
 
 plt.show()

[[Bild:PythonIng_figure37.svg|350px]]

Beispiel (Achsenkreuz beliebig setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 ax.spines['top'].set_color('none')
 ax.spines['right'].set_color('none')
 ax.spines['bottom'].set_position(('data', 0.3))
 ax.spines['left'].set_position(('data', 0.5))
 
 plt.show()

[[Bild:PythonIng_figure38.svg|350px]]

Beispiel (Inset):

 import matplotlib.pyplot as plt
 
 # Hauptplot erstellen
 fig, ax = plt.subplots()
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 
 # Inset hinzu:
 axin = ax.inset_axes([0.4, 0.4, 0.3, 0.3])
 axin.text(0, 0, &quot;Servus&quot;)
 axin.plot()
 
 plt.show()

[[Bild:PythonIng_figure40.svg|350px]]

Beispiel (Hintergrundfarben setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.set_facecolor(&quot;green&quot;)
 fig.set_facecolor(&quot;yellow&quot;)
 
 plt.plot([1, 3], [6, 8])
 plt.show()

[[Bild:PythonIng_figure39.svg|300px]]

=== GridSpec ===
Mit figures und axes lassen sich schon jede Menge an Grafikdetails einstellen. GridSpec ist dann der Turbo oder Raketenantrieb den matplotlib eingebaut hat. Naja, vielleicht ist das etwas übertrieben, aber GridSpec ist sozusagen ein flexibler Layout-Manager. Bisher haben wir immer gleich große axes gezeichnet. Mit GridSpec können wir Subplots über mehrere Zeilen und Spalten ziehen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 gs = fig.add_gridspec(3, 3)
 
 ax1 = fig.add_subplot(gs[0, :])
 ax1.set_title(&quot;Bereich 1: gs[0, :]&quot;)
 
 ax2 = fig.add_subplot(gs[1:, 0])
 ax2.set_title(&quot;Bereich 2: gs[1:, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 1:])
 ax3.set_title(&quot;Bereich 3: gs[1, 1:]&quot;)
 
 ax4 = fig.add_subplot(gs[2, 1:])
 ax4.set_title(&quot;Bereich 4: gs[2, 1:]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec1.svg|350px]]

Erklärung zu &lt;code&gt;(gs[zeile, spalte])&lt;/code&gt;: Slicing; damit legen Sie fest, welche Zellen ein Subplot belegt. Achtung! Die Indizes beginnen bei 0 und nicht bei 1 (d.h., die erste Zeile/Spalte hat den Index 0)
* : ... alle 
* 1: ... 1 bis Ende
* etc.

&lt;code&gt;constrained_layout=True&lt;/code&gt; sorgt dafür, dass sich die Subplots nicht überlappen.

Aber auch die Spaltenbreiten und Zeilenhöhen lassen sich anpassen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 
 # Verhältnis erste zu zweite Zeile = 1.5:1
 # Verhältnis erste zu zweite Spalte  = 1:4
 gs = fig.add_gridspec(2, 2, figure=fig, height_ratios=[1.5, 1], width_ratios=[1, 4])
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax1.set_title(&quot;Bereich 1: gs[0, 0]&quot;)
 
 ax2 = fig.add_subplot(gs[0, 1])
 ax2.set_title(&quot;Bereich 2: gs[0, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 0])
 ax3.set_title(&quot;Bereich 3: gs[1, 0]&quot;)
 
 ax4 = fig.add_subplot(gs[1, 1:])
 ax4.set_title(&quot;Bereich 4: gs[1, 1]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec2.svg|350px]]

Auch die Ränder lassen sich einstellen.

Beispiel 1:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.1, right=0.9, bottom=0.1,
                        top=0.9, wspace=0.2, hspace=0.2)
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec3.svg|300px]]

* hspace ... height space, vertikaler Abstand zwischen den Zeilen
* wspace ... width space, horizontaler Abstand zwischen den Spalten

Und im Vergleich dazu Beispiel 2:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.3, right=0.7, bottom=0.3, 
                        top=0.7, wspace=0.3, hspace=0.3) 
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec4.svg|300px]]

Es gibt noch einige weitere Details, die sich mit GridSpec variieren lassen (z.B. SubGridSpec ... verschachtelte Grid-Layouts). Aber wir belassen es vorerst dabei. Das bisher Gezeigte sollte für die meisten Probleme ausreichend sein.

=== Aufgaben ===
* Zeichnen Sie die Strophoide &lt;math&gt;x = \frac{a(t^2-1)}{t^2+1}, y = \frac{at(t^2-1)}{t^2+1}, a = 2, -3 \leq t \leq 3&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_strophoide.jpg|300px|center]]

* Zeichnen Sie die verschlungene Hypozykloide &lt;math&gt;x = (R-r)\cos t + c\cos\frac{R-r}{r}t, y = (R-r)\sin t - c\sin\frac{R-r}{r}t, c = 3, r = 2, R = 6, -15 \leq t \leq 15&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_hypozykloide.jpg|300px|center]]

* Testen Sie bei den obigen Übungsaufgaben verschiedene Linienstile und Farben. Farben können mit dem plt.plot()-Parameter color gewählt werden.

* Testen Sie bei den obigen Übungsaufgaben verschiedene Werte für a, c, r und R.

* Zeichnen Sie folgendes Bild (die Achsenbeschriftungen positionieren Sie z.B. mit den Befehlen &lt;code&gt;ax.set_xlabel(&quot;x&quot;, loc=&quot;right&quot;); ax.set_ylabel(&quot;y&quot;, loc=&quot;top&quot;)&lt;/code&gt;):

[[Bild:PythonIng_aufgabe24.svg|400px|center]] 

* Zeichnen Sie mit Python, matplotlib und NumPy folgendes Bild:

[[Bild:PythonIng_figure41.svg|400px|center]]

* Zeichnen Sie mit GridSpec ein Layout, das in etwa wie folgendes aussieht (&lt;code&gt;height_ratios=[1, 2], width_ratios=[2, 1]&lt;/code&gt;):

[[Bild:PythonIng_aufgabe23.svg|300px|center]]

== 3D ==
=== Räumliche Kurven ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0, 6*np.pi, 0.1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 z = t
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot(x, y, z)
 
 plt.show()

[[Datei:PythonIng_raumkurve1.png]]

=== Flächen ===
 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche1.png]]

Das Ganze in Netzdarstellung läßt sich so programmieren: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.5)
 y = np.arange(0, 10, 0.5)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_wireframe(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche2.png]]

Ein etwas komplexeres Beispiel:

 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0.1, 10, 0.1)
 y = np.arange(0.1, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z1 = np.sin(x) + 3 * np.cos(y)
 z2 = np.sin(x) + np.log(y)
 z3 = x + np.cos(y)
 z4 = x**2 - y
  
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;}, nrows=2, ncols=2)
 
 ax[0][0].plot_surface(x, y, z1)
 ax[0][1].plot_surface(x, y, z2)
 ax[1][0].plot_surface(x, y, z3)
 ax[1][1].plot_surface(x, y, z4)
 
 plt.show()

[[Datei:PythonIng_subplot1.png]]

Man beachte, dass man die Unterbilder im Bild nach dem Ausführen des Scripts z.B. mit der mittleren Maustaste einzeln drehen, oder über die Einträge in der Menüzeile einzeln bearbeiten kann. Mit ein paar Zeilen Programmtext lässt sich also eine Menge an Funktionalität generieren.

Die Farbgebung lässt sich über &lt;code&gt;colormaps&lt;/code&gt; variieren.

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm)
 
 plt.show()

[[Datei:PythonIng_colormap1.png]]

Es gibt eine Menge an Colormaps, z.B. &lt;code&gt;plasma, Greys, Dark2, ocean&lt;/code&gt;. Zwecks detaillierterer Infos siehe die matplotlib-Dokumentation. &lt;small&gt;Verwendet man die IDE namens IDLE, so gibt es dort auch die automatische Codevervollständigung. D.h. es werden alle Möglichkeiten (in unserem Fall nach dem Eintippen von &lt;code&gt;cm.&lt;/code&gt; alle verfügbaren Colormaps) angezeigt.&lt;/small&gt;

Die &quot;edgecolor&quot; und Linienbreite können auch frei gewählt werden:

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm, edgecolor=&quot;black&quot;, linewidth=1.0)
 
 plt.show()

[[Datei:PythonIng_colormap2.png]]

=== Höhenlinien ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 ax.contour(x, y, z)
 
 plt.show()

[[Datei:PythonIng_höhenlinien1.png|400px]]

Etwas abgewandelt sieht das so aus: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contour(x, y, z)
 ax.clabel(hl, inline = True)
 
 plt.show()

[[Datei:PythonIng_höhenlinien2.png|400px]]

Und noch eine Variante (mit einem Farbbalken) sei gezeigt. 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contourf(x, y, z)
 fig.colorbar(hl) 
 
 plt.show()

[[Datei:PythonIng_höhenlinien5.svg|400px]]

=== Aufgaben ===
* Zeichnen Sie die räumliche Kurve &lt;math&gt;x = 2 \cdot \cosh(t)&lt;/math&gt;, &lt;math&gt;y = 5 \cdot \sin(t)&lt;/math&gt;, &lt;math&gt; z = t^{2} - t&lt;/math&gt;, &lt;math&gt;0 \leq t \leq 3\pi&lt;/math&gt;.
* Zeichnen Sie die Fläche &lt;math&gt;z = \log(x) + \cos(y)&lt;/math&gt;.

== Animationen und fortgeschrittenes 3D ==
=== Mit matplotlib ===
Auch mit matplotlib sind Animationen möglich. Das ist ein bisschen komplizierter und wird deshalb hier nur mit einem sehr einfachen Beispiel dargestellt (bei Interesse siehe z.B. auch das [https://matplotlib.org/stable/users/explain/animations/animations.html#animations Animations using Matplotlib-Tutorial]).

 import matplotlib.pyplot as plt
 import matplotlib.animation as ani
 import matplotlib
 import numpy as np
 
 def update(frame):
     line.set_xdata(x[:frame])
     line.set_ydata(y[:frame])
     return (line)
 
 fig, ax = plt.subplots()
 
 x = np.arange(0, 10, .1)
 y = np.sin(x)
 
 line, = ax.plot(x[0], y[0])
 ax.set(xlim=[0, 10], ylim=[-1, 1])
 
 a = ani.FuncAnimation(fig=fig, func=update, frames=100, interval=20)
 plt.show()
 
 # Speichere die Animation in einem animierten GIF (optional)
 a.save(filename=&quot;c:/tmp/PythonIng_anim5.gif&quot;, writer=&quot;pillow&quot;)

[[Datei:PythonIng_anim5.gif]]

Es wird eine Sinuskurve auf den Bildschirm gezeichnet. In der letzten Zeile wird diese Animation in ein animiertes GIF gespeichert. Das ist natürlich optional und kann auch weggelassen werden.

=== Mit VPython ===
Aber auch mit dem Modul VPython lassen sich einfache 3D-Animationen erstellen. VPython ist ein externes Modul, das vorab installiert werden muss. Unter openSUSE Tumbleweed gibt es dzt. kein entsprechendes rpm-Paket. Die übliche Methode der Installation mittels YaST oder zypper ist somit nicht möglich. Auch eine direkte Verwendung von pip führt nur zu einer Fehlermeldung (&lt;code&gt;error: externally-managed-environment&lt;/code&gt;). Es empfiehlt sich dort folgende Vorgehensweise:
# Erstelle zuerst eine virtuelle Umgebung, z.B.: &lt;code&gt;python3.11 -m venv ~/tmp/venv1&lt;/code&gt;
# Wechsle das Verzeichnis: &lt;code&gt;cd ~/tmp/venv1/bin&lt;/code&gt;
# Installiere das entsprechende Paket: &lt;code&gt;./pip install vpython&lt;/code&gt;
# Führe das entsprechende Skript aus: &lt;code&gt;./python ~/tmp/test1.py&lt;/code&gt;

Aktuell (März 2026) ist dieses Programmpaket lt. der [https://vpython.org/presentation2018/install.html VPython-Homepage] nur für die Python-Versionen 3.8 bis 3.12 verfügbar.

Ein Beispiel zu einer einfachen Animation wird nachfolgend geliefert.

 from vpython import *
 
 scene.width = 1200
 scene.height = 600
 scene.center = vector(20,0,0)
 scene.background = color.white
 
 cylinder(pos=vector(0,0,0), axis=vector(20,0,0), radius=5, 
         color=color.blue)
 cone(pos=vector(0,0,0), axis=vector(-10,0,0), radius=5, 
         color=color.blue)
 helix(pos=vector(20,0,0), axis=vector(40,0,0), radius=2, 
         coils=10, thickness=0.5, color=color.blue)
 
 ball = sphere(pos=vector(20,0,0), color = color.green, radius = 1)
 ball.p = vector(0.15, 0, 0)
 
 toc = True
 
 while True:
     rate(200)
     if(ball.pos.x &lt;= 60 and toc == True):
         ball.pos += ball.p
     else:
         toc = False
         ball.pos -= ball.p
         if(ball.pos.x &lt;= 20 and toc == False):
             toc = True

[[Datei:PythonIng_vpython_anim.JPG]]

Idealerweise öffnet sich beim Ausführen des Scripts ein Browserfenster. Darin wird die programmierte Animation gezeigt (siehe auch den obigen Screenshot). Eine Größenänderung können Sie mit der mittleren Maustaste initiieren. Die Szenerie drehen können Sie mit der rechten Maustaste.

=== Mit build123d ===
Hiermit lassen sich einfach 3D-Modelle für CAD-Systeme erstellen. [https://build123d.readthedocs.io/en/latest/ build123d] ist ein externes Modul und muss vorab, wie schon für mehrere andere Module gezeigt, installiert werden (pip, venv etc.).

Beispielcode:

 from build123d import *
 
 # Bauteil
 with BuildPart() as bauteil: 
     # Zylinder erstellen
     Cylinder(100, 60)
        
     # Bohrung
     with BuildSketch(bauteil.faces().sort_by(Axis.Z)[-1]) as loch:
         Circle(radius=10)
     # negativ extrudieren
     extrude(amount=-60, mode=Mode.SUBTRACT)
     
     # Dem Bauteil z.B. die Farbe rot zuweisen
     # bauteil.part.color = Color(&quot;red&quot;, alpha=1.0)
 
     # Fertiges Modell exportieren
     export_step(bauteil.part, &quot;bauteil.step&quot;)

Ausgabe ({{W|Standard for the exchange of product model data | STEP}}-Datei, z.B. in {{W|FreeCAD}} importiert, Screenshot):

[[Datei:PythonIng_build123d.jpg | 300px]]

FreeCAD ist ein freies 3D-CAD-System. Die [[Ing_Mathematik:_Python#FreeCAD | Makroprogrammierung]] in diesem System wird später noch gezeigt. STEP steht für &quot;'''St'''andard for the '''e'''xchange of '''p'''roduct model data&quot; und ist ein Datenaustauschformat.

=== Mit VTK ===
Komplexer, aber auch mächtiger als VPython ist die Verwendung von VTK ('''V'''isualization '''T'''ool'''k'''it). Genauer gesagt des Python-Wrappers von VTK. Dieses externe Python-Modul muss vorab installiert werden (z.B. mittels YaST, pip oder in eine virtuelle Umgebung). VTK ist eine Softwarebibliothek zur 3D-Visualisierung und wurde ursprünglich in C++ geschrieben. Verbreitet eingesetzt wird diese Bibliothek in der Wissenschaft und Forschung, z.B. 
* in der medizinischen Bildgebung
* für Strömungssimulationen
* für Klimadaten

VTK funktioniert nach dem {{W|Grafikpipeline|Pipeline-Prinzip}}:

 Source (Quellen) -&gt;  Filter -&gt; Mapper (Senken) -&gt; Actor/Renderer

Daten fließen von den Quellen zu den Senken.

Als einfaches Beispiel wird die Darstellung eines Zylinders gezeigt, der mit den Maustasten gedreht oder in der Größe geändert werden kann:

 import vtk
 
 # Zylinder erzeugen
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 # Geometrie in darstellbare Daten umwandeln
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 # Objekt in der Szene
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 # Szene verwalten
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 # Render-Fenster
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 # Maus/Tastatur-Steuerung
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 # Starten
 render_window.Render()
 interactor.Start()

Ausgabe:

[[Datei:PythonIng_VTK_1.png]]

Gleiches Beispiel wie oben, aber mit einer Animationssequenz:

 import vtk
 import time
 
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     render_window.Render()
     time.sleep(0.01)

Das Grafikfenster schließt sich nach Ablauf der Schleife. Das Fenster bleibt geöffnet, wenn Sie am Programmende folgenden Befehl hinschreiben

 interactor.Start()

Um den animierten Zylinder grün einzufärben, müssen Sie Folgendes im obigen Programm ergänzen (Farbnamen):

 colors = vtk.vtkNamedColors()
 actor.GetProperty().SetColor(colors.GetColor3d(&quot;Green&quot;))

Als Namen können Sie u.a. die CSS3 Web-Farben verwenden (siehe z.B. [https://wiki.selfhtml.org/wiki/Farbe/Farbangaben] und {{W|Webfarbe#CSS_3}}).

Alternativ funktioniert auch das ({{W|RGB-Farbraum|RGB}}):

 actor.GetProperty().SetColor(0.0, 0.6, 0.0)

Wie der Zylinder mit einer Textur versehen wird, zeigt folgendes Programm:

 import vtk
 import time
 
 cylinder = vtk.vtkCylinderSource()
 cylinder.SetResolution(30)
 cylinder.SetHeight(3.0)
 cylinder.SetRadius(1.0)
 cylinder.CappingOn()
 
 texture_coords = vtk.vtkTextureMapToCylinder()
 texture_coords.SetInputConnection(cylinder.GetOutputPort())
 texture_coords.PreventSeamOn()
 
 reader = vtk.vtkJPEGReader()
 reader.SetFileName(&quot;PythonIng_textur.jpg&quot;)
 
 texture = vtk.vtkTexture()
 texture.SetInputConnection(reader.GetOutputPort()) 
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(texture_coords.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 actor.SetTexture(texture)
 
 renderer = vtk.vtkRenderer()
 renderWindow = vtk.vtkRenderWindow()
 renderWindow.AddRenderer(renderer)
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(renderWindow)
 
 renderer.AddActor(actor)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     renderWindow.Render()
     time.sleep(0.01)
 
 interactor.Start()

&lt;gallery&gt;
PythonIng_textur.jpg | Textur-Datei
PythonIng_VTK_2.png | Ausgabe (Screenshot)
&lt;/gallery&gt;

== Sonstige Grafikbibliotheken ==
=== Py5 ===
Im Buch ''Iacono et al.: Programmieren trainieren, mit über 150 Workouts in Java und Python; 3. Aufl., Hanser, 2023'' werden zahlreiche Aufgaben gestellt, die u.a. mit Processing zu lösen sind.  Processing ist eine einfache Programmiersprache und Entwicklungsumgebung. Warum ich das erwähne? Weil in älteren Processing-Versionen auch die Programmiersprache Python 2 abgedeckt war. Bei neueren Versionen gibt es keine Python-Anbindung mehr (getestet nur mit openSUSE Tumbleweed und Python 3). Somit funktioniert der Python-Teil im genannten Buch zum Teil nicht mehr. Ist das tragisch, oder kann das Buch weggeschmissen werden? Nein! Es gibt Alternativen zu Processing. Zum einen die im Buch selbst genannten Bibliotheken tkinter oder pygame. Pygame wird dort auch kurz anhand eines Beispiels thematisiert. Aber noch besser ist es, die py5-Bibliothek zu verwenden (lt. Google KI vom 30. Sept. 2026: ''Der echte, moderne „spirituelle Nachfolger“''). Damit ist die Funktionalität von Processing gewährleistet. Man kann aber beliebige Editoren oder IDEs zur Programmerstellung verwenden, ohne an Processing als IDE gebunden zu sein. Nachfolgend werden ein paar Beispiele zu dieser externen Bibliothek gegeben. Der erste Schritt ist wieder, die py5-Bibliothek zu installieren (z.B. mittels pip in eine virtuelle Umgebung; Python&gt;=3.10 und ein JDK&gt;=17 müssen auch installiert sein (Stand Okt. 2026)). Dann kann es schon mit dem Programmieren losgehen.

Beispiel (angelehnt an die ''Aufgabe W.2.3 Haus'' des genannten Buchs, jedoch etwas erweitert):

 import py5
 
 def setup():
     py5.size(600, 600)            # Fenstergröße 600px x 600px 
     py5.background(255, 255, 255) # Hintergrundfarbe ... weiss
     
 def draw():
     # Haus zeichnen
     py5.fill(255, 255, 255)       # Hintergrundfarbe ... weiss
     py5.stroke(255, 0, 0)         # Linienfarbe ... rot 
     py5.stroke_weight(3)          # Linienbreite ... 3px
     py5.rect(150, 200, 300, 300)  # Rechteck zeichnen (x, y, b, h)
     py5.triangle(150, 200, 300, 100, 450, 200) # Dreieck zeichnen
     py5.circle(250, 300, 70)      # Kreis zeichnen (x, y, d)   
     
     # Bemassung zeichnen
     py5.stroke(0, 255, 0)
     py5.stroke_weight(1)
     py5.line(300, 100, 550, 100)  # Linie zeichnen
     py5.line(450, 200, 550, 200) 
     py5.line(450, 500, 550, 500) 
     py5.line(150, 500, 150, 550)
     py5.line(450, 500, 450, 550)
     py5.text_size(20)             # Textgroesse
     py5.fill(0, 255, 0)           # Textfarbe
     py5.text(&quot;300&quot;, 280, 550)     # Text zeichnen
     py5.text(&quot;100&quot;, 500, 150)
     py5.text(&quot;300&quot;, 500, 350)  
 
     # Gedrehtes Rechteck zeichnen
     py5.stroke(255, 255, 0)
     py5.stroke_weight(3)
     py5.fill(200, 200, 200) 
     py5.translate(320, 260)  
     py5.rotate(0.3)               # Drehung (in Radiant)
     py5.rect(0, 0, 100, 50)
 
 # Startet den Sketch
 py5.run_sketch()


Ausgabe:

[[Datei:PythonIng_py5_1.png|300px]]

Das skizzierte Haus ist mit einer rudimentären Bemaßung versehen und hat zwei Fenster, ein rundes und ein gedrehtes, trübes rechteckiges. 

Beispiel (Mausoperationen):

 import py5
 
 def setup():
     py5.size(600, 600)            
     py5.background(255, 255, 255)
 
 def draw():
     pass
    
 def mouse_pressed():
     py5.text_size(15) 
     py5.fill(0, 0, 255)
     x = py5.mouse_x
     y = py5.mouse_y
     py5.text(&quot;(%d, %d)&quot; %(x, y), x, y) # Positionsdaten bei Maus-Klick schreiben
 
 py5.run_sketch()

Ausgabe:

[[Datei:PythonIng_py5_2.png|300px]]

Obiges Bild zeigt das Resultat nach einigen Mausklicks. Man erkennt, dass links-oben der Koordinatennullpunkt ist. Die x-Achse zeigt nach rechts, die y-Achse nach unten.

Beispiel (Fünfeck):

 import py5
 import random 
 
 def setup():
     py5.size(400, 400)
     py5.no_loop()       # statisches Bild (schont die Ressourcen)
 
 def draw():
     py5.translate(py5.width / 2, py5.height / 2)  # KS setzen
 
     radius = 150
     eck_anzahl = 5
 
     py5.fill(random.randint(0, 255), random.randint(0, 255), 
              random.randint(0, 255))    # Füllfarbe auf Zufallswert setzen
     py5.stroke(155, 0, 0)            
     py5.stroke_weight(5)     
     
     # Fünfeck als Polygon zeichnen
     py5.begin_shape()
     for i in range(eck_anzahl):
         winkel = i * py5.TWO_PI / eck_anzahl - py5.HALF_PI
         x = py5.cos(winkel) * radius
         y = py5.sin(winkel) * radius
         py5.vertex(x, y)
     py5.end_shape(py5.CLOSE)
 
 py5.run_sketch()

Ausgabe, bspw.:

[[Datei:PythonIng_py5_5.png|200px]]

&lt;u&gt;Kleine Aufgaben:&lt;/u&gt;
* Um die Funktionsweise von &lt;code&gt;py5.no_loop()&lt;/code&gt; zu verstehen, kommentieren Sie die Anweisung im Beispiel einfach aus, und starten Sie das Programm erneut.
* Zeichnen Sie ein Siebeneck.
* Was passiert, wenn man &lt;code&gt;py5.CLOSE&lt;/code&gt; im &lt;code&gt;py5.end_shape()&lt;/code&gt;-Befehl weglässt?

Beispiel (Grafik laden und zeichnen):

 import py5
 
 image1 = None
 
 def setup():
     global image1
     py5.size(600, 600)
     py5.no_loop()
     image1 = py5.load_image(&quot;PythonIng_py5_1.png&quot;)
 
 def draw():
     py5.image(image1, 0, 0)
 
 py5.run_sketch()

Hier wird einfach das Bild vom Haus-Beispiel (Screenshot von weiter oben) geladen und gezeichnet.

Beispiel (angelehnt an ''W.5.10 Wurfparabel'' des genannten Buches; mit OOP erstellt):

 import py5
 
 class Wurfparabel(py5.Sketch):
     def __init__(self, v0, angle):
         super().__init__()
         self.v0 = v0
         self.angle = self.radians(angle)
         self.g = 9.81
         self.t = 0.0
         self.scale = 1.5
 
     def settings(self):
         self.size(800, 600)
 
     def setup(self):        
         self.background(0, 0, 0)
         
     def draw(self):
         self.t += 0.1
 
         self.translate(50, 500)
       
         # KS Zeichnen
         self.fill(255, 255, 0)
         self.stroke(255, 255, 0)
         self.stroke_weight(1)
         self.line(0, 0, 0, -300)
         self.line(0, 0, 700, 0)
 
         # Punkt zeichnen
         cx = self.v0 * self.cos(self.angle) * self.t * self.scale
         cy = -(self.v0 * self.sin(self.angle) * self.t - \
                self.g/2 * self.t**2) * self.scale
         self.fill(255, 0, 0)
         self.stroke(255, 0, 0)
         self.circle(cx, cy, 3)
        
         # Stoppen bei Bodenkontakt
         if cy &gt;= -5:
             self.no_loop()
            
 def wurfparabel(v0=50, angle=45):
     sketch = Wurfparabel(v0, angle)
     sketch.run_sketch()
 
 v0 = float(input(&quot;v0 = &quot;))
 winkel = float(input(&quot;winkel = &quot;))
 wurfparabel(v0=v0, angle=winkel)

Eingabe auf der Konsole:

 v0 = 60
 winkel = 45

Ausgabe:

[[Datei:PythonIng_py5_13.png|200px]]

Die benötigten Formeln der Bewegungsgleichung kann man leicht herleiten, bzw. man benutzt folgende Grafik als Hilfestellung:

[[Datei:Wurfparabel_Zusammenfassung_aktualisierung.png|700px]]

&lt;u&gt;Aufgabe:&lt;/u&gt; Berechnen Sie den Scheitelpunkt und die Wurfweite bei gegebener Anfangsgeschwindigkeit und gegebenem Abwurfwinkel. Die Abwurfhöhe &lt;math&gt;y_0&lt;/math&gt; sei 0. Der Wurf soll auf der Erde stattfinden (g = 9.81 m/s²). Die dazu benötigten Formeln können aus obiger Grafik entnommen werden (oder Sie leiten sie selbst her). Geben Sie die Ergebnisse auf der Konsole aus.

Beispiel (eine einfache Animation):

 import py5
 
 i = 0
 
 def setup():
     py5.size(600, 600)
     py5.frame_rate(5)
     py5.stroke_weight(20)
 
 def draw():
     global i
     
     py5.background(255, 255, 255)
     py5.translate(py5.width/2, py5.height/2)
     py5.rotate(py5.PI/8 * i)    
 
     py5.line(-100, 0, 100, 0)
     i += 1
 
 py5.run_sketch()

Es wird eine rotierende Linie gezeichnet (z.B. wie bei einem Installationsprozess verwendet - zeigt an, dass der Installationsfortschritt nicht eingefroren ist). Hierbei ist nur aufzupassen, dass der Hintergrund in &lt;code&gt;draw()&lt;/code&gt; gesetzt wird, ansonsten würden die Linien additiv gezeichnet. Das ist zwar auch schön, aber eben nicht das gewünschte Resultat.

Hiermit belassen wir es mit der py5-Bibliothek und wenden uns wieder &quot;mathematischeren&quot; Themen zu.

= Vektoren und Matrizen =
== Zahlenfolgen ==
Für das Erstellen von Zahlenfolgen bieten sich die Funktionen &lt;code&gt;arange&lt;/code&gt; und &lt;code&gt;linspace&lt;/code&gt; aus dem &lt;code&gt;numpy&lt;/code&gt;-Modul an.

 from numpy import *
 
 start = 0
 stop = 10
 step = 2
 num = 10
 
 r = arange(start, stop, step)   # step ... Schrittweite
 l = linspace(start, stop, num)  # num ... Anzahl der Werte
 
 print(&quot;r = &quot;, r)
 print(&quot;l = &quot;, l)

Ausgabe:
 r =  [0 2 4 6 8]
 l =  [ 0.          1.11111111  2.22222222  3.33333333  4.44444444  5.55555556
   6.66666667  7.77777778  8.88888889 10.        ]

Bei &lt;code&gt;arange&lt;/code&gt; ist der &lt;code&gt;stop&lt;/code&gt;-Wert nicht im Ergebnis enthalten, bei &lt;code&gt;linspace&lt;/code&gt; standardmäßig aber sehr wohl. Jedoch kann man das bei &lt;code&gt;linspace&lt;/code&gt; auch ändern. Dann ist der Stoppwert nicht mehr enthalten: 

 linspace(start, stop, num, endpoint=False)

== Vektoren ==
Vektoren sollten jedem aus der Linearen Algebra bekannt sein. 

=== Arrays ===
In Python mit NumPy kann man Vektoren durch die Funktion array erzeugen.

 import numpy as np
 
 l1 = (-5, 3, 2)
 l2 = (1, 1, 4)
 
 a1 = np.array(l1)
 a2 = np.array(l2)
 
 a3 = a1 + a2
 a4 = 2 * a2
 
 print(a1)
 print(a2)
 print(a3)
 print(a3[2])
 print(a4)

Ausgabe:
 [-5  3  2]
 [1 1 4]
 [-4  4  6]
 6
 [2 2 8]

=== Zeilen- und Spaltenvektoren ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 print(z)
 print(s)

Ausgabe:
 [ [-5  3  2] ]
 [[1]
  [1]
  [4]]

=== Skalarprodukt ===
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4))
 
 skalarprodukt = np.dot(a1, a2)  
 
 print(skalarprodukt)

Ausgabe:
 6

=== Vektorprodukt ===
&lt;math&gt;a\ast b=\left(\begin{array}{c}
a_{1}\\
a_{2}\\
a_{3}
\end{array}\right)\ast\left(\begin{array}{c}
b_{1}\\
b_{2}\\
b_{3}
\end{array}\right)=\left(\begin{array}{c}
a_{2}b_{3}-a_{3}b_{2}\\
a_{3}b_{1}-a_{1}b_{3}\\
a_{1}b_{2}-a_{2}b_{1}
\end{array}\right)
&lt;/math&gt; 

Python-Code:
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4)) 
 
 vektorprodukt = np.cross(a1, a2) 
 
 print(vektorprodukt)

Ausgabe:
 [10 22 -8]

=== Transponierter Vektor ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 # transponierter Vektor
 z_tp = np.transpose(z)
 # transponierter Vektor
 s_tp = np.transpose(s)
 
 print(z_tp)
 print(s_tp)

Ausgabe:
 [[-5]
  [ 3]
  [ 2]]
 [ [1 1 4] ]

=== Vektorfelder visualisieren ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 # Daten generieren
 x = np.arange(0, 10, 1)
 y = np.arange(0, 10, 1)
 X, Y = np.meshgrid(x, y)
 U = X * Y
 V = Y + X
 
 # Plotten
 fig, ax = plt.subplots()
 
 ax.quiver(X, Y, U, V, angles='xy')
 
 plt.show()

Ausgabe:

[[Datei:PythonIng_quiver1.png]]

== Matrizen==
 import numpy as np
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 print(m1)

Ausgabe:
 [[1 2 3]
  [4 5 6]]

=== Zugriff auf Matrizenelemente ===
Beispiel:

 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 
 # Element aus Zeile 2 und Spalte 3 (Achtung! Index startet bei Null)
 print(m1[1,2])

Ausgabe:
 6

Visualisierung:
  
     0   1   2
   +-----------+
 0 | 1 | 2 | 3 |
   +-----------+
 1 | 4 | 5 | '''6''' |
   +-----------+


Beispiel:

 import numpy as np
 
 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
 
 B = np.matrix(A)     
 
 print(B[2::, ::2])

Ausgabe:

 [['20' '22']
  ['30' '32']
  ['40' '42']]

Mit der NumPy-Bibliothek funktioniert das zweidimensionale Slicing. Mit normalen Listen/Tupels geht das nicht, was wir schon früher thematisiert haben.

=== Addition und Subtraktion von Matrizen ===
 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 m2 = np.matrix([[0, 0, 2], [1, 3, 2]])
 
 print(m1 + m2)
 print(m1 - m2)

Ausgabe:
 [[1 2 5]
  [5 8 8]]
 [[1 2 1]
  [3 2 4]]

=== Transponierte Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 2, 3], [4, 5, 6]])
 mt = np.transpose(m) 
 
 print(m)
 print(mt)

Ausgabe:
 [[1 2 3]
  [4 5 6]]
 [[1 4]
  [2 5]
  [3 6]]

=== Rang einer Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 rg = np.linalg.matrix_rank(m)
 
 print(rg)

Ausgabe:
 2

=== Inverse Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 mi = np.linalg.inv(m)
 
 print(mi)

Ausgabe:
 [[ 1.   0.6]
  [-0.  -0.2]]

=== Multiplikation von Matrizen (falksches Schema) ===
 import numpy as np
 
 m1 = np.matrix([[1, 3, 4],  [0, -5, 1]])
 m2 = np.matrix([[1, 2], [2, 3], [0, 2]])
 
 print(m1 @ m2)

Ausgabe:
 [[  7  19]
  [-10 -13]]

=== Eigenwerte und Eigenvektoren ===
 import numpy as np
 
 m = np.matrix([[5, 8],  [1, 3]])
 D,V = np.linalg.eig(m)
 
 # Eigenwerte
 print(D)
 # Eigenvektoren
 print(V)

Ausgabe:
 [7. 1.]
 [[ 0.9701425  -0.89442719]
  [ 0.24253563  0.4472136 ]]

=== Teilmatrizen ===
 import numpy as np
 m = np.matrix([[1, 3, 4],  [0, -5, 1]])
 print(&quot;m = &quot;, m)
 
 # Erste Zeile extrahieren
 m1 = m[0,:]
 print(&quot;m1 = &quot;, m1)
 
 # Das Element aus der 1. Zeile und der 2. Spalte extrahieren
 m2 = m[0,1]
 print(&quot;m2 = &quot;, m2)
 
 # Zweite Spalte extrahieren
 m3 = m[:, 1]
 print(&quot;m3 = &quot;, m3)

Ausgabe:
 m =  [[ 1  3  4]
  [ 0 -5  1]]
 m1 =  [ [1 3 4] ]
 m2 =  3
 m3 =  [[ 3]
  [-5]]

=== Spezielle Matrizen ===
==== Nullmatrix ====
 import numpy as np
 z = np.zeros((3, 2))
 print(z)

Ausgabe:
 [[0. 0.]
  [0. 0.]
  [0. 0.]]

==== Einheitsmatrix ====
 import numpy as np
 z = np.eye(3)
 print(z)

Ausgabe:
 [[1. 0. 0.]
  [0. 1. 0.]
  [0. 0. 1.]]

==== Matrix mit lauter Einsen ====
 import numpy as np
 z = np.ones((3, 2))
 print(z)

Ausgabe:
 [[1. 1.]
  [1. 1.]
  [1. 1.]]

=== Spärlich besetzte Matrizen ===
Das Thema spärlich besetzter Matrizen wird hier nur kurz angerissen. Nähere Details siehe unter dem Weblink  [https://docs.scipy.org/doc/scipy/reference/sparse.html#module-scipy.sparse]. 

Beispiel:

 import numpy as np
 import scipy
 
 A = scipy.sparse.csr_array(np.eye(5))
 
 print(A)

Ausgabe:
 &lt;Compressed Sparse Row sparse array of dtype 'float64'
         with 5 stored elements and shape (5, 5)&gt;
   Coords        Values
   (0, 0)        1.0
   (1, 1)        1.0
   (2, 2)        1.0
   (3, 3)        1.0
   (4, 4)        1.0

csr steht für '''c'''ompressed '''s'''parse '''r'''ow.

Andere Möglichkeiten:
* coo-Format ('''coo'''rdinate Format): &lt;code&gt;scipy.sparse.coo_array()&lt;/code&gt;
* lil-Format ('''li'''st of '''l'''ists): &lt;code&gt;scipy.sparse.lil_array()&lt;/code&gt;
* csc-Format ('''c'''ompressed '''s'''parse '''c'''olumn): &lt;code&gt;scipy.sparse.csc_array()&lt;/code&gt;

Es gibt auch &lt;code&gt;scipy.sparse.csr_matrix()&lt;/code&gt; etc. Diese Befehle sind aber veraltet und es wird empfohlen, statt dessen die &lt;code&gt;..._array()&lt;/code&gt;-Funktionen zu verwenden.

&lt;u&gt;Aufgaben:&lt;/u&gt; 
Recherchieren Sie im Internet 
* generell zum Thema &quot;spärlich besetzte Matrizen mit Python&quot;.
* Was sind die Vor-/Nachteile von csr-arrays gegenüber coo- und lil-arrays?
* Wann verwendet man sinnvollerweise csr- und wann csc-arrays?
* Wie wandelt man coo-arrays in csr-arrays um?

= Lineare Gleichungssysteme =
Sei &lt;math&gt;Ax = b&lt;/math&gt; ein lineares Gleichungssystem. &lt;math&gt;A&lt;/math&gt; sei die Koeffizientenmatrix, &lt;math&gt;x&lt;/math&gt; der Lösungsvektor und &lt;math&gt;b&lt;/math&gt; ein bekannter Vektor.

Beispiel:
 import numpy as np
 
 A = np.array([[5, 1], [0, 2]])
 b = np.array([1, 2])
 
 x = np.linalg.solve(A, b)
 
 print(x)

Ausgabe:
 [0. 1.]

Siehe dazu auch das Kapitel [[Ing Mathematik: Numerisches Lösen von linearen Gleichungssystemen]]. Dort wird dieses Themengebiet u.a. mit weitergehenden Python-Skripten vertieft.

== Aufgabe ==
* Lösen Sie folgendes Gleichungssystem mittels Python (und zur Kontrolle auch händisch): 
 5x + 6y - 2z = 12
 3x - y  - 3z = 6
 2x + 2y + 4z = 5

= Polynome =
== Ein erstes einfaches Beispiel ==
Gegeben sei das Polynom &lt;math&gt;7x^3+5x^2+1&lt;/math&gt;. In Python:

 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p)

Ausgabe:
    3     2
 7 x + 5 x + 1

== Einzelne Polynomwerte berechnen ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p(1.5))

Ausgabe:
 35.875

== Polynome integrieren und differenzieren ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 
 # 1. Ableitung
 p1 = p.deriv()
 p2 = p.deriv(1)
 
 # 2. Ableitung
 p3 = p.deriv(2)
 
 # Integral
 p4 = p.integ()
 
 print(p1)
 print(p2)
 print(p3)
 print(p4)

Ausgabe:
     2
 21 x + 10 x
     2
 21 x + 10 x
 
 42 x + 10
       4         3
 1.75 x + 1.667 x + 1 x

== Nullstellen bestimmen ==
 import numpy as np
 
 p = np.poly1d([2, 5, 0, 4])
 r = np.roots(p)
 
 print(r)

Ausgabe:
 [-2.7621427 +0.j          0.13107135+0.84077099j  0.13107135-0.84077099j]

== Aufgaben ==
* Berechnen Sie den Wert für x = 3 des Polynoms &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Differenzieren und integrieren Sie das Polynom &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Berechnen Sie die Nullstellen von &lt;math&gt;y = 7x^5 - 3x^2 + 12&lt;/math&gt;.

= Nichtlineare Gleichungen und Gleichungssysteme =
== Nullstellenbestimmung ==
Löse eine beliebige Gleichung f(x) = 0, z.B. &lt;math&gt; f(x) = x^2 - 5\cos(x) - 10 = 0 &lt;/math&gt;:
 import scipy
 import numpy as np
 
 def f(x):
     return x**2 - 5*np.cos(x) - 10
    
 xstart = [-1, 1]        # Startwerte
 xn = scipy.optimize.root(f, xstart)
 
 print(xn.x)

Ausgabe:
 [-2.46813009  2.46813009]

Funktionsgraph:

[[Datei:octave_nichtlin2.jpg]]

== Gleichungssysteme ==
SymPy ist ein externes Modul, das symbolisches Rechnen ('''Sym'''bolic '''Py'''thon) ermöglicht. 

Folgende Aufgabe ist dem Buch &quot;Knorrenschild: Numerische Mathematik, Hanser, 2017, Seite 72&quot; entnommen. Zu lösen ist das nichtlineare Gleichungssystem

&lt;math&gt;f_1 = 2x_1 + 4x_2 = 0 &lt;/math&gt;

&lt;math&gt;f_2 = 4x_1 + 8x_2^3 = 0&lt;/math&gt;

Mit Python ist das so möglich:
 import sympy
 
 x1, x2 = sympy.symbols(&quot;x1 x2&quot;) 
 
 f1 = 2*x1 + 4*x2
 f2 = 4*x1 + 8*x2**3
 
 s = sympy.solve((f1, f2), x1, x2) 
 
 print(s)

Ausgabe:
 [(-2, 1), (0, 0), (2, -1)]

Plot:

[[Datei:IngPython_nl_gleichung1.svg|500px]]

= Komplexe Zahlen =
Die imaginäre Einheit wird in Python durch den Buchstaben &lt;code&gt;j&lt;/code&gt; symbolisiert. Darstellen kann man eine komplexe Zahl bekannterweise in mehreren Formen:
* Kartesische Darstellung &lt;math&gt;z = \Re(z) + j \cdot \Im(z)&lt;/math&gt;
* Polardarstellungen &lt;math&gt;z = r \cdot (\cos(\phi) + j \cdot \sin(\phi)) = r \cdot e^{j\cdot \phi}&lt;/math&gt;

Die konjugiert komplexe Zahl ist &lt;math&gt;z^* = \Re(z) - j \cdot \Im(z)&lt;/math&gt;

Nachfolgend einige mathematische Operationen mit Python und NumPy.

 import numpy as np
 
 z1 = 2 + 5j           # kartesische Darstellung
 z2 = 3 * np.exp(3j)   # Polardarstellung
  
 # Addition
 res = z1 + z2
 print(&quot;z1 + z2 = &quot;, res)
 
 # Multiplikation
 res = z1 * z2
 print(&quot;z1 * z2 = &quot;, res)
 
 # Realteil
 res = np.real(z2)
 print(&quot;Realteil von z2 = &quot;, res)
 
 # Imaginärteil
 res = np.imag(z2)
 print(&quot;Imaginaerteil von z2 = &quot;, res)
 
 # Betrag
 res = np.abs(z1)
 print(&quot;Betrag von z1 = &quot;, res)
 
 # Argument
 res = np.angle(z1)
 print(&quot;Argument von z1 = &quot;, res)
 
 # Konjugiert komplexe Zahl
 res = np.conj(z1)
 print(&quot;Konjugiert komplexe Zahl von z1 = &quot;, res)

Ausgabe:
 z1 + z2 =  (-0.9699774898013365+5.423360024179601j)
 z1 * z2 =  (-8.05675510050068-14.003167400647481j)
 Realteil von z2 =  -2.9699774898013365
 Imaginaerteil von z2 =  0.4233600241796016
 Betrag von z1 =  5.385164807134504
 Argument von z1 =  1.1902899496825317
 Konjugiert komplexe Zahl von z1 =  (2-5j)

= Interpolation =
 import numpy as np
 import scipy
 import matplotlib.pyplot as plt
 
 # Stützpunkte
 xp = np.arange(1, 6)
 yp = (0, -5, 2, 7, 6)
 
 ti = np.arange(1, 5, 0.01)
 
 i1 = scipy.interpolate.interp1d(xp, yp, kind = &quot;linear&quot;)
 i2 = scipy.interpolate.interp1d(xp, yp, kind = &quot;cubic&quot;) 
 
 plt.plot(xp, yp, &quot;rx&quot;)
 plt.plot(xp, i1(xp))
 plt.plot(ti, i2(ti))
 plt.show()

Ausgabe:

[[Datei:PythonIng_interpol1.png]]

= Differenzialrechnung =
== Numerisches Differenzieren ==
Als Beispiel differenzieren wir &lt;math&gt;y = 5x\sin{x}&lt;/math&gt; und stellen das Ganze grafisch dar.

 from findiff import Diff
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.linspace(0, 10, 1000)
 f = 5 * x * np.sin(x)
 dx = x[1] - x[0]
 
 # Ableitung
 d_dx = Diff(0, dx)
 df_dx = d_dx(f)
 
 # Grafik
 plt.plot(x, f, label = &quot;y&quot;)
 plt.plot(x, df_dx, label = &quot;y'&quot;)
 plt.grid()
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

Ausgabe:

[[Datei:octave_diff1.jpg]]

&lt;small&gt;findiff ist ein externes Modul. Dieses muss installiert werden (z.B. so: ...\Python\Scripts\pip.exe install --upgrade findiff). Für die Vorgehensweise unter openSUSE Tumbleweed siehe das Kapitel [[Ing_Mathematik:_Python#Mit_VPython | VPython]], nur dass das Ganze mit einer aktuelleren Python-Version exekutiert wird, z.B. mit Python 3.13.  Das im Buch &quot;Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler, Rheinwerk&quot; verwendete Modul &quot;scipy.misc&quot; ist veraltet (deprecated ... missbilligt). Lt. [https://docs.scipy.org/doc/scipy-1.17.0/dev/roadmap-detailed.html#misc SciPy-Dokumentation für die Version 1.17.0] wurden alle entsprechenden Features schon entfernt.&lt;/small&gt;

== Symbolisches Differenzieren ==
Differenzieren Sie die Funktionen &lt;math&gt;f_1(x) = x^2&lt;/math&gt; und &lt;math&gt;f_2(x) = \sin(x)\cos\left(\frac{x}{2}\right)&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2;
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 d1 = sympy.diff(f1, x)
 d2 = sympy.diff(f2, x)
 
 print(d1)
 print(d2)

Ausgabe:
 2*x
 -0.5*sin(0.5*x)*sin(x) + cos(0.5*x)*cos(x)

== Aufgaben ==
* Differenzieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.
* Differenzieren Sie die Funktion &lt;math&gt;y = \frac{\sinh(x)}{(1+x)}&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.

= Integralrechnung =
== Numerisches Integrieren ==
Berechnen Sie das Integral &lt;math&gt;\int_{0}^{3}x^2 dx&lt;/math&gt;.

 import scipy
 
 def f(x):
     return x**2
    
 i = scipy.integrate.quad(f, 0, 3)
 print(i)

Ausgabe:
 (9.000000000000002, 9.992007221626411e-14)

Das trifft den exakten Wert 9.0 ziemlich genau.

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} dx&lt;/math&gt;.

 import scipy
 import numpy as np
 
 def f(x):
     return 2**(-x)
   
 i = scipy.integrate.quad(f, 0, np.inf)
 print(i)

Ausgabe:
 (1.4426950408889556, 4.486558477977586e-09)

== Symbolisches Integrieren ==
Berechnen Sie &lt;math&gt;\int x^2 \text{d}x&lt;/math&gt; und &lt;math&gt;\int \sin{x}\cos{\frac{x}{2}} \text{d}x&lt;/math&gt;.
 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 i1 = sympy.integrate(f1, x)
 i2 = sympy.integrate(f2, x)
 
 print(i1)
 print(i2)

Ausgabe:
 x**3/3
 -0.666666666666667*sin(0.5*x)*sin(x) - 1.33333333333333*cos(0.5*x)*cos(x)

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} \text{d}x&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f = 2**(-x)
 i = sympy.integrate(f, (x, 0, sympy.oo))
 print(i)

Ausgabe:
 1/log(2)

&lt;code&gt;sympy.oo&lt;/code&gt; steht für das {{W|Unendlichzeichen}} &lt;math&gt;\infty&lt;/math&gt; (die liegende Acht oder das Möbiusband). Mit &lt;code&gt;sympy.pprint(i)&lt;/code&gt; ließe sich letzere Ausgabe etwas schöner schreiben:

   1   
 ──────
 log(2)

Man beachtete, &lt;code&gt;log&lt;/code&gt; steht hier für den natürlichen Logarithmus &lt;code&gt;ln&lt;/code&gt;.

== Aufgaben ==
* Integrieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; von 1 bis 5.
* Integrieren Sie die Funktion &lt;math&gt;y = x^3&lt;/math&gt; von 0 bis 4.
* Integrieren Sie &lt;math&gt;\int x^x(\log (x) + 1)\mathrm dx&lt;/math&gt; symbolisch.

= Gewöhnliche Differenzialgleichungen =
== DGL numerisch lösen ==
Für die Lösung von Differenzialgleichungen steht u.a. die Funktion scipy.integrate.solve_ivp() zur Verfügung. Diese Funktion implementiert auch das Runge-Kutta-Verfahren (RK45).

{{Wikipedia | Runge-Kutta-Verfahren}}

Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import scipy
 import numpy as np
 import matplotlib.pyplot as plt
 
 def dy_dx(x, y):
     return x**2 + y**3
 
 y0 = [1]
 xi = [0, 1]
 x = np.arange(0, 1, 0.01)
 
 z = scipy.integrate.solve_ivp(dy_dx, xi, y0, method=&quot;RK45&quot;, dense_output=True)
 y = z.sol(x)
 
 plt.plot(x, y.T)
 plt.grid()
 plt.show()

[[Datei:PythonIng_dgl1.png]]

== DGL symbolisch lösen ==
Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 print(lsg)

Ausgabe:
 [Eq(f(x), (-x**2)**(1/3)), Eq(f(x), (-x**2)**(1/3)*(-1 - sqrt(3)*I)/2), Eq(f(x), (-x**2)**(1/3)*(-1 + sqrt(3)*I)/2)]

Mit &lt;code&gt;sympy.pprint&lt;/code&gt; (pretty print) lässt sich die Ausgabe etwas übersichtlicher darstellen.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 sympy.pprint(lsg)

Ausgabe:
 ⎡                           _____                        _____            ⎤
 ⎢          _____         3 ╱   2                      3 ╱   2             ⎥
 ⎢       3 ╱   2          ╲╱  -x  ⋅(-1 - √3⋅ⅈ)         ╲╱  -x  ⋅(-1 + √3⋅ⅈ)⎥
 ⎢f(x) = ╲╱  -x  , f(x) = ────────────────────, f(x) = ────────────────────⎥
 ⎣                                 2                            2          ⎦

== Aufgaben ==
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \frac{1}{x\cdot y}&lt;/math&gt; mit Python. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;m' = -k\cdot m&lt;/math&gt;. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \sqrt{|y|}&lt;/math&gt;.

=Laplace-Transformation=
Laplace-Transformation:

&lt;math&gt;F(s) =\mathcal{L} \left\{f\right\}(s) = \int_{0}^{\infty} f(t) \mathrm e^{-st} \,\mathrm{d}t, \qquad s\in\mathbb{C}
&lt;/math&gt;

Inverse Laplace-Transformation:

&lt;math&gt;\mathcal{L}^{-1} \left\{F\right\}(t)
  = \frac{1}{2 \pi \mathrm j} \int_{ \gamma - \mathrm j \infty}^{ \gamma + \mathrm j \infty} \mathrm e^{st} F(s)\,\mathrm ds 
= \begin{cases}
      f(t) &amp; \text{für } t \geq 0 \\
      0    &amp; \text{für } t &lt; 0
    \end{cases}
&lt;/math&gt;

Siehe auch [[Ing_Mathematik:_Laplace-Transformation]]

Code:
 import sympy
 from sympy.abc import t, s
 
 # Laplace-Transformation der Funktion f(t) = 1 (Heaviside-Fkt.)
 f = 1
 # alternativ: f = sympy.Heaviside(t)
 F = sympy.laplace_transform(f, t, s, noconds=True)
 print(&quot;Laplace-Transformierte F(s):&quot;, F) 
 
 # Inverse Laplace-Transformation zurück in den Zeitbereich
 f_inv = sympy.inverse_laplace_transform(F, s, t)
 print(&quot;Inverse Transformation f(t):&quot;, f_inv)

Ausgabe:
 Laplace-Transformierte F(s): 1/s
 Inverse Transformation f(t): Heaviside(t)

Die Zeile

 from sympy.abc import t, s

steht alternativ für

 t = sympy.symbols(&quot;t&quot;)
 s = sympy.symbols(&quot;s&quot;)

&lt;u&gt;Aufgaben&lt;/u&gt;: Ermitteln Sie mittels SymPy die &lt;math&gt;\mathcal{L}&lt;/math&gt;-Transformierten und dann wieder die  &lt;math&gt;\mathcal{L}^{-1}&lt;/math&gt;-Transformationen (ähnlich wie beim obigen Beispiel):
* &lt;math&gt;\sin(t) \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;t^3 \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;\text{e}^{\omega t} \circ\! -\! \bullet \ ?&lt;/math&gt;

=Fourier-Reihen=
&lt;math&gt;
f(x)\approx \frac{a_{0}}{2}+\sum_{k=1}^{\infty}\left(a_{k}\cos\left(kx\right)+b_{k}\sin\left(kx\right)\right)
&lt;/math&gt;

&lt;math&gt;
a_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\cos\left(kx\right)\mathrm dx\quad\text{für }k\geq0
&lt;/math&gt;

&lt;math&gt;
b_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\sin\left(kx\right)\mathrm dx\quad\text{für }k\geq1
&lt;/math&gt;

Für die Sägezahnfunktion &lt;math&gt;y=x;\, 0 &lt; x &lt; 2\pi&lt;/math&gt; sei die Fourierreihe mit einem Python-Programm (unter Mithilfe von sympy) hergeleitet.

Code:

 from sympy import fourier_series, pi, symbols, pprint
 
 x = symbols('x')
 f = x
 s = fourier_series(f, (x, 0, 2*pi))
 pprint(s.truncate(n=4))

Ausgabe:

                        2⋅sin(3⋅x)    
 -2⋅sin(x) - sin(2⋅x) - ────────── + π
                            3

Siehe auch [[Ing Mathematik: Fourierreihen]].

Ein komplizierteres Beispiel:

[[Datei:IngMath fourier bsp13.svg | 300px]]

&lt;math&gt;0\le t &lt; T/2\text{:}\quad f(t) = H&lt;/math&gt;

&lt;math&gt;T/2 \le t \le T\text{:}\quad f(t) = \frac{2H}{T}\left( t-\frac{T}{2}\right)&lt;/math&gt;

Code:

 import sympy as sp
 
 H = sp.Symbol('H', positive=True)
 T = sp.Symbol('T', positive=True)
 t = sp.Symbol('t')
 
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T/2)),
     (2*H/T*(t-T/2), (t &gt; T/2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Ausgabe:

      ⎛2⋅π⋅t⎞        ⎛4⋅π⋅t⎞        ⎛6⋅π⋅t⎞          ⎛2⋅π⋅t⎞          ⎛6⋅π⋅t⎞      
 H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   2⋅H⋅cos⎜─────⎟   2⋅H⋅cos⎜─────⎟      
      ⎝  T  ⎠        ⎝  T  ⎠        ⎝  T  ⎠          ⎝  T  ⎠          ⎝  T  ⎠   3⋅H
 ──────────── - ──────────── + ──────────── + ────────────── + ────────────── + ───
      π             2⋅π            3⋅π               2                 2         4 
                                                    π               9⋅π

=Rechnen mit wirklich großen Zahlen=
Bekannt ist, dass Python kaum Einschränkungen beim Wertebereich von Ganzzahlen hat, z.B.

 print(10**300)

Ausgabe (gekürzt):

 100000000000000000000...00000000000000000000000000000000000000000000000000000000000000000000000

Ähnliches geht auch mit Gleitpunktzahlen, z.B. durch die Verwendung des Moduls [https://mpmath.org/ mpmath]:

 import mpmath
 print(mpmath.mpf(1500.4)**mpmath.mpf(300))

Ausgabe:

 7.27975299218612e+952

Anderes Beispiel:

 from mpmath import mp, pi
 mp.dps = 100
 print(pi)

Ausgabe:

 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068

mpmath kann noch einiges mehr, dazu sei aber auf die entsprechende Dokumentation auf der mpmath-Homepage verwiesen. mpmath ist Bestandteil von SymPy, kann aber auch separat installiert werden.

Aber auch Python selbst besitzt eine Möglichkeit, um mit großen bzw. exakten Gleitpunktzahlen zu rechnen, nämlich das interne Modul decimal. Dieses hat einige Vorteile gegenüber mpmath, aber auch gravierende Nachteile. Diese seien hier nicht detailliert aufgezählt. Grob gesagt hat decimal im Finanzwesen seine Berechtigung. Für wissenschaftliche Anwendungen wird aber mpmath vorzuziehen sein, da es u.a. vielfältige mathematische Funktionen bereit stellt. Nachfolgend ein einfaches Beispiel mit decimal:

 import decimal
 print(&quot;Potenzierung:&quot;, decimal.Decimal(1500.4) ** decimal.Decimal(300.0))
 print(&quot;Einfache Addition:&quot;, 0.1 + 0.2)
 decimal.getcontext().prec = 50
 print(&quot;Addition mit decimal:&quot;, decimal.Decimal(&quot;0.1&quot;) + decimal.Decimal(&quot;0.2&quot;))

Ausgabe:

 Potenzierung: 7.279752992186121551039839134E+952
 Einfache Addition: 0.30000000000000004
 Addition mit decimal: 0.3

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet die genauen Vor- und Nachteile von decimal und mpmath. Verwenden Sie dazu auch KI (z.B. von Google, chatgpt).

= pint - mit physikalischen Größen rechnen = 
[[File:Pint-Glas_UK.jpg|right|100px]]
pint ist ein externes Python-Paket zur Manipulation von physikalischen Einheiten. Es muss vor der ersten Benutzung installiert werden (Vorgehensweise wie immer: pip, YaST, via venv etc.).

Beispiel:

 import pint
 import numpy as np
 
 ureg = pint.UnitRegistry()
 
 # Einfache Berechnung
 print(3 * ureg.meter + 4 * ureg.cm)
 
 # Mit NumPy
 npeinzel = [3, 4] * ureg.meter + [2, 5] * ureg.cm
 print(npeinzel)
 npsum = np.sum(npeinzel)
 print(npsum)
 
 # Konvertierung von Einheiten
 npsum_inch = npsum.to(ureg.inch)
 print(npsum_inch)
 
 print(npeinzel.magnitude)
 print(npeinzel.units)
 print(npeinzel.dimensionality)

Ausgabe:

 3.04 meter
 [3.02 4.05] meter
 7.07 meter
 278.3464566929134 inch
 [3.02 4.05]
 meter
 [length]

Die Dokumentation zu pint findet sich auf [https://pint.readthedocs.io/en/stable/].

=Regelungstechnische Aufgabenstellungen=
Für regelungstechnische Aufgaben gibt es u.a. das externe Paket &lt;code&gt;control&lt;/code&gt;. Hier soll nicht detailliert darauf eingegangen werden. Anhand eines Beispiels soll anschließend nur die Visualisierung in Form eines Bode-Diagramms und der Sprungantwort gezeigt werden. Gegeben sei ein P-Regler mit &lt;math&gt;R = \frac{5}{2}&lt;/math&gt; und eine Strecke &lt;math&gt;S= \frac{1}{30s^3+20s^2+10s+1,5}&lt;/math&gt;. Gesucht sei vorerst ein Bode-Diagramm für den offenen Regelkreis und das Führungsverhalten.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke  # oder: G0 = ct.series(regler, strecke)
 Gw = ct.feedback(G0)
 
 ct.bode_plot(G0, label='G0')
 ct.bode_plot(Gw, label='Gw')
 plt.show()

[[Datei:PythonIng_bode1.svg]]

Nun noch für obiges Beispiel die Sprungantwort. Diese zeigt einige große Überschwinger, d.h. der Regler kann sicher noch optimiert werden.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke 
 Gw = ct.feedback(G0) 
 
 t, y = ct.step_response(Gw)
 
 plt.plot(t,y)
 plt.title('Sprungantwort')
 plt.xlabel('t')
 plt.ylabel('h(t)')
 plt.grid()
 plt.show()

[[Datei:PythonIng_bode3.svg]]

Einige weitere wichtige Daten (Phasenreserve, Amplitudenreserve, Durchtrittsfrequenz) lassen sich mittels der &lt;code&gt;control&lt;/code&gt;-Funktion &lt;code&gt;margin()&lt;/code&gt; ermitteln. Die Ortskurve lässt sich mit der Funktion &lt;code&gt;nyquist_plot()&lt;/code&gt; zeichnen. Dies sei hier aber nicht weiter ausgeführt.

==Aufgaben==
* Zeichen Sie mit Python die Ortskurve für obiges Beispiel.
* Was passiert, wenn man die Reglerverstärkung weiter aufdreht (z.B. auf &lt;math&gt;R = \frac{25}{2}&lt;/math&gt;)?
* Wie sehen das Bode-Diagramm und die Sprungantwort aus, wenn ein PI-Regler verwendet wird?

= Stereostatik etc. =
Das Modul SymPy bietet einige Möglichkeiten einfache Bauwerke zu berechnen, z.B. Balken oder Fachwerke. Nachfolgend wird ein einfaches Fachwerk berechnet und gezeichnet.

Python-Code:
 from sympy.physics.continuum_mechanics.truss import Truss 
 
 t = Truss()
 # Knoten
 t.add_node((&quot;A&quot;, -3, 0), (&quot;B&quot;, 0, 0), (&quot;C&quot;, 4, 0), (&quot;D&quot;, 7, 0),
            (&quot;E&quot;, 6, 1.5), (&quot;F&quot;, 2, 3), (&quot;G&quot;, -2, 1.5))
 # Stäbe
 t.add_member((&quot;AB&quot;,&quot;A&quot;,&quot;B&quot;), (&quot;BC&quot;,&quot;B&quot;,&quot;C&quot;), (&quot;CD&quot;,&quot;C&quot;,&quot;D&quot;))
 t.add_member((&quot;AG&quot;,&quot;A&quot;,&quot;G&quot;), (&quot;GB&quot;,&quot;G&quot;,&quot;B&quot;), (&quot;GF&quot;,&quot;G&quot;,&quot;F&quot;))
 t.add_member((&quot;BF&quot;,&quot;B&quot;,&quot;F&quot;), (&quot;FC&quot;,&quot;F&quot;,&quot;C&quot;), (&quot;CE&quot;,&quot;C&quot;,&quot;E&quot;))
 t.add_member((&quot;FE&quot;,&quot;F&quot;,&quot;E&quot;), (&quot;DE&quot;,&quot;D&quot;,&quot;E&quot;))
 # Auflager; roller ... Loslager, pinned ... Festlager
 t.apply_support((&quot;A&quot;,&quot;roller&quot;), (&quot;D&quot;,&quot;pinned&quot;))
 # Einwirkende Kräfte
 t.apply_load((&quot;G&quot;, 5, 270), (&quot;E&quot;, 3, 90))
 
 # Berechnung 
 t.solve()
 print(&quot;Reaction Forces: &quot;, t.reaction_loads)
 print(&quot;Internal Forces: &quot;, t.internal_forces)
 
 # Fachwerk zeichnen
 p = t.draw()
 p.show()

Ausgabe auf der Konsole:

 Reaction Forces:  {'R_A_y': 4.20000000000000, 'R_D_x': 0, 'R_D_y': -2.20000000000000}
 Internal Forces:  {'AB': 2.80000000000000, 'BC': 0.333333333333333, 'CD': -1.46666666666667, 
 'AG': -5.04777178564958, 'GB': -2.05555555555556, 'GF': -1.23413387432364, 
 'BF': 0.411111111111111*sqrt(13), 'FC': -0.3*sqrt(13), 'CE': 1.50000000000000, 
 'FE': 0.284800124843917, 'DE': 2.64407093534026}

Zeichnung:

[[File:PythonIng_fachwerk1.svg|300px]]

Details zu diesem Thema siehe z.B. [https://docs.sympy.org/latest/modules/physics/continuum_mechanics/index.html Continuum Mechanics] oder [https://docs.sympy.org/latest/tutorials/physics/continuum_mechanics/index.html Continuum Mechanics Tutorials]. Auch andere mechanische Probleme werden von SymPy abgehandelt ([https://docs.sympy.org/latest/tutorials/physics/index.html Physics Tutorials]).

== Aufgabe ==
Gegeben sei ein einseitig eingespannter Kragträger. Belastet wird er durch eine Einzellast am Trägerende. Für die Daten siehe folgende ASCII-Skizze:

                            | 20 kN  
    //|---&gt; x               |
    //|                     V
    //|----------------------
    //|         10 m        |
 
 Elastizitätsmodul E = 2,1*10⁵ N/mm²
 Flächenträgheitsmoment I = 0.001 m⁴

Berechnen Sie die Auflagerreaktionen, den Querkraft- und Biegemomentenverlauf, sowie die Verformungen.
Stellen Sie dies mit Hilfe von SymPy graphisch und auch mittels Formeln dar. Verwenden Sie dazu auch pprint (pretty print) aus dem SymPy-Modul. Zwecks Lösungsansatz siehe die oben aufgeführte Seite &quot;Continuum Mechanics Tutorials&quot;. Achten Sie auch auf die Einheiten! Kontrollieren Sie das Ganze mittels händischer Rechnung. In dem genannten Tutorial ist von &quot;Singularity Functions&quot; die Rede. Gemeint ist damit in diesem Kontext die {{W|Föppl-Klammer}}.

Einige Python-Programme, vorrangig zu Maschinenelementen, finden sich auf [https://baymp.de/download_python.html BayMP für Python] (Balken, Zahnräder, Stabknickung usw.).

=Thermodynamik= 
== PYroMat ==
Für thermodynamische Aufgabenstellungen gibt es verschiedene externe Module. Eines davon ist PYroMat (siehe auch [http://pyromat.org]). Damit lassen sich thermodynamische Stoffdaten für viele Substanzen berechnen.

Beispiel (einige Stoffdaten für Wasser bei 400°C und 20 bar berechnen):

 import pyromat as pm
 
 # Wasserdaten laden:
 H2O = pm.get('mp.H2O')
 
 # Stoffdaten berechnen:
 T = 673.15  # Temperatur in Kelvin
 p = 20      # Druck in bar
 v = H2O.v(T, p)
 h = H2O.h(T, p)
 s = H2O.s(T, p)
 print(f&quot;Spezifisches Volumen: {v} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {h} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {s} kJ/(kg K)&quot;)

Ausgabe:

 Spezifisches Volumen: [0.1512163] m³/kg
 Spezifische Enthalpie: [3248.3789473] kJ/kg
 Spezifische Entropie: [7.12924142] kJ/(kg K)

&lt;small&gt;
PYroMat muss vorab installiert werden (z.B. mittels pip, in eine virtuelle Umgebung)
&lt;/small&gt;

&lt;code&gt;mp&lt;/code&gt; steht für &quot;multi phase&quot;. Für ein ideales Gas wäre &lt;code&gt;ig&lt;/code&gt; zuständig, z.B. &lt;code&gt;'ig.O2'&lt;/code&gt;.

Beispiel (T-s-Diagramm für Wasser zeichnen):
 import numpy as np
 import matplotlib.pyplot as plt
 import pyromat as pm
 
 # Konfigurieren
 pm.config[&quot;unit_pressure&quot;] = &quot;bar&quot;
 pm.config[&quot;unit_temperature&quot;] = &quot;K&quot;
 fluid = pm.get(&quot;mp.H2O&quot;)
 
 # Temperaturbereich für das Nassdampfgebiet
 T_tripel = 273.16
 T_crit = 647.096
 T = np.linspace(T_tripel, T_crit - 0.1, 200)
 
 # Sättigungslinien berechnen und zeichnen
 for x in np.linspace(0.0, 1.0, 5):
     s = fluid.s(T=T, x=x)
     if(x&lt;=0.0):
         plt.plot(s, T, label=&quot;Siedelinie x=%3.1f&quot; % x, linewidth=2.0)
     elif(x&gt;=1.0):
         plt.plot(s, T, label=&quot;Taulinie x=%3.1f&quot; % x, linewidth=2.0)
     else:
         plt.plot(s, T, label=&quot;x=%3.1f&quot; % x, linewidth=1.0)
 
 # Isobaren zeichnen
 p_values = [0.1, 1, 10, 50, 100]
 T_isobar = np.linspace(T_tripel, 1000, 200)
 t = 0.7
 
 for p in p_values:
     s_iso = fluid.s(T=T_isobar, p=p)
     plt.plot(s_iso, T_isobar, 'k-', alpha=0.8, linewidth=0.8)
 
     t += .05
     idx = int(len(s_iso) * t)
     plt.text(s_iso[idx], T_isobar[idx], f&quot;{p} bar&quot;, fontsize=9, alpha=0.8)
 
 # Diagramm zeichnen
 plt.title(&quot;T-s-Diagramm für Wasser&quot;)
 plt.xlabel(&quot;Spezifische Entropie s in kJ/kg K&quot;, fontsize=10)
 plt.ylabel(&quot;Temperatur T in K&quot;, fontsize=10)
 plt.legend(loc=&quot;best&quot;)
 plt.grid(True)
 plt.show()

Ausgabe (in etwa so):

[[Datei:T-s-Diagramm fuer Wasser.svg|400px]]

== CoolProp ==
Auch mit CoolProp können Stoffdaten berechnet werden. Siehe auch [https://coolprop.org/coolprop/wrappers/Python/index.html]

Beispiel (Wasser bei 20bar und 400°C):
 import CoolProp.CoolProp as CP
 
 fluid = 'Water'
 T = 673.15   # Temperatur in Kelvin
 P = 20e5     # Druck in Pascal
 
 dichte = CP.PropsSI('D', 'T', T, 'P', P, fluid)
 enthalpie = CP.PropsSI('H', 'T', T, 'P', P, fluid)
 entropie = CP.PropsSI('S', 'T', T, 'P', P, fluid)
 
 print(f&quot;Spez. Volumen: {1/dichte:.6f} m³/kg&quot;)
 print(f&quot;Spez. Enthalpie: {enthalpie:.2f} J/kg&quot;)
 print(f&quot;Spez. Entropie: {entropie:.2f} J/kgK&quot;)

Ausgabe:
 Spez. Volumen: 0.151215 m³/kg
 Spez. Enthalpie: 3248344.02 J/kg
 Spez. Entropie: 7129.16 J/kgK

== iapws ==
Um Werte für Wasser(dampf) zu erhalten (IAPWS; '''I'''nternational '''A'''ssociation for the '''P'''roperties of '''W'''ater and '''S'''team) gibt es die Bibliothek iapws. Siehe auch [https://iapws.org/] und [https://pypi.org/project/iapws/]

Beispiel (Wasser für 20bar und 400°C):
 from iapws import IAPWS97
 
 dampf = IAPWS97(P=2.0, T=673.15)
 
 print(f&quot;Spezifisches Volumen: {dampf.v:.6f} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {dampf.h:.2f} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {dampf.s:.4f} kJ/(kgK)&quot;)
 print(f&quot;Phase: {dampf.phase}&quot;)

Ausgabe:
 Spezifisches Volumen: 0.151208 m³/kg
 Spezifische Enthalpie: 3248.23 kJ/kg
 Spezifische Entropie: 7.1290 kJ/(kgK)
 Phase: Gas

== TESPy ==
Ein anderes Modul für einen anderen Aufgabenzweck ist TESPy ('''T'''hermal '''E'''ngineering '''S'''ystems in '''Py'''thon). Dieses Modul ist für die Anlagensimulation zuständig. Für nähere Informationen siehe [https://tespy.readthedocs.io/en/main/getting_started/introduction.html]. Als Beipiel sei hier vorerst Code, der von der Google KI generiert wurde, angeführt. Der Code wurde überarbeitet, damit keine Warnungen auftreten. Bitte aber den Code trotzdem mit Vorsicht genießen, auch KI-generierter Code kann Fehler aufweisen. Eine Pumpe wird berechnet:

 from tespy.components import Sink, Source, Pump
 from tespy.connections import Connection
 from tespy.networks import Network
 
 # 1. Netzwerk definieren (Zentrales Steuerungselement)
 # Wir wählen Wasser als Fluid und bar/Celsius als Einheiten
 nw = Network(fluids=[&quot;water&quot;])
 nw.units.set_defaults(pressure=&quot;bar&quot;, pressure_difference=&quot;bar&quot;, 
                       temperature=&quot;°C&quot;, enthalpy=&quot;kJ / kg&quot;)
 
 # 2. Komponenten erstellen
 eingang = Source(&quot;Wasserquelle&quot;)
 ausgang = Sink(&quot;Wasserspeicher&quot;)
 pumpe = Pump(&quot;Speisewasserpumpe&quot;)
 
 # 3. Verbindungen definieren (Komponenten miteinander verknüpfen)
 c1 = Connection(eingang, &quot;out1&quot;, pumpe, &quot;in1&quot;)
 c2 = Connection(pumpe, &quot;out1&quot;, ausgang, &quot;in1&quot;)
 
 # Verbindungen dem Netzwerk hinzufügen
 nw.add_conns(c1, c2)
 
 # 4. Randbedingungen und Parameter festlegen
 # Zustand am Eingang (Druck, Temperatur, Massenstrom, Fluid-Zusammensetzung)
 c1.set_attr(
     v=1,  # Massenstrom: 1 kg/s
     T=20,  # Temperatur: 20 °C
     p=1,  # Druck: 1 bar
     fluid={&quot;water&quot;: 1},  # 100% Wasser
 )
 
 # Zustand am Ausgang / Zielwerte der Pumpe
 c2.set_attr(p=10)  # Ziel-Druck nach der Pumpe: 10 bar
 
 # Pumpeneigenschaften festlegen
 pumpe.set_attr(eta_s=0.8)  # Isentroper Wirkungsgrad von 80%
 
 # 5. Simulation ausführen
 nw.solve(mode=&quot;design&quot;)
 
 # 6. Ergebnisse ausgeben
 nw.print_results()
 
 # Spezifische Werte direkt auslesen
 print(&quot;\n--- Auswertung ---&quot;)
 print(f&quot;Erforderliche Pumpenleistung: {pumpe.P.val / 1000:.2f} kW&quot;)
 print(f&quot;Temperatur nach der Pumpe: {c2.T.val:.2f} °C&quot;)

Ausgabe (gekürzt):
  iter  | residual   | progress   | massflow   | pressure   | enthalpy   | fluid      | component  
 -------+------------+------------+------------+------------+------------+------------+------------
  1     | 7.04e+04   | 12 %       | 9.96e+02   | 0.00e+00   | 8.81e+04   | 0.00e+00   | 0.00e+00   
  2     | 5.91e-12   | 100 %      | 1.11e-13   | 0.00e+00   | 7.39e-12   | 0.00e+00   | 0.00e+00   
  3     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
  4     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
 Total iterations: 4, Calculation time: 0.01 s, Iterations per second: 480.85
 
 ##### RESULTS (Pump) #####
 +-------------------+----------+----------+-----------+----------+----------+----------+
 |                   |        P |       pr |        dp |      eta |    eta_s |     head |
 |-------------------+----------+----------+-----------+----------+----------+----------|
 | Speisewasserpumpe | 1.12e+06 | 1.00e+01 | -9.00e+00 | 8.00e-01 | 8.00e-01 | 9.19e+01 |
 +-------------------+----------+----------+-----------+----------+----------+----------+
 ...
 ...
 --- Auswertung ---
 Erforderliche Pumpenleistung: 1124.77 kW
 Temperatur nach der Pumpe: 20.07 °C

= Stochastik =
Die {{W|Stochastik}} ist ein sehr weites Feld. Hier werden etliche wichtige Themen kurz angerissen. Python stellt mit den Moduln math und statistics Software zu diesem Zwecke bereit. math und statistics sind bereits im Lieferumfang von Python enthalten. Aber auch mit den externen Modulen NumPy, SciPy, stochastic und pandas kann man Stochastik in Python betreiben. Die Theorie der Wahrscheinlichkeitsrechnung und Statistik soll etwas später in Band 5 dieser Buchreihe behandelt werden.

== Lageparameter == 
 import statistics
 
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 
 m1 = statistics.mean(werte)
 m2 = statistics.mode(werte)
 m3 = statistics.median(werte)
 
 print(&quot;Arithmetischer Mittelwert = &quot;, m1)
 print(&quot;Modalwert = &quot;, m2)
 print(&quot;Median = &quot;, m3)

Ausgabe:
 Arithmetischer Mittelwert =  3.5
 Modalwert =  1
 Median =  3.0

== Streuungsparameter ==
Beispiel (Berechnung der Standardabweichung):
 import statistics
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 s = statistics.stdev(werte)
 print(&quot;Standardabweichung = &quot;, s)

Ausgabe:
 Standardabweichung =  2.6770630673681683

Beispiel (Berechnung des Variationskoeffizienten V = Standardabweichung/Mittelwert)
 import numpy as np
 from scipy import stats
 import statistics
 
 k = 50
 
 dat1 = [14, 21, 18, 25, 30, 17, 20]
 dat = np.array(dat1)
 
 # Mit SciPy
 v = stats.variation(dat)
 vddof = stats.variation(dat, ddof=1)
 print(&quot;V SciPy: &quot;, v)
 print(&quot;V DDOF SciPy: &quot;, vddof)
 print(k*&quot;-&quot;)
 
 # mit NumPy
 mittelwert1 = np.mean(dat)
 std_abw1 = np.std(dat)
 std_abw1ddof = np.std(dat, ddof=1) 
 v1= std_abw1 / mittelwert1
 v1ddof = std_abw1ddof / mittelwert1
 print(&quot;Mittelwert NumPy: &quot;, mittelwert1)
 print(&quot;Std.abw. NumPy: &quot;, std_abw1)
 print(&quot;Std.abw. DDOF NumPy: &quot;, std_abw1ddof)
 print(&quot;V NumPy: &quot;, v1)
 print(&quot;V DDOF NumPy: &quot;, v1ddof)
 print(k*&quot;-&quot;)
 
 # nur mit reinem Python
 mittelwert2 = statistics.mean(dat1)
 std_abw2 = statistics.stdev(dat1)
 v2 = std_abw2 / mittelwert2
 print(&quot;Mittelwert Python: &quot;, mittelwert2)
 print(&quot;Std.abw. Python: &quot;, std_abw2)
 print(&quot;V Python:&quot;, v2)
 print(k*&quot;-&quot;)

Ausgabe:
 V SciPy:  0.23890355966467272
 V DDOF SciPy:  0.25804533701889254
 --------------------------------------------------
 Mittelwert NumPy:  20.714285714285715
 Std.abw. NumPy:  4.948716593053935
 Std.abw. DDOF NumPy:  5.3452248382484875
 V NumPy:  0.23890355966467272
 V DDOF NumPy:  0.2580453370188925
 --------------------------------------------------
 Mittelwert Python:  20.714285714285715
 Std.abw. Python:  5.3452248382484875
 V Python: 0.2580453370188925
 --------------------------------------------------

Der Unterschied bei der Standardabweichung zwischen reinem Python und den externen Bibliotheken SciPy und NumPy entsteht dadurch, dass einmal durch (n-1) und das andere Mal nur durch n dividiert wird. Dies kann bei NumPy und SciPy dadurch entschärft werden, indem &lt;code&gt;ddof=1&lt;/code&gt; gesetzt wird. ddof steht für '''D'''elta '''D'''egrees '''o'''f '''F'''reedom. &lt;small&gt;Je größer die Anzahl der Datensätze n wird, umso weniger spielt das eine Rolle.&lt;/small&gt;

== Kombinatorik ==
Beispiel:

 import math
 
 n = 7
 k = 5
 
 print(&quot;n! = &quot;, math.factorial(n))
 print(&quot;Kombinationen (n über k) = &quot;, math.comb(n, k))

Ausgabe:
 n! =  5040
 Kombinationen (n über k) =  21

Siehe zu diesem Thema auch [[Ing Mathematik: Permutationen, Kombinationen, binomischer Lehrsatz]]. Die Anzahlen lassen sich einfach aus den dortigen Formeln ermitteln, z.B. bei Permutationen mit &lt;math&gt;n!&lt;/math&gt; oder Variationen mit Wiederholungen als &lt;math&gt;n^k&lt;/math&gt;. Will man die Kombinationen oder Variationen aber auch als Liste ausgeben, so kann das Modul &lt;code&gt;itertools&lt;/code&gt; nützlich sein.  

Beispiel (Variationen ohne Wiederholung):

 from itertools import permutations
 
 menge = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]  # n = 4
 k = 3
 
 variationen = list(permutations(menge, k))
 
 for v in variationen:
     print(&quot;&quot;.join(v))
 
 print(50*&quot;-&quot;)
 print(len(variationen))

Ausgabe (gekürzt):
 ABC
 ABD
 ACB
 ...
 DCA
 DCB
 --------------------------------------------------
 24

Siehe zum Modul &lt;code&gt;itertools&lt;/code&gt; auch die Website [https://docs.python.org/3/library/itertools.html].

* Variationen mit Wiederholung: &lt;code&gt;itertools.product()&lt;/code&gt;
* Kombinationen ohne Wiederholung: &lt;code&gt;itertools.combinations()&lt;/code&gt;
* Kombinationen mit Wiederholung: &lt;code&gt;itertools.combinations_with_replacement()&lt;/code&gt;

== Zufallszahlen ==
Beispiel:
 import random
 
 # Ganzzahlige Zufallszahl von 1 bis 10
 zufallszahl1 = random.randint(1, 10)
 
 # Gleitpunktzahlen
 # zwischen 0.0 und 1.0
 zufallszahl2 = random.random()
 # Zahl zwischen 1.5 und 9.5
 zufallszahl3 = random.uniform(1.5, 9.5)
 
 # aus Liste auswählen
 farbe = [&quot;Rot&quot;, &quot;Grün&quot;, &quot;Blau&quot;]
 zufallswert = random.choice(farbe)
 
 print(zufallszahl1)
 print(zufallszahl2)
 print(zufallszahl3)
 print(zufallswert)

Ausgabe, z.B.:
 5
 0.14147945849015753
 6.894003397570905
 Rot

Benötigt man mehrere Zufallszahlen, so ist das Modul &lt;code&gt;numpy&lt;/code&gt; zu bevorzugen, z.B.:
* Normalverteilung: &lt;code&gt;np.random.normal(...)&lt;/code&gt;
* Gleichverteilung: &lt;code&gt;np.random.uniform(...)&lt;/code&gt;

== Histogramm ==
Zum Thema Histogramm siehe {{W|Histogramm}}.

Beispiel (mit Matplotlib):

 import matplotlib.pyplot as plt
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 
 plt.hist(daten, bins=25, edgecolor='darkgray')
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm.svg|300px]]

Beispiel (mit Seaborn):

 import matplotlib.pyplot as plt
 import seaborn as sns
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 sns.set_theme(style=&quot;darkgrid&quot;)
 sns.histplot(data=daten)
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm2.svg|300px]]

Das Kürzel &lt;code&gt;sns&lt;/code&gt; ist Konvention und steht für die fiktive Figur '''S'''amuel '''N'''orman '''S'''eaborn aus der US-Fernsehserie {{W|The West Wing – Im Zentrum der Macht | The West Wing}}.

== Box-Plot ==
[[File:Elements of a boxplot.svg|400px]]

Siehe auch {{W|Box-Plot}}.

Beispiel (mit Seaborn erstellt):
 import seaborn as sns
 import matplotlib.pyplot as plt
 
 df = sns.load_dataset(&quot;tips&quot;)
 sns.boxplot(data=df, x=&quot;day&quot;, y=&quot;tip&quot;, hue=&quot;day&quot;, legend=False)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot.svg|400px]]

Beispiel (mit Matplotlib erstellt):

 import matplotlib.pyplot as plt
 
 daten = [12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25]
 
 plt.boxplot(daten, patch_artist=True)
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot2.svg|300px]]

Um mehrere Box-Plots unterschiedlicher Farbe mit Matplotlib in einem Diagramm zu zeichnen, können Sie folgendermaßen vorgehen:

 import matplotlib.pyplot as plt
 
 daten = [[12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25],
          [10, 19, 20, 21, 20, 30, 19, 40, 11, 17, 19, 21]]
 
 farben = [&quot;green&quot;, &quot;blue&quot;]
 
 boxplot = plt.boxplot(daten, patch_artist=True)
 
 for patch, farbe in zip(boxplot['boxes'], farben):
     patch.set_facecolor(farbe)
 
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

== Regressionsrechnung ==
Beispiel:
 import numpy as np
 import matplotlib.pyplot as plt
 
 # Messpunkte
 x = np.array([1, 3, 5, 6, 8, 10, 20])
 y = np.array([3, 4, 5, 5, 7, 9, 11])
 
 # Regressionskurve (Grad 1 = lineare Regression, 2 = Polynom-Regression 2. Gr.)
 # y = kx + d
 k, d = np.polyfit(x, y, deg=1)
 # y = ax**2 + bx + c
 a, b, c = np.polyfit(x, y, deg=2)
 
 x_l = np.linspace(1, 20, 100)
 y_p = a * x_l**2 + b * x_l + c
 
 # Zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.plot(x, k*x + d, color='blue', label='Regressionsgerade')
 plt.plot(x_l, y_p, color='red', label='Regressionspolynom 2. Gr.')
 plt.xlabel('x')
 plt.ylabel('y')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_regression.svg|400px]]

== Korrelationsrechnung ==
Beispiel:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 # Messdaten
 x = [1, 3, 4, 5, 6]
 y = [2, 4, 6, 8, 5]
 
 daten = {'X': x, 'Y': y}
 df = pd.DataFrame(daten)
 
 # Korrelation
 korr = df['X'].corr(df['Y'])
 print(f&quot;Korrelationskoeff.: {korr}&quot;) 
 
 # Messpunkte zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:
 Korrelationskoeff.: 0.7556096518348252

[[Datei:IngMath_korrelation.svg|300px]]

== Mengen und Venn-Diagramme ==
Beispiel: 
 import matplotlib.pyplot as plt
 from matplotlib_venn import venn2
 
 menge_a = {1, 2, 3, 4, 5, 6}
 menge_b = {4, 5, 6, 7, 8}
 
 vereinigung = menge_a | menge_b
 schnitt = menge_a &amp; menge_b
 print(&quot;Vereinigungsmenge = &quot;, vereinigung)
 print(&quot;Schnittmenge = &quot;, schnitt)
 
 venn2([menge_a, menge_b], set_labels=('Menge A', 'Menge B'))
 plt.show()

Ausgabe:
 Vereinigungsmenge =  {1, 2, 3, 4, 5, 6, 7, 8}
 Schnittmenge =  {4, 5, 6}

[[Datei:IngMath_venn.svg|300px]]

Siehe auch {{W|Mengendiagramm#Venn-Diagramme}}.

== Verteilungs- und Dichtefunktion ==
* CDF ... '''C'''umulative '''D'''istribution '''F'''unction, Verteilungsfunktion
* PDF ... '''P'''robability '''D'''ensity '''F'''unction, Dichtefunktion

Beispiel (Normalverteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 from scipy.stats import norm
 
 my, sigma = 0, 1
 x = np.linspace(-4, 4, 50)
 
 pdf = norm.pdf(x, my, sigma)
 cdf = norm.cdf(x, my, sigma)
 
 plt.plot(x, pdf, lw=2, label=&quot;Dichtefunktion&quot;)
 plt.plot(x, cdf, lw=2, label=&quot;Verteilungsfunktion&quot;)
 plt.legend()
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:IngMath_cdf_pdf.svg|300px]]

Beispiel (&lt;math&gt;\chi^2&lt;/math&gt;-Verteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 import scipy.stats as stats
 
 x = np.linspace(0, 20, 500)
 
 # df ... degree of freedom, Freiheitsgrad
 pdf = (stats.chi2.pdf(x, df=2), stats.chi2.pdf(x, df=5), stats.chi2.pdf(x, df=10))
 
 for i in range(0,3):
     if(i==0):
         lab = &quot;Freiheitsgrad 2&quot;
     elif(i==1):
         lab = &quot;Freiheitsgrad 5&quot;
     else:
         lab = &quot;Freiheitsgrad 10&quot;
 
     plt.plot(x, pdf[i], label=lab, lw=2)
 
 plt.grid()
 plt.legend()
 plt.show()

Ausgabe:

[[Datei:IngMath_chi2.svg | 300px]]

== Schätzen und Testen ==
=== Intervallschätzung ===
Als Beispiel seien Daten gegeben, die von ''Dürr, Mayer: Wahrscheinlichkeitsrechnung und Schließende Statistik; 7. Aufl., Hanser, 2014, Seite 137'' stammen. Und zwar soll das 95%-Vertrauensintervall für den Mittelwert des Kaloriengehalts (kcal/100g) von Hähnchen ermittelt werden. Wir wollen das mit Python inkl. NumPy und SciPy durchführen. Die Stichprobe ist groß (50 Hähnchen):

Python-Code:
 import numpy as np
 import scipy.stats as stats
 
 # Stichprobe
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203]
 
 # Parameter definieren
 konfidenzniveau = 0.95
 mean = np.mean(daten)
 std = np.std(daten, ddof=1)
 stdfehler = stats.sem(daten)
 
 intervall = stats.norm.interval(confidence=konfidenzniveau, loc=mean, scale=stdfehler)
 
 print(f&quot;Mittelwert: {mean}&quot;)
 print(f&quot;Standardabweichung: {std}&quot;)
 print(f&quot;Konfidenzintervall: {intervall}&quot;)

Ausgabe:
 Mittelwert: 215.48
 Standardabweichung: 33.14238915925757
 Konfidenzintervall: (np.float64(206.29356722321992), np.float64(224.66643277678006))

Diese Werte stimmen gerundet mit denen im genannten Buch überein. Zum Code selbst:
* sem steht für '''s'''tandard '''e'''rror of the '''m'''ean.
* &lt;code&gt;scipy.stats.norm&lt;/code&gt; ... Modul für die Normalverteilung.

=== Punktschätzung ===
Gleiche Daten wie oben bei der Intervallschätzung.

Python-Code:
 import numpy as np
 from scipy import stats
 
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203
         ]
 
 mu_hat, sigma_hat = stats.norm.fit(daten) 
 
 print(f&quot;Schätzer für den Erwartungswert (μ): {mu_hat:.4f}&quot;)
 print(f&quot;Schätzer für die Standardabweichung (σ): {sigma_hat:.4f}&quot;)

Ausgabe:
 Schätzer für den Erwartungswert (μ): 215.4800
 Schätzer für die Standardabweichung (σ): 32.8093

=== Hypothesentests ===
Beispiel:

 import numpy as np
 import scipy.stats as stats
 
 x_quer = 12.075      # Stichproben-Mittelwert
 var    = 0.069       # Stichproben-Varianz
 n      = 90          # Stichprobengröße
 my_0   = 12.0        # Nullhypothese
 alpha  = 0.05        # Signifikanzniveau
 
 z_stat = (x_quer - my_0) / np.sqrt(var / n)
 p_val = 2 * (1 - stats.norm.cdf(np.abs(z_stat)))
 
 print(f&quot;Z-Statistik: {z_stat:.4f}&quot;)
 
 if p_val &lt; alpha:
     print(f&quot;p-Wert: {p_val:.6f} &lt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird verworfen.&quot;)
 else:
     print(f&quot;p-Wert: {p_val:.6f} &gt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird nicht verworfen.&quot;)

Ausgabe:

 Z-Statistik: 2.7087
 p-Wert: 0.006755 &lt; alpha: 0.05
 Die Nullhypothese wird verworfen.

== Statistische Qualitätskontrolle ==
Beispiel (Mittelwertkarte):

 import numpy as np
 import matplotlib.pyplot as plt
 
 # Gegeben
 sollwert = 50.0
 varianz = 4.0
 stichproben_umfang = 1
 daten = [49.5, 50.2, 53.0, 48.1, 52.6, 53.4, 49.8]
 
 # Berechnung
 standardabweichung = np.sqrt(varianz)
 streuung = standardabweichung / np.sqrt(stichproben_umfang)
 
 cl = sollwert
 ucl = cl + 3 * streuung
 lcl = cl - 3 * streuung
 
 # Darstellung
 plt.plot(daten, marker='o', linestyle='-', color='b', label='Messdaten')
 plt.axhline(cl, color='green', linestyle='-', label=f'CL: {cl}')
 plt.axhline(ucl, color='red', linestyle='--', label=f'UCL: {ucl:.2f}')
 plt.axhline(lcl, color='red', linestyle='--', label=f'LCL: {lcl:.2f}')
 
 plt.title('Mittelwertkarte')
 plt.xlabel('Stichprobe')
 plt.ylabel('Wert')
 plt.legend(loc='lower left')
 plt.grid(True)
 plt.show()

Ausgabe:

[[Datei:IngMath_mittelwertkarte.svg|300px]]

Siehe auch {{W|Shewhart-Regelkarte}} und {{W|Qualitätsregelkarte}}.

* UCL ... '''U'''pper '''C'''ontrol '''Limit''', Obere Eingriffsgrenze
* LCL ... '''L'''ower '''C'''ontrol '''Limit''', Untere Eingriffsgrenze
* CL ... '''C'''enter '''L'''ine, Mittellinie

= Ein- und Ausgabe =
== print ==
Die Anweisung print haben wir schon oft verwendet. Hier soll anhand von Beispielen kurz beschrieben werden, was der Befehl print leisten kann.

 print(&quot;Hallo&quot;, &quot;Welt&quot;, 1, sep=&quot;-&quot;)
 print(&quot;Hallo&quot;, end=&quot; &quot;)
 print(&quot;Welt&quot;)

Ausgabe:
 Hallo-Welt-1
 Hallo Welt

== input ==
 a = int(input(&quot;Zahl 1: &quot;))
 b = int(input(&quot;Zahl 2: &quot;))
 
 print(&quot;a + b = &quot;, a+b)

Ausgabe (nach Eingabe der beiden Ganzzahlen):
 Zahl 1: 4
 Zahl 2: 5
 a + b =  9

== Aus Dateien lesen ==
Es seinen die datei.txt
 Hallo Welt.
 Wie geht es dir?
 ...

und test1.py
 dat = open(&quot;datei.txt&quot;, mode = &quot;r&quot;)
 print(dat.read())
 dat.close()

Ausgabe
 Hallo Welt.
 Wie geht es dir?
 ...

Mit dem open()-Befehl wird die Datei datei.txt im Lesemodus geöffnet (r ... read). Mit dem read()-Befehl wird die Datei eingelesen und mittels print ausgegeben.

== In Dateien schreiben ==
 dat = open(&quot;datei.txt&quot;, mode = &quot;a&quot;, encoding = &quot;utf-8&quot;)
 dat.write(&quot;Hänge Zeile an\n&quot;)
 dat.close()

Die Datei datei.txt sieht nach Abarbeitung des obigen Skripts nun so aus
 Hallo Welt.
 Wie geht es dir?
 ...
 Hänge Zeile an

Es wird die Datei im Schreibmodus geöffnet (a ... append (anhängend), w ... write (überschreibend)).
write() fügt hier also eine Zeile Text am Dateiende ein. close() schließt die Datei wieder.

Das close() kann man sich mit der with-Anweisung auch sparen.

 with open(&quot;datei.txt&quot;, mode=&quot;a&quot;, encoding=&quot;utf-8&quot;) as dat:
     dat.write(&quot;Hänge Zeile an\n&quot;)

= Benutzeroberflächen erstellen =
== tkinter ==
{{Wikipedia | Tkinter}}

Python bietet standardmäßig das Modul tkinter zur Programmierung von Benutzeroberflächen. Es müssen also bei der Verwendung von tkinter keine externen Module installiert werden. Hier wird eine (sehr) kurze Einführung in das Erstellen von grafischen Oberflächen mittels tkinter gegeben.

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 win.minsize(300, 50)
 but = tk.Button(win, text = &quot;Push the button&quot;)
 but.pack()
 win.mainloop()

Ausgabe:

[[Datei:PythonIng_gui1.jpg]]

Ein etwas komplizierteres Beispiel sei nachfolgend gezeigt. Es sollen zwei Strings miteinander verknüpft und ausgegeben werden. 

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 
 def on_button_clicked():
     str = ent1.get() + ent2.get()
     lab2[&quot;text&quot;] = str
  
 ent1 = tk.Entry(win)
 ent2 = tk.Entry(win)
 lab1 = tk.Label(win, text=&quot;verknuepfen mit&quot;)
 lab2 = tk.Label(win, text=&quot;&quot;) 
 but = tk.Button(win, text = &quot;=&quot;, command=on_button_clicked)
 
 ent1.pack(side=&quot;left&quot;)
 lab1.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 but.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 lab2.pack(side=&quot;left&quot;)
 
 win.mainloop()

Ausgabe  (vor der Eingabe der Teilstrings): 

[[Datei:PythonIng_gui2.jpg]]

Ausgabe (nach der Eingabe der Teilstrings und dem Drücken des =-Buttons): 

[[Datei:PythonIng_gui3.jpg]]

== curses ==
{{Wikipedia | curses}}

Mit dem curses-Modul lassen sich u.a. TUIs ('''T'''ext '''U'''ser '''I'''nterfaces) erstellen. Ein sehr einfaches Beispiel zur allgemeinen Funktionsweise wird nachstehend geliefert.
 
 import curses
 
 stdscr = curses.initscr()
 curses.start_color()
 curses.init_pair(1, curses.COLOR_RED, curses.COLOR_WHITE)
 stdscr.clear()
 
 stdscr.addstr(&quot;Hallo Welt&quot;, curses.color_pair(1))
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()
 
Als Ausgabe sollte &lt;span style=&quot;color:#FF0000;&quot;&gt;Hallo Welt&lt;/span&gt; (rote Schrift auf weißem Hintergrund) auf dem Terminal/der Konsole erscheinen. Getestet wurde dies mit openSUSE Tumbleweed, Python-Version 3.13.12. Das entsprechende Python-curses-Package muss installiert sein.

Allgemeine Informationen zur Terminal-/Konsolengröße und Cursorposition liefert folgendes Programm:
 
 import curses
 
 stdscr = curses.initscr()
 
 stdscr.addstr(3, 5, &quot;LINES: %d&quot; % curses.LINES)
 stdscr.addstr(4, 5, &quot;COLS:  %d&quot; % curses.COLS)
 
 (y,x) = stdscr.getyx()
 stdscr.addstr(5, 5, &quot;Momentane Cursorposition:  [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getbegyx()
 stdscr.addstr(6, 5, &quot;Koordinatenursprung:       [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getmaxyx()
 stdscr.addstr(7, 5, &quot;Fenstergröße:              [%d, %d]&quot; % (y, x))
 
 stdscr.addstr(11, 2, &quot;Taste drücken -&gt; Ende&quot;)
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()

Es sollte sich in etwa folgende Ausgabe ergeben:

     LINES: 44
     COLS:  110
     Momentane Cursorposition:  [4, 15]
     Koordinatenursprung:       [0, 0]
     Fenstergröße:              [44, 110]
 
 
 Taste drücken -&gt; Ende

Zur Funktionsweise von curses siehe auch das Wikibook [[ncurses]]. Zum Verständnis sind dort allerdings elementare Kenntnisse in der Programmiersprache C erforderlich.

== Qt ==
{{Wikipedia | Qt (Bibliothek)}}

Auch für das Qt-Framework gibt es eine Anbindung an Python. Nachfolgend ein einfaches Beispiel.

 import sys
 from PySide6.QtWidgets import QApplication, QLabel
 
 app = QApplication(sys.argv)
 label = QLabel(&quot;Hallo Welt!&quot;)
 label.show()
 sys.exit(app.exec())

Ausgabe:

[[Datei:PythonIng_gui10.png]]

== Gtk ==
{{Wikipedia | GTK (Programmbibliothek)}}

Eine idente Ausgabe, wie oben für Qt gezeigt, erzeugt z.B. folgendes Gtk-Programm:

 import gi
 gi.require_version(&quot;Gtk&quot;, &quot;4.0&quot;)
 from gi.repository import Gtk
 
 def on_activate(app):
     win = Gtk.ApplicationWindow(application=app)
     lab = Gtk.Label(label=&quot;Hallo Welt!&quot;)
     win.set_child(lab)
     win.present()
 
 app = Gtk.Application()
 app.connect('activate', on_activate)
 app.run(None)

Auch für die Benutzung von Qt und Gtk müssen die jeweiligen Packages installiert sein. Getestet wurden die entsprechenden Python-Programme nur unter openSUSE Tumbleweed. Wie das GTK-Paket unter MS Windows 11 installiert wird, siehe z.B. [https://www.gtk.org/docs/installations/windows Setting up GTK for Windows].

Damit sei aber das Thema &quot;Benutzeroberflächen erstellen&quot; hier abgeschlossen, da dies schon ein sehr spezielles Aufgabengebiet ist, das eher Informatiker und nicht so sehr Ingenieure anspricht. Bei Bedarf siehe aber ggf. die entsprechenden Links unten in diesem Tutorial. Dort sind weiterführende Informationen zu finden.

= Pandas kurz erklärt =
Hier wird kurz auf das externe Modul Pandas eingegangen. Pandas steht für '''Pan'''el '''Da'''ta und ist ein Modul für die Datenanalyse und -manipulation.

== Series ==
Vorstellbar ist eine &quot;Series&quot; wie eine einzelne Spalte in einem Tabellenkalkulationsprogramm.

Beispiel (Index implizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5]) # Temperaturwerte
 print(temp)

Ausgabe:
 0     8.5
 1    11.0
 2    12.5
 3    10.0
 4    13.0
 5    11.0
 6    14.5
 dtype: float64

Das Kürzel &lt;code&gt;pd&lt;/code&gt; ist Konvention. Es seien Temperaturwerte gegeben. Die erste Spalte bei der Ausgabe ist der Index. Die zweite Spalte enthält die Werte.

Beispiel (separater Zugriff auf den Index und auf die Werte):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5])
 print(temp.index)
 print(temp.values)

Ausgabe:
 RangeIndex(start=0, stop=7, step=1)
 [ 8.5 11.  12.5 10.  13.  11.  14.5]

Beispiel (Index explizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 print(&quot;*** Die gesamte Series ***&quot;)
 print(temp)
 
 print(&quot;*** Temperatur am Donnerstag ***&quot;)
 print(temp[&quot;Do&quot;])
 
 print(&quot;*** Tage wärmer als 12 Grad ***&quot;)
 temp_gr_12 = temp[temp &gt; 12]
 print(temp_gr_12)

Ausgabe:
 *** Die gesamte Series ***
 Mo     8.5
 Di    11.0
 Mi    12.5
 Do    10.0
 Fr    13.0
 Sa    11.0
 So    14.5
 dtype: float64
 *** Temperatur am Donnerstag ***
 10.0
 *** Tage wärmer als 12 Grad ***
 Mi    12.5
 Fr    13.0
 So    14.5
 dtype: float64

== DataFrame ==
Ein DataFrame entspricht einer Tabelle.

Beispiel (Erzeugen eines DataFrames):
 import pandas as pd
 
 tag   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 v1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=tag)
 v2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=tag)
 v3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=tag)
 
 tab = pd.concat([v1, v2, v3], axis=1)
 tab.columns = stadt
 
 print(tab)
 print(type(tab))

Ausgabe:
     Linz  Salzburg Innsbruck
 Mo     1         8     Hallo
 Di     2         9        16
 Mi     3        10        17
 Do     4        11        18
 Fr     5        12        19
 Sa     6        13        20
 So     7        14        21
 &lt;class 'pandas.core.frame.DataFrame'&gt;

Wir haben hier drei Datenspalten (v1, v2, v3) mit den Spaltennamen &quot;Linz&quot;, &quot;Salzburg&quot; und &quot;Innsbruck&quot;, sowie sieben Zeilen &quot;Mo&quot; bis &quot;So&quot;.

Beispiel (Zugriff auf eine Spalte):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab[&quot;Salzburg&quot;])

Ausgabe:
 Mo     8
 Di     9
 Mi    10
 Do    11
 Fr    12
 Sa    13
 So    14
 Name: Salzburg, dtype: int64

Beispiel (Zugriff auf eine Zeile):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab.loc[&quot;Di&quot;])

Ausgabe:
 Linz          2
 Salzburg      9
 Innsbruck    16
 Name: Di, dtype: object

== Grafiken erstellen ==
Hier sei nur ein Torten- oder Kreisdiagramm gezeichnet:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 expl = [0, 0.2, 0, 0, 0, 0, 0]
 temp.plot.pie(figsize=(5,5), explode=expl)
 plt.show()

Ausgabe:

[[Datei:IngPython_pandas1.svg|350px]]

Die &lt;code&gt;figsize&lt;/code&gt; hat nichts mit der Spaltenanzahl zu tun, sondern setzt die Fenster- oder Diagrammgröße in Inches (Breite * Höhe).
 
Mit Pandas kann man auch noch andere Diagrammarten erstellen, z.B. Linien- oder Balkendiagramme. Dies wird hier aber nicht vorgeführt.

== Arbeiten mit CSV- und LibreOffice-Dateien ==
Gegeben sei eine CSV-Datei test1.csv:
 Mai;Juni;Juli
 12;17;45
 15;65;65
 16;32;23
 4;14;7
 23;17;Keine Daten verfügbar
 67;Keine Daten verfügbar;45
 15;24;12

Lesen von dieser CSV-Datei:
 import pandas as pd
 
 tab = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 print(tab)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Schreiben in eine CSV-Datei test2.csv:
 import pandas as pd
 
 val = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 val.to_csv(&quot;test2.csv&quot;, index=False)

Ausgabedatei:
 Mai,Juni,Juli
 12,17,45
 15,65,65
 16,32,23
 4,14,7
 23,17,Keine Daten verfügbar
 67,Keine Daten verfügbar,45
 15,24,12

Die Ausgabedatei ist beinahe gleich wie die Eingabedatei. Es werden aber Kommas statt Strichpunkten verwendet. Daher kommt auch der Name CSV ('''C'''omma '''S'''eparated '''V'''alue). Will man wieder Strichpunkte, so kann man dies über den Parameter &lt;code&gt;sep=&quot;;&quot;&lt;/code&gt; in der &lt;code&gt;to_csv&lt;/code&gt;-Funktion machen.

Um direkt von einer ODS-Datei (LibreOffice Calc, '''O'''pen '''D'''ocument '''S'''preadsheet) zu lesen muss das Modul odfpy extra installiert sein (per YaST, pip etc.). Gelesen wird dann folgendermaßen:
 import pandas as pd
 
 df = pd.read_excel('test1.ods', engine='odf')
 print(df)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Die Datei &quot;test1.ods&quot; sei die Datei, aus der das obige &quot;test1.csv&quot; generiert wurde. Schreiben kann man ebenfalls in eine ODS-Datei:

 import pandas as pd
 
 daten = {
     &quot;Name&quot;: [&quot;Hugo&quot;, &quot;Richie&quot;, &quot;Wilhelmine&quot;],
     &quot;Alter&quot;: [38, 30, 29],
     &quot;Ort&quot;: [&quot;Linz&quot;, &quot;Innsbruck&quot;, &quot;Salzburg&quot;]
 }
 
 tab = pd.DataFrame(daten)
 
 with pd.ExcelWriter(&quot;test2.ods&quot;, engine=&quot;odf&quot;) as writer:
     tab.to_excel(writer, sheet_name=&quot;Daten&quot;, index=False)

Es ergibt sich eine &quot;test2.ods&quot;-Datei (Screenshot):

[[Datei:IngPython_pandas2.png|250px]]

== Sonstiges ==
Hier seien stichpunktartig einige weitere Features von Pandas angeführt:
* {{W|Pivot-Tabelle|Pivot-Tabellen}} (pivot ... Dreh-, Angelpunkt): Zweck - große Datenmengen schnell zusammenfassen, filtern und analysieren.
* NaN ('''n'''ot '''a''' '''n'''umber): In einem Datensatz fehlt ein Wert oder ist nicht definiert.
* groupby-Funktion: Daten strukturieren, aggregieren oder Zwischensummen bilden. 
* {{W|Binning#Datenverarbeitung_und_-analyse|Binning}}: Klassenbildung.
* Mehrstufige Indizierung (Hierarchical Indexing oder MultiIndex)
* Zeitreihen (Time Series)

Für tiefergehende und weiterführende Informationen wird auf das Buch von ''Klein: Numerisches Python; Hanser, 2023'' und [https://pandas.pydata.org/ pandas] verwiesen.

= Style Guide, flake8, pylint, Black etc. =
== Style Guide ==
Wie man schönen und richtigen Python-Code schreibt, erfahren Sie in
* [https://peps.python.org/pep-0008/ PEP 8 – Style Guide for Python Code]

== Formatter und Linter ==
Ein Modul, das prüft, ob die Richtlinien im Style Guide eingehalten wurden, ist ''flake8'':
* [https://flake8.pycqa.org/en/latest/ Flake8: Your Tool For Style Guide Enforcement]

Code formatieren kann man auch mit [https://pypi.org/project/black/ Black]. Z.B. übersetzt &lt;code&gt;black test1.py&lt;/code&gt; die Datei &lt;code&gt;test1.py&lt;/code&gt;

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)),
     (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

in 

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)), (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Die Programmausgabe ist 

 reformatted test1.py
 
 All done! ✨ 🍰 ✨
 1 file reformatted.

Der Unterschied zwischen Black und Flake8:
* Black ist ein Code-Formatter. Er formatiert Ihren Code um, sodass er im Einklang mit PEP 8 steht.
* Flake8 ist ein {{W|Lint (Programmierwerkzeug) | Code-Linter}}. Flake8 verändert Ihren Code nicht, sondern durchsucht ihn nach potenziellen Fehlern etc.

Am obigen Beispiel sieht man auch, dass flake8 und Black nicht immer einer Meinung sind. Flake8 (&lt;code&gt;flake8 test1.py&lt;/code&gt;) würde standardmäßig den mit Black formatierten Code bemängeln:

 test1.py:8:80: E501 line too long (80 &gt; 79 characters)

Diese Diskrepanz kann beseitigt werden. Da 79 Zeichen auf modernen Bildschirmen meist als zu kurz empfunden werden, ist ein Limit von 88 Zeichen (Black-Standard) oder mehr empfehlenswert. Um dies zu implementieren, erstellen Sie in Ihrem Projektverzeichnis eine &lt;code&gt;.flake8&lt;/code&gt;-Datei mit dem Inhalt

 [flake8]
 max-line-length = 88

Und schon ignoriert Flake8 dieses Problem.

Ein anderer Linter ist pylint. Der würde beim Abarbeiten des obigen Beispiels, z.B. mit &lt;code&gt;pylint test1.py&lt;/code&gt; noch eine Kleinigkeit bemängeln:

 ************* Module test1
 /home/hr/tmp/test1.py:1:0: C0114: Missing module docstring (missing-module-docstring)
 
 ------------------------------------------------------------------
 Your code has been rated at 8.57/10 (previous run: 8.57/10, +0.00)

Auch pylint muss vor der ersten Verwendung installiert werden (z.B. mittels pip, virtuelle Umgebung, YaST). Die Dokumentation zu pylint findet sich auf [https://pylint.readthedocs.io/en/latest/].

&lt;u&gt;Aufgabe:&lt;/u&gt; Fügen Sie einen &quot;module docstring&quot; in die &lt;code&gt;test1.py&lt;/code&gt;-Datei ein und testen Sie erneut mit flake8, Black und pylint. &lt;small&gt;Sehen Sie zum Thema docstrings auch [https://peps.python.org/pep-0257/#what-is-a-docstring PEP 257 – Docstring Conventions].&lt;/small&gt;

Es gibt noch weitere Formatierungswerkzeuge für Python-Code. Z.B. [https://docs.astral.sh/ruff/ Ruff], ein moderner Code-Formatter und -Linter. Mittels &lt;code&gt;ruff check test1.py&lt;/code&gt; würde obiger Code geprüft (Linter). &lt;code&gt;ruff format test1.py&lt;/code&gt; formatiert den Code (Formatter).

== Type Checker ==
&quot;Type Checker&quot; sind z.B.
* mypy
* pyright
* ty

Diese prüfen die Datentypen, z.B. in folgendem Code

 def greetings(name: str) -&gt; str:
     return &quot;Hello, %s&quot; % name
 
 
 print(greetings(42))

Python selbst, flake8, ruff oder black würden diesen Code ohne zu murren akzeptieren. &quot;Type Checker&quot; würden aber sehr wohl Alarm schlagen, z.B. liefert &lt;code&gt;mypy&lt;/code&gt; folgende Ausgabe

 test1.py:5: error: Argument 1 to &quot;greetings&quot; has incompatible type &quot;int&quot;; expected &quot;str&quot;  [arg-type]
 Found 1 error in 1 file (checked 1 source file)

Das funktioniert übrigens nicht nur bei Funktionsannotationen, sondern auch mit Variablen etc.

 from typing import Final
 
 # &quot;Konstante&quot;, ab Python 3.8
 NUMBER: Final = 123
 print(NUMBER)
 NUMBER = 125
 print(NUMBER)
 
 # Variable
 a: int = 345
 print(a)
 a = &quot;Irgendwas&quot;
 print(a)
 
 # Variable (Pipe-Symbol), ab Python 3.10
 b : int|str = 567
 print(b)
 b = &quot;sonstiges&quot;
 print(b)

Ausgabe mit python:
 123
 125
 345
 Irgendwas
 567
 sonstiges

Ausgabe mit mypy:
 test3.py:6: error: Cannot assign to final name &quot;NUMBER&quot;  [misc]
 test3.py:12: error: Incompatible types in assignment (expression has type &quot;str&quot;, variable has type &quot;int&quot;)  [assignment]
 Found 2 errors in 1 file (checked 1 source file)

Python kennt übrigens keine Konstanten. Man kann diese mittels Großbuchstaben andeuten. Das ist aber nur Konvention, hat aber keine sonstigen Auswirkungen. Oder man verwendet wie oben gezeigt &lt;code&gt;Final&lt;/code&gt;. Dann werfen Typchecker Errors aus.

==pydoc==
pydoc ist ein Werkzeug, um Python-Module, -Funktionen und -Klassen zu dokumentieren.

Beispiel &lt;code&gt;test1.py&lt;/code&gt;:
 &quot;&quot;&quot;Rechen-Modul.
 
 Funktionen die von pydoc gelesen werden.
 &quot;&quot;&quot;
 
 def multiply(a, b):
     &quot;&quot;&quot;Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
     
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a * b
     
 def add(a, b):
     &quot;&quot;&quot;Addiert zwei Zahlen und gibt das Ergebnis zurück.
    
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a + b
    
 
 if __name__ == '__main__':
     print(multiply(3, 5))
     print(add(4, 6))

Ausgabe mit &lt;code&gt;python3.13 -m pydoc test1&lt;/code&gt; auf der Konsole:

 Help on module test1:
 
 NAME
     test1 - Rechen-Modul. 
 
 DESCRIPTION
     Funktionen die von pydoc gelesen werden.
 
 FUNCTIONS
     add(a, b)
         Addiert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
     multiply(a, b)
         Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
 FILE
     /home/xyz/tmp/test1.py

Siehe zu diesem Thema z.B. auch [https://docs.python.org/3/library/pydoc.html]. Mittels &lt;code&gt;python3.13 -m pydoc -w test1&lt;/code&gt; kann man auch eine HTML-Dokumentation erstellen.

Wofür &lt;code&gt;if __name__ == '__main__':&lt;/code&gt; steht, siehe z.B. etwas später im Abschnitt [[Ing_Mathematik:_Python#Doctests]].

== Sonstige Tools ==
Andere Tools für die {{W|Statische Code-Analyse|statische Codeanalyse}}, die aber für Ingenieure weniger interessant sein dürften, sind z.B.
* Radon: Liefert verschiedene {{W|Softwaremetrik|Codemetriken}} (Komplexität, Wartbarkeitsindex ...)
* Bandit: Findet Sicherheitslücken

Tools für die {{W|Dynamisches Software-Testverfahren|dynamische Codeanalyse}}, z.B.:
* DynaPyt (Framework zur dynamischen Programmanalyse)
* cProfile (Profiler)
* Memory Profiler (Speicheranalyse)
* Memray (Speicheranalyse)
* tracemalloc (Speicheranalyse)

Paket- und Projektmanagement (pip-Ersatz etc.):
* uv
* Poetry
* Conda
* pipx

Packaging-Tools (Freezer) und {{W|Compiler#Sonderformen|Transpiler}} :
* pyinstaller
** erstellt eigenständige, ausführbare Binärdatei
** kein Cross-Compiler
** kein Schutz vor Reverse-Engineering
** langsam
** packt alles in eine Datei
** sehr große Datei
** Befehl, z.B.: &lt;code&gt;pyinstaller --onefile test1.py&lt;/code&gt;
** GUI: &lt;code&gt;auto-py-to-exe&lt;/code&gt;
* cx_Freeze
* nuitka
** Übersetzt Python-Code in C/C++-Code und weiter in eine ausführbare Datei
** kein Cross-Compiler
** Schutz vor Reverse-Engineering
** Befehl, z.B.: &lt;code&gt;nuitka --standalone --onefile test1.py&lt;/code&gt;
* cython

= Einige Integrierte Entwicklungsumgebungen (IDEs)=
Werden Programmtexte größer und umfangreicher, so ist das Arbeiten mit der interaktiven Programmierumgebung bzw. das direkte Ausführen von Python-Skripten mühsam. Man wünscht sich z.B. Hilfen zum Debuggen oder die automatische Code-Vervollständigung. Zu diesem Zweck wurden IDEs (Integrated Development Environments) geschaffen. Von diesen seinen nachfolgend auszugsweise einige kurz beschrieben. Testen Sie einfach aus, welche davon für Sie bzw. für Ihr Python-Projekt geeignet sind.

== IDLE ==
IDLE ist die mit dem Python-Programmpaket mitgelieferte IDE. Der Name leitet sich einerseits ab vom Monty-Python-Mitglied Eric Idle, andererseits steht es als Abkürzung für &quot;'''I'''ntegrated '''D'''evelopment and '''L'''earning '''E'''nvironment. IDLE ist einfach zu bedienen, bietet aber schon einen beachtlichen Leistungsumfang. Nachfolgend wird ein Screenshot zu IDLE geliefert. Rechts ist das Editor-Fenster zu sehen, links die interaktive Programmierumgebung. Um das Beispiel selbst nachvollziehen zu können, starten Sie IDLE. Das geht ähnlich, wie Sie die interaktive Programmierumgebung von Python starten (nur, dass Sie eben das IDLE-Icon doppelklicken und nicht das Python-Icon. Unter Linux geben Sie einfach in einem Terminal &lt;code&gt;idle3.13&lt;/code&gt; o. Ä. ein). Weiter geht es mit &quot;File - Open - ...&quot;. Die auszuführende Datei auswählen (im konkreten Fall ein &quot;Hallo-Welt&quot;-Programm). Es erscheint das rechte Fenster. Dort &quot;Run - Run Module&quot; auswählen. Und schon wird im linken Fenster &quot;Hallo Welt!&quot; ausgegeben.

[[Datei:PythonIng_idle1.jpg | 600px]]

Siehe auch {{W|IDLE}}.

== PyCharm ==
PyCharm ist ein kommerzielles Produkt. Es gab aber auch eine kostenlose Community Edition. Seit 2025 sind beide Varianten vereint. Für die ersten 30 Tage sind die Pro-Funktionen frei verfügbar, danach nur noch die Kernfunktionalitäten (oder man bezieht kostenpflichtig  die Pro-Version). Zu beziehen ist PyCharm unter dem Weblink [https://www.jetbrains.com/pycharm/]. Nachfolgend ein etwas abgewandeltes &quot;Hallo Welt&quot;-Programm, editiert und ausgeführt mit PyCharm.

[[Datei:PyCharm_IDE_2023_screenshot.png | 600px]]

Siehe auch {{W|PyCharm}}.

== Eric ==
Auch eric ist Open Source und steht unter der  GNU General Public License Version 3 oder später. Zu beziehen ist diese Software unter [https://eric-ide.python-projects.org/].

[[Datei:Screenshot_Eric_4.png | 600px]]

Siehe auch {{W|eric (Software)}}.

&lt;small&gt;
Unter openSUSE Tumbleweed sollte sich eric auch mit YaST installieren lassen. Bei mir gibt es aber dann beim Ausführen des eric-Programms eine Fehlermeldung (Stand März 2026): 
 
 ...
 ModuleNotFoundError: No module named 'PyQt6.QtPdfWidgets'

Umgehen kann man dieses Problem aber wieder mit dem Erstellen einer virtuellen Umgebung, in etwa so

 python3.13 -m venv ~/tmp/venv1
 cd ~/tmp/venv1/bin
 ./python3.13 -m pip install --upgrade --prefer-binary eric-ide
 ./eric7_ide
&lt;/small&gt;

== PyScripter ==
Vom Funktionsumfang vergleichbar mit den vorherigen IDEs ist PyScripter. Auch PyScripter ist Open Source. Die Projekt-Homepage findet sich auf [https://sourceforge.net/projects/pyscripter/]. PyScripter ist nur für MS Windows verfügbar.

[[Datei:PythonIng_pyscripter1.jpg | 600px]]

== Spyder IDE ==
Spyder enthält bereits eine stabile Python-Version und etliche Module (z.B. matplotlib, numpy, control). Ansonsten kann dieses Softwarepaket vom Funktionsumfang her mit den anderen genannten IDEs locker mithalten. Spyder wurde unter der MIT-Lizenz veröffentlicht. Diese Software findet sich auf [https://www.spyder-ide.org].

[[Datei:Spyder-windows-screenshot.png | 600px]]

Siehe auch {{W|Spyder (Software)}}

== Eclipse IDE==
Die {{W|Eclipse_(IDE)|Eclipse-IDE}} kann für Python aufgerüstet werden. Dazu gibt es das PyDev-Plugin. Installiert wird es über 
* Help &gt; Eclipse Marketplace... 
* Find - PyDev - Install
Danach muss noch der Pfad zum Python-Interpreter festgelegt werden 
* Window &gt; Preferences &gt; PyDev &gt; Interpreters &gt; Python Interpreter &gt; New ... 
Das Ergebnis ist ähnlich wie im folgenden Bild, nur dass statt C/C++ Python Verwendung findet. 

[[Datei:Setting Up Eclipse CDT helloout.png | 600px]]

== Sonstige ==
Die genannten IDEs sind nicht die Einzigen. Es gibt, um dem Image Pythons als beliebteste Programmiersprache gerecht zu werden, noch einige andere. Sowohl Open Source-Programme als auch kommerzielle Programme sind im Web zu finden, z.B. Thonny oder {{W|Visual Studio Code}}. Unter Linux kann man auch {{W|KDevelop}}, ausgestattet mit dem Python3-Plugin, einsetzen. Braucht man den Umfang von ausgewachsenen IDEs nicht, so kann man auch normale Texteditoren verwenden (z.B. {{W|Geany}} oder {{W|Kate_(Texteditor)|Kate}}).

= Debuggen und Testen =
Das Debuggen und Testen von Programmen sind wichtige Bestandteile der Programmierung. Syntaxfehler lassen sich i.A. leicht beheben. Schwieriger ist das Eingrenzen von logischen Fehlern, die ev. nur in bestimmten Situationen auftreten und keine explizite Fehlermeldung hervorrufen. Das Programm liefert falsche Ergebnisse oder es stürzt aus heiterem Himmel ab. Um das zu verhindern gibt es verschiedene Werkzeuge, die bei der Fehlersuche behilflich sein können. Vorerst siehe aber zwecks Begriffsklärung noch folgende Links: 
 
* {{W|Debuggen}}
* {{W|Debugger}}
* {{W|Softwaretest}}

&lt;gallery&gt;
First Computer Bug, 1947.jpg
Test ganzheitlich.png
V-Modell.svg
&lt;/gallery&gt;

== Das Modul pdb ==
Python bringt schon ein Modul zum Debuggen mit. Siehe z.B. [https://docs.python.org/3/library/pdb.html pdb — The Python Debugger].
Komfortabler lässt sich das aber mittels Integrierter Entwicklungsumgebungen (IDEs) angehen.

== Debuggen mit IDEs ==
Für die IDEs IDLE und Spyder sei kurz auf die entsprechenden Webseiten verwiesen:

* [https://www.cs.uky.edu/~keen/help/debug-tutorial/debug.html Debugging under IDLE].
* [https://docs.spyder-ide.org/current/panes/debugging.html Spyder Debugger]

Dort wird die Vorgehensweise auch mittels Screenshots erläutert.

== assert ==
assert ... behaupten, zusichern ({{W|Assertion (Informatik)}})

Python-Code:
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10., 0.)

Ausgabe:

 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10., 0.)
   File &quot;/home/hr/Develop/test1.py&quot;, line 4, in print1
     assert y != 0.0
            ^^^^^^^^
 AssertionError
 
Python-Code: 
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)
 
Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(&quot;10.&quot;, &quot;5.&quot;)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError
 
Aber auch bei nachfolgendem Code gibt es eine Fehlermeldung:

 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10, 5)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError

Damit letzteres funktioniert, kann man den Programmcode so umschreiben:
 def print1(x, y):
     assert type(x) == float or type(x) == int
     assert type(y) == float or type(y) == int
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 2.0
 
Und jetzt fangen wir den &lt;code&gt;AssertionError&lt;/code&gt; auf:
 def print1(x, y):
     try:
         assert type(x) == float or type(x) == int
         assert type(y) == float or type(y) == int
         assert y != 0.0
         print(x/y)
     except(AssertionError):
         print(&quot;Hallo&quot;)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)

Ausgabe:
 2.0
 Hallo

Ich hoffe, es ist wenigstens im Ansatz klar geworden, wofür &lt;code&gt;assert&lt;/code&gt; gut sein kann. Ausschalten kann man die &lt;code&gt;assert&lt;/code&gt;-Überprüfung übrigens mit dem Python-Schalter &lt;code&gt;-O&lt;/code&gt;.

== Doctests == 
Innerhalb eines Docstrings kann die Arbeit im interaktiven Modus simuliert werden. Nach den Promptzeichen (&gt;&gt;&gt;) erfolgen dann bei unserem Beispiel innerhalb des Docstrings simulierte Aufrufe der Funktion &lt;code&gt;print1()&lt;/code&gt;. Danach folgen jeweils die Sollresultate. Wird das Modul oder die Datei als Hauptprogramm aufgerufen, so wird die Funktion &lt;code&gt;doctest.testmode()&lt;/code&gt; aufgerufen und ein Bericht auf der Konsole ausgegeben. Wird das Modul nicht als Hauptprogramm aufgerufen, sondern importiert, dann wird diese &lt;code&gt;testmod&lt;/code&gt;-Funktion nicht aufgerufen. D.h. dieser Code kann sowohl für Testzwecke als auch für den produktiven Einsatz verwendet werden. Das ist auch sinnvoll, weil wenn man Teile der Datei immer löschen bzw. einfügen müsste, so würden sich Fehlerquellen auftun. Das würde den Sinn und Zweck von Doctests konterkarieren.  

 def print1(x=0., y=1.):
     &quot;&quot;&quot; Dividiere zwei Zahlen
     Autor: Intruder
     Datum: 12.08.2025
 
     &gt;&gt;&gt; print1(2., 1.)
     2.0
     &gt;&gt;&gt; print1(5., 2.)
     2.5
     &gt;&gt;&gt; print1(5.)
     5.0
     &quot;&quot;&quot;
     print(x/y)
 
 if __name__ == &quot;__main__&quot;:
     import doctest
     doctest.testmod(verbose=True)

Ausgabe:
 Trying:
     print1(2., 1.)
 Expecting:
     2.0
 ok
 Trying:
     print1(5., 2)
 Expecting:
     2.5
 ok
 Trying:
     print1(5.)
 Expecting:
     5.0
 ok
 1 items had no tests:
     __main__
 1 items passed all tests:
    3 tests in __main__.print1
 3 tests in 2 items.
 3 passed and 0 failed.
 Test passed.

Das gezeigte Beispiel ist so ziemlich das einfachste, das es gibt. Für weiterführende Details siehe z.B.:
* [https://peps.python.org/pep-0257/ PEP 257 – Docstring Conventions]
* [https://docs.python.org/3/library/doctest.html doctest — Test interactive Python examples]

''Einschub:'' Ganz ähnlich kann man auch Klassen testen, z.B. in folgendem Code-Fragment

 class Fahrzeug:
   # siehe Abschnitt &quot;Objektorientierte Programmierung&quot;
   # ...
 
 if __name__ == &quot;__main__&quot;:
   vauweh = Fahrzeug(170, 90)
   beemweh = Fahrzeug(200, 120)
   print(vauweh.convertGeschw())
   print(beemweh.convertGeschw())

Wird das Script als Hauptprogramm ausgeführt (z.B. zu Testzwecken), so erfolgt die Ausgabe der zwei, via &lt;code&gt;convertGeschw()&lt;/code&gt;, umgerechneten Geschwindigkeiten. Wird es aber als Modul eingebunden, so wird der letzte Programmabschnitt nicht ausgeführt (&lt;code&gt;__name__ == &quot;__main__&quot;&lt;/code&gt; ergibt &lt;code&gt;False&lt;/code&gt;).

== pytest ==
Siehe zu diesem Thema auch {{W|Modultest}}.

pytest ist ein externes Modul und muss vorab installiert werden, z.B. mittels 
 pip install -U pytest
 pip install -U pytest-html 

Python-Code, Datei test1.py:
 def add(x, y):
     return x + y
 
 def test_answer():
     assert add(1, 1) == 3

Starten von pytest in der Konsole:
 pytest test1.py
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py F                                                                                                            [100%]
 
 ========================================================= FAILURES ==========================================================
 ________________________________________________________ test_answer ________________________________________________________
 
     def test_answer():
 &gt;       assert add(1, 1) == 3
 E       assert 2 == 3
 E        +  where 2 = add(1, 1)
 
 test1.py:6: AssertionError
 ================================================== short test summary info ==================================================
 FAILED test1.py::test_answer - assert 2 == 3
 ===================================================== 1 failed in 0.09s =====================================================

Hier erhalten wir einen Fehler, da 1+1 eindeutig ungleich 3 ist. Aber aus irgendeinem Grund wollte der Programmierer oder Tester in diesem Fall, dass dies so ist. Testfälle werden übrigens mit dem Präfix &lt;code&gt;test_&lt;/code&gt; eingeleitet.

Python-Code:
 def add(x, y):
     return x + y + 1
 
 def test_answer():
     assert add(1, 1) == 3 
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py .                                                                                                            [100%]
 
 ===================================================== 1 passed in 0.01s =====================================================

Jetzt ist alles in Ordnung. Weiterführendes siehe z.B.

* [https://docs.pytest.org/en/stable/ pytest: helps you write better programs]

== unittest ==
Auch unittest dient zur Durchführung von Testreihen, ist aber Bestandteil von Python. Hier wird vorerst nicht näher darauf eingegangen. Siehe z.B. 
* [https://docs.python.org/3/library/unittest.html unittest — Unit testing framework]

Lt. ''Inden: Python Challenge; dpunkt, 2021, Seite 481''  soll unittest weniger komfortabel als pytest sein.

Einen Vergleich von unittest mit pytest findet man in
* [https://knapsackpro.com/testing_frameworks/difference_between/pytest/vs/unittest pytest vs unittest]

= Python und Anwendungsprogramme =
Bisher stand immer alleine die Programmiersprache Python (ev. unter Einbeziehung von Modulen) im Mittelpunkt der Betrachtungen. Aber Python kann auch als Makrosprache für Anwendungsprogramme auftreten. Als Beispiele seien {{W|FreeCAD}} und {{W|LibreOffice}} genannt.

== FreeCAD ==
FreeCAD ist ein freies 3D-CAD-Programm. Hier soll nicht auf die Bedienung dieses CAD-Pakets eingegangen werden, sondern nur auf die Möglichkeit, mittels Python Makros zu schreiben. Als einfacher Einstieg soll ein Makro erstellt werden, welches eine Kugel (rot) und einen Quader (blau) zeichnet. Folgende Vorbereitungsschritte sind erforderlich (es sei vorausgesetzt, dass FreeCAD schon am Rechner installiert ist. Downloaden können Sie das Programm von der Website [https://www.freecad.org/downloads.php?lang=en]):

* FreeCAD starten
* Leere Datei erstellen
* Makro &gt; Makros &gt; Erstellen ...

Es öffnet sich ein leeres Editorfenster, in das Sie folgenden Code eingeben können:

 import FreeCAD
 import Part
 
 doc = FreeCAD.newDocument()
 
 # Kugel
 kugel = Part.makeSphere(10)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Kugel&quot;)
 form_element.Shape = kugel
 kug = FreeCAD.ActiveDocument.getObject(&quot;Kugel&quot;)
 kug.ViewObject.ShapeColor = (1.0, 0.0, 0.0)
 neuePosition = App.Vector(5, 2.5, 2.5)
 kug.Placement = App.Placement(neuePosition, kug.Placement.Rotation)
 
 # Quader
 quader = Part.makeBox(5, 5, 50)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Quader&quot;)
 form_element.Shape = quader
 quad = FreeCAD.ActiveDocument.getObject(&quot;Quader&quot;)
 quad.ViewObject.ShapeColor = (0.0, 0.0, 1.0)
 
 doc.recompute()

Diesen Code können Sie nun ausführen:
* Makro &gt; Makro ausführen

Es ergibt sich folgende Ausgabe (gedreht und gezoomt):

[[Datei: PythonIng_freecad1.png|500px]]

Siehe auch [https://wiki.freecad.org/Python_scripting_tutorial/de# Anleitung Skripterstellung mit Python]. Getestet wurde obiges Beispiel mit FreeCAD 1.1.3 unter Linux und 1.1.1 unter MS Windows.

== LibreOffice ==
LibreOffice ist ein freies Officepaket ([https://de.libreoffice.org/]). Hier soll nur das Tabellenkalkulationsprogramm Calc kurz betrachtet werden. Es seinen in den ersten 3 Zellen (A1 bis A3) Zahlen gegeben. Diese sollen mit einem Python-Makro addiert und das Resultat in der Zelle A5 ausgegeben werden. Auch hier sind Vorbereitungsarbeiten nötig: 
* zuerst muss unter Linux das Verzeichnis &lt;code&gt;~/.config/libreoffice/4/user/Scripts/python&lt;/code&gt; erstellt werden
* für MS Windows ist es das Verzeichnis &lt;code&gt;%APPDATA%\LibreOffice\4\user\Scripts\python&lt;/code&gt; 
** drücken Sie zuerst Win + R (es öffnet sich das Ausführen-Fenster)
** geben Sie &lt;code&gt;%appdata%&lt;/code&gt; ein, danach drücken Sie Enter (es öffnet sich der Explorer)
** navigieren Sie zu dem genannten Verzeichnis bzw. erstellen Sie das Verzeichnis 
* in diesem Verzeichnis wird dann mit einem beliebigen Texteditor das Python-Makro erstellt, in unserem Fall die Datei &lt;code&gt;summiere_zellen.py&lt;/code&gt;:

 import uno
 
 def summiere_zellen(*args):
     # Zugriff auf das aktuelle Dokument und das aktive Tabellenblatt
     ctx = uno.getComponentContext()
     smgr = ctx.getServiceManager()
     desktop = smgr.createInstanceWithContext(&quot;com.sun.star.frame.Desktop&quot;, ctx)
     doc = desktop.getCurrentComponent()
     sheet = doc.getCurrentController().getActiveSheet()
 
     # Werte aus den Zellen A1 bis A3 auslesen
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
 
     # Addition der drei Werte
     summe = w1 + w2 + w3
 
     # Ergebnis in die Zelle A5 schreiben
     sheet.getCellRangeByName(&quot;A5&quot;).Value = summe

* siehe dazu ggf. auch [https://help.libreoffice.org/latest/de/text/sbasic/python/python_locations.html?DbPAR=BASIC].

Weiter geht es in LibreOffice Calc mit dem Menü ''Extras &gt; Makros &gt; Makros verwalten &gt; Python''. Dort wird das Makro &lt;code&gt;summiere_zellen&lt;/code&gt; ausgeführt. Es ergibt sich z.B. folgendes Resultat

[[Datei:PythonIng_libreoffice1.png]]

Das Kürzel &lt;code&gt;uno&lt;/code&gt; steht für '''U'''niversal '''N'''etwork '''O'''bjects. Etwas einfacher geht's auch so:

 def summiere_zellen():
     desktop = XSCRIPTCONTEXT.getDesktop()
     model = desktop.getCurrentComponent()
     sheets = model.getSheets()
     sheet = sheets.getByIndex(0)
     
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
     
     cell = sheet.getCellRangeByName(&quot;A5&quot;)    
     cell.setValue(w1 + w2 + w3) 

Empfohlen wird auch, das Erweiterungspaket APSO ('''A'''lternative '''P'''ython '''S'''cript '''O'''rganizer, apso.oxt) zu installieren. Die Vorgehensweise wird hier nicht gezeigt, sondern nur darauf hingewiesen, dass man das einfach &quot;googeln&quot; kann. Siehe zur Python-Programmierung für LibreOffice auch [https://wiki.documentfoundation.org/Macros/Python_Guide/de Makros/Python-Handbuch]. Getestet wurden obige Beispiele mit LibreOffice 26.2.5.1 unter Linux und 26.2.1.2 unter MS Windows.

= Ausblick =
Dies war eine kurze Einführung in die Berechnungs- und Darstellungsmöglichkeiten mit Python. Es sollten etliche relevante Themen behandelt, oder zumindest kurz angesprochen worden sein. Wem dieser Text nicht ausreichend ist, der sei auf die entsprechenden weiterführenden Weblinks, Bücher und die Python-Hilfefunktion verwiesen. Python kennt noch viel mehr Befehle, als hier dargestellt wurden. Das Themenspektrum ist auch durch die Einbindung externer Module fast beliebig erweiterbar.

= Weblinks=
== Python allgemein ==
* [https://www.python.org/ Python Homepage]

== Externe mathematische Module ==
* [https://numpy.org/ NumPy]
* [https://numpy.org/doc/stable/user/numpy-for-matlab-users.html NumPy for MATLAB users]
* [https://scipy.org/ SciPy]
* [https://www.sympy.org/en/index.html SymPy]
* [https://pandas.pydata.org/ pandas]
* [https://github.com/maroba/findiff findiff]
* [https://mpmath.org/ mpmath]

== Externe Module für Grafiken ==
* [https://matplotlib.org/ Matplotlib]
* [https://vpython.org/ VPython]
* [https://build123d.readthedocs.io/en/latest/ build123d]
* [https://docs.vtk.org/en/latest/api/python.html VTK]
* [https://docs.bokeh.org/en/latest/docs/first_steps.html bokeh]
* [https://py5coding.org/ py5]

== Erstellung von User Interfaces ==
* [https://docs.python.org/3/library/tkinter.html tkinter - Python interface to Tcl/Tk]
* [https://docs.python.org/3/library/curses.html curses - Terminal handling for character-cell displays]
* [https://wiki.qt.io/Qt_for_Python Qt for Python]
* [https://www.gtk.org/docs/language-bindings/python GTK and Python]

== Erstellen virtueller Umgebungen ==
* [https://docs.python.org/3/library/venv.html venv - Creation of virtual environments]

== Sonstige ==
* [https://python-control.readthedocs.io/en/stable/ Python Control Systems Library]
* [https://pypi.org/project/regex/ regex - Regular Expressions]
* [http://pyromat.org/ PYroMat]
* [https://coolprop.org/coolprop/wrappers/Python/index.html CoolProp]
* [https://pypi.org/project/iapws/ iapws]
* [https://tespy.readthedocs.io/en/main/getting_started/introduction.html TESPy - Thermal Engineering Systems in Python]
* [https://pint.readthedocs.io/en/stable/ pint]

= Bücher =
== Gedruckte Bücher, OpenBooks, Magazine ==
* Diverse: c't Python Lernen, Verstehen, Anwenden; Heise, 2022 
* Ernesti, Kaiser: Python3 - das umfassende Handbuch; 5. Aufl., Rheinwerk, [https://openbook.rheinwerk-verlag.de/python/ OpenBook]
* Iacono et al.: Programmieren trainieren; 3. Aufl., Hanser, 2023, ISBN 978-3-446-47766-7
* Inden: Python Challenge; dpunkt, 2021, ISBN 978-3-86490-809-5
* Klein: Numerisches Python; 2. Aufl., Hanser, 2023, ISBN 978-3-446-47170-2 
* Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler; Rheinwerk, 2021, ISBN 978-3-8362-7316-9
* Weigend: Python 3 - Das umfassende Praxisbuch; 9. Aufl., mitp, 2022, ISBN 978-3-7475-0544-1
* Woyand: Python für Ingenieure und Naturwissenschaftler; 4. Aufl., Hanser, 2021, ISBN 978-3-446-46483-4

== Andere Wikibooks ==
* [[:en:Subject:Python_programming_language | Englische Wikibooks zum Thema Python]]
* [[Python|Deutschsprachiges Python-Wikibook]] [[Bild:2von10.png|20%]]
* [[Python unter Linux|Python 2.7 unter Linux]] [[Bild:10von10.png|100%]]


{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}</text>
      <sha1>4bksmzf0mvkg9bi13htq13lf77lr96u</sha1>
    </revision>
    <revision>
      <id>1092167</id>
      <parentid>1092166</parentid>
      <timestamp>2026-10-16T13:33:46Z</timestamp>
      <contributor>
        <username>Intruder</username>
        <id>1513</id>
      </contributor>
      <comment>/* if */</comment>
      <origin>1092167</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="189226" sha1="stwtgi1hrjag0b2ejnby5hevpchxnk1" xml:space="preserve">{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}


= Hallo Welt und allgemeine Hinweise =
== Was ist Python ==
* Python ist eine universelle höhere Programmiersprache.
* Python ist objektorientiert.
* Python ist Open-Source (Python Software Foundation License).
* Python ist für viele Betriebssysteme erhältlich (z.B. für Linux, MS Windows, macOS).
* Python ist ein Interpreter.
* Python ist durch Module fast beliebig erweiterbar.
* Python als Programmiersprache ist case-sensitive - d.h. Groß- und Kleinschreibung ist relevant bei der Eingabe von Befehlen.
* Python ist in etlichen Anwendungsprogrammen (z.B. {{W|FreeCAD}}, {{W|LibreOffice}}, {{W|GIMP}}, {{W|Blender (Software) | Blender}}) als Makrosprache verwendbar.

{{Wikipedia | Python (Programmiersprache)}}

== Python installieren ==
=== MS Windows ===
Laden Sie das aktuelle Python-Paket von der Webseite [https://www.python.org/] herunter. Weiter geht es wie bei jedem anderen größeren zu installierenden Programm. Einfach das Installationsprogramm im Explorer doppelklicken und den Anweisungen des Setup-Programmes folgen.

=== Linux ===
Entweder ist Python bereits standardmäßig installiert, ansonsten ist die Installation mittels Paketmanagementsystem einfach möglich. Aber auch die Spyder-Entwicklungsumgebung ([https://www.spyder-ide.org]) bietet einen guten Einstieg mit Python (das gilt auch für MS Windows). Spyder bringt auch schon etliche wichtige Module standardmäßig mit.

== Python starten ==
=== MS Windows ===
Das Icon für das Python-Programm doppelklicken. Und schon startet das Programm.

[[Datei:PythonIng_start1.jpg]]

Python im interaktiven Modus präsentiert sich dann so:

 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

Alternativ kann das Programm auch über die Eingabeaufforderung oder die PowerShell gestartet werden:

 c:\devel\Python&gt;python.exe
 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

=== Linux ===
Tippen Sie einfach das Wort „python“ (oder unter openSUSE Tumbleweed z.B. auch „python3.11“ oder „python3.13“) in einem Linux-Terminal ein, schließen den Befehl mit der RETURN-Taste ab, und schon startet Python im interaktiven Modus:
 
 Python 3.13.12 (main, Feb 09 2026, 22:37:44) [GCC] on linux
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt; 

Es gibt auch noch andere Möglichkeiten Python zwecks Programmausführung zu starten, z.&amp;nbsp;B. den {{W|Shebang}} (&lt;code&gt;#!&lt;/code&gt;) am Beginn eines Python-Scripts. Das Script sei als Script.py gespeichert. Dann kann das Script mit ./Script.py ausgeführt werden. Für openSUSE Tumbleweed sei nachfolgend ein lauffähiges &quot;Hallo Welt!&quot;-Script angegeben. Es wird in diesem Script der Python-Interpreter in der Version 3.13 verwendet :

 #!/usr/bin/python3.13
 print(&quot;Hallo Welt!&quot;)

Die Berechtigungen zum Ausführen der Datei müssen natürlich noch richtig gesetzt werden, z.B. mittels &lt;code&gt;chmod 777 Script.py&lt;/code&gt;. &lt;small&gt;&lt;code&gt;chmod&lt;/code&gt; ist die Abkürzung für&quot;'''ch'''ange file '''mod'''e bits&quot;.&lt;/small&gt; 

&lt;small&gt;Die &quot;Maske&quot; &lt;code&gt;777&lt;/code&gt; ist nur für Testzwecke sinnvoll, weil sie leicht zu merken ist und für alle Benutzer alle Zugriffsberechtigungen ('''r'''ead/'''w'''rite/e'''x'''ecute für owner/group/others) setzt. Im richtigen Einsatz wird man das aus Sicherheitsgründen nicht so handhaben, sondern nur die Berechtigungen setzen, die unbedingt erforderlich sind. Welche Zugriffsberechtigungen gesetzt sind, kann man z.B. mit dem Befehl &lt;code&gt;ls -l&lt;/code&gt; oder &lt;code&gt;ll&lt;/code&gt; ('''l'''i'''s'''t directory contents) erfragen. Aber dazu im Moment genug. Erfahrene Linux-Nutzer kennen das ohnehin und Anfänger sollen jetzt nicht mit Linux-Interna überfordert werden. Bei Bedarf siehe die Linux-Man-Pages oder dezidierte Bücher zu Linux.&lt;/code&gt;&lt;/small&gt;

&lt;small&gt;Oder das Script wird in einen Pfad verschoben, in dem sich ausführbare Programme generell befinden (welche Verzeichnisse im PATH liegen, kann bspw. mit &lt;code&gt;echo $PATH&lt;/code&gt; abgefragt werden). Das Script kann dann wie ein normales Programm ohne weitere Angaben mit Script.py gestartet werden. Alternativ wird nicht das Script an sich verschoben, sondern nur ein symbolischer Link angelegt, z.B. mit &lt;code&gt;ln -s ~/tmp/Script.py ~/.local/bin/Script.py&lt;/code&gt;. &lt;code&gt;~/.local/bin&lt;/code&gt; sei ein im PATH gelegenes Verzeichnis. Dies sind aber schon Features für fortgeschrittene Linux-Benutzer und werden am Anfang eher selten benötigt.&lt;/small&gt;

== Ein paar Worte zur Erklärung ==
=== Tests ===
Getestet wurden die Beispiele unter den Betriebssystemen 
* MS Windows 10 mit der Python-Version 3.12.0 (teilweise auch mit 3.12.2 und 3.13.1; nur die Inhalte die bis spätestens Juli 2025 erstellt wurden) 
* MS Windows 11 ab der Python-Version 3.13.4 (nur zum Teil; ab Juli 2025)
* openSUSE Leap 15.6 mit der Python-Version 3.11.12 (Spyder, nur vereinzelt) und zum Teil mit 3.12.11 (ab Juli 2025 bis November 2025).
* openSUSE Tumbleweed ab der Python-Version 3.13.9 (nur vereinzelt, ab November 2025)

=== Popularität ===
* An Beliebtheit rangiert Python mit Stand September 2026 mit einem Rating von 17,76% an 1. Stelle vor C und C++ (lt. [https://www.tiobe.com/tiobe-index/ TPCI - TIOBE Programming Community Index]). 
* Lt. [https://innovationgraph.github.com/global-metrics/programming-languages GitHub Top 50 Programming Languages Globally] lag Python im Q1/2026 auf Rang 2, vor TypeScript und hinter JavaScript. 
* [https://pypl.github.io/PYPL.html PYPL] (Popularity of Programming Language Index) ist ein anderer Popularitätsindex für Programmiersprachen. Auch hier liegt Python mit großem Vorsprung auf dem ersten Platz (52,08%), gefolgt von Java (13,34%) und C/C++ (7,99%) (Stand September 2026). 

=== Namensgebung ===
Der Name &quot;Python&quot; rührt von der Komikertruppe {{W|Monty Python}} her. Die Icons für Python (z.B. Python selbst, Eric IDE, IDLE) sind aber durch die Python-Schlangenart symbolisiert.

&lt;gallery&gt;
Python-logo-notext.svg|Python-Logo
Guido van Rossum in PyConUS24.jpg|{{W|Guido van Rossum}} (geb. 1956), der Erfinder von Python
&lt;/gallery&gt;

== Ein erstes Programm ==
Kommentare werden in Python mit der Raute (#) eingeleitet. Sie werden vom Python-Interpreter ignoriert. Text kann mit der print-Funktion ausgegeben werden. Starten Sie Python und geben sie folgende Anweisungen zeilenweise ein

 &gt;&gt;&gt; # Das ist ein Kommentar
 &gt;&gt;&gt; print(&quot;Hallo Welt!&quot;)

Als Ergebnis erhalten Sie

 Hallo Welt!

Der Prompt (&gt;&gt;&gt;) ist selbstverständlich nicht einzutippen, sondern wird vom Python-System geliefert.

Strings können in Python entweder in Anführungszeichen (&quot;) gesetzt werden oder in Hochkommatas('). In diesem Text wird die erste Variante bevorzugt eingesetzt.

Im Gegensatz zu Julia ist es hier egal, ob zwischen &lt;code&gt;print&lt;/code&gt; und der öffnenden Klammer Leerzeichen stehen.

= Python als Taschenrechner =
== Allgemeines ==
Wir wollen 3 * 5 berechnen. Dazu starten wir Python im interaktiven Modus. Geben Sie dann die Formel  

 &gt;&gt;&gt; 3 * 5

ein, drücken die Taste ENTER/RETURN ({{Taste|↵}}) und erhalten als Ergebnis

 15

Auch kompliziertere Ausdrücke sind möglich. Beispielsweise mit Winkelfunktionen, Quadratwurzeln etc. Wir wollen nun den Ausdruck &lt;math&gt;\sin\sqrt{15}&lt;/math&gt; berechnen :

 &gt;&gt;&gt; import math
 &gt;&gt;&gt; math.sin(math.sqrt(15))
 -0.6679052983383519

Als erstes wird das math-Modul importiert. Dann wird der mathematische Ausdruck berechnet.

Eine andere Variante, die dasselbe Ergebnis liefert, ist

 &gt;&gt;&gt; from math import *
 &gt;&gt;&gt; sin(sqrt(15))
 -0.6679052983383519

Es wird also aus dem Modul &lt;code&gt;math&lt;/code&gt; alles importiert (erkennbar am &lt;code&gt;*&lt;/code&gt;). Will man nicht alles importieren, so kann man das auch einschränken:

 &gt;&gt;&gt; from math import sin, sqrt

Beenden lässt sich das Python-Programm durch Eingabe von &lt;code&gt;exit()&lt;/code&gt; (und natürlich ist zur Bestätigung die RETURN-Taste zu drücken). &lt;code&gt;exit&lt;/code&gt; (ohne Klammern) oder &lt;code&gt;quit&lt;/code&gt; werden auch akzeptiert.

== Die Hilfefunktion von Python ==
Bei Eingabe der Anweisung &lt;code&gt;help&lt;/code&gt; oder &lt;code&gt;help()&lt;/code&gt; springt Python in den Hilfemodus. 

Eingabe:
 &gt;&gt;&gt; help()
 
Eingabe:
 help&gt; math.sin

Ausgabe:
 Help on built-in function sin in math:
 
 math.sin = sin(x, /)
     Return the sine of x (measured in radians).

Für die komplette Python-Dokumentation siehe [https://docs.python.org/3/]. Verlassen kann man den Hilfemodus durch das Drücken von STRG-C, bzw. der Eingabe von q, quit oder exit mit anschließendem Drücken der RETURN-Taste.

== Aufgaben ==
* Erkunden Sie die Tangensfunktion &quot;tan&quot; mittels Python-Hilfe (vergessen Sie nicht das math-Modul zu importieren und das &lt;code&gt;math.&lt;/code&gt; vor &lt;code&gt;tan&lt;/code&gt;)
* Berechnen Sie mit Python den Ausdruck &lt;math&gt;\frac{1}{2}\cdot \text{e}^2 \cdot \tan(\pi/3)&lt;/math&gt;. Siehe für die Exponentialfunktion im Python-Hilfesystem auch den Befehl &lt;code&gt;math.exp&lt;/code&gt;. Alternativ kann auch die Konstante &lt;code&gt;math.e&lt;/code&gt; eingesetzt werden. Potenzieren kann man bei Python mit dem **-Operator (z.B. 2**3 = 8). Für &lt;math&gt;\pi&lt;/math&gt; gibt es &lt;code&gt;math.pi&lt;/code&gt;.

= Python als Scriptsprache =
Häufig wird man aber kompliziertere Anweisungsfolgen verarbeiten müssen. Diese will man normalerweise nicht jedesmal neu eingeben, sondern in einer Datei speichern und diese Datei dann zur Ausführung bringen. Speichern Sie dazu folgenden Code in einer Textdatei, z.B. unter MS Windows als c:\tmp\test1.py

 # Das ist ein Kommentar
 print(&quot;Hallo Welt!&quot;)

Python-Dateien werden mit der Dateiendung .py versehen. Achten Sie darauf, dass vor dem print keine Leerzeichen vorhanden sind. Das ist eine Python-Eigenheit. Wie wir später sehen werden, nutzt Python Einrückungen als syntaktisches Mittel, z.B. um bei Schleifen den Schleifenkörper zu kennzeichnen. 

Danach bringen Sie die Skriptdatei test1.py (sozusagen das Hauptprogramm) folgendermaßen zur Ausführung:

1) Starten Sie unter MS Windows die Eingabeaufforderung (oder alternativ auch die Windows PowerShell). Das sieht dann etwa so aus:

 Microsoft Windows [Version 10.0.19045.3693]
 (c) Microsoft Corporation. Alle Rechte vorbehalten.
 
 C:\Users\xyz&gt;

: &lt;small&gt;Falls jemand nicht weiß, wie man die Eingabeaufforderung startet: Eine Möglichkeit ist, einfach in der Taskleiste von Windows das &quot;Start&quot;-Symbol &amp;nbsp;([[Image:Windows_logo_-_2021_(Black).svg|10px]])&amp;nbsp; mit der rechten Maustaste anklicken. &quot;Ausführen&quot; auswählen (oder alternativ für die PowerShell unter Windows 10 den Eintrag &quot;Windows PowerShell&quot;, unter Windows 11 den Eintrag &quot;Terminal&quot;). Im sich öffnenden Dialogfenster gibt man in die &quot;Öffnen&quot;-Zeile das Wort &lt;code&gt;cmd&lt;/code&gt; ein und mit &quot;OK&quot; wird das Ganze bestätigt.&lt;/small&gt; 
 
2) Wechseln Sie mittels &lt;code&gt;cd c:\tmp&lt;/code&gt; in das Verzeichnis c:\tmp

3) Angenommen, Sie haben Python unter dem Pfad &lt;code&gt;c:\devel\Python\&lt;/code&gt; installiert. Starten Sie das Programm so (der Prompt &lt;code&gt;c:\tmp&gt;&lt;/code&gt;ist natürlich nicht mit einzutippen): 

 c:\tmp&gt;c:\devel\Python\python.exe test1.py

4) Wie erwartet ergibt sich folgende Ausgabe am Bildschirm

 Hallo Welt!

Die Vorgehensweise unter Linux ist prinzipiell gleich. Die kleinen Unterschiede, wie z.B. der Slash statt dem Backslash in Pfadangaben, sollten für Linux-Benutzer keine Hürde darstellen.

== Variablen ==
Variablenbezeichner können aus Buchstaben (A-Za-z), Ziffern (0-9) und Underscores (_) bestehen, dürfen aber nicht mit einer Zahl beginnen. Führende Underscores haben u.a. im Kontext mit der Objektorientierten Programmierung eine spezielle Bedeutung und sollten nicht für &quot;normale&quot; Variablenbezeichner verwendet werden.

Gültige Variablenbezeichner wären also:
 xyz
 x1
 _wert
 name_anzahl

Theoretisch kann man auch Umlaute, griechische Buchstaben u.ä. in Variablenbezeichnern nutzen, z.B.

 ößÜ = 16
 α = 134 
 print(ößÜ)
 print(α)

Ausgabe:
 16
 134

Davon wird aber aus offensichtlichen Gründen ({{W|Englisch als Lingua franca}}) abgeraten. Das Eurozeichen (€) etc. darf man ohnehin nicht in Variablenbezeichnern verwenden, dies ergäbe einen Syntaxfehler. Siehe dazu auch [https://peps.python.org/pep-3131/].

Es gibt in Python etliche Schlüsselwörter (z.B. for, if oder return). Diese dürfen nicht als eigene Variablenbezeichner verwendet werden. Eine Liste aller Schlüsselwörter liefert das Script

 import keyword
 print(keyword.kwlist)

&lt;small&gt;Übung: Speichern Sie dieses Script in eine Datei, z.B. in c:\tmp\test1.py. Führen Sie diese Datei aus, um die Liste der Schlüsselwörter auszugeben.&lt;/small&gt;

Da Python case-sensitiv ist, repräsentieren folgende Bezeichner verschiedene Variablen:
 xyz
 XYZ
 xYz

Werte werden an Variablen mittels Gleich-Zeichen (=) zugewiesen. Im Folgenden wird der Code immer in der Datei c:\tmp\test1.py gespeichert.

 x = 5
 y = 10
 z = x*y
 print(z)

Bringen Sie die Datei test1.py zur Ausführung, so erhalten Sie folgende Bildschirmausgabe

 50

Sie können auch mehrere Anweisungen in einer Zeile durch Semikolon getrennt schreiben. Dies führt aber zu unübersichtlichem Code.

 x = 5; y = 10; z = x*y; print(z)

Ausgabe:
 50

Auch aus der Programmiersprache C/C++ oder Java bekannte Konstrukte können Sie verwenden, z.B.
 x = 5
 # x = x - 2
 x -= 2
 print(x)

Bildschirmausgabe:

 3
 
Beachten Sie, dass mit dem =-Zeichen eine Wertezuweisung durchgeführt wird. Dies ist nicht äquivalent zum mathematischen =-Zeichen, wie am vorigen Beispiel zu ersehen ist. Den Inkrement-/Dekrementoperator (z.B. x++ oder x--) aus C/C++ oder Java kennt Python aber nicht.

Variablen sind nicht an einen bestimmten Datentyp gebunden, folgendes ist mit Python problemlos möglich:

 import math
 wert = 10
 print(wert)
 wert = 35.5
 print(wert)
 wert = &quot;Hallo&quot;
 print(wert)
 wert = math.pi
 print(wert)

Ausgabe:
 10
 35.5
 Hallo
 3.141592653589793

== Physische und logische Zeilen ==
In Python muss eine Anweisung in einer logischen Zeile Platz finden. Wird eine Anweisung aber zu lang für eine Zeile, dann kann sie in mehrere physische Zeilen unterteilt werden. Dies kann einerseits durch einen Backslash am Ende einer Zeile geschehen, z.B.

 a = 2 + \
 5
 
Dies stellt eine logische Zeile dar, die in zwei physische Zeilen unterbrochen ist.

Geklammerte Ausdrücke werden automatisch zu einer logischen Zeile verbunden, z.B.

 a = (2 + 
 5)
 
Achtung: Im ersten Beispiel darf nach dem Backslash nichts mehr stehen, auch kein Kommentar. Dies trifft im zweiten Bespiel nicht zu, hier könnte noch ein Kommentar folgen, z.B.

 a = (2 +    # Kommentar 
 5)

Auch für Strings gibt es Möglichkeiten, diese auf mehrere Zeilen aufzuspalten.

 # Kurzer String
 str1 = &quot;ABC&quot;
 
 # Langer String
 str2 = &quot;&quot;&quot;Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle&quot;&quot;&quot;
 
 # Backslash
 str3 = &quot;UVW\
 XYZ&quot;
 
 # Mit Klammern
 str4 = (&quot;Sehr langer Text, der automatisch .............. &quot;
         &quot;in einer einzigen Variable zusammengefügt wird.&quot;
 )
 
 print(str1)
 print(str2)
 print(str3)
 print(str4)

Ausgabe:

 ABC
 Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle
 UVWXYZ
 Sehr langer Text, der automatisch .............. in einer einzigen Variable zusammengefügt wird.

==Hexadezimale, oktale, binäre und andere Zahlen==
 d = 1050         # Dezimalzahl
 h = 0xAA2        # Hexadezimalzahl
 o = 0o12         # Oktalzahl
 b = 0b100001101  # Binärzahl
 
 print(d)
 print(h)
 print(o)
 print(b)

Ausgabe:
 1050
 2722
 10
 269

Groß- und Kleinbuchstaben sind in obigen Literalen übrigens egal. So kann man z.B. statt &lt;code&gt;0b1001&lt;/code&gt; auch &lt;code&gt;0B1001&lt;/code&gt; schreiben (siehe dazu [https://docs.python.org/3/reference/lexical_analysis.html#integer-literals]).

Sie können auch dezimale in hexadezimale Zahlen umwandeln, usw.:
 h = hex(1050)    # Dezimalzahl -&gt; Hexadezimalzahl
 b = bin(1050)    # Dezimalzahl -&gt; Binärzahl
 o = oct(1050)    # Dezimalzahl -&gt; Oktalzahl
 print(h)
 print(b)
 print(o)

Ausgabe:
 0x41a
 0b10000011010
 0o2032

Gegeben sei die Zahl 121 zur Basis 3. Diese soll in eine Dezimalzahl umgewandelt werden. Das kann so geschehen:

 z = int(&quot;121&quot;, 3)
 print(z)

Ausgabe:
 16

Dass dies richtig ist, davon kann man sich folgendermaßen überzeugen:
 &lt;math&gt; 1 \cdot 3^2 + 2 \cdot 3^1 + 1 \cdot 3^0 = 9 + 6+ 1 = 16 &lt;/math&gt;

Zahlen übersichtlicher schreiben kann man auch mittels Underscore, z.B.:

 print(&quot;Eine Million (Variante 1) =&quot;, 1000000)
 print(&quot;Eine Million (Variante 2) =&quot;, 1_000_000)
 print(&quot;Eine Rechnung:&quot;, 2_000 * 400_000);

Es ergibt sich bei beiden Varianten die gleiche Ausgabe. Variante 2 ist aber im Sourcecode leichter lesbar, detto die Zahlen in der Rechnung:

 Eine Million (Variante 1) = 1000000
 Eine Million (Variante 2) = 1000000
 Eine Rechnung: 800000000

== Strings und Platzhalter==
Ein paar einfache Beispiele:

 print(&quot;Hallo {}&quot; . format(&quot;Hugo&quot;))     # new style string formatting
 print(&quot;Hallo {:s}&quot; . format(&quot;Hugo&quot;))   # new style string formatting
 print(&quot;Hallo %s&quot; % &quot;Hugo&quot;)             # %-String

Ausgabe:

 Hallo Hugo
 Hallo Hugo
 Hallo Hugo

Python-Code (formatted string literals, Beispiel 1):
 str1 = &quot;Hallo&quot;
 str2 = &quot;Hugo&quot;
 print(f&quot;{str1} {str2}&quot;)

Ausgabe:
 Hallo Hugo

f-Strings (ab Python 3.6) sind die modernere Variante gegenüber %-Strings oder das ''new style string formatting''. Sie sind in der Regel auch schneller.

Python-Code (formatted string literals, Beispiel 2):
 wert = 11.567
 print(f&quot;Ausgabe: {wert:.5f}&quot;)

Ausgabe:
 Ausgabe: 11.56700

Komplexere Beispiele:

 print(&quot;Hallo {} und {}&quot; . format(&quot;Hugo&quot;, &quot;Mike&quot;))
 print(&quot;Hallo {name1} und {name2}&quot; . format(name2=&quot;Hugo&quot;, name1=&quot;Mike&quot;))
 # Füllzeichen: *
 # Bündigkeit: &gt; (=rechts), &lt; (=links), ^ (=zentriert)
 # Feldweite: 10
 # Typ: s (=String), f (=Gleitkommazahl), d (=Dezimalzahl) etc.
 print(&quot;Hallo {:*&gt;10s}&quot; . format(&quot;Hugo&quot;))
 print(&quot;Hallo {:*&lt;10s}&quot; . format(&quot;Hugo&quot;))

Ausgabe:

 Hallo Hugo und Mike
 Hallo Mike und Hugo
 Hallo ******Hugo
 Hallo Hugo******

Python-Code:
 str = &quot;Hallo\t%s\t%7.2f\t%10.2e\t%i&quot; % (&quot;Hugo&quot;, 12.34567, 34.567, 264)
 print(str)

Ausgabe:
 Hallo	Hugo	  12.35	  3.46e+01	264

== Unicode ==
Neben den bekannten ASCII-Zeichen lassen sich Zeichen auch mittels Unicode beschreiben. Griechische Buchstaben oder komplexere mathematische Operatoren - all das sollte kein Problem sein. Siehe auch {{W|Unicode}}, {{W|Liste der Unicodeblöcke}} und {{W|Unicodeblock Mathematische Operatoren}}. Im Folgenden werden ein paar Zeichen (Allquantor, Nabla-Operator, Existenzquantor), die man aus der Mathematik kennt, erzeugt. 
 
 ch1 = &quot;\N{FOR ALL}&quot;
 ch2 = &quot;\N{NABLA}&quot;
 ch3 = &quot;\u2203&quot;
 print(ch1, ch2, ch3)

Ausgabe:
 ∀ ∇ ∃

&lt;small&gt;Diese Ausgabe ergibt sich z.B. mit der IDLE-Shell oder mit Cygwin. Beim Ausführen über die Windows-Eingabeaufforderung oder Windows PowerShell unter MS Windows 10 erfolgt keine korrekte Darstellung. IDLE ist die mit Python mitgelieferte IDE ('''I'''ntegrated '''D'''evelopment '''E'''nvironment, Integrierte Entwicklungsumgebung). Gegen Ende dieses Textes wird IDLE kurz beschrieben.
Das Problem mit der Windows Eingabeaufforderung lässt sich aber umgehen. Man muss nur eine Schriftart auswählen, die die Zeichen kennt, z.B. &quot;DejaVu Sans Mono&quot;. Dazu klicken Sie einfach bei der Eingabeaufforderung mit der rechten Maustaste oben auf die weiße Leiste und wählen im aufpoppenden Fenster den Menüpunkt &quot;Eigenschaften&quot;. Es öffnet sich ein Dialogfenster. Über den Reiter &quot;Schriftart&quot; lässt sich nun die Schriftart einstellen. Unter MS Windows 11 oder openSUSE Leap 15.6 (bash-Konsole) gibt es dieses Problem ohnehin nicht.&lt;/small&gt;

== Reguläre Ausdrücke ==
Python kennt auch {{W|Regulärer Ausdruck|reguläre Ausdrücke}}. Dazu gibt es in Python das Modul &lt;code&gt;re&lt;/code&gt;. Beipielsweise sollen alle Zahlen (&lt;math&gt;\text{zahl}\in\mathbb{N}_0&lt;/math&gt;) in einem String gesucht und ausgegeben werden. Als String sei gegeben: &lt;code&gt;3x Grüße und 100 Kekse.&lt;/code&gt; Das Muster (Pattern) ist &lt;code&gt;\d+&lt;/code&gt;. &lt;code&gt;\d&lt;/code&gt; steht für eine Dezimalziffer 0-9. Das Plus-Zeichen (+) steht symbolisch für ein oder mehrere Zeichen des vorherigen Ausdrucks. Hier also ein oder mehrere Dezimalziffern. Es wird die Funktion &lt;code&gt;findall&lt;/code&gt; aus dem Modul &lt;code&gt;re&lt;/code&gt;verwendet.

Python-Code:
 from re import findall
 
 str = &quot;3x Grüße und 100 Kekse.&quot;
 pat = &quot;\\d+&quot;  # Doppel-Backslashes müssen verwendet werden, sonst gibt Python eine Warnung aus!
               # alternativ: pat = r&quot;\d+&quot; 
               # oder: pat = &quot;[0-9]+&quot;
 
 numb = findall(pat, str)
 print(numb)

Ausgabe:
 ['3', '100']

Python kennt noch viele weitere Möglichkeiten mittels regulärer Ausdrücke zu hantieren. Dies soll hier aber nicht vertieft werden, da das Thema schon ziemlich speziell und komplex ist. Bei Bedarf siehe aber z.B. die Bücher ''Weigend, Seite 380ff'' und ''Ernesti, Kaiser'' [https://openbook.rheinwerk-verlag.de/python/28_001.html] oder die Python-Dokumentation [https://docs.python.org/3/library/re.html]. Auch [[Python unter Linux: Reguläre Ausdrücke]] liefert ein umfangreiches und brauchbares Python-2-Kapitel zu den regulären Ausdrücken. Die dort gelisteten Beispiele müssten ggf. vor Verwendung auf Python-3 umgeschrieben werden. &lt;small&gt;Wie macht  man das? Dazu siehe z.B. [https://openbook.rheinwerk-verlag.de/python/43_001.html], [https://portingguide.readthedocs.io/en/latest/] oder [https://www.digitalocean.com/community/tutorials/how-to-port-python-2-code-to-python-3]&lt;/small&gt;

&lt;small&gt;Es gibt auch ein externes Modul ''regex'', das bei Bedarf extra installiert werden muss ([https://pypi.org/project/regex/]). Es bietet zusätzliche Funktionalität und gründlicheren Unicode-Support. Dies sei hier aber nur der Vollständigkeit halber erwähnt.&lt;/small&gt;

== Verzweigungen ==
=== if ===
Die IF-Verzweigung sei aus anderen Programmiersprachen bereits bekannt. In {{W|Pseudocode}} lässt sie sich folgendermaßen darstellen:

 WENN bedingung TRUE
   führe block1 aus
 SONST
   führe block2 aus
 ENDE 

Als {{W|Aktivitätsdiagramm|UML-Aktivitätsdiagramm}} sieht das in etwa so aus:

[[File:If-Then-Else-diagram.svg|200px]]

Und als {{W|Nassi-Shneiderman-Diagramm|Nassi-Shneiderman-Struktogramm}} so:

[[File:Zweiseitige Auswahl.png|250px]]

In Python gibt es keinen expliziten ENDE-Kennzeichner. Stattdessen wird der Code durch Einrückungen strukturiert. Alles mit der gleichen Einrückungstiefe gehört zum selben Block. Dies zeichnet Python vor anderen Programmiersprachen aus.

Die test1.py-Datei laute also wie folgt:

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
   print(&quot;x ist groesser oder gleich 4&quot;)  

Ausgabe:

 Der else-Zweig wird ausgefuehrt
 x ist groesser oder gleich 4

Man achte auch auf die Doppelpunkte in der if- und else-Zeile. Darauf vergisst man gerne, wenn man von anderen Programmiersprachen kommt.

Folgendes wäre in Python ein Fehler (genauer gesagt ein IndentationError).

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
     print(&quot;x ist groesser oder gleich 4&quot;)  

Auch Nachstehendes würde nicht zum gewünschten Ergebnis führen (löst aber keine Fehlermeldung aus). Der letzte print-Befehl ist schon außerhalb der IF-ELSE-Verzweigung.

 x = 3
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
 print(&quot;x ist groesser oder gleich 4&quot;)

Ausgabe:

 x ist kleiner als 4
 x ist groesser oder gleich 4

Python kennt eine Reihe von Vergleichs- und Verknüpfungsoperatoren:

    &lt;, &lt;= ... kleiner (gleich)
    &gt;, &gt;= ... größer (gleich)
    == ... gleich
    != ... ungleich
    is ... identisch
    is not ... nicht identisch
    and ... AND
    or ... OR
    not ... NOT

Beispielsweise:

 a = 5
 b = 9
 
 if a&lt;=10 and b!=7:
   print(&quot;OK&quot;)
 else
   print(&quot;Nicht OK&quot;)

Ausgabe:

 OK

Der else-Block kann übrigens auch ersatzlos entfallen. Als Pseudocode sieht das so aus

 WENN bedingung TRUE
   führe block aus
 ENDE

Mehrfache Verzweigungen werden durch das elif-Konstrukt erstellt. In Pseudocode:

 WENN bedingung1 TRUE
   führe block1 aus
 SONST WENN bedingung2 TRUE
   führe block2 aus
 SONST WENN bedingung3 TRUE
   führe block3 aus
 SONST
   führe block4 aus
 ENDE

Ein Python-Beispiel:
 a = 14
 
 if a&lt;=10:   
   print(&quot;&lt;=10&quot;)
 elif a&gt;=11 and a&lt;=15:
   print(&quot;11 bis 15&quot;)
 elif a&gt;=16 and a&lt;=20:
   print(&quot;16 bis 20&quot;)
 else:
   print(&quot;&gt;20&quot;)

Ausgabe:

 11 bis 15

In Python gibt es auch die Schlüsselwörter &lt;code&gt;True&lt;/code&gt; (für wahr) und &lt;code&gt;False&lt;/code&gt; (für falsch). Man beachte, dass sie mit Großbuchstaben beginnen. Andere Schreibweisen wären ein Fehler. Sie gehören zum Datentyp &lt;code&gt;bool&lt;/code&gt;. Ihnen sind auch die Zahlen &lt;code&gt;1&lt;/code&gt; und &lt;code&gt;0&lt;/code&gt; zugewiesen.

Man beachte, dass {{W|Rundungsfehler}} auftreten können. D.h. man sollte  bei der Verwendung von {{W|Gleitkommazahl|Gleitpunktzahlen}} niemals auf absolute Genauigkeit prüfen, sondern eine Toleranz (einen &lt;math&gt;\varepsilon&lt;/math&gt;-Wert) vorgeben.
 
Ein klassisches Beispiel, das ein falsches Ergebnis liefert, ist:

 i = 0.1 + 0.2
 
 print(i)
 
 if i == 0.3:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 NOK

Und das, obwohl man schon in der Volksschule lernt, dass 0.1 + 0.2 gleich 0.3 ist.

Korrekt muss das obige Beispiel z.B. so umgeschrieben werden:

 ist = 0.1 + 0.2
 soll = 0.3
 epsilon = 0.000001
 
 print(ist)
 
 if abs(ist-soll) &lt; epsilon:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 OK

Alternativ kann auch die &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion verwendet werden. Das sei aber hier nur erwähnt und nicht konkret ausgeführt.

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet zum Thema &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion.

=== match ===
Ab Python 3.10 gibt es auch die match-Anweisung. Dies ist das Python-Pendant für die switch-Anweisung in anderen Programmiersprachen, geht aber bei näherer Betrachtung weit darüber hinaus. Hier nur ein einfaches Beispiel:

 x = &quot;Hello&quot;
 
 match x:
     case &quot;Servus&quot; | &quot;Ciao&quot;:         # or
         print(&quot;Servus an alle&quot;)
     case &quot;Grüetzi&quot;:
         print(&quot;Grüetzi Schwyzer&quot;)  
     case _:                         # other, default, sonstiges ...
         print(&quot;Hallo Welt&quot;)

Ausgabe: 
 Hallo Welt

Als Struktogramm sieht das in etwa so aus:

[[File:Mehrseitige Auswahl.png|250px]]

Für nähere Details siehe z.B. [https://www.geeksforgeeks.org/python-match-case-statement/], [https://learnpython.com/blog/python-match-case-statement/], [https://docs.python.org/3/tutorial/controlflow.html#match-statements] und das Python Enhancement Proposal (PEP) 636 – Structural Pattern Matching: Tutorial [https://peps.python.org/pep-0636] und dort insbesondere den Anhang A - Quick Intro.

&lt;small&gt;&lt;code&gt;match, case, _&lt;/code&gt; etc. sind sogenannte ''soft keywords''. Im Gegensatz zu den normalen Schlüsselwörtern dürfen ihnen auch Werte zugewiesen werden. Eine Liste der weichen Schlüsselwörter lässt sich durch &lt;code&gt;keyword.softkwlist&lt;/code&gt; erstellen (die Anweisung gibt es seit Python 3.9). Siehe dazu auch [https://stackoverflow.com/questions/65800344/what-are-soft-keywords] und [https://docs.python.org/3/library/keyword.html#keyword.softkwlist].&lt;/small&gt;

== Schleifen ==
Kopfgesteuerte Schleife, Endlosschleife und fußgesteuerte Schleife:

[[File:Programmingloops.svg|450px]]

=== while ===
Die WHILE-Schleife ist kopfgesteuert. Sie funktioniert wie aus anderen Programmiersprachen bekannt. 

In Pseudocode:
 SOLANGE bedingung TRUE
   führe block aus
 ENDE

In Python:
 x = 0
 
 while x &lt;= 10:
   print(x)
   x += 1

Ausgabe:
 0
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10

Eine Endlosschleife ergibt sich z.B. so:
 i = 5
 
 while True:
     print(i)
     i-=1

Beendet werden kann sie mit der Tastenkombination STRG-C.

Eine fußgesteuerte Schleife kann so simuliert werden:
 i = 5
 
 while True:
     print(i)
     i-=1
 
     if i&lt;=0:
         print(&quot;Fire&quot;)
         break

Ausgabe:
 5
 4
 3
 2
 1
 Fire

Der &lt;code&gt;break&lt;/code&gt;-Befehl wird etwas später noch einmal kurz thematisiert.

=== for ===
Struktogramm einer for-Schleife:

[[File:Zählschleife.png|200px]]

In Python bspw. so:

 for x in range(6):
   print(x*2)

Ausgabe:
 0
 2
 4
 6
 8
 10

Die Schleife läuft von 0 bis 5. Ausgegeben wird jeweils der Wert x*2. Aquivalent kann diese Schleife auch so geschrieben werden:
 for x in range(0, 11, 2):
   print(x)

Die Ausgabe ist wie oben. Der Startwert sei 0, der Endwert ist 11-1 und die Schrittweite ist 2.

Ein anderes Beispiel sei
 for x in &quot;text&quot;:
   print(x)

Ausgabe:
 t
 e
 x
 t

== Schleifen abbrechen ==
=== break ===
&lt;code&gt;break&lt;/code&gt; bricht die Schleife ab und setzt mit dem nächsten Befehl außerhalb der Schleife fort.

 for var in range(100):
   print(var) 
   if var == 5:
     break

Ausgabe:
 0
 1
 2
 3
 4
 5

=== continue ===
&lt;code&gt;continue&lt;/code&gt; bricht den aktuellen Schleifendurchlauf ab und setzt mit dem nächsten Schleifendurchlauf fort.

 for var in range (11):
   if var == 5:
     continue
   print(var)

Ausgabe:
 0
 1
 2 
 3
 4
 6
 7
 8
 9
 10

== try - except ==
 try:
     z1 = 12 / 0
     print(z1)
 except ZeroDivisionError:
     print(&quot;Das Ergebnis ist unendlich&quot;)
 except:
     print(&quot;Kann nicht berechnet werden!&quot;)
     print(&quot;Bitte die Formel korrigieren!&quot;)
 
 print(&quot;Setze Programm fort!&quot;)

Ausgabe:
 Das Ergebnis ist unendlich
 Setze Programm fort!

Es wird versucht, eine Zahl durch Null zu dividieren. Das ist nicht möglich, es wird eine Ausnahme ausgelöst. Das Programm springt daher in den except-ZeroDivisionError-Block und führt die dort gelisteten Anweisungen aus (in unserem Fall eine print-Anweisung). Danach wird das Programm fortgesetzt. Würden wir dieses Programm ohne try-except ausführen, so ergibt sich aus

 z1 = 12 / 0
 print(z1)

folgende Fehlermeldung und ein unmittelbarer Programmabbruch

 Traceback (most recent call last):
   File &quot;C:\tmp\test1.py&quot;, line 1, in &lt;module&gt;
     z1 = 12 / 0
 ZeroDivisionError: division by zero

Mit dem try-except-Mechanismus können also Ausnahmen oder Fehler aufgefangen und behandelt werden. In unserem Beispiel ist das eher trivial, aber bei größeren Programmen kann das durchaus Sinn machen.

Neu in Python 3.14 ist, dass mehrere Ausnahmen auch ohne Klammern angegeben werden können, z.B.:

bis inkl. Python 3.13 nur:
 except (ZeroDivisionError, ValueError):

ab Python 3.14 auch:
 except ZeroDivisionError, ValueError:

== pass ==
Ein leerer Block muss in Python mittels dem Schlüsselwort &lt;code&gt;pass&lt;/code&gt; dargestellt werden. Z.B.

 x = 2
 
 if x == 1:
     print(&quot;Wert ist &quot;, x)
 else:
     pass

Würde man das &lt;code&gt;pass&lt;/code&gt; im else-Block weglassen, so würde man eine Fehlermeldung erhalten:

 IndentationError: expected an indented block after 'else' statement on line 5

= Funktionen =
== Aufrufen von Funktionen ==
Funktionen sind uns im Rahmen dieses Kurses schon zuhauf begegnet. Sei es die print()-, die math.sin()- oder die hex()-Funktion. All diese Funktionen werden von Python zur Verfügung gestellt, ohne dass man sie explizit programmieren müsste. Aufgerufen werden diese Funktionen, indem man ihren Namen eintippt, gefolgt von runden Klammern. In diesen Klammern können noch Argumente übergeben werden. Auch Rückgabewerte sind möglich.

== Funktionen selber schreiben ==
Funktionen werden mit dem def-Schlüsselwort (man definiert die Funktion) eingeleitet, danach folgt der Funktionsname, danach wiederum runde Klammern, in denen formale Argumente stehen können. Abgeschlossen wird die def-Zeile mit einem Doppelpunkt. Danach folgt der Funktionskörper. Dieser Funktionskörper muss wiederum eingerückt werden (wie von den Verzweigungen und Schleifen bekannt). Aufgerufen wird diese Funktion, indem man ihren Funktionsnamen eingibt, gefolgt von runden Klammern (ggf. mit den aktuellen Parametern). Z.B.

 # Funktion definieren
 def halloWelt(i):
     # i ... beliebige Ganzzahl
     print(&quot;Hallo &quot; * i, end=&quot;&quot;)
     print(&quot;Welt!&quot;)
    
 # Funktion aufrufen
 halloWelt(3)

Ausgabe:
 Hallo Hallo Hallo Welt!

Unterschied zwischen formalen und aktuellen Parametern:

[[Datei:PythonIng_func1.jpg]]

&lt;small&gt;Aktuelle Parameter werden auch Argumente genannt.&lt;/small&gt;

Rückgabe von Funktionswerten:
 # Funktion definieren
 def mathFunc(a, b):
     r1 = a + b
     r2 = a * b
     return r1, r2
    
 # Funktion aufrufen
 c, d = mathFunc(3, 5)
 
 # Ausgabe der zurückgegebenen Werte
 print(c)
 print(d)

Ausgabe:
 8
 15

Es werden r1 und r2 zurückgegeben und den Variablen c und d zugewiesen. (r1, r2) und (c, d) sind Tupel. Was Tupel konkret sind, siehe etwas später in diesem Kapitel. 3 und 5 sind die aktuellen Parameter (die Argumente). a und b sind die formalen Parameter. Die Zuweisung der aktuellen zu den formalen Parametern erfolgt in der gegebenen Reihenfolge, also die Zahl 3 wird an a übergeben und die Zahl 5 an b.

Vorgabeparameter, z.B.:
 def mathFunc(a=10, b=20):
     r1 = a + b
     r2 = a * b
     return r1, r2
 
 c, d = mathFunc(3, 5)
 print(c)
 print(d) 
 
 e, f = mathFunc(5)
 print(e)
 print(f)
 
 g, h = mathFunc(b=6)
 print(g)
 print(h)

Ausgabe:
 8
 15
 25
 100
 16
 60

Erklärung:
* Erster &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es werden, wie weiter oben, die Argumente 3 und 5 an die formalen Parameter a und b übergeben. Die Rückgabewerte r1 und r2 werden an c und d übergeben. Somit ist c=8 und d=15.
* Zweiter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur das Argment 5 an a übergeben. b behält den Vorgabewert 20. D.h. e= 25 und f=100.
* Dritter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur die Zahl 6 an b übergeben, a behält seinen Vorgabewert 10. Somit ergibt sich g=16 und h=60.

Beispiel (Schlüsselwortargumente vs. Positionsargumente):
 def mathFunc(a, b):
     r1 = a - b
     r2 = a / b
     return r1, r2
 
 c, d = mathFunc(b=3, a=5)  # Schlüsselwortargumente
 e, f = mathFunc(3, 5)      # Positionsargumente

 print(c)
 print(d)
 print(e)
 print(f)

Ausgabe:
 2
 1.6666666666666667
 -2
 0.6

Durch die Verwendung von Schlüsselwortargumenten können die Argumente in beliebiger Reihenfolge angegeben werden. Bei den Positionsargumenten ist die Reihenfolge vorgegeben. Daraus resultiert auch der Unterschied bei den obigen Ausgaben. Werden beide Arten in einem Aufruf gemischt, so müssen die Positionsargumente zuerst angegeben werden. Den Unterschied zwischen beiden Argumentarten zu kennen ist wichtig, nicht nur bei selbst erstellten Funktionen. Auch beim Aufruf von Python-Funktionen verfolgt einen die Mischung von Schlüsselwort- und Positionsargumenten auf Schritt und Tritt, z.B. beim etwas später folgenden Abschnitt über &quot;Grafiken zeichnen&quot;:

 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)

Bei dieser &lt;code&gt;plot&lt;/code&gt;-Funktion aus dem Modul &lt;code&gt;matplotlib.pyplot&lt;/code&gt; sind &lt;code&gt;x&lt;/code&gt; und &lt;code&gt;y1&lt;/code&gt; Positionsargumente. &lt;code&gt;label, lw&lt;/code&gt; und &lt;code&gt;ls&lt;/code&gt; sind die Namen der Schlüsselwortargumente. Die Schlüsselwortargumente könnten auch in anderer Reihenfolge angeschrieben werden, nicht jedoch die Positionsargumente!
Siehe zu &lt;code&gt;matplotlib.pyplot.plot&lt;/code&gt; auch die Seite [https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html].

== Lambda-Funktionen ==
 print((lambda a, b: a*b) (3, 5))

Ausgabe:
 15

Eingeleitet wird eine Lambda-Funktion (auch Lambda-Form, Lambda-Operator oder anonyme Funktion genannt) mit dem Schlüsselwort &lt;code&gt;lambda&lt;/code&gt;. Es folgen die formalen Argumente, danach ein Doppelpunkt, die Berechnungsvorschrift und ggf. abschliessend in Klammern die aktuellen Parameter.

Man kann einer Lambda-Funktion auch einen Funktionsnamen geben und die Funktion über diesen Namen aufrufen, z.B.

 prod = lambda a, b: a*b
 print(prod(3, 5))

Als Ausgabe wird wieder die Zahl 15 geliefert.

== Rekursive Funktionen ==
Funktionen können wiederum andere Funktionen aufrufen. Von einem {{W|Rekursion|rekursiven Funktionsaufruf}} spricht man, wenn die aufgerufene Funktion gleich der aufrufenden ist. 

 def printFunc(i):
     if (i &gt;= 5):
         return 
     else:
         print(&quot;Hallo Welt&quot;)
         printFunc(i+1)
         
 printFunc(1)

Ausgabe:
 Hallo Welt
 Hallo Welt
 Hallo Welt
 Hallo Welt

Typische Beispiele für die Abarbeitung als rekursive Funktionen sind die {{W|Fibonacci-Folge}} und die {{W|Fakultät_(Mathematik)|Fakultät}}. Jedoch ist der iterative Ansatz (mit konventionellen Schleifen) meist schneller und speicherplatzschonender.

== Funktionsannotationen ==
Python ist sehr flexibel, was Typen angeht. Im Vorhergehenden haben wir generell keine Typangaben gemacht. Will man Typen angeben, so bietet Python das Konzept der Funktionsannotation.

 def calcFunc(a: int, b: int) -&gt; int:
     return a+b
 
 r1 = calcFunc(8, 9)
 r2 = calcFunc(8.0, 9.0)
 r3 = calcFunc(&quot;Hallo&quot;, &quot;Welt&quot;)
 
 print(r1)
 print(r2)
 print(r3)

Ausgabe:
 17
 17.0
 HalloWelt

Jetzt sieht man auf den ersten Blick, welche Typen der Programmierer im Sinn hatte, als er die Funktion erstellte. Das Problem dabei ist nur, dass es Python ziemlich egal ist, welche Typen man im Endeffekt eingibt. Im obigen Beispiel können statt Integer-Typen u.a. auch Float- oder String-Typen eingegeben werden.

&lt;small&gt;
Siehe zum Thema &quot;Type Checking&quot; aber auch den später folgenden Abschnitt [[Ing_Mathematik:_Python#Type_Checker]].
&lt;/small&gt;

== Variadische Funktionen ==
Python-Code:

 def test1(a, *b):
     print(a);
      
     for c in b:
         print(c);
        
 test1(&quot;Hallo&quot;, &quot;Welt&quot;, &quot;Schweizer&quot;, &quot;und alle anderen&quot;)

Ausgabe:

 Hallo
 Welt
 Schweizer
 und alle anderen

Mit dem Stern (auch als Splat-Operator bezeichnet) in der formalen Parameterliste bei der Funktion &lt;code&gt;test1&lt;/code&gt; wird angezeigt, dass eine beliebige Anzahl von Argumenten übergeben wird. &lt;small&gt; Dies entspricht in etwa dem, was in anderen Programmiersprachen (PHP etc.) mittels Ellipse (&lt;code&gt;...&lt;/code&gt;) angezeigt wird.&lt;/small&gt;

= Tupel, Listen und andere =
[[Datei:Python 3. The standard type hierarchy.png|mini|hochkant=1.7|Datentypen und Strukturen]]

== Tupel und Listen ==
Tupel, Listen und einige andere sind Datenstrukturen oder Sequenzen.

Listen (z.B. eine Einkaufsliste) sind veränderbar (mutable). Ein Tupel kann dagegen nicht verändert werden (immutable). Listen werden beim Anlegen in eckige Klammern eingeschlossen, Tupel in runde Klammern. Beim Tupel können die Klammern auch weggelassen werden. Ein Tupel mit nur einem Element muss mit einem Beistrich abgeschlossen werden. Der Grund ist, dass Python sonst nicht entscheiden kann, ob ein Tupel angelegt werden soll, oder nur ein geklammerter Wert. 

Als Gedächtnisstütze kann man sich den Unterschied zwischen Tupel und Liste ev. so leichter merken:
: T'''u'''pel ... r'''u'''nde Klammern, '''u'''nveränderlich
: L'''i'''ste ... eck'''i'''ge Klammern, veränderl'''i'''ch.

Nachfolgend werden einige Operationen mit Listen und Tupel dargestellt.

 # Liste und Tupel
 liste = [1, 2, &quot;Hallo&quot;]
 tupel = (1, 2, &quot;Hallo&quot;) 
 
 # Ausgabe von liste und tupel
 print(liste)
 print(tupel)
 
 # Ausgabe von Einzelelementen
 print(liste[1])
 print(tupel[2])
 
 # Element an Liste anhängen und einfügen 
 liste.append(55)
 liste.insert(4, &quot;Welt&quot;)
 print(liste)
 
 # Element aus Liste entfernen
 liste.remove(1)
 print(liste)
 
 # einige weitere Beispiele
 liste2 = [1,]
 tupel2 = 1, 2
 tupel3 = (1,) 
 print(liste2)
 print(tupel2)
 print(tupel3)

Ausgabe:
 [1, 2, 'Hallo']
 (1, 2, 'Hallo')
 2
 Hallo
 [1, 2, 'Hallo', 55, 'Welt']
 [2, 'Hallo', 55, 'Welt']
 [1]
 (1, 2)
 (1,)

Beispiel (eine Liste von Wörtern zu einem einzigen zusammenhängenden Text verbinden):

 woerter = [&quot;Hallo&quot;, &quot;Welt&quot;]
 satz = &quot; &quot;.join(woerter)
 print(satz)

Ausgabe:

 Hallo Welt

== Dictionaries und Mengen ==
Zu den Datenstrukturen gehören weiters auch Mengen und Dictionaries. Mengen sind von der Mathematik bekannt, sie sind ungeordnet und es kommen keine mehrfachen Elemente vor. Dictionaries sind durch Schlüssel :Wert-Paare gekennzeichnet. Mengen werden beim Anlegen wie Dictionaries in geschweifte Klammern eingeschlossen.

 dict = {&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot; }
 menge = {1, 1, 3, 4, 4, 4, &quot;Hallo&quot;}
 
 print(dict)
 print(menge)
 print(dict[&quot;vorname&quot;])

Ausgabe:
 {'vorname': 'Hugo', 'nachname': 'Meister'}
 {1, 3, 4, 'Hallo'}
 Hugo

Geschweifte Klammern ohne Inhalt stellen Dictionaries dar und keine Mengen:

 di = {}
 print(type(di))

Ausgabe:
 &lt;class 'dict'&gt;

Leere Mengen lassen sich mit &lt;code&gt;set()&lt;/code&gt; erzeugen:

 menge = set()      # leere Menge
 print(menge)
 menge.add(&quot;Hallo&quot;) # Element hinzufügen
 print(menge)

Ausgabe:
 set()
 {'Hallo'}

Beispiel (einige Mengenoperationen):
 mengeA = {&quot;Hallo&quot;, &quot;Welt&quot;}
 mengeB = {1, 2, &quot;Welt&quot;, 3}
 
 # Vereinigung
 print(mengeA | mengeB)
 print(mengeA.union(mengeB))
 
 # Durchschnitt
 print(mengeA &amp; mengeB)
 print(mengeA.intersection(mengeB))
 
 # Differenz
 print(mengeA - mengeB)
 print(mengeA.difference(mengeB))
 
 # Symmetrische Differenz
 print(mengeA ^ mengeB)
 print(mengeA.symmetric_difference(mengeB))
 
 # Teilmenge
 print(mengeA.issubset(mengeB))
 
 # Mehrere Elemente hinzu
 mengeA.update([&quot;Super&quot;, 67, 125])
 print(mengeA)
 
 # Element löschen
 mengeA.discard(&quot;Hallo&quot;)
 print(mengeA)

Ausgabe:
 {1, 2, 3, 'Welt', 'Hallo'}
 {1, 2, 3, 'Welt', 'Hallo'}
 {'Welt'}
 {'Welt'}
 {'Hallo'}
 {'Hallo'}
 {1, 2, 3, 'Hallo'}
 {1, 2, 3, 'Hallo'}
 False
 {67, 'Super', 'Welt', 'Hallo', 125}
 {67, 'Super', 'Welt', 125}

Es gibt schon seit &quot;ewigen&quot; Zeiten unveränderbare Mengen, die mittels &lt;code&gt;frozenset&lt;/code&gt; eingeleitet werden. Neu ab Python 3.15 ist dagegen das Pendant &lt;code&gt;frozendict&lt;/code&gt;, das unveränderbare Dictionaries darstellt.

 fdict = frozendict({&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot;})
 fset = frozenset({&quot;A&quot;, 1, &quot;A&quot;})
 
 print(fdict)
 print(fdict[&quot;vorname&quot;])
 print (fset) 
 
 try:
     fdict[&quot;vorname&quot;] = &quot;Max&quot;
     print(fdict[&quot;vorname&quot;])
 except TypeError as e:
     print(f&quot;Fehler: {e}&quot;)
 
 try:
     fset.add(&quot;B&quot;)
     print(fset)
 except AttributeError as e:
     print(f&quot;Fehler: {e}&quot;)

Ausgabe:
 frozendict({'vorname': 'Hugo', 'nachname': 'Meister'})
 Hugo
 frozenset({1, 'A'})
 Fehler: 'frozendict' object does not support item assignment
 Fehler: 'frozenset' object has no attribute 'add'

== List Comprehensions ==
Aus einer Eingabeliste soll eine Ausgabeliste erzeugt werden. Das kann folgendermaßen geschehen.

Mathematische Schreibweise: &lt;math&gt;lc = \{2x|x\in\ \mathbb{N}, 1\le x &lt; 11\}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11)]
 print(lc)

Ausgabe:
 [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Mathematische Schreibweise: &lt;math&gt;lc = \{2x | x \in \mathbb{N}, 1\le x &lt; 11, x \bmod 2 = 0 \}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11) if x%2 == 0]
 print(lc)

Ausgabe:
 [4, 8, 12, 16, 20]

Siehe auch {{W|List Comprehension}}.

== Set Comprehensions ==
Dies ist sehr ähnlich wie im vorigen Abschnitt beschrieben. Es wird aber keine Liste, sondern eine Menge erzeugt.

 sc = {x*2 for x in range(1,11)}
 print(sc)

Ausgabe:
 {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}

== Listen zusammenführen - zip() ==
 li1 = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]
 li2 = [1, 2, 3, 4]
 li3 = [5.5, 6.6, 7.7, 8.8]
 
 z = zip(li1, li2, li3)
 print(z)
 
 li4 = list(z)
 print(li4)

Ausgabe:
 &lt;zip object at 0x00000283B6C6AC80&gt;
 [('A', 1, 5.5), ('B', 2, 6.6), ('C', 3, 7.7), ('D', 4, 8.8)]

== Generatorausdruck ==
 g = (i*2 for i in range(1,11))
 print(g)
 t = tuple(g)
 print(t)
 print(t[1:3])

Ausgabe:
 &lt;generator object &lt;genexpr&gt; at 0x00000241D2A4A5A0&gt;
 (2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
 (4, 6)

== Slicing ==
slice ... Scheibe, Teil, in Scheiben schneiden

Beispiel: Zugriff auf Elemente eines geordneten sequentiellen Objekttyps (Liste, Tupel oder String):

 str1 = &quot;Hallo&quot;
 # Das erste Element wird mit dem Index 0 angesprochen
 # [start (inkl.) : stop (exkl.) : step (default=1)]
 str2 = str1[0:2]
 # Alternativ auch: str2 = str1[:2] 
 print(str2)
 
 tup1 = (0,1,2,3)
 # Das letzte Element hat auch den Index -1, das vorletzte den Index -2 usw.
 tup2 = tup1[-3:-1]
 print(tup2)
 
 lst1 = [[1,  5,  10, 20],
         [30, 40, 50, 60]]
 lst2 = lst1[1][1]
 print(lst2)
 
Ausgabe:
 Ha
 (1, 2)
 40

Beispiel:

 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2])
 print(x[-3]) 
 print(x)
 print(x[:])
 print(x[2:])
 print(x[:2])
 print(x[::-1])

Ausgabe:

 c
 c
 ('a', 'b', 'c', 'd', 'e')
 ('a', 'b', 'c', 'd', 'e')
 ('c', 'd', 'e')
 ('a', 'b')
 ('e', 'd', 'c', 'b', 'a')

Visualisierung:

    '''a'''     '''b'''     '''c'''     '''d'''     '''e'''
 +-----------------------------+
 |  0  |  1  |//'''2'''//|  3  |  4  |
 +-----------------------------+
 | -5  | -4  |/'''-3'''//| -2  | -1  | 
 +-----------------------------+
 |/////////////////////////////|
 +-----------------------------+
 |/////////////''':'''///////////////|
 +-----------------------------+
 |     |     |///////'''2:'''////////|
 +-----------------------------+
 |////''':2'''/////|     |     |     |
 +-----------------------------+
 |\\\\\&lt;--\\\\\'''::-1'''\\\\&lt;--\\\\\|
 +-----------------------------+

Beispiel:
 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2::2])
 print(x[2::-1])
 print(x[2:0:-1])

Ausgabe:

 ('c', 'e')
 ('c', 'b', 'a')
 ('c', 'b')

Hier sieht man sehr schön, dass beim letzen &lt;code&gt;print&lt;/code&gt;-Befehl die 0, die in diesem Fall den Buchstaben &quot;a&quot; repräsentiert, als letzer Wert nicht mehr dazugehört (wie weiter oben angedeutet ist der End- oder Stoppwert exklusiv). Will man den Buchstaben &quot;a&quot; dazunehmen, so ist die vorletzte Zeile die richtige.

Beispiel: Umdrehen von Strings

 str1 = &quot;Hallo&quot;
 str2 = str1[::-1]
 print(str2)

Ausgabe:
 ollaH

Mit zweidimensionalen Listen/Tupels wird das Ganze schon bedeutend komplexer.

Beispiel: Verkettetes Slicing

 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
     
 print(A[2::][::2])

Ausgabe:

 [['20', '21', '22', '23'], ['40', '41', '42', '43']]

Das erste Slicing erstellt folgenden Slice:

 [[&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
  [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
  [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]

Das zweite Slicing wird dann auf diesen Slice angewendet und ergibt das genannte Endergebnis. Will man Spalten statt Zeilen, so funktioniert dieser direkte Weg nicht. Man verwendet dann List Comprehensions oder die NumPy-Bibliothek. Diese Bibliothek erlaubt [[Ing_Mathematik:_Python#Zugriff_auf_Matrizenelemente|zweidimensionales Slicing]]. Sie wird erst später bei den Grafiken eingeführt. Deshalb wird hier dazu noch kein Beispiel gezeigt.

= Objektorientierte Programmierung =
{{Wikipedia|Objektorientierte Programmierung}}

* {{W|Klasse (Objektorientierung)|Klasse}} ... die Schablone oder der Bauplan, enthält Methoden und Attribute
* {{W|Objekt (Programmierung)|Objekt}} ... eine Klasseninstanz (die konkrete Ausprägung der Klasse)
* {{W|Attribut (Programmierung)|Attribute}} ... die Eigenschaften eines Objekts
* {{W|Methode (Programmierung)|Methoden}} ... die Aktionen (Operationen), die ein Objekt ausführen kann
* {{W|Vererbung (Programmierung)|Vererbung}} ... neue Klassen (Subklassen, Unterklassen, abgeleitete Klassen) aus vorhandenen Klassen (Superklassen, Oberklassen, Basisklassen, Elternklassen) ableiten. Ermöglicht den Aufbau von Klassenhierarchien. Die Subklasse &quot;erbt&quot; Attribute und Methoden von der Superklasse. Python unterstützt (so wie C++, aber im Gegensatz zu Java) Mehrfachvererbung.

== UML ==
* {{W|Unified Modeling Language|UML}} ... '''U'''nified '''M'''odeling '''L'''anguage, eine Modellierungssprache. Die UML enthält zahlreiche Diagrammarten, um Programme zu modellieren. Im Nachfolgenden wird nur das {{W|Klassendiagramm}} verwendet.

[[File:UmlCd Klasse-3.svg|300px]]

* {{W|Sichtbarkeit (Programmierung)|Sichtbarkeit}}:
** + ... public (öffentlich)
** - ... private
** # ... protected 

* {{W|Attribut_(UML)#Attribute_für_Instanzen_und_für_Klassen|Klassenattribute}} (statische Attribute): Werden nur einmal pro Klasse angelegt. Im Klassendiagramm werden sie unterstrichen.

[[File:Attribute-3.png|200px]]

* Vererbung:

&lt;gallery&gt;
InheritancePgmUML.svg | Abgeleitete Klasse erbt von Basisklasse (Einfachvererbung)
Diamond inheritance.svg | D erbt von B und C (Mehrfachvererbung). B und C erben von A (Einfachvererbung)
&lt;/gallery&gt;

Für weitergehende Betrachtungen zur UML wird auf Spezialliteratur verwiesen, z.B.:
* Seidl et al.: UML@Classroom. dpunkt, 2012, ISBN 978-3-89864-776-2
* Rupp et al.: UML 2 glasklar. Hanser, 4. Aufl., 2012, ISBN 978-3-446-43057-0

== Eine einfache Klasse ==

[[Datei:PythonIng_uml1.svg | 200px]]

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
 
 fahr = Fahrzeug(150, 90)
 
 print(fahr.convertGeschw())
 
Ausgabe:
 41.666666666666664

Die Klasse Fahrzeug wird durch das class-Schlüsselwort eingeleitet. raeder ist ein Klassenattribut und public. __init__ wird bei der Objekterzeugung automatisch aufgerufen (ist der sogenannte Konstruktor). Man achte darauf, dass diese Methode immer mit zwei Unterstrichen eingeleitet und abgeschlossen wird. Instanzattributen wird das Wort self vorangestellt. Wir sehen uns z.B. das Attribut self.__geschwind an. Auch hier werden zwei Unterstriche verwendet. Das bedeutet, dass dieses Attribut strikt/stark private ist. Wird nur ein Unterstrich verwendet, so deutet dies auf schwach/weakly private hin. Letzteres wird in Python deutlich häufiger verwendet. Bei den Methoden wird immer self als erster Parameter angegeben. Beim Aufruf der entsprechenden Funktion wird das self aber nicht berücksichtigt.

Besonderheiten bei stark und schwach private:
* '''stark private''':
** zwei führende Unterstriche
** Name Mangling: Name wird zu &lt;code&gt;_Klassenname__variablenname&lt;/code&gt;
** Schutz vor Namenskollisionen bei Vererbung
** am Ende des Namens dürfen keine zwei Unterstriche verwendet werden. Das wären dann Magic Methods oder Dunder-Methods (z.B. __init__). Diese sind public.

* '''schwach private''':
** ein führender Unterstrich
** Name bleibt gleich
** ist nur ein Hinweis an die Programmierer, kein starker Schutz
** &lt;code&gt;from modul import *&lt;/code&gt;: Objekte mit einem führenden Unterstrich werden standardmäßig nicht importiert
** Standard für die Kapselung bei Python. Schätzung: Weit mehr als 80% der nicht-öffentlichen Attribute/Methoden werden als schwach private deklariert. Weniger als 5-10% als stark private (Quelle: Google KI)

== Klassen importieren ==
Häufig ist es sinnvoll und übersichtlicher Klassen in eigenen Dateien zu speichern. Das sind dann eigene Module. Abgespeichert werden Sie mit der Endung py, wie bisher auch praktiziert. Aufgerufen werden Sie mit der import-Anweisung. Dann ist aber nur der Dateiname ohne Endung py zu verwenden. Klarer wird das mit einem Beispiel.

Datei c:\tmp\fahrzeug.py

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6

Datei c:\tmp\test1.py

 import fahrzeug
 fahr = fahrzeug.Fahrzeug(150, 90)
 print(fahr.convertGeschw())

Ausgabe:
 41.666666666666664

Die üblichen import-Anweisungen lauten wie folgt:
{| {{prettytable}}
! import-Befehl
! Instanz
|-
| import xyz      || xyz.Klasse
|-
| import xyz as x || x.Klasse
|-
| from xyz import Klasse || Klasse
|-
| from xyz import * || Klasse 
|}

Der Vorteil der ersten beiden import-Anweisungen ist, dass es kaum zu Namenskollisionen kommen kann. Dafür hat man bei den letzten beiden Varianten weniger Tipparbeit.

== Vererbung ==
=== Einfachvererbung ===

[[Datei:PythonIng_uml2.svg | 200px]]

Datei fahrzeug.py:
 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
        
     def setLeistung(self, leistung):
         self.__leistung = leistung
        
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
        
 class Luftfahrzeug(Fahrzeug):
     def __init__(self, geschwindigkeit, leistung, fluegel):
         super().__init__(geschwindigkeit, leistung)
         self.__flueg = fluegel
     
     def getFlueg(self):
         return self.__flueg

Datei test1.py:
 import fahrzeug
 fahr = fahrzeug.Luftfahrzeug(150, 90, 4)
 print(fahr.getFlueg())

Ausgabe:
 4

=== Mehrfachvererbung ===
Mit Python ist auch Mehrfachvererbung möglich, z.B.:

 class A:
     def _printA(self):
         print(&quot;Klasse A&quot;)
 
 class B:
     def _printB(self):
         print(&quot;Klasse B&quot;)
 
 class C(A,B):
     def __init__(self):
         self._printA()
         self._printB()
 
 c = C()

Ausgabe:

 Klasse A
 Klasse B

Die Klasse C erbt von A und B. In UML sieht das in etwa so aus:

 +-----------------------------+   +-------------------------+
 |            A                |   |          B              |
 +-----------------------------+   +-------------------------+
 |                             |   |                         |
 +-----------------------------+   +-------------------------+
 | # printA()                  |   | # printB()              |
 +-----------------------------+   +-------------------------+
                           .              .
                          / \            / \
                          ---            ---
                           |              |
                           |              |
                        +---------------------+
                        |          C          |
                        +---------------------+
                        |                     |
                        +---------------------+
                        |                     |
                        +---------------------+

&lt;code&gt;printA()&lt;/code&gt; und &lt;code&gt;printB()&lt;/code&gt; sind schwach private (in UML als &lt;code&gt;protected&lt;/code&gt; mit einem # dargestellt). Es ist aber zu beachten, dass schwach private nur Konvention ist. Praktisch könnte man auch von außerhalb auf diese Methoden zugreifen. Das soll man aber nicht tun, und das wird in Python durch einen Unterstrich angedeutet.

== Statische Attribute, statische Methoden und Klassenmethoden ==
Beispiel:

 class Math:
     pi = 3.14159265
     cnt = 0
     
     @staticmethod
     def expo():
         return 2.71828183
    
     @classmethod    
     def counterPlus(cls):
         cls.cnt += 1
        
 print(Math.pi)
 print(Math.expo())
 
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)

Ausgabe:

 3.14159265
 2.71828183
 1
 2
 3

Statische Attribute und Methoden, bzw. Klassenmethoden, sind direkt einer Klasse zugeordnet und nicht einem Objekt. Der Unterschied zwischen statischen Methoden und Klassenmethoden ist, dass statische Methoden nicht auf Klassenattribute (bzw. statische Attribute) zugreifen können, Klassenmethoden aber schon. &lt;code&gt;pi&lt;/code&gt; und &lt;code&gt;cnt&lt;/code&gt; sind statische Attribute. &lt;code&gt;expo()&lt;/code&gt; ist eine statische Methode. &lt;code&gt;counterPlus(cls)&lt;/code&gt; ist eine Klassenmethode. Die Bezeichnung des Parameters als &lt;code&gt;cls&lt;/code&gt; ist reine Konvention, man sollte sich aber daran halten.

= Grafiken zeichnen =
Für das Zeichnen von Grafiken wird hier das Modul &lt;code&gt;matplotlib&lt;/code&gt; verwendet. &lt;code&gt;matplotlib&lt;/code&gt; ist ein externes Modul und muss vor der ersten Verwendung installiert werden. Das geht so:

# Starten Sie ein Terminal (bei Windows die Eingabeaufforderung).
# Führen Sie darin folgenden Befehl aus &lt;code&gt;c:\devel\Python\Scripts\pip.exe install matplotlib&lt;/code&gt;

pip ist übrigens der Paketmanager von Python ({{W|Pip_(Python)}}). 

Optimalerweise installieren wir auch gleich das Modul &lt;code&gt;numpy&lt;/code&gt; (Numerical Python). Wir werden es im Folgenden oft benötigen (nicht nur bei den Grafiken). Das funktioniert vom Prinzip her genauso, wie für &lt;code&gt;matplotlib&lt;/code&gt; gezeigt.

&lt;small&gt;Verwenden Sie Spyder, so sind diese Schritte nicht nötig. Spyder inkludiert diese Pakete standardmäßig. Unter openSUSE Tumbleweed lassen sich diese Pakete mittels YaST oder zypper installieren.&lt;/small&gt;

== 2D ==
=== Graph einer Funktion ===
Es soll die cosh-Funktion im Intervall &lt;math&gt;x\in[-3,3]&lt;/math&gt; gezeichnet werden. Der Programmcode lautet in der einfachsten Form:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x)
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:PythonIng_cosh1.jpg]]

Der Code ist quasi selbsterklärend. Das Untermodul pyplot des matplotlib-Moduls und das numpy-Modul werden importiert. x läuft von -3 bis +3. y wird für jeden x-Wert per Formel ausgerechnet. &quot;plt.plot()&quot; ist der Zeichenbefehl. &quot;plt.show&quot; ist notwendig, um das Fenster mit der Grafik anzuzeigen.
Die Schrittweite 0.1 wurde so gewählt, um einen ausreichend glatten Verlauf des Graphen zu gewährleisten. Das ist immer ein Kompromiss zwischen Berechnungszeit und Ansehnlichkeit. Testen Sie einfach ein paar verschiedene Werte, um ein Gefühl dafür zu zu bekommen. &quot;plt.grid()&quot; zeichnet ein Gitter in die Grafik (kann auch weggelassen werden).
Die Bezeichnungen plt und np könnten auch anders gewählt werden. Es ist aber Konvention, diese so wie hier gezeigt zu wählen. Die &quot;arange&quot;-Funktion aus der NumPy-Bibliothek wird später ein bisschen genauer behandelt (siehe [[Ing_Mathematik:_Python#Zahlenfolgen|Zahlenfolgen]]).  

&lt;small&gt;Mit der im obigen Bild gezeigten Menüleiste kann die dargestellte Grafik nachträglich noch geändert werden (Zoom, Pan, Achsenparameter, Kurvenparameter etc.). Natürlich kann man das alles auch direkt programmieren. Wie das funktioniert wird ansatzweise etwas später gezeigt.&lt;/small&gt;

Ein etwas komplexeres Beispiel ist Folgendes:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x) + 2**x
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:
[[Datei:PythonIng_cosh4.png]]

Man beachte, dass im Gegensatz zu Octave und Julia der ominöse Punkt (.) bei 2**x mit Python nicht benötigt wird. Das macht das Programmiererleben etwas einfacher.

Die Farbe des Graphen kann man über den &lt;code&gt;color&lt;/code&gt;-Schalter einstellen, z.B. auf rot setzen:
 plt.plot(x, y, color=&quot;red&quot;)

Das ist nur eine Möglichkeit, es gibt auch andere, z.B. mittels
* hexadezimaler Zahl, z.B. &lt;code&gt;color=&quot;#ff0000&quot;&lt;/code&gt;
* Kurzform, z.B. &lt;code&gt;&quot;r&quot;&lt;/code&gt;

Statt &lt;code&gt;color&lt;/code&gt; kann auch die Kurzform &lt;code&gt;c&lt;/code&gt; verwendet werden.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie diese &quot;Farbspielereien&quot; am Computer aus.

=== Graphen mehrerer Funktionen und weiteres ===
==== Mehrere Funktionen in einen Plot zeichnen ==== 
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh2.png]]

Um die Linienstile etwas individueller zu gestalten, ist folgender Programmcode gedacht: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;, lw=3, ls=&quot;--&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh3.png]]

Einige weitere Bespiele zu &lt;code&gt;ls&lt;/code&gt;&lt;/code&gt;:
* - ... durchgezogene Linie
* -. ... Strichpunkt-Linie
* dashed ... gestrichelte Linie 

==== Marker ====
Desweiteren kann man Marker verwenden.

Beispiel:

 import matplotlib.pyplot as plt
 
 plt.plot(10, 10, &quot;ob&quot;, markersize=30)
 plt.plot(20,20, &quot;.r&quot;)
 plt.plot(30,30, &quot;Dg&quot;, ms=15)
 plt.plot(40, 40, &quot;ok&quot;, ms=20, mec=&quot;#FF5733&quot;, mew=3)
 plt.plot(50, 50, &quot;vk&quot;, ms=20, mec=&quot;yellow&quot;, mew=3)
 plt.grid()
 plt.show()


Das erste Zeichen im String nach den Koordinaten im plot-Befehl symbolisiert die Form (z.B. o für einen Kreis). Das zweite Zeichen steht für die Farbe (z.B. b für blue). &lt;code&gt;markersize&lt;/code&gt; oder &lt;code&gt;ms&lt;/code&gt; setzt die Größe des Markers.

Ausgabe:

[[Bild:PythonIng_formatpara1.svg|200px]]

Einige weitere Marker:
* * ... Stern
* + ... Plus
* h oder H ... Sechseck

Man kann mit den Parametern 
* &lt;code&gt;markeredgecolor&lt;/code&gt; oder kurz &lt;code&gt;mec&lt;/code&gt; die Farbe des Markerrandes
* &lt;code&gt;markeredgewidth&lt;/code&gt; oder kurz &lt;code&gt;mew&lt;/code&gt; die Dicke des Randes
* &lt;code&gt;markerfacecolor&lt;/code&gt; oder kurz &lt;code&gt;mfc&lt;/code&gt; die Innenfarbe des Markers
bestimmen.

=== Funktion in Parameterdarstellung ===
Es soll die archimedische Spirale &lt;math&gt;x = t \cos(t), y = t  \sin(t)&lt;/math&gt; im Intervall &lt;math&gt;[0, 6\pi[&lt;/math&gt; gezeichnet werden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
  
 plt.show()

[[Datei:PythonIng_spirale1.png]]

Diese Darstellung erscheint verzerrt. Will man gleiche Achsenskalierungen, so kann man den plt.axis()-Befehl verwenden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
 plt.axis(&quot;equal&quot;)
 
 plt.show()
 
[[Datei:PythonIng_spirale2.png]]

=== Funktion in Polardarstellung ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 fig = plt.figure()
 ax = fig.add_subplot(projection=&quot;polar&quot;)
 r = np.arange(0, 1, 0.01)
 theta = r**3
 line = ax.plot(theta, r)
 
 plt.show()

[[Datei:PythonIng_polar1.png]]

=== Logarithmische Achsenskalierung ===
==== Semilog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.semilogy()
 plt.show()

Ausgabe:

[[Datei:PythonIng_semilog1.png]]

==== LogLog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.loglog()
 plt.show()

[[Datei:PythonIng_loglog1.png]]

=== Gefüllte Fläche ===
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.arange(0, 3, 0.1)
 
 y1 = 3*x - 1
 y2 = x**2
 
 plt.plot(x, y1, x, y2, color='black')
 plt.fill_between(x, y1, y2, where=y1&gt;=y2)
 
 plt.show()

[[Datei:PythonIng_gefuellt.png]]

=== Linien, Pfeile, Rechtecke, Kreise und Texte ===
 import matplotlib as mpl
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 r = mpl.patches.Rectangle((0, 0), 3, 3, angle=30, fill=False)
 c = mpl.patches.Circle((4, 4), 2, fill=False)
 
 ax.add_patch(r)
 ax.add_patch(c)
 ax.plot([-2, 7], [-2, 0], color=&quot;black&quot;)
 ax.arrow(0, 7, 5, 0, length_includes_head=True, head_width=0.5, head_length=1.5,
          color=&quot;black&quot;)
 
 ax.set_aspect(&quot;equal&quot;)
 
 plt.axis([-3, 8, -3, 8])
 plt.show() 

[[Datei:PythonIng_linien_pfeile_etc.png]]

Text kann mit &lt;code&gt;ax.text(x, y, &quot;Text&quot;)&lt;/code&gt; hinzugefügt werden, bspw.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 ax.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

Oder einfacher auch ohne &lt;code&gt;subplots&lt;/code&gt;

 import matplotlib.pyplot as plt
 
 plt.text(0.1, 0.1, &quot;Hallo&quot;)
 plt.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

[[Datei:PythonIng_text1.png]]

Auch Sonderzeichen (griechische Buchstaben etc.) können verwendet werden (siehe dazu auch [https://matplotlib.org/stable/users/explain/text/mathtext.html]).

 import matplotlib.pyplot as plt
 
 plt.text(.3, .5,
          r'$\Omega\ \psi\ \oint\ \nabla\ \dot a\ \frac{a}{b}\ a_b$',
          size=&quot;20&quot;)
 plt.show() 

[[Datei:PythonIng_text20.svg]]

Jetzt wird noch gezeigt, wofür &lt;code&gt;subplots&lt;/code&gt; sinnvoll eingesetzt werden können.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(0.1, 0.1, &quot;Hallo&quot;)
 ax[1].text(0.1, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
            rotation=30.0)
 
 plt.show()

[[Datei:PythonIng_text2.png]]

=== Anmerkungen hinzufügen ===
Anmerkungen (engl. annotations) lassen sich mit matplotlib einfach hinzufügen. Unter Anmerkung wird hier ein Pfeil mit Text verstanden.

Beispiel:

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 ax.plot([1,10], [1,10])
 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
             arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0))
 plt.show()

Ausgabe:

[[Datei: PythonIng_ann1.svg|400px]]

&lt;code&gt;shrink&lt;/code&gt; verkürzt den Pfeil. Sinnvoll sind beim obigen Beispiel Werte irgendwo zwischen 0.0 und 0.3.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie verschiedene Pfeillängen aus. 

Die Schriftgröße verändern können Sie übrigens mit &lt;code&gt;fontsize&lt;/code&gt; oder &lt;code&gt;size&lt;/code&gt;, z.B.

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0), fontsize=25)

Eine andere Schreibweise für Dictionaries, die wir weiter oben schon kennengelernt haben, die wir aber nochmals explizit aufschreiben wollen, ist

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops={&quot;facecolor&quot;:&quot;red&quot;, &quot;shrink&quot;:0.0})

=== Figure, Axes etc.===
[[Bild:PythonIng_figure33.svg|350px]]

* fig (figure) ... das übergeordnete Fenster
* ax (axes) ... &quot;Plot&quot;, das eigentliche Zeichenfenster
* axis ... die Koordinatenachsen
* spine ... Begrenzungslinien des Zeichenfensters
* tick ... Markierung an den Achsen des Zeichenfensters

Beispiel (eine figure mit 6 axes, ax-Titel, y-axis-Titel):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=3, ncols=2)
 
 ax[0][0].text(0.1, 0.5, &quot;11&quot;)
 ax[0][1].text(0.1, 0.5, &quot;12&quot;)
 ax[1][0].text(0.1, 0.5, &quot;21&quot;)
 ax[1][1].text(0.1, 0.5, &quot;22&quot;)
 ax[2][0].text(0.1, 0.5, &quot;31&quot;)
 ax[2][1].text(0.1, 0.5, &quot;32&quot;)
 
 ax[0][0].set(ylabel=&quot;y-label&quot;, title=&quot;axes 1&quot;)
 
 plt.show()

[[Bild:PythonIng_figure34.png|350px]]

Beispiel (Achsenbereiche setzen):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 
 ax[0].axis((-1, 10, 1, 12))
 
 plt.show()

[[Bild:PythonIng_figure35.svg|350px]]

Beispiel (Gitter einschalten): 

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 ax[0].axis((-5, 10, 1, 12))
 ax[0].minorticks_on()
 ax[0].grid(which='minor')
 ax[1].grid(which='major')
 plt.show()

[[Bild:PythonIng_figure36.svg|350px]]

Beispiel (ticks setzen)

 import matplotlib.pyplot as plt
 import matplotlib.ticker as tick
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 pos = [0, .2, .5]
 lab = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
 
 ax.xaxis.set_major_locator(tick.FixedLocator(pos))
 ax.xaxis.set_major_formatter(tick.FixedFormatter(lab))
 
 plt.show()

[[Bild:PythonIng_figure37.svg|350px]]

Beispiel (Achsenkreuz beliebig setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 ax.spines['top'].set_color('none')
 ax.spines['right'].set_color('none')
 ax.spines['bottom'].set_position(('data', 0.3))
 ax.spines['left'].set_position(('data', 0.5))
 
 plt.show()

[[Bild:PythonIng_figure38.svg|350px]]

Beispiel (Inset):

 import matplotlib.pyplot as plt
 
 # Hauptplot erstellen
 fig, ax = plt.subplots()
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 
 # Inset hinzu:
 axin = ax.inset_axes([0.4, 0.4, 0.3, 0.3])
 axin.text(0, 0, &quot;Servus&quot;)
 axin.plot()
 
 plt.show()

[[Bild:PythonIng_figure40.svg|350px]]

Beispiel (Hintergrundfarben setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.set_facecolor(&quot;green&quot;)
 fig.set_facecolor(&quot;yellow&quot;)
 
 plt.plot([1, 3], [6, 8])
 plt.show()

[[Bild:PythonIng_figure39.svg|300px]]

=== GridSpec ===
Mit figures und axes lassen sich schon jede Menge an Grafikdetails einstellen. GridSpec ist dann der Turbo oder Raketenantrieb den matplotlib eingebaut hat. Naja, vielleicht ist das etwas übertrieben, aber GridSpec ist sozusagen ein flexibler Layout-Manager. Bisher haben wir immer gleich große axes gezeichnet. Mit GridSpec können wir Subplots über mehrere Zeilen und Spalten ziehen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 gs = fig.add_gridspec(3, 3)
 
 ax1 = fig.add_subplot(gs[0, :])
 ax1.set_title(&quot;Bereich 1: gs[0, :]&quot;)
 
 ax2 = fig.add_subplot(gs[1:, 0])
 ax2.set_title(&quot;Bereich 2: gs[1:, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 1:])
 ax3.set_title(&quot;Bereich 3: gs[1, 1:]&quot;)
 
 ax4 = fig.add_subplot(gs[2, 1:])
 ax4.set_title(&quot;Bereich 4: gs[2, 1:]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec1.svg|350px]]

Erklärung zu &lt;code&gt;(gs[zeile, spalte])&lt;/code&gt;: Slicing; damit legen Sie fest, welche Zellen ein Subplot belegt. Achtung! Die Indizes beginnen bei 0 und nicht bei 1 (d.h., die erste Zeile/Spalte hat den Index 0)
* : ... alle 
* 1: ... 1 bis Ende
* etc.

&lt;code&gt;constrained_layout=True&lt;/code&gt; sorgt dafür, dass sich die Subplots nicht überlappen.

Aber auch die Spaltenbreiten und Zeilenhöhen lassen sich anpassen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 
 # Verhältnis erste zu zweite Zeile = 1.5:1
 # Verhältnis erste zu zweite Spalte  = 1:4
 gs = fig.add_gridspec(2, 2, figure=fig, height_ratios=[1.5, 1], width_ratios=[1, 4])
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax1.set_title(&quot;Bereich 1: gs[0, 0]&quot;)
 
 ax2 = fig.add_subplot(gs[0, 1])
 ax2.set_title(&quot;Bereich 2: gs[0, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 0])
 ax3.set_title(&quot;Bereich 3: gs[1, 0]&quot;)
 
 ax4 = fig.add_subplot(gs[1, 1:])
 ax4.set_title(&quot;Bereich 4: gs[1, 1]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec2.svg|350px]]

Auch die Ränder lassen sich einstellen.

Beispiel 1:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.1, right=0.9, bottom=0.1,
                        top=0.9, wspace=0.2, hspace=0.2)
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec3.svg|300px]]

* hspace ... height space, vertikaler Abstand zwischen den Zeilen
* wspace ... width space, horizontaler Abstand zwischen den Spalten

Und im Vergleich dazu Beispiel 2:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.3, right=0.7, bottom=0.3, 
                        top=0.7, wspace=0.3, hspace=0.3) 
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec4.svg|300px]]

Es gibt noch einige weitere Details, die sich mit GridSpec variieren lassen (z.B. SubGridSpec ... verschachtelte Grid-Layouts). Aber wir belassen es vorerst dabei. Das bisher Gezeigte sollte für die meisten Probleme ausreichend sein.

=== Aufgaben ===
* Zeichnen Sie die Strophoide &lt;math&gt;x = \frac{a(t^2-1)}{t^2+1}, y = \frac{at(t^2-1)}{t^2+1}, a = 2, -3 \leq t \leq 3&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_strophoide.jpg|300px|center]]

* Zeichnen Sie die verschlungene Hypozykloide &lt;math&gt;x = (R-r)\cos t + c\cos\frac{R-r}{r}t, y = (R-r)\sin t - c\sin\frac{R-r}{r}t, c = 3, r = 2, R = 6, -15 \leq t \leq 15&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_hypozykloide.jpg|300px|center]]

* Testen Sie bei den obigen Übungsaufgaben verschiedene Linienstile und Farben. Farben können mit dem plt.plot()-Parameter color gewählt werden.

* Testen Sie bei den obigen Übungsaufgaben verschiedene Werte für a, c, r und R.

* Zeichnen Sie folgendes Bild (die Achsenbeschriftungen positionieren Sie z.B. mit den Befehlen &lt;code&gt;ax.set_xlabel(&quot;x&quot;, loc=&quot;right&quot;); ax.set_ylabel(&quot;y&quot;, loc=&quot;top&quot;)&lt;/code&gt;):

[[Bild:PythonIng_aufgabe24.svg|400px|center]] 

* Zeichnen Sie mit Python, matplotlib und NumPy folgendes Bild:

[[Bild:PythonIng_figure41.svg|400px|center]]

* Zeichnen Sie mit GridSpec ein Layout, das in etwa wie folgendes aussieht (&lt;code&gt;height_ratios=[1, 2], width_ratios=[2, 1]&lt;/code&gt;):

[[Bild:PythonIng_aufgabe23.svg|300px|center]]

== 3D ==
=== Räumliche Kurven ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0, 6*np.pi, 0.1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 z = t
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot(x, y, z)
 
 plt.show()

[[Datei:PythonIng_raumkurve1.png]]

=== Flächen ===
 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche1.png]]

Das Ganze in Netzdarstellung läßt sich so programmieren: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.5)
 y = np.arange(0, 10, 0.5)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_wireframe(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche2.png]]

Ein etwas komplexeres Beispiel:

 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0.1, 10, 0.1)
 y = np.arange(0.1, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z1 = np.sin(x) + 3 * np.cos(y)
 z2 = np.sin(x) + np.log(y)
 z3 = x + np.cos(y)
 z4 = x**2 - y
  
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;}, nrows=2, ncols=2)
 
 ax[0][0].plot_surface(x, y, z1)
 ax[0][1].plot_surface(x, y, z2)
 ax[1][0].plot_surface(x, y, z3)
 ax[1][1].plot_surface(x, y, z4)
 
 plt.show()

[[Datei:PythonIng_subplot1.png]]

Man beachte, dass man die Unterbilder im Bild nach dem Ausführen des Scripts z.B. mit der mittleren Maustaste einzeln drehen, oder über die Einträge in der Menüzeile einzeln bearbeiten kann. Mit ein paar Zeilen Programmtext lässt sich also eine Menge an Funktionalität generieren.

Die Farbgebung lässt sich über &lt;code&gt;colormaps&lt;/code&gt; variieren.

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm)
 
 plt.show()

[[Datei:PythonIng_colormap1.png]]

Es gibt eine Menge an Colormaps, z.B. &lt;code&gt;plasma, Greys, Dark2, ocean&lt;/code&gt;. Zwecks detaillierterer Infos siehe die matplotlib-Dokumentation. &lt;small&gt;Verwendet man die IDE namens IDLE, so gibt es dort auch die automatische Codevervollständigung. D.h. es werden alle Möglichkeiten (in unserem Fall nach dem Eintippen von &lt;code&gt;cm.&lt;/code&gt; alle verfügbaren Colormaps) angezeigt.&lt;/small&gt;

Die &quot;edgecolor&quot; und Linienbreite können auch frei gewählt werden:

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm, edgecolor=&quot;black&quot;, linewidth=1.0)
 
 plt.show()

[[Datei:PythonIng_colormap2.png]]

=== Höhenlinien ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 ax.contour(x, y, z)
 
 plt.show()

[[Datei:PythonIng_höhenlinien1.png|400px]]

Etwas abgewandelt sieht das so aus: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contour(x, y, z)
 ax.clabel(hl, inline = True)
 
 plt.show()

[[Datei:PythonIng_höhenlinien2.png|400px]]

Und noch eine Variante (mit einem Farbbalken) sei gezeigt. 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contourf(x, y, z)
 fig.colorbar(hl) 
 
 plt.show()

[[Datei:PythonIng_höhenlinien5.svg|400px]]

=== Aufgaben ===
* Zeichnen Sie die räumliche Kurve &lt;math&gt;x = 2 \cdot \cosh(t)&lt;/math&gt;, &lt;math&gt;y = 5 \cdot \sin(t)&lt;/math&gt;, &lt;math&gt; z = t^{2} - t&lt;/math&gt;, &lt;math&gt;0 \leq t \leq 3\pi&lt;/math&gt;.
* Zeichnen Sie die Fläche &lt;math&gt;z = \log(x) + \cos(y)&lt;/math&gt;.

== Animationen und fortgeschrittenes 3D ==
=== Mit matplotlib ===
Auch mit matplotlib sind Animationen möglich. Das ist ein bisschen komplizierter und wird deshalb hier nur mit einem sehr einfachen Beispiel dargestellt (bei Interesse siehe z.B. auch das [https://matplotlib.org/stable/users/explain/animations/animations.html#animations Animations using Matplotlib-Tutorial]).

 import matplotlib.pyplot as plt
 import matplotlib.animation as ani
 import matplotlib
 import numpy as np
 
 def update(frame):
     line.set_xdata(x[:frame])
     line.set_ydata(y[:frame])
     return (line)
 
 fig, ax = plt.subplots()
 
 x = np.arange(0, 10, .1)
 y = np.sin(x)
 
 line, = ax.plot(x[0], y[0])
 ax.set(xlim=[0, 10], ylim=[-1, 1])
 
 a = ani.FuncAnimation(fig=fig, func=update, frames=100, interval=20)
 plt.show()
 
 # Speichere die Animation in einem animierten GIF (optional)
 a.save(filename=&quot;c:/tmp/PythonIng_anim5.gif&quot;, writer=&quot;pillow&quot;)

[[Datei:PythonIng_anim5.gif]]

Es wird eine Sinuskurve auf den Bildschirm gezeichnet. In der letzten Zeile wird diese Animation in ein animiertes GIF gespeichert. Das ist natürlich optional und kann auch weggelassen werden.

=== Mit VPython ===
Aber auch mit dem Modul VPython lassen sich einfache 3D-Animationen erstellen. VPython ist ein externes Modul, das vorab installiert werden muss. Unter openSUSE Tumbleweed gibt es dzt. kein entsprechendes rpm-Paket. Die übliche Methode der Installation mittels YaST oder zypper ist somit nicht möglich. Auch eine direkte Verwendung von pip führt nur zu einer Fehlermeldung (&lt;code&gt;error: externally-managed-environment&lt;/code&gt;). Es empfiehlt sich dort folgende Vorgehensweise:
# Erstelle zuerst eine virtuelle Umgebung, z.B.: &lt;code&gt;python3.11 -m venv ~/tmp/venv1&lt;/code&gt;
# Wechsle das Verzeichnis: &lt;code&gt;cd ~/tmp/venv1/bin&lt;/code&gt;
# Installiere das entsprechende Paket: &lt;code&gt;./pip install vpython&lt;/code&gt;
# Führe das entsprechende Skript aus: &lt;code&gt;./python ~/tmp/test1.py&lt;/code&gt;

Aktuell (März 2026) ist dieses Programmpaket lt. der [https://vpython.org/presentation2018/install.html VPython-Homepage] nur für die Python-Versionen 3.8 bis 3.12 verfügbar.

Ein Beispiel zu einer einfachen Animation wird nachfolgend geliefert.

 from vpython import *
 
 scene.width = 1200
 scene.height = 600
 scene.center = vector(20,0,0)
 scene.background = color.white
 
 cylinder(pos=vector(0,0,0), axis=vector(20,0,0), radius=5, 
         color=color.blue)
 cone(pos=vector(0,0,0), axis=vector(-10,0,0), radius=5, 
         color=color.blue)
 helix(pos=vector(20,0,0), axis=vector(40,0,0), radius=2, 
         coils=10, thickness=0.5, color=color.blue)
 
 ball = sphere(pos=vector(20,0,0), color = color.green, radius = 1)
 ball.p = vector(0.15, 0, 0)
 
 toc = True
 
 while True:
     rate(200)
     if(ball.pos.x &lt;= 60 and toc == True):
         ball.pos += ball.p
     else:
         toc = False
         ball.pos -= ball.p
         if(ball.pos.x &lt;= 20 and toc == False):
             toc = True

[[Datei:PythonIng_vpython_anim.JPG]]

Idealerweise öffnet sich beim Ausführen des Scripts ein Browserfenster. Darin wird die programmierte Animation gezeigt (siehe auch den obigen Screenshot). Eine Größenänderung können Sie mit der mittleren Maustaste initiieren. Die Szenerie drehen können Sie mit der rechten Maustaste.

=== Mit build123d ===
Hiermit lassen sich einfach 3D-Modelle für CAD-Systeme erstellen. [https://build123d.readthedocs.io/en/latest/ build123d] ist ein externes Modul und muss vorab, wie schon für mehrere andere Module gezeigt, installiert werden (pip, venv etc.).

Beispielcode:

 from build123d import *
 
 # Bauteil
 with BuildPart() as bauteil: 
     # Zylinder erstellen
     Cylinder(100, 60)
        
     # Bohrung
     with BuildSketch(bauteil.faces().sort_by(Axis.Z)[-1]) as loch:
         Circle(radius=10)
     # negativ extrudieren
     extrude(amount=-60, mode=Mode.SUBTRACT)
     
     # Dem Bauteil z.B. die Farbe rot zuweisen
     # bauteil.part.color = Color(&quot;red&quot;, alpha=1.0)
 
     # Fertiges Modell exportieren
     export_step(bauteil.part, &quot;bauteil.step&quot;)

Ausgabe ({{W|Standard for the exchange of product model data | STEP}}-Datei, z.B. in {{W|FreeCAD}} importiert, Screenshot):

[[Datei:PythonIng_build123d.jpg | 300px]]

FreeCAD ist ein freies 3D-CAD-System. Die [[Ing_Mathematik:_Python#FreeCAD | Makroprogrammierung]] in diesem System wird später noch gezeigt. STEP steht für &quot;'''St'''andard for the '''e'''xchange of '''p'''roduct model data&quot; und ist ein Datenaustauschformat.

=== Mit VTK ===
Komplexer, aber auch mächtiger als VPython ist die Verwendung von VTK ('''V'''isualization '''T'''ool'''k'''it). Genauer gesagt des Python-Wrappers von VTK. Dieses externe Python-Modul muss vorab installiert werden (z.B. mittels YaST, pip oder in eine virtuelle Umgebung). VTK ist eine Softwarebibliothek zur 3D-Visualisierung und wurde ursprünglich in C++ geschrieben. Verbreitet eingesetzt wird diese Bibliothek in der Wissenschaft und Forschung, z.B. 
* in der medizinischen Bildgebung
* für Strömungssimulationen
* für Klimadaten

VTK funktioniert nach dem {{W|Grafikpipeline|Pipeline-Prinzip}}:

 Source (Quellen) -&gt;  Filter -&gt; Mapper (Senken) -&gt; Actor/Renderer

Daten fließen von den Quellen zu den Senken.

Als einfaches Beispiel wird die Darstellung eines Zylinders gezeigt, der mit den Maustasten gedreht oder in der Größe geändert werden kann:

 import vtk
 
 # Zylinder erzeugen
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 # Geometrie in darstellbare Daten umwandeln
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 # Objekt in der Szene
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 # Szene verwalten
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 # Render-Fenster
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 # Maus/Tastatur-Steuerung
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 # Starten
 render_window.Render()
 interactor.Start()

Ausgabe:

[[Datei:PythonIng_VTK_1.png]]

Gleiches Beispiel wie oben, aber mit einer Animationssequenz:

 import vtk
 import time
 
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     render_window.Render()
     time.sleep(0.01)

Das Grafikfenster schließt sich nach Ablauf der Schleife. Das Fenster bleibt geöffnet, wenn Sie am Programmende folgenden Befehl hinschreiben

 interactor.Start()

Um den animierten Zylinder grün einzufärben, müssen Sie Folgendes im obigen Programm ergänzen (Farbnamen):

 colors = vtk.vtkNamedColors()
 actor.GetProperty().SetColor(colors.GetColor3d(&quot;Green&quot;))

Als Namen können Sie u.a. die CSS3 Web-Farben verwenden (siehe z.B. [https://wiki.selfhtml.org/wiki/Farbe/Farbangaben] und {{W|Webfarbe#CSS_3}}).

Alternativ funktioniert auch das ({{W|RGB-Farbraum|RGB}}):

 actor.GetProperty().SetColor(0.0, 0.6, 0.0)

Wie der Zylinder mit einer Textur versehen wird, zeigt folgendes Programm:

 import vtk
 import time
 
 cylinder = vtk.vtkCylinderSource()
 cylinder.SetResolution(30)
 cylinder.SetHeight(3.0)
 cylinder.SetRadius(1.0)
 cylinder.CappingOn()
 
 texture_coords = vtk.vtkTextureMapToCylinder()
 texture_coords.SetInputConnection(cylinder.GetOutputPort())
 texture_coords.PreventSeamOn()
 
 reader = vtk.vtkJPEGReader()
 reader.SetFileName(&quot;PythonIng_textur.jpg&quot;)
 
 texture = vtk.vtkTexture()
 texture.SetInputConnection(reader.GetOutputPort()) 
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(texture_coords.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 actor.SetTexture(texture)
 
 renderer = vtk.vtkRenderer()
 renderWindow = vtk.vtkRenderWindow()
 renderWindow.AddRenderer(renderer)
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(renderWindow)
 
 renderer.AddActor(actor)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     renderWindow.Render()
     time.sleep(0.01)
 
 interactor.Start()

&lt;gallery&gt;
PythonIng_textur.jpg | Textur-Datei
PythonIng_VTK_2.png | Ausgabe (Screenshot)
&lt;/gallery&gt;

== Sonstige Grafikbibliotheken ==
=== Py5 ===
Im Buch ''Iacono et al.: Programmieren trainieren, mit über 150 Workouts in Java und Python; 3. Aufl., Hanser, 2023'' werden zahlreiche Aufgaben gestellt, die u.a. mit Processing zu lösen sind.  Processing ist eine einfache Programmiersprache und Entwicklungsumgebung. Warum ich das erwähne? Weil in älteren Processing-Versionen auch die Programmiersprache Python 2 abgedeckt war. Bei neueren Versionen gibt es keine Python-Anbindung mehr (getestet nur mit openSUSE Tumbleweed und Python 3). Somit funktioniert der Python-Teil im genannten Buch zum Teil nicht mehr. Ist das tragisch, oder kann das Buch weggeschmissen werden? Nein! Es gibt Alternativen zu Processing. Zum einen die im Buch selbst genannten Bibliotheken tkinter oder pygame. Pygame wird dort auch kurz anhand eines Beispiels thematisiert. Aber noch besser ist es, die py5-Bibliothek zu verwenden (lt. Google KI vom 30. Sept. 2026: ''Der echte, moderne „spirituelle Nachfolger“''). Damit ist die Funktionalität von Processing gewährleistet. Man kann aber beliebige Editoren oder IDEs zur Programmerstellung verwenden, ohne an Processing als IDE gebunden zu sein. Nachfolgend werden ein paar Beispiele zu dieser externen Bibliothek gegeben. Der erste Schritt ist wieder, die py5-Bibliothek zu installieren (z.B. mittels pip in eine virtuelle Umgebung; Python&gt;=3.10 und ein JDK&gt;=17 müssen auch installiert sein (Stand Okt. 2026)). Dann kann es schon mit dem Programmieren losgehen.

Beispiel (angelehnt an die ''Aufgabe W.2.3 Haus'' des genannten Buchs, jedoch etwas erweitert):

 import py5
 
 def setup():
     py5.size(600, 600)            # Fenstergröße 600px x 600px 
     py5.background(255, 255, 255) # Hintergrundfarbe ... weiss
     
 def draw():
     # Haus zeichnen
     py5.fill(255, 255, 255)       # Hintergrundfarbe ... weiss
     py5.stroke(255, 0, 0)         # Linienfarbe ... rot 
     py5.stroke_weight(3)          # Linienbreite ... 3px
     py5.rect(150, 200, 300, 300)  # Rechteck zeichnen (x, y, b, h)
     py5.triangle(150, 200, 300, 100, 450, 200) # Dreieck zeichnen
     py5.circle(250, 300, 70)      # Kreis zeichnen (x, y, d)   
     
     # Bemassung zeichnen
     py5.stroke(0, 255, 0)
     py5.stroke_weight(1)
     py5.line(300, 100, 550, 100)  # Linie zeichnen
     py5.line(450, 200, 550, 200) 
     py5.line(450, 500, 550, 500) 
     py5.line(150, 500, 150, 550)
     py5.line(450, 500, 450, 550)
     py5.text_size(20)             # Textgroesse
     py5.fill(0, 255, 0)           # Textfarbe
     py5.text(&quot;300&quot;, 280, 550)     # Text zeichnen
     py5.text(&quot;100&quot;, 500, 150)
     py5.text(&quot;300&quot;, 500, 350)  
 
     # Gedrehtes Rechteck zeichnen
     py5.stroke(255, 255, 0)
     py5.stroke_weight(3)
     py5.fill(200, 200, 200) 
     py5.translate(320, 260)  
     py5.rotate(0.3)               # Drehung (in Radiant)
     py5.rect(0, 0, 100, 50)
 
 # Startet den Sketch
 py5.run_sketch()


Ausgabe:

[[Datei:PythonIng_py5_1.png|300px]]

Das skizzierte Haus ist mit einer rudimentären Bemaßung versehen und hat zwei Fenster, ein rundes und ein gedrehtes, trübes rechteckiges. 

Beispiel (Mausoperationen):

 import py5
 
 def setup():
     py5.size(600, 600)            
     py5.background(255, 255, 255)
 
 def draw():
     pass
    
 def mouse_pressed():
     py5.text_size(15) 
     py5.fill(0, 0, 255)
     x = py5.mouse_x
     y = py5.mouse_y
     py5.text(&quot;(%d, %d)&quot; %(x, y), x, y) # Positionsdaten bei Maus-Klick schreiben
 
 py5.run_sketch()

Ausgabe:

[[Datei:PythonIng_py5_2.png|300px]]

Obiges Bild zeigt das Resultat nach einigen Mausklicks. Man erkennt, dass links-oben der Koordinatennullpunkt ist. Die x-Achse zeigt nach rechts, die y-Achse nach unten.

Beispiel (Fünfeck):

 import py5
 import random 
 
 def setup():
     py5.size(400, 400)
     py5.no_loop()       # statisches Bild (schont die Ressourcen)
 
 def draw():
     py5.translate(py5.width / 2, py5.height / 2)  # KS setzen
 
     radius = 150
     eck_anzahl = 5
 
     py5.fill(random.randint(0, 255), random.randint(0, 255), 
              random.randint(0, 255))    # Füllfarbe auf Zufallswert setzen
     py5.stroke(155, 0, 0)            
     py5.stroke_weight(5)     
     
     # Fünfeck als Polygon zeichnen
     py5.begin_shape()
     for i in range(eck_anzahl):
         winkel = i * py5.TWO_PI / eck_anzahl - py5.HALF_PI
         x = py5.cos(winkel) * radius
         y = py5.sin(winkel) * radius
         py5.vertex(x, y)
     py5.end_shape(py5.CLOSE)
 
 py5.run_sketch()

Ausgabe, bspw.:

[[Datei:PythonIng_py5_5.png|200px]]

&lt;u&gt;Kleine Aufgaben:&lt;/u&gt;
* Um die Funktionsweise von &lt;code&gt;py5.no_loop()&lt;/code&gt; zu verstehen, kommentieren Sie die Anweisung im Beispiel einfach aus, und starten Sie das Programm erneut.
* Zeichnen Sie ein Siebeneck.
* Was passiert, wenn man &lt;code&gt;py5.CLOSE&lt;/code&gt; im &lt;code&gt;py5.end_shape()&lt;/code&gt;-Befehl weglässt?

Beispiel (Grafik laden und zeichnen):

 import py5
 
 image1 = None
 
 def setup():
     global image1
     py5.size(600, 600)
     py5.no_loop()
     image1 = py5.load_image(&quot;PythonIng_py5_1.png&quot;)
 
 def draw():
     py5.image(image1, 0, 0)
 
 py5.run_sketch()

Hier wird einfach das Bild vom Haus-Beispiel (Screenshot von weiter oben) geladen und gezeichnet.

Beispiel (angelehnt an ''W.5.10 Wurfparabel'' des genannten Buches; mit OOP erstellt):

 import py5
 
 class Wurfparabel(py5.Sketch):
     def __init__(self, v0, angle):
         super().__init__()
         self.v0 = v0
         self.angle = self.radians(angle)
         self.g = 9.81
         self.t = 0.0
         self.scale = 1.5
 
     def settings(self):
         self.size(800, 600)
 
     def setup(self):        
         self.background(0, 0, 0)
         
     def draw(self):
         self.t += 0.1
 
         self.translate(50, 500)
       
         # KS Zeichnen
         self.fill(255, 255, 0)
         self.stroke(255, 255, 0)
         self.stroke_weight(1)
         self.line(0, 0, 0, -300)
         self.line(0, 0, 700, 0)
 
         # Punkt zeichnen
         cx = self.v0 * self.cos(self.angle) * self.t * self.scale
         cy = -(self.v0 * self.sin(self.angle) * self.t - \
                self.g/2 * self.t**2) * self.scale
         self.fill(255, 0, 0)
         self.stroke(255, 0, 0)
         self.circle(cx, cy, 3)
        
         # Stoppen bei Bodenkontakt
         if cy &gt;= -5:
             self.no_loop()
            
 def wurfparabel(v0=50, angle=45):
     sketch = Wurfparabel(v0, angle)
     sketch.run_sketch()
 
 v0 = float(input(&quot;v0 = &quot;))
 winkel = float(input(&quot;winkel = &quot;))
 wurfparabel(v0=v0, angle=winkel)

Eingabe auf der Konsole:

 v0 = 60
 winkel = 45

Ausgabe:

[[Datei:PythonIng_py5_13.png|200px]]

Die benötigten Formeln der Bewegungsgleichung kann man leicht herleiten, bzw. man benutzt folgende Grafik als Hilfestellung:

[[Datei:Wurfparabel_Zusammenfassung_aktualisierung.png|700px]]

&lt;u&gt;Aufgabe:&lt;/u&gt; Berechnen Sie den Scheitelpunkt und die Wurfweite bei gegebener Anfangsgeschwindigkeit und gegebenem Abwurfwinkel. Die Abwurfhöhe &lt;math&gt;y_0&lt;/math&gt; sei 0. Der Wurf soll auf der Erde stattfinden (g = 9.81 m/s²). Die dazu benötigten Formeln können aus obiger Grafik entnommen werden (oder Sie leiten sie selbst her). Geben Sie die Ergebnisse auf der Konsole aus.

Beispiel (eine einfache Animation):

 import py5
 
 i = 0
 
 def setup():
     py5.size(600, 600)
     py5.frame_rate(5)
     py5.stroke_weight(20)
 
 def draw():
     global i
     
     py5.background(255, 255, 255)
     py5.translate(py5.width/2, py5.height/2)
     py5.rotate(py5.PI/8 * i)    
 
     py5.line(-100, 0, 100, 0)
     i += 1
 
 py5.run_sketch()

Es wird eine rotierende Linie gezeichnet (z.B. wie bei einem Installationsprozess verwendet - zeigt an, dass der Installationsfortschritt nicht eingefroren ist). Hierbei ist nur aufzupassen, dass der Hintergrund in &lt;code&gt;draw()&lt;/code&gt; gesetzt wird, ansonsten würden die Linien additiv gezeichnet. Das ist zwar auch schön, aber eben nicht das gewünschte Resultat.

Hiermit belassen wir es mit der py5-Bibliothek und wenden uns wieder &quot;mathematischeren&quot; Themen zu.

= Vektoren und Matrizen =
== Zahlenfolgen ==
Für das Erstellen von Zahlenfolgen bieten sich die Funktionen &lt;code&gt;arange&lt;/code&gt; und &lt;code&gt;linspace&lt;/code&gt; aus dem &lt;code&gt;numpy&lt;/code&gt;-Modul an.

 from numpy import *
 
 start = 0
 stop = 10
 step = 2
 num = 10
 
 r = arange(start, stop, step)   # step ... Schrittweite
 l = linspace(start, stop, num)  # num ... Anzahl der Werte
 
 print(&quot;r = &quot;, r)
 print(&quot;l = &quot;, l)

Ausgabe:
 r =  [0 2 4 6 8]
 l =  [ 0.          1.11111111  2.22222222  3.33333333  4.44444444  5.55555556
   6.66666667  7.77777778  8.88888889 10.        ]

Bei &lt;code&gt;arange&lt;/code&gt; ist der &lt;code&gt;stop&lt;/code&gt;-Wert nicht im Ergebnis enthalten, bei &lt;code&gt;linspace&lt;/code&gt; standardmäßig aber sehr wohl. Jedoch kann man das bei &lt;code&gt;linspace&lt;/code&gt; auch ändern. Dann ist der Stoppwert nicht mehr enthalten: 

 linspace(start, stop, num, endpoint=False)

== Vektoren ==
Vektoren sollten jedem aus der Linearen Algebra bekannt sein. 

=== Arrays ===
In Python mit NumPy kann man Vektoren durch die Funktion array erzeugen.

 import numpy as np
 
 l1 = (-5, 3, 2)
 l2 = (1, 1, 4)
 
 a1 = np.array(l1)
 a2 = np.array(l2)
 
 a3 = a1 + a2
 a4 = 2 * a2
 
 print(a1)
 print(a2)
 print(a3)
 print(a3[2])
 print(a4)

Ausgabe:
 [-5  3  2]
 [1 1 4]
 [-4  4  6]
 6
 [2 2 8]

=== Zeilen- und Spaltenvektoren ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 print(z)
 print(s)

Ausgabe:
 [ [-5  3  2] ]
 [[1]
  [1]
  [4]]

=== Skalarprodukt ===
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4))
 
 skalarprodukt = np.dot(a1, a2)  
 
 print(skalarprodukt)

Ausgabe:
 6

=== Vektorprodukt ===
&lt;math&gt;a\ast b=\left(\begin{array}{c}
a_{1}\\
a_{2}\\
a_{3}
\end{array}\right)\ast\left(\begin{array}{c}
b_{1}\\
b_{2}\\
b_{3}
\end{array}\right)=\left(\begin{array}{c}
a_{2}b_{3}-a_{3}b_{2}\\
a_{3}b_{1}-a_{1}b_{3}\\
a_{1}b_{2}-a_{2}b_{1}
\end{array}\right)
&lt;/math&gt; 

Python-Code:
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4)) 
 
 vektorprodukt = np.cross(a1, a2) 
 
 print(vektorprodukt)

Ausgabe:
 [10 22 -8]

=== Transponierter Vektor ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 # transponierter Vektor
 z_tp = np.transpose(z)
 # transponierter Vektor
 s_tp = np.transpose(s)
 
 print(z_tp)
 print(s_tp)

Ausgabe:
 [[-5]
  [ 3]
  [ 2]]
 [ [1 1 4] ]

=== Vektorfelder visualisieren ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 # Daten generieren
 x = np.arange(0, 10, 1)
 y = np.arange(0, 10, 1)
 X, Y = np.meshgrid(x, y)
 U = X * Y
 V = Y + X
 
 # Plotten
 fig, ax = plt.subplots()
 
 ax.quiver(X, Y, U, V, angles='xy')
 
 plt.show()

Ausgabe:

[[Datei:PythonIng_quiver1.png]]

== Matrizen==
 import numpy as np
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 print(m1)

Ausgabe:
 [[1 2 3]
  [4 5 6]]

=== Zugriff auf Matrizenelemente ===
Beispiel:

 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 
 # Element aus Zeile 2 und Spalte 3 (Achtung! Index startet bei Null)
 print(m1[1,2])

Ausgabe:
 6

Visualisierung:
  
     0   1   2
   +-----------+
 0 | 1 | 2 | 3 |
   +-----------+
 1 | 4 | 5 | '''6''' |
   +-----------+


Beispiel:

 import numpy as np
 
 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
 
 B = np.matrix(A)     
 
 print(B[2::, ::2])

Ausgabe:

 [['20' '22']
  ['30' '32']
  ['40' '42']]

Mit der NumPy-Bibliothek funktioniert das zweidimensionale Slicing. Mit normalen Listen/Tupels geht das nicht, was wir schon früher thematisiert haben.

=== Addition und Subtraktion von Matrizen ===
 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 m2 = np.matrix([[0, 0, 2], [1, 3, 2]])
 
 print(m1 + m2)
 print(m1 - m2)

Ausgabe:
 [[1 2 5]
  [5 8 8]]
 [[1 2 1]
  [3 2 4]]

=== Transponierte Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 2, 3], [4, 5, 6]])
 mt = np.transpose(m) 
 
 print(m)
 print(mt)

Ausgabe:
 [[1 2 3]
  [4 5 6]]
 [[1 4]
  [2 5]
  [3 6]]

=== Rang einer Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 rg = np.linalg.matrix_rank(m)
 
 print(rg)

Ausgabe:
 2

=== Inverse Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 mi = np.linalg.inv(m)
 
 print(mi)

Ausgabe:
 [[ 1.   0.6]
  [-0.  -0.2]]

=== Multiplikation von Matrizen (falksches Schema) ===
 import numpy as np
 
 m1 = np.matrix([[1, 3, 4],  [0, -5, 1]])
 m2 = np.matrix([[1, 2], [2, 3], [0, 2]])
 
 print(m1 @ m2)

Ausgabe:
 [[  7  19]
  [-10 -13]]

=== Eigenwerte und Eigenvektoren ===
 import numpy as np
 
 m = np.matrix([[5, 8],  [1, 3]])
 D,V = np.linalg.eig(m)
 
 # Eigenwerte
 print(D)
 # Eigenvektoren
 print(V)

Ausgabe:
 [7. 1.]
 [[ 0.9701425  -0.89442719]
  [ 0.24253563  0.4472136 ]]

=== Teilmatrizen ===
 import numpy as np
 m = np.matrix([[1, 3, 4],  [0, -5, 1]])
 print(&quot;m = &quot;, m)
 
 # Erste Zeile extrahieren
 m1 = m[0,:]
 print(&quot;m1 = &quot;, m1)
 
 # Das Element aus der 1. Zeile und der 2. Spalte extrahieren
 m2 = m[0,1]
 print(&quot;m2 = &quot;, m2)
 
 # Zweite Spalte extrahieren
 m3 = m[:, 1]
 print(&quot;m3 = &quot;, m3)

Ausgabe:
 m =  [[ 1  3  4]
  [ 0 -5  1]]
 m1 =  [ [1 3 4] ]
 m2 =  3
 m3 =  [[ 3]
  [-5]]

=== Spezielle Matrizen ===
==== Nullmatrix ====
 import numpy as np
 z = np.zeros((3, 2))
 print(z)

Ausgabe:
 [[0. 0.]
  [0. 0.]
  [0. 0.]]

==== Einheitsmatrix ====
 import numpy as np
 z = np.eye(3)
 print(z)

Ausgabe:
 [[1. 0. 0.]
  [0. 1. 0.]
  [0. 0. 1.]]

==== Matrix mit lauter Einsen ====
 import numpy as np
 z = np.ones((3, 2))
 print(z)

Ausgabe:
 [[1. 1.]
  [1. 1.]
  [1. 1.]]

=== Spärlich besetzte Matrizen ===
Das Thema spärlich besetzter Matrizen wird hier nur kurz angerissen. Nähere Details siehe unter dem Weblink  [https://docs.scipy.org/doc/scipy/reference/sparse.html#module-scipy.sparse]. 

Beispiel:

 import numpy as np
 import scipy
 
 A = scipy.sparse.csr_array(np.eye(5))
 
 print(A)

Ausgabe:
 &lt;Compressed Sparse Row sparse array of dtype 'float64'
         with 5 stored elements and shape (5, 5)&gt;
   Coords        Values
   (0, 0)        1.0
   (1, 1)        1.0
   (2, 2)        1.0
   (3, 3)        1.0
   (4, 4)        1.0

csr steht für '''c'''ompressed '''s'''parse '''r'''ow.

Andere Möglichkeiten:
* coo-Format ('''coo'''rdinate Format): &lt;code&gt;scipy.sparse.coo_array()&lt;/code&gt;
* lil-Format ('''li'''st of '''l'''ists): &lt;code&gt;scipy.sparse.lil_array()&lt;/code&gt;
* csc-Format ('''c'''ompressed '''s'''parse '''c'''olumn): &lt;code&gt;scipy.sparse.csc_array()&lt;/code&gt;

Es gibt auch &lt;code&gt;scipy.sparse.csr_matrix()&lt;/code&gt; etc. Diese Befehle sind aber veraltet und es wird empfohlen, statt dessen die &lt;code&gt;..._array()&lt;/code&gt;-Funktionen zu verwenden.

&lt;u&gt;Aufgaben:&lt;/u&gt; 
Recherchieren Sie im Internet 
* generell zum Thema &quot;spärlich besetzte Matrizen mit Python&quot;.
* Was sind die Vor-/Nachteile von csr-arrays gegenüber coo- und lil-arrays?
* Wann verwendet man sinnvollerweise csr- und wann csc-arrays?
* Wie wandelt man coo-arrays in csr-arrays um?

= Lineare Gleichungssysteme =
Sei &lt;math&gt;Ax = b&lt;/math&gt; ein lineares Gleichungssystem. &lt;math&gt;A&lt;/math&gt; sei die Koeffizientenmatrix, &lt;math&gt;x&lt;/math&gt; der Lösungsvektor und &lt;math&gt;b&lt;/math&gt; ein bekannter Vektor.

Beispiel:
 import numpy as np
 
 A = np.array([[5, 1], [0, 2]])
 b = np.array([1, 2])
 
 x = np.linalg.solve(A, b)
 
 print(x)

Ausgabe:
 [0. 1.]

Siehe dazu auch das Kapitel [[Ing Mathematik: Numerisches Lösen von linearen Gleichungssystemen]]. Dort wird dieses Themengebiet u.a. mit weitergehenden Python-Skripten vertieft.

== Aufgabe ==
* Lösen Sie folgendes Gleichungssystem mittels Python (und zur Kontrolle auch händisch): 
 5x + 6y - 2z = 12
 3x - y  - 3z = 6
 2x + 2y + 4z = 5

= Polynome =
== Ein erstes einfaches Beispiel ==
Gegeben sei das Polynom &lt;math&gt;7x^3+5x^2+1&lt;/math&gt;. In Python:

 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p)

Ausgabe:
    3     2
 7 x + 5 x + 1

== Einzelne Polynomwerte berechnen ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p(1.5))

Ausgabe:
 35.875

== Polynome integrieren und differenzieren ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 
 # 1. Ableitung
 p1 = p.deriv()
 p2 = p.deriv(1)
 
 # 2. Ableitung
 p3 = p.deriv(2)
 
 # Integral
 p4 = p.integ()
 
 print(p1)
 print(p2)
 print(p3)
 print(p4)

Ausgabe:
     2
 21 x + 10 x
     2
 21 x + 10 x
 
 42 x + 10
       4         3
 1.75 x + 1.667 x + 1 x

== Nullstellen bestimmen ==
 import numpy as np
 
 p = np.poly1d([2, 5, 0, 4])
 r = np.roots(p)
 
 print(r)

Ausgabe:
 [-2.7621427 +0.j          0.13107135+0.84077099j  0.13107135-0.84077099j]

== Aufgaben ==
* Berechnen Sie den Wert für x = 3 des Polynoms &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Differenzieren und integrieren Sie das Polynom &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Berechnen Sie die Nullstellen von &lt;math&gt;y = 7x^5 - 3x^2 + 12&lt;/math&gt;.

= Nichtlineare Gleichungen und Gleichungssysteme =
== Nullstellenbestimmung ==
Löse eine beliebige Gleichung f(x) = 0, z.B. &lt;math&gt; f(x) = x^2 - 5\cos(x) - 10 = 0 &lt;/math&gt;:
 import scipy
 import numpy as np
 
 def f(x):
     return x**2 - 5*np.cos(x) - 10
    
 xstart = [-1, 1]        # Startwerte
 xn = scipy.optimize.root(f, xstart)
 
 print(xn.x)

Ausgabe:
 [-2.46813009  2.46813009]

Funktionsgraph:

[[Datei:octave_nichtlin2.jpg]]

== Gleichungssysteme ==
SymPy ist ein externes Modul, das symbolisches Rechnen ('''Sym'''bolic '''Py'''thon) ermöglicht. 

Folgende Aufgabe ist dem Buch &quot;Knorrenschild: Numerische Mathematik, Hanser, 2017, Seite 72&quot; entnommen. Zu lösen ist das nichtlineare Gleichungssystem

&lt;math&gt;f_1 = 2x_1 + 4x_2 = 0 &lt;/math&gt;

&lt;math&gt;f_2 = 4x_1 + 8x_2^3 = 0&lt;/math&gt;

Mit Python ist das so möglich:
 import sympy
 
 x1, x2 = sympy.symbols(&quot;x1 x2&quot;) 
 
 f1 = 2*x1 + 4*x2
 f2 = 4*x1 + 8*x2**3
 
 s = sympy.solve((f1, f2), x1, x2) 
 
 print(s)

Ausgabe:
 [(-2, 1), (0, 0), (2, -1)]

Plot:

[[Datei:IngPython_nl_gleichung1.svg|500px]]

= Komplexe Zahlen =
Die imaginäre Einheit wird in Python durch den Buchstaben &lt;code&gt;j&lt;/code&gt; symbolisiert. Darstellen kann man eine komplexe Zahl bekannterweise in mehreren Formen:
* Kartesische Darstellung &lt;math&gt;z = \Re(z) + j \cdot \Im(z)&lt;/math&gt;
* Polardarstellungen &lt;math&gt;z = r \cdot (\cos(\phi) + j \cdot \sin(\phi)) = r \cdot e^{j\cdot \phi}&lt;/math&gt;

Die konjugiert komplexe Zahl ist &lt;math&gt;z^* = \Re(z) - j \cdot \Im(z)&lt;/math&gt;

Nachfolgend einige mathematische Operationen mit Python und NumPy.

 import numpy as np
 
 z1 = 2 + 5j           # kartesische Darstellung
 z2 = 3 * np.exp(3j)   # Polardarstellung
  
 # Addition
 res = z1 + z2
 print(&quot;z1 + z2 = &quot;, res)
 
 # Multiplikation
 res = z1 * z2
 print(&quot;z1 * z2 = &quot;, res)
 
 # Realteil
 res = np.real(z2)
 print(&quot;Realteil von z2 = &quot;, res)
 
 # Imaginärteil
 res = np.imag(z2)
 print(&quot;Imaginaerteil von z2 = &quot;, res)
 
 # Betrag
 res = np.abs(z1)
 print(&quot;Betrag von z1 = &quot;, res)
 
 # Argument
 res = np.angle(z1)
 print(&quot;Argument von z1 = &quot;, res)
 
 # Konjugiert komplexe Zahl
 res = np.conj(z1)
 print(&quot;Konjugiert komplexe Zahl von z1 = &quot;, res)

Ausgabe:
 z1 + z2 =  (-0.9699774898013365+5.423360024179601j)
 z1 * z2 =  (-8.05675510050068-14.003167400647481j)
 Realteil von z2 =  -2.9699774898013365
 Imaginaerteil von z2 =  0.4233600241796016
 Betrag von z1 =  5.385164807134504
 Argument von z1 =  1.1902899496825317
 Konjugiert komplexe Zahl von z1 =  (2-5j)

= Interpolation =
 import numpy as np
 import scipy
 import matplotlib.pyplot as plt
 
 # Stützpunkte
 xp = np.arange(1, 6)
 yp = (0, -5, 2, 7, 6)
 
 ti = np.arange(1, 5, 0.01)
 
 i1 = scipy.interpolate.interp1d(xp, yp, kind = &quot;linear&quot;)
 i2 = scipy.interpolate.interp1d(xp, yp, kind = &quot;cubic&quot;) 
 
 plt.plot(xp, yp, &quot;rx&quot;)
 plt.plot(xp, i1(xp))
 plt.plot(ti, i2(ti))
 plt.show()

Ausgabe:

[[Datei:PythonIng_interpol1.png]]

= Differenzialrechnung =
== Numerisches Differenzieren ==
Als Beispiel differenzieren wir &lt;math&gt;y = 5x\sin{x}&lt;/math&gt; und stellen das Ganze grafisch dar.

 from findiff import Diff
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.linspace(0, 10, 1000)
 f = 5 * x * np.sin(x)
 dx = x[1] - x[0]
 
 # Ableitung
 d_dx = Diff(0, dx)
 df_dx = d_dx(f)
 
 # Grafik
 plt.plot(x, f, label = &quot;y&quot;)
 plt.plot(x, df_dx, label = &quot;y'&quot;)
 plt.grid()
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

Ausgabe:

[[Datei:octave_diff1.jpg]]

&lt;small&gt;findiff ist ein externes Modul. Dieses muss installiert werden (z.B. so: ...\Python\Scripts\pip.exe install --upgrade findiff). Für die Vorgehensweise unter openSUSE Tumbleweed siehe das Kapitel [[Ing_Mathematik:_Python#Mit_VPython | VPython]], nur dass das Ganze mit einer aktuelleren Python-Version exekutiert wird, z.B. mit Python 3.13.  Das im Buch &quot;Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler, Rheinwerk&quot; verwendete Modul &quot;scipy.misc&quot; ist veraltet (deprecated ... missbilligt). Lt. [https://docs.scipy.org/doc/scipy-1.17.0/dev/roadmap-detailed.html#misc SciPy-Dokumentation für die Version 1.17.0] wurden alle entsprechenden Features schon entfernt.&lt;/small&gt;

== Symbolisches Differenzieren ==
Differenzieren Sie die Funktionen &lt;math&gt;f_1(x) = x^2&lt;/math&gt; und &lt;math&gt;f_2(x) = \sin(x)\cos\left(\frac{x}{2}\right)&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2;
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 d1 = sympy.diff(f1, x)
 d2 = sympy.diff(f2, x)
 
 print(d1)
 print(d2)

Ausgabe:
 2*x
 -0.5*sin(0.5*x)*sin(x) + cos(0.5*x)*cos(x)

== Aufgaben ==
* Differenzieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.
* Differenzieren Sie die Funktion &lt;math&gt;y = \frac{\sinh(x)}{(1+x)}&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.

= Integralrechnung =
== Numerisches Integrieren ==
Berechnen Sie das Integral &lt;math&gt;\int_{0}^{3}x^2 dx&lt;/math&gt;.

 import scipy
 
 def f(x):
     return x**2
    
 i = scipy.integrate.quad(f, 0, 3)
 print(i)

Ausgabe:
 (9.000000000000002, 9.992007221626411e-14)

Das trifft den exakten Wert 9.0 ziemlich genau.

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} dx&lt;/math&gt;.

 import scipy
 import numpy as np
 
 def f(x):
     return 2**(-x)
   
 i = scipy.integrate.quad(f, 0, np.inf)
 print(i)

Ausgabe:
 (1.4426950408889556, 4.486558477977586e-09)

== Symbolisches Integrieren ==
Berechnen Sie &lt;math&gt;\int x^2 \text{d}x&lt;/math&gt; und &lt;math&gt;\int \sin{x}\cos{\frac{x}{2}} \text{d}x&lt;/math&gt;.
 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 i1 = sympy.integrate(f1, x)
 i2 = sympy.integrate(f2, x)
 
 print(i1)
 print(i2)

Ausgabe:
 x**3/3
 -0.666666666666667*sin(0.5*x)*sin(x) - 1.33333333333333*cos(0.5*x)*cos(x)

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} \text{d}x&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f = 2**(-x)
 i = sympy.integrate(f, (x, 0, sympy.oo))
 print(i)

Ausgabe:
 1/log(2)

&lt;code&gt;sympy.oo&lt;/code&gt; steht für das {{W|Unendlichzeichen}} &lt;math&gt;\infty&lt;/math&gt; (die liegende Acht oder das Möbiusband). Mit &lt;code&gt;sympy.pprint(i)&lt;/code&gt; ließe sich letzere Ausgabe etwas schöner schreiben:

   1   
 ──────
 log(2)

Man beachtete, &lt;code&gt;log&lt;/code&gt; steht hier für den natürlichen Logarithmus &lt;code&gt;ln&lt;/code&gt;.

== Aufgaben ==
* Integrieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; von 1 bis 5.
* Integrieren Sie die Funktion &lt;math&gt;y = x^3&lt;/math&gt; von 0 bis 4.
* Integrieren Sie &lt;math&gt;\int x^x(\log (x) + 1)\mathrm dx&lt;/math&gt; symbolisch.

= Gewöhnliche Differenzialgleichungen =
== DGL numerisch lösen ==
Für die Lösung von Differenzialgleichungen steht u.a. die Funktion scipy.integrate.solve_ivp() zur Verfügung. Diese Funktion implementiert auch das Runge-Kutta-Verfahren (RK45).

{{Wikipedia | Runge-Kutta-Verfahren}}

Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import scipy
 import numpy as np
 import matplotlib.pyplot as plt
 
 def dy_dx(x, y):
     return x**2 + y**3
 
 y0 = [1]
 xi = [0, 1]
 x = np.arange(0, 1, 0.01)
 
 z = scipy.integrate.solve_ivp(dy_dx, xi, y0, method=&quot;RK45&quot;, dense_output=True)
 y = z.sol(x)
 
 plt.plot(x, y.T)
 plt.grid()
 plt.show()

[[Datei:PythonIng_dgl1.png]]

== DGL symbolisch lösen ==
Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 print(lsg)

Ausgabe:
 [Eq(f(x), (-x**2)**(1/3)), Eq(f(x), (-x**2)**(1/3)*(-1 - sqrt(3)*I)/2), Eq(f(x), (-x**2)**(1/3)*(-1 + sqrt(3)*I)/2)]

Mit &lt;code&gt;sympy.pprint&lt;/code&gt; (pretty print) lässt sich die Ausgabe etwas übersichtlicher darstellen.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 sympy.pprint(lsg)

Ausgabe:
 ⎡                           _____                        _____            ⎤
 ⎢          _____         3 ╱   2                      3 ╱   2             ⎥
 ⎢       3 ╱   2          ╲╱  -x  ⋅(-1 - √3⋅ⅈ)         ╲╱  -x  ⋅(-1 + √3⋅ⅈ)⎥
 ⎢f(x) = ╲╱  -x  , f(x) = ────────────────────, f(x) = ────────────────────⎥
 ⎣                                 2                            2          ⎦

== Aufgaben ==
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \frac{1}{x\cdot y}&lt;/math&gt; mit Python. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;m' = -k\cdot m&lt;/math&gt;. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \sqrt{|y|}&lt;/math&gt;.

=Laplace-Transformation=
Laplace-Transformation:

&lt;math&gt;F(s) =\mathcal{L} \left\{f\right\}(s) = \int_{0}^{\infty} f(t) \mathrm e^{-st} \,\mathrm{d}t, \qquad s\in\mathbb{C}
&lt;/math&gt;

Inverse Laplace-Transformation:

&lt;math&gt;\mathcal{L}^{-1} \left\{F\right\}(t)
  = \frac{1}{2 \pi \mathrm j} \int_{ \gamma - \mathrm j \infty}^{ \gamma + \mathrm j \infty} \mathrm e^{st} F(s)\,\mathrm ds 
= \begin{cases}
      f(t) &amp; \text{für } t \geq 0 \\
      0    &amp; \text{für } t &lt; 0
    \end{cases}
&lt;/math&gt;

Siehe auch [[Ing_Mathematik:_Laplace-Transformation]]

Code:
 import sympy
 from sympy.abc import t, s
 
 # Laplace-Transformation der Funktion f(t) = 1 (Heaviside-Fkt.)
 f = 1
 # alternativ: f = sympy.Heaviside(t)
 F = sympy.laplace_transform(f, t, s, noconds=True)
 print(&quot;Laplace-Transformierte F(s):&quot;, F) 
 
 # Inverse Laplace-Transformation zurück in den Zeitbereich
 f_inv = sympy.inverse_laplace_transform(F, s, t)
 print(&quot;Inverse Transformation f(t):&quot;, f_inv)

Ausgabe:
 Laplace-Transformierte F(s): 1/s
 Inverse Transformation f(t): Heaviside(t)

Die Zeile

 from sympy.abc import t, s

steht alternativ für

 t = sympy.symbols(&quot;t&quot;)
 s = sympy.symbols(&quot;s&quot;)

&lt;u&gt;Aufgaben&lt;/u&gt;: Ermitteln Sie mittels SymPy die &lt;math&gt;\mathcal{L}&lt;/math&gt;-Transformierten und dann wieder die  &lt;math&gt;\mathcal{L}^{-1}&lt;/math&gt;-Transformationen (ähnlich wie beim obigen Beispiel):
* &lt;math&gt;\sin(t) \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;t^3 \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;\text{e}^{\omega t} \circ\! -\! \bullet \ ?&lt;/math&gt;

=Fourier-Reihen=
&lt;math&gt;
f(x)\approx \frac{a_{0}}{2}+\sum_{k=1}^{\infty}\left(a_{k}\cos\left(kx\right)+b_{k}\sin\left(kx\right)\right)
&lt;/math&gt;

&lt;math&gt;
a_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\cos\left(kx\right)\mathrm dx\quad\text{für }k\geq0
&lt;/math&gt;

&lt;math&gt;
b_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\sin\left(kx\right)\mathrm dx\quad\text{für }k\geq1
&lt;/math&gt;

Für die Sägezahnfunktion &lt;math&gt;y=x;\, 0 &lt; x &lt; 2\pi&lt;/math&gt; sei die Fourierreihe mit einem Python-Programm (unter Mithilfe von sympy) hergeleitet.

Code:

 from sympy import fourier_series, pi, symbols, pprint
 
 x = symbols('x')
 f = x
 s = fourier_series(f, (x, 0, 2*pi))
 pprint(s.truncate(n=4))

Ausgabe:

                        2⋅sin(3⋅x)    
 -2⋅sin(x) - sin(2⋅x) - ────────── + π
                            3

Siehe auch [[Ing Mathematik: Fourierreihen]].

Ein komplizierteres Beispiel:

[[Datei:IngMath fourier bsp13.svg | 300px]]

&lt;math&gt;0\le t &lt; T/2\text{:}\quad f(t) = H&lt;/math&gt;

&lt;math&gt;T/2 \le t \le T\text{:}\quad f(t) = \frac{2H}{T}\left( t-\frac{T}{2}\right)&lt;/math&gt;

Code:

 import sympy as sp
 
 H = sp.Symbol('H', positive=True)
 T = sp.Symbol('T', positive=True)
 t = sp.Symbol('t')
 
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T/2)),
     (2*H/T*(t-T/2), (t &gt; T/2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Ausgabe:

      ⎛2⋅π⋅t⎞        ⎛4⋅π⋅t⎞        ⎛6⋅π⋅t⎞          ⎛2⋅π⋅t⎞          ⎛6⋅π⋅t⎞      
 H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   2⋅H⋅cos⎜─────⎟   2⋅H⋅cos⎜─────⎟      
      ⎝  T  ⎠        ⎝  T  ⎠        ⎝  T  ⎠          ⎝  T  ⎠          ⎝  T  ⎠   3⋅H
 ──────────── - ──────────── + ──────────── + ────────────── + ────────────── + ───
      π             2⋅π            3⋅π               2                 2         4 
                                                    π               9⋅π

=Rechnen mit wirklich großen Zahlen=
Bekannt ist, dass Python kaum Einschränkungen beim Wertebereich von Ganzzahlen hat, z.B.

 print(10**300)

Ausgabe (gekürzt):

 100000000000000000000...00000000000000000000000000000000000000000000000000000000000000000000000

Ähnliches geht auch mit Gleitpunktzahlen, z.B. durch die Verwendung des Moduls [https://mpmath.org/ mpmath]:

 import mpmath
 print(mpmath.mpf(1500.4)**mpmath.mpf(300))

Ausgabe:

 7.27975299218612e+952

Anderes Beispiel:

 from mpmath import mp, pi
 mp.dps = 100
 print(pi)

Ausgabe:

 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068

mpmath kann noch einiges mehr, dazu sei aber auf die entsprechende Dokumentation auf der mpmath-Homepage verwiesen. mpmath ist Bestandteil von SymPy, kann aber auch separat installiert werden.

Aber auch Python selbst besitzt eine Möglichkeit, um mit großen bzw. exakten Gleitpunktzahlen zu rechnen, nämlich das interne Modul decimal. Dieses hat einige Vorteile gegenüber mpmath, aber auch gravierende Nachteile. Diese seien hier nicht detailliert aufgezählt. Grob gesagt hat decimal im Finanzwesen seine Berechtigung. Für wissenschaftliche Anwendungen wird aber mpmath vorzuziehen sein, da es u.a. vielfältige mathematische Funktionen bereit stellt. Nachfolgend ein einfaches Beispiel mit decimal:

 import decimal
 print(&quot;Potenzierung:&quot;, decimal.Decimal(1500.4) ** decimal.Decimal(300.0))
 print(&quot;Einfache Addition:&quot;, 0.1 + 0.2)
 decimal.getcontext().prec = 50
 print(&quot;Addition mit decimal:&quot;, decimal.Decimal(&quot;0.1&quot;) + decimal.Decimal(&quot;0.2&quot;))

Ausgabe:

 Potenzierung: 7.279752992186121551039839134E+952
 Einfache Addition: 0.30000000000000004
 Addition mit decimal: 0.3

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet die genauen Vor- und Nachteile von decimal und mpmath. Verwenden Sie dazu auch KI (z.B. von Google, chatgpt).

= pint - mit physikalischen Größen rechnen = 
[[File:Pint-Glas_UK.jpg|right|100px]]
pint ist ein externes Python-Paket zur Manipulation von physikalischen Einheiten. Es muss vor der ersten Benutzung installiert werden (Vorgehensweise wie immer: pip, YaST, via venv etc.).

Beispiel:

 import pint
 import numpy as np
 
 ureg = pint.UnitRegistry()
 
 # Einfache Berechnung
 print(3 * ureg.meter + 4 * ureg.cm)
 
 # Mit NumPy
 npeinzel = [3, 4] * ureg.meter + [2, 5] * ureg.cm
 print(npeinzel)
 npsum = np.sum(npeinzel)
 print(npsum)
 
 # Konvertierung von Einheiten
 npsum_inch = npsum.to(ureg.inch)
 print(npsum_inch)
 
 print(npeinzel.magnitude)
 print(npeinzel.units)
 print(npeinzel.dimensionality)

Ausgabe:

 3.04 meter
 [3.02 4.05] meter
 7.07 meter
 278.3464566929134 inch
 [3.02 4.05]
 meter
 [length]

Die Dokumentation zu pint findet sich auf [https://pint.readthedocs.io/en/stable/].

=Regelungstechnische Aufgabenstellungen=
Für regelungstechnische Aufgaben gibt es u.a. das externe Paket &lt;code&gt;control&lt;/code&gt;. Hier soll nicht detailliert darauf eingegangen werden. Anhand eines Beispiels soll anschließend nur die Visualisierung in Form eines Bode-Diagramms und der Sprungantwort gezeigt werden. Gegeben sei ein P-Regler mit &lt;math&gt;R = \frac{5}{2}&lt;/math&gt; und eine Strecke &lt;math&gt;S= \frac{1}{30s^3+20s^2+10s+1,5}&lt;/math&gt;. Gesucht sei vorerst ein Bode-Diagramm für den offenen Regelkreis und das Führungsverhalten.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke  # oder: G0 = ct.series(regler, strecke)
 Gw = ct.feedback(G0)
 
 ct.bode_plot(G0, label='G0')
 ct.bode_plot(Gw, label='Gw')
 plt.show()

[[Datei:PythonIng_bode1.svg]]

Nun noch für obiges Beispiel die Sprungantwort. Diese zeigt einige große Überschwinger, d.h. der Regler kann sicher noch optimiert werden.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke 
 Gw = ct.feedback(G0) 
 
 t, y = ct.step_response(Gw)
 
 plt.plot(t,y)
 plt.title('Sprungantwort')
 plt.xlabel('t')
 plt.ylabel('h(t)')
 plt.grid()
 plt.show()

[[Datei:PythonIng_bode3.svg]]

Einige weitere wichtige Daten (Phasenreserve, Amplitudenreserve, Durchtrittsfrequenz) lassen sich mittels der &lt;code&gt;control&lt;/code&gt;-Funktion &lt;code&gt;margin()&lt;/code&gt; ermitteln. Die Ortskurve lässt sich mit der Funktion &lt;code&gt;nyquist_plot()&lt;/code&gt; zeichnen. Dies sei hier aber nicht weiter ausgeführt.

==Aufgaben==
* Zeichen Sie mit Python die Ortskurve für obiges Beispiel.
* Was passiert, wenn man die Reglerverstärkung weiter aufdreht (z.B. auf &lt;math&gt;R = \frac{25}{2}&lt;/math&gt;)?
* Wie sehen das Bode-Diagramm und die Sprungantwort aus, wenn ein PI-Regler verwendet wird?

= Stereostatik etc. =
Das Modul SymPy bietet einige Möglichkeiten einfache Bauwerke zu berechnen, z.B. Balken oder Fachwerke. Nachfolgend wird ein einfaches Fachwerk berechnet und gezeichnet.

Python-Code:
 from sympy.physics.continuum_mechanics.truss import Truss 
 
 t = Truss()
 # Knoten
 t.add_node((&quot;A&quot;, -3, 0), (&quot;B&quot;, 0, 0), (&quot;C&quot;, 4, 0), (&quot;D&quot;, 7, 0),
            (&quot;E&quot;, 6, 1.5), (&quot;F&quot;, 2, 3), (&quot;G&quot;, -2, 1.5))
 # Stäbe
 t.add_member((&quot;AB&quot;,&quot;A&quot;,&quot;B&quot;), (&quot;BC&quot;,&quot;B&quot;,&quot;C&quot;), (&quot;CD&quot;,&quot;C&quot;,&quot;D&quot;))
 t.add_member((&quot;AG&quot;,&quot;A&quot;,&quot;G&quot;), (&quot;GB&quot;,&quot;G&quot;,&quot;B&quot;), (&quot;GF&quot;,&quot;G&quot;,&quot;F&quot;))
 t.add_member((&quot;BF&quot;,&quot;B&quot;,&quot;F&quot;), (&quot;FC&quot;,&quot;F&quot;,&quot;C&quot;), (&quot;CE&quot;,&quot;C&quot;,&quot;E&quot;))
 t.add_member((&quot;FE&quot;,&quot;F&quot;,&quot;E&quot;), (&quot;DE&quot;,&quot;D&quot;,&quot;E&quot;))
 # Auflager; roller ... Loslager, pinned ... Festlager
 t.apply_support((&quot;A&quot;,&quot;roller&quot;), (&quot;D&quot;,&quot;pinned&quot;))
 # Einwirkende Kräfte
 t.apply_load((&quot;G&quot;, 5, 270), (&quot;E&quot;, 3, 90))
 
 # Berechnung 
 t.solve()
 print(&quot;Reaction Forces: &quot;, t.reaction_loads)
 print(&quot;Internal Forces: &quot;, t.internal_forces)
 
 # Fachwerk zeichnen
 p = t.draw()
 p.show()

Ausgabe auf der Konsole:

 Reaction Forces:  {'R_A_y': 4.20000000000000, 'R_D_x': 0, 'R_D_y': -2.20000000000000}
 Internal Forces:  {'AB': 2.80000000000000, 'BC': 0.333333333333333, 'CD': -1.46666666666667, 
 'AG': -5.04777178564958, 'GB': -2.05555555555556, 'GF': -1.23413387432364, 
 'BF': 0.411111111111111*sqrt(13), 'FC': -0.3*sqrt(13), 'CE': 1.50000000000000, 
 'FE': 0.284800124843917, 'DE': 2.64407093534026}

Zeichnung:

[[File:PythonIng_fachwerk1.svg|300px]]

Details zu diesem Thema siehe z.B. [https://docs.sympy.org/latest/modules/physics/continuum_mechanics/index.html Continuum Mechanics] oder [https://docs.sympy.org/latest/tutorials/physics/continuum_mechanics/index.html Continuum Mechanics Tutorials]. Auch andere mechanische Probleme werden von SymPy abgehandelt ([https://docs.sympy.org/latest/tutorials/physics/index.html Physics Tutorials]).

== Aufgabe ==
Gegeben sei ein einseitig eingespannter Kragträger. Belastet wird er durch eine Einzellast am Trägerende. Für die Daten siehe folgende ASCII-Skizze:

                            | 20 kN  
    //|---&gt; x               |
    //|                     V
    //|----------------------
    //|         10 m        |
 
 Elastizitätsmodul E = 2,1*10⁵ N/mm²
 Flächenträgheitsmoment I = 0.001 m⁴

Berechnen Sie die Auflagerreaktionen, den Querkraft- und Biegemomentenverlauf, sowie die Verformungen.
Stellen Sie dies mit Hilfe von SymPy graphisch und auch mittels Formeln dar. Verwenden Sie dazu auch pprint (pretty print) aus dem SymPy-Modul. Zwecks Lösungsansatz siehe die oben aufgeführte Seite &quot;Continuum Mechanics Tutorials&quot;. Achten Sie auch auf die Einheiten! Kontrollieren Sie das Ganze mittels händischer Rechnung. In dem genannten Tutorial ist von &quot;Singularity Functions&quot; die Rede. Gemeint ist damit in diesem Kontext die {{W|Föppl-Klammer}}.

Einige Python-Programme, vorrangig zu Maschinenelementen, finden sich auf [https://baymp.de/download_python.html BayMP für Python] (Balken, Zahnräder, Stabknickung usw.).

=Thermodynamik= 
== PYroMat ==
Für thermodynamische Aufgabenstellungen gibt es verschiedene externe Module. Eines davon ist PYroMat (siehe auch [http://pyromat.org]). Damit lassen sich thermodynamische Stoffdaten für viele Substanzen berechnen.

Beispiel (einige Stoffdaten für Wasser bei 400°C und 20 bar berechnen):

 import pyromat as pm
 
 # Wasserdaten laden:
 H2O = pm.get('mp.H2O')
 
 # Stoffdaten berechnen:
 T = 673.15  # Temperatur in Kelvin
 p = 20      # Druck in bar
 v = H2O.v(T, p)
 h = H2O.h(T, p)
 s = H2O.s(T, p)
 print(f&quot;Spezifisches Volumen: {v} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {h} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {s} kJ/(kg K)&quot;)

Ausgabe:

 Spezifisches Volumen: [0.1512163] m³/kg
 Spezifische Enthalpie: [3248.3789473] kJ/kg
 Spezifische Entropie: [7.12924142] kJ/(kg K)

&lt;small&gt;
PYroMat muss vorab installiert werden (z.B. mittels pip, in eine virtuelle Umgebung)
&lt;/small&gt;

&lt;code&gt;mp&lt;/code&gt; steht für &quot;multi phase&quot;. Für ein ideales Gas wäre &lt;code&gt;ig&lt;/code&gt; zuständig, z.B. &lt;code&gt;'ig.O2'&lt;/code&gt;.

Beispiel (T-s-Diagramm für Wasser zeichnen):
 import numpy as np
 import matplotlib.pyplot as plt
 import pyromat as pm
 
 # Konfigurieren
 pm.config[&quot;unit_pressure&quot;] = &quot;bar&quot;
 pm.config[&quot;unit_temperature&quot;] = &quot;K&quot;
 fluid = pm.get(&quot;mp.H2O&quot;)
 
 # Temperaturbereich für das Nassdampfgebiet
 T_tripel = 273.16
 T_crit = 647.096
 T = np.linspace(T_tripel, T_crit - 0.1, 200)
 
 # Sättigungslinien berechnen und zeichnen
 for x in np.linspace(0.0, 1.0, 5):
     s = fluid.s(T=T, x=x)
     if(x&lt;=0.0):
         plt.plot(s, T, label=&quot;Siedelinie x=%3.1f&quot; % x, linewidth=2.0)
     elif(x&gt;=1.0):
         plt.plot(s, T, label=&quot;Taulinie x=%3.1f&quot; % x, linewidth=2.0)
     else:
         plt.plot(s, T, label=&quot;x=%3.1f&quot; % x, linewidth=1.0)
 
 # Isobaren zeichnen
 p_values = [0.1, 1, 10, 50, 100]
 T_isobar = np.linspace(T_tripel, 1000, 200)
 t = 0.7
 
 for p in p_values:
     s_iso = fluid.s(T=T_isobar, p=p)
     plt.plot(s_iso, T_isobar, 'k-', alpha=0.8, linewidth=0.8)
 
     t += .05
     idx = int(len(s_iso) * t)
     plt.text(s_iso[idx], T_isobar[idx], f&quot;{p} bar&quot;, fontsize=9, alpha=0.8)
 
 # Diagramm zeichnen
 plt.title(&quot;T-s-Diagramm für Wasser&quot;)
 plt.xlabel(&quot;Spezifische Entropie s in kJ/kg K&quot;, fontsize=10)
 plt.ylabel(&quot;Temperatur T in K&quot;, fontsize=10)
 plt.legend(loc=&quot;best&quot;)
 plt.grid(True)
 plt.show()

Ausgabe (in etwa so):

[[Datei:T-s-Diagramm fuer Wasser.svg|400px]]

== CoolProp ==
Auch mit CoolProp können Stoffdaten berechnet werden. Siehe auch [https://coolprop.org/coolprop/wrappers/Python/index.html]

Beispiel (Wasser bei 20bar und 400°C):
 import CoolProp.CoolProp as CP
 
 fluid = 'Water'
 T = 673.15   # Temperatur in Kelvin
 P = 20e5     # Druck in Pascal
 
 dichte = CP.PropsSI('D', 'T', T, 'P', P, fluid)
 enthalpie = CP.PropsSI('H', 'T', T, 'P', P, fluid)
 entropie = CP.PropsSI('S', 'T', T, 'P', P, fluid)
 
 print(f&quot;Spez. Volumen: {1/dichte:.6f} m³/kg&quot;)
 print(f&quot;Spez. Enthalpie: {enthalpie:.2f} J/kg&quot;)
 print(f&quot;Spez. Entropie: {entropie:.2f} J/kgK&quot;)

Ausgabe:
 Spez. Volumen: 0.151215 m³/kg
 Spez. Enthalpie: 3248344.02 J/kg
 Spez. Entropie: 7129.16 J/kgK

== iapws ==
Um Werte für Wasser(dampf) zu erhalten (IAPWS; '''I'''nternational '''A'''ssociation for the '''P'''roperties of '''W'''ater and '''S'''team) gibt es die Bibliothek iapws. Siehe auch [https://iapws.org/] und [https://pypi.org/project/iapws/]

Beispiel (Wasser für 20bar und 400°C):
 from iapws import IAPWS97
 
 dampf = IAPWS97(P=2.0, T=673.15)
 
 print(f&quot;Spezifisches Volumen: {dampf.v:.6f} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {dampf.h:.2f} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {dampf.s:.4f} kJ/(kgK)&quot;)
 print(f&quot;Phase: {dampf.phase}&quot;)

Ausgabe:
 Spezifisches Volumen: 0.151208 m³/kg
 Spezifische Enthalpie: 3248.23 kJ/kg
 Spezifische Entropie: 7.1290 kJ/(kgK)
 Phase: Gas

== TESPy ==
Ein anderes Modul für einen anderen Aufgabenzweck ist TESPy ('''T'''hermal '''E'''ngineering '''S'''ystems in '''Py'''thon). Dieses Modul ist für die Anlagensimulation zuständig. Für nähere Informationen siehe [https://tespy.readthedocs.io/en/main/getting_started/introduction.html]. Als Beipiel sei hier vorerst Code, der von der Google KI generiert wurde, angeführt. Der Code wurde überarbeitet, damit keine Warnungen auftreten. Bitte aber den Code trotzdem mit Vorsicht genießen, auch KI-generierter Code kann Fehler aufweisen. Eine Pumpe wird berechnet:

 from tespy.components import Sink, Source, Pump
 from tespy.connections import Connection
 from tespy.networks import Network
 
 # 1. Netzwerk definieren (Zentrales Steuerungselement)
 # Wir wählen Wasser als Fluid und bar/Celsius als Einheiten
 nw = Network(fluids=[&quot;water&quot;])
 nw.units.set_defaults(pressure=&quot;bar&quot;, pressure_difference=&quot;bar&quot;, 
                       temperature=&quot;°C&quot;, enthalpy=&quot;kJ / kg&quot;)
 
 # 2. Komponenten erstellen
 eingang = Source(&quot;Wasserquelle&quot;)
 ausgang = Sink(&quot;Wasserspeicher&quot;)
 pumpe = Pump(&quot;Speisewasserpumpe&quot;)
 
 # 3. Verbindungen definieren (Komponenten miteinander verknüpfen)
 c1 = Connection(eingang, &quot;out1&quot;, pumpe, &quot;in1&quot;)
 c2 = Connection(pumpe, &quot;out1&quot;, ausgang, &quot;in1&quot;)
 
 # Verbindungen dem Netzwerk hinzufügen
 nw.add_conns(c1, c2)
 
 # 4. Randbedingungen und Parameter festlegen
 # Zustand am Eingang (Druck, Temperatur, Massenstrom, Fluid-Zusammensetzung)
 c1.set_attr(
     v=1,  # Massenstrom: 1 kg/s
     T=20,  # Temperatur: 20 °C
     p=1,  # Druck: 1 bar
     fluid={&quot;water&quot;: 1},  # 100% Wasser
 )
 
 # Zustand am Ausgang / Zielwerte der Pumpe
 c2.set_attr(p=10)  # Ziel-Druck nach der Pumpe: 10 bar
 
 # Pumpeneigenschaften festlegen
 pumpe.set_attr(eta_s=0.8)  # Isentroper Wirkungsgrad von 80%
 
 # 5. Simulation ausführen
 nw.solve(mode=&quot;design&quot;)
 
 # 6. Ergebnisse ausgeben
 nw.print_results()
 
 # Spezifische Werte direkt auslesen
 print(&quot;\n--- Auswertung ---&quot;)
 print(f&quot;Erforderliche Pumpenleistung: {pumpe.P.val / 1000:.2f} kW&quot;)
 print(f&quot;Temperatur nach der Pumpe: {c2.T.val:.2f} °C&quot;)

Ausgabe (gekürzt):
  iter  | residual   | progress   | massflow   | pressure   | enthalpy   | fluid      | component  
 -------+------------+------------+------------+------------+------------+------------+------------
  1     | 7.04e+04   | 12 %       | 9.96e+02   | 0.00e+00   | 8.81e+04   | 0.00e+00   | 0.00e+00   
  2     | 5.91e-12   | 100 %      | 1.11e-13   | 0.00e+00   | 7.39e-12   | 0.00e+00   | 0.00e+00   
  3     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
  4     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
 Total iterations: 4, Calculation time: 0.01 s, Iterations per second: 480.85
 
 ##### RESULTS (Pump) #####
 +-------------------+----------+----------+-----------+----------+----------+----------+
 |                   |        P |       pr |        dp |      eta |    eta_s |     head |
 |-------------------+----------+----------+-----------+----------+----------+----------|
 | Speisewasserpumpe | 1.12e+06 | 1.00e+01 | -9.00e+00 | 8.00e-01 | 8.00e-01 | 9.19e+01 |
 +-------------------+----------+----------+-----------+----------+----------+----------+
 ...
 ...
 --- Auswertung ---
 Erforderliche Pumpenleistung: 1124.77 kW
 Temperatur nach der Pumpe: 20.07 °C

= Stochastik =
Die {{W|Stochastik}} ist ein sehr weites Feld. Hier werden etliche wichtige Themen kurz angerissen. Python stellt mit den Moduln math und statistics Software zu diesem Zwecke bereit. math und statistics sind bereits im Lieferumfang von Python enthalten. Aber auch mit den externen Modulen NumPy, SciPy, stochastic und pandas kann man Stochastik in Python betreiben. Die Theorie der Wahrscheinlichkeitsrechnung und Statistik soll etwas später in Band 5 dieser Buchreihe behandelt werden.

== Lageparameter == 
 import statistics
 
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 
 m1 = statistics.mean(werte)
 m2 = statistics.mode(werte)
 m3 = statistics.median(werte)
 
 print(&quot;Arithmetischer Mittelwert = &quot;, m1)
 print(&quot;Modalwert = &quot;, m2)
 print(&quot;Median = &quot;, m3)

Ausgabe:
 Arithmetischer Mittelwert =  3.5
 Modalwert =  1
 Median =  3.0

== Streuungsparameter ==
Beispiel (Berechnung der Standardabweichung):
 import statistics
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 s = statistics.stdev(werte)
 print(&quot;Standardabweichung = &quot;, s)

Ausgabe:
 Standardabweichung =  2.6770630673681683

Beispiel (Berechnung des Variationskoeffizienten V = Standardabweichung/Mittelwert)
 import numpy as np
 from scipy import stats
 import statistics
 
 k = 50
 
 dat1 = [14, 21, 18, 25, 30, 17, 20]
 dat = np.array(dat1)
 
 # Mit SciPy
 v = stats.variation(dat)
 vddof = stats.variation(dat, ddof=1)
 print(&quot;V SciPy: &quot;, v)
 print(&quot;V DDOF SciPy: &quot;, vddof)
 print(k*&quot;-&quot;)
 
 # mit NumPy
 mittelwert1 = np.mean(dat)
 std_abw1 = np.std(dat)
 std_abw1ddof = np.std(dat, ddof=1) 
 v1= std_abw1 / mittelwert1
 v1ddof = std_abw1ddof / mittelwert1
 print(&quot;Mittelwert NumPy: &quot;, mittelwert1)
 print(&quot;Std.abw. NumPy: &quot;, std_abw1)
 print(&quot;Std.abw. DDOF NumPy: &quot;, std_abw1ddof)
 print(&quot;V NumPy: &quot;, v1)
 print(&quot;V DDOF NumPy: &quot;, v1ddof)
 print(k*&quot;-&quot;)
 
 # nur mit reinem Python
 mittelwert2 = statistics.mean(dat1)
 std_abw2 = statistics.stdev(dat1)
 v2 = std_abw2 / mittelwert2
 print(&quot;Mittelwert Python: &quot;, mittelwert2)
 print(&quot;Std.abw. Python: &quot;, std_abw2)
 print(&quot;V Python:&quot;, v2)
 print(k*&quot;-&quot;)

Ausgabe:
 V SciPy:  0.23890355966467272
 V DDOF SciPy:  0.25804533701889254
 --------------------------------------------------
 Mittelwert NumPy:  20.714285714285715
 Std.abw. NumPy:  4.948716593053935
 Std.abw. DDOF NumPy:  5.3452248382484875
 V NumPy:  0.23890355966467272
 V DDOF NumPy:  0.2580453370188925
 --------------------------------------------------
 Mittelwert Python:  20.714285714285715
 Std.abw. Python:  5.3452248382484875
 V Python: 0.2580453370188925
 --------------------------------------------------

Der Unterschied bei der Standardabweichung zwischen reinem Python und den externen Bibliotheken SciPy und NumPy entsteht dadurch, dass einmal durch (n-1) und das andere Mal nur durch n dividiert wird. Dies kann bei NumPy und SciPy dadurch entschärft werden, indem &lt;code&gt;ddof=1&lt;/code&gt; gesetzt wird. ddof steht für '''D'''elta '''D'''egrees '''o'''f '''F'''reedom. &lt;small&gt;Je größer die Anzahl der Datensätze n wird, umso weniger spielt das eine Rolle.&lt;/small&gt;

== Kombinatorik ==
Beispiel:

 import math
 
 n = 7
 k = 5
 
 print(&quot;n! = &quot;, math.factorial(n))
 print(&quot;Kombinationen (n über k) = &quot;, math.comb(n, k))

Ausgabe:
 n! =  5040
 Kombinationen (n über k) =  21

Siehe zu diesem Thema auch [[Ing Mathematik: Permutationen, Kombinationen, binomischer Lehrsatz]]. Die Anzahlen lassen sich einfach aus den dortigen Formeln ermitteln, z.B. bei Permutationen mit &lt;math&gt;n!&lt;/math&gt; oder Variationen mit Wiederholungen als &lt;math&gt;n^k&lt;/math&gt;. Will man die Kombinationen oder Variationen aber auch als Liste ausgeben, so kann das Modul &lt;code&gt;itertools&lt;/code&gt; nützlich sein.  

Beispiel (Variationen ohne Wiederholung):

 from itertools import permutations
 
 menge = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]  # n = 4
 k = 3
 
 variationen = list(permutations(menge, k))
 
 for v in variationen:
     print(&quot;&quot;.join(v))
 
 print(50*&quot;-&quot;)
 print(len(variationen))

Ausgabe (gekürzt):
 ABC
 ABD
 ACB
 ...
 DCA
 DCB
 --------------------------------------------------
 24

Siehe zum Modul &lt;code&gt;itertools&lt;/code&gt; auch die Website [https://docs.python.org/3/library/itertools.html].

* Variationen mit Wiederholung: &lt;code&gt;itertools.product()&lt;/code&gt;
* Kombinationen ohne Wiederholung: &lt;code&gt;itertools.combinations()&lt;/code&gt;
* Kombinationen mit Wiederholung: &lt;code&gt;itertools.combinations_with_replacement()&lt;/code&gt;

== Zufallszahlen ==
Beispiel:
 import random
 
 # Ganzzahlige Zufallszahl von 1 bis 10
 zufallszahl1 = random.randint(1, 10)
 
 # Gleitpunktzahlen
 # zwischen 0.0 und 1.0
 zufallszahl2 = random.random()
 # Zahl zwischen 1.5 und 9.5
 zufallszahl3 = random.uniform(1.5, 9.5)
 
 # aus Liste auswählen
 farbe = [&quot;Rot&quot;, &quot;Grün&quot;, &quot;Blau&quot;]
 zufallswert = random.choice(farbe)
 
 print(zufallszahl1)
 print(zufallszahl2)
 print(zufallszahl3)
 print(zufallswert)

Ausgabe, z.B.:
 5
 0.14147945849015753
 6.894003397570905
 Rot

Benötigt man mehrere Zufallszahlen, so ist das Modul &lt;code&gt;numpy&lt;/code&gt; zu bevorzugen, z.B.:
* Normalverteilung: &lt;code&gt;np.random.normal(...)&lt;/code&gt;
* Gleichverteilung: &lt;code&gt;np.random.uniform(...)&lt;/code&gt;

== Histogramm ==
Zum Thema Histogramm siehe {{W|Histogramm}}.

Beispiel (mit Matplotlib):

 import matplotlib.pyplot as plt
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 
 plt.hist(daten, bins=25, edgecolor='darkgray')
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm.svg|300px]]

Beispiel (mit Seaborn):

 import matplotlib.pyplot as plt
 import seaborn as sns
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 sns.set_theme(style=&quot;darkgrid&quot;)
 sns.histplot(data=daten)
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm2.svg|300px]]

Das Kürzel &lt;code&gt;sns&lt;/code&gt; ist Konvention und steht für die fiktive Figur '''S'''amuel '''N'''orman '''S'''eaborn aus der US-Fernsehserie {{W|The West Wing – Im Zentrum der Macht | The West Wing}}.

== Box-Plot ==
[[File:Elements of a boxplot.svg|400px]]

Siehe auch {{W|Box-Plot}}.

Beispiel (mit Seaborn erstellt):
 import seaborn as sns
 import matplotlib.pyplot as plt
 
 df = sns.load_dataset(&quot;tips&quot;)
 sns.boxplot(data=df, x=&quot;day&quot;, y=&quot;tip&quot;, hue=&quot;day&quot;, legend=False)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot.svg|400px]]

Beispiel (mit Matplotlib erstellt):

 import matplotlib.pyplot as plt
 
 daten = [12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25]
 
 plt.boxplot(daten, patch_artist=True)
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot2.svg|300px]]

Um mehrere Box-Plots unterschiedlicher Farbe mit Matplotlib in einem Diagramm zu zeichnen, können Sie folgendermaßen vorgehen:

 import matplotlib.pyplot as plt
 
 daten = [[12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25],
          [10, 19, 20, 21, 20, 30, 19, 40, 11, 17, 19, 21]]
 
 farben = [&quot;green&quot;, &quot;blue&quot;]
 
 boxplot = plt.boxplot(daten, patch_artist=True)
 
 for patch, farbe in zip(boxplot['boxes'], farben):
     patch.set_facecolor(farbe)
 
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

== Regressionsrechnung ==
Beispiel:
 import numpy as np
 import matplotlib.pyplot as plt
 
 # Messpunkte
 x = np.array([1, 3, 5, 6, 8, 10, 20])
 y = np.array([3, 4, 5, 5, 7, 9, 11])
 
 # Regressionskurve (Grad 1 = lineare Regression, 2 = Polynom-Regression 2. Gr.)
 # y = kx + d
 k, d = np.polyfit(x, y, deg=1)
 # y = ax**2 + bx + c
 a, b, c = np.polyfit(x, y, deg=2)
 
 x_l = np.linspace(1, 20, 100)
 y_p = a * x_l**2 + b * x_l + c
 
 # Zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.plot(x, k*x + d, color='blue', label='Regressionsgerade')
 plt.plot(x_l, y_p, color='red', label='Regressionspolynom 2. Gr.')
 plt.xlabel('x')
 plt.ylabel('y')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_regression.svg|400px]]

== Korrelationsrechnung ==
Beispiel:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 # Messdaten
 x = [1, 3, 4, 5, 6]
 y = [2, 4, 6, 8, 5]
 
 daten = {'X': x, 'Y': y}
 df = pd.DataFrame(daten)
 
 # Korrelation
 korr = df['X'].corr(df['Y'])
 print(f&quot;Korrelationskoeff.: {korr}&quot;) 
 
 # Messpunkte zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:
 Korrelationskoeff.: 0.7556096518348252

[[Datei:IngMath_korrelation.svg|300px]]

== Mengen und Venn-Diagramme ==
Beispiel: 
 import matplotlib.pyplot as plt
 from matplotlib_venn import venn2
 
 menge_a = {1, 2, 3, 4, 5, 6}
 menge_b = {4, 5, 6, 7, 8}
 
 vereinigung = menge_a | menge_b
 schnitt = menge_a &amp; menge_b
 print(&quot;Vereinigungsmenge = &quot;, vereinigung)
 print(&quot;Schnittmenge = &quot;, schnitt)
 
 venn2([menge_a, menge_b], set_labels=('Menge A', 'Menge B'))
 plt.show()

Ausgabe:
 Vereinigungsmenge =  {1, 2, 3, 4, 5, 6, 7, 8}
 Schnittmenge =  {4, 5, 6}

[[Datei:IngMath_venn.svg|300px]]

Siehe auch {{W|Mengendiagramm#Venn-Diagramme}}.

== Verteilungs- und Dichtefunktion ==
* CDF ... '''C'''umulative '''D'''istribution '''F'''unction, Verteilungsfunktion
* PDF ... '''P'''robability '''D'''ensity '''F'''unction, Dichtefunktion

Beispiel (Normalverteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 from scipy.stats import norm
 
 my, sigma = 0, 1
 x = np.linspace(-4, 4, 50)
 
 pdf = norm.pdf(x, my, sigma)
 cdf = norm.cdf(x, my, sigma)
 
 plt.plot(x, pdf, lw=2, label=&quot;Dichtefunktion&quot;)
 plt.plot(x, cdf, lw=2, label=&quot;Verteilungsfunktion&quot;)
 plt.legend()
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:IngMath_cdf_pdf.svg|300px]]

Beispiel (&lt;math&gt;\chi^2&lt;/math&gt;-Verteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 import scipy.stats as stats
 
 x = np.linspace(0, 20, 500)
 
 # df ... degree of freedom, Freiheitsgrad
 pdf = (stats.chi2.pdf(x, df=2), stats.chi2.pdf(x, df=5), stats.chi2.pdf(x, df=10))
 
 for i in range(0,3):
     if(i==0):
         lab = &quot;Freiheitsgrad 2&quot;
     elif(i==1):
         lab = &quot;Freiheitsgrad 5&quot;
     else:
         lab = &quot;Freiheitsgrad 10&quot;
 
     plt.plot(x, pdf[i], label=lab, lw=2)
 
 plt.grid()
 plt.legend()
 plt.show()

Ausgabe:

[[Datei:IngMath_chi2.svg | 300px]]

== Schätzen und Testen ==
=== Intervallschätzung ===
Als Beispiel seien Daten gegeben, die von ''Dürr, Mayer: Wahrscheinlichkeitsrechnung und Schließende Statistik; 7. Aufl., Hanser, 2014, Seite 137'' stammen. Und zwar soll das 95%-Vertrauensintervall für den Mittelwert des Kaloriengehalts (kcal/100g) von Hähnchen ermittelt werden. Wir wollen das mit Python inkl. NumPy und SciPy durchführen. Die Stichprobe ist groß (50 Hähnchen):

Python-Code:
 import numpy as np
 import scipy.stats as stats
 
 # Stichprobe
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203]
 
 # Parameter definieren
 konfidenzniveau = 0.95
 mean = np.mean(daten)
 std = np.std(daten, ddof=1)
 stdfehler = stats.sem(daten)
 
 intervall = stats.norm.interval(confidence=konfidenzniveau, loc=mean, scale=stdfehler)
 
 print(f&quot;Mittelwert: {mean}&quot;)
 print(f&quot;Standardabweichung: {std}&quot;)
 print(f&quot;Konfidenzintervall: {intervall}&quot;)

Ausgabe:
 Mittelwert: 215.48
 Standardabweichung: 33.14238915925757
 Konfidenzintervall: (np.float64(206.29356722321992), np.float64(224.66643277678006))

Diese Werte stimmen gerundet mit denen im genannten Buch überein. Zum Code selbst:
* sem steht für '''s'''tandard '''e'''rror of the '''m'''ean.
* &lt;code&gt;scipy.stats.norm&lt;/code&gt; ... Modul für die Normalverteilung.

=== Punktschätzung ===
Gleiche Daten wie oben bei der Intervallschätzung.

Python-Code:
 import numpy as np
 from scipy import stats
 
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203
         ]
 
 mu_hat, sigma_hat = stats.norm.fit(daten) 
 
 print(f&quot;Schätzer für den Erwartungswert (μ): {mu_hat:.4f}&quot;)
 print(f&quot;Schätzer für die Standardabweichung (σ): {sigma_hat:.4f}&quot;)

Ausgabe:
 Schätzer für den Erwartungswert (μ): 215.4800
 Schätzer für die Standardabweichung (σ): 32.8093

=== Hypothesentests ===
Beispiel:

 import numpy as np
 import scipy.stats as stats
 
 x_quer = 12.075      # Stichproben-Mittelwert
 var    = 0.069       # Stichproben-Varianz
 n      = 90          # Stichprobengröße
 my_0   = 12.0        # Nullhypothese
 alpha  = 0.05        # Signifikanzniveau
 
 z_stat = (x_quer - my_0) / np.sqrt(var / n)
 p_val = 2 * (1 - stats.norm.cdf(np.abs(z_stat)))
 
 print(f&quot;Z-Statistik: {z_stat:.4f}&quot;)
 
 if p_val &lt; alpha:
     print(f&quot;p-Wert: {p_val:.6f} &lt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird verworfen.&quot;)
 else:
     print(f&quot;p-Wert: {p_val:.6f} &gt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird nicht verworfen.&quot;)

Ausgabe:

 Z-Statistik: 2.7087
 p-Wert: 0.006755 &lt; alpha: 0.05
 Die Nullhypothese wird verworfen.

== Statistische Qualitätskontrolle ==
Beispiel (Mittelwertkarte):

 import numpy as np
 import matplotlib.pyplot as plt
 
 # Gegeben
 sollwert = 50.0
 varianz = 4.0
 stichproben_umfang = 1
 daten = [49.5, 50.2, 53.0, 48.1, 52.6, 53.4, 49.8]
 
 # Berechnung
 standardabweichung = np.sqrt(varianz)
 streuung = standardabweichung / np.sqrt(stichproben_umfang)
 
 cl = sollwert
 ucl = cl + 3 * streuung
 lcl = cl - 3 * streuung
 
 # Darstellung
 plt.plot(daten, marker='o', linestyle='-', color='b', label='Messdaten')
 plt.axhline(cl, color='green', linestyle='-', label=f'CL: {cl}')
 plt.axhline(ucl, color='red', linestyle='--', label=f'UCL: {ucl:.2f}')
 plt.axhline(lcl, color='red', linestyle='--', label=f'LCL: {lcl:.2f}')
 
 plt.title('Mittelwertkarte')
 plt.xlabel('Stichprobe')
 plt.ylabel('Wert')
 plt.legend(loc='lower left')
 plt.grid(True)
 plt.show()

Ausgabe:

[[Datei:IngMath_mittelwertkarte.svg|300px]]

Siehe auch {{W|Shewhart-Regelkarte}} und {{W|Qualitätsregelkarte}}.

* UCL ... '''U'''pper '''C'''ontrol '''Limit''', Obere Eingriffsgrenze
* LCL ... '''L'''ower '''C'''ontrol '''Limit''', Untere Eingriffsgrenze
* CL ... '''C'''enter '''L'''ine, Mittellinie

= Ein- und Ausgabe =
== print ==
Die Anweisung print haben wir schon oft verwendet. Hier soll anhand von Beispielen kurz beschrieben werden, was der Befehl print leisten kann.

 print(&quot;Hallo&quot;, &quot;Welt&quot;, 1, sep=&quot;-&quot;)
 print(&quot;Hallo&quot;, end=&quot; &quot;)
 print(&quot;Welt&quot;)

Ausgabe:
 Hallo-Welt-1
 Hallo Welt

== input ==
 a = int(input(&quot;Zahl 1: &quot;))
 b = int(input(&quot;Zahl 2: &quot;))
 
 print(&quot;a + b = &quot;, a+b)

Ausgabe (nach Eingabe der beiden Ganzzahlen):
 Zahl 1: 4
 Zahl 2: 5
 a + b =  9

== Aus Dateien lesen ==
Es seinen die datei.txt
 Hallo Welt.
 Wie geht es dir?
 ...

und test1.py
 dat = open(&quot;datei.txt&quot;, mode = &quot;r&quot;)
 print(dat.read())
 dat.close()

Ausgabe
 Hallo Welt.
 Wie geht es dir?
 ...

Mit dem open()-Befehl wird die Datei datei.txt im Lesemodus geöffnet (r ... read). Mit dem read()-Befehl wird die Datei eingelesen und mittels print ausgegeben.

== In Dateien schreiben ==
 dat = open(&quot;datei.txt&quot;, mode = &quot;a&quot;, encoding = &quot;utf-8&quot;)
 dat.write(&quot;Hänge Zeile an\n&quot;)
 dat.close()

Die Datei datei.txt sieht nach Abarbeitung des obigen Skripts nun so aus
 Hallo Welt.
 Wie geht es dir?
 ...
 Hänge Zeile an

Es wird die Datei im Schreibmodus geöffnet (a ... append (anhängend), w ... write (überschreibend)).
write() fügt hier also eine Zeile Text am Dateiende ein. close() schließt die Datei wieder.

Das close() kann man sich mit der with-Anweisung auch sparen.

 with open(&quot;datei.txt&quot;, mode=&quot;a&quot;, encoding=&quot;utf-8&quot;) as dat:
     dat.write(&quot;Hänge Zeile an\n&quot;)

= Benutzeroberflächen erstellen =
== tkinter ==
{{Wikipedia | Tkinter}}

Python bietet standardmäßig das Modul tkinter zur Programmierung von Benutzeroberflächen. Es müssen also bei der Verwendung von tkinter keine externen Module installiert werden. Hier wird eine (sehr) kurze Einführung in das Erstellen von grafischen Oberflächen mittels tkinter gegeben.

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 win.minsize(300, 50)
 but = tk.Button(win, text = &quot;Push the button&quot;)
 but.pack()
 win.mainloop()

Ausgabe:

[[Datei:PythonIng_gui1.jpg]]

Ein etwas komplizierteres Beispiel sei nachfolgend gezeigt. Es sollen zwei Strings miteinander verknüpft und ausgegeben werden. 

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 
 def on_button_clicked():
     str = ent1.get() + ent2.get()
     lab2[&quot;text&quot;] = str
  
 ent1 = tk.Entry(win)
 ent2 = tk.Entry(win)
 lab1 = tk.Label(win, text=&quot;verknuepfen mit&quot;)
 lab2 = tk.Label(win, text=&quot;&quot;) 
 but = tk.Button(win, text = &quot;=&quot;, command=on_button_clicked)
 
 ent1.pack(side=&quot;left&quot;)
 lab1.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 but.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 lab2.pack(side=&quot;left&quot;)
 
 win.mainloop()

Ausgabe  (vor der Eingabe der Teilstrings): 

[[Datei:PythonIng_gui2.jpg]]

Ausgabe (nach der Eingabe der Teilstrings und dem Drücken des =-Buttons): 

[[Datei:PythonIng_gui3.jpg]]

== curses ==
{{Wikipedia | curses}}

Mit dem curses-Modul lassen sich u.a. TUIs ('''T'''ext '''U'''ser '''I'''nterfaces) erstellen. Ein sehr einfaches Beispiel zur allgemeinen Funktionsweise wird nachstehend geliefert.
 
 import curses
 
 stdscr = curses.initscr()
 curses.start_color()
 curses.init_pair(1, curses.COLOR_RED, curses.COLOR_WHITE)
 stdscr.clear()
 
 stdscr.addstr(&quot;Hallo Welt&quot;, curses.color_pair(1))
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()
 
Als Ausgabe sollte &lt;span style=&quot;color:#FF0000;&quot;&gt;Hallo Welt&lt;/span&gt; (rote Schrift auf weißem Hintergrund) auf dem Terminal/der Konsole erscheinen. Getestet wurde dies mit openSUSE Tumbleweed, Python-Version 3.13.12. Das entsprechende Python-curses-Package muss installiert sein.

Allgemeine Informationen zur Terminal-/Konsolengröße und Cursorposition liefert folgendes Programm:
 
 import curses
 
 stdscr = curses.initscr()
 
 stdscr.addstr(3, 5, &quot;LINES: %d&quot; % curses.LINES)
 stdscr.addstr(4, 5, &quot;COLS:  %d&quot; % curses.COLS)
 
 (y,x) = stdscr.getyx()
 stdscr.addstr(5, 5, &quot;Momentane Cursorposition:  [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getbegyx()
 stdscr.addstr(6, 5, &quot;Koordinatenursprung:       [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getmaxyx()
 stdscr.addstr(7, 5, &quot;Fenstergröße:              [%d, %d]&quot; % (y, x))
 
 stdscr.addstr(11, 2, &quot;Taste drücken -&gt; Ende&quot;)
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()

Es sollte sich in etwa folgende Ausgabe ergeben:

     LINES: 44
     COLS:  110
     Momentane Cursorposition:  [4, 15]
     Koordinatenursprung:       [0, 0]
     Fenstergröße:              [44, 110]
 
 
 Taste drücken -&gt; Ende

Zur Funktionsweise von curses siehe auch das Wikibook [[ncurses]]. Zum Verständnis sind dort allerdings elementare Kenntnisse in der Programmiersprache C erforderlich.

== Qt ==
{{Wikipedia | Qt (Bibliothek)}}

Auch für das Qt-Framework gibt es eine Anbindung an Python. Nachfolgend ein einfaches Beispiel.

 import sys
 from PySide6.QtWidgets import QApplication, QLabel
 
 app = QApplication(sys.argv)
 label = QLabel(&quot;Hallo Welt!&quot;)
 label.show()
 sys.exit(app.exec())

Ausgabe:

[[Datei:PythonIng_gui10.png]]

== Gtk ==
{{Wikipedia | GTK (Programmbibliothek)}}

Eine idente Ausgabe, wie oben für Qt gezeigt, erzeugt z.B. folgendes Gtk-Programm:

 import gi
 gi.require_version(&quot;Gtk&quot;, &quot;4.0&quot;)
 from gi.repository import Gtk
 
 def on_activate(app):
     win = Gtk.ApplicationWindow(application=app)
     lab = Gtk.Label(label=&quot;Hallo Welt!&quot;)
     win.set_child(lab)
     win.present()
 
 app = Gtk.Application()
 app.connect('activate', on_activate)
 app.run(None)

Auch für die Benutzung von Qt und Gtk müssen die jeweiligen Packages installiert sein. Getestet wurden die entsprechenden Python-Programme nur unter openSUSE Tumbleweed. Wie das GTK-Paket unter MS Windows 11 installiert wird, siehe z.B. [https://www.gtk.org/docs/installations/windows Setting up GTK for Windows].

Damit sei aber das Thema &quot;Benutzeroberflächen erstellen&quot; hier abgeschlossen, da dies schon ein sehr spezielles Aufgabengebiet ist, das eher Informatiker und nicht so sehr Ingenieure anspricht. Bei Bedarf siehe aber ggf. die entsprechenden Links unten in diesem Tutorial. Dort sind weiterführende Informationen zu finden.

= Pandas kurz erklärt =
Hier wird kurz auf das externe Modul Pandas eingegangen. Pandas steht für '''Pan'''el '''Da'''ta und ist ein Modul für die Datenanalyse und -manipulation.

== Series ==
Vorstellbar ist eine &quot;Series&quot; wie eine einzelne Spalte in einem Tabellenkalkulationsprogramm.

Beispiel (Index implizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5]) # Temperaturwerte
 print(temp)

Ausgabe:
 0     8.5
 1    11.0
 2    12.5
 3    10.0
 4    13.0
 5    11.0
 6    14.5
 dtype: float64

Das Kürzel &lt;code&gt;pd&lt;/code&gt; ist Konvention. Es seien Temperaturwerte gegeben. Die erste Spalte bei der Ausgabe ist der Index. Die zweite Spalte enthält die Werte.

Beispiel (separater Zugriff auf den Index und auf die Werte):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5])
 print(temp.index)
 print(temp.values)

Ausgabe:
 RangeIndex(start=0, stop=7, step=1)
 [ 8.5 11.  12.5 10.  13.  11.  14.5]

Beispiel (Index explizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 print(&quot;*** Die gesamte Series ***&quot;)
 print(temp)
 
 print(&quot;*** Temperatur am Donnerstag ***&quot;)
 print(temp[&quot;Do&quot;])
 
 print(&quot;*** Tage wärmer als 12 Grad ***&quot;)
 temp_gr_12 = temp[temp &gt; 12]
 print(temp_gr_12)

Ausgabe:
 *** Die gesamte Series ***
 Mo     8.5
 Di    11.0
 Mi    12.5
 Do    10.0
 Fr    13.0
 Sa    11.0
 So    14.5
 dtype: float64
 *** Temperatur am Donnerstag ***
 10.0
 *** Tage wärmer als 12 Grad ***
 Mi    12.5
 Fr    13.0
 So    14.5
 dtype: float64

== DataFrame ==
Ein DataFrame entspricht einer Tabelle.

Beispiel (Erzeugen eines DataFrames):
 import pandas as pd
 
 tag   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 v1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=tag)
 v2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=tag)
 v3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=tag)
 
 tab = pd.concat([v1, v2, v3], axis=1)
 tab.columns = stadt
 
 print(tab)
 print(type(tab))

Ausgabe:
     Linz  Salzburg Innsbruck
 Mo     1         8     Hallo
 Di     2         9        16
 Mi     3        10        17
 Do     4        11        18
 Fr     5        12        19
 Sa     6        13        20
 So     7        14        21
 &lt;class 'pandas.core.frame.DataFrame'&gt;

Wir haben hier drei Datenspalten (v1, v2, v3) mit den Spaltennamen &quot;Linz&quot;, &quot;Salzburg&quot; und &quot;Innsbruck&quot;, sowie sieben Zeilen &quot;Mo&quot; bis &quot;So&quot;.

Beispiel (Zugriff auf eine Spalte):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab[&quot;Salzburg&quot;])

Ausgabe:
 Mo     8
 Di     9
 Mi    10
 Do    11
 Fr    12
 Sa    13
 So    14
 Name: Salzburg, dtype: int64

Beispiel (Zugriff auf eine Zeile):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab.loc[&quot;Di&quot;])

Ausgabe:
 Linz          2
 Salzburg      9
 Innsbruck    16
 Name: Di, dtype: object

== Grafiken erstellen ==
Hier sei nur ein Torten- oder Kreisdiagramm gezeichnet:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 expl = [0, 0.2, 0, 0, 0, 0, 0]
 temp.plot.pie(figsize=(5,5), explode=expl)
 plt.show()

Ausgabe:

[[Datei:IngPython_pandas1.svg|350px]]

Die &lt;code&gt;figsize&lt;/code&gt; hat nichts mit der Spaltenanzahl zu tun, sondern setzt die Fenster- oder Diagrammgröße in Inches (Breite * Höhe).
 
Mit Pandas kann man auch noch andere Diagrammarten erstellen, z.B. Linien- oder Balkendiagramme. Dies wird hier aber nicht vorgeführt.

== Arbeiten mit CSV- und LibreOffice-Dateien ==
Gegeben sei eine CSV-Datei test1.csv:
 Mai;Juni;Juli
 12;17;45
 15;65;65
 16;32;23
 4;14;7
 23;17;Keine Daten verfügbar
 67;Keine Daten verfügbar;45
 15;24;12

Lesen von dieser CSV-Datei:
 import pandas as pd
 
 tab = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 print(tab)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Schreiben in eine CSV-Datei test2.csv:
 import pandas as pd
 
 val = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 val.to_csv(&quot;test2.csv&quot;, index=False)

Ausgabedatei:
 Mai,Juni,Juli
 12,17,45
 15,65,65
 16,32,23
 4,14,7
 23,17,Keine Daten verfügbar
 67,Keine Daten verfügbar,45
 15,24,12

Die Ausgabedatei ist beinahe gleich wie die Eingabedatei. Es werden aber Kommas statt Strichpunkten verwendet. Daher kommt auch der Name CSV ('''C'''omma '''S'''eparated '''V'''alue). Will man wieder Strichpunkte, so kann man dies über den Parameter &lt;code&gt;sep=&quot;;&quot;&lt;/code&gt; in der &lt;code&gt;to_csv&lt;/code&gt;-Funktion machen.

Um direkt von einer ODS-Datei (LibreOffice Calc, '''O'''pen '''D'''ocument '''S'''preadsheet) zu lesen muss das Modul odfpy extra installiert sein (per YaST, pip etc.). Gelesen wird dann folgendermaßen:
 import pandas as pd
 
 df = pd.read_excel('test1.ods', engine='odf')
 print(df)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Die Datei &quot;test1.ods&quot; sei die Datei, aus der das obige &quot;test1.csv&quot; generiert wurde. Schreiben kann man ebenfalls in eine ODS-Datei:

 import pandas as pd
 
 daten = {
     &quot;Name&quot;: [&quot;Hugo&quot;, &quot;Richie&quot;, &quot;Wilhelmine&quot;],
     &quot;Alter&quot;: [38, 30, 29],
     &quot;Ort&quot;: [&quot;Linz&quot;, &quot;Innsbruck&quot;, &quot;Salzburg&quot;]
 }
 
 tab = pd.DataFrame(daten)
 
 with pd.ExcelWriter(&quot;test2.ods&quot;, engine=&quot;odf&quot;) as writer:
     tab.to_excel(writer, sheet_name=&quot;Daten&quot;, index=False)

Es ergibt sich eine &quot;test2.ods&quot;-Datei (Screenshot):

[[Datei:IngPython_pandas2.png|250px]]

== Sonstiges ==
Hier seien stichpunktartig einige weitere Features von Pandas angeführt:
* {{W|Pivot-Tabelle|Pivot-Tabellen}} (pivot ... Dreh-, Angelpunkt): Zweck - große Datenmengen schnell zusammenfassen, filtern und analysieren.
* NaN ('''n'''ot '''a''' '''n'''umber): In einem Datensatz fehlt ein Wert oder ist nicht definiert.
* groupby-Funktion: Daten strukturieren, aggregieren oder Zwischensummen bilden. 
* {{W|Binning#Datenverarbeitung_und_-analyse|Binning}}: Klassenbildung.
* Mehrstufige Indizierung (Hierarchical Indexing oder MultiIndex)
* Zeitreihen (Time Series)

Für tiefergehende und weiterführende Informationen wird auf das Buch von ''Klein: Numerisches Python; Hanser, 2023'' und [https://pandas.pydata.org/ pandas] verwiesen.

= Style Guide, flake8, pylint, Black etc. =
== Style Guide ==
Wie man schönen und richtigen Python-Code schreibt, erfahren Sie in
* [https://peps.python.org/pep-0008/ PEP 8 – Style Guide for Python Code]

== Formatter und Linter ==
Ein Modul, das prüft, ob die Richtlinien im Style Guide eingehalten wurden, ist ''flake8'':
* [https://flake8.pycqa.org/en/latest/ Flake8: Your Tool For Style Guide Enforcement]

Code formatieren kann man auch mit [https://pypi.org/project/black/ Black]. Z.B. übersetzt &lt;code&gt;black test1.py&lt;/code&gt; die Datei &lt;code&gt;test1.py&lt;/code&gt;

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)),
     (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

in 

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)), (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Die Programmausgabe ist 

 reformatted test1.py
 
 All done! ✨ 🍰 ✨
 1 file reformatted.

Der Unterschied zwischen Black und Flake8:
* Black ist ein Code-Formatter. Er formatiert Ihren Code um, sodass er im Einklang mit PEP 8 steht.
* Flake8 ist ein {{W|Lint (Programmierwerkzeug) | Code-Linter}}. Flake8 verändert Ihren Code nicht, sondern durchsucht ihn nach potenziellen Fehlern etc.

Am obigen Beispiel sieht man auch, dass flake8 und Black nicht immer einer Meinung sind. Flake8 (&lt;code&gt;flake8 test1.py&lt;/code&gt;) würde standardmäßig den mit Black formatierten Code bemängeln:

 test1.py:8:80: E501 line too long (80 &gt; 79 characters)

Diese Diskrepanz kann beseitigt werden. Da 79 Zeichen auf modernen Bildschirmen meist als zu kurz empfunden werden, ist ein Limit von 88 Zeichen (Black-Standard) oder mehr empfehlenswert. Um dies zu implementieren, erstellen Sie in Ihrem Projektverzeichnis eine &lt;code&gt;.flake8&lt;/code&gt;-Datei mit dem Inhalt

 [flake8]
 max-line-length = 88

Und schon ignoriert Flake8 dieses Problem.

Ein anderer Linter ist pylint. Der würde beim Abarbeiten des obigen Beispiels, z.B. mit &lt;code&gt;pylint test1.py&lt;/code&gt; noch eine Kleinigkeit bemängeln:

 ************* Module test1
 /home/hr/tmp/test1.py:1:0: C0114: Missing module docstring (missing-module-docstring)
 
 ------------------------------------------------------------------
 Your code has been rated at 8.57/10 (previous run: 8.57/10, +0.00)

Auch pylint muss vor der ersten Verwendung installiert werden (z.B. mittels pip, virtuelle Umgebung, YaST). Die Dokumentation zu pylint findet sich auf [https://pylint.readthedocs.io/en/latest/].

&lt;u&gt;Aufgabe:&lt;/u&gt; Fügen Sie einen &quot;module docstring&quot; in die &lt;code&gt;test1.py&lt;/code&gt;-Datei ein und testen Sie erneut mit flake8, Black und pylint. &lt;small&gt;Sehen Sie zum Thema docstrings auch [https://peps.python.org/pep-0257/#what-is-a-docstring PEP 257 – Docstring Conventions].&lt;/small&gt;

Es gibt noch weitere Formatierungswerkzeuge für Python-Code. Z.B. [https://docs.astral.sh/ruff/ Ruff], ein moderner Code-Formatter und -Linter. Mittels &lt;code&gt;ruff check test1.py&lt;/code&gt; würde obiger Code geprüft (Linter). &lt;code&gt;ruff format test1.py&lt;/code&gt; formatiert den Code (Formatter).

== Type Checker ==
&quot;Type Checker&quot; sind z.B.
* mypy
* pyright
* ty

Diese prüfen die Datentypen, z.B. in folgendem Code

 def greetings(name: str) -&gt; str:
     return &quot;Hello, %s&quot; % name
 
 
 print(greetings(42))

Python selbst, flake8, ruff oder black würden diesen Code ohne zu murren akzeptieren. &quot;Type Checker&quot; würden aber sehr wohl Alarm schlagen, z.B. liefert &lt;code&gt;mypy&lt;/code&gt; folgende Ausgabe

 test1.py:5: error: Argument 1 to &quot;greetings&quot; has incompatible type &quot;int&quot;; expected &quot;str&quot;  [arg-type]
 Found 1 error in 1 file (checked 1 source file)

Das funktioniert übrigens nicht nur bei Funktionsannotationen, sondern auch mit Variablen etc.

 from typing import Final
 
 # &quot;Konstante&quot;, ab Python 3.8
 NUMBER: Final = 123
 print(NUMBER)
 NUMBER = 125
 print(NUMBER)
 
 # Variable
 a: int = 345
 print(a)
 a = &quot;Irgendwas&quot;
 print(a)
 
 # Variable (Pipe-Symbol), ab Python 3.10
 b : int|str = 567
 print(b)
 b = &quot;sonstiges&quot;
 print(b)

Ausgabe mit python:
 123
 125
 345
 Irgendwas
 567
 sonstiges

Ausgabe mit mypy:
 test3.py:6: error: Cannot assign to final name &quot;NUMBER&quot;  [misc]
 test3.py:12: error: Incompatible types in assignment (expression has type &quot;str&quot;, variable has type &quot;int&quot;)  [assignment]
 Found 2 errors in 1 file (checked 1 source file)

Python kennt übrigens keine Konstanten. Man kann diese mittels Großbuchstaben andeuten. Das ist aber nur Konvention, hat aber keine sonstigen Auswirkungen. Oder man verwendet wie oben gezeigt &lt;code&gt;Final&lt;/code&gt;. Dann werfen Typchecker Errors aus.

==pydoc==
pydoc ist ein Werkzeug, um Python-Module, -Funktionen und -Klassen zu dokumentieren.

Beispiel &lt;code&gt;test1.py&lt;/code&gt;:
 &quot;&quot;&quot;Rechen-Modul.
 
 Funktionen die von pydoc gelesen werden.
 &quot;&quot;&quot;
 
 def multiply(a, b):
     &quot;&quot;&quot;Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
     
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a * b
     
 def add(a, b):
     &quot;&quot;&quot;Addiert zwei Zahlen und gibt das Ergebnis zurück.
    
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a + b
    
 
 if __name__ == '__main__':
     print(multiply(3, 5))
     print(add(4, 6))

Ausgabe mit &lt;code&gt;python3.13 -m pydoc test1&lt;/code&gt; auf der Konsole:

 Help on module test1:
 
 NAME
     test1 - Rechen-Modul. 
 
 DESCRIPTION
     Funktionen die von pydoc gelesen werden.
 
 FUNCTIONS
     add(a, b)
         Addiert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
     multiply(a, b)
         Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
 FILE
     /home/xyz/tmp/test1.py

Siehe zu diesem Thema z.B. auch [https://docs.python.org/3/library/pydoc.html]. Mittels &lt;code&gt;python3.13 -m pydoc -w test1&lt;/code&gt; kann man auch eine HTML-Dokumentation erstellen.

Wofür &lt;code&gt;if __name__ == '__main__':&lt;/code&gt; steht, siehe z.B. etwas später im Abschnitt [[Ing_Mathematik:_Python#Doctests]].

== Sonstige Tools ==
Andere Tools für die {{W|Statische Code-Analyse|statische Codeanalyse}}, die aber für Ingenieure weniger interessant sein dürften, sind z.B.
* Radon: Liefert verschiedene {{W|Softwaremetrik|Codemetriken}} (Komplexität, Wartbarkeitsindex ...)
* Bandit: Findet Sicherheitslücken

Tools für die {{W|Dynamisches Software-Testverfahren|dynamische Codeanalyse}}, z.B.:
* DynaPyt (Framework zur dynamischen Programmanalyse)
* cProfile (Profiler)
* Memory Profiler (Speicheranalyse)
* Memray (Speicheranalyse)
* tracemalloc (Speicheranalyse)

Paket- und Projektmanagement (pip-Ersatz etc.):
* uv
* Poetry
* Conda
* pipx

Packaging-Tools (Freezer) und {{W|Compiler#Sonderformen|Transpiler}} :
* pyinstaller
** erstellt eigenständige, ausführbare Binärdatei
** kein Cross-Compiler
** kein Schutz vor Reverse-Engineering
** langsam
** packt alles in eine Datei
** sehr große Datei
** Befehl, z.B.: &lt;code&gt;pyinstaller --onefile test1.py&lt;/code&gt;
** GUI: &lt;code&gt;auto-py-to-exe&lt;/code&gt;
* cx_Freeze
* nuitka
** Übersetzt Python-Code in C/C++-Code und weiter in eine ausführbare Datei
** kein Cross-Compiler
** Schutz vor Reverse-Engineering
** Befehl, z.B.: &lt;code&gt;nuitka --standalone --onefile test1.py&lt;/code&gt;
* cython

= Einige Integrierte Entwicklungsumgebungen (IDEs)=
Werden Programmtexte größer und umfangreicher, so ist das Arbeiten mit der interaktiven Programmierumgebung bzw. das direkte Ausführen von Python-Skripten mühsam. Man wünscht sich z.B. Hilfen zum Debuggen oder die automatische Code-Vervollständigung. Zu diesem Zweck wurden IDEs (Integrated Development Environments) geschaffen. Von diesen seinen nachfolgend auszugsweise einige kurz beschrieben. Testen Sie einfach aus, welche davon für Sie bzw. für Ihr Python-Projekt geeignet sind.

== IDLE ==
IDLE ist die mit dem Python-Programmpaket mitgelieferte IDE. Der Name leitet sich einerseits ab vom Monty-Python-Mitglied Eric Idle, andererseits steht es als Abkürzung für &quot;'''I'''ntegrated '''D'''evelopment and '''L'''earning '''E'''nvironment. IDLE ist einfach zu bedienen, bietet aber schon einen beachtlichen Leistungsumfang. Nachfolgend wird ein Screenshot zu IDLE geliefert. Rechts ist das Editor-Fenster zu sehen, links die interaktive Programmierumgebung. Um das Beispiel selbst nachvollziehen zu können, starten Sie IDLE. Das geht ähnlich, wie Sie die interaktive Programmierumgebung von Python starten (nur, dass Sie eben das IDLE-Icon doppelklicken und nicht das Python-Icon. Unter Linux geben Sie einfach in einem Terminal &lt;code&gt;idle3.13&lt;/code&gt; o. Ä. ein). Weiter geht es mit &quot;File - Open - ...&quot;. Die auszuführende Datei auswählen (im konkreten Fall ein &quot;Hallo-Welt&quot;-Programm). Es erscheint das rechte Fenster. Dort &quot;Run - Run Module&quot; auswählen. Und schon wird im linken Fenster &quot;Hallo Welt!&quot; ausgegeben.

[[Datei:PythonIng_idle1.jpg | 600px]]

Siehe auch {{W|IDLE}}.

== PyCharm ==
PyCharm ist ein kommerzielles Produkt. Es gab aber auch eine kostenlose Community Edition. Seit 2025 sind beide Varianten vereint. Für die ersten 30 Tage sind die Pro-Funktionen frei verfügbar, danach nur noch die Kernfunktionalitäten (oder man bezieht kostenpflichtig  die Pro-Version). Zu beziehen ist PyCharm unter dem Weblink [https://www.jetbrains.com/pycharm/]. Nachfolgend ein etwas abgewandeltes &quot;Hallo Welt&quot;-Programm, editiert und ausgeführt mit PyCharm.

[[Datei:PyCharm_IDE_2023_screenshot.png | 600px]]

Siehe auch {{W|PyCharm}}.

== Eric ==
Auch eric ist Open Source und steht unter der  GNU General Public License Version 3 oder später. Zu beziehen ist diese Software unter [https://eric-ide.python-projects.org/].

[[Datei:Screenshot_Eric_4.png | 600px]]

Siehe auch {{W|eric (Software)}}.

&lt;small&gt;
Unter openSUSE Tumbleweed sollte sich eric auch mit YaST installieren lassen. Bei mir gibt es aber dann beim Ausführen des eric-Programms eine Fehlermeldung (Stand März 2026): 
 
 ...
 ModuleNotFoundError: No module named 'PyQt6.QtPdfWidgets'

Umgehen kann man dieses Problem aber wieder mit dem Erstellen einer virtuellen Umgebung, in etwa so

 python3.13 -m venv ~/tmp/venv1
 cd ~/tmp/venv1/bin
 ./python3.13 -m pip install --upgrade --prefer-binary eric-ide
 ./eric7_ide
&lt;/small&gt;

== PyScripter ==
Vom Funktionsumfang vergleichbar mit den vorherigen IDEs ist PyScripter. Auch PyScripter ist Open Source. Die Projekt-Homepage findet sich auf [https://sourceforge.net/projects/pyscripter/]. PyScripter ist nur für MS Windows verfügbar.

[[Datei:PythonIng_pyscripter1.jpg | 600px]]

== Spyder IDE ==
Spyder enthält bereits eine stabile Python-Version und etliche Module (z.B. matplotlib, numpy, control). Ansonsten kann dieses Softwarepaket vom Funktionsumfang her mit den anderen genannten IDEs locker mithalten. Spyder wurde unter der MIT-Lizenz veröffentlicht. Diese Software findet sich auf [https://www.spyder-ide.org].

[[Datei:Spyder-windows-screenshot.png | 600px]]

Siehe auch {{W|Spyder (Software)}}

== Eclipse IDE==
Die {{W|Eclipse_(IDE)|Eclipse-IDE}} kann für Python aufgerüstet werden. Dazu gibt es das PyDev-Plugin. Installiert wird es über 
* Help &gt; Eclipse Marketplace... 
* Find - PyDev - Install
Danach muss noch der Pfad zum Python-Interpreter festgelegt werden 
* Window &gt; Preferences &gt; PyDev &gt; Interpreters &gt; Python Interpreter &gt; New ... 
Das Ergebnis ist ähnlich wie im folgenden Bild, nur dass statt C/C++ Python Verwendung findet. 

[[Datei:Setting Up Eclipse CDT helloout.png | 600px]]

== Sonstige ==
Die genannten IDEs sind nicht die Einzigen. Es gibt, um dem Image Pythons als beliebteste Programmiersprache gerecht zu werden, noch einige andere. Sowohl Open Source-Programme als auch kommerzielle Programme sind im Web zu finden, z.B. Thonny oder {{W|Visual Studio Code}}. Unter Linux kann man auch {{W|KDevelop}}, ausgestattet mit dem Python3-Plugin, einsetzen. Braucht man den Umfang von ausgewachsenen IDEs nicht, so kann man auch normale Texteditoren verwenden (z.B. {{W|Geany}} oder {{W|Kate_(Texteditor)|Kate}}).

= Debuggen und Testen =
Das Debuggen und Testen von Programmen sind wichtige Bestandteile der Programmierung. Syntaxfehler lassen sich i.A. leicht beheben. Schwieriger ist das Eingrenzen von logischen Fehlern, die ev. nur in bestimmten Situationen auftreten und keine explizite Fehlermeldung hervorrufen. Das Programm liefert falsche Ergebnisse oder es stürzt aus heiterem Himmel ab. Um das zu verhindern gibt es verschiedene Werkzeuge, die bei der Fehlersuche behilflich sein können. Vorerst siehe aber zwecks Begriffsklärung noch folgende Links: 
 
* {{W|Debuggen}}
* {{W|Debugger}}
* {{W|Softwaretest}}

&lt;gallery&gt;
First Computer Bug, 1947.jpg
Test ganzheitlich.png
V-Modell.svg
&lt;/gallery&gt;

== Das Modul pdb ==
Python bringt schon ein Modul zum Debuggen mit. Siehe z.B. [https://docs.python.org/3/library/pdb.html pdb — The Python Debugger].
Komfortabler lässt sich das aber mittels Integrierter Entwicklungsumgebungen (IDEs) angehen.

== Debuggen mit IDEs ==
Für die IDEs IDLE und Spyder sei kurz auf die entsprechenden Webseiten verwiesen:

* [https://www.cs.uky.edu/~keen/help/debug-tutorial/debug.html Debugging under IDLE].
* [https://docs.spyder-ide.org/current/panes/debugging.html Spyder Debugger]

Dort wird die Vorgehensweise auch mittels Screenshots erläutert.

== assert ==
assert ... behaupten, zusichern ({{W|Assertion (Informatik)}})

Python-Code:
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10., 0.)

Ausgabe:

 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10., 0.)
   File &quot;/home/hr/Develop/test1.py&quot;, line 4, in print1
     assert y != 0.0
            ^^^^^^^^
 AssertionError
 
Python-Code: 
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)
 
Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(&quot;10.&quot;, &quot;5.&quot;)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError
 
Aber auch bei nachfolgendem Code gibt es eine Fehlermeldung:

 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10, 5)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError

Damit letzteres funktioniert, kann man den Programmcode so umschreiben:
 def print1(x, y):
     assert type(x) == float or type(x) == int
     assert type(y) == float or type(y) == int
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 2.0
 
Und jetzt fangen wir den &lt;code&gt;AssertionError&lt;/code&gt; auf:
 def print1(x, y):
     try:
         assert type(x) == float or type(x) == int
         assert type(y) == float or type(y) == int
         assert y != 0.0
         print(x/y)
     except(AssertionError):
         print(&quot;Hallo&quot;)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)

Ausgabe:
 2.0
 Hallo

Ich hoffe, es ist wenigstens im Ansatz klar geworden, wofür &lt;code&gt;assert&lt;/code&gt; gut sein kann. Ausschalten kann man die &lt;code&gt;assert&lt;/code&gt;-Überprüfung übrigens mit dem Python-Schalter &lt;code&gt;-O&lt;/code&gt;.

== Doctests == 
Innerhalb eines Docstrings kann die Arbeit im interaktiven Modus simuliert werden. Nach den Promptzeichen (&gt;&gt;&gt;) erfolgen dann bei unserem Beispiel innerhalb des Docstrings simulierte Aufrufe der Funktion &lt;code&gt;print1()&lt;/code&gt;. Danach folgen jeweils die Sollresultate. Wird das Modul oder die Datei als Hauptprogramm aufgerufen, so wird die Funktion &lt;code&gt;doctest.testmode()&lt;/code&gt; aufgerufen und ein Bericht auf der Konsole ausgegeben. Wird das Modul nicht als Hauptprogramm aufgerufen, sondern importiert, dann wird diese &lt;code&gt;testmod&lt;/code&gt;-Funktion nicht aufgerufen. D.h. dieser Code kann sowohl für Testzwecke als auch für den produktiven Einsatz verwendet werden. Das ist auch sinnvoll, weil wenn man Teile der Datei immer löschen bzw. einfügen müsste, so würden sich Fehlerquellen auftun. Das würde den Sinn und Zweck von Doctests konterkarieren.  

 def print1(x=0., y=1.):
     &quot;&quot;&quot; Dividiere zwei Zahlen
     Autor: Intruder
     Datum: 12.08.2025
 
     &gt;&gt;&gt; print1(2., 1.)
     2.0
     &gt;&gt;&gt; print1(5., 2.)
     2.5
     &gt;&gt;&gt; print1(5.)
     5.0
     &quot;&quot;&quot;
     print(x/y)
 
 if __name__ == &quot;__main__&quot;:
     import doctest
     doctest.testmod(verbose=True)

Ausgabe:
 Trying:
     print1(2., 1.)
 Expecting:
     2.0
 ok
 Trying:
     print1(5., 2)
 Expecting:
     2.5
 ok
 Trying:
     print1(5.)
 Expecting:
     5.0
 ok
 1 items had no tests:
     __main__
 1 items passed all tests:
    3 tests in __main__.print1
 3 tests in 2 items.
 3 passed and 0 failed.
 Test passed.

Das gezeigte Beispiel ist so ziemlich das einfachste, das es gibt. Für weiterführende Details siehe z.B.:
* [https://peps.python.org/pep-0257/ PEP 257 – Docstring Conventions]
* [https://docs.python.org/3/library/doctest.html doctest — Test interactive Python examples]

''Einschub:'' Ganz ähnlich kann man auch Klassen testen, z.B. in folgendem Code-Fragment

 class Fahrzeug:
   # siehe Abschnitt &quot;Objektorientierte Programmierung&quot;
   # ...
 
 if __name__ == &quot;__main__&quot;:
   vauweh = Fahrzeug(170, 90)
   beemweh = Fahrzeug(200, 120)
   print(vauweh.convertGeschw())
   print(beemweh.convertGeschw())

Wird das Script als Hauptprogramm ausgeführt (z.B. zu Testzwecken), so erfolgt die Ausgabe der zwei, via &lt;code&gt;convertGeschw()&lt;/code&gt;, umgerechneten Geschwindigkeiten. Wird es aber als Modul eingebunden, so wird der letzte Programmabschnitt nicht ausgeführt (&lt;code&gt;__name__ == &quot;__main__&quot;&lt;/code&gt; ergibt &lt;code&gt;False&lt;/code&gt;).

== pytest ==
Siehe zu diesem Thema auch {{W|Modultest}}.

pytest ist ein externes Modul und muss vorab installiert werden, z.B. mittels 
 pip install -U pytest
 pip install -U pytest-html 

Python-Code, Datei test1.py:
 def add(x, y):
     return x + y
 
 def test_answer():
     assert add(1, 1) == 3

Starten von pytest in der Konsole:
 pytest test1.py
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py F                                                                                                            [100%]
 
 ========================================================= FAILURES ==========================================================
 ________________________________________________________ test_answer ________________________________________________________
 
     def test_answer():
 &gt;       assert add(1, 1) == 3
 E       assert 2 == 3
 E        +  where 2 = add(1, 1)
 
 test1.py:6: AssertionError
 ================================================== short test summary info ==================================================
 FAILED test1.py::test_answer - assert 2 == 3
 ===================================================== 1 failed in 0.09s =====================================================

Hier erhalten wir einen Fehler, da 1+1 eindeutig ungleich 3 ist. Aber aus irgendeinem Grund wollte der Programmierer oder Tester in diesem Fall, dass dies so ist. Testfälle werden übrigens mit dem Präfix &lt;code&gt;test_&lt;/code&gt; eingeleitet.

Python-Code:
 def add(x, y):
     return x + y + 1
 
 def test_answer():
     assert add(1, 1) == 3 
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py .                                                                                                            [100%]
 
 ===================================================== 1 passed in 0.01s =====================================================

Jetzt ist alles in Ordnung. Weiterführendes siehe z.B.

* [https://docs.pytest.org/en/stable/ pytest: helps you write better programs]

== unittest ==
Auch unittest dient zur Durchführung von Testreihen, ist aber Bestandteil von Python. Hier wird vorerst nicht näher darauf eingegangen. Siehe z.B. 
* [https://docs.python.org/3/library/unittest.html unittest — Unit testing framework]

Lt. ''Inden: Python Challenge; dpunkt, 2021, Seite 481''  soll unittest weniger komfortabel als pytest sein.

Einen Vergleich von unittest mit pytest findet man in
* [https://knapsackpro.com/testing_frameworks/difference_between/pytest/vs/unittest pytest vs unittest]

= Python und Anwendungsprogramme =
Bisher stand immer alleine die Programmiersprache Python (ev. unter Einbeziehung von Modulen) im Mittelpunkt der Betrachtungen. Aber Python kann auch als Makrosprache für Anwendungsprogramme auftreten. Als Beispiele seien {{W|FreeCAD}} und {{W|LibreOffice}} genannt.

== FreeCAD ==
FreeCAD ist ein freies 3D-CAD-Programm. Hier soll nicht auf die Bedienung dieses CAD-Pakets eingegangen werden, sondern nur auf die Möglichkeit, mittels Python Makros zu schreiben. Als einfacher Einstieg soll ein Makro erstellt werden, welches eine Kugel (rot) und einen Quader (blau) zeichnet. Folgende Vorbereitungsschritte sind erforderlich (es sei vorausgesetzt, dass FreeCAD schon am Rechner installiert ist. Downloaden können Sie das Programm von der Website [https://www.freecad.org/downloads.php?lang=en]):

* FreeCAD starten
* Leere Datei erstellen
* Makro &gt; Makros &gt; Erstellen ...

Es öffnet sich ein leeres Editorfenster, in das Sie folgenden Code eingeben können:

 import FreeCAD
 import Part
 
 doc = FreeCAD.newDocument()
 
 # Kugel
 kugel = Part.makeSphere(10)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Kugel&quot;)
 form_element.Shape = kugel
 kug = FreeCAD.ActiveDocument.getObject(&quot;Kugel&quot;)
 kug.ViewObject.ShapeColor = (1.0, 0.0, 0.0)
 neuePosition = App.Vector(5, 2.5, 2.5)
 kug.Placement = App.Placement(neuePosition, kug.Placement.Rotation)
 
 # Quader
 quader = Part.makeBox(5, 5, 50)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Quader&quot;)
 form_element.Shape = quader
 quad = FreeCAD.ActiveDocument.getObject(&quot;Quader&quot;)
 quad.ViewObject.ShapeColor = (0.0, 0.0, 1.0)
 
 doc.recompute()

Diesen Code können Sie nun ausführen:
* Makro &gt; Makro ausführen

Es ergibt sich folgende Ausgabe (gedreht und gezoomt):

[[Datei: PythonIng_freecad1.png|500px]]

Siehe auch [https://wiki.freecad.org/Python_scripting_tutorial/de# Anleitung Skripterstellung mit Python]. Getestet wurde obiges Beispiel mit FreeCAD 1.1.3 unter Linux und 1.1.1 unter MS Windows.

== LibreOffice ==
LibreOffice ist ein freies Officepaket ([https://de.libreoffice.org/]). Hier soll nur das Tabellenkalkulationsprogramm Calc kurz betrachtet werden. Es seinen in den ersten 3 Zellen (A1 bis A3) Zahlen gegeben. Diese sollen mit einem Python-Makro addiert und das Resultat in der Zelle A5 ausgegeben werden. Auch hier sind Vorbereitungsarbeiten nötig: 
* zuerst muss unter Linux das Verzeichnis &lt;code&gt;~/.config/libreoffice/4/user/Scripts/python&lt;/code&gt; erstellt werden
* für MS Windows ist es das Verzeichnis &lt;code&gt;%APPDATA%\LibreOffice\4\user\Scripts\python&lt;/code&gt; 
** drücken Sie zuerst Win + R (es öffnet sich das Ausführen-Fenster)
** geben Sie &lt;code&gt;%appdata%&lt;/code&gt; ein, danach drücken Sie Enter (es öffnet sich der Explorer)
** navigieren Sie zu dem genannten Verzeichnis bzw. erstellen Sie das Verzeichnis 
* in diesem Verzeichnis wird dann mit einem beliebigen Texteditor das Python-Makro erstellt, in unserem Fall die Datei &lt;code&gt;summiere_zellen.py&lt;/code&gt;:

 import uno
 
 def summiere_zellen(*args):
     # Zugriff auf das aktuelle Dokument und das aktive Tabellenblatt
     ctx = uno.getComponentContext()
     smgr = ctx.getServiceManager()
     desktop = smgr.createInstanceWithContext(&quot;com.sun.star.frame.Desktop&quot;, ctx)
     doc = desktop.getCurrentComponent()
     sheet = doc.getCurrentController().getActiveSheet()
 
     # Werte aus den Zellen A1 bis A3 auslesen
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
 
     # Addition der drei Werte
     summe = w1 + w2 + w3
 
     # Ergebnis in die Zelle A5 schreiben
     sheet.getCellRangeByName(&quot;A5&quot;).Value = summe

* siehe dazu ggf. auch [https://help.libreoffice.org/latest/de/text/sbasic/python/python_locations.html?DbPAR=BASIC].

Weiter geht es in LibreOffice Calc mit dem Menü ''Extras &gt; Makros &gt; Makros verwalten &gt; Python''. Dort wird das Makro &lt;code&gt;summiere_zellen&lt;/code&gt; ausgeführt. Es ergibt sich z.B. folgendes Resultat

[[Datei:PythonIng_libreoffice1.png]]

Das Kürzel &lt;code&gt;uno&lt;/code&gt; steht für '''U'''niversal '''N'''etwork '''O'''bjects. Etwas einfacher geht's auch so:

 def summiere_zellen():
     desktop = XSCRIPTCONTEXT.getDesktop()
     model = desktop.getCurrentComponent()
     sheets = model.getSheets()
     sheet = sheets.getByIndex(0)
     
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
     
     cell = sheet.getCellRangeByName(&quot;A5&quot;)    
     cell.setValue(w1 + w2 + w3) 

Empfohlen wird auch, das Erweiterungspaket APSO ('''A'''lternative '''P'''ython '''S'''cript '''O'''rganizer, apso.oxt) zu installieren. Die Vorgehensweise wird hier nicht gezeigt, sondern nur darauf hingewiesen, dass man das einfach &quot;googeln&quot; kann. Siehe zur Python-Programmierung für LibreOffice auch [https://wiki.documentfoundation.org/Macros/Python_Guide/de Makros/Python-Handbuch]. Getestet wurden obige Beispiele mit LibreOffice 26.2.5.1 unter Linux und 26.2.1.2 unter MS Windows.

= Ausblick =
Dies war eine kurze Einführung in die Berechnungs- und Darstellungsmöglichkeiten mit Python. Es sollten etliche relevante Themen behandelt, oder zumindest kurz angesprochen worden sein. Wem dieser Text nicht ausreichend ist, der sei auf die entsprechenden weiterführenden Weblinks, Bücher und die Python-Hilfefunktion verwiesen. Python kennt noch viel mehr Befehle, als hier dargestellt wurden. Das Themenspektrum ist auch durch die Einbindung externer Module fast beliebig erweiterbar.

= Weblinks=
== Python allgemein ==
* [https://www.python.org/ Python Homepage]

== Externe mathematische Module ==
* [https://numpy.org/ NumPy]
* [https://numpy.org/doc/stable/user/numpy-for-matlab-users.html NumPy for MATLAB users]
* [https://scipy.org/ SciPy]
* [https://www.sympy.org/en/index.html SymPy]
* [https://pandas.pydata.org/ pandas]
* [https://github.com/maroba/findiff findiff]
* [https://mpmath.org/ mpmath]

== Externe Module für Grafiken ==
* [https://matplotlib.org/ Matplotlib]
* [https://vpython.org/ VPython]
* [https://build123d.readthedocs.io/en/latest/ build123d]
* [https://docs.vtk.org/en/latest/api/python.html VTK]
* [https://docs.bokeh.org/en/latest/docs/first_steps.html bokeh]
* [https://py5coding.org/ py5]

== Erstellung von User Interfaces ==
* [https://docs.python.org/3/library/tkinter.html tkinter - Python interface to Tcl/Tk]
* [https://docs.python.org/3/library/curses.html curses - Terminal handling for character-cell displays]
* [https://wiki.qt.io/Qt_for_Python Qt for Python]
* [https://www.gtk.org/docs/language-bindings/python GTK and Python]

== Erstellen virtueller Umgebungen ==
* [https://docs.python.org/3/library/venv.html venv - Creation of virtual environments]

== Sonstige ==
* [https://python-control.readthedocs.io/en/stable/ Python Control Systems Library]
* [https://pypi.org/project/regex/ regex - Regular Expressions]
* [http://pyromat.org/ PYroMat]
* [https://coolprop.org/coolprop/wrappers/Python/index.html CoolProp]
* [https://pypi.org/project/iapws/ iapws]
* [https://tespy.readthedocs.io/en/main/getting_started/introduction.html TESPy - Thermal Engineering Systems in Python]
* [https://pint.readthedocs.io/en/stable/ pint]

= Bücher =
== Gedruckte Bücher, OpenBooks, Magazine ==
* Diverse: c't Python Lernen, Verstehen, Anwenden; Heise, 2022 
* Ernesti, Kaiser: Python3 - das umfassende Handbuch; 5. Aufl., Rheinwerk, [https://openbook.rheinwerk-verlag.de/python/ OpenBook]
* Iacono et al.: Programmieren trainieren; 3. Aufl., Hanser, 2023, ISBN 978-3-446-47766-7
* Inden: Python Challenge; dpunkt, 2021, ISBN 978-3-86490-809-5
* Klein: Numerisches Python; 2. Aufl., Hanser, 2023, ISBN 978-3-446-47170-2 
* Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler; Rheinwerk, 2021, ISBN 978-3-8362-7316-9
* Weigend: Python 3 - Das umfassende Praxisbuch; 9. Aufl., mitp, 2022, ISBN 978-3-7475-0544-1
* Woyand: Python für Ingenieure und Naturwissenschaftler; 4. Aufl., Hanser, 2021, ISBN 978-3-446-46483-4

== Andere Wikibooks ==
* [[:en:Subject:Python_programming_language | Englische Wikibooks zum Thema Python]]
* [[Python|Deutschsprachiges Python-Wikibook]] [[Bild:2von10.png|20%]]
* [[Python unter Linux|Python 2.7 unter Linux]] [[Bild:10von10.png|100%]]


{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}</text>
      <sha1>stwtgi1hrjag0b2ejnby5hevpchxnk1</sha1>
    </revision>
    <revision>
      <id>1092168</id>
      <parentid>1092167</parentid>
      <timestamp>2026-10-16T13:43:28Z</timestamp>
      <contributor>
        <username>Intruder</username>
        <id>1513</id>
      </contributor>
      <minor />
      <comment>/* while */</comment>
      <origin>1092168</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="189259" sha1="nf0n158ub0yv34euqlzq5od3p3rendi" xml:space="preserve">{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}


= Hallo Welt und allgemeine Hinweise =
== Was ist Python ==
* Python ist eine universelle höhere Programmiersprache.
* Python ist objektorientiert.
* Python ist Open-Source (Python Software Foundation License).
* Python ist für viele Betriebssysteme erhältlich (z.B. für Linux, MS Windows, macOS).
* Python ist ein Interpreter.
* Python ist durch Module fast beliebig erweiterbar.
* Python als Programmiersprache ist case-sensitive - d.h. Groß- und Kleinschreibung ist relevant bei der Eingabe von Befehlen.
* Python ist in etlichen Anwendungsprogrammen (z.B. {{W|FreeCAD}}, {{W|LibreOffice}}, {{W|GIMP}}, {{W|Blender (Software) | Blender}}) als Makrosprache verwendbar.

{{Wikipedia | Python (Programmiersprache)}}

== Python installieren ==
=== MS Windows ===
Laden Sie das aktuelle Python-Paket von der Webseite [https://www.python.org/] herunter. Weiter geht es wie bei jedem anderen größeren zu installierenden Programm. Einfach das Installationsprogramm im Explorer doppelklicken und den Anweisungen des Setup-Programmes folgen.

=== Linux ===
Entweder ist Python bereits standardmäßig installiert, ansonsten ist die Installation mittels Paketmanagementsystem einfach möglich. Aber auch die Spyder-Entwicklungsumgebung ([https://www.spyder-ide.org]) bietet einen guten Einstieg mit Python (das gilt auch für MS Windows). Spyder bringt auch schon etliche wichtige Module standardmäßig mit.

== Python starten ==
=== MS Windows ===
Das Icon für das Python-Programm doppelklicken. Und schon startet das Programm.

[[Datei:PythonIng_start1.jpg]]

Python im interaktiven Modus präsentiert sich dann so:

 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

Alternativ kann das Programm auch über die Eingabeaufforderung oder die PowerShell gestartet werden:

 c:\devel\Python&gt;python.exe
 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

=== Linux ===
Tippen Sie einfach das Wort „python“ (oder unter openSUSE Tumbleweed z.B. auch „python3.11“ oder „python3.13“) in einem Linux-Terminal ein, schließen den Befehl mit der RETURN-Taste ab, und schon startet Python im interaktiven Modus:
 
 Python 3.13.12 (main, Feb 09 2026, 22:37:44) [GCC] on linux
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt; 

Es gibt auch noch andere Möglichkeiten Python zwecks Programmausführung zu starten, z.&amp;nbsp;B. den {{W|Shebang}} (&lt;code&gt;#!&lt;/code&gt;) am Beginn eines Python-Scripts. Das Script sei als Script.py gespeichert. Dann kann das Script mit ./Script.py ausgeführt werden. Für openSUSE Tumbleweed sei nachfolgend ein lauffähiges &quot;Hallo Welt!&quot;-Script angegeben. Es wird in diesem Script der Python-Interpreter in der Version 3.13 verwendet :

 #!/usr/bin/python3.13
 print(&quot;Hallo Welt!&quot;)

Die Berechtigungen zum Ausführen der Datei müssen natürlich noch richtig gesetzt werden, z.B. mittels &lt;code&gt;chmod 777 Script.py&lt;/code&gt;. &lt;small&gt;&lt;code&gt;chmod&lt;/code&gt; ist die Abkürzung für&quot;'''ch'''ange file '''mod'''e bits&quot;.&lt;/small&gt; 

&lt;small&gt;Die &quot;Maske&quot; &lt;code&gt;777&lt;/code&gt; ist nur für Testzwecke sinnvoll, weil sie leicht zu merken ist und für alle Benutzer alle Zugriffsberechtigungen ('''r'''ead/'''w'''rite/e'''x'''ecute für owner/group/others) setzt. Im richtigen Einsatz wird man das aus Sicherheitsgründen nicht so handhaben, sondern nur die Berechtigungen setzen, die unbedingt erforderlich sind. Welche Zugriffsberechtigungen gesetzt sind, kann man z.B. mit dem Befehl &lt;code&gt;ls -l&lt;/code&gt; oder &lt;code&gt;ll&lt;/code&gt; ('''l'''i'''s'''t directory contents) erfragen. Aber dazu im Moment genug. Erfahrene Linux-Nutzer kennen das ohnehin und Anfänger sollen jetzt nicht mit Linux-Interna überfordert werden. Bei Bedarf siehe die Linux-Man-Pages oder dezidierte Bücher zu Linux.&lt;/code&gt;&lt;/small&gt;

&lt;small&gt;Oder das Script wird in einen Pfad verschoben, in dem sich ausführbare Programme generell befinden (welche Verzeichnisse im PATH liegen, kann bspw. mit &lt;code&gt;echo $PATH&lt;/code&gt; abgefragt werden). Das Script kann dann wie ein normales Programm ohne weitere Angaben mit Script.py gestartet werden. Alternativ wird nicht das Script an sich verschoben, sondern nur ein symbolischer Link angelegt, z.B. mit &lt;code&gt;ln -s ~/tmp/Script.py ~/.local/bin/Script.py&lt;/code&gt;. &lt;code&gt;~/.local/bin&lt;/code&gt; sei ein im PATH gelegenes Verzeichnis. Dies sind aber schon Features für fortgeschrittene Linux-Benutzer und werden am Anfang eher selten benötigt.&lt;/small&gt;

== Ein paar Worte zur Erklärung ==
=== Tests ===
Getestet wurden die Beispiele unter den Betriebssystemen 
* MS Windows 10 mit der Python-Version 3.12.0 (teilweise auch mit 3.12.2 und 3.13.1; nur die Inhalte die bis spätestens Juli 2025 erstellt wurden) 
* MS Windows 11 ab der Python-Version 3.13.4 (nur zum Teil; ab Juli 2025)
* openSUSE Leap 15.6 mit der Python-Version 3.11.12 (Spyder, nur vereinzelt) und zum Teil mit 3.12.11 (ab Juli 2025 bis November 2025).
* openSUSE Tumbleweed ab der Python-Version 3.13.9 (nur vereinzelt, ab November 2025)

=== Popularität ===
* An Beliebtheit rangiert Python mit Stand September 2026 mit einem Rating von 17,76% an 1. Stelle vor C und C++ (lt. [https://www.tiobe.com/tiobe-index/ TPCI - TIOBE Programming Community Index]). 
* Lt. [https://innovationgraph.github.com/global-metrics/programming-languages GitHub Top 50 Programming Languages Globally] lag Python im Q1/2026 auf Rang 2, vor TypeScript und hinter JavaScript. 
* [https://pypl.github.io/PYPL.html PYPL] (Popularity of Programming Language Index) ist ein anderer Popularitätsindex für Programmiersprachen. Auch hier liegt Python mit großem Vorsprung auf dem ersten Platz (52,08%), gefolgt von Java (13,34%) und C/C++ (7,99%) (Stand September 2026). 

=== Namensgebung ===
Der Name &quot;Python&quot; rührt von der Komikertruppe {{W|Monty Python}} her. Die Icons für Python (z.B. Python selbst, Eric IDE, IDLE) sind aber durch die Python-Schlangenart symbolisiert.

&lt;gallery&gt;
Python-logo-notext.svg|Python-Logo
Guido van Rossum in PyConUS24.jpg|{{W|Guido van Rossum}} (geb. 1956), der Erfinder von Python
&lt;/gallery&gt;

== Ein erstes Programm ==
Kommentare werden in Python mit der Raute (#) eingeleitet. Sie werden vom Python-Interpreter ignoriert. Text kann mit der print-Funktion ausgegeben werden. Starten Sie Python und geben sie folgende Anweisungen zeilenweise ein

 &gt;&gt;&gt; # Das ist ein Kommentar
 &gt;&gt;&gt; print(&quot;Hallo Welt!&quot;)

Als Ergebnis erhalten Sie

 Hallo Welt!

Der Prompt (&gt;&gt;&gt;) ist selbstverständlich nicht einzutippen, sondern wird vom Python-System geliefert.

Strings können in Python entweder in Anführungszeichen (&quot;) gesetzt werden oder in Hochkommatas('). In diesem Text wird die erste Variante bevorzugt eingesetzt.

Im Gegensatz zu Julia ist es hier egal, ob zwischen &lt;code&gt;print&lt;/code&gt; und der öffnenden Klammer Leerzeichen stehen.

= Python als Taschenrechner =
== Allgemeines ==
Wir wollen 3 * 5 berechnen. Dazu starten wir Python im interaktiven Modus. Geben Sie dann die Formel  

 &gt;&gt;&gt; 3 * 5

ein, drücken die Taste ENTER/RETURN ({{Taste|↵}}) und erhalten als Ergebnis

 15

Auch kompliziertere Ausdrücke sind möglich. Beispielsweise mit Winkelfunktionen, Quadratwurzeln etc. Wir wollen nun den Ausdruck &lt;math&gt;\sin\sqrt{15}&lt;/math&gt; berechnen :

 &gt;&gt;&gt; import math
 &gt;&gt;&gt; math.sin(math.sqrt(15))
 -0.6679052983383519

Als erstes wird das math-Modul importiert. Dann wird der mathematische Ausdruck berechnet.

Eine andere Variante, die dasselbe Ergebnis liefert, ist

 &gt;&gt;&gt; from math import *
 &gt;&gt;&gt; sin(sqrt(15))
 -0.6679052983383519

Es wird also aus dem Modul &lt;code&gt;math&lt;/code&gt; alles importiert (erkennbar am &lt;code&gt;*&lt;/code&gt;). Will man nicht alles importieren, so kann man das auch einschränken:

 &gt;&gt;&gt; from math import sin, sqrt

Beenden lässt sich das Python-Programm durch Eingabe von &lt;code&gt;exit()&lt;/code&gt; (und natürlich ist zur Bestätigung die RETURN-Taste zu drücken). &lt;code&gt;exit&lt;/code&gt; (ohne Klammern) oder &lt;code&gt;quit&lt;/code&gt; werden auch akzeptiert.

== Die Hilfefunktion von Python ==
Bei Eingabe der Anweisung &lt;code&gt;help&lt;/code&gt; oder &lt;code&gt;help()&lt;/code&gt; springt Python in den Hilfemodus. 

Eingabe:
 &gt;&gt;&gt; help()
 
Eingabe:
 help&gt; math.sin

Ausgabe:
 Help on built-in function sin in math:
 
 math.sin = sin(x, /)
     Return the sine of x (measured in radians).

Für die komplette Python-Dokumentation siehe [https://docs.python.org/3/]. Verlassen kann man den Hilfemodus durch das Drücken von STRG-C, bzw. der Eingabe von q, quit oder exit mit anschließendem Drücken der RETURN-Taste.

== Aufgaben ==
* Erkunden Sie die Tangensfunktion &quot;tan&quot; mittels Python-Hilfe (vergessen Sie nicht das math-Modul zu importieren und das &lt;code&gt;math.&lt;/code&gt; vor &lt;code&gt;tan&lt;/code&gt;)
* Berechnen Sie mit Python den Ausdruck &lt;math&gt;\frac{1}{2}\cdot \text{e}^2 \cdot \tan(\pi/3)&lt;/math&gt;. Siehe für die Exponentialfunktion im Python-Hilfesystem auch den Befehl &lt;code&gt;math.exp&lt;/code&gt;. Alternativ kann auch die Konstante &lt;code&gt;math.e&lt;/code&gt; eingesetzt werden. Potenzieren kann man bei Python mit dem **-Operator (z.B. 2**3 = 8). Für &lt;math&gt;\pi&lt;/math&gt; gibt es &lt;code&gt;math.pi&lt;/code&gt;.

= Python als Scriptsprache =
Häufig wird man aber kompliziertere Anweisungsfolgen verarbeiten müssen. Diese will man normalerweise nicht jedesmal neu eingeben, sondern in einer Datei speichern und diese Datei dann zur Ausführung bringen. Speichern Sie dazu folgenden Code in einer Textdatei, z.B. unter MS Windows als c:\tmp\test1.py

 # Das ist ein Kommentar
 print(&quot;Hallo Welt!&quot;)

Python-Dateien werden mit der Dateiendung .py versehen. Achten Sie darauf, dass vor dem print keine Leerzeichen vorhanden sind. Das ist eine Python-Eigenheit. Wie wir später sehen werden, nutzt Python Einrückungen als syntaktisches Mittel, z.B. um bei Schleifen den Schleifenkörper zu kennzeichnen. 

Danach bringen Sie die Skriptdatei test1.py (sozusagen das Hauptprogramm) folgendermaßen zur Ausführung:

1) Starten Sie unter MS Windows die Eingabeaufforderung (oder alternativ auch die Windows PowerShell). Das sieht dann etwa so aus:

 Microsoft Windows [Version 10.0.19045.3693]
 (c) Microsoft Corporation. Alle Rechte vorbehalten.
 
 C:\Users\xyz&gt;

: &lt;small&gt;Falls jemand nicht weiß, wie man die Eingabeaufforderung startet: Eine Möglichkeit ist, einfach in der Taskleiste von Windows das &quot;Start&quot;-Symbol &amp;nbsp;([[Image:Windows_logo_-_2021_(Black).svg|10px]])&amp;nbsp; mit der rechten Maustaste anklicken. &quot;Ausführen&quot; auswählen (oder alternativ für die PowerShell unter Windows 10 den Eintrag &quot;Windows PowerShell&quot;, unter Windows 11 den Eintrag &quot;Terminal&quot;). Im sich öffnenden Dialogfenster gibt man in die &quot;Öffnen&quot;-Zeile das Wort &lt;code&gt;cmd&lt;/code&gt; ein und mit &quot;OK&quot; wird das Ganze bestätigt.&lt;/small&gt; 
 
2) Wechseln Sie mittels &lt;code&gt;cd c:\tmp&lt;/code&gt; in das Verzeichnis c:\tmp

3) Angenommen, Sie haben Python unter dem Pfad &lt;code&gt;c:\devel\Python\&lt;/code&gt; installiert. Starten Sie das Programm so (der Prompt &lt;code&gt;c:\tmp&gt;&lt;/code&gt;ist natürlich nicht mit einzutippen): 

 c:\tmp&gt;c:\devel\Python\python.exe test1.py

4) Wie erwartet ergibt sich folgende Ausgabe am Bildschirm

 Hallo Welt!

Die Vorgehensweise unter Linux ist prinzipiell gleich. Die kleinen Unterschiede, wie z.B. der Slash statt dem Backslash in Pfadangaben, sollten für Linux-Benutzer keine Hürde darstellen.

== Variablen ==
Variablenbezeichner können aus Buchstaben (A-Za-z), Ziffern (0-9) und Underscores (_) bestehen, dürfen aber nicht mit einer Zahl beginnen. Führende Underscores haben u.a. im Kontext mit der Objektorientierten Programmierung eine spezielle Bedeutung und sollten nicht für &quot;normale&quot; Variablenbezeichner verwendet werden.

Gültige Variablenbezeichner wären also:
 xyz
 x1
 _wert
 name_anzahl

Theoretisch kann man auch Umlaute, griechische Buchstaben u.ä. in Variablenbezeichnern nutzen, z.B.

 ößÜ = 16
 α = 134 
 print(ößÜ)
 print(α)

Ausgabe:
 16
 134

Davon wird aber aus offensichtlichen Gründen ({{W|Englisch als Lingua franca}}) abgeraten. Das Eurozeichen (€) etc. darf man ohnehin nicht in Variablenbezeichnern verwenden, dies ergäbe einen Syntaxfehler. Siehe dazu auch [https://peps.python.org/pep-3131/].

Es gibt in Python etliche Schlüsselwörter (z.B. for, if oder return). Diese dürfen nicht als eigene Variablenbezeichner verwendet werden. Eine Liste aller Schlüsselwörter liefert das Script

 import keyword
 print(keyword.kwlist)

&lt;small&gt;Übung: Speichern Sie dieses Script in eine Datei, z.B. in c:\tmp\test1.py. Führen Sie diese Datei aus, um die Liste der Schlüsselwörter auszugeben.&lt;/small&gt;

Da Python case-sensitiv ist, repräsentieren folgende Bezeichner verschiedene Variablen:
 xyz
 XYZ
 xYz

Werte werden an Variablen mittels Gleich-Zeichen (=) zugewiesen. Im Folgenden wird der Code immer in der Datei c:\tmp\test1.py gespeichert.

 x = 5
 y = 10
 z = x*y
 print(z)

Bringen Sie die Datei test1.py zur Ausführung, so erhalten Sie folgende Bildschirmausgabe

 50

Sie können auch mehrere Anweisungen in einer Zeile durch Semikolon getrennt schreiben. Dies führt aber zu unübersichtlichem Code.

 x = 5; y = 10; z = x*y; print(z)

Ausgabe:
 50

Auch aus der Programmiersprache C/C++ oder Java bekannte Konstrukte können Sie verwenden, z.B.
 x = 5
 # x = x - 2
 x -= 2
 print(x)

Bildschirmausgabe:

 3
 
Beachten Sie, dass mit dem =-Zeichen eine Wertezuweisung durchgeführt wird. Dies ist nicht äquivalent zum mathematischen =-Zeichen, wie am vorigen Beispiel zu ersehen ist. Den Inkrement-/Dekrementoperator (z.B. x++ oder x--) aus C/C++ oder Java kennt Python aber nicht.

Variablen sind nicht an einen bestimmten Datentyp gebunden, folgendes ist mit Python problemlos möglich:

 import math
 wert = 10
 print(wert)
 wert = 35.5
 print(wert)
 wert = &quot;Hallo&quot;
 print(wert)
 wert = math.pi
 print(wert)

Ausgabe:
 10
 35.5
 Hallo
 3.141592653589793

== Physische und logische Zeilen ==
In Python muss eine Anweisung in einer logischen Zeile Platz finden. Wird eine Anweisung aber zu lang für eine Zeile, dann kann sie in mehrere physische Zeilen unterteilt werden. Dies kann einerseits durch einen Backslash am Ende einer Zeile geschehen, z.B.

 a = 2 + \
 5
 
Dies stellt eine logische Zeile dar, die in zwei physische Zeilen unterbrochen ist.

Geklammerte Ausdrücke werden automatisch zu einer logischen Zeile verbunden, z.B.

 a = (2 + 
 5)
 
Achtung: Im ersten Beispiel darf nach dem Backslash nichts mehr stehen, auch kein Kommentar. Dies trifft im zweiten Bespiel nicht zu, hier könnte noch ein Kommentar folgen, z.B.

 a = (2 +    # Kommentar 
 5)

Auch für Strings gibt es Möglichkeiten, diese auf mehrere Zeilen aufzuspalten.

 # Kurzer String
 str1 = &quot;ABC&quot;
 
 # Langer String
 str2 = &quot;&quot;&quot;Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle&quot;&quot;&quot;
 
 # Backslash
 str3 = &quot;UVW\
 XYZ&quot;
 
 # Mit Klammern
 str4 = (&quot;Sehr langer Text, der automatisch .............. &quot;
         &quot;in einer einzigen Variable zusammengefügt wird.&quot;
 )
 
 print(str1)
 print(str2)
 print(str3)
 print(str4)

Ausgabe:

 ABC
 Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle
 UVWXYZ
 Sehr langer Text, der automatisch .............. in einer einzigen Variable zusammengefügt wird.

==Hexadezimale, oktale, binäre und andere Zahlen==
 d = 1050         # Dezimalzahl
 h = 0xAA2        # Hexadezimalzahl
 o = 0o12         # Oktalzahl
 b = 0b100001101  # Binärzahl
 
 print(d)
 print(h)
 print(o)
 print(b)

Ausgabe:
 1050
 2722
 10
 269

Groß- und Kleinbuchstaben sind in obigen Literalen übrigens egal. So kann man z.B. statt &lt;code&gt;0b1001&lt;/code&gt; auch &lt;code&gt;0B1001&lt;/code&gt; schreiben (siehe dazu [https://docs.python.org/3/reference/lexical_analysis.html#integer-literals]).

Sie können auch dezimale in hexadezimale Zahlen umwandeln, usw.:
 h = hex(1050)    # Dezimalzahl -&gt; Hexadezimalzahl
 b = bin(1050)    # Dezimalzahl -&gt; Binärzahl
 o = oct(1050)    # Dezimalzahl -&gt; Oktalzahl
 print(h)
 print(b)
 print(o)

Ausgabe:
 0x41a
 0b10000011010
 0o2032

Gegeben sei die Zahl 121 zur Basis 3. Diese soll in eine Dezimalzahl umgewandelt werden. Das kann so geschehen:

 z = int(&quot;121&quot;, 3)
 print(z)

Ausgabe:
 16

Dass dies richtig ist, davon kann man sich folgendermaßen überzeugen:
 &lt;math&gt; 1 \cdot 3^2 + 2 \cdot 3^1 + 1 \cdot 3^0 = 9 + 6+ 1 = 16 &lt;/math&gt;

Zahlen übersichtlicher schreiben kann man auch mittels Underscore, z.B.:

 print(&quot;Eine Million (Variante 1) =&quot;, 1000000)
 print(&quot;Eine Million (Variante 2) =&quot;, 1_000_000)
 print(&quot;Eine Rechnung:&quot;, 2_000 * 400_000);

Es ergibt sich bei beiden Varianten die gleiche Ausgabe. Variante 2 ist aber im Sourcecode leichter lesbar, detto die Zahlen in der Rechnung:

 Eine Million (Variante 1) = 1000000
 Eine Million (Variante 2) = 1000000
 Eine Rechnung: 800000000

== Strings und Platzhalter==
Ein paar einfache Beispiele:

 print(&quot;Hallo {}&quot; . format(&quot;Hugo&quot;))     # new style string formatting
 print(&quot;Hallo {:s}&quot; . format(&quot;Hugo&quot;))   # new style string formatting
 print(&quot;Hallo %s&quot; % &quot;Hugo&quot;)             # %-String

Ausgabe:

 Hallo Hugo
 Hallo Hugo
 Hallo Hugo

Python-Code (formatted string literals, Beispiel 1):
 str1 = &quot;Hallo&quot;
 str2 = &quot;Hugo&quot;
 print(f&quot;{str1} {str2}&quot;)

Ausgabe:
 Hallo Hugo

f-Strings (ab Python 3.6) sind die modernere Variante gegenüber %-Strings oder das ''new style string formatting''. Sie sind in der Regel auch schneller.

Python-Code (formatted string literals, Beispiel 2):
 wert = 11.567
 print(f&quot;Ausgabe: {wert:.5f}&quot;)

Ausgabe:
 Ausgabe: 11.56700

Komplexere Beispiele:

 print(&quot;Hallo {} und {}&quot; . format(&quot;Hugo&quot;, &quot;Mike&quot;))
 print(&quot;Hallo {name1} und {name2}&quot; . format(name2=&quot;Hugo&quot;, name1=&quot;Mike&quot;))
 # Füllzeichen: *
 # Bündigkeit: &gt; (=rechts), &lt; (=links), ^ (=zentriert)
 # Feldweite: 10
 # Typ: s (=String), f (=Gleitkommazahl), d (=Dezimalzahl) etc.
 print(&quot;Hallo {:*&gt;10s}&quot; . format(&quot;Hugo&quot;))
 print(&quot;Hallo {:*&lt;10s}&quot; . format(&quot;Hugo&quot;))

Ausgabe:

 Hallo Hugo und Mike
 Hallo Mike und Hugo
 Hallo ******Hugo
 Hallo Hugo******

Python-Code:
 str = &quot;Hallo\t%s\t%7.2f\t%10.2e\t%i&quot; % (&quot;Hugo&quot;, 12.34567, 34.567, 264)
 print(str)

Ausgabe:
 Hallo	Hugo	  12.35	  3.46e+01	264

== Unicode ==
Neben den bekannten ASCII-Zeichen lassen sich Zeichen auch mittels Unicode beschreiben. Griechische Buchstaben oder komplexere mathematische Operatoren - all das sollte kein Problem sein. Siehe auch {{W|Unicode}}, {{W|Liste der Unicodeblöcke}} und {{W|Unicodeblock Mathematische Operatoren}}. Im Folgenden werden ein paar Zeichen (Allquantor, Nabla-Operator, Existenzquantor), die man aus der Mathematik kennt, erzeugt. 
 
 ch1 = &quot;\N{FOR ALL}&quot;
 ch2 = &quot;\N{NABLA}&quot;
 ch3 = &quot;\u2203&quot;
 print(ch1, ch2, ch3)

Ausgabe:
 ∀ ∇ ∃

&lt;small&gt;Diese Ausgabe ergibt sich z.B. mit der IDLE-Shell oder mit Cygwin. Beim Ausführen über die Windows-Eingabeaufforderung oder Windows PowerShell unter MS Windows 10 erfolgt keine korrekte Darstellung. IDLE ist die mit Python mitgelieferte IDE ('''I'''ntegrated '''D'''evelopment '''E'''nvironment, Integrierte Entwicklungsumgebung). Gegen Ende dieses Textes wird IDLE kurz beschrieben.
Das Problem mit der Windows Eingabeaufforderung lässt sich aber umgehen. Man muss nur eine Schriftart auswählen, die die Zeichen kennt, z.B. &quot;DejaVu Sans Mono&quot;. Dazu klicken Sie einfach bei der Eingabeaufforderung mit der rechten Maustaste oben auf die weiße Leiste und wählen im aufpoppenden Fenster den Menüpunkt &quot;Eigenschaften&quot;. Es öffnet sich ein Dialogfenster. Über den Reiter &quot;Schriftart&quot; lässt sich nun die Schriftart einstellen. Unter MS Windows 11 oder openSUSE Leap 15.6 (bash-Konsole) gibt es dieses Problem ohnehin nicht.&lt;/small&gt;

== Reguläre Ausdrücke ==
Python kennt auch {{W|Regulärer Ausdruck|reguläre Ausdrücke}}. Dazu gibt es in Python das Modul &lt;code&gt;re&lt;/code&gt;. Beipielsweise sollen alle Zahlen (&lt;math&gt;\text{zahl}\in\mathbb{N}_0&lt;/math&gt;) in einem String gesucht und ausgegeben werden. Als String sei gegeben: &lt;code&gt;3x Grüße und 100 Kekse.&lt;/code&gt; Das Muster (Pattern) ist &lt;code&gt;\d+&lt;/code&gt;. &lt;code&gt;\d&lt;/code&gt; steht für eine Dezimalziffer 0-9. Das Plus-Zeichen (+) steht symbolisch für ein oder mehrere Zeichen des vorherigen Ausdrucks. Hier also ein oder mehrere Dezimalziffern. Es wird die Funktion &lt;code&gt;findall&lt;/code&gt; aus dem Modul &lt;code&gt;re&lt;/code&gt;verwendet.

Python-Code:
 from re import findall
 
 str = &quot;3x Grüße und 100 Kekse.&quot;
 pat = &quot;\\d+&quot;  # Doppel-Backslashes müssen verwendet werden, sonst gibt Python eine Warnung aus!
               # alternativ: pat = r&quot;\d+&quot; 
               # oder: pat = &quot;[0-9]+&quot;
 
 numb = findall(pat, str)
 print(numb)

Ausgabe:
 ['3', '100']

Python kennt noch viele weitere Möglichkeiten mittels regulärer Ausdrücke zu hantieren. Dies soll hier aber nicht vertieft werden, da das Thema schon ziemlich speziell und komplex ist. Bei Bedarf siehe aber z.B. die Bücher ''Weigend, Seite 380ff'' und ''Ernesti, Kaiser'' [https://openbook.rheinwerk-verlag.de/python/28_001.html] oder die Python-Dokumentation [https://docs.python.org/3/library/re.html]. Auch [[Python unter Linux: Reguläre Ausdrücke]] liefert ein umfangreiches und brauchbares Python-2-Kapitel zu den regulären Ausdrücken. Die dort gelisteten Beispiele müssten ggf. vor Verwendung auf Python-3 umgeschrieben werden. &lt;small&gt;Wie macht  man das? Dazu siehe z.B. [https://openbook.rheinwerk-verlag.de/python/43_001.html], [https://portingguide.readthedocs.io/en/latest/] oder [https://www.digitalocean.com/community/tutorials/how-to-port-python-2-code-to-python-3]&lt;/small&gt;

&lt;small&gt;Es gibt auch ein externes Modul ''regex'', das bei Bedarf extra installiert werden muss ([https://pypi.org/project/regex/]). Es bietet zusätzliche Funktionalität und gründlicheren Unicode-Support. Dies sei hier aber nur der Vollständigkeit halber erwähnt.&lt;/small&gt;

== Verzweigungen ==
=== if ===
Die IF-Verzweigung sei aus anderen Programmiersprachen bereits bekannt. In {{W|Pseudocode}} lässt sie sich folgendermaßen darstellen:

 WENN bedingung TRUE
   führe block1 aus
 SONST
   führe block2 aus
 ENDE 

Als {{W|Aktivitätsdiagramm|UML-Aktivitätsdiagramm}} sieht das in etwa so aus:

[[File:If-Then-Else-diagram.svg|200px]]

Und als {{W|Nassi-Shneiderman-Diagramm|Nassi-Shneiderman-Struktogramm}} so:

[[File:Zweiseitige Auswahl.png|250px]]

In Python gibt es keinen expliziten ENDE-Kennzeichner. Stattdessen wird der Code durch Einrückungen strukturiert. Alles mit der gleichen Einrückungstiefe gehört zum selben Block. Dies zeichnet Python vor anderen Programmiersprachen aus.

Die test1.py-Datei laute also wie folgt:

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
   print(&quot;x ist groesser oder gleich 4&quot;)  

Ausgabe:

 Der else-Zweig wird ausgefuehrt
 x ist groesser oder gleich 4

Man achte auch auf die Doppelpunkte in der if- und else-Zeile. Darauf vergisst man gerne, wenn man von anderen Programmiersprachen kommt.

Folgendes wäre in Python ein Fehler (genauer gesagt ein IndentationError).

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
     print(&quot;x ist groesser oder gleich 4&quot;)  

Auch Nachstehendes würde nicht zum gewünschten Ergebnis führen (löst aber keine Fehlermeldung aus). Der letzte print-Befehl ist schon außerhalb der IF-ELSE-Verzweigung.

 x = 3
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
 print(&quot;x ist groesser oder gleich 4&quot;)

Ausgabe:

 x ist kleiner als 4
 x ist groesser oder gleich 4

Python kennt eine Reihe von Vergleichs- und Verknüpfungsoperatoren:

    &lt;, &lt;= ... kleiner (gleich)
    &gt;, &gt;= ... größer (gleich)
    == ... gleich
    != ... ungleich
    is ... identisch
    is not ... nicht identisch
    and ... AND
    or ... OR
    not ... NOT

Beispielsweise:

 a = 5
 b = 9
 
 if a&lt;=10 and b!=7:
   print(&quot;OK&quot;)
 else
   print(&quot;Nicht OK&quot;)

Ausgabe:

 OK

Der else-Block kann übrigens auch ersatzlos entfallen. Als Pseudocode sieht das so aus

 WENN bedingung TRUE
   führe block aus
 ENDE

Mehrfache Verzweigungen werden durch das elif-Konstrukt erstellt. In Pseudocode:

 WENN bedingung1 TRUE
   führe block1 aus
 SONST WENN bedingung2 TRUE
   führe block2 aus
 SONST WENN bedingung3 TRUE
   führe block3 aus
 SONST
   führe block4 aus
 ENDE

Ein Python-Beispiel:
 a = 14
 
 if a&lt;=10:   
   print(&quot;&lt;=10&quot;)
 elif a&gt;=11 and a&lt;=15:
   print(&quot;11 bis 15&quot;)
 elif a&gt;=16 and a&lt;=20:
   print(&quot;16 bis 20&quot;)
 else:
   print(&quot;&gt;20&quot;)

Ausgabe:

 11 bis 15

In Python gibt es auch die Schlüsselwörter &lt;code&gt;True&lt;/code&gt; (für wahr) und &lt;code&gt;False&lt;/code&gt; (für falsch). Man beachte, dass sie mit Großbuchstaben beginnen. Andere Schreibweisen wären ein Fehler. Sie gehören zum Datentyp &lt;code&gt;bool&lt;/code&gt;. Ihnen sind auch die Zahlen &lt;code&gt;1&lt;/code&gt; und &lt;code&gt;0&lt;/code&gt; zugewiesen.

Man beachte, dass {{W|Rundungsfehler}} auftreten können. D.h. man sollte  bei der Verwendung von {{W|Gleitkommazahl|Gleitpunktzahlen}} niemals auf absolute Genauigkeit prüfen, sondern eine Toleranz (einen &lt;math&gt;\varepsilon&lt;/math&gt;-Wert) vorgeben.
 
Ein klassisches Beispiel, das ein falsches Ergebnis liefert, ist:

 i = 0.1 + 0.2
 
 print(i)
 
 if i == 0.3:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 NOK

Und das, obwohl man schon in der Volksschule lernt, dass 0.1 + 0.2 gleich 0.3 ist.

Korrekt muss das obige Beispiel z.B. so umgeschrieben werden:

 ist = 0.1 + 0.2
 soll = 0.3
 epsilon = 0.000001
 
 print(ist)
 
 if abs(ist-soll) &lt; epsilon:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 OK

Alternativ kann auch die &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion verwendet werden. Das sei aber hier nur erwähnt und nicht konkret ausgeführt.

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet zum Thema &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion.

=== match ===
Ab Python 3.10 gibt es auch die match-Anweisung. Dies ist das Python-Pendant für die switch-Anweisung in anderen Programmiersprachen, geht aber bei näherer Betrachtung weit darüber hinaus. Hier nur ein einfaches Beispiel:

 x = &quot;Hello&quot;
 
 match x:
     case &quot;Servus&quot; | &quot;Ciao&quot;:         # or
         print(&quot;Servus an alle&quot;)
     case &quot;Grüetzi&quot;:
         print(&quot;Grüetzi Schwyzer&quot;)  
     case _:                         # other, default, sonstiges ...
         print(&quot;Hallo Welt&quot;)

Ausgabe: 
 Hallo Welt

Als Struktogramm sieht das in etwa so aus:

[[File:Mehrseitige Auswahl.png|250px]]

Für nähere Details siehe z.B. [https://www.geeksforgeeks.org/python-match-case-statement/], [https://learnpython.com/blog/python-match-case-statement/], [https://docs.python.org/3/tutorial/controlflow.html#match-statements] und das Python Enhancement Proposal (PEP) 636 – Structural Pattern Matching: Tutorial [https://peps.python.org/pep-0636] und dort insbesondere den Anhang A - Quick Intro.

&lt;small&gt;&lt;code&gt;match, case, _&lt;/code&gt; etc. sind sogenannte ''soft keywords''. Im Gegensatz zu den normalen Schlüsselwörtern dürfen ihnen auch Werte zugewiesen werden. Eine Liste der weichen Schlüsselwörter lässt sich durch &lt;code&gt;keyword.softkwlist&lt;/code&gt; erstellen (die Anweisung gibt es seit Python 3.9). Siehe dazu auch [https://stackoverflow.com/questions/65800344/what-are-soft-keywords] und [https://docs.python.org/3/library/keyword.html#keyword.softkwlist].&lt;/small&gt;

== Schleifen ==
Kopfgesteuerte Schleife, Endlosschleife und fußgesteuerte Schleife:

[[File:Programmingloops.svg|450px]]

=== while ===
Die WHILE-Schleife ist kopfgesteuert. Sie funktioniert wie aus anderen Programmiersprachen bekannt. 

In Pseudocode:
 SOLANGE bedingung TRUE
   führe block aus
 ENDE

In Python:
 x = 0
 
 while x &lt;= 10:
   print(x)
   x += 1

Ausgabe:
 0
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10

Eine Endlosschleife ergibt sich z.B. so:
 i = 5
 
 while True:
     print(i)
     i-=1

Beendet werden kann sie mit der Tastenkombination STRG-C.

Eine fußgesteuerte Schleife kann so simuliert werden:
 i = 5
 
 while True:
     print(i)
     i-=1
 
     if i&lt;=0:
         print(&quot;Fire&quot;)
         break

Ausgabe:
 5
 4
 3
 2
 1
 Fire

Der &lt;code&gt;break&lt;/code&gt;-Befehl wird etwas [[Ing_Mathematik:_Python#break|später]] noch einmal kurz thematisiert.

=== for ===
Struktogramm einer for-Schleife:

[[File:Zählschleife.png|200px]]

In Python bspw. so:

 for x in range(6):
   print(x*2)

Ausgabe:
 0
 2
 4
 6
 8
 10

Die Schleife läuft von 0 bis 5. Ausgegeben wird jeweils der Wert x*2. Aquivalent kann diese Schleife auch so geschrieben werden:
 for x in range(0, 11, 2):
   print(x)

Die Ausgabe ist wie oben. Der Startwert sei 0, der Endwert ist 11-1 und die Schrittweite ist 2.

Ein anderes Beispiel sei
 for x in &quot;text&quot;:
   print(x)

Ausgabe:
 t
 e
 x
 t

== Schleifen abbrechen ==
=== break ===
&lt;code&gt;break&lt;/code&gt; bricht die Schleife ab und setzt mit dem nächsten Befehl außerhalb der Schleife fort.

 for var in range(100):
   print(var) 
   if var == 5:
     break

Ausgabe:
 0
 1
 2
 3
 4
 5

=== continue ===
&lt;code&gt;continue&lt;/code&gt; bricht den aktuellen Schleifendurchlauf ab und setzt mit dem nächsten Schleifendurchlauf fort.

 for var in range (11):
   if var == 5:
     continue
   print(var)

Ausgabe:
 0
 1
 2 
 3
 4
 6
 7
 8
 9
 10

== try - except ==
 try:
     z1 = 12 / 0
     print(z1)
 except ZeroDivisionError:
     print(&quot;Das Ergebnis ist unendlich&quot;)
 except:
     print(&quot;Kann nicht berechnet werden!&quot;)
     print(&quot;Bitte die Formel korrigieren!&quot;)
 
 print(&quot;Setze Programm fort!&quot;)

Ausgabe:
 Das Ergebnis ist unendlich
 Setze Programm fort!

Es wird versucht, eine Zahl durch Null zu dividieren. Das ist nicht möglich, es wird eine Ausnahme ausgelöst. Das Programm springt daher in den except-ZeroDivisionError-Block und führt die dort gelisteten Anweisungen aus (in unserem Fall eine print-Anweisung). Danach wird das Programm fortgesetzt. Würden wir dieses Programm ohne try-except ausführen, so ergibt sich aus

 z1 = 12 / 0
 print(z1)

folgende Fehlermeldung und ein unmittelbarer Programmabbruch

 Traceback (most recent call last):
   File &quot;C:\tmp\test1.py&quot;, line 1, in &lt;module&gt;
     z1 = 12 / 0
 ZeroDivisionError: division by zero

Mit dem try-except-Mechanismus können also Ausnahmen oder Fehler aufgefangen und behandelt werden. In unserem Beispiel ist das eher trivial, aber bei größeren Programmen kann das durchaus Sinn machen.

Neu in Python 3.14 ist, dass mehrere Ausnahmen auch ohne Klammern angegeben werden können, z.B.:

bis inkl. Python 3.13 nur:
 except (ZeroDivisionError, ValueError):

ab Python 3.14 auch:
 except ZeroDivisionError, ValueError:

== pass ==
Ein leerer Block muss in Python mittels dem Schlüsselwort &lt;code&gt;pass&lt;/code&gt; dargestellt werden. Z.B.

 x = 2
 
 if x == 1:
     print(&quot;Wert ist &quot;, x)
 else:
     pass

Würde man das &lt;code&gt;pass&lt;/code&gt; im else-Block weglassen, so würde man eine Fehlermeldung erhalten:

 IndentationError: expected an indented block after 'else' statement on line 5

= Funktionen =
== Aufrufen von Funktionen ==
Funktionen sind uns im Rahmen dieses Kurses schon zuhauf begegnet. Sei es die print()-, die math.sin()- oder die hex()-Funktion. All diese Funktionen werden von Python zur Verfügung gestellt, ohne dass man sie explizit programmieren müsste. Aufgerufen werden diese Funktionen, indem man ihren Namen eintippt, gefolgt von runden Klammern. In diesen Klammern können noch Argumente übergeben werden. Auch Rückgabewerte sind möglich.

== Funktionen selber schreiben ==
Funktionen werden mit dem def-Schlüsselwort (man definiert die Funktion) eingeleitet, danach folgt der Funktionsname, danach wiederum runde Klammern, in denen formale Argumente stehen können. Abgeschlossen wird die def-Zeile mit einem Doppelpunkt. Danach folgt der Funktionskörper. Dieser Funktionskörper muss wiederum eingerückt werden (wie von den Verzweigungen und Schleifen bekannt). Aufgerufen wird diese Funktion, indem man ihren Funktionsnamen eingibt, gefolgt von runden Klammern (ggf. mit den aktuellen Parametern). Z.B.

 # Funktion definieren
 def halloWelt(i):
     # i ... beliebige Ganzzahl
     print(&quot;Hallo &quot; * i, end=&quot;&quot;)
     print(&quot;Welt!&quot;)
    
 # Funktion aufrufen
 halloWelt(3)

Ausgabe:
 Hallo Hallo Hallo Welt!

Unterschied zwischen formalen und aktuellen Parametern:

[[Datei:PythonIng_func1.jpg]]

&lt;small&gt;Aktuelle Parameter werden auch Argumente genannt.&lt;/small&gt;

Rückgabe von Funktionswerten:
 # Funktion definieren
 def mathFunc(a, b):
     r1 = a + b
     r2 = a * b
     return r1, r2
    
 # Funktion aufrufen
 c, d = mathFunc(3, 5)
 
 # Ausgabe der zurückgegebenen Werte
 print(c)
 print(d)

Ausgabe:
 8
 15

Es werden r1 und r2 zurückgegeben und den Variablen c und d zugewiesen. (r1, r2) und (c, d) sind Tupel. Was Tupel konkret sind, siehe etwas später in diesem Kapitel. 3 und 5 sind die aktuellen Parameter (die Argumente). a und b sind die formalen Parameter. Die Zuweisung der aktuellen zu den formalen Parametern erfolgt in der gegebenen Reihenfolge, also die Zahl 3 wird an a übergeben und die Zahl 5 an b.

Vorgabeparameter, z.B.:
 def mathFunc(a=10, b=20):
     r1 = a + b
     r2 = a * b
     return r1, r2
 
 c, d = mathFunc(3, 5)
 print(c)
 print(d) 
 
 e, f = mathFunc(5)
 print(e)
 print(f)
 
 g, h = mathFunc(b=6)
 print(g)
 print(h)

Ausgabe:
 8
 15
 25
 100
 16
 60

Erklärung:
* Erster &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es werden, wie weiter oben, die Argumente 3 und 5 an die formalen Parameter a und b übergeben. Die Rückgabewerte r1 und r2 werden an c und d übergeben. Somit ist c=8 und d=15.
* Zweiter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur das Argment 5 an a übergeben. b behält den Vorgabewert 20. D.h. e= 25 und f=100.
* Dritter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur die Zahl 6 an b übergeben, a behält seinen Vorgabewert 10. Somit ergibt sich g=16 und h=60.

Beispiel (Schlüsselwortargumente vs. Positionsargumente):
 def mathFunc(a, b):
     r1 = a - b
     r2 = a / b
     return r1, r2
 
 c, d = mathFunc(b=3, a=5)  # Schlüsselwortargumente
 e, f = mathFunc(3, 5)      # Positionsargumente

 print(c)
 print(d)
 print(e)
 print(f)

Ausgabe:
 2
 1.6666666666666667
 -2
 0.6

Durch die Verwendung von Schlüsselwortargumenten können die Argumente in beliebiger Reihenfolge angegeben werden. Bei den Positionsargumenten ist die Reihenfolge vorgegeben. Daraus resultiert auch der Unterschied bei den obigen Ausgaben. Werden beide Arten in einem Aufruf gemischt, so müssen die Positionsargumente zuerst angegeben werden. Den Unterschied zwischen beiden Argumentarten zu kennen ist wichtig, nicht nur bei selbst erstellten Funktionen. Auch beim Aufruf von Python-Funktionen verfolgt einen die Mischung von Schlüsselwort- und Positionsargumenten auf Schritt und Tritt, z.B. beim etwas später folgenden Abschnitt über &quot;Grafiken zeichnen&quot;:

 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)

Bei dieser &lt;code&gt;plot&lt;/code&gt;-Funktion aus dem Modul &lt;code&gt;matplotlib.pyplot&lt;/code&gt; sind &lt;code&gt;x&lt;/code&gt; und &lt;code&gt;y1&lt;/code&gt; Positionsargumente. &lt;code&gt;label, lw&lt;/code&gt; und &lt;code&gt;ls&lt;/code&gt; sind die Namen der Schlüsselwortargumente. Die Schlüsselwortargumente könnten auch in anderer Reihenfolge angeschrieben werden, nicht jedoch die Positionsargumente!
Siehe zu &lt;code&gt;matplotlib.pyplot.plot&lt;/code&gt; auch die Seite [https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html].

== Lambda-Funktionen ==
 print((lambda a, b: a*b) (3, 5))

Ausgabe:
 15

Eingeleitet wird eine Lambda-Funktion (auch Lambda-Form, Lambda-Operator oder anonyme Funktion genannt) mit dem Schlüsselwort &lt;code&gt;lambda&lt;/code&gt;. Es folgen die formalen Argumente, danach ein Doppelpunkt, die Berechnungsvorschrift und ggf. abschliessend in Klammern die aktuellen Parameter.

Man kann einer Lambda-Funktion auch einen Funktionsnamen geben und die Funktion über diesen Namen aufrufen, z.B.

 prod = lambda a, b: a*b
 print(prod(3, 5))

Als Ausgabe wird wieder die Zahl 15 geliefert.

== Rekursive Funktionen ==
Funktionen können wiederum andere Funktionen aufrufen. Von einem {{W|Rekursion|rekursiven Funktionsaufruf}} spricht man, wenn die aufgerufene Funktion gleich der aufrufenden ist. 

 def printFunc(i):
     if (i &gt;= 5):
         return 
     else:
         print(&quot;Hallo Welt&quot;)
         printFunc(i+1)
         
 printFunc(1)

Ausgabe:
 Hallo Welt
 Hallo Welt
 Hallo Welt
 Hallo Welt

Typische Beispiele für die Abarbeitung als rekursive Funktionen sind die {{W|Fibonacci-Folge}} und die {{W|Fakultät_(Mathematik)|Fakultät}}. Jedoch ist der iterative Ansatz (mit konventionellen Schleifen) meist schneller und speicherplatzschonender.

== Funktionsannotationen ==
Python ist sehr flexibel, was Typen angeht. Im Vorhergehenden haben wir generell keine Typangaben gemacht. Will man Typen angeben, so bietet Python das Konzept der Funktionsannotation.

 def calcFunc(a: int, b: int) -&gt; int:
     return a+b
 
 r1 = calcFunc(8, 9)
 r2 = calcFunc(8.0, 9.0)
 r3 = calcFunc(&quot;Hallo&quot;, &quot;Welt&quot;)
 
 print(r1)
 print(r2)
 print(r3)

Ausgabe:
 17
 17.0
 HalloWelt

Jetzt sieht man auf den ersten Blick, welche Typen der Programmierer im Sinn hatte, als er die Funktion erstellte. Das Problem dabei ist nur, dass es Python ziemlich egal ist, welche Typen man im Endeffekt eingibt. Im obigen Beispiel können statt Integer-Typen u.a. auch Float- oder String-Typen eingegeben werden.

&lt;small&gt;
Siehe zum Thema &quot;Type Checking&quot; aber auch den später folgenden Abschnitt [[Ing_Mathematik:_Python#Type_Checker]].
&lt;/small&gt;

== Variadische Funktionen ==
Python-Code:

 def test1(a, *b):
     print(a);
      
     for c in b:
         print(c);
        
 test1(&quot;Hallo&quot;, &quot;Welt&quot;, &quot;Schweizer&quot;, &quot;und alle anderen&quot;)

Ausgabe:

 Hallo
 Welt
 Schweizer
 und alle anderen

Mit dem Stern (auch als Splat-Operator bezeichnet) in der formalen Parameterliste bei der Funktion &lt;code&gt;test1&lt;/code&gt; wird angezeigt, dass eine beliebige Anzahl von Argumenten übergeben wird. &lt;small&gt; Dies entspricht in etwa dem, was in anderen Programmiersprachen (PHP etc.) mittels Ellipse (&lt;code&gt;...&lt;/code&gt;) angezeigt wird.&lt;/small&gt;

= Tupel, Listen und andere =
[[Datei:Python 3. The standard type hierarchy.png|mini|hochkant=1.7|Datentypen und Strukturen]]

== Tupel und Listen ==
Tupel, Listen und einige andere sind Datenstrukturen oder Sequenzen.

Listen (z.B. eine Einkaufsliste) sind veränderbar (mutable). Ein Tupel kann dagegen nicht verändert werden (immutable). Listen werden beim Anlegen in eckige Klammern eingeschlossen, Tupel in runde Klammern. Beim Tupel können die Klammern auch weggelassen werden. Ein Tupel mit nur einem Element muss mit einem Beistrich abgeschlossen werden. Der Grund ist, dass Python sonst nicht entscheiden kann, ob ein Tupel angelegt werden soll, oder nur ein geklammerter Wert. 

Als Gedächtnisstütze kann man sich den Unterschied zwischen Tupel und Liste ev. so leichter merken:
: T'''u'''pel ... r'''u'''nde Klammern, '''u'''nveränderlich
: L'''i'''ste ... eck'''i'''ge Klammern, veränderl'''i'''ch.

Nachfolgend werden einige Operationen mit Listen und Tupel dargestellt.

 # Liste und Tupel
 liste = [1, 2, &quot;Hallo&quot;]
 tupel = (1, 2, &quot;Hallo&quot;) 
 
 # Ausgabe von liste und tupel
 print(liste)
 print(tupel)
 
 # Ausgabe von Einzelelementen
 print(liste[1])
 print(tupel[2])
 
 # Element an Liste anhängen und einfügen 
 liste.append(55)
 liste.insert(4, &quot;Welt&quot;)
 print(liste)
 
 # Element aus Liste entfernen
 liste.remove(1)
 print(liste)
 
 # einige weitere Beispiele
 liste2 = [1,]
 tupel2 = 1, 2
 tupel3 = (1,) 
 print(liste2)
 print(tupel2)
 print(tupel3)

Ausgabe:
 [1, 2, 'Hallo']
 (1, 2, 'Hallo')
 2
 Hallo
 [1, 2, 'Hallo', 55, 'Welt']
 [2, 'Hallo', 55, 'Welt']
 [1]
 (1, 2)
 (1,)

Beispiel (eine Liste von Wörtern zu einem einzigen zusammenhängenden Text verbinden):

 woerter = [&quot;Hallo&quot;, &quot;Welt&quot;]
 satz = &quot; &quot;.join(woerter)
 print(satz)

Ausgabe:

 Hallo Welt

== Dictionaries und Mengen ==
Zu den Datenstrukturen gehören weiters auch Mengen und Dictionaries. Mengen sind von der Mathematik bekannt, sie sind ungeordnet und es kommen keine mehrfachen Elemente vor. Dictionaries sind durch Schlüssel :Wert-Paare gekennzeichnet. Mengen werden beim Anlegen wie Dictionaries in geschweifte Klammern eingeschlossen.

 dict = {&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot; }
 menge = {1, 1, 3, 4, 4, 4, &quot;Hallo&quot;}
 
 print(dict)
 print(menge)
 print(dict[&quot;vorname&quot;])

Ausgabe:
 {'vorname': 'Hugo', 'nachname': 'Meister'}
 {1, 3, 4, 'Hallo'}
 Hugo

Geschweifte Klammern ohne Inhalt stellen Dictionaries dar und keine Mengen:

 di = {}
 print(type(di))

Ausgabe:
 &lt;class 'dict'&gt;

Leere Mengen lassen sich mit &lt;code&gt;set()&lt;/code&gt; erzeugen:

 menge = set()      # leere Menge
 print(menge)
 menge.add(&quot;Hallo&quot;) # Element hinzufügen
 print(menge)

Ausgabe:
 set()
 {'Hallo'}

Beispiel (einige Mengenoperationen):
 mengeA = {&quot;Hallo&quot;, &quot;Welt&quot;}
 mengeB = {1, 2, &quot;Welt&quot;, 3}
 
 # Vereinigung
 print(mengeA | mengeB)
 print(mengeA.union(mengeB))
 
 # Durchschnitt
 print(mengeA &amp; mengeB)
 print(mengeA.intersection(mengeB))
 
 # Differenz
 print(mengeA - mengeB)
 print(mengeA.difference(mengeB))
 
 # Symmetrische Differenz
 print(mengeA ^ mengeB)
 print(mengeA.symmetric_difference(mengeB))
 
 # Teilmenge
 print(mengeA.issubset(mengeB))
 
 # Mehrere Elemente hinzu
 mengeA.update([&quot;Super&quot;, 67, 125])
 print(mengeA)
 
 # Element löschen
 mengeA.discard(&quot;Hallo&quot;)
 print(mengeA)

Ausgabe:
 {1, 2, 3, 'Welt', 'Hallo'}
 {1, 2, 3, 'Welt', 'Hallo'}
 {'Welt'}
 {'Welt'}
 {'Hallo'}
 {'Hallo'}
 {1, 2, 3, 'Hallo'}
 {1, 2, 3, 'Hallo'}
 False
 {67, 'Super', 'Welt', 'Hallo', 125}
 {67, 'Super', 'Welt', 125}

Es gibt schon seit &quot;ewigen&quot; Zeiten unveränderbare Mengen, die mittels &lt;code&gt;frozenset&lt;/code&gt; eingeleitet werden. Neu ab Python 3.15 ist dagegen das Pendant &lt;code&gt;frozendict&lt;/code&gt;, das unveränderbare Dictionaries darstellt.

 fdict = frozendict({&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot;})
 fset = frozenset({&quot;A&quot;, 1, &quot;A&quot;})
 
 print(fdict)
 print(fdict[&quot;vorname&quot;])
 print (fset) 
 
 try:
     fdict[&quot;vorname&quot;] = &quot;Max&quot;
     print(fdict[&quot;vorname&quot;])
 except TypeError as e:
     print(f&quot;Fehler: {e}&quot;)
 
 try:
     fset.add(&quot;B&quot;)
     print(fset)
 except AttributeError as e:
     print(f&quot;Fehler: {e}&quot;)

Ausgabe:
 frozendict({'vorname': 'Hugo', 'nachname': 'Meister'})
 Hugo
 frozenset({1, 'A'})
 Fehler: 'frozendict' object does not support item assignment
 Fehler: 'frozenset' object has no attribute 'add'

== List Comprehensions ==
Aus einer Eingabeliste soll eine Ausgabeliste erzeugt werden. Das kann folgendermaßen geschehen.

Mathematische Schreibweise: &lt;math&gt;lc = \{2x|x\in\ \mathbb{N}, 1\le x &lt; 11\}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11)]
 print(lc)

Ausgabe:
 [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Mathematische Schreibweise: &lt;math&gt;lc = \{2x | x \in \mathbb{N}, 1\le x &lt; 11, x \bmod 2 = 0 \}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11) if x%2 == 0]
 print(lc)

Ausgabe:
 [4, 8, 12, 16, 20]

Siehe auch {{W|List Comprehension}}.

== Set Comprehensions ==
Dies ist sehr ähnlich wie im vorigen Abschnitt beschrieben. Es wird aber keine Liste, sondern eine Menge erzeugt.

 sc = {x*2 for x in range(1,11)}
 print(sc)

Ausgabe:
 {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}

== Listen zusammenführen - zip() ==
 li1 = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]
 li2 = [1, 2, 3, 4]
 li3 = [5.5, 6.6, 7.7, 8.8]
 
 z = zip(li1, li2, li3)
 print(z)
 
 li4 = list(z)
 print(li4)

Ausgabe:
 &lt;zip object at 0x00000283B6C6AC80&gt;
 [('A', 1, 5.5), ('B', 2, 6.6), ('C', 3, 7.7), ('D', 4, 8.8)]

== Generatorausdruck ==
 g = (i*2 for i in range(1,11))
 print(g)
 t = tuple(g)
 print(t)
 print(t[1:3])

Ausgabe:
 &lt;generator object &lt;genexpr&gt; at 0x00000241D2A4A5A0&gt;
 (2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
 (4, 6)

== Slicing ==
slice ... Scheibe, Teil, in Scheiben schneiden

Beispiel: Zugriff auf Elemente eines geordneten sequentiellen Objekttyps (Liste, Tupel oder String):

 str1 = &quot;Hallo&quot;
 # Das erste Element wird mit dem Index 0 angesprochen
 # [start (inkl.) : stop (exkl.) : step (default=1)]
 str2 = str1[0:2]
 # Alternativ auch: str2 = str1[:2] 
 print(str2)
 
 tup1 = (0,1,2,3)
 # Das letzte Element hat auch den Index -1, das vorletzte den Index -2 usw.
 tup2 = tup1[-3:-1]
 print(tup2)
 
 lst1 = [[1,  5,  10, 20],
         [30, 40, 50, 60]]
 lst2 = lst1[1][1]
 print(lst2)
 
Ausgabe:
 Ha
 (1, 2)
 40

Beispiel:

 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2])
 print(x[-3]) 
 print(x)
 print(x[:])
 print(x[2:])
 print(x[:2])
 print(x[::-1])

Ausgabe:

 c
 c
 ('a', 'b', 'c', 'd', 'e')
 ('a', 'b', 'c', 'd', 'e')
 ('c', 'd', 'e')
 ('a', 'b')
 ('e', 'd', 'c', 'b', 'a')

Visualisierung:

    '''a'''     '''b'''     '''c'''     '''d'''     '''e'''
 +-----------------------------+
 |  0  |  1  |//'''2'''//|  3  |  4  |
 +-----------------------------+
 | -5  | -4  |/'''-3'''//| -2  | -1  | 
 +-----------------------------+
 |/////////////////////////////|
 +-----------------------------+
 |/////////////''':'''///////////////|
 +-----------------------------+
 |     |     |///////'''2:'''////////|
 +-----------------------------+
 |////''':2'''/////|     |     |     |
 +-----------------------------+
 |\\\\\&lt;--\\\\\'''::-1'''\\\\&lt;--\\\\\|
 +-----------------------------+

Beispiel:
 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2::2])
 print(x[2::-1])
 print(x[2:0:-1])

Ausgabe:

 ('c', 'e')
 ('c', 'b', 'a')
 ('c', 'b')

Hier sieht man sehr schön, dass beim letzen &lt;code&gt;print&lt;/code&gt;-Befehl die 0, die in diesem Fall den Buchstaben &quot;a&quot; repräsentiert, als letzer Wert nicht mehr dazugehört (wie weiter oben angedeutet ist der End- oder Stoppwert exklusiv). Will man den Buchstaben &quot;a&quot; dazunehmen, so ist die vorletzte Zeile die richtige.

Beispiel: Umdrehen von Strings

 str1 = &quot;Hallo&quot;
 str2 = str1[::-1]
 print(str2)

Ausgabe:
 ollaH

Mit zweidimensionalen Listen/Tupels wird das Ganze schon bedeutend komplexer.

Beispiel: Verkettetes Slicing

 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
     
 print(A[2::][::2])

Ausgabe:

 [['20', '21', '22', '23'], ['40', '41', '42', '43']]

Das erste Slicing erstellt folgenden Slice:

 [[&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
  [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
  [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]

Das zweite Slicing wird dann auf diesen Slice angewendet und ergibt das genannte Endergebnis. Will man Spalten statt Zeilen, so funktioniert dieser direkte Weg nicht. Man verwendet dann List Comprehensions oder die NumPy-Bibliothek. Diese Bibliothek erlaubt [[Ing_Mathematik:_Python#Zugriff_auf_Matrizenelemente|zweidimensionales Slicing]]. Sie wird erst später bei den Grafiken eingeführt. Deshalb wird hier dazu noch kein Beispiel gezeigt.

= Objektorientierte Programmierung =
{{Wikipedia|Objektorientierte Programmierung}}

* {{W|Klasse (Objektorientierung)|Klasse}} ... die Schablone oder der Bauplan, enthält Methoden und Attribute
* {{W|Objekt (Programmierung)|Objekt}} ... eine Klasseninstanz (die konkrete Ausprägung der Klasse)
* {{W|Attribut (Programmierung)|Attribute}} ... die Eigenschaften eines Objekts
* {{W|Methode (Programmierung)|Methoden}} ... die Aktionen (Operationen), die ein Objekt ausführen kann
* {{W|Vererbung (Programmierung)|Vererbung}} ... neue Klassen (Subklassen, Unterklassen, abgeleitete Klassen) aus vorhandenen Klassen (Superklassen, Oberklassen, Basisklassen, Elternklassen) ableiten. Ermöglicht den Aufbau von Klassenhierarchien. Die Subklasse &quot;erbt&quot; Attribute und Methoden von der Superklasse. Python unterstützt (so wie C++, aber im Gegensatz zu Java) Mehrfachvererbung.

== UML ==
* {{W|Unified Modeling Language|UML}} ... '''U'''nified '''M'''odeling '''L'''anguage, eine Modellierungssprache. Die UML enthält zahlreiche Diagrammarten, um Programme zu modellieren. Im Nachfolgenden wird nur das {{W|Klassendiagramm}} verwendet.

[[File:UmlCd Klasse-3.svg|300px]]

* {{W|Sichtbarkeit (Programmierung)|Sichtbarkeit}}:
** + ... public (öffentlich)
** - ... private
** # ... protected 

* {{W|Attribut_(UML)#Attribute_für_Instanzen_und_für_Klassen|Klassenattribute}} (statische Attribute): Werden nur einmal pro Klasse angelegt. Im Klassendiagramm werden sie unterstrichen.

[[File:Attribute-3.png|200px]]

* Vererbung:

&lt;gallery&gt;
InheritancePgmUML.svg | Abgeleitete Klasse erbt von Basisklasse (Einfachvererbung)
Diamond inheritance.svg | D erbt von B und C (Mehrfachvererbung). B und C erben von A (Einfachvererbung)
&lt;/gallery&gt;

Für weitergehende Betrachtungen zur UML wird auf Spezialliteratur verwiesen, z.B.:
* Seidl et al.: UML@Classroom. dpunkt, 2012, ISBN 978-3-89864-776-2
* Rupp et al.: UML 2 glasklar. Hanser, 4. Aufl., 2012, ISBN 978-3-446-43057-0

== Eine einfache Klasse ==

[[Datei:PythonIng_uml1.svg | 200px]]

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
 
 fahr = Fahrzeug(150, 90)
 
 print(fahr.convertGeschw())
 
Ausgabe:
 41.666666666666664

Die Klasse Fahrzeug wird durch das class-Schlüsselwort eingeleitet. raeder ist ein Klassenattribut und public. __init__ wird bei der Objekterzeugung automatisch aufgerufen (ist der sogenannte Konstruktor). Man achte darauf, dass diese Methode immer mit zwei Unterstrichen eingeleitet und abgeschlossen wird. Instanzattributen wird das Wort self vorangestellt. Wir sehen uns z.B. das Attribut self.__geschwind an. Auch hier werden zwei Unterstriche verwendet. Das bedeutet, dass dieses Attribut strikt/stark private ist. Wird nur ein Unterstrich verwendet, so deutet dies auf schwach/weakly private hin. Letzteres wird in Python deutlich häufiger verwendet. Bei den Methoden wird immer self als erster Parameter angegeben. Beim Aufruf der entsprechenden Funktion wird das self aber nicht berücksichtigt.

Besonderheiten bei stark und schwach private:
* '''stark private''':
** zwei führende Unterstriche
** Name Mangling: Name wird zu &lt;code&gt;_Klassenname__variablenname&lt;/code&gt;
** Schutz vor Namenskollisionen bei Vererbung
** am Ende des Namens dürfen keine zwei Unterstriche verwendet werden. Das wären dann Magic Methods oder Dunder-Methods (z.B. __init__). Diese sind public.

* '''schwach private''':
** ein führender Unterstrich
** Name bleibt gleich
** ist nur ein Hinweis an die Programmierer, kein starker Schutz
** &lt;code&gt;from modul import *&lt;/code&gt;: Objekte mit einem führenden Unterstrich werden standardmäßig nicht importiert
** Standard für die Kapselung bei Python. Schätzung: Weit mehr als 80% der nicht-öffentlichen Attribute/Methoden werden als schwach private deklariert. Weniger als 5-10% als stark private (Quelle: Google KI)

== Klassen importieren ==
Häufig ist es sinnvoll und übersichtlicher Klassen in eigenen Dateien zu speichern. Das sind dann eigene Module. Abgespeichert werden Sie mit der Endung py, wie bisher auch praktiziert. Aufgerufen werden Sie mit der import-Anweisung. Dann ist aber nur der Dateiname ohne Endung py zu verwenden. Klarer wird das mit einem Beispiel.

Datei c:\tmp\fahrzeug.py

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6

Datei c:\tmp\test1.py

 import fahrzeug
 fahr = fahrzeug.Fahrzeug(150, 90)
 print(fahr.convertGeschw())

Ausgabe:
 41.666666666666664

Die üblichen import-Anweisungen lauten wie folgt:
{| {{prettytable}}
! import-Befehl
! Instanz
|-
| import xyz      || xyz.Klasse
|-
| import xyz as x || x.Klasse
|-
| from xyz import Klasse || Klasse
|-
| from xyz import * || Klasse 
|}

Der Vorteil der ersten beiden import-Anweisungen ist, dass es kaum zu Namenskollisionen kommen kann. Dafür hat man bei den letzten beiden Varianten weniger Tipparbeit.

== Vererbung ==
=== Einfachvererbung ===

[[Datei:PythonIng_uml2.svg | 200px]]

Datei fahrzeug.py:
 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
        
     def setLeistung(self, leistung):
         self.__leistung = leistung
        
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
        
 class Luftfahrzeug(Fahrzeug):
     def __init__(self, geschwindigkeit, leistung, fluegel):
         super().__init__(geschwindigkeit, leistung)
         self.__flueg = fluegel
     
     def getFlueg(self):
         return self.__flueg

Datei test1.py:
 import fahrzeug
 fahr = fahrzeug.Luftfahrzeug(150, 90, 4)
 print(fahr.getFlueg())

Ausgabe:
 4

=== Mehrfachvererbung ===
Mit Python ist auch Mehrfachvererbung möglich, z.B.:

 class A:
     def _printA(self):
         print(&quot;Klasse A&quot;)
 
 class B:
     def _printB(self):
         print(&quot;Klasse B&quot;)
 
 class C(A,B):
     def __init__(self):
         self._printA()
         self._printB()
 
 c = C()

Ausgabe:

 Klasse A
 Klasse B

Die Klasse C erbt von A und B. In UML sieht das in etwa so aus:

 +-----------------------------+   +-------------------------+
 |            A                |   |          B              |
 +-----------------------------+   +-------------------------+
 |                             |   |                         |
 +-----------------------------+   +-------------------------+
 | # printA()                  |   | # printB()              |
 +-----------------------------+   +-------------------------+
                           .              .
                          / \            / \
                          ---            ---
                           |              |
                           |              |
                        +---------------------+
                        |          C          |
                        +---------------------+
                        |                     |
                        +---------------------+
                        |                     |
                        +---------------------+

&lt;code&gt;printA()&lt;/code&gt; und &lt;code&gt;printB()&lt;/code&gt; sind schwach private (in UML als &lt;code&gt;protected&lt;/code&gt; mit einem # dargestellt). Es ist aber zu beachten, dass schwach private nur Konvention ist. Praktisch könnte man auch von außerhalb auf diese Methoden zugreifen. Das soll man aber nicht tun, und das wird in Python durch einen Unterstrich angedeutet.

== Statische Attribute, statische Methoden und Klassenmethoden ==
Beispiel:

 class Math:
     pi = 3.14159265
     cnt = 0
     
     @staticmethod
     def expo():
         return 2.71828183
    
     @classmethod    
     def counterPlus(cls):
         cls.cnt += 1
        
 print(Math.pi)
 print(Math.expo())
 
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)

Ausgabe:

 3.14159265
 2.71828183
 1
 2
 3

Statische Attribute und Methoden, bzw. Klassenmethoden, sind direkt einer Klasse zugeordnet und nicht einem Objekt. Der Unterschied zwischen statischen Methoden und Klassenmethoden ist, dass statische Methoden nicht auf Klassenattribute (bzw. statische Attribute) zugreifen können, Klassenmethoden aber schon. &lt;code&gt;pi&lt;/code&gt; und &lt;code&gt;cnt&lt;/code&gt; sind statische Attribute. &lt;code&gt;expo()&lt;/code&gt; ist eine statische Methode. &lt;code&gt;counterPlus(cls)&lt;/code&gt; ist eine Klassenmethode. Die Bezeichnung des Parameters als &lt;code&gt;cls&lt;/code&gt; ist reine Konvention, man sollte sich aber daran halten.

= Grafiken zeichnen =
Für das Zeichnen von Grafiken wird hier das Modul &lt;code&gt;matplotlib&lt;/code&gt; verwendet. &lt;code&gt;matplotlib&lt;/code&gt; ist ein externes Modul und muss vor der ersten Verwendung installiert werden. Das geht so:

# Starten Sie ein Terminal (bei Windows die Eingabeaufforderung).
# Führen Sie darin folgenden Befehl aus &lt;code&gt;c:\devel\Python\Scripts\pip.exe install matplotlib&lt;/code&gt;

pip ist übrigens der Paketmanager von Python ({{W|Pip_(Python)}}). 

Optimalerweise installieren wir auch gleich das Modul &lt;code&gt;numpy&lt;/code&gt; (Numerical Python). Wir werden es im Folgenden oft benötigen (nicht nur bei den Grafiken). Das funktioniert vom Prinzip her genauso, wie für &lt;code&gt;matplotlib&lt;/code&gt; gezeigt.

&lt;small&gt;Verwenden Sie Spyder, so sind diese Schritte nicht nötig. Spyder inkludiert diese Pakete standardmäßig. Unter openSUSE Tumbleweed lassen sich diese Pakete mittels YaST oder zypper installieren.&lt;/small&gt;

== 2D ==
=== Graph einer Funktion ===
Es soll die cosh-Funktion im Intervall &lt;math&gt;x\in[-3,3]&lt;/math&gt; gezeichnet werden. Der Programmcode lautet in der einfachsten Form:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x)
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:PythonIng_cosh1.jpg]]

Der Code ist quasi selbsterklärend. Das Untermodul pyplot des matplotlib-Moduls und das numpy-Modul werden importiert. x läuft von -3 bis +3. y wird für jeden x-Wert per Formel ausgerechnet. &quot;plt.plot()&quot; ist der Zeichenbefehl. &quot;plt.show&quot; ist notwendig, um das Fenster mit der Grafik anzuzeigen.
Die Schrittweite 0.1 wurde so gewählt, um einen ausreichend glatten Verlauf des Graphen zu gewährleisten. Das ist immer ein Kompromiss zwischen Berechnungszeit und Ansehnlichkeit. Testen Sie einfach ein paar verschiedene Werte, um ein Gefühl dafür zu zu bekommen. &quot;plt.grid()&quot; zeichnet ein Gitter in die Grafik (kann auch weggelassen werden).
Die Bezeichnungen plt und np könnten auch anders gewählt werden. Es ist aber Konvention, diese so wie hier gezeigt zu wählen. Die &quot;arange&quot;-Funktion aus der NumPy-Bibliothek wird später ein bisschen genauer behandelt (siehe [[Ing_Mathematik:_Python#Zahlenfolgen|Zahlenfolgen]]).  

&lt;small&gt;Mit der im obigen Bild gezeigten Menüleiste kann die dargestellte Grafik nachträglich noch geändert werden (Zoom, Pan, Achsenparameter, Kurvenparameter etc.). Natürlich kann man das alles auch direkt programmieren. Wie das funktioniert wird ansatzweise etwas später gezeigt.&lt;/small&gt;

Ein etwas komplexeres Beispiel ist Folgendes:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x) + 2**x
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:
[[Datei:PythonIng_cosh4.png]]

Man beachte, dass im Gegensatz zu Octave und Julia der ominöse Punkt (.) bei 2**x mit Python nicht benötigt wird. Das macht das Programmiererleben etwas einfacher.

Die Farbe des Graphen kann man über den &lt;code&gt;color&lt;/code&gt;-Schalter einstellen, z.B. auf rot setzen:
 plt.plot(x, y, color=&quot;red&quot;)

Das ist nur eine Möglichkeit, es gibt auch andere, z.B. mittels
* hexadezimaler Zahl, z.B. &lt;code&gt;color=&quot;#ff0000&quot;&lt;/code&gt;
* Kurzform, z.B. &lt;code&gt;&quot;r&quot;&lt;/code&gt;

Statt &lt;code&gt;color&lt;/code&gt; kann auch die Kurzform &lt;code&gt;c&lt;/code&gt; verwendet werden.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie diese &quot;Farbspielereien&quot; am Computer aus.

=== Graphen mehrerer Funktionen und weiteres ===
==== Mehrere Funktionen in einen Plot zeichnen ==== 
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh2.png]]

Um die Linienstile etwas individueller zu gestalten, ist folgender Programmcode gedacht: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;, lw=3, ls=&quot;--&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh3.png]]

Einige weitere Bespiele zu &lt;code&gt;ls&lt;/code&gt;&lt;/code&gt;:
* - ... durchgezogene Linie
* -. ... Strichpunkt-Linie
* dashed ... gestrichelte Linie 

==== Marker ====
Desweiteren kann man Marker verwenden.

Beispiel:

 import matplotlib.pyplot as plt
 
 plt.plot(10, 10, &quot;ob&quot;, markersize=30)
 plt.plot(20,20, &quot;.r&quot;)
 plt.plot(30,30, &quot;Dg&quot;, ms=15)
 plt.plot(40, 40, &quot;ok&quot;, ms=20, mec=&quot;#FF5733&quot;, mew=3)
 plt.plot(50, 50, &quot;vk&quot;, ms=20, mec=&quot;yellow&quot;, mew=3)
 plt.grid()
 plt.show()


Das erste Zeichen im String nach den Koordinaten im plot-Befehl symbolisiert die Form (z.B. o für einen Kreis). Das zweite Zeichen steht für die Farbe (z.B. b für blue). &lt;code&gt;markersize&lt;/code&gt; oder &lt;code&gt;ms&lt;/code&gt; setzt die Größe des Markers.

Ausgabe:

[[Bild:PythonIng_formatpara1.svg|200px]]

Einige weitere Marker:
* * ... Stern
* + ... Plus
* h oder H ... Sechseck

Man kann mit den Parametern 
* &lt;code&gt;markeredgecolor&lt;/code&gt; oder kurz &lt;code&gt;mec&lt;/code&gt; die Farbe des Markerrandes
* &lt;code&gt;markeredgewidth&lt;/code&gt; oder kurz &lt;code&gt;mew&lt;/code&gt; die Dicke des Randes
* &lt;code&gt;markerfacecolor&lt;/code&gt; oder kurz &lt;code&gt;mfc&lt;/code&gt; die Innenfarbe des Markers
bestimmen.

=== Funktion in Parameterdarstellung ===
Es soll die archimedische Spirale &lt;math&gt;x = t \cos(t), y = t  \sin(t)&lt;/math&gt; im Intervall &lt;math&gt;[0, 6\pi[&lt;/math&gt; gezeichnet werden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
  
 plt.show()

[[Datei:PythonIng_spirale1.png]]

Diese Darstellung erscheint verzerrt. Will man gleiche Achsenskalierungen, so kann man den plt.axis()-Befehl verwenden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
 plt.axis(&quot;equal&quot;)
 
 plt.show()
 
[[Datei:PythonIng_spirale2.png]]

=== Funktion in Polardarstellung ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 fig = plt.figure()
 ax = fig.add_subplot(projection=&quot;polar&quot;)
 r = np.arange(0, 1, 0.01)
 theta = r**3
 line = ax.plot(theta, r)
 
 plt.show()

[[Datei:PythonIng_polar1.png]]

=== Logarithmische Achsenskalierung ===
==== Semilog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.semilogy()
 plt.show()

Ausgabe:

[[Datei:PythonIng_semilog1.png]]

==== LogLog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.loglog()
 plt.show()

[[Datei:PythonIng_loglog1.png]]

=== Gefüllte Fläche ===
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.arange(0, 3, 0.1)
 
 y1 = 3*x - 1
 y2 = x**2
 
 plt.plot(x, y1, x, y2, color='black')
 plt.fill_between(x, y1, y2, where=y1&gt;=y2)
 
 plt.show()

[[Datei:PythonIng_gefuellt.png]]

=== Linien, Pfeile, Rechtecke, Kreise und Texte ===
 import matplotlib as mpl
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 r = mpl.patches.Rectangle((0, 0), 3, 3, angle=30, fill=False)
 c = mpl.patches.Circle((4, 4), 2, fill=False)
 
 ax.add_patch(r)
 ax.add_patch(c)
 ax.plot([-2, 7], [-2, 0], color=&quot;black&quot;)
 ax.arrow(0, 7, 5, 0, length_includes_head=True, head_width=0.5, head_length=1.5,
          color=&quot;black&quot;)
 
 ax.set_aspect(&quot;equal&quot;)
 
 plt.axis([-3, 8, -3, 8])
 plt.show() 

[[Datei:PythonIng_linien_pfeile_etc.png]]

Text kann mit &lt;code&gt;ax.text(x, y, &quot;Text&quot;)&lt;/code&gt; hinzugefügt werden, bspw.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 ax.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

Oder einfacher auch ohne &lt;code&gt;subplots&lt;/code&gt;

 import matplotlib.pyplot as plt
 
 plt.text(0.1, 0.1, &quot;Hallo&quot;)
 plt.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

[[Datei:PythonIng_text1.png]]

Auch Sonderzeichen (griechische Buchstaben etc.) können verwendet werden (siehe dazu auch [https://matplotlib.org/stable/users/explain/text/mathtext.html]).

 import matplotlib.pyplot as plt
 
 plt.text(.3, .5,
          r'$\Omega\ \psi\ \oint\ \nabla\ \dot a\ \frac{a}{b}\ a_b$',
          size=&quot;20&quot;)
 plt.show() 

[[Datei:PythonIng_text20.svg]]

Jetzt wird noch gezeigt, wofür &lt;code&gt;subplots&lt;/code&gt; sinnvoll eingesetzt werden können.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(0.1, 0.1, &quot;Hallo&quot;)
 ax[1].text(0.1, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
            rotation=30.0)
 
 plt.show()

[[Datei:PythonIng_text2.png]]

=== Anmerkungen hinzufügen ===
Anmerkungen (engl. annotations) lassen sich mit matplotlib einfach hinzufügen. Unter Anmerkung wird hier ein Pfeil mit Text verstanden.

Beispiel:

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 ax.plot([1,10], [1,10])
 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
             arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0))
 plt.show()

Ausgabe:

[[Datei: PythonIng_ann1.svg|400px]]

&lt;code&gt;shrink&lt;/code&gt; verkürzt den Pfeil. Sinnvoll sind beim obigen Beispiel Werte irgendwo zwischen 0.0 und 0.3.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie verschiedene Pfeillängen aus. 

Die Schriftgröße verändern können Sie übrigens mit &lt;code&gt;fontsize&lt;/code&gt; oder &lt;code&gt;size&lt;/code&gt;, z.B.

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0), fontsize=25)

Eine andere Schreibweise für Dictionaries, die wir weiter oben schon kennengelernt haben, die wir aber nochmals explizit aufschreiben wollen, ist

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops={&quot;facecolor&quot;:&quot;red&quot;, &quot;shrink&quot;:0.0})

=== Figure, Axes etc.===
[[Bild:PythonIng_figure33.svg|350px]]

* fig (figure) ... das übergeordnete Fenster
* ax (axes) ... &quot;Plot&quot;, das eigentliche Zeichenfenster
* axis ... die Koordinatenachsen
* spine ... Begrenzungslinien des Zeichenfensters
* tick ... Markierung an den Achsen des Zeichenfensters

Beispiel (eine figure mit 6 axes, ax-Titel, y-axis-Titel):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=3, ncols=2)
 
 ax[0][0].text(0.1, 0.5, &quot;11&quot;)
 ax[0][1].text(0.1, 0.5, &quot;12&quot;)
 ax[1][0].text(0.1, 0.5, &quot;21&quot;)
 ax[1][1].text(0.1, 0.5, &quot;22&quot;)
 ax[2][0].text(0.1, 0.5, &quot;31&quot;)
 ax[2][1].text(0.1, 0.5, &quot;32&quot;)
 
 ax[0][0].set(ylabel=&quot;y-label&quot;, title=&quot;axes 1&quot;)
 
 plt.show()

[[Bild:PythonIng_figure34.png|350px]]

Beispiel (Achsenbereiche setzen):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 
 ax[0].axis((-1, 10, 1, 12))
 
 plt.show()

[[Bild:PythonIng_figure35.svg|350px]]

Beispiel (Gitter einschalten): 

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 ax[0].axis((-5, 10, 1, 12))
 ax[0].minorticks_on()
 ax[0].grid(which='minor')
 ax[1].grid(which='major')
 plt.show()

[[Bild:PythonIng_figure36.svg|350px]]

Beispiel (ticks setzen)

 import matplotlib.pyplot as plt
 import matplotlib.ticker as tick
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 pos = [0, .2, .5]
 lab = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
 
 ax.xaxis.set_major_locator(tick.FixedLocator(pos))
 ax.xaxis.set_major_formatter(tick.FixedFormatter(lab))
 
 plt.show()

[[Bild:PythonIng_figure37.svg|350px]]

Beispiel (Achsenkreuz beliebig setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 ax.spines['top'].set_color('none')
 ax.spines['right'].set_color('none')
 ax.spines['bottom'].set_position(('data', 0.3))
 ax.spines['left'].set_position(('data', 0.5))
 
 plt.show()

[[Bild:PythonIng_figure38.svg|350px]]

Beispiel (Inset):

 import matplotlib.pyplot as plt
 
 # Hauptplot erstellen
 fig, ax = plt.subplots()
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 
 # Inset hinzu:
 axin = ax.inset_axes([0.4, 0.4, 0.3, 0.3])
 axin.text(0, 0, &quot;Servus&quot;)
 axin.plot()
 
 plt.show()

[[Bild:PythonIng_figure40.svg|350px]]

Beispiel (Hintergrundfarben setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.set_facecolor(&quot;green&quot;)
 fig.set_facecolor(&quot;yellow&quot;)
 
 plt.plot([1, 3], [6, 8])
 plt.show()

[[Bild:PythonIng_figure39.svg|300px]]

=== GridSpec ===
Mit figures und axes lassen sich schon jede Menge an Grafikdetails einstellen. GridSpec ist dann der Turbo oder Raketenantrieb den matplotlib eingebaut hat. Naja, vielleicht ist das etwas übertrieben, aber GridSpec ist sozusagen ein flexibler Layout-Manager. Bisher haben wir immer gleich große axes gezeichnet. Mit GridSpec können wir Subplots über mehrere Zeilen und Spalten ziehen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 gs = fig.add_gridspec(3, 3)
 
 ax1 = fig.add_subplot(gs[0, :])
 ax1.set_title(&quot;Bereich 1: gs[0, :]&quot;)
 
 ax2 = fig.add_subplot(gs[1:, 0])
 ax2.set_title(&quot;Bereich 2: gs[1:, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 1:])
 ax3.set_title(&quot;Bereich 3: gs[1, 1:]&quot;)
 
 ax4 = fig.add_subplot(gs[2, 1:])
 ax4.set_title(&quot;Bereich 4: gs[2, 1:]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec1.svg|350px]]

Erklärung zu &lt;code&gt;(gs[zeile, spalte])&lt;/code&gt;: Slicing; damit legen Sie fest, welche Zellen ein Subplot belegt. Achtung! Die Indizes beginnen bei 0 und nicht bei 1 (d.h., die erste Zeile/Spalte hat den Index 0)
* : ... alle 
* 1: ... 1 bis Ende
* etc.

&lt;code&gt;constrained_layout=True&lt;/code&gt; sorgt dafür, dass sich die Subplots nicht überlappen.

Aber auch die Spaltenbreiten und Zeilenhöhen lassen sich anpassen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 
 # Verhältnis erste zu zweite Zeile = 1.5:1
 # Verhältnis erste zu zweite Spalte  = 1:4
 gs = fig.add_gridspec(2, 2, figure=fig, height_ratios=[1.5, 1], width_ratios=[1, 4])
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax1.set_title(&quot;Bereich 1: gs[0, 0]&quot;)
 
 ax2 = fig.add_subplot(gs[0, 1])
 ax2.set_title(&quot;Bereich 2: gs[0, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 0])
 ax3.set_title(&quot;Bereich 3: gs[1, 0]&quot;)
 
 ax4 = fig.add_subplot(gs[1, 1:])
 ax4.set_title(&quot;Bereich 4: gs[1, 1]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec2.svg|350px]]

Auch die Ränder lassen sich einstellen.

Beispiel 1:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.1, right=0.9, bottom=0.1,
                        top=0.9, wspace=0.2, hspace=0.2)
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec3.svg|300px]]

* hspace ... height space, vertikaler Abstand zwischen den Zeilen
* wspace ... width space, horizontaler Abstand zwischen den Spalten

Und im Vergleich dazu Beispiel 2:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.3, right=0.7, bottom=0.3, 
                        top=0.7, wspace=0.3, hspace=0.3) 
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec4.svg|300px]]

Es gibt noch einige weitere Details, die sich mit GridSpec variieren lassen (z.B. SubGridSpec ... verschachtelte Grid-Layouts). Aber wir belassen es vorerst dabei. Das bisher Gezeigte sollte für die meisten Probleme ausreichend sein.

=== Aufgaben ===
* Zeichnen Sie die Strophoide &lt;math&gt;x = \frac{a(t^2-1)}{t^2+1}, y = \frac{at(t^2-1)}{t^2+1}, a = 2, -3 \leq t \leq 3&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_strophoide.jpg|300px|center]]

* Zeichnen Sie die verschlungene Hypozykloide &lt;math&gt;x = (R-r)\cos t + c\cos\frac{R-r}{r}t, y = (R-r)\sin t - c\sin\frac{R-r}{r}t, c = 3, r = 2, R = 6, -15 \leq t \leq 15&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_hypozykloide.jpg|300px|center]]

* Testen Sie bei den obigen Übungsaufgaben verschiedene Linienstile und Farben. Farben können mit dem plt.plot()-Parameter color gewählt werden.

* Testen Sie bei den obigen Übungsaufgaben verschiedene Werte für a, c, r und R.

* Zeichnen Sie folgendes Bild (die Achsenbeschriftungen positionieren Sie z.B. mit den Befehlen &lt;code&gt;ax.set_xlabel(&quot;x&quot;, loc=&quot;right&quot;); ax.set_ylabel(&quot;y&quot;, loc=&quot;top&quot;)&lt;/code&gt;):

[[Bild:PythonIng_aufgabe24.svg|400px|center]] 

* Zeichnen Sie mit Python, matplotlib und NumPy folgendes Bild:

[[Bild:PythonIng_figure41.svg|400px|center]]

* Zeichnen Sie mit GridSpec ein Layout, das in etwa wie folgendes aussieht (&lt;code&gt;height_ratios=[1, 2], width_ratios=[2, 1]&lt;/code&gt;):

[[Bild:PythonIng_aufgabe23.svg|300px|center]]

== 3D ==
=== Räumliche Kurven ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0, 6*np.pi, 0.1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 z = t
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot(x, y, z)
 
 plt.show()

[[Datei:PythonIng_raumkurve1.png]]

=== Flächen ===
 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche1.png]]

Das Ganze in Netzdarstellung läßt sich so programmieren: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.5)
 y = np.arange(0, 10, 0.5)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_wireframe(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche2.png]]

Ein etwas komplexeres Beispiel:

 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0.1, 10, 0.1)
 y = np.arange(0.1, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z1 = np.sin(x) + 3 * np.cos(y)
 z2 = np.sin(x) + np.log(y)
 z3 = x + np.cos(y)
 z4 = x**2 - y
  
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;}, nrows=2, ncols=2)
 
 ax[0][0].plot_surface(x, y, z1)
 ax[0][1].plot_surface(x, y, z2)
 ax[1][0].plot_surface(x, y, z3)
 ax[1][1].plot_surface(x, y, z4)
 
 plt.show()

[[Datei:PythonIng_subplot1.png]]

Man beachte, dass man die Unterbilder im Bild nach dem Ausführen des Scripts z.B. mit der mittleren Maustaste einzeln drehen, oder über die Einträge in der Menüzeile einzeln bearbeiten kann. Mit ein paar Zeilen Programmtext lässt sich also eine Menge an Funktionalität generieren.

Die Farbgebung lässt sich über &lt;code&gt;colormaps&lt;/code&gt; variieren.

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm)
 
 plt.show()

[[Datei:PythonIng_colormap1.png]]

Es gibt eine Menge an Colormaps, z.B. &lt;code&gt;plasma, Greys, Dark2, ocean&lt;/code&gt;. Zwecks detaillierterer Infos siehe die matplotlib-Dokumentation. &lt;small&gt;Verwendet man die IDE namens IDLE, so gibt es dort auch die automatische Codevervollständigung. D.h. es werden alle Möglichkeiten (in unserem Fall nach dem Eintippen von &lt;code&gt;cm.&lt;/code&gt; alle verfügbaren Colormaps) angezeigt.&lt;/small&gt;

Die &quot;edgecolor&quot; und Linienbreite können auch frei gewählt werden:

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm, edgecolor=&quot;black&quot;, linewidth=1.0)
 
 plt.show()

[[Datei:PythonIng_colormap2.png]]

=== Höhenlinien ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 ax.contour(x, y, z)
 
 plt.show()

[[Datei:PythonIng_höhenlinien1.png|400px]]

Etwas abgewandelt sieht das so aus: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contour(x, y, z)
 ax.clabel(hl, inline = True)
 
 plt.show()

[[Datei:PythonIng_höhenlinien2.png|400px]]

Und noch eine Variante (mit einem Farbbalken) sei gezeigt. 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contourf(x, y, z)
 fig.colorbar(hl) 
 
 plt.show()

[[Datei:PythonIng_höhenlinien5.svg|400px]]

=== Aufgaben ===
* Zeichnen Sie die räumliche Kurve &lt;math&gt;x = 2 \cdot \cosh(t)&lt;/math&gt;, &lt;math&gt;y = 5 \cdot \sin(t)&lt;/math&gt;, &lt;math&gt; z = t^{2} - t&lt;/math&gt;, &lt;math&gt;0 \leq t \leq 3\pi&lt;/math&gt;.
* Zeichnen Sie die Fläche &lt;math&gt;z = \log(x) + \cos(y)&lt;/math&gt;.

== Animationen und fortgeschrittenes 3D ==
=== Mit matplotlib ===
Auch mit matplotlib sind Animationen möglich. Das ist ein bisschen komplizierter und wird deshalb hier nur mit einem sehr einfachen Beispiel dargestellt (bei Interesse siehe z.B. auch das [https://matplotlib.org/stable/users/explain/animations/animations.html#animations Animations using Matplotlib-Tutorial]).

 import matplotlib.pyplot as plt
 import matplotlib.animation as ani
 import matplotlib
 import numpy as np
 
 def update(frame):
     line.set_xdata(x[:frame])
     line.set_ydata(y[:frame])
     return (line)
 
 fig, ax = plt.subplots()
 
 x = np.arange(0, 10, .1)
 y = np.sin(x)
 
 line, = ax.plot(x[0], y[0])
 ax.set(xlim=[0, 10], ylim=[-1, 1])
 
 a = ani.FuncAnimation(fig=fig, func=update, frames=100, interval=20)
 plt.show()
 
 # Speichere die Animation in einem animierten GIF (optional)
 a.save(filename=&quot;c:/tmp/PythonIng_anim5.gif&quot;, writer=&quot;pillow&quot;)

[[Datei:PythonIng_anim5.gif]]

Es wird eine Sinuskurve auf den Bildschirm gezeichnet. In der letzten Zeile wird diese Animation in ein animiertes GIF gespeichert. Das ist natürlich optional und kann auch weggelassen werden.

=== Mit VPython ===
Aber auch mit dem Modul VPython lassen sich einfache 3D-Animationen erstellen. VPython ist ein externes Modul, das vorab installiert werden muss. Unter openSUSE Tumbleweed gibt es dzt. kein entsprechendes rpm-Paket. Die übliche Methode der Installation mittels YaST oder zypper ist somit nicht möglich. Auch eine direkte Verwendung von pip führt nur zu einer Fehlermeldung (&lt;code&gt;error: externally-managed-environment&lt;/code&gt;). Es empfiehlt sich dort folgende Vorgehensweise:
# Erstelle zuerst eine virtuelle Umgebung, z.B.: &lt;code&gt;python3.11 -m venv ~/tmp/venv1&lt;/code&gt;
# Wechsle das Verzeichnis: &lt;code&gt;cd ~/tmp/venv1/bin&lt;/code&gt;
# Installiere das entsprechende Paket: &lt;code&gt;./pip install vpython&lt;/code&gt;
# Führe das entsprechende Skript aus: &lt;code&gt;./python ~/tmp/test1.py&lt;/code&gt;

Aktuell (März 2026) ist dieses Programmpaket lt. der [https://vpython.org/presentation2018/install.html VPython-Homepage] nur für die Python-Versionen 3.8 bis 3.12 verfügbar.

Ein Beispiel zu einer einfachen Animation wird nachfolgend geliefert.

 from vpython import *
 
 scene.width = 1200
 scene.height = 600
 scene.center = vector(20,0,0)
 scene.background = color.white
 
 cylinder(pos=vector(0,0,0), axis=vector(20,0,0), radius=5, 
         color=color.blue)
 cone(pos=vector(0,0,0), axis=vector(-10,0,0), radius=5, 
         color=color.blue)
 helix(pos=vector(20,0,0), axis=vector(40,0,0), radius=2, 
         coils=10, thickness=0.5, color=color.blue)
 
 ball = sphere(pos=vector(20,0,0), color = color.green, radius = 1)
 ball.p = vector(0.15, 0, 0)
 
 toc = True
 
 while True:
     rate(200)
     if(ball.pos.x &lt;= 60 and toc == True):
         ball.pos += ball.p
     else:
         toc = False
         ball.pos -= ball.p
         if(ball.pos.x &lt;= 20 and toc == False):
             toc = True

[[Datei:PythonIng_vpython_anim.JPG]]

Idealerweise öffnet sich beim Ausführen des Scripts ein Browserfenster. Darin wird die programmierte Animation gezeigt (siehe auch den obigen Screenshot). Eine Größenänderung können Sie mit der mittleren Maustaste initiieren. Die Szenerie drehen können Sie mit der rechten Maustaste.

=== Mit build123d ===
Hiermit lassen sich einfach 3D-Modelle für CAD-Systeme erstellen. [https://build123d.readthedocs.io/en/latest/ build123d] ist ein externes Modul und muss vorab, wie schon für mehrere andere Module gezeigt, installiert werden (pip, venv etc.).

Beispielcode:

 from build123d import *
 
 # Bauteil
 with BuildPart() as bauteil: 
     # Zylinder erstellen
     Cylinder(100, 60)
        
     # Bohrung
     with BuildSketch(bauteil.faces().sort_by(Axis.Z)[-1]) as loch:
         Circle(radius=10)
     # negativ extrudieren
     extrude(amount=-60, mode=Mode.SUBTRACT)
     
     # Dem Bauteil z.B. die Farbe rot zuweisen
     # bauteil.part.color = Color(&quot;red&quot;, alpha=1.0)
 
     # Fertiges Modell exportieren
     export_step(bauteil.part, &quot;bauteil.step&quot;)

Ausgabe ({{W|Standard for the exchange of product model data | STEP}}-Datei, z.B. in {{W|FreeCAD}} importiert, Screenshot):

[[Datei:PythonIng_build123d.jpg | 300px]]

FreeCAD ist ein freies 3D-CAD-System. Die [[Ing_Mathematik:_Python#FreeCAD | Makroprogrammierung]] in diesem System wird später noch gezeigt. STEP steht für &quot;'''St'''andard for the '''e'''xchange of '''p'''roduct model data&quot; und ist ein Datenaustauschformat.

=== Mit VTK ===
Komplexer, aber auch mächtiger als VPython ist die Verwendung von VTK ('''V'''isualization '''T'''ool'''k'''it). Genauer gesagt des Python-Wrappers von VTK. Dieses externe Python-Modul muss vorab installiert werden (z.B. mittels YaST, pip oder in eine virtuelle Umgebung). VTK ist eine Softwarebibliothek zur 3D-Visualisierung und wurde ursprünglich in C++ geschrieben. Verbreitet eingesetzt wird diese Bibliothek in der Wissenschaft und Forschung, z.B. 
* in der medizinischen Bildgebung
* für Strömungssimulationen
* für Klimadaten

VTK funktioniert nach dem {{W|Grafikpipeline|Pipeline-Prinzip}}:

 Source (Quellen) -&gt;  Filter -&gt; Mapper (Senken) -&gt; Actor/Renderer

Daten fließen von den Quellen zu den Senken.

Als einfaches Beispiel wird die Darstellung eines Zylinders gezeigt, der mit den Maustasten gedreht oder in der Größe geändert werden kann:

 import vtk
 
 # Zylinder erzeugen
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 # Geometrie in darstellbare Daten umwandeln
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 # Objekt in der Szene
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 # Szene verwalten
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 # Render-Fenster
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 # Maus/Tastatur-Steuerung
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 # Starten
 render_window.Render()
 interactor.Start()

Ausgabe:

[[Datei:PythonIng_VTK_1.png]]

Gleiches Beispiel wie oben, aber mit einer Animationssequenz:

 import vtk
 import time
 
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     render_window.Render()
     time.sleep(0.01)

Das Grafikfenster schließt sich nach Ablauf der Schleife. Das Fenster bleibt geöffnet, wenn Sie am Programmende folgenden Befehl hinschreiben

 interactor.Start()

Um den animierten Zylinder grün einzufärben, müssen Sie Folgendes im obigen Programm ergänzen (Farbnamen):

 colors = vtk.vtkNamedColors()
 actor.GetProperty().SetColor(colors.GetColor3d(&quot;Green&quot;))

Als Namen können Sie u.a. die CSS3 Web-Farben verwenden (siehe z.B. [https://wiki.selfhtml.org/wiki/Farbe/Farbangaben] und {{W|Webfarbe#CSS_3}}).

Alternativ funktioniert auch das ({{W|RGB-Farbraum|RGB}}):

 actor.GetProperty().SetColor(0.0, 0.6, 0.0)

Wie der Zylinder mit einer Textur versehen wird, zeigt folgendes Programm:

 import vtk
 import time
 
 cylinder = vtk.vtkCylinderSource()
 cylinder.SetResolution(30)
 cylinder.SetHeight(3.0)
 cylinder.SetRadius(1.0)
 cylinder.CappingOn()
 
 texture_coords = vtk.vtkTextureMapToCylinder()
 texture_coords.SetInputConnection(cylinder.GetOutputPort())
 texture_coords.PreventSeamOn()
 
 reader = vtk.vtkJPEGReader()
 reader.SetFileName(&quot;PythonIng_textur.jpg&quot;)
 
 texture = vtk.vtkTexture()
 texture.SetInputConnection(reader.GetOutputPort()) 
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(texture_coords.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 actor.SetTexture(texture)
 
 renderer = vtk.vtkRenderer()
 renderWindow = vtk.vtkRenderWindow()
 renderWindow.AddRenderer(renderer)
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(renderWindow)
 
 renderer.AddActor(actor)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     renderWindow.Render()
     time.sleep(0.01)
 
 interactor.Start()

&lt;gallery&gt;
PythonIng_textur.jpg | Textur-Datei
PythonIng_VTK_2.png | Ausgabe (Screenshot)
&lt;/gallery&gt;

== Sonstige Grafikbibliotheken ==
=== Py5 ===
Im Buch ''Iacono et al.: Programmieren trainieren, mit über 150 Workouts in Java und Python; 3. Aufl., Hanser, 2023'' werden zahlreiche Aufgaben gestellt, die u.a. mit Processing zu lösen sind.  Processing ist eine einfache Programmiersprache und Entwicklungsumgebung. Warum ich das erwähne? Weil in älteren Processing-Versionen auch die Programmiersprache Python 2 abgedeckt war. Bei neueren Versionen gibt es keine Python-Anbindung mehr (getestet nur mit openSUSE Tumbleweed und Python 3). Somit funktioniert der Python-Teil im genannten Buch zum Teil nicht mehr. Ist das tragisch, oder kann das Buch weggeschmissen werden? Nein! Es gibt Alternativen zu Processing. Zum einen die im Buch selbst genannten Bibliotheken tkinter oder pygame. Pygame wird dort auch kurz anhand eines Beispiels thematisiert. Aber noch besser ist es, die py5-Bibliothek zu verwenden (lt. Google KI vom 30. Sept. 2026: ''Der echte, moderne „spirituelle Nachfolger“''). Damit ist die Funktionalität von Processing gewährleistet. Man kann aber beliebige Editoren oder IDEs zur Programmerstellung verwenden, ohne an Processing als IDE gebunden zu sein. Nachfolgend werden ein paar Beispiele zu dieser externen Bibliothek gegeben. Der erste Schritt ist wieder, die py5-Bibliothek zu installieren (z.B. mittels pip in eine virtuelle Umgebung; Python&gt;=3.10 und ein JDK&gt;=17 müssen auch installiert sein (Stand Okt. 2026)). Dann kann es schon mit dem Programmieren losgehen.

Beispiel (angelehnt an die ''Aufgabe W.2.3 Haus'' des genannten Buchs, jedoch etwas erweitert):

 import py5
 
 def setup():
     py5.size(600, 600)            # Fenstergröße 600px x 600px 
     py5.background(255, 255, 255) # Hintergrundfarbe ... weiss
     
 def draw():
     # Haus zeichnen
     py5.fill(255, 255, 255)       # Hintergrundfarbe ... weiss
     py5.stroke(255, 0, 0)         # Linienfarbe ... rot 
     py5.stroke_weight(3)          # Linienbreite ... 3px
     py5.rect(150, 200, 300, 300)  # Rechteck zeichnen (x, y, b, h)
     py5.triangle(150, 200, 300, 100, 450, 200) # Dreieck zeichnen
     py5.circle(250, 300, 70)      # Kreis zeichnen (x, y, d)   
     
     # Bemassung zeichnen
     py5.stroke(0, 255, 0)
     py5.stroke_weight(1)
     py5.line(300, 100, 550, 100)  # Linie zeichnen
     py5.line(450, 200, 550, 200) 
     py5.line(450, 500, 550, 500) 
     py5.line(150, 500, 150, 550)
     py5.line(450, 500, 450, 550)
     py5.text_size(20)             # Textgroesse
     py5.fill(0, 255, 0)           # Textfarbe
     py5.text(&quot;300&quot;, 280, 550)     # Text zeichnen
     py5.text(&quot;100&quot;, 500, 150)
     py5.text(&quot;300&quot;, 500, 350)  
 
     # Gedrehtes Rechteck zeichnen
     py5.stroke(255, 255, 0)
     py5.stroke_weight(3)
     py5.fill(200, 200, 200) 
     py5.translate(320, 260)  
     py5.rotate(0.3)               # Drehung (in Radiant)
     py5.rect(0, 0, 100, 50)
 
 # Startet den Sketch
 py5.run_sketch()


Ausgabe:

[[Datei:PythonIng_py5_1.png|300px]]

Das skizzierte Haus ist mit einer rudimentären Bemaßung versehen und hat zwei Fenster, ein rundes und ein gedrehtes, trübes rechteckiges. 

Beispiel (Mausoperationen):

 import py5
 
 def setup():
     py5.size(600, 600)            
     py5.background(255, 255, 255)
 
 def draw():
     pass
    
 def mouse_pressed():
     py5.text_size(15) 
     py5.fill(0, 0, 255)
     x = py5.mouse_x
     y = py5.mouse_y
     py5.text(&quot;(%d, %d)&quot; %(x, y), x, y) # Positionsdaten bei Maus-Klick schreiben
 
 py5.run_sketch()

Ausgabe:

[[Datei:PythonIng_py5_2.png|300px]]

Obiges Bild zeigt das Resultat nach einigen Mausklicks. Man erkennt, dass links-oben der Koordinatennullpunkt ist. Die x-Achse zeigt nach rechts, die y-Achse nach unten.

Beispiel (Fünfeck):

 import py5
 import random 
 
 def setup():
     py5.size(400, 400)
     py5.no_loop()       # statisches Bild (schont die Ressourcen)
 
 def draw():
     py5.translate(py5.width / 2, py5.height / 2)  # KS setzen
 
     radius = 150
     eck_anzahl = 5
 
     py5.fill(random.randint(0, 255), random.randint(0, 255), 
              random.randint(0, 255))    # Füllfarbe auf Zufallswert setzen
     py5.stroke(155, 0, 0)            
     py5.stroke_weight(5)     
     
     # Fünfeck als Polygon zeichnen
     py5.begin_shape()
     for i in range(eck_anzahl):
         winkel = i * py5.TWO_PI / eck_anzahl - py5.HALF_PI
         x = py5.cos(winkel) * radius
         y = py5.sin(winkel) * radius
         py5.vertex(x, y)
     py5.end_shape(py5.CLOSE)
 
 py5.run_sketch()

Ausgabe, bspw.:

[[Datei:PythonIng_py5_5.png|200px]]

&lt;u&gt;Kleine Aufgaben:&lt;/u&gt;
* Um die Funktionsweise von &lt;code&gt;py5.no_loop()&lt;/code&gt; zu verstehen, kommentieren Sie die Anweisung im Beispiel einfach aus, und starten Sie das Programm erneut.
* Zeichnen Sie ein Siebeneck.
* Was passiert, wenn man &lt;code&gt;py5.CLOSE&lt;/code&gt; im &lt;code&gt;py5.end_shape()&lt;/code&gt;-Befehl weglässt?

Beispiel (Grafik laden und zeichnen):

 import py5
 
 image1 = None
 
 def setup():
     global image1
     py5.size(600, 600)
     py5.no_loop()
     image1 = py5.load_image(&quot;PythonIng_py5_1.png&quot;)
 
 def draw():
     py5.image(image1, 0, 0)
 
 py5.run_sketch()

Hier wird einfach das Bild vom Haus-Beispiel (Screenshot von weiter oben) geladen und gezeichnet.

Beispiel (angelehnt an ''W.5.10 Wurfparabel'' des genannten Buches; mit OOP erstellt):

 import py5
 
 class Wurfparabel(py5.Sketch):
     def __init__(self, v0, angle):
         super().__init__()
         self.v0 = v0
         self.angle = self.radians(angle)
         self.g = 9.81
         self.t = 0.0
         self.scale = 1.5
 
     def settings(self):
         self.size(800, 600)
 
     def setup(self):        
         self.background(0, 0, 0)
         
     def draw(self):
         self.t += 0.1
 
         self.translate(50, 500)
       
         # KS Zeichnen
         self.fill(255, 255, 0)
         self.stroke(255, 255, 0)
         self.stroke_weight(1)
         self.line(0, 0, 0, -300)
         self.line(0, 0, 700, 0)
 
         # Punkt zeichnen
         cx = self.v0 * self.cos(self.angle) * self.t * self.scale
         cy = -(self.v0 * self.sin(self.angle) * self.t - \
                self.g/2 * self.t**2) * self.scale
         self.fill(255, 0, 0)
         self.stroke(255, 0, 0)
         self.circle(cx, cy, 3)
        
         # Stoppen bei Bodenkontakt
         if cy &gt;= -5:
             self.no_loop()
            
 def wurfparabel(v0=50, angle=45):
     sketch = Wurfparabel(v0, angle)
     sketch.run_sketch()
 
 v0 = float(input(&quot;v0 = &quot;))
 winkel = float(input(&quot;winkel = &quot;))
 wurfparabel(v0=v0, angle=winkel)

Eingabe auf der Konsole:

 v0 = 60
 winkel = 45

Ausgabe:

[[Datei:PythonIng_py5_13.png|200px]]

Die benötigten Formeln der Bewegungsgleichung kann man leicht herleiten, bzw. man benutzt folgende Grafik als Hilfestellung:

[[Datei:Wurfparabel_Zusammenfassung_aktualisierung.png|700px]]

&lt;u&gt;Aufgabe:&lt;/u&gt; Berechnen Sie den Scheitelpunkt und die Wurfweite bei gegebener Anfangsgeschwindigkeit und gegebenem Abwurfwinkel. Die Abwurfhöhe &lt;math&gt;y_0&lt;/math&gt; sei 0. Der Wurf soll auf der Erde stattfinden (g = 9.81 m/s²). Die dazu benötigten Formeln können aus obiger Grafik entnommen werden (oder Sie leiten sie selbst her). Geben Sie die Ergebnisse auf der Konsole aus.

Beispiel (eine einfache Animation):

 import py5
 
 i = 0
 
 def setup():
     py5.size(600, 600)
     py5.frame_rate(5)
     py5.stroke_weight(20)
 
 def draw():
     global i
     
     py5.background(255, 255, 255)
     py5.translate(py5.width/2, py5.height/2)
     py5.rotate(py5.PI/8 * i)    
 
     py5.line(-100, 0, 100, 0)
     i += 1
 
 py5.run_sketch()

Es wird eine rotierende Linie gezeichnet (z.B. wie bei einem Installationsprozess verwendet - zeigt an, dass der Installationsfortschritt nicht eingefroren ist). Hierbei ist nur aufzupassen, dass der Hintergrund in &lt;code&gt;draw()&lt;/code&gt; gesetzt wird, ansonsten würden die Linien additiv gezeichnet. Das ist zwar auch schön, aber eben nicht das gewünschte Resultat.

Hiermit belassen wir es mit der py5-Bibliothek und wenden uns wieder &quot;mathematischeren&quot; Themen zu.

= Vektoren und Matrizen =
== Zahlenfolgen ==
Für das Erstellen von Zahlenfolgen bieten sich die Funktionen &lt;code&gt;arange&lt;/code&gt; und &lt;code&gt;linspace&lt;/code&gt; aus dem &lt;code&gt;numpy&lt;/code&gt;-Modul an.

 from numpy import *
 
 start = 0
 stop = 10
 step = 2
 num = 10
 
 r = arange(start, stop, step)   # step ... Schrittweite
 l = linspace(start, stop, num)  # num ... Anzahl der Werte
 
 print(&quot;r = &quot;, r)
 print(&quot;l = &quot;, l)

Ausgabe:
 r =  [0 2 4 6 8]
 l =  [ 0.          1.11111111  2.22222222  3.33333333  4.44444444  5.55555556
   6.66666667  7.77777778  8.88888889 10.        ]

Bei &lt;code&gt;arange&lt;/code&gt; ist der &lt;code&gt;stop&lt;/code&gt;-Wert nicht im Ergebnis enthalten, bei &lt;code&gt;linspace&lt;/code&gt; standardmäßig aber sehr wohl. Jedoch kann man das bei &lt;code&gt;linspace&lt;/code&gt; auch ändern. Dann ist der Stoppwert nicht mehr enthalten: 

 linspace(start, stop, num, endpoint=False)

== Vektoren ==
Vektoren sollten jedem aus der Linearen Algebra bekannt sein. 

=== Arrays ===
In Python mit NumPy kann man Vektoren durch die Funktion array erzeugen.

 import numpy as np
 
 l1 = (-5, 3, 2)
 l2 = (1, 1, 4)
 
 a1 = np.array(l1)
 a2 = np.array(l2)
 
 a3 = a1 + a2
 a4 = 2 * a2
 
 print(a1)
 print(a2)
 print(a3)
 print(a3[2])
 print(a4)

Ausgabe:
 [-5  3  2]
 [1 1 4]
 [-4  4  6]
 6
 [2 2 8]

=== Zeilen- und Spaltenvektoren ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 print(z)
 print(s)

Ausgabe:
 [ [-5  3  2] ]
 [[1]
  [1]
  [4]]

=== Skalarprodukt ===
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4))
 
 skalarprodukt = np.dot(a1, a2)  
 
 print(skalarprodukt)

Ausgabe:
 6

=== Vektorprodukt ===
&lt;math&gt;a\ast b=\left(\begin{array}{c}
a_{1}\\
a_{2}\\
a_{3}
\end{array}\right)\ast\left(\begin{array}{c}
b_{1}\\
b_{2}\\
b_{3}
\end{array}\right)=\left(\begin{array}{c}
a_{2}b_{3}-a_{3}b_{2}\\
a_{3}b_{1}-a_{1}b_{3}\\
a_{1}b_{2}-a_{2}b_{1}
\end{array}\right)
&lt;/math&gt; 

Python-Code:
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4)) 
 
 vektorprodukt = np.cross(a1, a2) 
 
 print(vektorprodukt)

Ausgabe:
 [10 22 -8]

=== Transponierter Vektor ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 # transponierter Vektor
 z_tp = np.transpose(z)
 # transponierter Vektor
 s_tp = np.transpose(s)
 
 print(z_tp)
 print(s_tp)

Ausgabe:
 [[-5]
  [ 3]
  [ 2]]
 [ [1 1 4] ]

=== Vektorfelder visualisieren ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 # Daten generieren
 x = np.arange(0, 10, 1)
 y = np.arange(0, 10, 1)
 X, Y = np.meshgrid(x, y)
 U = X * Y
 V = Y + X
 
 # Plotten
 fig, ax = plt.subplots()
 
 ax.quiver(X, Y, U, V, angles='xy')
 
 plt.show()

Ausgabe:

[[Datei:PythonIng_quiver1.png]]

== Matrizen==
 import numpy as np
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 print(m1)

Ausgabe:
 [[1 2 3]
  [4 5 6]]

=== Zugriff auf Matrizenelemente ===
Beispiel:

 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 
 # Element aus Zeile 2 und Spalte 3 (Achtung! Index startet bei Null)
 print(m1[1,2])

Ausgabe:
 6

Visualisierung:
  
     0   1   2
   +-----------+
 0 | 1 | 2 | 3 |
   +-----------+
 1 | 4 | 5 | '''6''' |
   +-----------+


Beispiel:

 import numpy as np
 
 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
 
 B = np.matrix(A)     
 
 print(B[2::, ::2])

Ausgabe:

 [['20' '22']
  ['30' '32']
  ['40' '42']]

Mit der NumPy-Bibliothek funktioniert das zweidimensionale Slicing. Mit normalen Listen/Tupels geht das nicht, was wir schon früher thematisiert haben.

=== Addition und Subtraktion von Matrizen ===
 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 m2 = np.matrix([[0, 0, 2], [1, 3, 2]])
 
 print(m1 + m2)
 print(m1 - m2)

Ausgabe:
 [[1 2 5]
  [5 8 8]]
 [[1 2 1]
  [3 2 4]]

=== Transponierte Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 2, 3], [4, 5, 6]])
 mt = np.transpose(m) 
 
 print(m)
 print(mt)

Ausgabe:
 [[1 2 3]
  [4 5 6]]
 [[1 4]
  [2 5]
  [3 6]]

=== Rang einer Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 rg = np.linalg.matrix_rank(m)
 
 print(rg)

Ausgabe:
 2

=== Inverse Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 mi = np.linalg.inv(m)
 
 print(mi)

Ausgabe:
 [[ 1.   0.6]
  [-0.  -0.2]]

=== Multiplikation von Matrizen (falksches Schema) ===
 import numpy as np
 
 m1 = np.matrix([[1, 3, 4],  [0, -5, 1]])
 m2 = np.matrix([[1, 2], [2, 3], [0, 2]])
 
 print(m1 @ m2)

Ausgabe:
 [[  7  19]
  [-10 -13]]

=== Eigenwerte und Eigenvektoren ===
 import numpy as np
 
 m = np.matrix([[5, 8],  [1, 3]])
 D,V = np.linalg.eig(m)
 
 # Eigenwerte
 print(D)
 # Eigenvektoren
 print(V)

Ausgabe:
 [7. 1.]
 [[ 0.9701425  -0.89442719]
  [ 0.24253563  0.4472136 ]]

=== Teilmatrizen ===
 import numpy as np
 m = np.matrix([[1, 3, 4],  [0, -5, 1]])
 print(&quot;m = &quot;, m)
 
 # Erste Zeile extrahieren
 m1 = m[0,:]
 print(&quot;m1 = &quot;, m1)
 
 # Das Element aus der 1. Zeile und der 2. Spalte extrahieren
 m2 = m[0,1]
 print(&quot;m2 = &quot;, m2)
 
 # Zweite Spalte extrahieren
 m3 = m[:, 1]
 print(&quot;m3 = &quot;, m3)

Ausgabe:
 m =  [[ 1  3  4]
  [ 0 -5  1]]
 m1 =  [ [1 3 4] ]
 m2 =  3
 m3 =  [[ 3]
  [-5]]

=== Spezielle Matrizen ===
==== Nullmatrix ====
 import numpy as np
 z = np.zeros((3, 2))
 print(z)

Ausgabe:
 [[0. 0.]
  [0. 0.]
  [0. 0.]]

==== Einheitsmatrix ====
 import numpy as np
 z = np.eye(3)
 print(z)

Ausgabe:
 [[1. 0. 0.]
  [0. 1. 0.]
  [0. 0. 1.]]

==== Matrix mit lauter Einsen ====
 import numpy as np
 z = np.ones((3, 2))
 print(z)

Ausgabe:
 [[1. 1.]
  [1. 1.]
  [1. 1.]]

=== Spärlich besetzte Matrizen ===
Das Thema spärlich besetzter Matrizen wird hier nur kurz angerissen. Nähere Details siehe unter dem Weblink  [https://docs.scipy.org/doc/scipy/reference/sparse.html#module-scipy.sparse]. 

Beispiel:

 import numpy as np
 import scipy
 
 A = scipy.sparse.csr_array(np.eye(5))
 
 print(A)

Ausgabe:
 &lt;Compressed Sparse Row sparse array of dtype 'float64'
         with 5 stored elements and shape (5, 5)&gt;
   Coords        Values
   (0, 0)        1.0
   (1, 1)        1.0
   (2, 2)        1.0
   (3, 3)        1.0
   (4, 4)        1.0

csr steht für '''c'''ompressed '''s'''parse '''r'''ow.

Andere Möglichkeiten:
* coo-Format ('''coo'''rdinate Format): &lt;code&gt;scipy.sparse.coo_array()&lt;/code&gt;
* lil-Format ('''li'''st of '''l'''ists): &lt;code&gt;scipy.sparse.lil_array()&lt;/code&gt;
* csc-Format ('''c'''ompressed '''s'''parse '''c'''olumn): &lt;code&gt;scipy.sparse.csc_array()&lt;/code&gt;

Es gibt auch &lt;code&gt;scipy.sparse.csr_matrix()&lt;/code&gt; etc. Diese Befehle sind aber veraltet und es wird empfohlen, statt dessen die &lt;code&gt;..._array()&lt;/code&gt;-Funktionen zu verwenden.

&lt;u&gt;Aufgaben:&lt;/u&gt; 
Recherchieren Sie im Internet 
* generell zum Thema &quot;spärlich besetzte Matrizen mit Python&quot;.
* Was sind die Vor-/Nachteile von csr-arrays gegenüber coo- und lil-arrays?
* Wann verwendet man sinnvollerweise csr- und wann csc-arrays?
* Wie wandelt man coo-arrays in csr-arrays um?

= Lineare Gleichungssysteme =
Sei &lt;math&gt;Ax = b&lt;/math&gt; ein lineares Gleichungssystem. &lt;math&gt;A&lt;/math&gt; sei die Koeffizientenmatrix, &lt;math&gt;x&lt;/math&gt; der Lösungsvektor und &lt;math&gt;b&lt;/math&gt; ein bekannter Vektor.

Beispiel:
 import numpy as np
 
 A = np.array([[5, 1], [0, 2]])
 b = np.array([1, 2])
 
 x = np.linalg.solve(A, b)
 
 print(x)

Ausgabe:
 [0. 1.]

Siehe dazu auch das Kapitel [[Ing Mathematik: Numerisches Lösen von linearen Gleichungssystemen]]. Dort wird dieses Themengebiet u.a. mit weitergehenden Python-Skripten vertieft.

== Aufgabe ==
* Lösen Sie folgendes Gleichungssystem mittels Python (und zur Kontrolle auch händisch): 
 5x + 6y - 2z = 12
 3x - y  - 3z = 6
 2x + 2y + 4z = 5

= Polynome =
== Ein erstes einfaches Beispiel ==
Gegeben sei das Polynom &lt;math&gt;7x^3+5x^2+1&lt;/math&gt;. In Python:

 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p)

Ausgabe:
    3     2
 7 x + 5 x + 1

== Einzelne Polynomwerte berechnen ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p(1.5))

Ausgabe:
 35.875

== Polynome integrieren und differenzieren ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 
 # 1. Ableitung
 p1 = p.deriv()
 p2 = p.deriv(1)
 
 # 2. Ableitung
 p3 = p.deriv(2)
 
 # Integral
 p4 = p.integ()
 
 print(p1)
 print(p2)
 print(p3)
 print(p4)

Ausgabe:
     2
 21 x + 10 x
     2
 21 x + 10 x
 
 42 x + 10
       4         3
 1.75 x + 1.667 x + 1 x

== Nullstellen bestimmen ==
 import numpy as np
 
 p = np.poly1d([2, 5, 0, 4])
 r = np.roots(p)
 
 print(r)

Ausgabe:
 [-2.7621427 +0.j          0.13107135+0.84077099j  0.13107135-0.84077099j]

== Aufgaben ==
* Berechnen Sie den Wert für x = 3 des Polynoms &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Differenzieren und integrieren Sie das Polynom &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Berechnen Sie die Nullstellen von &lt;math&gt;y = 7x^5 - 3x^2 + 12&lt;/math&gt;.

= Nichtlineare Gleichungen und Gleichungssysteme =
== Nullstellenbestimmung ==
Löse eine beliebige Gleichung f(x) = 0, z.B. &lt;math&gt; f(x) = x^2 - 5\cos(x) - 10 = 0 &lt;/math&gt;:
 import scipy
 import numpy as np
 
 def f(x):
     return x**2 - 5*np.cos(x) - 10
    
 xstart = [-1, 1]        # Startwerte
 xn = scipy.optimize.root(f, xstart)
 
 print(xn.x)

Ausgabe:
 [-2.46813009  2.46813009]

Funktionsgraph:

[[Datei:octave_nichtlin2.jpg]]

== Gleichungssysteme ==
SymPy ist ein externes Modul, das symbolisches Rechnen ('''Sym'''bolic '''Py'''thon) ermöglicht. 

Folgende Aufgabe ist dem Buch &quot;Knorrenschild: Numerische Mathematik, Hanser, 2017, Seite 72&quot; entnommen. Zu lösen ist das nichtlineare Gleichungssystem

&lt;math&gt;f_1 = 2x_1 + 4x_2 = 0 &lt;/math&gt;

&lt;math&gt;f_2 = 4x_1 + 8x_2^3 = 0&lt;/math&gt;

Mit Python ist das so möglich:
 import sympy
 
 x1, x2 = sympy.symbols(&quot;x1 x2&quot;) 
 
 f1 = 2*x1 + 4*x2
 f2 = 4*x1 + 8*x2**3
 
 s = sympy.solve((f1, f2), x1, x2) 
 
 print(s)

Ausgabe:
 [(-2, 1), (0, 0), (2, -1)]

Plot:

[[Datei:IngPython_nl_gleichung1.svg|500px]]

= Komplexe Zahlen =
Die imaginäre Einheit wird in Python durch den Buchstaben &lt;code&gt;j&lt;/code&gt; symbolisiert. Darstellen kann man eine komplexe Zahl bekannterweise in mehreren Formen:
* Kartesische Darstellung &lt;math&gt;z = \Re(z) + j \cdot \Im(z)&lt;/math&gt;
* Polardarstellungen &lt;math&gt;z = r \cdot (\cos(\phi) + j \cdot \sin(\phi)) = r \cdot e^{j\cdot \phi}&lt;/math&gt;

Die konjugiert komplexe Zahl ist &lt;math&gt;z^* = \Re(z) - j \cdot \Im(z)&lt;/math&gt;

Nachfolgend einige mathematische Operationen mit Python und NumPy.

 import numpy as np
 
 z1 = 2 + 5j           # kartesische Darstellung
 z2 = 3 * np.exp(3j)   # Polardarstellung
  
 # Addition
 res = z1 + z2
 print(&quot;z1 + z2 = &quot;, res)
 
 # Multiplikation
 res = z1 * z2
 print(&quot;z1 * z2 = &quot;, res)
 
 # Realteil
 res = np.real(z2)
 print(&quot;Realteil von z2 = &quot;, res)
 
 # Imaginärteil
 res = np.imag(z2)
 print(&quot;Imaginaerteil von z2 = &quot;, res)
 
 # Betrag
 res = np.abs(z1)
 print(&quot;Betrag von z1 = &quot;, res)
 
 # Argument
 res = np.angle(z1)
 print(&quot;Argument von z1 = &quot;, res)
 
 # Konjugiert komplexe Zahl
 res = np.conj(z1)
 print(&quot;Konjugiert komplexe Zahl von z1 = &quot;, res)

Ausgabe:
 z1 + z2 =  (-0.9699774898013365+5.423360024179601j)
 z1 * z2 =  (-8.05675510050068-14.003167400647481j)
 Realteil von z2 =  -2.9699774898013365
 Imaginaerteil von z2 =  0.4233600241796016
 Betrag von z1 =  5.385164807134504
 Argument von z1 =  1.1902899496825317
 Konjugiert komplexe Zahl von z1 =  (2-5j)

= Interpolation =
 import numpy as np
 import scipy
 import matplotlib.pyplot as plt
 
 # Stützpunkte
 xp = np.arange(1, 6)
 yp = (0, -5, 2, 7, 6)
 
 ti = np.arange(1, 5, 0.01)
 
 i1 = scipy.interpolate.interp1d(xp, yp, kind = &quot;linear&quot;)
 i2 = scipy.interpolate.interp1d(xp, yp, kind = &quot;cubic&quot;) 
 
 plt.plot(xp, yp, &quot;rx&quot;)
 plt.plot(xp, i1(xp))
 plt.plot(ti, i2(ti))
 plt.show()

Ausgabe:

[[Datei:PythonIng_interpol1.png]]

= Differenzialrechnung =
== Numerisches Differenzieren ==
Als Beispiel differenzieren wir &lt;math&gt;y = 5x\sin{x}&lt;/math&gt; und stellen das Ganze grafisch dar.

 from findiff import Diff
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.linspace(0, 10, 1000)
 f = 5 * x * np.sin(x)
 dx = x[1] - x[0]
 
 # Ableitung
 d_dx = Diff(0, dx)
 df_dx = d_dx(f)
 
 # Grafik
 plt.plot(x, f, label = &quot;y&quot;)
 plt.plot(x, df_dx, label = &quot;y'&quot;)
 plt.grid()
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

Ausgabe:

[[Datei:octave_diff1.jpg]]

&lt;small&gt;findiff ist ein externes Modul. Dieses muss installiert werden (z.B. so: ...\Python\Scripts\pip.exe install --upgrade findiff). Für die Vorgehensweise unter openSUSE Tumbleweed siehe das Kapitel [[Ing_Mathematik:_Python#Mit_VPython | VPython]], nur dass das Ganze mit einer aktuelleren Python-Version exekutiert wird, z.B. mit Python 3.13.  Das im Buch &quot;Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler, Rheinwerk&quot; verwendete Modul &quot;scipy.misc&quot; ist veraltet (deprecated ... missbilligt). Lt. [https://docs.scipy.org/doc/scipy-1.17.0/dev/roadmap-detailed.html#misc SciPy-Dokumentation für die Version 1.17.0] wurden alle entsprechenden Features schon entfernt.&lt;/small&gt;

== Symbolisches Differenzieren ==
Differenzieren Sie die Funktionen &lt;math&gt;f_1(x) = x^2&lt;/math&gt; und &lt;math&gt;f_2(x) = \sin(x)\cos\left(\frac{x}{2}\right)&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2;
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 d1 = sympy.diff(f1, x)
 d2 = sympy.diff(f2, x)
 
 print(d1)
 print(d2)

Ausgabe:
 2*x
 -0.5*sin(0.5*x)*sin(x) + cos(0.5*x)*cos(x)

== Aufgaben ==
* Differenzieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.
* Differenzieren Sie die Funktion &lt;math&gt;y = \frac{\sinh(x)}{(1+x)}&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.

= Integralrechnung =
== Numerisches Integrieren ==
Berechnen Sie das Integral &lt;math&gt;\int_{0}^{3}x^2 dx&lt;/math&gt;.

 import scipy
 
 def f(x):
     return x**2
    
 i = scipy.integrate.quad(f, 0, 3)
 print(i)

Ausgabe:
 (9.000000000000002, 9.992007221626411e-14)

Das trifft den exakten Wert 9.0 ziemlich genau.

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} dx&lt;/math&gt;.

 import scipy
 import numpy as np
 
 def f(x):
     return 2**(-x)
   
 i = scipy.integrate.quad(f, 0, np.inf)
 print(i)

Ausgabe:
 (1.4426950408889556, 4.486558477977586e-09)

== Symbolisches Integrieren ==
Berechnen Sie &lt;math&gt;\int x^2 \text{d}x&lt;/math&gt; und &lt;math&gt;\int \sin{x}\cos{\frac{x}{2}} \text{d}x&lt;/math&gt;.
 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 i1 = sympy.integrate(f1, x)
 i2 = sympy.integrate(f2, x)
 
 print(i1)
 print(i2)

Ausgabe:
 x**3/3
 -0.666666666666667*sin(0.5*x)*sin(x) - 1.33333333333333*cos(0.5*x)*cos(x)

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} \text{d}x&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f = 2**(-x)
 i = sympy.integrate(f, (x, 0, sympy.oo))
 print(i)

Ausgabe:
 1/log(2)

&lt;code&gt;sympy.oo&lt;/code&gt; steht für das {{W|Unendlichzeichen}} &lt;math&gt;\infty&lt;/math&gt; (die liegende Acht oder das Möbiusband). Mit &lt;code&gt;sympy.pprint(i)&lt;/code&gt; ließe sich letzere Ausgabe etwas schöner schreiben:

   1   
 ──────
 log(2)

Man beachtete, &lt;code&gt;log&lt;/code&gt; steht hier für den natürlichen Logarithmus &lt;code&gt;ln&lt;/code&gt;.

== Aufgaben ==
* Integrieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; von 1 bis 5.
* Integrieren Sie die Funktion &lt;math&gt;y = x^3&lt;/math&gt; von 0 bis 4.
* Integrieren Sie &lt;math&gt;\int x^x(\log (x) + 1)\mathrm dx&lt;/math&gt; symbolisch.

= Gewöhnliche Differenzialgleichungen =
== DGL numerisch lösen ==
Für die Lösung von Differenzialgleichungen steht u.a. die Funktion scipy.integrate.solve_ivp() zur Verfügung. Diese Funktion implementiert auch das Runge-Kutta-Verfahren (RK45).

{{Wikipedia | Runge-Kutta-Verfahren}}

Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import scipy
 import numpy as np
 import matplotlib.pyplot as plt
 
 def dy_dx(x, y):
     return x**2 + y**3
 
 y0 = [1]
 xi = [0, 1]
 x = np.arange(0, 1, 0.01)
 
 z = scipy.integrate.solve_ivp(dy_dx, xi, y0, method=&quot;RK45&quot;, dense_output=True)
 y = z.sol(x)
 
 plt.plot(x, y.T)
 plt.grid()
 plt.show()

[[Datei:PythonIng_dgl1.png]]

== DGL symbolisch lösen ==
Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 print(lsg)

Ausgabe:
 [Eq(f(x), (-x**2)**(1/3)), Eq(f(x), (-x**2)**(1/3)*(-1 - sqrt(3)*I)/2), Eq(f(x), (-x**2)**(1/3)*(-1 + sqrt(3)*I)/2)]

Mit &lt;code&gt;sympy.pprint&lt;/code&gt; (pretty print) lässt sich die Ausgabe etwas übersichtlicher darstellen.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 sympy.pprint(lsg)

Ausgabe:
 ⎡                           _____                        _____            ⎤
 ⎢          _____         3 ╱   2                      3 ╱   2             ⎥
 ⎢       3 ╱   2          ╲╱  -x  ⋅(-1 - √3⋅ⅈ)         ╲╱  -x  ⋅(-1 + √3⋅ⅈ)⎥
 ⎢f(x) = ╲╱  -x  , f(x) = ────────────────────, f(x) = ────────────────────⎥
 ⎣                                 2                            2          ⎦

== Aufgaben ==
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \frac{1}{x\cdot y}&lt;/math&gt; mit Python. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;m' = -k\cdot m&lt;/math&gt;. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \sqrt{|y|}&lt;/math&gt;.

=Laplace-Transformation=
Laplace-Transformation:

&lt;math&gt;F(s) =\mathcal{L} \left\{f\right\}(s) = \int_{0}^{\infty} f(t) \mathrm e^{-st} \,\mathrm{d}t, \qquad s\in\mathbb{C}
&lt;/math&gt;

Inverse Laplace-Transformation:

&lt;math&gt;\mathcal{L}^{-1} \left\{F\right\}(t)
  = \frac{1}{2 \pi \mathrm j} \int_{ \gamma - \mathrm j \infty}^{ \gamma + \mathrm j \infty} \mathrm e^{st} F(s)\,\mathrm ds 
= \begin{cases}
      f(t) &amp; \text{für } t \geq 0 \\
      0    &amp; \text{für } t &lt; 0
    \end{cases}
&lt;/math&gt;

Siehe auch [[Ing_Mathematik:_Laplace-Transformation]]

Code:
 import sympy
 from sympy.abc import t, s
 
 # Laplace-Transformation der Funktion f(t) = 1 (Heaviside-Fkt.)
 f = 1
 # alternativ: f = sympy.Heaviside(t)
 F = sympy.laplace_transform(f, t, s, noconds=True)
 print(&quot;Laplace-Transformierte F(s):&quot;, F) 
 
 # Inverse Laplace-Transformation zurück in den Zeitbereich
 f_inv = sympy.inverse_laplace_transform(F, s, t)
 print(&quot;Inverse Transformation f(t):&quot;, f_inv)

Ausgabe:
 Laplace-Transformierte F(s): 1/s
 Inverse Transformation f(t): Heaviside(t)

Die Zeile

 from sympy.abc import t, s

steht alternativ für

 t = sympy.symbols(&quot;t&quot;)
 s = sympy.symbols(&quot;s&quot;)

&lt;u&gt;Aufgaben&lt;/u&gt;: Ermitteln Sie mittels SymPy die &lt;math&gt;\mathcal{L}&lt;/math&gt;-Transformierten und dann wieder die  &lt;math&gt;\mathcal{L}^{-1}&lt;/math&gt;-Transformationen (ähnlich wie beim obigen Beispiel):
* &lt;math&gt;\sin(t) \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;t^3 \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;\text{e}^{\omega t} \circ\! -\! \bullet \ ?&lt;/math&gt;

=Fourier-Reihen=
&lt;math&gt;
f(x)\approx \frac{a_{0}}{2}+\sum_{k=1}^{\infty}\left(a_{k}\cos\left(kx\right)+b_{k}\sin\left(kx\right)\right)
&lt;/math&gt;

&lt;math&gt;
a_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\cos\left(kx\right)\mathrm dx\quad\text{für }k\geq0
&lt;/math&gt;

&lt;math&gt;
b_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\sin\left(kx\right)\mathrm dx\quad\text{für }k\geq1
&lt;/math&gt;

Für die Sägezahnfunktion &lt;math&gt;y=x;\, 0 &lt; x &lt; 2\pi&lt;/math&gt; sei die Fourierreihe mit einem Python-Programm (unter Mithilfe von sympy) hergeleitet.

Code:

 from sympy import fourier_series, pi, symbols, pprint
 
 x = symbols('x')
 f = x
 s = fourier_series(f, (x, 0, 2*pi))
 pprint(s.truncate(n=4))

Ausgabe:

                        2⋅sin(3⋅x)    
 -2⋅sin(x) - sin(2⋅x) - ────────── + π
                            3

Siehe auch [[Ing Mathematik: Fourierreihen]].

Ein komplizierteres Beispiel:

[[Datei:IngMath fourier bsp13.svg | 300px]]

&lt;math&gt;0\le t &lt; T/2\text{:}\quad f(t) = H&lt;/math&gt;

&lt;math&gt;T/2 \le t \le T\text{:}\quad f(t) = \frac{2H}{T}\left( t-\frac{T}{2}\right)&lt;/math&gt;

Code:

 import sympy as sp
 
 H = sp.Symbol('H', positive=True)
 T = sp.Symbol('T', positive=True)
 t = sp.Symbol('t')
 
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T/2)),
     (2*H/T*(t-T/2), (t &gt; T/2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Ausgabe:

      ⎛2⋅π⋅t⎞        ⎛4⋅π⋅t⎞        ⎛6⋅π⋅t⎞          ⎛2⋅π⋅t⎞          ⎛6⋅π⋅t⎞      
 H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   2⋅H⋅cos⎜─────⎟   2⋅H⋅cos⎜─────⎟      
      ⎝  T  ⎠        ⎝  T  ⎠        ⎝  T  ⎠          ⎝  T  ⎠          ⎝  T  ⎠   3⋅H
 ──────────── - ──────────── + ──────────── + ────────────── + ────────────── + ───
      π             2⋅π            3⋅π               2                 2         4 
                                                    π               9⋅π

=Rechnen mit wirklich großen Zahlen=
Bekannt ist, dass Python kaum Einschränkungen beim Wertebereich von Ganzzahlen hat, z.B.

 print(10**300)

Ausgabe (gekürzt):

 100000000000000000000...00000000000000000000000000000000000000000000000000000000000000000000000

Ähnliches geht auch mit Gleitpunktzahlen, z.B. durch die Verwendung des Moduls [https://mpmath.org/ mpmath]:

 import mpmath
 print(mpmath.mpf(1500.4)**mpmath.mpf(300))

Ausgabe:

 7.27975299218612e+952

Anderes Beispiel:

 from mpmath import mp, pi
 mp.dps = 100
 print(pi)

Ausgabe:

 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068

mpmath kann noch einiges mehr, dazu sei aber auf die entsprechende Dokumentation auf der mpmath-Homepage verwiesen. mpmath ist Bestandteil von SymPy, kann aber auch separat installiert werden.

Aber auch Python selbst besitzt eine Möglichkeit, um mit großen bzw. exakten Gleitpunktzahlen zu rechnen, nämlich das interne Modul decimal. Dieses hat einige Vorteile gegenüber mpmath, aber auch gravierende Nachteile. Diese seien hier nicht detailliert aufgezählt. Grob gesagt hat decimal im Finanzwesen seine Berechtigung. Für wissenschaftliche Anwendungen wird aber mpmath vorzuziehen sein, da es u.a. vielfältige mathematische Funktionen bereit stellt. Nachfolgend ein einfaches Beispiel mit decimal:

 import decimal
 print(&quot;Potenzierung:&quot;, decimal.Decimal(1500.4) ** decimal.Decimal(300.0))
 print(&quot;Einfache Addition:&quot;, 0.1 + 0.2)
 decimal.getcontext().prec = 50
 print(&quot;Addition mit decimal:&quot;, decimal.Decimal(&quot;0.1&quot;) + decimal.Decimal(&quot;0.2&quot;))

Ausgabe:

 Potenzierung: 7.279752992186121551039839134E+952
 Einfache Addition: 0.30000000000000004
 Addition mit decimal: 0.3

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet die genauen Vor- und Nachteile von decimal und mpmath. Verwenden Sie dazu auch KI (z.B. von Google, chatgpt).

= pint - mit physikalischen Größen rechnen = 
[[File:Pint-Glas_UK.jpg|right|100px]]
pint ist ein externes Python-Paket zur Manipulation von physikalischen Einheiten. Es muss vor der ersten Benutzung installiert werden (Vorgehensweise wie immer: pip, YaST, via venv etc.).

Beispiel:

 import pint
 import numpy as np
 
 ureg = pint.UnitRegistry()
 
 # Einfache Berechnung
 print(3 * ureg.meter + 4 * ureg.cm)
 
 # Mit NumPy
 npeinzel = [3, 4] * ureg.meter + [2, 5] * ureg.cm
 print(npeinzel)
 npsum = np.sum(npeinzel)
 print(npsum)
 
 # Konvertierung von Einheiten
 npsum_inch = npsum.to(ureg.inch)
 print(npsum_inch)
 
 print(npeinzel.magnitude)
 print(npeinzel.units)
 print(npeinzel.dimensionality)

Ausgabe:

 3.04 meter
 [3.02 4.05] meter
 7.07 meter
 278.3464566929134 inch
 [3.02 4.05]
 meter
 [length]

Die Dokumentation zu pint findet sich auf [https://pint.readthedocs.io/en/stable/].

=Regelungstechnische Aufgabenstellungen=
Für regelungstechnische Aufgaben gibt es u.a. das externe Paket &lt;code&gt;control&lt;/code&gt;. Hier soll nicht detailliert darauf eingegangen werden. Anhand eines Beispiels soll anschließend nur die Visualisierung in Form eines Bode-Diagramms und der Sprungantwort gezeigt werden. Gegeben sei ein P-Regler mit &lt;math&gt;R = \frac{5}{2}&lt;/math&gt; und eine Strecke &lt;math&gt;S= \frac{1}{30s^3+20s^2+10s+1,5}&lt;/math&gt;. Gesucht sei vorerst ein Bode-Diagramm für den offenen Regelkreis und das Führungsverhalten.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke  # oder: G0 = ct.series(regler, strecke)
 Gw = ct.feedback(G0)
 
 ct.bode_plot(G0, label='G0')
 ct.bode_plot(Gw, label='Gw')
 plt.show()

[[Datei:PythonIng_bode1.svg]]

Nun noch für obiges Beispiel die Sprungantwort. Diese zeigt einige große Überschwinger, d.h. der Regler kann sicher noch optimiert werden.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke 
 Gw = ct.feedback(G0) 
 
 t, y = ct.step_response(Gw)
 
 plt.plot(t,y)
 plt.title('Sprungantwort')
 plt.xlabel('t')
 plt.ylabel('h(t)')
 plt.grid()
 plt.show()

[[Datei:PythonIng_bode3.svg]]

Einige weitere wichtige Daten (Phasenreserve, Amplitudenreserve, Durchtrittsfrequenz) lassen sich mittels der &lt;code&gt;control&lt;/code&gt;-Funktion &lt;code&gt;margin()&lt;/code&gt; ermitteln. Die Ortskurve lässt sich mit der Funktion &lt;code&gt;nyquist_plot()&lt;/code&gt; zeichnen. Dies sei hier aber nicht weiter ausgeführt.

==Aufgaben==
* Zeichen Sie mit Python die Ortskurve für obiges Beispiel.
* Was passiert, wenn man die Reglerverstärkung weiter aufdreht (z.B. auf &lt;math&gt;R = \frac{25}{2}&lt;/math&gt;)?
* Wie sehen das Bode-Diagramm und die Sprungantwort aus, wenn ein PI-Regler verwendet wird?

= Stereostatik etc. =
Das Modul SymPy bietet einige Möglichkeiten einfache Bauwerke zu berechnen, z.B. Balken oder Fachwerke. Nachfolgend wird ein einfaches Fachwerk berechnet und gezeichnet.

Python-Code:
 from sympy.physics.continuum_mechanics.truss import Truss 
 
 t = Truss()
 # Knoten
 t.add_node((&quot;A&quot;, -3, 0), (&quot;B&quot;, 0, 0), (&quot;C&quot;, 4, 0), (&quot;D&quot;, 7, 0),
            (&quot;E&quot;, 6, 1.5), (&quot;F&quot;, 2, 3), (&quot;G&quot;, -2, 1.5))
 # Stäbe
 t.add_member((&quot;AB&quot;,&quot;A&quot;,&quot;B&quot;), (&quot;BC&quot;,&quot;B&quot;,&quot;C&quot;), (&quot;CD&quot;,&quot;C&quot;,&quot;D&quot;))
 t.add_member((&quot;AG&quot;,&quot;A&quot;,&quot;G&quot;), (&quot;GB&quot;,&quot;G&quot;,&quot;B&quot;), (&quot;GF&quot;,&quot;G&quot;,&quot;F&quot;))
 t.add_member((&quot;BF&quot;,&quot;B&quot;,&quot;F&quot;), (&quot;FC&quot;,&quot;F&quot;,&quot;C&quot;), (&quot;CE&quot;,&quot;C&quot;,&quot;E&quot;))
 t.add_member((&quot;FE&quot;,&quot;F&quot;,&quot;E&quot;), (&quot;DE&quot;,&quot;D&quot;,&quot;E&quot;))
 # Auflager; roller ... Loslager, pinned ... Festlager
 t.apply_support((&quot;A&quot;,&quot;roller&quot;), (&quot;D&quot;,&quot;pinned&quot;))
 # Einwirkende Kräfte
 t.apply_load((&quot;G&quot;, 5, 270), (&quot;E&quot;, 3, 90))
 
 # Berechnung 
 t.solve()
 print(&quot;Reaction Forces: &quot;, t.reaction_loads)
 print(&quot;Internal Forces: &quot;, t.internal_forces)
 
 # Fachwerk zeichnen
 p = t.draw()
 p.show()

Ausgabe auf der Konsole:

 Reaction Forces:  {'R_A_y': 4.20000000000000, 'R_D_x': 0, 'R_D_y': -2.20000000000000}
 Internal Forces:  {'AB': 2.80000000000000, 'BC': 0.333333333333333, 'CD': -1.46666666666667, 
 'AG': -5.04777178564958, 'GB': -2.05555555555556, 'GF': -1.23413387432364, 
 'BF': 0.411111111111111*sqrt(13), 'FC': -0.3*sqrt(13), 'CE': 1.50000000000000, 
 'FE': 0.284800124843917, 'DE': 2.64407093534026}

Zeichnung:

[[File:PythonIng_fachwerk1.svg|300px]]

Details zu diesem Thema siehe z.B. [https://docs.sympy.org/latest/modules/physics/continuum_mechanics/index.html Continuum Mechanics] oder [https://docs.sympy.org/latest/tutorials/physics/continuum_mechanics/index.html Continuum Mechanics Tutorials]. Auch andere mechanische Probleme werden von SymPy abgehandelt ([https://docs.sympy.org/latest/tutorials/physics/index.html Physics Tutorials]).

== Aufgabe ==
Gegeben sei ein einseitig eingespannter Kragträger. Belastet wird er durch eine Einzellast am Trägerende. Für die Daten siehe folgende ASCII-Skizze:

                            | 20 kN  
    //|---&gt; x               |
    //|                     V
    //|----------------------
    //|         10 m        |
 
 Elastizitätsmodul E = 2,1*10⁵ N/mm²
 Flächenträgheitsmoment I = 0.001 m⁴

Berechnen Sie die Auflagerreaktionen, den Querkraft- und Biegemomentenverlauf, sowie die Verformungen.
Stellen Sie dies mit Hilfe von SymPy graphisch und auch mittels Formeln dar. Verwenden Sie dazu auch pprint (pretty print) aus dem SymPy-Modul. Zwecks Lösungsansatz siehe die oben aufgeführte Seite &quot;Continuum Mechanics Tutorials&quot;. Achten Sie auch auf die Einheiten! Kontrollieren Sie das Ganze mittels händischer Rechnung. In dem genannten Tutorial ist von &quot;Singularity Functions&quot; die Rede. Gemeint ist damit in diesem Kontext die {{W|Föppl-Klammer}}.

Einige Python-Programme, vorrangig zu Maschinenelementen, finden sich auf [https://baymp.de/download_python.html BayMP für Python] (Balken, Zahnräder, Stabknickung usw.).

=Thermodynamik= 
== PYroMat ==
Für thermodynamische Aufgabenstellungen gibt es verschiedene externe Module. Eines davon ist PYroMat (siehe auch [http://pyromat.org]). Damit lassen sich thermodynamische Stoffdaten für viele Substanzen berechnen.

Beispiel (einige Stoffdaten für Wasser bei 400°C und 20 bar berechnen):

 import pyromat as pm
 
 # Wasserdaten laden:
 H2O = pm.get('mp.H2O')
 
 # Stoffdaten berechnen:
 T = 673.15  # Temperatur in Kelvin
 p = 20      # Druck in bar
 v = H2O.v(T, p)
 h = H2O.h(T, p)
 s = H2O.s(T, p)
 print(f&quot;Spezifisches Volumen: {v} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {h} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {s} kJ/(kg K)&quot;)

Ausgabe:

 Spezifisches Volumen: [0.1512163] m³/kg
 Spezifische Enthalpie: [3248.3789473] kJ/kg
 Spezifische Entropie: [7.12924142] kJ/(kg K)

&lt;small&gt;
PYroMat muss vorab installiert werden (z.B. mittels pip, in eine virtuelle Umgebung)
&lt;/small&gt;

&lt;code&gt;mp&lt;/code&gt; steht für &quot;multi phase&quot;. Für ein ideales Gas wäre &lt;code&gt;ig&lt;/code&gt; zuständig, z.B. &lt;code&gt;'ig.O2'&lt;/code&gt;.

Beispiel (T-s-Diagramm für Wasser zeichnen):
 import numpy as np
 import matplotlib.pyplot as plt
 import pyromat as pm
 
 # Konfigurieren
 pm.config[&quot;unit_pressure&quot;] = &quot;bar&quot;
 pm.config[&quot;unit_temperature&quot;] = &quot;K&quot;
 fluid = pm.get(&quot;mp.H2O&quot;)
 
 # Temperaturbereich für das Nassdampfgebiet
 T_tripel = 273.16
 T_crit = 647.096
 T = np.linspace(T_tripel, T_crit - 0.1, 200)
 
 # Sättigungslinien berechnen und zeichnen
 for x in np.linspace(0.0, 1.0, 5):
     s = fluid.s(T=T, x=x)
     if(x&lt;=0.0):
         plt.plot(s, T, label=&quot;Siedelinie x=%3.1f&quot; % x, linewidth=2.0)
     elif(x&gt;=1.0):
         plt.plot(s, T, label=&quot;Taulinie x=%3.1f&quot; % x, linewidth=2.0)
     else:
         plt.plot(s, T, label=&quot;x=%3.1f&quot; % x, linewidth=1.0)
 
 # Isobaren zeichnen
 p_values = [0.1, 1, 10, 50, 100]
 T_isobar = np.linspace(T_tripel, 1000, 200)
 t = 0.7
 
 for p in p_values:
     s_iso = fluid.s(T=T_isobar, p=p)
     plt.plot(s_iso, T_isobar, 'k-', alpha=0.8, linewidth=0.8)
 
     t += .05
     idx = int(len(s_iso) * t)
     plt.text(s_iso[idx], T_isobar[idx], f&quot;{p} bar&quot;, fontsize=9, alpha=0.8)
 
 # Diagramm zeichnen
 plt.title(&quot;T-s-Diagramm für Wasser&quot;)
 plt.xlabel(&quot;Spezifische Entropie s in kJ/kg K&quot;, fontsize=10)
 plt.ylabel(&quot;Temperatur T in K&quot;, fontsize=10)
 plt.legend(loc=&quot;best&quot;)
 plt.grid(True)
 plt.show()

Ausgabe (in etwa so):

[[Datei:T-s-Diagramm fuer Wasser.svg|400px]]

== CoolProp ==
Auch mit CoolProp können Stoffdaten berechnet werden. Siehe auch [https://coolprop.org/coolprop/wrappers/Python/index.html]

Beispiel (Wasser bei 20bar und 400°C):
 import CoolProp.CoolProp as CP
 
 fluid = 'Water'
 T = 673.15   # Temperatur in Kelvin
 P = 20e5     # Druck in Pascal
 
 dichte = CP.PropsSI('D', 'T', T, 'P', P, fluid)
 enthalpie = CP.PropsSI('H', 'T', T, 'P', P, fluid)
 entropie = CP.PropsSI('S', 'T', T, 'P', P, fluid)
 
 print(f&quot;Spez. Volumen: {1/dichte:.6f} m³/kg&quot;)
 print(f&quot;Spez. Enthalpie: {enthalpie:.2f} J/kg&quot;)
 print(f&quot;Spez. Entropie: {entropie:.2f} J/kgK&quot;)

Ausgabe:
 Spez. Volumen: 0.151215 m³/kg
 Spez. Enthalpie: 3248344.02 J/kg
 Spez. Entropie: 7129.16 J/kgK

== iapws ==
Um Werte für Wasser(dampf) zu erhalten (IAPWS; '''I'''nternational '''A'''ssociation for the '''P'''roperties of '''W'''ater and '''S'''team) gibt es die Bibliothek iapws. Siehe auch [https://iapws.org/] und [https://pypi.org/project/iapws/]

Beispiel (Wasser für 20bar und 400°C):
 from iapws import IAPWS97
 
 dampf = IAPWS97(P=2.0, T=673.15)
 
 print(f&quot;Spezifisches Volumen: {dampf.v:.6f} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {dampf.h:.2f} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {dampf.s:.4f} kJ/(kgK)&quot;)
 print(f&quot;Phase: {dampf.phase}&quot;)

Ausgabe:
 Spezifisches Volumen: 0.151208 m³/kg
 Spezifische Enthalpie: 3248.23 kJ/kg
 Spezifische Entropie: 7.1290 kJ/(kgK)
 Phase: Gas

== TESPy ==
Ein anderes Modul für einen anderen Aufgabenzweck ist TESPy ('''T'''hermal '''E'''ngineering '''S'''ystems in '''Py'''thon). Dieses Modul ist für die Anlagensimulation zuständig. Für nähere Informationen siehe [https://tespy.readthedocs.io/en/main/getting_started/introduction.html]. Als Beipiel sei hier vorerst Code, der von der Google KI generiert wurde, angeführt. Der Code wurde überarbeitet, damit keine Warnungen auftreten. Bitte aber den Code trotzdem mit Vorsicht genießen, auch KI-generierter Code kann Fehler aufweisen. Eine Pumpe wird berechnet:

 from tespy.components import Sink, Source, Pump
 from tespy.connections import Connection
 from tespy.networks import Network
 
 # 1. Netzwerk definieren (Zentrales Steuerungselement)
 # Wir wählen Wasser als Fluid und bar/Celsius als Einheiten
 nw = Network(fluids=[&quot;water&quot;])
 nw.units.set_defaults(pressure=&quot;bar&quot;, pressure_difference=&quot;bar&quot;, 
                       temperature=&quot;°C&quot;, enthalpy=&quot;kJ / kg&quot;)
 
 # 2. Komponenten erstellen
 eingang = Source(&quot;Wasserquelle&quot;)
 ausgang = Sink(&quot;Wasserspeicher&quot;)
 pumpe = Pump(&quot;Speisewasserpumpe&quot;)
 
 # 3. Verbindungen definieren (Komponenten miteinander verknüpfen)
 c1 = Connection(eingang, &quot;out1&quot;, pumpe, &quot;in1&quot;)
 c2 = Connection(pumpe, &quot;out1&quot;, ausgang, &quot;in1&quot;)
 
 # Verbindungen dem Netzwerk hinzufügen
 nw.add_conns(c1, c2)
 
 # 4. Randbedingungen und Parameter festlegen
 # Zustand am Eingang (Druck, Temperatur, Massenstrom, Fluid-Zusammensetzung)
 c1.set_attr(
     v=1,  # Massenstrom: 1 kg/s
     T=20,  # Temperatur: 20 °C
     p=1,  # Druck: 1 bar
     fluid={&quot;water&quot;: 1},  # 100% Wasser
 )
 
 # Zustand am Ausgang / Zielwerte der Pumpe
 c2.set_attr(p=10)  # Ziel-Druck nach der Pumpe: 10 bar
 
 # Pumpeneigenschaften festlegen
 pumpe.set_attr(eta_s=0.8)  # Isentroper Wirkungsgrad von 80%
 
 # 5. Simulation ausführen
 nw.solve(mode=&quot;design&quot;)
 
 # 6. Ergebnisse ausgeben
 nw.print_results()
 
 # Spezifische Werte direkt auslesen
 print(&quot;\n--- Auswertung ---&quot;)
 print(f&quot;Erforderliche Pumpenleistung: {pumpe.P.val / 1000:.2f} kW&quot;)
 print(f&quot;Temperatur nach der Pumpe: {c2.T.val:.2f} °C&quot;)

Ausgabe (gekürzt):
  iter  | residual   | progress   | massflow   | pressure   | enthalpy   | fluid      | component  
 -------+------------+------------+------------+------------+------------+------------+------------
  1     | 7.04e+04   | 12 %       | 9.96e+02   | 0.00e+00   | 8.81e+04   | 0.00e+00   | 0.00e+00   
  2     | 5.91e-12   | 100 %      | 1.11e-13   | 0.00e+00   | 7.39e-12   | 0.00e+00   | 0.00e+00   
  3     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
  4     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
 Total iterations: 4, Calculation time: 0.01 s, Iterations per second: 480.85
 
 ##### RESULTS (Pump) #####
 +-------------------+----------+----------+-----------+----------+----------+----------+
 |                   |        P |       pr |        dp |      eta |    eta_s |     head |
 |-------------------+----------+----------+-----------+----------+----------+----------|
 | Speisewasserpumpe | 1.12e+06 | 1.00e+01 | -9.00e+00 | 8.00e-01 | 8.00e-01 | 9.19e+01 |
 +-------------------+----------+----------+-----------+----------+----------+----------+
 ...
 ...
 --- Auswertung ---
 Erforderliche Pumpenleistung: 1124.77 kW
 Temperatur nach der Pumpe: 20.07 °C

= Stochastik =
Die {{W|Stochastik}} ist ein sehr weites Feld. Hier werden etliche wichtige Themen kurz angerissen. Python stellt mit den Moduln math und statistics Software zu diesem Zwecke bereit. math und statistics sind bereits im Lieferumfang von Python enthalten. Aber auch mit den externen Modulen NumPy, SciPy, stochastic und pandas kann man Stochastik in Python betreiben. Die Theorie der Wahrscheinlichkeitsrechnung und Statistik soll etwas später in Band 5 dieser Buchreihe behandelt werden.

== Lageparameter == 
 import statistics
 
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 
 m1 = statistics.mean(werte)
 m2 = statistics.mode(werte)
 m3 = statistics.median(werte)
 
 print(&quot;Arithmetischer Mittelwert = &quot;, m1)
 print(&quot;Modalwert = &quot;, m2)
 print(&quot;Median = &quot;, m3)

Ausgabe:
 Arithmetischer Mittelwert =  3.5
 Modalwert =  1
 Median =  3.0

== Streuungsparameter ==
Beispiel (Berechnung der Standardabweichung):
 import statistics
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 s = statistics.stdev(werte)
 print(&quot;Standardabweichung = &quot;, s)

Ausgabe:
 Standardabweichung =  2.6770630673681683

Beispiel (Berechnung des Variationskoeffizienten V = Standardabweichung/Mittelwert)
 import numpy as np
 from scipy import stats
 import statistics
 
 k = 50
 
 dat1 = [14, 21, 18, 25, 30, 17, 20]
 dat = np.array(dat1)
 
 # Mit SciPy
 v = stats.variation(dat)
 vddof = stats.variation(dat, ddof=1)
 print(&quot;V SciPy: &quot;, v)
 print(&quot;V DDOF SciPy: &quot;, vddof)
 print(k*&quot;-&quot;)
 
 # mit NumPy
 mittelwert1 = np.mean(dat)
 std_abw1 = np.std(dat)
 std_abw1ddof = np.std(dat, ddof=1) 
 v1= std_abw1 / mittelwert1
 v1ddof = std_abw1ddof / mittelwert1
 print(&quot;Mittelwert NumPy: &quot;, mittelwert1)
 print(&quot;Std.abw. NumPy: &quot;, std_abw1)
 print(&quot;Std.abw. DDOF NumPy: &quot;, std_abw1ddof)
 print(&quot;V NumPy: &quot;, v1)
 print(&quot;V DDOF NumPy: &quot;, v1ddof)
 print(k*&quot;-&quot;)
 
 # nur mit reinem Python
 mittelwert2 = statistics.mean(dat1)
 std_abw2 = statistics.stdev(dat1)
 v2 = std_abw2 / mittelwert2
 print(&quot;Mittelwert Python: &quot;, mittelwert2)
 print(&quot;Std.abw. Python: &quot;, std_abw2)
 print(&quot;V Python:&quot;, v2)
 print(k*&quot;-&quot;)

Ausgabe:
 V SciPy:  0.23890355966467272
 V DDOF SciPy:  0.25804533701889254
 --------------------------------------------------
 Mittelwert NumPy:  20.714285714285715
 Std.abw. NumPy:  4.948716593053935
 Std.abw. DDOF NumPy:  5.3452248382484875
 V NumPy:  0.23890355966467272
 V DDOF NumPy:  0.2580453370188925
 --------------------------------------------------
 Mittelwert Python:  20.714285714285715
 Std.abw. Python:  5.3452248382484875
 V Python: 0.2580453370188925
 --------------------------------------------------

Der Unterschied bei der Standardabweichung zwischen reinem Python und den externen Bibliotheken SciPy und NumPy entsteht dadurch, dass einmal durch (n-1) und das andere Mal nur durch n dividiert wird. Dies kann bei NumPy und SciPy dadurch entschärft werden, indem &lt;code&gt;ddof=1&lt;/code&gt; gesetzt wird. ddof steht für '''D'''elta '''D'''egrees '''o'''f '''F'''reedom. &lt;small&gt;Je größer die Anzahl der Datensätze n wird, umso weniger spielt das eine Rolle.&lt;/small&gt;

== Kombinatorik ==
Beispiel:

 import math
 
 n = 7
 k = 5
 
 print(&quot;n! = &quot;, math.factorial(n))
 print(&quot;Kombinationen (n über k) = &quot;, math.comb(n, k))

Ausgabe:
 n! =  5040
 Kombinationen (n über k) =  21

Siehe zu diesem Thema auch [[Ing Mathematik: Permutationen, Kombinationen, binomischer Lehrsatz]]. Die Anzahlen lassen sich einfach aus den dortigen Formeln ermitteln, z.B. bei Permutationen mit &lt;math&gt;n!&lt;/math&gt; oder Variationen mit Wiederholungen als &lt;math&gt;n^k&lt;/math&gt;. Will man die Kombinationen oder Variationen aber auch als Liste ausgeben, so kann das Modul &lt;code&gt;itertools&lt;/code&gt; nützlich sein.  

Beispiel (Variationen ohne Wiederholung):

 from itertools import permutations
 
 menge = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]  # n = 4
 k = 3
 
 variationen = list(permutations(menge, k))
 
 for v in variationen:
     print(&quot;&quot;.join(v))
 
 print(50*&quot;-&quot;)
 print(len(variationen))

Ausgabe (gekürzt):
 ABC
 ABD
 ACB
 ...
 DCA
 DCB
 --------------------------------------------------
 24

Siehe zum Modul &lt;code&gt;itertools&lt;/code&gt; auch die Website [https://docs.python.org/3/library/itertools.html].

* Variationen mit Wiederholung: &lt;code&gt;itertools.product()&lt;/code&gt;
* Kombinationen ohne Wiederholung: &lt;code&gt;itertools.combinations()&lt;/code&gt;
* Kombinationen mit Wiederholung: &lt;code&gt;itertools.combinations_with_replacement()&lt;/code&gt;

== Zufallszahlen ==
Beispiel:
 import random
 
 # Ganzzahlige Zufallszahl von 1 bis 10
 zufallszahl1 = random.randint(1, 10)
 
 # Gleitpunktzahlen
 # zwischen 0.0 und 1.0
 zufallszahl2 = random.random()
 # Zahl zwischen 1.5 und 9.5
 zufallszahl3 = random.uniform(1.5, 9.5)
 
 # aus Liste auswählen
 farbe = [&quot;Rot&quot;, &quot;Grün&quot;, &quot;Blau&quot;]
 zufallswert = random.choice(farbe)
 
 print(zufallszahl1)
 print(zufallszahl2)
 print(zufallszahl3)
 print(zufallswert)

Ausgabe, z.B.:
 5
 0.14147945849015753
 6.894003397570905
 Rot

Benötigt man mehrere Zufallszahlen, so ist das Modul &lt;code&gt;numpy&lt;/code&gt; zu bevorzugen, z.B.:
* Normalverteilung: &lt;code&gt;np.random.normal(...)&lt;/code&gt;
* Gleichverteilung: &lt;code&gt;np.random.uniform(...)&lt;/code&gt;

== Histogramm ==
Zum Thema Histogramm siehe {{W|Histogramm}}.

Beispiel (mit Matplotlib):

 import matplotlib.pyplot as plt
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 
 plt.hist(daten, bins=25, edgecolor='darkgray')
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm.svg|300px]]

Beispiel (mit Seaborn):

 import matplotlib.pyplot as plt
 import seaborn as sns
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 sns.set_theme(style=&quot;darkgrid&quot;)
 sns.histplot(data=daten)
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm2.svg|300px]]

Das Kürzel &lt;code&gt;sns&lt;/code&gt; ist Konvention und steht für die fiktive Figur '''S'''amuel '''N'''orman '''S'''eaborn aus der US-Fernsehserie {{W|The West Wing – Im Zentrum der Macht | The West Wing}}.

== Box-Plot ==
[[File:Elements of a boxplot.svg|400px]]

Siehe auch {{W|Box-Plot}}.

Beispiel (mit Seaborn erstellt):
 import seaborn as sns
 import matplotlib.pyplot as plt
 
 df = sns.load_dataset(&quot;tips&quot;)
 sns.boxplot(data=df, x=&quot;day&quot;, y=&quot;tip&quot;, hue=&quot;day&quot;, legend=False)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot.svg|400px]]

Beispiel (mit Matplotlib erstellt):

 import matplotlib.pyplot as plt
 
 daten = [12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25]
 
 plt.boxplot(daten, patch_artist=True)
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot2.svg|300px]]

Um mehrere Box-Plots unterschiedlicher Farbe mit Matplotlib in einem Diagramm zu zeichnen, können Sie folgendermaßen vorgehen:

 import matplotlib.pyplot as plt
 
 daten = [[12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25],
          [10, 19, 20, 21, 20, 30, 19, 40, 11, 17, 19, 21]]
 
 farben = [&quot;green&quot;, &quot;blue&quot;]
 
 boxplot = plt.boxplot(daten, patch_artist=True)
 
 for patch, farbe in zip(boxplot['boxes'], farben):
     patch.set_facecolor(farbe)
 
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

== Regressionsrechnung ==
Beispiel:
 import numpy as np
 import matplotlib.pyplot as plt
 
 # Messpunkte
 x = np.array([1, 3, 5, 6, 8, 10, 20])
 y = np.array([3, 4, 5, 5, 7, 9, 11])
 
 # Regressionskurve (Grad 1 = lineare Regression, 2 = Polynom-Regression 2. Gr.)
 # y = kx + d
 k, d = np.polyfit(x, y, deg=1)
 # y = ax**2 + bx + c
 a, b, c = np.polyfit(x, y, deg=2)
 
 x_l = np.linspace(1, 20, 100)
 y_p = a * x_l**2 + b * x_l + c
 
 # Zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.plot(x, k*x + d, color='blue', label='Regressionsgerade')
 plt.plot(x_l, y_p, color='red', label='Regressionspolynom 2. Gr.')
 plt.xlabel('x')
 plt.ylabel('y')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_regression.svg|400px]]

== Korrelationsrechnung ==
Beispiel:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 # Messdaten
 x = [1, 3, 4, 5, 6]
 y = [2, 4, 6, 8, 5]
 
 daten = {'X': x, 'Y': y}
 df = pd.DataFrame(daten)
 
 # Korrelation
 korr = df['X'].corr(df['Y'])
 print(f&quot;Korrelationskoeff.: {korr}&quot;) 
 
 # Messpunkte zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:
 Korrelationskoeff.: 0.7556096518348252

[[Datei:IngMath_korrelation.svg|300px]]

== Mengen und Venn-Diagramme ==
Beispiel: 
 import matplotlib.pyplot as plt
 from matplotlib_venn import venn2
 
 menge_a = {1, 2, 3, 4, 5, 6}
 menge_b = {4, 5, 6, 7, 8}
 
 vereinigung = menge_a | menge_b
 schnitt = menge_a &amp; menge_b
 print(&quot;Vereinigungsmenge = &quot;, vereinigung)
 print(&quot;Schnittmenge = &quot;, schnitt)
 
 venn2([menge_a, menge_b], set_labels=('Menge A', 'Menge B'))
 plt.show()

Ausgabe:
 Vereinigungsmenge =  {1, 2, 3, 4, 5, 6, 7, 8}
 Schnittmenge =  {4, 5, 6}

[[Datei:IngMath_venn.svg|300px]]

Siehe auch {{W|Mengendiagramm#Venn-Diagramme}}.

== Verteilungs- und Dichtefunktion ==
* CDF ... '''C'''umulative '''D'''istribution '''F'''unction, Verteilungsfunktion
* PDF ... '''P'''robability '''D'''ensity '''F'''unction, Dichtefunktion

Beispiel (Normalverteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 from scipy.stats import norm
 
 my, sigma = 0, 1
 x = np.linspace(-4, 4, 50)
 
 pdf = norm.pdf(x, my, sigma)
 cdf = norm.cdf(x, my, sigma)
 
 plt.plot(x, pdf, lw=2, label=&quot;Dichtefunktion&quot;)
 plt.plot(x, cdf, lw=2, label=&quot;Verteilungsfunktion&quot;)
 plt.legend()
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:IngMath_cdf_pdf.svg|300px]]

Beispiel (&lt;math&gt;\chi^2&lt;/math&gt;-Verteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 import scipy.stats as stats
 
 x = np.linspace(0, 20, 500)
 
 # df ... degree of freedom, Freiheitsgrad
 pdf = (stats.chi2.pdf(x, df=2), stats.chi2.pdf(x, df=5), stats.chi2.pdf(x, df=10))
 
 for i in range(0,3):
     if(i==0):
         lab = &quot;Freiheitsgrad 2&quot;
     elif(i==1):
         lab = &quot;Freiheitsgrad 5&quot;
     else:
         lab = &quot;Freiheitsgrad 10&quot;
 
     plt.plot(x, pdf[i], label=lab, lw=2)
 
 plt.grid()
 plt.legend()
 plt.show()

Ausgabe:

[[Datei:IngMath_chi2.svg | 300px]]

== Schätzen und Testen ==
=== Intervallschätzung ===
Als Beispiel seien Daten gegeben, die von ''Dürr, Mayer: Wahrscheinlichkeitsrechnung und Schließende Statistik; 7. Aufl., Hanser, 2014, Seite 137'' stammen. Und zwar soll das 95%-Vertrauensintervall für den Mittelwert des Kaloriengehalts (kcal/100g) von Hähnchen ermittelt werden. Wir wollen das mit Python inkl. NumPy und SciPy durchführen. Die Stichprobe ist groß (50 Hähnchen):

Python-Code:
 import numpy as np
 import scipy.stats as stats
 
 # Stichprobe
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203]
 
 # Parameter definieren
 konfidenzniveau = 0.95
 mean = np.mean(daten)
 std = np.std(daten, ddof=1)
 stdfehler = stats.sem(daten)
 
 intervall = stats.norm.interval(confidence=konfidenzniveau, loc=mean, scale=stdfehler)
 
 print(f&quot;Mittelwert: {mean}&quot;)
 print(f&quot;Standardabweichung: {std}&quot;)
 print(f&quot;Konfidenzintervall: {intervall}&quot;)

Ausgabe:
 Mittelwert: 215.48
 Standardabweichung: 33.14238915925757
 Konfidenzintervall: (np.float64(206.29356722321992), np.float64(224.66643277678006))

Diese Werte stimmen gerundet mit denen im genannten Buch überein. Zum Code selbst:
* sem steht für '''s'''tandard '''e'''rror of the '''m'''ean.
* &lt;code&gt;scipy.stats.norm&lt;/code&gt; ... Modul für die Normalverteilung.

=== Punktschätzung ===
Gleiche Daten wie oben bei der Intervallschätzung.

Python-Code:
 import numpy as np
 from scipy import stats
 
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203
         ]
 
 mu_hat, sigma_hat = stats.norm.fit(daten) 
 
 print(f&quot;Schätzer für den Erwartungswert (μ): {mu_hat:.4f}&quot;)
 print(f&quot;Schätzer für die Standardabweichung (σ): {sigma_hat:.4f}&quot;)

Ausgabe:
 Schätzer für den Erwartungswert (μ): 215.4800
 Schätzer für die Standardabweichung (σ): 32.8093

=== Hypothesentests ===
Beispiel:

 import numpy as np
 import scipy.stats as stats
 
 x_quer = 12.075      # Stichproben-Mittelwert
 var    = 0.069       # Stichproben-Varianz
 n      = 90          # Stichprobengröße
 my_0   = 12.0        # Nullhypothese
 alpha  = 0.05        # Signifikanzniveau
 
 z_stat = (x_quer - my_0) / np.sqrt(var / n)
 p_val = 2 * (1 - stats.norm.cdf(np.abs(z_stat)))
 
 print(f&quot;Z-Statistik: {z_stat:.4f}&quot;)
 
 if p_val &lt; alpha:
     print(f&quot;p-Wert: {p_val:.6f} &lt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird verworfen.&quot;)
 else:
     print(f&quot;p-Wert: {p_val:.6f} &gt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird nicht verworfen.&quot;)

Ausgabe:

 Z-Statistik: 2.7087
 p-Wert: 0.006755 &lt; alpha: 0.05
 Die Nullhypothese wird verworfen.

== Statistische Qualitätskontrolle ==
Beispiel (Mittelwertkarte):

 import numpy as np
 import matplotlib.pyplot as plt
 
 # Gegeben
 sollwert = 50.0
 varianz = 4.0
 stichproben_umfang = 1
 daten = [49.5, 50.2, 53.0, 48.1, 52.6, 53.4, 49.8]
 
 # Berechnung
 standardabweichung = np.sqrt(varianz)
 streuung = standardabweichung / np.sqrt(stichproben_umfang)
 
 cl = sollwert
 ucl = cl + 3 * streuung
 lcl = cl - 3 * streuung
 
 # Darstellung
 plt.plot(daten, marker='o', linestyle='-', color='b', label='Messdaten')
 plt.axhline(cl, color='green', linestyle='-', label=f'CL: {cl}')
 plt.axhline(ucl, color='red', linestyle='--', label=f'UCL: {ucl:.2f}')
 plt.axhline(lcl, color='red', linestyle='--', label=f'LCL: {lcl:.2f}')
 
 plt.title('Mittelwertkarte')
 plt.xlabel('Stichprobe')
 plt.ylabel('Wert')
 plt.legend(loc='lower left')
 plt.grid(True)
 plt.show()

Ausgabe:

[[Datei:IngMath_mittelwertkarte.svg|300px]]

Siehe auch {{W|Shewhart-Regelkarte}} und {{W|Qualitätsregelkarte}}.

* UCL ... '''U'''pper '''C'''ontrol '''Limit''', Obere Eingriffsgrenze
* LCL ... '''L'''ower '''C'''ontrol '''Limit''', Untere Eingriffsgrenze
* CL ... '''C'''enter '''L'''ine, Mittellinie

= Ein- und Ausgabe =
== print ==
Die Anweisung print haben wir schon oft verwendet. Hier soll anhand von Beispielen kurz beschrieben werden, was der Befehl print leisten kann.

 print(&quot;Hallo&quot;, &quot;Welt&quot;, 1, sep=&quot;-&quot;)
 print(&quot;Hallo&quot;, end=&quot; &quot;)
 print(&quot;Welt&quot;)

Ausgabe:
 Hallo-Welt-1
 Hallo Welt

== input ==
 a = int(input(&quot;Zahl 1: &quot;))
 b = int(input(&quot;Zahl 2: &quot;))
 
 print(&quot;a + b = &quot;, a+b)

Ausgabe (nach Eingabe der beiden Ganzzahlen):
 Zahl 1: 4
 Zahl 2: 5
 a + b =  9

== Aus Dateien lesen ==
Es seinen die datei.txt
 Hallo Welt.
 Wie geht es dir?
 ...

und test1.py
 dat = open(&quot;datei.txt&quot;, mode = &quot;r&quot;)
 print(dat.read())
 dat.close()

Ausgabe
 Hallo Welt.
 Wie geht es dir?
 ...

Mit dem open()-Befehl wird die Datei datei.txt im Lesemodus geöffnet (r ... read). Mit dem read()-Befehl wird die Datei eingelesen und mittels print ausgegeben.

== In Dateien schreiben ==
 dat = open(&quot;datei.txt&quot;, mode = &quot;a&quot;, encoding = &quot;utf-8&quot;)
 dat.write(&quot;Hänge Zeile an\n&quot;)
 dat.close()

Die Datei datei.txt sieht nach Abarbeitung des obigen Skripts nun so aus
 Hallo Welt.
 Wie geht es dir?
 ...
 Hänge Zeile an

Es wird die Datei im Schreibmodus geöffnet (a ... append (anhängend), w ... write (überschreibend)).
write() fügt hier also eine Zeile Text am Dateiende ein. close() schließt die Datei wieder.

Das close() kann man sich mit der with-Anweisung auch sparen.

 with open(&quot;datei.txt&quot;, mode=&quot;a&quot;, encoding=&quot;utf-8&quot;) as dat:
     dat.write(&quot;Hänge Zeile an\n&quot;)

= Benutzeroberflächen erstellen =
== tkinter ==
{{Wikipedia | Tkinter}}

Python bietet standardmäßig das Modul tkinter zur Programmierung von Benutzeroberflächen. Es müssen also bei der Verwendung von tkinter keine externen Module installiert werden. Hier wird eine (sehr) kurze Einführung in das Erstellen von grafischen Oberflächen mittels tkinter gegeben.

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 win.minsize(300, 50)
 but = tk.Button(win, text = &quot;Push the button&quot;)
 but.pack()
 win.mainloop()

Ausgabe:

[[Datei:PythonIng_gui1.jpg]]

Ein etwas komplizierteres Beispiel sei nachfolgend gezeigt. Es sollen zwei Strings miteinander verknüpft und ausgegeben werden. 

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 
 def on_button_clicked():
     str = ent1.get() + ent2.get()
     lab2[&quot;text&quot;] = str
  
 ent1 = tk.Entry(win)
 ent2 = tk.Entry(win)
 lab1 = tk.Label(win, text=&quot;verknuepfen mit&quot;)
 lab2 = tk.Label(win, text=&quot;&quot;) 
 but = tk.Button(win, text = &quot;=&quot;, command=on_button_clicked)
 
 ent1.pack(side=&quot;left&quot;)
 lab1.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 but.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 lab2.pack(side=&quot;left&quot;)
 
 win.mainloop()

Ausgabe  (vor der Eingabe der Teilstrings): 

[[Datei:PythonIng_gui2.jpg]]

Ausgabe (nach der Eingabe der Teilstrings und dem Drücken des =-Buttons): 

[[Datei:PythonIng_gui3.jpg]]

== curses ==
{{Wikipedia | curses}}

Mit dem curses-Modul lassen sich u.a. TUIs ('''T'''ext '''U'''ser '''I'''nterfaces) erstellen. Ein sehr einfaches Beispiel zur allgemeinen Funktionsweise wird nachstehend geliefert.
 
 import curses
 
 stdscr = curses.initscr()
 curses.start_color()
 curses.init_pair(1, curses.COLOR_RED, curses.COLOR_WHITE)
 stdscr.clear()
 
 stdscr.addstr(&quot;Hallo Welt&quot;, curses.color_pair(1))
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()
 
Als Ausgabe sollte &lt;span style=&quot;color:#FF0000;&quot;&gt;Hallo Welt&lt;/span&gt; (rote Schrift auf weißem Hintergrund) auf dem Terminal/der Konsole erscheinen. Getestet wurde dies mit openSUSE Tumbleweed, Python-Version 3.13.12. Das entsprechende Python-curses-Package muss installiert sein.

Allgemeine Informationen zur Terminal-/Konsolengröße und Cursorposition liefert folgendes Programm:
 
 import curses
 
 stdscr = curses.initscr()
 
 stdscr.addstr(3, 5, &quot;LINES: %d&quot; % curses.LINES)
 stdscr.addstr(4, 5, &quot;COLS:  %d&quot; % curses.COLS)
 
 (y,x) = stdscr.getyx()
 stdscr.addstr(5, 5, &quot;Momentane Cursorposition:  [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getbegyx()
 stdscr.addstr(6, 5, &quot;Koordinatenursprung:       [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getmaxyx()
 stdscr.addstr(7, 5, &quot;Fenstergröße:              [%d, %d]&quot; % (y, x))
 
 stdscr.addstr(11, 2, &quot;Taste drücken -&gt; Ende&quot;)
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()

Es sollte sich in etwa folgende Ausgabe ergeben:

     LINES: 44
     COLS:  110
     Momentane Cursorposition:  [4, 15]
     Koordinatenursprung:       [0, 0]
     Fenstergröße:              [44, 110]
 
 
 Taste drücken -&gt; Ende

Zur Funktionsweise von curses siehe auch das Wikibook [[ncurses]]. Zum Verständnis sind dort allerdings elementare Kenntnisse in der Programmiersprache C erforderlich.

== Qt ==
{{Wikipedia | Qt (Bibliothek)}}

Auch für das Qt-Framework gibt es eine Anbindung an Python. Nachfolgend ein einfaches Beispiel.

 import sys
 from PySide6.QtWidgets import QApplication, QLabel
 
 app = QApplication(sys.argv)
 label = QLabel(&quot;Hallo Welt!&quot;)
 label.show()
 sys.exit(app.exec())

Ausgabe:

[[Datei:PythonIng_gui10.png]]

== Gtk ==
{{Wikipedia | GTK (Programmbibliothek)}}

Eine idente Ausgabe, wie oben für Qt gezeigt, erzeugt z.B. folgendes Gtk-Programm:

 import gi
 gi.require_version(&quot;Gtk&quot;, &quot;4.0&quot;)
 from gi.repository import Gtk
 
 def on_activate(app):
     win = Gtk.ApplicationWindow(application=app)
     lab = Gtk.Label(label=&quot;Hallo Welt!&quot;)
     win.set_child(lab)
     win.present()
 
 app = Gtk.Application()
 app.connect('activate', on_activate)
 app.run(None)

Auch für die Benutzung von Qt und Gtk müssen die jeweiligen Packages installiert sein. Getestet wurden die entsprechenden Python-Programme nur unter openSUSE Tumbleweed. Wie das GTK-Paket unter MS Windows 11 installiert wird, siehe z.B. [https://www.gtk.org/docs/installations/windows Setting up GTK for Windows].

Damit sei aber das Thema &quot;Benutzeroberflächen erstellen&quot; hier abgeschlossen, da dies schon ein sehr spezielles Aufgabengebiet ist, das eher Informatiker und nicht so sehr Ingenieure anspricht. Bei Bedarf siehe aber ggf. die entsprechenden Links unten in diesem Tutorial. Dort sind weiterführende Informationen zu finden.

= Pandas kurz erklärt =
Hier wird kurz auf das externe Modul Pandas eingegangen. Pandas steht für '''Pan'''el '''Da'''ta und ist ein Modul für die Datenanalyse und -manipulation.

== Series ==
Vorstellbar ist eine &quot;Series&quot; wie eine einzelne Spalte in einem Tabellenkalkulationsprogramm.

Beispiel (Index implizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5]) # Temperaturwerte
 print(temp)

Ausgabe:
 0     8.5
 1    11.0
 2    12.5
 3    10.0
 4    13.0
 5    11.0
 6    14.5
 dtype: float64

Das Kürzel &lt;code&gt;pd&lt;/code&gt; ist Konvention. Es seien Temperaturwerte gegeben. Die erste Spalte bei der Ausgabe ist der Index. Die zweite Spalte enthält die Werte.

Beispiel (separater Zugriff auf den Index und auf die Werte):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5])
 print(temp.index)
 print(temp.values)

Ausgabe:
 RangeIndex(start=0, stop=7, step=1)
 [ 8.5 11.  12.5 10.  13.  11.  14.5]

Beispiel (Index explizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 print(&quot;*** Die gesamte Series ***&quot;)
 print(temp)
 
 print(&quot;*** Temperatur am Donnerstag ***&quot;)
 print(temp[&quot;Do&quot;])
 
 print(&quot;*** Tage wärmer als 12 Grad ***&quot;)
 temp_gr_12 = temp[temp &gt; 12]
 print(temp_gr_12)

Ausgabe:
 *** Die gesamte Series ***
 Mo     8.5
 Di    11.0
 Mi    12.5
 Do    10.0
 Fr    13.0
 Sa    11.0
 So    14.5
 dtype: float64
 *** Temperatur am Donnerstag ***
 10.0
 *** Tage wärmer als 12 Grad ***
 Mi    12.5
 Fr    13.0
 So    14.5
 dtype: float64

== DataFrame ==
Ein DataFrame entspricht einer Tabelle.

Beispiel (Erzeugen eines DataFrames):
 import pandas as pd
 
 tag   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 v1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=tag)
 v2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=tag)
 v3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=tag)
 
 tab = pd.concat([v1, v2, v3], axis=1)
 tab.columns = stadt
 
 print(tab)
 print(type(tab))

Ausgabe:
     Linz  Salzburg Innsbruck
 Mo     1         8     Hallo
 Di     2         9        16
 Mi     3        10        17
 Do     4        11        18
 Fr     5        12        19
 Sa     6        13        20
 So     7        14        21
 &lt;class 'pandas.core.frame.DataFrame'&gt;

Wir haben hier drei Datenspalten (v1, v2, v3) mit den Spaltennamen &quot;Linz&quot;, &quot;Salzburg&quot; und &quot;Innsbruck&quot;, sowie sieben Zeilen &quot;Mo&quot; bis &quot;So&quot;.

Beispiel (Zugriff auf eine Spalte):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab[&quot;Salzburg&quot;])

Ausgabe:
 Mo     8
 Di     9
 Mi    10
 Do    11
 Fr    12
 Sa    13
 So    14
 Name: Salzburg, dtype: int64

Beispiel (Zugriff auf eine Zeile):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab.loc[&quot;Di&quot;])

Ausgabe:
 Linz          2
 Salzburg      9
 Innsbruck    16
 Name: Di, dtype: object

== Grafiken erstellen ==
Hier sei nur ein Torten- oder Kreisdiagramm gezeichnet:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 expl = [0, 0.2, 0, 0, 0, 0, 0]
 temp.plot.pie(figsize=(5,5), explode=expl)
 plt.show()

Ausgabe:

[[Datei:IngPython_pandas1.svg|350px]]

Die &lt;code&gt;figsize&lt;/code&gt; hat nichts mit der Spaltenanzahl zu tun, sondern setzt die Fenster- oder Diagrammgröße in Inches (Breite * Höhe).
 
Mit Pandas kann man auch noch andere Diagrammarten erstellen, z.B. Linien- oder Balkendiagramme. Dies wird hier aber nicht vorgeführt.

== Arbeiten mit CSV- und LibreOffice-Dateien ==
Gegeben sei eine CSV-Datei test1.csv:
 Mai;Juni;Juli
 12;17;45
 15;65;65
 16;32;23
 4;14;7
 23;17;Keine Daten verfügbar
 67;Keine Daten verfügbar;45
 15;24;12

Lesen von dieser CSV-Datei:
 import pandas as pd
 
 tab = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 print(tab)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Schreiben in eine CSV-Datei test2.csv:
 import pandas as pd
 
 val = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 val.to_csv(&quot;test2.csv&quot;, index=False)

Ausgabedatei:
 Mai,Juni,Juli
 12,17,45
 15,65,65
 16,32,23
 4,14,7
 23,17,Keine Daten verfügbar
 67,Keine Daten verfügbar,45
 15,24,12

Die Ausgabedatei ist beinahe gleich wie die Eingabedatei. Es werden aber Kommas statt Strichpunkten verwendet. Daher kommt auch der Name CSV ('''C'''omma '''S'''eparated '''V'''alue). Will man wieder Strichpunkte, so kann man dies über den Parameter &lt;code&gt;sep=&quot;;&quot;&lt;/code&gt; in der &lt;code&gt;to_csv&lt;/code&gt;-Funktion machen.

Um direkt von einer ODS-Datei (LibreOffice Calc, '''O'''pen '''D'''ocument '''S'''preadsheet) zu lesen muss das Modul odfpy extra installiert sein (per YaST, pip etc.). Gelesen wird dann folgendermaßen:
 import pandas as pd
 
 df = pd.read_excel('test1.ods', engine='odf')
 print(df)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Die Datei &quot;test1.ods&quot; sei die Datei, aus der das obige &quot;test1.csv&quot; generiert wurde. Schreiben kann man ebenfalls in eine ODS-Datei:

 import pandas as pd
 
 daten = {
     &quot;Name&quot;: [&quot;Hugo&quot;, &quot;Richie&quot;, &quot;Wilhelmine&quot;],
     &quot;Alter&quot;: [38, 30, 29],
     &quot;Ort&quot;: [&quot;Linz&quot;, &quot;Innsbruck&quot;, &quot;Salzburg&quot;]
 }
 
 tab = pd.DataFrame(daten)
 
 with pd.ExcelWriter(&quot;test2.ods&quot;, engine=&quot;odf&quot;) as writer:
     tab.to_excel(writer, sheet_name=&quot;Daten&quot;, index=False)

Es ergibt sich eine &quot;test2.ods&quot;-Datei (Screenshot):

[[Datei:IngPython_pandas2.png|250px]]

== Sonstiges ==
Hier seien stichpunktartig einige weitere Features von Pandas angeführt:
* {{W|Pivot-Tabelle|Pivot-Tabellen}} (pivot ... Dreh-, Angelpunkt): Zweck - große Datenmengen schnell zusammenfassen, filtern und analysieren.
* NaN ('''n'''ot '''a''' '''n'''umber): In einem Datensatz fehlt ein Wert oder ist nicht definiert.
* groupby-Funktion: Daten strukturieren, aggregieren oder Zwischensummen bilden. 
* {{W|Binning#Datenverarbeitung_und_-analyse|Binning}}: Klassenbildung.
* Mehrstufige Indizierung (Hierarchical Indexing oder MultiIndex)
* Zeitreihen (Time Series)

Für tiefergehende und weiterführende Informationen wird auf das Buch von ''Klein: Numerisches Python; Hanser, 2023'' und [https://pandas.pydata.org/ pandas] verwiesen.

= Style Guide, flake8, pylint, Black etc. =
== Style Guide ==
Wie man schönen und richtigen Python-Code schreibt, erfahren Sie in
* [https://peps.python.org/pep-0008/ PEP 8 – Style Guide for Python Code]

== Formatter und Linter ==
Ein Modul, das prüft, ob die Richtlinien im Style Guide eingehalten wurden, ist ''flake8'':
* [https://flake8.pycqa.org/en/latest/ Flake8: Your Tool For Style Guide Enforcement]

Code formatieren kann man auch mit [https://pypi.org/project/black/ Black]. Z.B. übersetzt &lt;code&gt;black test1.py&lt;/code&gt; die Datei &lt;code&gt;test1.py&lt;/code&gt;

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)),
     (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

in 

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)), (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Die Programmausgabe ist 

 reformatted test1.py
 
 All done! ✨ 🍰 ✨
 1 file reformatted.

Der Unterschied zwischen Black und Flake8:
* Black ist ein Code-Formatter. Er formatiert Ihren Code um, sodass er im Einklang mit PEP 8 steht.
* Flake8 ist ein {{W|Lint (Programmierwerkzeug) | Code-Linter}}. Flake8 verändert Ihren Code nicht, sondern durchsucht ihn nach potenziellen Fehlern etc.

Am obigen Beispiel sieht man auch, dass flake8 und Black nicht immer einer Meinung sind. Flake8 (&lt;code&gt;flake8 test1.py&lt;/code&gt;) würde standardmäßig den mit Black formatierten Code bemängeln:

 test1.py:8:80: E501 line too long (80 &gt; 79 characters)

Diese Diskrepanz kann beseitigt werden. Da 79 Zeichen auf modernen Bildschirmen meist als zu kurz empfunden werden, ist ein Limit von 88 Zeichen (Black-Standard) oder mehr empfehlenswert. Um dies zu implementieren, erstellen Sie in Ihrem Projektverzeichnis eine &lt;code&gt;.flake8&lt;/code&gt;-Datei mit dem Inhalt

 [flake8]
 max-line-length = 88

Und schon ignoriert Flake8 dieses Problem.

Ein anderer Linter ist pylint. Der würde beim Abarbeiten des obigen Beispiels, z.B. mit &lt;code&gt;pylint test1.py&lt;/code&gt; noch eine Kleinigkeit bemängeln:

 ************* Module test1
 /home/hr/tmp/test1.py:1:0: C0114: Missing module docstring (missing-module-docstring)
 
 ------------------------------------------------------------------
 Your code has been rated at 8.57/10 (previous run: 8.57/10, +0.00)

Auch pylint muss vor der ersten Verwendung installiert werden (z.B. mittels pip, virtuelle Umgebung, YaST). Die Dokumentation zu pylint findet sich auf [https://pylint.readthedocs.io/en/latest/].

&lt;u&gt;Aufgabe:&lt;/u&gt; Fügen Sie einen &quot;module docstring&quot; in die &lt;code&gt;test1.py&lt;/code&gt;-Datei ein und testen Sie erneut mit flake8, Black und pylint. &lt;small&gt;Sehen Sie zum Thema docstrings auch [https://peps.python.org/pep-0257/#what-is-a-docstring PEP 257 – Docstring Conventions].&lt;/small&gt;

Es gibt noch weitere Formatierungswerkzeuge für Python-Code. Z.B. [https://docs.astral.sh/ruff/ Ruff], ein moderner Code-Formatter und -Linter. Mittels &lt;code&gt;ruff check test1.py&lt;/code&gt; würde obiger Code geprüft (Linter). &lt;code&gt;ruff format test1.py&lt;/code&gt; formatiert den Code (Formatter).

== Type Checker ==
&quot;Type Checker&quot; sind z.B.
* mypy
* pyright
* ty

Diese prüfen die Datentypen, z.B. in folgendem Code

 def greetings(name: str) -&gt; str:
     return &quot;Hello, %s&quot; % name
 
 
 print(greetings(42))

Python selbst, flake8, ruff oder black würden diesen Code ohne zu murren akzeptieren. &quot;Type Checker&quot; würden aber sehr wohl Alarm schlagen, z.B. liefert &lt;code&gt;mypy&lt;/code&gt; folgende Ausgabe

 test1.py:5: error: Argument 1 to &quot;greetings&quot; has incompatible type &quot;int&quot;; expected &quot;str&quot;  [arg-type]
 Found 1 error in 1 file (checked 1 source file)

Das funktioniert übrigens nicht nur bei Funktionsannotationen, sondern auch mit Variablen etc.

 from typing import Final
 
 # &quot;Konstante&quot;, ab Python 3.8
 NUMBER: Final = 123
 print(NUMBER)
 NUMBER = 125
 print(NUMBER)
 
 # Variable
 a: int = 345
 print(a)
 a = &quot;Irgendwas&quot;
 print(a)
 
 # Variable (Pipe-Symbol), ab Python 3.10
 b : int|str = 567
 print(b)
 b = &quot;sonstiges&quot;
 print(b)

Ausgabe mit python:
 123
 125
 345
 Irgendwas
 567
 sonstiges

Ausgabe mit mypy:
 test3.py:6: error: Cannot assign to final name &quot;NUMBER&quot;  [misc]
 test3.py:12: error: Incompatible types in assignment (expression has type &quot;str&quot;, variable has type &quot;int&quot;)  [assignment]
 Found 2 errors in 1 file (checked 1 source file)

Python kennt übrigens keine Konstanten. Man kann diese mittels Großbuchstaben andeuten. Das ist aber nur Konvention, hat aber keine sonstigen Auswirkungen. Oder man verwendet wie oben gezeigt &lt;code&gt;Final&lt;/code&gt;. Dann werfen Typchecker Errors aus.

==pydoc==
pydoc ist ein Werkzeug, um Python-Module, -Funktionen und -Klassen zu dokumentieren.

Beispiel &lt;code&gt;test1.py&lt;/code&gt;:
 &quot;&quot;&quot;Rechen-Modul.
 
 Funktionen die von pydoc gelesen werden.
 &quot;&quot;&quot;
 
 def multiply(a, b):
     &quot;&quot;&quot;Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
     
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a * b
     
 def add(a, b):
     &quot;&quot;&quot;Addiert zwei Zahlen und gibt das Ergebnis zurück.
    
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a + b
    
 
 if __name__ == '__main__':
     print(multiply(3, 5))
     print(add(4, 6))

Ausgabe mit &lt;code&gt;python3.13 -m pydoc test1&lt;/code&gt; auf der Konsole:

 Help on module test1:
 
 NAME
     test1 - Rechen-Modul. 
 
 DESCRIPTION
     Funktionen die von pydoc gelesen werden.
 
 FUNCTIONS
     add(a, b)
         Addiert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
     multiply(a, b)
         Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
 FILE
     /home/xyz/tmp/test1.py

Siehe zu diesem Thema z.B. auch [https://docs.python.org/3/library/pydoc.html]. Mittels &lt;code&gt;python3.13 -m pydoc -w test1&lt;/code&gt; kann man auch eine HTML-Dokumentation erstellen.

Wofür &lt;code&gt;if __name__ == '__main__':&lt;/code&gt; steht, siehe z.B. etwas später im Abschnitt [[Ing_Mathematik:_Python#Doctests]].

== Sonstige Tools ==
Andere Tools für die {{W|Statische Code-Analyse|statische Codeanalyse}}, die aber für Ingenieure weniger interessant sein dürften, sind z.B.
* Radon: Liefert verschiedene {{W|Softwaremetrik|Codemetriken}} (Komplexität, Wartbarkeitsindex ...)
* Bandit: Findet Sicherheitslücken

Tools für die {{W|Dynamisches Software-Testverfahren|dynamische Codeanalyse}}, z.B.:
* DynaPyt (Framework zur dynamischen Programmanalyse)
* cProfile (Profiler)
* Memory Profiler (Speicheranalyse)
* Memray (Speicheranalyse)
* tracemalloc (Speicheranalyse)

Paket- und Projektmanagement (pip-Ersatz etc.):
* uv
* Poetry
* Conda
* pipx

Packaging-Tools (Freezer) und {{W|Compiler#Sonderformen|Transpiler}} :
* pyinstaller
** erstellt eigenständige, ausführbare Binärdatei
** kein Cross-Compiler
** kein Schutz vor Reverse-Engineering
** langsam
** packt alles in eine Datei
** sehr große Datei
** Befehl, z.B.: &lt;code&gt;pyinstaller --onefile test1.py&lt;/code&gt;
** GUI: &lt;code&gt;auto-py-to-exe&lt;/code&gt;
* cx_Freeze
* nuitka
** Übersetzt Python-Code in C/C++-Code und weiter in eine ausführbare Datei
** kein Cross-Compiler
** Schutz vor Reverse-Engineering
** Befehl, z.B.: &lt;code&gt;nuitka --standalone --onefile test1.py&lt;/code&gt;
* cython

= Einige Integrierte Entwicklungsumgebungen (IDEs)=
Werden Programmtexte größer und umfangreicher, so ist das Arbeiten mit der interaktiven Programmierumgebung bzw. das direkte Ausführen von Python-Skripten mühsam. Man wünscht sich z.B. Hilfen zum Debuggen oder die automatische Code-Vervollständigung. Zu diesem Zweck wurden IDEs (Integrated Development Environments) geschaffen. Von diesen seinen nachfolgend auszugsweise einige kurz beschrieben. Testen Sie einfach aus, welche davon für Sie bzw. für Ihr Python-Projekt geeignet sind.

== IDLE ==
IDLE ist die mit dem Python-Programmpaket mitgelieferte IDE. Der Name leitet sich einerseits ab vom Monty-Python-Mitglied Eric Idle, andererseits steht es als Abkürzung für &quot;'''I'''ntegrated '''D'''evelopment and '''L'''earning '''E'''nvironment. IDLE ist einfach zu bedienen, bietet aber schon einen beachtlichen Leistungsumfang. Nachfolgend wird ein Screenshot zu IDLE geliefert. Rechts ist das Editor-Fenster zu sehen, links die interaktive Programmierumgebung. Um das Beispiel selbst nachvollziehen zu können, starten Sie IDLE. Das geht ähnlich, wie Sie die interaktive Programmierumgebung von Python starten (nur, dass Sie eben das IDLE-Icon doppelklicken und nicht das Python-Icon. Unter Linux geben Sie einfach in einem Terminal &lt;code&gt;idle3.13&lt;/code&gt; o. Ä. ein). Weiter geht es mit &quot;File - Open - ...&quot;. Die auszuführende Datei auswählen (im konkreten Fall ein &quot;Hallo-Welt&quot;-Programm). Es erscheint das rechte Fenster. Dort &quot;Run - Run Module&quot; auswählen. Und schon wird im linken Fenster &quot;Hallo Welt!&quot; ausgegeben.

[[Datei:PythonIng_idle1.jpg | 600px]]

Siehe auch {{W|IDLE}}.

== PyCharm ==
PyCharm ist ein kommerzielles Produkt. Es gab aber auch eine kostenlose Community Edition. Seit 2025 sind beide Varianten vereint. Für die ersten 30 Tage sind die Pro-Funktionen frei verfügbar, danach nur noch die Kernfunktionalitäten (oder man bezieht kostenpflichtig  die Pro-Version). Zu beziehen ist PyCharm unter dem Weblink [https://www.jetbrains.com/pycharm/]. Nachfolgend ein etwas abgewandeltes &quot;Hallo Welt&quot;-Programm, editiert und ausgeführt mit PyCharm.

[[Datei:PyCharm_IDE_2023_screenshot.png | 600px]]

Siehe auch {{W|PyCharm}}.

== Eric ==
Auch eric ist Open Source und steht unter der  GNU General Public License Version 3 oder später. Zu beziehen ist diese Software unter [https://eric-ide.python-projects.org/].

[[Datei:Screenshot_Eric_4.png | 600px]]

Siehe auch {{W|eric (Software)}}.

&lt;small&gt;
Unter openSUSE Tumbleweed sollte sich eric auch mit YaST installieren lassen. Bei mir gibt es aber dann beim Ausführen des eric-Programms eine Fehlermeldung (Stand März 2026): 
 
 ...
 ModuleNotFoundError: No module named 'PyQt6.QtPdfWidgets'

Umgehen kann man dieses Problem aber wieder mit dem Erstellen einer virtuellen Umgebung, in etwa so

 python3.13 -m venv ~/tmp/venv1
 cd ~/tmp/venv1/bin
 ./python3.13 -m pip install --upgrade --prefer-binary eric-ide
 ./eric7_ide
&lt;/small&gt;

== PyScripter ==
Vom Funktionsumfang vergleichbar mit den vorherigen IDEs ist PyScripter. Auch PyScripter ist Open Source. Die Projekt-Homepage findet sich auf [https://sourceforge.net/projects/pyscripter/]. PyScripter ist nur für MS Windows verfügbar.

[[Datei:PythonIng_pyscripter1.jpg | 600px]]

== Spyder IDE ==
Spyder enthält bereits eine stabile Python-Version und etliche Module (z.B. matplotlib, numpy, control). Ansonsten kann dieses Softwarepaket vom Funktionsumfang her mit den anderen genannten IDEs locker mithalten. Spyder wurde unter der MIT-Lizenz veröffentlicht. Diese Software findet sich auf [https://www.spyder-ide.org].

[[Datei:Spyder-windows-screenshot.png | 600px]]

Siehe auch {{W|Spyder (Software)}}

== Eclipse IDE==
Die {{W|Eclipse_(IDE)|Eclipse-IDE}} kann für Python aufgerüstet werden. Dazu gibt es das PyDev-Plugin. Installiert wird es über 
* Help &gt; Eclipse Marketplace... 
* Find - PyDev - Install
Danach muss noch der Pfad zum Python-Interpreter festgelegt werden 
* Window &gt; Preferences &gt; PyDev &gt; Interpreters &gt; Python Interpreter &gt; New ... 
Das Ergebnis ist ähnlich wie im folgenden Bild, nur dass statt C/C++ Python Verwendung findet. 

[[Datei:Setting Up Eclipse CDT helloout.png | 600px]]

== Sonstige ==
Die genannten IDEs sind nicht die Einzigen. Es gibt, um dem Image Pythons als beliebteste Programmiersprache gerecht zu werden, noch einige andere. Sowohl Open Source-Programme als auch kommerzielle Programme sind im Web zu finden, z.B. Thonny oder {{W|Visual Studio Code}}. Unter Linux kann man auch {{W|KDevelop}}, ausgestattet mit dem Python3-Plugin, einsetzen. Braucht man den Umfang von ausgewachsenen IDEs nicht, so kann man auch normale Texteditoren verwenden (z.B. {{W|Geany}} oder {{W|Kate_(Texteditor)|Kate}}).

= Debuggen und Testen =
Das Debuggen und Testen von Programmen sind wichtige Bestandteile der Programmierung. Syntaxfehler lassen sich i.A. leicht beheben. Schwieriger ist das Eingrenzen von logischen Fehlern, die ev. nur in bestimmten Situationen auftreten und keine explizite Fehlermeldung hervorrufen. Das Programm liefert falsche Ergebnisse oder es stürzt aus heiterem Himmel ab. Um das zu verhindern gibt es verschiedene Werkzeuge, die bei der Fehlersuche behilflich sein können. Vorerst siehe aber zwecks Begriffsklärung noch folgende Links: 
 
* {{W|Debuggen}}
* {{W|Debugger}}
* {{W|Softwaretest}}

&lt;gallery&gt;
First Computer Bug, 1947.jpg
Test ganzheitlich.png
V-Modell.svg
&lt;/gallery&gt;

== Das Modul pdb ==
Python bringt schon ein Modul zum Debuggen mit. Siehe z.B. [https://docs.python.org/3/library/pdb.html pdb — The Python Debugger].
Komfortabler lässt sich das aber mittels Integrierter Entwicklungsumgebungen (IDEs) angehen.

== Debuggen mit IDEs ==
Für die IDEs IDLE und Spyder sei kurz auf die entsprechenden Webseiten verwiesen:

* [https://www.cs.uky.edu/~keen/help/debug-tutorial/debug.html Debugging under IDLE].
* [https://docs.spyder-ide.org/current/panes/debugging.html Spyder Debugger]

Dort wird die Vorgehensweise auch mittels Screenshots erläutert.

== assert ==
assert ... behaupten, zusichern ({{W|Assertion (Informatik)}})

Python-Code:
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10., 0.)

Ausgabe:

 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10., 0.)
   File &quot;/home/hr/Develop/test1.py&quot;, line 4, in print1
     assert y != 0.0
            ^^^^^^^^
 AssertionError
 
Python-Code: 
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)
 
Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(&quot;10.&quot;, &quot;5.&quot;)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError
 
Aber auch bei nachfolgendem Code gibt es eine Fehlermeldung:

 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10, 5)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError

Damit letzteres funktioniert, kann man den Programmcode so umschreiben:
 def print1(x, y):
     assert type(x) == float or type(x) == int
     assert type(y) == float or type(y) == int
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 2.0
 
Und jetzt fangen wir den &lt;code&gt;AssertionError&lt;/code&gt; auf:
 def print1(x, y):
     try:
         assert type(x) == float or type(x) == int
         assert type(y) == float or type(y) == int
         assert y != 0.0
         print(x/y)
     except(AssertionError):
         print(&quot;Hallo&quot;)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)

Ausgabe:
 2.0
 Hallo

Ich hoffe, es ist wenigstens im Ansatz klar geworden, wofür &lt;code&gt;assert&lt;/code&gt; gut sein kann. Ausschalten kann man die &lt;code&gt;assert&lt;/code&gt;-Überprüfung übrigens mit dem Python-Schalter &lt;code&gt;-O&lt;/code&gt;.

== Doctests == 
Innerhalb eines Docstrings kann die Arbeit im interaktiven Modus simuliert werden. Nach den Promptzeichen (&gt;&gt;&gt;) erfolgen dann bei unserem Beispiel innerhalb des Docstrings simulierte Aufrufe der Funktion &lt;code&gt;print1()&lt;/code&gt;. Danach folgen jeweils die Sollresultate. Wird das Modul oder die Datei als Hauptprogramm aufgerufen, so wird die Funktion &lt;code&gt;doctest.testmode()&lt;/code&gt; aufgerufen und ein Bericht auf der Konsole ausgegeben. Wird das Modul nicht als Hauptprogramm aufgerufen, sondern importiert, dann wird diese &lt;code&gt;testmod&lt;/code&gt;-Funktion nicht aufgerufen. D.h. dieser Code kann sowohl für Testzwecke als auch für den produktiven Einsatz verwendet werden. Das ist auch sinnvoll, weil wenn man Teile der Datei immer löschen bzw. einfügen müsste, so würden sich Fehlerquellen auftun. Das würde den Sinn und Zweck von Doctests konterkarieren.  

 def print1(x=0., y=1.):
     &quot;&quot;&quot; Dividiere zwei Zahlen
     Autor: Intruder
     Datum: 12.08.2025
 
     &gt;&gt;&gt; print1(2., 1.)
     2.0
     &gt;&gt;&gt; print1(5., 2.)
     2.5
     &gt;&gt;&gt; print1(5.)
     5.0
     &quot;&quot;&quot;
     print(x/y)
 
 if __name__ == &quot;__main__&quot;:
     import doctest
     doctest.testmod(verbose=True)

Ausgabe:
 Trying:
     print1(2., 1.)
 Expecting:
     2.0
 ok
 Trying:
     print1(5., 2)
 Expecting:
     2.5
 ok
 Trying:
     print1(5.)
 Expecting:
     5.0
 ok
 1 items had no tests:
     __main__
 1 items passed all tests:
    3 tests in __main__.print1
 3 tests in 2 items.
 3 passed and 0 failed.
 Test passed.

Das gezeigte Beispiel ist so ziemlich das einfachste, das es gibt. Für weiterführende Details siehe z.B.:
* [https://peps.python.org/pep-0257/ PEP 257 – Docstring Conventions]
* [https://docs.python.org/3/library/doctest.html doctest — Test interactive Python examples]

''Einschub:'' Ganz ähnlich kann man auch Klassen testen, z.B. in folgendem Code-Fragment

 class Fahrzeug:
   # siehe Abschnitt &quot;Objektorientierte Programmierung&quot;
   # ...
 
 if __name__ == &quot;__main__&quot;:
   vauweh = Fahrzeug(170, 90)
   beemweh = Fahrzeug(200, 120)
   print(vauweh.convertGeschw())
   print(beemweh.convertGeschw())

Wird das Script als Hauptprogramm ausgeführt (z.B. zu Testzwecken), so erfolgt die Ausgabe der zwei, via &lt;code&gt;convertGeschw()&lt;/code&gt;, umgerechneten Geschwindigkeiten. Wird es aber als Modul eingebunden, so wird der letzte Programmabschnitt nicht ausgeführt (&lt;code&gt;__name__ == &quot;__main__&quot;&lt;/code&gt; ergibt &lt;code&gt;False&lt;/code&gt;).

== pytest ==
Siehe zu diesem Thema auch {{W|Modultest}}.

pytest ist ein externes Modul und muss vorab installiert werden, z.B. mittels 
 pip install -U pytest
 pip install -U pytest-html 

Python-Code, Datei test1.py:
 def add(x, y):
     return x + y
 
 def test_answer():
     assert add(1, 1) == 3

Starten von pytest in der Konsole:
 pytest test1.py
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py F                                                                                                            [100%]
 
 ========================================================= FAILURES ==========================================================
 ________________________________________________________ test_answer ________________________________________________________
 
     def test_answer():
 &gt;       assert add(1, 1) == 3
 E       assert 2 == 3
 E        +  where 2 = add(1, 1)
 
 test1.py:6: AssertionError
 ================================================== short test summary info ==================================================
 FAILED test1.py::test_answer - assert 2 == 3
 ===================================================== 1 failed in 0.09s =====================================================

Hier erhalten wir einen Fehler, da 1+1 eindeutig ungleich 3 ist. Aber aus irgendeinem Grund wollte der Programmierer oder Tester in diesem Fall, dass dies so ist. Testfälle werden übrigens mit dem Präfix &lt;code&gt;test_&lt;/code&gt; eingeleitet.

Python-Code:
 def add(x, y):
     return x + y + 1
 
 def test_answer():
     assert add(1, 1) == 3 
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py .                                                                                                            [100%]
 
 ===================================================== 1 passed in 0.01s =====================================================

Jetzt ist alles in Ordnung. Weiterführendes siehe z.B.

* [https://docs.pytest.org/en/stable/ pytest: helps you write better programs]

== unittest ==
Auch unittest dient zur Durchführung von Testreihen, ist aber Bestandteil von Python. Hier wird vorerst nicht näher darauf eingegangen. Siehe z.B. 
* [https://docs.python.org/3/library/unittest.html unittest — Unit testing framework]

Lt. ''Inden: Python Challenge; dpunkt, 2021, Seite 481''  soll unittest weniger komfortabel als pytest sein.

Einen Vergleich von unittest mit pytest findet man in
* [https://knapsackpro.com/testing_frameworks/difference_between/pytest/vs/unittest pytest vs unittest]

= Python und Anwendungsprogramme =
Bisher stand immer alleine die Programmiersprache Python (ev. unter Einbeziehung von Modulen) im Mittelpunkt der Betrachtungen. Aber Python kann auch als Makrosprache für Anwendungsprogramme auftreten. Als Beispiele seien {{W|FreeCAD}} und {{W|LibreOffice}} genannt.

== FreeCAD ==
FreeCAD ist ein freies 3D-CAD-Programm. Hier soll nicht auf die Bedienung dieses CAD-Pakets eingegangen werden, sondern nur auf die Möglichkeit, mittels Python Makros zu schreiben. Als einfacher Einstieg soll ein Makro erstellt werden, welches eine Kugel (rot) und einen Quader (blau) zeichnet. Folgende Vorbereitungsschritte sind erforderlich (es sei vorausgesetzt, dass FreeCAD schon am Rechner installiert ist. Downloaden können Sie das Programm von der Website [https://www.freecad.org/downloads.php?lang=en]):

* FreeCAD starten
* Leere Datei erstellen
* Makro &gt; Makros &gt; Erstellen ...

Es öffnet sich ein leeres Editorfenster, in das Sie folgenden Code eingeben können:

 import FreeCAD
 import Part
 
 doc = FreeCAD.newDocument()
 
 # Kugel
 kugel = Part.makeSphere(10)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Kugel&quot;)
 form_element.Shape = kugel
 kug = FreeCAD.ActiveDocument.getObject(&quot;Kugel&quot;)
 kug.ViewObject.ShapeColor = (1.0, 0.0, 0.0)
 neuePosition = App.Vector(5, 2.5, 2.5)
 kug.Placement = App.Placement(neuePosition, kug.Placement.Rotation)
 
 # Quader
 quader = Part.makeBox(5, 5, 50)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Quader&quot;)
 form_element.Shape = quader
 quad = FreeCAD.ActiveDocument.getObject(&quot;Quader&quot;)
 quad.ViewObject.ShapeColor = (0.0, 0.0, 1.0)
 
 doc.recompute()

Diesen Code können Sie nun ausführen:
* Makro &gt; Makro ausführen

Es ergibt sich folgende Ausgabe (gedreht und gezoomt):

[[Datei: PythonIng_freecad1.png|500px]]

Siehe auch [https://wiki.freecad.org/Python_scripting_tutorial/de# Anleitung Skripterstellung mit Python]. Getestet wurde obiges Beispiel mit FreeCAD 1.1.3 unter Linux und 1.1.1 unter MS Windows.

== LibreOffice ==
LibreOffice ist ein freies Officepaket ([https://de.libreoffice.org/]). Hier soll nur das Tabellenkalkulationsprogramm Calc kurz betrachtet werden. Es seinen in den ersten 3 Zellen (A1 bis A3) Zahlen gegeben. Diese sollen mit einem Python-Makro addiert und das Resultat in der Zelle A5 ausgegeben werden. Auch hier sind Vorbereitungsarbeiten nötig: 
* zuerst muss unter Linux das Verzeichnis &lt;code&gt;~/.config/libreoffice/4/user/Scripts/python&lt;/code&gt; erstellt werden
* für MS Windows ist es das Verzeichnis &lt;code&gt;%APPDATA%\LibreOffice\4\user\Scripts\python&lt;/code&gt; 
** drücken Sie zuerst Win + R (es öffnet sich das Ausführen-Fenster)
** geben Sie &lt;code&gt;%appdata%&lt;/code&gt; ein, danach drücken Sie Enter (es öffnet sich der Explorer)
** navigieren Sie zu dem genannten Verzeichnis bzw. erstellen Sie das Verzeichnis 
* in diesem Verzeichnis wird dann mit einem beliebigen Texteditor das Python-Makro erstellt, in unserem Fall die Datei &lt;code&gt;summiere_zellen.py&lt;/code&gt;:

 import uno
 
 def summiere_zellen(*args):
     # Zugriff auf das aktuelle Dokument und das aktive Tabellenblatt
     ctx = uno.getComponentContext()
     smgr = ctx.getServiceManager()
     desktop = smgr.createInstanceWithContext(&quot;com.sun.star.frame.Desktop&quot;, ctx)
     doc = desktop.getCurrentComponent()
     sheet = doc.getCurrentController().getActiveSheet()
 
     # Werte aus den Zellen A1 bis A3 auslesen
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
 
     # Addition der drei Werte
     summe = w1 + w2 + w3
 
     # Ergebnis in die Zelle A5 schreiben
     sheet.getCellRangeByName(&quot;A5&quot;).Value = summe

* siehe dazu ggf. auch [https://help.libreoffice.org/latest/de/text/sbasic/python/python_locations.html?DbPAR=BASIC].

Weiter geht es in LibreOffice Calc mit dem Menü ''Extras &gt; Makros &gt; Makros verwalten &gt; Python''. Dort wird das Makro &lt;code&gt;summiere_zellen&lt;/code&gt; ausgeführt. Es ergibt sich z.B. folgendes Resultat

[[Datei:PythonIng_libreoffice1.png]]

Das Kürzel &lt;code&gt;uno&lt;/code&gt; steht für '''U'''niversal '''N'''etwork '''O'''bjects. Etwas einfacher geht's auch so:

 def summiere_zellen():
     desktop = XSCRIPTCONTEXT.getDesktop()
     model = desktop.getCurrentComponent()
     sheets = model.getSheets()
     sheet = sheets.getByIndex(0)
     
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
     
     cell = sheet.getCellRangeByName(&quot;A5&quot;)    
     cell.setValue(w1 + w2 + w3) 

Empfohlen wird auch, das Erweiterungspaket APSO ('''A'''lternative '''P'''ython '''S'''cript '''O'''rganizer, apso.oxt) zu installieren. Die Vorgehensweise wird hier nicht gezeigt, sondern nur darauf hingewiesen, dass man das einfach &quot;googeln&quot; kann. Siehe zur Python-Programmierung für LibreOffice auch [https://wiki.documentfoundation.org/Macros/Python_Guide/de Makros/Python-Handbuch]. Getestet wurden obige Beispiele mit LibreOffice 26.2.5.1 unter Linux und 26.2.1.2 unter MS Windows.

= Ausblick =
Dies war eine kurze Einführung in die Berechnungs- und Darstellungsmöglichkeiten mit Python. Es sollten etliche relevante Themen behandelt, oder zumindest kurz angesprochen worden sein. Wem dieser Text nicht ausreichend ist, der sei auf die entsprechenden weiterführenden Weblinks, Bücher und die Python-Hilfefunktion verwiesen. Python kennt noch viel mehr Befehle, als hier dargestellt wurden. Das Themenspektrum ist auch durch die Einbindung externer Module fast beliebig erweiterbar.

= Weblinks=
== Python allgemein ==
* [https://www.python.org/ Python Homepage]

== Externe mathematische Module ==
* [https://numpy.org/ NumPy]
* [https://numpy.org/doc/stable/user/numpy-for-matlab-users.html NumPy for MATLAB users]
* [https://scipy.org/ SciPy]
* [https://www.sympy.org/en/index.html SymPy]
* [https://pandas.pydata.org/ pandas]
* [https://github.com/maroba/findiff findiff]
* [https://mpmath.org/ mpmath]

== Externe Module für Grafiken ==
* [https://matplotlib.org/ Matplotlib]
* [https://vpython.org/ VPython]
* [https://build123d.readthedocs.io/en/latest/ build123d]
* [https://docs.vtk.org/en/latest/api/python.html VTK]
* [https://docs.bokeh.org/en/latest/docs/first_steps.html bokeh]
* [https://py5coding.org/ py5]

== Erstellung von User Interfaces ==
* [https://docs.python.org/3/library/tkinter.html tkinter - Python interface to Tcl/Tk]
* [https://docs.python.org/3/library/curses.html curses - Terminal handling for character-cell displays]
* [https://wiki.qt.io/Qt_for_Python Qt for Python]
* [https://www.gtk.org/docs/language-bindings/python GTK and Python]

== Erstellen virtueller Umgebungen ==
* [https://docs.python.org/3/library/venv.html venv - Creation of virtual environments]

== Sonstige ==
* [https://python-control.readthedocs.io/en/stable/ Python Control Systems Library]
* [https://pypi.org/project/regex/ regex - Regular Expressions]
* [http://pyromat.org/ PYroMat]
* [https://coolprop.org/coolprop/wrappers/Python/index.html CoolProp]
* [https://pypi.org/project/iapws/ iapws]
* [https://tespy.readthedocs.io/en/main/getting_started/introduction.html TESPy - Thermal Engineering Systems in Python]
* [https://pint.readthedocs.io/en/stable/ pint]

= Bücher =
== Gedruckte Bücher, OpenBooks, Magazine ==
* Diverse: c't Python Lernen, Verstehen, Anwenden; Heise, 2022 
* Ernesti, Kaiser: Python3 - das umfassende Handbuch; 5. Aufl., Rheinwerk, [https://openbook.rheinwerk-verlag.de/python/ OpenBook]
* Iacono et al.: Programmieren trainieren; 3. Aufl., Hanser, 2023, ISBN 978-3-446-47766-7
* Inden: Python Challenge; dpunkt, 2021, ISBN 978-3-86490-809-5
* Klein: Numerisches Python; 2. Aufl., Hanser, 2023, ISBN 978-3-446-47170-2 
* Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler; Rheinwerk, 2021, ISBN 978-3-8362-7316-9
* Weigend: Python 3 - Das umfassende Praxisbuch; 9. Aufl., mitp, 2022, ISBN 978-3-7475-0544-1
* Woyand: Python für Ingenieure und Naturwissenschaftler; 4. Aufl., Hanser, 2021, ISBN 978-3-446-46483-4

== Andere Wikibooks ==
* [[:en:Subject:Python_programming_language | Englische Wikibooks zum Thema Python]]
* [[Python|Deutschsprachiges Python-Wikibook]] [[Bild:2von10.png|20%]]
* [[Python unter Linux|Python 2.7 unter Linux]] [[Bild:10von10.png|100%]]


{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}</text>
      <sha1>nf0n158ub0yv34euqlzq5od3p3rendi</sha1>
    </revision>
    <revision>
      <id>1092170</id>
      <parentid>1092168</parentid>
      <timestamp>2026-10-16T17:58:15Z</timestamp>
      <contributor>
        <username>Intruder</username>
        <id>1513</id>
      </contributor>
      <minor />
      <comment>/* MS Windows */</comment>
      <origin>1092170</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="189319" sha1="kd4ppf5k6nqfj7zo67kbc91bh7bswp7" xml:space="preserve">{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}


= Hallo Welt und allgemeine Hinweise =
== Was ist Python ==
* Python ist eine universelle höhere Programmiersprache.
* Python ist objektorientiert.
* Python ist Open-Source (Python Software Foundation License).
* Python ist für viele Betriebssysteme erhältlich (z.B. für Linux, MS Windows, macOS).
* Python ist ein Interpreter.
* Python ist durch Module fast beliebig erweiterbar.
* Python als Programmiersprache ist case-sensitive - d.h. Groß- und Kleinschreibung ist relevant bei der Eingabe von Befehlen.
* Python ist in etlichen Anwendungsprogrammen (z.B. {{W|FreeCAD}}, {{W|LibreOffice}}, {{W|GIMP}}, {{W|Blender (Software) | Blender}}) als Makrosprache verwendbar.

{{Wikipedia | Python (Programmiersprache)}}

== Python installieren ==
=== MS Windows ===
Laden Sie das aktuelle Python-Paket von der Webseite [https://www.python.org/] herunter. Weiter geht es wie bei jedem anderen größeren zu installierenden Programm. Einfach das Installationsprogramm im Explorer doppelklicken und den Anweisungen des Setup-Programmes folgen.

=== Linux ===
Entweder ist Python bereits standardmäßig installiert, ansonsten ist die Installation mittels Paketmanagementsystem einfach möglich. Aber auch die Spyder-Entwicklungsumgebung ([https://www.spyder-ide.org]) bietet einen guten Einstieg mit Python (das gilt auch für MS Windows). Spyder bringt auch schon etliche wichtige Module standardmäßig mit.

== Python starten ==
=== MS Windows ===
Das Icon für das Python-Programm doppelklicken. Und schon startet das Programm.

[[Datei:PythonIng_start1.jpg]]

Python im interaktiven Modus (REPL ... '''R'''ead-'''E'''valuate-'''P'''rint-'''L'''oop) präsentiert sich dann so:

 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

Alternativ kann das Programm auch über die Eingabeaufforderung oder die PowerShell gestartet werden:

 c:\devel\Python&gt;python.exe
 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

=== Linux ===
Tippen Sie einfach das Wort „python“ (oder unter openSUSE Tumbleweed z.B. auch „python3.11“ oder „python3.13“) in einem Linux-Terminal ein, schließen den Befehl mit der RETURN-Taste ab, und schon startet Python im interaktiven Modus:
 
 Python 3.13.12 (main, Feb 09 2026, 22:37:44) [GCC] on linux
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt; 

Es gibt auch noch andere Möglichkeiten Python zwecks Programmausführung zu starten, z.&amp;nbsp;B. den {{W|Shebang}} (&lt;code&gt;#!&lt;/code&gt;) am Beginn eines Python-Scripts. Das Script sei als Script.py gespeichert. Dann kann das Script mit ./Script.py ausgeführt werden. Für openSUSE Tumbleweed sei nachfolgend ein lauffähiges &quot;Hallo Welt!&quot;-Script angegeben. Es wird in diesem Script der Python-Interpreter in der Version 3.13 verwendet :

 #!/usr/bin/python3.13
 print(&quot;Hallo Welt!&quot;)

Die Berechtigungen zum Ausführen der Datei müssen natürlich noch richtig gesetzt werden, z.B. mittels &lt;code&gt;chmod 777 Script.py&lt;/code&gt;. &lt;small&gt;&lt;code&gt;chmod&lt;/code&gt; ist die Abkürzung für&quot;'''ch'''ange file '''mod'''e bits&quot;.&lt;/small&gt; 

&lt;small&gt;Die &quot;Maske&quot; &lt;code&gt;777&lt;/code&gt; ist nur für Testzwecke sinnvoll, weil sie leicht zu merken ist und für alle Benutzer alle Zugriffsberechtigungen ('''r'''ead/'''w'''rite/e'''x'''ecute für owner/group/others) setzt. Im richtigen Einsatz wird man das aus Sicherheitsgründen nicht so handhaben, sondern nur die Berechtigungen setzen, die unbedingt erforderlich sind. Welche Zugriffsberechtigungen gesetzt sind, kann man z.B. mit dem Befehl &lt;code&gt;ls -l&lt;/code&gt; oder &lt;code&gt;ll&lt;/code&gt; ('''l'''i'''s'''t directory contents) erfragen. Aber dazu im Moment genug. Erfahrene Linux-Nutzer kennen das ohnehin und Anfänger sollen jetzt nicht mit Linux-Interna überfordert werden. Bei Bedarf siehe die Linux-Man-Pages oder dezidierte Bücher zu Linux.&lt;/code&gt;&lt;/small&gt;

&lt;small&gt;Oder das Script wird in einen Pfad verschoben, in dem sich ausführbare Programme generell befinden (welche Verzeichnisse im PATH liegen, kann bspw. mit &lt;code&gt;echo $PATH&lt;/code&gt; abgefragt werden). Das Script kann dann wie ein normales Programm ohne weitere Angaben mit Script.py gestartet werden. Alternativ wird nicht das Script an sich verschoben, sondern nur ein symbolischer Link angelegt, z.B. mit &lt;code&gt;ln -s ~/tmp/Script.py ~/.local/bin/Script.py&lt;/code&gt;. &lt;code&gt;~/.local/bin&lt;/code&gt; sei ein im PATH gelegenes Verzeichnis. Dies sind aber schon Features für fortgeschrittene Linux-Benutzer und werden am Anfang eher selten benötigt.&lt;/small&gt;

== Ein paar Worte zur Erklärung ==
=== Tests ===
Getestet wurden die Beispiele unter den Betriebssystemen 
* MS Windows 10 mit der Python-Version 3.12.0 (teilweise auch mit 3.12.2 und 3.13.1; nur die Inhalte die bis spätestens Juli 2025 erstellt wurden) 
* MS Windows 11 ab der Python-Version 3.13.4 (nur zum Teil; ab Juli 2025)
* openSUSE Leap 15.6 mit der Python-Version 3.11.12 (Spyder, nur vereinzelt) und zum Teil mit 3.12.11 (ab Juli 2025 bis November 2025).
* openSUSE Tumbleweed ab der Python-Version 3.13.9 (nur vereinzelt, ab November 2025)

=== Popularität ===
* An Beliebtheit rangiert Python mit Stand September 2026 mit einem Rating von 17,76% an 1. Stelle vor C und C++ (lt. [https://www.tiobe.com/tiobe-index/ TPCI - TIOBE Programming Community Index]). 
* Lt. [https://innovationgraph.github.com/global-metrics/programming-languages GitHub Top 50 Programming Languages Globally] lag Python im Q1/2026 auf Rang 2, vor TypeScript und hinter JavaScript. 
* [https://pypl.github.io/PYPL.html PYPL] (Popularity of Programming Language Index) ist ein anderer Popularitätsindex für Programmiersprachen. Auch hier liegt Python mit großem Vorsprung auf dem ersten Platz (52,08%), gefolgt von Java (13,34%) und C/C++ (7,99%) (Stand September 2026). 

=== Namensgebung ===
Der Name &quot;Python&quot; rührt von der Komikertruppe {{W|Monty Python}} her. Die Icons für Python (z.B. Python selbst, Eric IDE, IDLE) sind aber durch die Python-Schlangenart symbolisiert.

&lt;gallery&gt;
Python-logo-notext.svg|Python-Logo
Guido van Rossum in PyConUS24.jpg|{{W|Guido van Rossum}} (geb. 1956), der Erfinder von Python
&lt;/gallery&gt;

== Ein erstes Programm ==
Kommentare werden in Python mit der Raute (#) eingeleitet. Sie werden vom Python-Interpreter ignoriert. Text kann mit der print-Funktion ausgegeben werden. Starten Sie Python und geben sie folgende Anweisungen zeilenweise ein

 &gt;&gt;&gt; # Das ist ein Kommentar
 &gt;&gt;&gt; print(&quot;Hallo Welt!&quot;)

Als Ergebnis erhalten Sie

 Hallo Welt!

Der Prompt (&gt;&gt;&gt;) ist selbstverständlich nicht einzutippen, sondern wird vom Python-System geliefert.

Strings können in Python entweder in Anführungszeichen (&quot;) gesetzt werden oder in Hochkommatas('). In diesem Text wird die erste Variante bevorzugt eingesetzt.

Im Gegensatz zu Julia ist es hier egal, ob zwischen &lt;code&gt;print&lt;/code&gt; und der öffnenden Klammer Leerzeichen stehen.

= Python als Taschenrechner =
== Allgemeines ==
Wir wollen 3 * 5 berechnen. Dazu starten wir Python im interaktiven Modus. Geben Sie dann die Formel  

 &gt;&gt;&gt; 3 * 5

ein, drücken die Taste ENTER/RETURN ({{Taste|↵}}) und erhalten als Ergebnis

 15

Auch kompliziertere Ausdrücke sind möglich. Beispielsweise mit Winkelfunktionen, Quadratwurzeln etc. Wir wollen nun den Ausdruck &lt;math&gt;\sin\sqrt{15}&lt;/math&gt; berechnen :

 &gt;&gt;&gt; import math
 &gt;&gt;&gt; math.sin(math.sqrt(15))
 -0.6679052983383519

Als erstes wird das math-Modul importiert. Dann wird der mathematische Ausdruck berechnet.

Eine andere Variante, die dasselbe Ergebnis liefert, ist

 &gt;&gt;&gt; from math import *
 &gt;&gt;&gt; sin(sqrt(15))
 -0.6679052983383519

Es wird also aus dem Modul &lt;code&gt;math&lt;/code&gt; alles importiert (erkennbar am &lt;code&gt;*&lt;/code&gt;). Will man nicht alles importieren, so kann man das auch einschränken:

 &gt;&gt;&gt; from math import sin, sqrt

Beenden lässt sich das Python-Programm durch Eingabe von &lt;code&gt;exit()&lt;/code&gt; (und natürlich ist zur Bestätigung die RETURN-Taste zu drücken). &lt;code&gt;exit&lt;/code&gt; (ohne Klammern) oder &lt;code&gt;quit&lt;/code&gt; werden auch akzeptiert.

== Die Hilfefunktion von Python ==
Bei Eingabe der Anweisung &lt;code&gt;help&lt;/code&gt; oder &lt;code&gt;help()&lt;/code&gt; springt Python in den Hilfemodus. 

Eingabe:
 &gt;&gt;&gt; help()
 
Eingabe:
 help&gt; math.sin

Ausgabe:
 Help on built-in function sin in math:
 
 math.sin = sin(x, /)
     Return the sine of x (measured in radians).

Für die komplette Python-Dokumentation siehe [https://docs.python.org/3/]. Verlassen kann man den Hilfemodus durch das Drücken von STRG-C, bzw. der Eingabe von q, quit oder exit mit anschließendem Drücken der RETURN-Taste.

== Aufgaben ==
* Erkunden Sie die Tangensfunktion &quot;tan&quot; mittels Python-Hilfe (vergessen Sie nicht das math-Modul zu importieren und das &lt;code&gt;math.&lt;/code&gt; vor &lt;code&gt;tan&lt;/code&gt;)
* Berechnen Sie mit Python den Ausdruck &lt;math&gt;\frac{1}{2}\cdot \text{e}^2 \cdot \tan(\pi/3)&lt;/math&gt;. Siehe für die Exponentialfunktion im Python-Hilfesystem auch den Befehl &lt;code&gt;math.exp&lt;/code&gt;. Alternativ kann auch die Konstante &lt;code&gt;math.e&lt;/code&gt; eingesetzt werden. Potenzieren kann man bei Python mit dem **-Operator (z.B. 2**3 = 8). Für &lt;math&gt;\pi&lt;/math&gt; gibt es &lt;code&gt;math.pi&lt;/code&gt;.

= Python als Scriptsprache =
Häufig wird man aber kompliziertere Anweisungsfolgen verarbeiten müssen. Diese will man normalerweise nicht jedesmal neu eingeben, sondern in einer Datei speichern und diese Datei dann zur Ausführung bringen. Speichern Sie dazu folgenden Code in einer Textdatei, z.B. unter MS Windows als c:\tmp\test1.py

 # Das ist ein Kommentar
 print(&quot;Hallo Welt!&quot;)

Python-Dateien werden mit der Dateiendung .py versehen. Achten Sie darauf, dass vor dem print keine Leerzeichen vorhanden sind. Das ist eine Python-Eigenheit. Wie wir später sehen werden, nutzt Python Einrückungen als syntaktisches Mittel, z.B. um bei Schleifen den Schleifenkörper zu kennzeichnen. 

Danach bringen Sie die Skriptdatei test1.py (sozusagen das Hauptprogramm) folgendermaßen zur Ausführung:

1) Starten Sie unter MS Windows die Eingabeaufforderung (oder alternativ auch die Windows PowerShell). Das sieht dann etwa so aus:

 Microsoft Windows [Version 10.0.19045.3693]
 (c) Microsoft Corporation. Alle Rechte vorbehalten.
 
 C:\Users\xyz&gt;

: &lt;small&gt;Falls jemand nicht weiß, wie man die Eingabeaufforderung startet: Eine Möglichkeit ist, einfach in der Taskleiste von Windows das &quot;Start&quot;-Symbol &amp;nbsp;([[Image:Windows_logo_-_2021_(Black).svg|10px]])&amp;nbsp; mit der rechten Maustaste anklicken. &quot;Ausführen&quot; auswählen (oder alternativ für die PowerShell unter Windows 10 den Eintrag &quot;Windows PowerShell&quot;, unter Windows 11 den Eintrag &quot;Terminal&quot;). Im sich öffnenden Dialogfenster gibt man in die &quot;Öffnen&quot;-Zeile das Wort &lt;code&gt;cmd&lt;/code&gt; ein und mit &quot;OK&quot; wird das Ganze bestätigt.&lt;/small&gt; 
 
2) Wechseln Sie mittels &lt;code&gt;cd c:\tmp&lt;/code&gt; in das Verzeichnis c:\tmp

3) Angenommen, Sie haben Python unter dem Pfad &lt;code&gt;c:\devel\Python\&lt;/code&gt; installiert. Starten Sie das Programm so (der Prompt &lt;code&gt;c:\tmp&gt;&lt;/code&gt;ist natürlich nicht mit einzutippen): 

 c:\tmp&gt;c:\devel\Python\python.exe test1.py

4) Wie erwartet ergibt sich folgende Ausgabe am Bildschirm

 Hallo Welt!

Die Vorgehensweise unter Linux ist prinzipiell gleich. Die kleinen Unterschiede, wie z.B. der Slash statt dem Backslash in Pfadangaben, sollten für Linux-Benutzer keine Hürde darstellen.

== Variablen ==
Variablenbezeichner können aus Buchstaben (A-Za-z), Ziffern (0-9) und Underscores (_) bestehen, dürfen aber nicht mit einer Zahl beginnen. Führende Underscores haben u.a. im Kontext mit der Objektorientierten Programmierung eine spezielle Bedeutung und sollten nicht für &quot;normale&quot; Variablenbezeichner verwendet werden.

Gültige Variablenbezeichner wären also:
 xyz
 x1
 _wert
 name_anzahl

Theoretisch kann man auch Umlaute, griechische Buchstaben u.ä. in Variablenbezeichnern nutzen, z.B.

 ößÜ = 16
 α = 134 
 print(ößÜ)
 print(α)

Ausgabe:
 16
 134

Davon wird aber aus offensichtlichen Gründen ({{W|Englisch als Lingua franca}}) abgeraten. Das Eurozeichen (€) etc. darf man ohnehin nicht in Variablenbezeichnern verwenden, dies ergäbe einen Syntaxfehler. Siehe dazu auch [https://peps.python.org/pep-3131/].

Es gibt in Python etliche Schlüsselwörter (z.B. for, if oder return). Diese dürfen nicht als eigene Variablenbezeichner verwendet werden. Eine Liste aller Schlüsselwörter liefert das Script

 import keyword
 print(keyword.kwlist)

&lt;small&gt;Übung: Speichern Sie dieses Script in eine Datei, z.B. in c:\tmp\test1.py. Führen Sie diese Datei aus, um die Liste der Schlüsselwörter auszugeben.&lt;/small&gt;

Da Python case-sensitiv ist, repräsentieren folgende Bezeichner verschiedene Variablen:
 xyz
 XYZ
 xYz

Werte werden an Variablen mittels Gleich-Zeichen (=) zugewiesen. Im Folgenden wird der Code immer in der Datei c:\tmp\test1.py gespeichert.

 x = 5
 y = 10
 z = x*y
 print(z)

Bringen Sie die Datei test1.py zur Ausführung, so erhalten Sie folgende Bildschirmausgabe

 50

Sie können auch mehrere Anweisungen in einer Zeile durch Semikolon getrennt schreiben. Dies führt aber zu unübersichtlichem Code.

 x = 5; y = 10; z = x*y; print(z)

Ausgabe:
 50

Auch aus der Programmiersprache C/C++ oder Java bekannte Konstrukte können Sie verwenden, z.B.
 x = 5
 # x = x - 2
 x -= 2
 print(x)

Bildschirmausgabe:

 3
 
Beachten Sie, dass mit dem =-Zeichen eine Wertezuweisung durchgeführt wird. Dies ist nicht äquivalent zum mathematischen =-Zeichen, wie am vorigen Beispiel zu ersehen ist. Den Inkrement-/Dekrementoperator (z.B. x++ oder x--) aus C/C++ oder Java kennt Python aber nicht.

Variablen sind nicht an einen bestimmten Datentyp gebunden, folgendes ist mit Python problemlos möglich:

 import math
 wert = 10
 print(wert)
 wert = 35.5
 print(wert)
 wert = &quot;Hallo&quot;
 print(wert)
 wert = math.pi
 print(wert)

Ausgabe:
 10
 35.5
 Hallo
 3.141592653589793

== Physische und logische Zeilen ==
In Python muss eine Anweisung in einer logischen Zeile Platz finden. Wird eine Anweisung aber zu lang für eine Zeile, dann kann sie in mehrere physische Zeilen unterteilt werden. Dies kann einerseits durch einen Backslash am Ende einer Zeile geschehen, z.B.

 a = 2 + \
 5
 
Dies stellt eine logische Zeile dar, die in zwei physische Zeilen unterbrochen ist.

Geklammerte Ausdrücke werden automatisch zu einer logischen Zeile verbunden, z.B.

 a = (2 + 
 5)
 
Achtung: Im ersten Beispiel darf nach dem Backslash nichts mehr stehen, auch kein Kommentar. Dies trifft im zweiten Bespiel nicht zu, hier könnte noch ein Kommentar folgen, z.B.

 a = (2 +    # Kommentar 
 5)

Auch für Strings gibt es Möglichkeiten, diese auf mehrere Zeilen aufzuspalten.

 # Kurzer String
 str1 = &quot;ABC&quot;
 
 # Langer String
 str2 = &quot;&quot;&quot;Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle&quot;&quot;&quot;
 
 # Backslash
 str3 = &quot;UVW\
 XYZ&quot;
 
 # Mit Klammern
 str4 = (&quot;Sehr langer Text, der automatisch .............. &quot;
         &quot;in einer einzigen Variable zusammengefügt wird.&quot;
 )
 
 print(str1)
 print(str2)
 print(str3)
 print(str4)

Ausgabe:

 ABC
 Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle
 UVWXYZ
 Sehr langer Text, der automatisch .............. in einer einzigen Variable zusammengefügt wird.

==Hexadezimale, oktale, binäre und andere Zahlen==
 d = 1050         # Dezimalzahl
 h = 0xAA2        # Hexadezimalzahl
 o = 0o12         # Oktalzahl
 b = 0b100001101  # Binärzahl
 
 print(d)
 print(h)
 print(o)
 print(b)

Ausgabe:
 1050
 2722
 10
 269

Groß- und Kleinbuchstaben sind in obigen Literalen übrigens egal. So kann man z.B. statt &lt;code&gt;0b1001&lt;/code&gt; auch &lt;code&gt;0B1001&lt;/code&gt; schreiben (siehe dazu [https://docs.python.org/3/reference/lexical_analysis.html#integer-literals]).

Sie können auch dezimale in hexadezimale Zahlen umwandeln, usw.:
 h = hex(1050)    # Dezimalzahl -&gt; Hexadezimalzahl
 b = bin(1050)    # Dezimalzahl -&gt; Binärzahl
 o = oct(1050)    # Dezimalzahl -&gt; Oktalzahl
 print(h)
 print(b)
 print(o)

Ausgabe:
 0x41a
 0b10000011010
 0o2032

Gegeben sei die Zahl 121 zur Basis 3. Diese soll in eine Dezimalzahl umgewandelt werden. Das kann so geschehen:

 z = int(&quot;121&quot;, 3)
 print(z)

Ausgabe:
 16

Dass dies richtig ist, davon kann man sich folgendermaßen überzeugen:
 &lt;math&gt; 1 \cdot 3^2 + 2 \cdot 3^1 + 1 \cdot 3^0 = 9 + 6+ 1 = 16 &lt;/math&gt;

Zahlen übersichtlicher schreiben kann man auch mittels Underscore, z.B.:

 print(&quot;Eine Million (Variante 1) =&quot;, 1000000)
 print(&quot;Eine Million (Variante 2) =&quot;, 1_000_000)
 print(&quot;Eine Rechnung:&quot;, 2_000 * 400_000);

Es ergibt sich bei beiden Varianten die gleiche Ausgabe. Variante 2 ist aber im Sourcecode leichter lesbar, detto die Zahlen in der Rechnung:

 Eine Million (Variante 1) = 1000000
 Eine Million (Variante 2) = 1000000
 Eine Rechnung: 800000000

== Strings und Platzhalter==
Ein paar einfache Beispiele:

 print(&quot;Hallo {}&quot; . format(&quot;Hugo&quot;))     # new style string formatting
 print(&quot;Hallo {:s}&quot; . format(&quot;Hugo&quot;))   # new style string formatting
 print(&quot;Hallo %s&quot; % &quot;Hugo&quot;)             # %-String

Ausgabe:

 Hallo Hugo
 Hallo Hugo
 Hallo Hugo

Python-Code (formatted string literals, Beispiel 1):
 str1 = &quot;Hallo&quot;
 str2 = &quot;Hugo&quot;
 print(f&quot;{str1} {str2}&quot;)

Ausgabe:
 Hallo Hugo

f-Strings (ab Python 3.6) sind die modernere Variante gegenüber %-Strings oder das ''new style string formatting''. Sie sind in der Regel auch schneller.

Python-Code (formatted string literals, Beispiel 2):
 wert = 11.567
 print(f&quot;Ausgabe: {wert:.5f}&quot;)

Ausgabe:
 Ausgabe: 11.56700

Komplexere Beispiele:

 print(&quot;Hallo {} und {}&quot; . format(&quot;Hugo&quot;, &quot;Mike&quot;))
 print(&quot;Hallo {name1} und {name2}&quot; . format(name2=&quot;Hugo&quot;, name1=&quot;Mike&quot;))
 # Füllzeichen: *
 # Bündigkeit: &gt; (=rechts), &lt; (=links), ^ (=zentriert)
 # Feldweite: 10
 # Typ: s (=String), f (=Gleitkommazahl), d (=Dezimalzahl) etc.
 print(&quot;Hallo {:*&gt;10s}&quot; . format(&quot;Hugo&quot;))
 print(&quot;Hallo {:*&lt;10s}&quot; . format(&quot;Hugo&quot;))

Ausgabe:

 Hallo Hugo und Mike
 Hallo Mike und Hugo
 Hallo ******Hugo
 Hallo Hugo******

Python-Code:
 str = &quot;Hallo\t%s\t%7.2f\t%10.2e\t%i&quot; % (&quot;Hugo&quot;, 12.34567, 34.567, 264)
 print(str)

Ausgabe:
 Hallo	Hugo	  12.35	  3.46e+01	264

== Unicode ==
Neben den bekannten ASCII-Zeichen lassen sich Zeichen auch mittels Unicode beschreiben. Griechische Buchstaben oder komplexere mathematische Operatoren - all das sollte kein Problem sein. Siehe auch {{W|Unicode}}, {{W|Liste der Unicodeblöcke}} und {{W|Unicodeblock Mathematische Operatoren}}. Im Folgenden werden ein paar Zeichen (Allquantor, Nabla-Operator, Existenzquantor), die man aus der Mathematik kennt, erzeugt. 
 
 ch1 = &quot;\N{FOR ALL}&quot;
 ch2 = &quot;\N{NABLA}&quot;
 ch3 = &quot;\u2203&quot;
 print(ch1, ch2, ch3)

Ausgabe:
 ∀ ∇ ∃

&lt;small&gt;Diese Ausgabe ergibt sich z.B. mit der IDLE-Shell oder mit Cygwin. Beim Ausführen über die Windows-Eingabeaufforderung oder Windows PowerShell unter MS Windows 10 erfolgt keine korrekte Darstellung. IDLE ist die mit Python mitgelieferte IDE ('''I'''ntegrated '''D'''evelopment '''E'''nvironment, Integrierte Entwicklungsumgebung). Gegen Ende dieses Textes wird IDLE kurz beschrieben.
Das Problem mit der Windows Eingabeaufforderung lässt sich aber umgehen. Man muss nur eine Schriftart auswählen, die die Zeichen kennt, z.B. &quot;DejaVu Sans Mono&quot;. Dazu klicken Sie einfach bei der Eingabeaufforderung mit der rechten Maustaste oben auf die weiße Leiste und wählen im aufpoppenden Fenster den Menüpunkt &quot;Eigenschaften&quot;. Es öffnet sich ein Dialogfenster. Über den Reiter &quot;Schriftart&quot; lässt sich nun die Schriftart einstellen. Unter MS Windows 11 oder openSUSE Leap 15.6 (bash-Konsole) gibt es dieses Problem ohnehin nicht.&lt;/small&gt;

== Reguläre Ausdrücke ==
Python kennt auch {{W|Regulärer Ausdruck|reguläre Ausdrücke}}. Dazu gibt es in Python das Modul &lt;code&gt;re&lt;/code&gt;. Beipielsweise sollen alle Zahlen (&lt;math&gt;\text{zahl}\in\mathbb{N}_0&lt;/math&gt;) in einem String gesucht und ausgegeben werden. Als String sei gegeben: &lt;code&gt;3x Grüße und 100 Kekse.&lt;/code&gt; Das Muster (Pattern) ist &lt;code&gt;\d+&lt;/code&gt;. &lt;code&gt;\d&lt;/code&gt; steht für eine Dezimalziffer 0-9. Das Plus-Zeichen (+) steht symbolisch für ein oder mehrere Zeichen des vorherigen Ausdrucks. Hier also ein oder mehrere Dezimalziffern. Es wird die Funktion &lt;code&gt;findall&lt;/code&gt; aus dem Modul &lt;code&gt;re&lt;/code&gt;verwendet.

Python-Code:
 from re import findall
 
 str = &quot;3x Grüße und 100 Kekse.&quot;
 pat = &quot;\\d+&quot;  # Doppel-Backslashes müssen verwendet werden, sonst gibt Python eine Warnung aus!
               # alternativ: pat = r&quot;\d+&quot; 
               # oder: pat = &quot;[0-9]+&quot;
 
 numb = findall(pat, str)
 print(numb)

Ausgabe:
 ['3', '100']

Python kennt noch viele weitere Möglichkeiten mittels regulärer Ausdrücke zu hantieren. Dies soll hier aber nicht vertieft werden, da das Thema schon ziemlich speziell und komplex ist. Bei Bedarf siehe aber z.B. die Bücher ''Weigend, Seite 380ff'' und ''Ernesti, Kaiser'' [https://openbook.rheinwerk-verlag.de/python/28_001.html] oder die Python-Dokumentation [https://docs.python.org/3/library/re.html]. Auch [[Python unter Linux: Reguläre Ausdrücke]] liefert ein umfangreiches und brauchbares Python-2-Kapitel zu den regulären Ausdrücken. Die dort gelisteten Beispiele müssten ggf. vor Verwendung auf Python-3 umgeschrieben werden. &lt;small&gt;Wie macht  man das? Dazu siehe z.B. [https://openbook.rheinwerk-verlag.de/python/43_001.html], [https://portingguide.readthedocs.io/en/latest/] oder [https://www.digitalocean.com/community/tutorials/how-to-port-python-2-code-to-python-3]&lt;/small&gt;

&lt;small&gt;Es gibt auch ein externes Modul ''regex'', das bei Bedarf extra installiert werden muss ([https://pypi.org/project/regex/]). Es bietet zusätzliche Funktionalität und gründlicheren Unicode-Support. Dies sei hier aber nur der Vollständigkeit halber erwähnt.&lt;/small&gt;

== Verzweigungen ==
=== if ===
Die IF-Verzweigung sei aus anderen Programmiersprachen bereits bekannt. In {{W|Pseudocode}} lässt sie sich folgendermaßen darstellen:

 WENN bedingung TRUE
   führe block1 aus
 SONST
   führe block2 aus
 ENDE 

Als {{W|Aktivitätsdiagramm|UML-Aktivitätsdiagramm}} sieht das in etwa so aus:

[[File:If-Then-Else-diagram.svg|200px]]

Und als {{W|Nassi-Shneiderman-Diagramm|Nassi-Shneiderman-Struktogramm}} so:

[[File:Zweiseitige Auswahl.png|250px]]

In Python gibt es keinen expliziten ENDE-Kennzeichner. Stattdessen wird der Code durch Einrückungen strukturiert. Alles mit der gleichen Einrückungstiefe gehört zum selben Block. Dies zeichnet Python vor anderen Programmiersprachen aus.

Die test1.py-Datei laute also wie folgt:

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
   print(&quot;x ist groesser oder gleich 4&quot;)  

Ausgabe:

 Der else-Zweig wird ausgefuehrt
 x ist groesser oder gleich 4

Man achte auch auf die Doppelpunkte in der if- und else-Zeile. Darauf vergisst man gerne, wenn man von anderen Programmiersprachen kommt.

Folgendes wäre in Python ein Fehler (genauer gesagt ein IndentationError).

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
     print(&quot;x ist groesser oder gleich 4&quot;)  

Auch Nachstehendes würde nicht zum gewünschten Ergebnis führen (löst aber keine Fehlermeldung aus). Der letzte print-Befehl ist schon außerhalb der IF-ELSE-Verzweigung.

 x = 3
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
 print(&quot;x ist groesser oder gleich 4&quot;)

Ausgabe:

 x ist kleiner als 4
 x ist groesser oder gleich 4

Python kennt eine Reihe von Vergleichs- und Verknüpfungsoperatoren:

    &lt;, &lt;= ... kleiner (gleich)
    &gt;, &gt;= ... größer (gleich)
    == ... gleich
    != ... ungleich
    is ... identisch
    is not ... nicht identisch
    and ... AND
    or ... OR
    not ... NOT

Beispielsweise:

 a = 5
 b = 9
 
 if a&lt;=10 and b!=7:
   print(&quot;OK&quot;)
 else
   print(&quot;Nicht OK&quot;)

Ausgabe:

 OK

Der else-Block kann übrigens auch ersatzlos entfallen. Als Pseudocode sieht das so aus

 WENN bedingung TRUE
   führe block aus
 ENDE

Mehrfache Verzweigungen werden durch das elif-Konstrukt erstellt. In Pseudocode:

 WENN bedingung1 TRUE
   führe block1 aus
 SONST WENN bedingung2 TRUE
   führe block2 aus
 SONST WENN bedingung3 TRUE
   führe block3 aus
 SONST
   führe block4 aus
 ENDE

Ein Python-Beispiel:
 a = 14
 
 if a&lt;=10:   
   print(&quot;&lt;=10&quot;)
 elif a&gt;=11 and a&lt;=15:
   print(&quot;11 bis 15&quot;)
 elif a&gt;=16 and a&lt;=20:
   print(&quot;16 bis 20&quot;)
 else:
   print(&quot;&gt;20&quot;)

Ausgabe:

 11 bis 15

In Python gibt es auch die Schlüsselwörter &lt;code&gt;True&lt;/code&gt; (für wahr) und &lt;code&gt;False&lt;/code&gt; (für falsch). Man beachte, dass sie mit Großbuchstaben beginnen. Andere Schreibweisen wären ein Fehler. Sie gehören zum Datentyp &lt;code&gt;bool&lt;/code&gt;. Ihnen sind auch die Zahlen &lt;code&gt;1&lt;/code&gt; und &lt;code&gt;0&lt;/code&gt; zugewiesen.

Man beachte, dass {{W|Rundungsfehler}} auftreten können. D.h. man sollte  bei der Verwendung von {{W|Gleitkommazahl|Gleitpunktzahlen}} niemals auf absolute Genauigkeit prüfen, sondern eine Toleranz (einen &lt;math&gt;\varepsilon&lt;/math&gt;-Wert) vorgeben.
 
Ein klassisches Beispiel, das ein falsches Ergebnis liefert, ist:

 i = 0.1 + 0.2
 
 print(i)
 
 if i == 0.3:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 NOK

Und das, obwohl man schon in der Volksschule lernt, dass 0.1 + 0.2 gleich 0.3 ist.

Korrekt muss das obige Beispiel z.B. so umgeschrieben werden:

 ist = 0.1 + 0.2
 soll = 0.3
 epsilon = 0.000001
 
 print(ist)
 
 if abs(ist-soll) &lt; epsilon:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 OK

Alternativ kann auch die &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion verwendet werden. Das sei aber hier nur erwähnt und nicht konkret ausgeführt.

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet zum Thema &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion.

=== match ===
Ab Python 3.10 gibt es auch die match-Anweisung. Dies ist das Python-Pendant für die switch-Anweisung in anderen Programmiersprachen, geht aber bei näherer Betrachtung weit darüber hinaus. Hier nur ein einfaches Beispiel:

 x = &quot;Hello&quot;
 
 match x:
     case &quot;Servus&quot; | &quot;Ciao&quot;:         # or
         print(&quot;Servus an alle&quot;)
     case &quot;Grüetzi&quot;:
         print(&quot;Grüetzi Schwyzer&quot;)  
     case _:                         # other, default, sonstiges ...
         print(&quot;Hallo Welt&quot;)

Ausgabe: 
 Hallo Welt

Als Struktogramm sieht das in etwa so aus:

[[File:Mehrseitige Auswahl.png|250px]]

Für nähere Details siehe z.B. [https://www.geeksforgeeks.org/python-match-case-statement/], [https://learnpython.com/blog/python-match-case-statement/], [https://docs.python.org/3/tutorial/controlflow.html#match-statements] und das Python Enhancement Proposal (PEP) 636 – Structural Pattern Matching: Tutorial [https://peps.python.org/pep-0636] und dort insbesondere den Anhang A - Quick Intro.

&lt;small&gt;&lt;code&gt;match, case, _&lt;/code&gt; etc. sind sogenannte ''soft keywords''. Im Gegensatz zu den normalen Schlüsselwörtern dürfen ihnen auch Werte zugewiesen werden. Eine Liste der weichen Schlüsselwörter lässt sich durch &lt;code&gt;keyword.softkwlist&lt;/code&gt; erstellen (die Anweisung gibt es seit Python 3.9). Siehe dazu auch [https://stackoverflow.com/questions/65800344/what-are-soft-keywords] und [https://docs.python.org/3/library/keyword.html#keyword.softkwlist].&lt;/small&gt;

== Schleifen ==
Kopfgesteuerte Schleife, Endlosschleife und fußgesteuerte Schleife:

[[File:Programmingloops.svg|450px]]

=== while ===
Die WHILE-Schleife ist kopfgesteuert. Sie funktioniert wie aus anderen Programmiersprachen bekannt. 

In Pseudocode:
 SOLANGE bedingung TRUE
   führe block aus
 ENDE

In Python:
 x = 0
 
 while x &lt;= 10:
   print(x)
   x += 1

Ausgabe:
 0
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10

Eine Endlosschleife ergibt sich z.B. so:
 i = 5
 
 while True:
     print(i)
     i-=1

Beendet werden kann sie mit der Tastenkombination STRG-C.

Eine fußgesteuerte Schleife kann so simuliert werden:
 i = 5
 
 while True:
     print(i)
     i-=1
 
     if i&lt;=0:
         print(&quot;Fire&quot;)
         break

Ausgabe:
 5
 4
 3
 2
 1
 Fire

Der &lt;code&gt;break&lt;/code&gt;-Befehl wird etwas [[Ing_Mathematik:_Python#break|später]] noch einmal kurz thematisiert.

=== for ===
Struktogramm einer for-Schleife:

[[File:Zählschleife.png|200px]]

In Python bspw. so:

 for x in range(6):
   print(x*2)

Ausgabe:
 0
 2
 4
 6
 8
 10

Die Schleife läuft von 0 bis 5. Ausgegeben wird jeweils der Wert x*2. Aquivalent kann diese Schleife auch so geschrieben werden:
 for x in range(0, 11, 2):
   print(x)

Die Ausgabe ist wie oben. Der Startwert sei 0, der Endwert ist 11-1 und die Schrittweite ist 2.

Ein anderes Beispiel sei
 for x in &quot;text&quot;:
   print(x)

Ausgabe:
 t
 e
 x
 t

== Schleifen abbrechen ==
=== break ===
&lt;code&gt;break&lt;/code&gt; bricht die Schleife ab und setzt mit dem nächsten Befehl außerhalb der Schleife fort.

 for var in range(100):
   print(var) 
   if var == 5:
     break

Ausgabe:
 0
 1
 2
 3
 4
 5

=== continue ===
&lt;code&gt;continue&lt;/code&gt; bricht den aktuellen Schleifendurchlauf ab und setzt mit dem nächsten Schleifendurchlauf fort.

 for var in range (11):
   if var == 5:
     continue
   print(var)

Ausgabe:
 0
 1
 2 
 3
 4
 6
 7
 8
 9
 10

== try - except ==
 try:
     z1 = 12 / 0
     print(z1)
 except ZeroDivisionError:
     print(&quot;Das Ergebnis ist unendlich&quot;)
 except:
     print(&quot;Kann nicht berechnet werden!&quot;)
     print(&quot;Bitte die Formel korrigieren!&quot;)
 
 print(&quot;Setze Programm fort!&quot;)

Ausgabe:
 Das Ergebnis ist unendlich
 Setze Programm fort!

Es wird versucht, eine Zahl durch Null zu dividieren. Das ist nicht möglich, es wird eine Ausnahme ausgelöst. Das Programm springt daher in den except-ZeroDivisionError-Block und führt die dort gelisteten Anweisungen aus (in unserem Fall eine print-Anweisung). Danach wird das Programm fortgesetzt. Würden wir dieses Programm ohne try-except ausführen, so ergibt sich aus

 z1 = 12 / 0
 print(z1)

folgende Fehlermeldung und ein unmittelbarer Programmabbruch

 Traceback (most recent call last):
   File &quot;C:\tmp\test1.py&quot;, line 1, in &lt;module&gt;
     z1 = 12 / 0
 ZeroDivisionError: division by zero

Mit dem try-except-Mechanismus können also Ausnahmen oder Fehler aufgefangen und behandelt werden. In unserem Beispiel ist das eher trivial, aber bei größeren Programmen kann das durchaus Sinn machen.

Neu in Python 3.14 ist, dass mehrere Ausnahmen auch ohne Klammern angegeben werden können, z.B.:

bis inkl. Python 3.13 nur:
 except (ZeroDivisionError, ValueError):

ab Python 3.14 auch:
 except ZeroDivisionError, ValueError:

== pass ==
Ein leerer Block muss in Python mittels dem Schlüsselwort &lt;code&gt;pass&lt;/code&gt; dargestellt werden. Z.B.

 x = 2
 
 if x == 1:
     print(&quot;Wert ist &quot;, x)
 else:
     pass

Würde man das &lt;code&gt;pass&lt;/code&gt; im else-Block weglassen, so würde man eine Fehlermeldung erhalten:

 IndentationError: expected an indented block after 'else' statement on line 5

= Funktionen =
== Aufrufen von Funktionen ==
Funktionen sind uns im Rahmen dieses Kurses schon zuhauf begegnet. Sei es die print()-, die math.sin()- oder die hex()-Funktion. All diese Funktionen werden von Python zur Verfügung gestellt, ohne dass man sie explizit programmieren müsste. Aufgerufen werden diese Funktionen, indem man ihren Namen eintippt, gefolgt von runden Klammern. In diesen Klammern können noch Argumente übergeben werden. Auch Rückgabewerte sind möglich.

== Funktionen selber schreiben ==
Funktionen werden mit dem def-Schlüsselwort (man definiert die Funktion) eingeleitet, danach folgt der Funktionsname, danach wiederum runde Klammern, in denen formale Argumente stehen können. Abgeschlossen wird die def-Zeile mit einem Doppelpunkt. Danach folgt der Funktionskörper. Dieser Funktionskörper muss wiederum eingerückt werden (wie von den Verzweigungen und Schleifen bekannt). Aufgerufen wird diese Funktion, indem man ihren Funktionsnamen eingibt, gefolgt von runden Klammern (ggf. mit den aktuellen Parametern). Z.B.

 # Funktion definieren
 def halloWelt(i):
     # i ... beliebige Ganzzahl
     print(&quot;Hallo &quot; * i, end=&quot;&quot;)
     print(&quot;Welt!&quot;)
    
 # Funktion aufrufen
 halloWelt(3)

Ausgabe:
 Hallo Hallo Hallo Welt!

Unterschied zwischen formalen und aktuellen Parametern:

[[Datei:PythonIng_func1.jpg]]

&lt;small&gt;Aktuelle Parameter werden auch Argumente genannt.&lt;/small&gt;

Rückgabe von Funktionswerten:
 # Funktion definieren
 def mathFunc(a, b):
     r1 = a + b
     r2 = a * b
     return r1, r2
    
 # Funktion aufrufen
 c, d = mathFunc(3, 5)
 
 # Ausgabe der zurückgegebenen Werte
 print(c)
 print(d)

Ausgabe:
 8
 15

Es werden r1 und r2 zurückgegeben und den Variablen c und d zugewiesen. (r1, r2) und (c, d) sind Tupel. Was Tupel konkret sind, siehe etwas später in diesem Kapitel. 3 und 5 sind die aktuellen Parameter (die Argumente). a und b sind die formalen Parameter. Die Zuweisung der aktuellen zu den formalen Parametern erfolgt in der gegebenen Reihenfolge, also die Zahl 3 wird an a übergeben und die Zahl 5 an b.

Vorgabeparameter, z.B.:
 def mathFunc(a=10, b=20):
     r1 = a + b
     r2 = a * b
     return r1, r2
 
 c, d = mathFunc(3, 5)
 print(c)
 print(d) 
 
 e, f = mathFunc(5)
 print(e)
 print(f)
 
 g, h = mathFunc(b=6)
 print(g)
 print(h)

Ausgabe:
 8
 15
 25
 100
 16
 60

Erklärung:
* Erster &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es werden, wie weiter oben, die Argumente 3 und 5 an die formalen Parameter a und b übergeben. Die Rückgabewerte r1 und r2 werden an c und d übergeben. Somit ist c=8 und d=15.
* Zweiter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur das Argment 5 an a übergeben. b behält den Vorgabewert 20. D.h. e= 25 und f=100.
* Dritter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur die Zahl 6 an b übergeben, a behält seinen Vorgabewert 10. Somit ergibt sich g=16 und h=60.

Beispiel (Schlüsselwortargumente vs. Positionsargumente):
 def mathFunc(a, b):
     r1 = a - b
     r2 = a / b
     return r1, r2
 
 c, d = mathFunc(b=3, a=5)  # Schlüsselwortargumente
 e, f = mathFunc(3, 5)      # Positionsargumente

 print(c)
 print(d)
 print(e)
 print(f)

Ausgabe:
 2
 1.6666666666666667
 -2
 0.6

Durch die Verwendung von Schlüsselwortargumenten können die Argumente in beliebiger Reihenfolge angegeben werden. Bei den Positionsargumenten ist die Reihenfolge vorgegeben. Daraus resultiert auch der Unterschied bei den obigen Ausgaben. Werden beide Arten in einem Aufruf gemischt, so müssen die Positionsargumente zuerst angegeben werden. Den Unterschied zwischen beiden Argumentarten zu kennen ist wichtig, nicht nur bei selbst erstellten Funktionen. Auch beim Aufruf von Python-Funktionen verfolgt einen die Mischung von Schlüsselwort- und Positionsargumenten auf Schritt und Tritt, z.B. beim etwas später folgenden Abschnitt über &quot;Grafiken zeichnen&quot;:

 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)

Bei dieser &lt;code&gt;plot&lt;/code&gt;-Funktion aus dem Modul &lt;code&gt;matplotlib.pyplot&lt;/code&gt; sind &lt;code&gt;x&lt;/code&gt; und &lt;code&gt;y1&lt;/code&gt; Positionsargumente. &lt;code&gt;label, lw&lt;/code&gt; und &lt;code&gt;ls&lt;/code&gt; sind die Namen der Schlüsselwortargumente. Die Schlüsselwortargumente könnten auch in anderer Reihenfolge angeschrieben werden, nicht jedoch die Positionsargumente!
Siehe zu &lt;code&gt;matplotlib.pyplot.plot&lt;/code&gt; auch die Seite [https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html].

== Lambda-Funktionen ==
 print((lambda a, b: a*b) (3, 5))

Ausgabe:
 15

Eingeleitet wird eine Lambda-Funktion (auch Lambda-Form, Lambda-Operator oder anonyme Funktion genannt) mit dem Schlüsselwort &lt;code&gt;lambda&lt;/code&gt;. Es folgen die formalen Argumente, danach ein Doppelpunkt, die Berechnungsvorschrift und ggf. abschliessend in Klammern die aktuellen Parameter.

Man kann einer Lambda-Funktion auch einen Funktionsnamen geben und die Funktion über diesen Namen aufrufen, z.B.

 prod = lambda a, b: a*b
 print(prod(3, 5))

Als Ausgabe wird wieder die Zahl 15 geliefert.

== Rekursive Funktionen ==
Funktionen können wiederum andere Funktionen aufrufen. Von einem {{W|Rekursion|rekursiven Funktionsaufruf}} spricht man, wenn die aufgerufene Funktion gleich der aufrufenden ist. 

 def printFunc(i):
     if (i &gt;= 5):
         return 
     else:
         print(&quot;Hallo Welt&quot;)
         printFunc(i+1)
         
 printFunc(1)

Ausgabe:
 Hallo Welt
 Hallo Welt
 Hallo Welt
 Hallo Welt

Typische Beispiele für die Abarbeitung als rekursive Funktionen sind die {{W|Fibonacci-Folge}} und die {{W|Fakultät_(Mathematik)|Fakultät}}. Jedoch ist der iterative Ansatz (mit konventionellen Schleifen) meist schneller und speicherplatzschonender.

== Funktionsannotationen ==
Python ist sehr flexibel, was Typen angeht. Im Vorhergehenden haben wir generell keine Typangaben gemacht. Will man Typen angeben, so bietet Python das Konzept der Funktionsannotation.

 def calcFunc(a: int, b: int) -&gt; int:
     return a+b
 
 r1 = calcFunc(8, 9)
 r2 = calcFunc(8.0, 9.0)
 r3 = calcFunc(&quot;Hallo&quot;, &quot;Welt&quot;)
 
 print(r1)
 print(r2)
 print(r3)

Ausgabe:
 17
 17.0
 HalloWelt

Jetzt sieht man auf den ersten Blick, welche Typen der Programmierer im Sinn hatte, als er die Funktion erstellte. Das Problem dabei ist nur, dass es Python ziemlich egal ist, welche Typen man im Endeffekt eingibt. Im obigen Beispiel können statt Integer-Typen u.a. auch Float- oder String-Typen eingegeben werden.

&lt;small&gt;
Siehe zum Thema &quot;Type Checking&quot; aber auch den später folgenden Abschnitt [[Ing_Mathematik:_Python#Type_Checker]].
&lt;/small&gt;

== Variadische Funktionen ==
Python-Code:

 def test1(a, *b):
     print(a);
      
     for c in b:
         print(c);
        
 test1(&quot;Hallo&quot;, &quot;Welt&quot;, &quot;Schweizer&quot;, &quot;und alle anderen&quot;)

Ausgabe:

 Hallo
 Welt
 Schweizer
 und alle anderen

Mit dem Stern (auch als Splat-Operator bezeichnet) in der formalen Parameterliste bei der Funktion &lt;code&gt;test1&lt;/code&gt; wird angezeigt, dass eine beliebige Anzahl von Argumenten übergeben wird. &lt;small&gt; Dies entspricht in etwa dem, was in anderen Programmiersprachen (PHP etc.) mittels Ellipse (&lt;code&gt;...&lt;/code&gt;) angezeigt wird.&lt;/small&gt;

= Tupel, Listen und andere =
[[Datei:Python 3. The standard type hierarchy.png|mini|hochkant=1.7|Datentypen und Strukturen]]

== Tupel und Listen ==
Tupel, Listen und einige andere sind Datenstrukturen oder Sequenzen.

Listen (z.B. eine Einkaufsliste) sind veränderbar (mutable). Ein Tupel kann dagegen nicht verändert werden (immutable). Listen werden beim Anlegen in eckige Klammern eingeschlossen, Tupel in runde Klammern. Beim Tupel können die Klammern auch weggelassen werden. Ein Tupel mit nur einem Element muss mit einem Beistrich abgeschlossen werden. Der Grund ist, dass Python sonst nicht entscheiden kann, ob ein Tupel angelegt werden soll, oder nur ein geklammerter Wert. 

Als Gedächtnisstütze kann man sich den Unterschied zwischen Tupel und Liste ev. so leichter merken:
: T'''u'''pel ... r'''u'''nde Klammern, '''u'''nveränderlich
: L'''i'''ste ... eck'''i'''ge Klammern, veränderl'''i'''ch.

Nachfolgend werden einige Operationen mit Listen und Tupel dargestellt.

 # Liste und Tupel
 liste = [1, 2, &quot;Hallo&quot;]
 tupel = (1, 2, &quot;Hallo&quot;) 
 
 # Ausgabe von liste und tupel
 print(liste)
 print(tupel)
 
 # Ausgabe von Einzelelementen
 print(liste[1])
 print(tupel[2])
 
 # Element an Liste anhängen und einfügen 
 liste.append(55)
 liste.insert(4, &quot;Welt&quot;)
 print(liste)
 
 # Element aus Liste entfernen
 liste.remove(1)
 print(liste)
 
 # einige weitere Beispiele
 liste2 = [1,]
 tupel2 = 1, 2
 tupel3 = (1,) 
 print(liste2)
 print(tupel2)
 print(tupel3)

Ausgabe:
 [1, 2, 'Hallo']
 (1, 2, 'Hallo')
 2
 Hallo
 [1, 2, 'Hallo', 55, 'Welt']
 [2, 'Hallo', 55, 'Welt']
 [1]
 (1, 2)
 (1,)

Beispiel (eine Liste von Wörtern zu einem einzigen zusammenhängenden Text verbinden):

 woerter = [&quot;Hallo&quot;, &quot;Welt&quot;]
 satz = &quot; &quot;.join(woerter)
 print(satz)

Ausgabe:

 Hallo Welt

== Dictionaries und Mengen ==
Zu den Datenstrukturen gehören weiters auch Mengen und Dictionaries. Mengen sind von der Mathematik bekannt, sie sind ungeordnet und es kommen keine mehrfachen Elemente vor. Dictionaries sind durch Schlüssel :Wert-Paare gekennzeichnet. Mengen werden beim Anlegen wie Dictionaries in geschweifte Klammern eingeschlossen.

 dict = {&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot; }
 menge = {1, 1, 3, 4, 4, 4, &quot;Hallo&quot;}
 
 print(dict)
 print(menge)
 print(dict[&quot;vorname&quot;])

Ausgabe:
 {'vorname': 'Hugo', 'nachname': 'Meister'}
 {1, 3, 4, 'Hallo'}
 Hugo

Geschweifte Klammern ohne Inhalt stellen Dictionaries dar und keine Mengen:

 di = {}
 print(type(di))

Ausgabe:
 &lt;class 'dict'&gt;

Leere Mengen lassen sich mit &lt;code&gt;set()&lt;/code&gt; erzeugen:

 menge = set()      # leere Menge
 print(menge)
 menge.add(&quot;Hallo&quot;) # Element hinzufügen
 print(menge)

Ausgabe:
 set()
 {'Hallo'}

Beispiel (einige Mengenoperationen):
 mengeA = {&quot;Hallo&quot;, &quot;Welt&quot;}
 mengeB = {1, 2, &quot;Welt&quot;, 3}
 
 # Vereinigung
 print(mengeA | mengeB)
 print(mengeA.union(mengeB))
 
 # Durchschnitt
 print(mengeA &amp; mengeB)
 print(mengeA.intersection(mengeB))
 
 # Differenz
 print(mengeA - mengeB)
 print(mengeA.difference(mengeB))
 
 # Symmetrische Differenz
 print(mengeA ^ mengeB)
 print(mengeA.symmetric_difference(mengeB))
 
 # Teilmenge
 print(mengeA.issubset(mengeB))
 
 # Mehrere Elemente hinzu
 mengeA.update([&quot;Super&quot;, 67, 125])
 print(mengeA)
 
 # Element löschen
 mengeA.discard(&quot;Hallo&quot;)
 print(mengeA)

Ausgabe:
 {1, 2, 3, 'Welt', 'Hallo'}
 {1, 2, 3, 'Welt', 'Hallo'}
 {'Welt'}
 {'Welt'}
 {'Hallo'}
 {'Hallo'}
 {1, 2, 3, 'Hallo'}
 {1, 2, 3, 'Hallo'}
 False
 {67, 'Super', 'Welt', 'Hallo', 125}
 {67, 'Super', 'Welt', 125}

Es gibt schon seit &quot;ewigen&quot; Zeiten unveränderbare Mengen, die mittels &lt;code&gt;frozenset&lt;/code&gt; eingeleitet werden. Neu ab Python 3.15 ist dagegen das Pendant &lt;code&gt;frozendict&lt;/code&gt;, das unveränderbare Dictionaries darstellt.

 fdict = frozendict({&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot;})
 fset = frozenset({&quot;A&quot;, 1, &quot;A&quot;})
 
 print(fdict)
 print(fdict[&quot;vorname&quot;])
 print (fset) 
 
 try:
     fdict[&quot;vorname&quot;] = &quot;Max&quot;
     print(fdict[&quot;vorname&quot;])
 except TypeError as e:
     print(f&quot;Fehler: {e}&quot;)
 
 try:
     fset.add(&quot;B&quot;)
     print(fset)
 except AttributeError as e:
     print(f&quot;Fehler: {e}&quot;)

Ausgabe:
 frozendict({'vorname': 'Hugo', 'nachname': 'Meister'})
 Hugo
 frozenset({1, 'A'})
 Fehler: 'frozendict' object does not support item assignment
 Fehler: 'frozenset' object has no attribute 'add'

== List Comprehensions ==
Aus einer Eingabeliste soll eine Ausgabeliste erzeugt werden. Das kann folgendermaßen geschehen.

Mathematische Schreibweise: &lt;math&gt;lc = \{2x|x\in\ \mathbb{N}, 1\le x &lt; 11\}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11)]
 print(lc)

Ausgabe:
 [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Mathematische Schreibweise: &lt;math&gt;lc = \{2x | x \in \mathbb{N}, 1\le x &lt; 11, x \bmod 2 = 0 \}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11) if x%2 == 0]
 print(lc)

Ausgabe:
 [4, 8, 12, 16, 20]

Siehe auch {{W|List Comprehension}}.

== Set Comprehensions ==
Dies ist sehr ähnlich wie im vorigen Abschnitt beschrieben. Es wird aber keine Liste, sondern eine Menge erzeugt.

 sc = {x*2 for x in range(1,11)}
 print(sc)

Ausgabe:
 {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}

== Listen zusammenführen - zip() ==
 li1 = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]
 li2 = [1, 2, 3, 4]
 li3 = [5.5, 6.6, 7.7, 8.8]
 
 z = zip(li1, li2, li3)
 print(z)
 
 li4 = list(z)
 print(li4)

Ausgabe:
 &lt;zip object at 0x00000283B6C6AC80&gt;
 [('A', 1, 5.5), ('B', 2, 6.6), ('C', 3, 7.7), ('D', 4, 8.8)]

== Generatorausdruck ==
 g = (i*2 for i in range(1,11))
 print(g)
 t = tuple(g)
 print(t)
 print(t[1:3])

Ausgabe:
 &lt;generator object &lt;genexpr&gt; at 0x00000241D2A4A5A0&gt;
 (2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
 (4, 6)

== Slicing ==
slice ... Scheibe, Teil, in Scheiben schneiden

Beispiel: Zugriff auf Elemente eines geordneten sequentiellen Objekttyps (Liste, Tupel oder String):

 str1 = &quot;Hallo&quot;
 # Das erste Element wird mit dem Index 0 angesprochen
 # [start (inkl.) : stop (exkl.) : step (default=1)]
 str2 = str1[0:2]
 # Alternativ auch: str2 = str1[:2] 
 print(str2)
 
 tup1 = (0,1,2,3)
 # Das letzte Element hat auch den Index -1, das vorletzte den Index -2 usw.
 tup2 = tup1[-3:-1]
 print(tup2)
 
 lst1 = [[1,  5,  10, 20],
         [30, 40, 50, 60]]
 lst2 = lst1[1][1]
 print(lst2)
 
Ausgabe:
 Ha
 (1, 2)
 40

Beispiel:

 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2])
 print(x[-3]) 
 print(x)
 print(x[:])
 print(x[2:])
 print(x[:2])
 print(x[::-1])

Ausgabe:

 c
 c
 ('a', 'b', 'c', 'd', 'e')
 ('a', 'b', 'c', 'd', 'e')
 ('c', 'd', 'e')
 ('a', 'b')
 ('e', 'd', 'c', 'b', 'a')

Visualisierung:

    '''a'''     '''b'''     '''c'''     '''d'''     '''e'''
 +-----------------------------+
 |  0  |  1  |//'''2'''//|  3  |  4  |
 +-----------------------------+
 | -5  | -4  |/'''-3'''//| -2  | -1  | 
 +-----------------------------+
 |/////////////////////////////|
 +-----------------------------+
 |/////////////''':'''///////////////|
 +-----------------------------+
 |     |     |///////'''2:'''////////|
 +-----------------------------+
 |////''':2'''/////|     |     |     |
 +-----------------------------+
 |\\\\\&lt;--\\\\\'''::-1'''\\\\&lt;--\\\\\|
 +-----------------------------+

Beispiel:
 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2::2])
 print(x[2::-1])
 print(x[2:0:-1])

Ausgabe:

 ('c', 'e')
 ('c', 'b', 'a')
 ('c', 'b')

Hier sieht man sehr schön, dass beim letzen &lt;code&gt;print&lt;/code&gt;-Befehl die 0, die in diesem Fall den Buchstaben &quot;a&quot; repräsentiert, als letzer Wert nicht mehr dazugehört (wie weiter oben angedeutet ist der End- oder Stoppwert exklusiv). Will man den Buchstaben &quot;a&quot; dazunehmen, so ist die vorletzte Zeile die richtige.

Beispiel: Umdrehen von Strings

 str1 = &quot;Hallo&quot;
 str2 = str1[::-1]
 print(str2)

Ausgabe:
 ollaH

Mit zweidimensionalen Listen/Tupels wird das Ganze schon bedeutend komplexer.

Beispiel: Verkettetes Slicing

 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
     
 print(A[2::][::2])

Ausgabe:

 [['20', '21', '22', '23'], ['40', '41', '42', '43']]

Das erste Slicing erstellt folgenden Slice:

 [[&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
  [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
  [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]

Das zweite Slicing wird dann auf diesen Slice angewendet und ergibt das genannte Endergebnis. Will man Spalten statt Zeilen, so funktioniert dieser direkte Weg nicht. Man verwendet dann List Comprehensions oder die NumPy-Bibliothek. Diese Bibliothek erlaubt [[Ing_Mathematik:_Python#Zugriff_auf_Matrizenelemente|zweidimensionales Slicing]]. Sie wird erst später bei den Grafiken eingeführt. Deshalb wird hier dazu noch kein Beispiel gezeigt.

= Objektorientierte Programmierung =
{{Wikipedia|Objektorientierte Programmierung}}

* {{W|Klasse (Objektorientierung)|Klasse}} ... die Schablone oder der Bauplan, enthält Methoden und Attribute
* {{W|Objekt (Programmierung)|Objekt}} ... eine Klasseninstanz (die konkrete Ausprägung der Klasse)
* {{W|Attribut (Programmierung)|Attribute}} ... die Eigenschaften eines Objekts
* {{W|Methode (Programmierung)|Methoden}} ... die Aktionen (Operationen), die ein Objekt ausführen kann
* {{W|Vererbung (Programmierung)|Vererbung}} ... neue Klassen (Subklassen, Unterklassen, abgeleitete Klassen) aus vorhandenen Klassen (Superklassen, Oberklassen, Basisklassen, Elternklassen) ableiten. Ermöglicht den Aufbau von Klassenhierarchien. Die Subklasse &quot;erbt&quot; Attribute und Methoden von der Superklasse. Python unterstützt (so wie C++, aber im Gegensatz zu Java) Mehrfachvererbung.

== UML ==
* {{W|Unified Modeling Language|UML}} ... '''U'''nified '''M'''odeling '''L'''anguage, eine Modellierungssprache. Die UML enthält zahlreiche Diagrammarten, um Programme zu modellieren. Im Nachfolgenden wird nur das {{W|Klassendiagramm}} verwendet.

[[File:UmlCd Klasse-3.svg|300px]]

* {{W|Sichtbarkeit (Programmierung)|Sichtbarkeit}}:
** + ... public (öffentlich)
** - ... private
** # ... protected 

* {{W|Attribut_(UML)#Attribute_für_Instanzen_und_für_Klassen|Klassenattribute}} (statische Attribute): Werden nur einmal pro Klasse angelegt. Im Klassendiagramm werden sie unterstrichen.

[[File:Attribute-3.png|200px]]

* Vererbung:

&lt;gallery&gt;
InheritancePgmUML.svg | Abgeleitete Klasse erbt von Basisklasse (Einfachvererbung)
Diamond inheritance.svg | D erbt von B und C (Mehrfachvererbung). B und C erben von A (Einfachvererbung)
&lt;/gallery&gt;

Für weitergehende Betrachtungen zur UML wird auf Spezialliteratur verwiesen, z.B.:
* Seidl et al.: UML@Classroom. dpunkt, 2012, ISBN 978-3-89864-776-2
* Rupp et al.: UML 2 glasklar. Hanser, 4. Aufl., 2012, ISBN 978-3-446-43057-0

== Eine einfache Klasse ==

[[Datei:PythonIng_uml1.svg | 200px]]

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
 
 fahr = Fahrzeug(150, 90)
 
 print(fahr.convertGeschw())
 
Ausgabe:
 41.666666666666664

Die Klasse Fahrzeug wird durch das class-Schlüsselwort eingeleitet. raeder ist ein Klassenattribut und public. __init__ wird bei der Objekterzeugung automatisch aufgerufen (ist der sogenannte Konstruktor). Man achte darauf, dass diese Methode immer mit zwei Unterstrichen eingeleitet und abgeschlossen wird. Instanzattributen wird das Wort self vorangestellt. Wir sehen uns z.B. das Attribut self.__geschwind an. Auch hier werden zwei Unterstriche verwendet. Das bedeutet, dass dieses Attribut strikt/stark private ist. Wird nur ein Unterstrich verwendet, so deutet dies auf schwach/weakly private hin. Letzteres wird in Python deutlich häufiger verwendet. Bei den Methoden wird immer self als erster Parameter angegeben. Beim Aufruf der entsprechenden Funktion wird das self aber nicht berücksichtigt.

Besonderheiten bei stark und schwach private:
* '''stark private''':
** zwei führende Unterstriche
** Name Mangling: Name wird zu &lt;code&gt;_Klassenname__variablenname&lt;/code&gt;
** Schutz vor Namenskollisionen bei Vererbung
** am Ende des Namens dürfen keine zwei Unterstriche verwendet werden. Das wären dann Magic Methods oder Dunder-Methods (z.B. __init__). Diese sind public.

* '''schwach private''':
** ein führender Unterstrich
** Name bleibt gleich
** ist nur ein Hinweis an die Programmierer, kein starker Schutz
** &lt;code&gt;from modul import *&lt;/code&gt;: Objekte mit einem führenden Unterstrich werden standardmäßig nicht importiert
** Standard für die Kapselung bei Python. Schätzung: Weit mehr als 80% der nicht-öffentlichen Attribute/Methoden werden als schwach private deklariert. Weniger als 5-10% als stark private (Quelle: Google KI)

== Klassen importieren ==
Häufig ist es sinnvoll und übersichtlicher Klassen in eigenen Dateien zu speichern. Das sind dann eigene Module. Abgespeichert werden Sie mit der Endung py, wie bisher auch praktiziert. Aufgerufen werden Sie mit der import-Anweisung. Dann ist aber nur der Dateiname ohne Endung py zu verwenden. Klarer wird das mit einem Beispiel.

Datei c:\tmp\fahrzeug.py

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6

Datei c:\tmp\test1.py

 import fahrzeug
 fahr = fahrzeug.Fahrzeug(150, 90)
 print(fahr.convertGeschw())

Ausgabe:
 41.666666666666664

Die üblichen import-Anweisungen lauten wie folgt:
{| {{prettytable}}
! import-Befehl
! Instanz
|-
| import xyz      || xyz.Klasse
|-
| import xyz as x || x.Klasse
|-
| from xyz import Klasse || Klasse
|-
| from xyz import * || Klasse 
|}

Der Vorteil der ersten beiden import-Anweisungen ist, dass es kaum zu Namenskollisionen kommen kann. Dafür hat man bei den letzten beiden Varianten weniger Tipparbeit.

== Vererbung ==
=== Einfachvererbung ===

[[Datei:PythonIng_uml2.svg | 200px]]

Datei fahrzeug.py:
 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
        
     def setLeistung(self, leistung):
         self.__leistung = leistung
        
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
        
 class Luftfahrzeug(Fahrzeug):
     def __init__(self, geschwindigkeit, leistung, fluegel):
         super().__init__(geschwindigkeit, leistung)
         self.__flueg = fluegel
     
     def getFlueg(self):
         return self.__flueg

Datei test1.py:
 import fahrzeug
 fahr = fahrzeug.Luftfahrzeug(150, 90, 4)
 print(fahr.getFlueg())

Ausgabe:
 4

=== Mehrfachvererbung ===
Mit Python ist auch Mehrfachvererbung möglich, z.B.:

 class A:
     def _printA(self):
         print(&quot;Klasse A&quot;)
 
 class B:
     def _printB(self):
         print(&quot;Klasse B&quot;)
 
 class C(A,B):
     def __init__(self):
         self._printA()
         self._printB()
 
 c = C()

Ausgabe:

 Klasse A
 Klasse B

Die Klasse C erbt von A und B. In UML sieht das in etwa so aus:

 +-----------------------------+   +-------------------------+
 |            A                |   |          B              |
 +-----------------------------+   +-------------------------+
 |                             |   |                         |
 +-----------------------------+   +-------------------------+
 | # printA()                  |   | # printB()              |
 +-----------------------------+   +-------------------------+
                           .              .
                          / \            / \
                          ---            ---
                           |              |
                           |              |
                        +---------------------+
                        |          C          |
                        +---------------------+
                        |                     |
                        +---------------------+
                        |                     |
                        +---------------------+

&lt;code&gt;printA()&lt;/code&gt; und &lt;code&gt;printB()&lt;/code&gt; sind schwach private (in UML als &lt;code&gt;protected&lt;/code&gt; mit einem # dargestellt). Es ist aber zu beachten, dass schwach private nur Konvention ist. Praktisch könnte man auch von außerhalb auf diese Methoden zugreifen. Das soll man aber nicht tun, und das wird in Python durch einen Unterstrich angedeutet.

== Statische Attribute, statische Methoden und Klassenmethoden ==
Beispiel:

 class Math:
     pi = 3.14159265
     cnt = 0
     
     @staticmethod
     def expo():
         return 2.71828183
    
     @classmethod    
     def counterPlus(cls):
         cls.cnt += 1
        
 print(Math.pi)
 print(Math.expo())
 
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)

Ausgabe:

 3.14159265
 2.71828183
 1
 2
 3

Statische Attribute und Methoden, bzw. Klassenmethoden, sind direkt einer Klasse zugeordnet und nicht einem Objekt. Der Unterschied zwischen statischen Methoden und Klassenmethoden ist, dass statische Methoden nicht auf Klassenattribute (bzw. statische Attribute) zugreifen können, Klassenmethoden aber schon. &lt;code&gt;pi&lt;/code&gt; und &lt;code&gt;cnt&lt;/code&gt; sind statische Attribute. &lt;code&gt;expo()&lt;/code&gt; ist eine statische Methode. &lt;code&gt;counterPlus(cls)&lt;/code&gt; ist eine Klassenmethode. Die Bezeichnung des Parameters als &lt;code&gt;cls&lt;/code&gt; ist reine Konvention, man sollte sich aber daran halten.

= Grafiken zeichnen =
Für das Zeichnen von Grafiken wird hier das Modul &lt;code&gt;matplotlib&lt;/code&gt; verwendet. &lt;code&gt;matplotlib&lt;/code&gt; ist ein externes Modul und muss vor der ersten Verwendung installiert werden. Das geht so:

# Starten Sie ein Terminal (bei Windows die Eingabeaufforderung).
# Führen Sie darin folgenden Befehl aus &lt;code&gt;c:\devel\Python\Scripts\pip.exe install matplotlib&lt;/code&gt;

pip ist übrigens der Paketmanager von Python ({{W|Pip_(Python)}}). 

Optimalerweise installieren wir auch gleich das Modul &lt;code&gt;numpy&lt;/code&gt; (Numerical Python). Wir werden es im Folgenden oft benötigen (nicht nur bei den Grafiken). Das funktioniert vom Prinzip her genauso, wie für &lt;code&gt;matplotlib&lt;/code&gt; gezeigt.

&lt;small&gt;Verwenden Sie Spyder, so sind diese Schritte nicht nötig. Spyder inkludiert diese Pakete standardmäßig. Unter openSUSE Tumbleweed lassen sich diese Pakete mittels YaST oder zypper installieren.&lt;/small&gt;

== 2D ==
=== Graph einer Funktion ===
Es soll die cosh-Funktion im Intervall &lt;math&gt;x\in[-3,3]&lt;/math&gt; gezeichnet werden. Der Programmcode lautet in der einfachsten Form:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x)
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:PythonIng_cosh1.jpg]]

Der Code ist quasi selbsterklärend. Das Untermodul pyplot des matplotlib-Moduls und das numpy-Modul werden importiert. x läuft von -3 bis +3. y wird für jeden x-Wert per Formel ausgerechnet. &quot;plt.plot()&quot; ist der Zeichenbefehl. &quot;plt.show&quot; ist notwendig, um das Fenster mit der Grafik anzuzeigen.
Die Schrittweite 0.1 wurde so gewählt, um einen ausreichend glatten Verlauf des Graphen zu gewährleisten. Das ist immer ein Kompromiss zwischen Berechnungszeit und Ansehnlichkeit. Testen Sie einfach ein paar verschiedene Werte, um ein Gefühl dafür zu zu bekommen. &quot;plt.grid()&quot; zeichnet ein Gitter in die Grafik (kann auch weggelassen werden).
Die Bezeichnungen plt und np könnten auch anders gewählt werden. Es ist aber Konvention, diese so wie hier gezeigt zu wählen. Die &quot;arange&quot;-Funktion aus der NumPy-Bibliothek wird später ein bisschen genauer behandelt (siehe [[Ing_Mathematik:_Python#Zahlenfolgen|Zahlenfolgen]]).  

&lt;small&gt;Mit der im obigen Bild gezeigten Menüleiste kann die dargestellte Grafik nachträglich noch geändert werden (Zoom, Pan, Achsenparameter, Kurvenparameter etc.). Natürlich kann man das alles auch direkt programmieren. Wie das funktioniert wird ansatzweise etwas später gezeigt.&lt;/small&gt;

Ein etwas komplexeres Beispiel ist Folgendes:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x) + 2**x
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:
[[Datei:PythonIng_cosh4.png]]

Man beachte, dass im Gegensatz zu Octave und Julia der ominöse Punkt (.) bei 2**x mit Python nicht benötigt wird. Das macht das Programmiererleben etwas einfacher.

Die Farbe des Graphen kann man über den &lt;code&gt;color&lt;/code&gt;-Schalter einstellen, z.B. auf rot setzen:
 plt.plot(x, y, color=&quot;red&quot;)

Das ist nur eine Möglichkeit, es gibt auch andere, z.B. mittels
* hexadezimaler Zahl, z.B. &lt;code&gt;color=&quot;#ff0000&quot;&lt;/code&gt;
* Kurzform, z.B. &lt;code&gt;&quot;r&quot;&lt;/code&gt;

Statt &lt;code&gt;color&lt;/code&gt; kann auch die Kurzform &lt;code&gt;c&lt;/code&gt; verwendet werden.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie diese &quot;Farbspielereien&quot; am Computer aus.

=== Graphen mehrerer Funktionen und weiteres ===
==== Mehrere Funktionen in einen Plot zeichnen ==== 
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh2.png]]

Um die Linienstile etwas individueller zu gestalten, ist folgender Programmcode gedacht: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;, lw=3, ls=&quot;--&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh3.png]]

Einige weitere Bespiele zu &lt;code&gt;ls&lt;/code&gt;&lt;/code&gt;:
* - ... durchgezogene Linie
* -. ... Strichpunkt-Linie
* dashed ... gestrichelte Linie 

==== Marker ====
Desweiteren kann man Marker verwenden.

Beispiel:

 import matplotlib.pyplot as plt
 
 plt.plot(10, 10, &quot;ob&quot;, markersize=30)
 plt.plot(20,20, &quot;.r&quot;)
 plt.plot(30,30, &quot;Dg&quot;, ms=15)
 plt.plot(40, 40, &quot;ok&quot;, ms=20, mec=&quot;#FF5733&quot;, mew=3)
 plt.plot(50, 50, &quot;vk&quot;, ms=20, mec=&quot;yellow&quot;, mew=3)
 plt.grid()
 plt.show()


Das erste Zeichen im String nach den Koordinaten im plot-Befehl symbolisiert die Form (z.B. o für einen Kreis). Das zweite Zeichen steht für die Farbe (z.B. b für blue). &lt;code&gt;markersize&lt;/code&gt; oder &lt;code&gt;ms&lt;/code&gt; setzt die Größe des Markers.

Ausgabe:

[[Bild:PythonIng_formatpara1.svg|200px]]

Einige weitere Marker:
* * ... Stern
* + ... Plus
* h oder H ... Sechseck

Man kann mit den Parametern 
* &lt;code&gt;markeredgecolor&lt;/code&gt; oder kurz &lt;code&gt;mec&lt;/code&gt; die Farbe des Markerrandes
* &lt;code&gt;markeredgewidth&lt;/code&gt; oder kurz &lt;code&gt;mew&lt;/code&gt; die Dicke des Randes
* &lt;code&gt;markerfacecolor&lt;/code&gt; oder kurz &lt;code&gt;mfc&lt;/code&gt; die Innenfarbe des Markers
bestimmen.

=== Funktion in Parameterdarstellung ===
Es soll die archimedische Spirale &lt;math&gt;x = t \cos(t), y = t  \sin(t)&lt;/math&gt; im Intervall &lt;math&gt;[0, 6\pi[&lt;/math&gt; gezeichnet werden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
  
 plt.show()

[[Datei:PythonIng_spirale1.png]]

Diese Darstellung erscheint verzerrt. Will man gleiche Achsenskalierungen, so kann man den plt.axis()-Befehl verwenden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
 plt.axis(&quot;equal&quot;)
 
 plt.show()
 
[[Datei:PythonIng_spirale2.png]]

=== Funktion in Polardarstellung ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 fig = plt.figure()
 ax = fig.add_subplot(projection=&quot;polar&quot;)
 r = np.arange(0, 1, 0.01)
 theta = r**3
 line = ax.plot(theta, r)
 
 plt.show()

[[Datei:PythonIng_polar1.png]]

=== Logarithmische Achsenskalierung ===
==== Semilog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.semilogy()
 plt.show()

Ausgabe:

[[Datei:PythonIng_semilog1.png]]

==== LogLog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.loglog()
 plt.show()

[[Datei:PythonIng_loglog1.png]]

=== Gefüllte Fläche ===
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.arange(0, 3, 0.1)
 
 y1 = 3*x - 1
 y2 = x**2
 
 plt.plot(x, y1, x, y2, color='black')
 plt.fill_between(x, y1, y2, where=y1&gt;=y2)
 
 plt.show()

[[Datei:PythonIng_gefuellt.png]]

=== Linien, Pfeile, Rechtecke, Kreise und Texte ===
 import matplotlib as mpl
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 r = mpl.patches.Rectangle((0, 0), 3, 3, angle=30, fill=False)
 c = mpl.patches.Circle((4, 4), 2, fill=False)
 
 ax.add_patch(r)
 ax.add_patch(c)
 ax.plot([-2, 7], [-2, 0], color=&quot;black&quot;)
 ax.arrow(0, 7, 5, 0, length_includes_head=True, head_width=0.5, head_length=1.5,
          color=&quot;black&quot;)
 
 ax.set_aspect(&quot;equal&quot;)
 
 plt.axis([-3, 8, -3, 8])
 plt.show() 

[[Datei:PythonIng_linien_pfeile_etc.png]]

Text kann mit &lt;code&gt;ax.text(x, y, &quot;Text&quot;)&lt;/code&gt; hinzugefügt werden, bspw.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 ax.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

Oder einfacher auch ohne &lt;code&gt;subplots&lt;/code&gt;

 import matplotlib.pyplot as plt
 
 plt.text(0.1, 0.1, &quot;Hallo&quot;)
 plt.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

[[Datei:PythonIng_text1.png]]

Auch Sonderzeichen (griechische Buchstaben etc.) können verwendet werden (siehe dazu auch [https://matplotlib.org/stable/users/explain/text/mathtext.html]).

 import matplotlib.pyplot as plt
 
 plt.text(.3, .5,
          r'$\Omega\ \psi\ \oint\ \nabla\ \dot a\ \frac{a}{b}\ a_b$',
          size=&quot;20&quot;)
 plt.show() 

[[Datei:PythonIng_text20.svg]]

Jetzt wird noch gezeigt, wofür &lt;code&gt;subplots&lt;/code&gt; sinnvoll eingesetzt werden können.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(0.1, 0.1, &quot;Hallo&quot;)
 ax[1].text(0.1, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
            rotation=30.0)
 
 plt.show()

[[Datei:PythonIng_text2.png]]

=== Anmerkungen hinzufügen ===
Anmerkungen (engl. annotations) lassen sich mit matplotlib einfach hinzufügen. Unter Anmerkung wird hier ein Pfeil mit Text verstanden.

Beispiel:

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 ax.plot([1,10], [1,10])
 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
             arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0))
 plt.show()

Ausgabe:

[[Datei: PythonIng_ann1.svg|400px]]

&lt;code&gt;shrink&lt;/code&gt; verkürzt den Pfeil. Sinnvoll sind beim obigen Beispiel Werte irgendwo zwischen 0.0 und 0.3.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie verschiedene Pfeillängen aus. 

Die Schriftgröße verändern können Sie übrigens mit &lt;code&gt;fontsize&lt;/code&gt; oder &lt;code&gt;size&lt;/code&gt;, z.B.

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0), fontsize=25)

Eine andere Schreibweise für Dictionaries, die wir weiter oben schon kennengelernt haben, die wir aber nochmals explizit aufschreiben wollen, ist

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops={&quot;facecolor&quot;:&quot;red&quot;, &quot;shrink&quot;:0.0})

=== Figure, Axes etc.===
[[Bild:PythonIng_figure33.svg|350px]]

* fig (figure) ... das übergeordnete Fenster
* ax (axes) ... &quot;Plot&quot;, das eigentliche Zeichenfenster
* axis ... die Koordinatenachsen
* spine ... Begrenzungslinien des Zeichenfensters
* tick ... Markierung an den Achsen des Zeichenfensters

Beispiel (eine figure mit 6 axes, ax-Titel, y-axis-Titel):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=3, ncols=2)
 
 ax[0][0].text(0.1, 0.5, &quot;11&quot;)
 ax[0][1].text(0.1, 0.5, &quot;12&quot;)
 ax[1][0].text(0.1, 0.5, &quot;21&quot;)
 ax[1][1].text(0.1, 0.5, &quot;22&quot;)
 ax[2][0].text(0.1, 0.5, &quot;31&quot;)
 ax[2][1].text(0.1, 0.5, &quot;32&quot;)
 
 ax[0][0].set(ylabel=&quot;y-label&quot;, title=&quot;axes 1&quot;)
 
 plt.show()

[[Bild:PythonIng_figure34.png|350px]]

Beispiel (Achsenbereiche setzen):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 
 ax[0].axis((-1, 10, 1, 12))
 
 plt.show()

[[Bild:PythonIng_figure35.svg|350px]]

Beispiel (Gitter einschalten): 

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 ax[0].axis((-5, 10, 1, 12))
 ax[0].minorticks_on()
 ax[0].grid(which='minor')
 ax[1].grid(which='major')
 plt.show()

[[Bild:PythonIng_figure36.svg|350px]]

Beispiel (ticks setzen)

 import matplotlib.pyplot as plt
 import matplotlib.ticker as tick
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 pos = [0, .2, .5]
 lab = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
 
 ax.xaxis.set_major_locator(tick.FixedLocator(pos))
 ax.xaxis.set_major_formatter(tick.FixedFormatter(lab))
 
 plt.show()

[[Bild:PythonIng_figure37.svg|350px]]

Beispiel (Achsenkreuz beliebig setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 ax.spines['top'].set_color('none')
 ax.spines['right'].set_color('none')
 ax.spines['bottom'].set_position(('data', 0.3))
 ax.spines['left'].set_position(('data', 0.5))
 
 plt.show()

[[Bild:PythonIng_figure38.svg|350px]]

Beispiel (Inset):

 import matplotlib.pyplot as plt
 
 # Hauptplot erstellen
 fig, ax = plt.subplots()
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 
 # Inset hinzu:
 axin = ax.inset_axes([0.4, 0.4, 0.3, 0.3])
 axin.text(0, 0, &quot;Servus&quot;)
 axin.plot()
 
 plt.show()

[[Bild:PythonIng_figure40.svg|350px]]

Beispiel (Hintergrundfarben setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.set_facecolor(&quot;green&quot;)
 fig.set_facecolor(&quot;yellow&quot;)
 
 plt.plot([1, 3], [6, 8])
 plt.show()

[[Bild:PythonIng_figure39.svg|300px]]

=== GridSpec ===
Mit figures und axes lassen sich schon jede Menge an Grafikdetails einstellen. GridSpec ist dann der Turbo oder Raketenantrieb den matplotlib eingebaut hat. Naja, vielleicht ist das etwas übertrieben, aber GridSpec ist sozusagen ein flexibler Layout-Manager. Bisher haben wir immer gleich große axes gezeichnet. Mit GridSpec können wir Subplots über mehrere Zeilen und Spalten ziehen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 gs = fig.add_gridspec(3, 3)
 
 ax1 = fig.add_subplot(gs[0, :])
 ax1.set_title(&quot;Bereich 1: gs[0, :]&quot;)
 
 ax2 = fig.add_subplot(gs[1:, 0])
 ax2.set_title(&quot;Bereich 2: gs[1:, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 1:])
 ax3.set_title(&quot;Bereich 3: gs[1, 1:]&quot;)
 
 ax4 = fig.add_subplot(gs[2, 1:])
 ax4.set_title(&quot;Bereich 4: gs[2, 1:]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec1.svg|350px]]

Erklärung zu &lt;code&gt;(gs[zeile, spalte])&lt;/code&gt;: Slicing; damit legen Sie fest, welche Zellen ein Subplot belegt. Achtung! Die Indizes beginnen bei 0 und nicht bei 1 (d.h., die erste Zeile/Spalte hat den Index 0)
* : ... alle 
* 1: ... 1 bis Ende
* etc.

&lt;code&gt;constrained_layout=True&lt;/code&gt; sorgt dafür, dass sich die Subplots nicht überlappen.

Aber auch die Spaltenbreiten und Zeilenhöhen lassen sich anpassen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 
 # Verhältnis erste zu zweite Zeile = 1.5:1
 # Verhältnis erste zu zweite Spalte  = 1:4
 gs = fig.add_gridspec(2, 2, figure=fig, height_ratios=[1.5, 1], width_ratios=[1, 4])
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax1.set_title(&quot;Bereich 1: gs[0, 0]&quot;)
 
 ax2 = fig.add_subplot(gs[0, 1])
 ax2.set_title(&quot;Bereich 2: gs[0, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 0])
 ax3.set_title(&quot;Bereich 3: gs[1, 0]&quot;)
 
 ax4 = fig.add_subplot(gs[1, 1:])
 ax4.set_title(&quot;Bereich 4: gs[1, 1]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec2.svg|350px]]

Auch die Ränder lassen sich einstellen.

Beispiel 1:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.1, right=0.9, bottom=0.1,
                        top=0.9, wspace=0.2, hspace=0.2)
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec3.svg|300px]]

* hspace ... height space, vertikaler Abstand zwischen den Zeilen
* wspace ... width space, horizontaler Abstand zwischen den Spalten

Und im Vergleich dazu Beispiel 2:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.3, right=0.7, bottom=0.3, 
                        top=0.7, wspace=0.3, hspace=0.3) 
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec4.svg|300px]]

Es gibt noch einige weitere Details, die sich mit GridSpec variieren lassen (z.B. SubGridSpec ... verschachtelte Grid-Layouts). Aber wir belassen es vorerst dabei. Das bisher Gezeigte sollte für die meisten Probleme ausreichend sein.

=== Aufgaben ===
* Zeichnen Sie die Strophoide &lt;math&gt;x = \frac{a(t^2-1)}{t^2+1}, y = \frac{at(t^2-1)}{t^2+1}, a = 2, -3 \leq t \leq 3&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_strophoide.jpg|300px|center]]

* Zeichnen Sie die verschlungene Hypozykloide &lt;math&gt;x = (R-r)\cos t + c\cos\frac{R-r}{r}t, y = (R-r)\sin t - c\sin\frac{R-r}{r}t, c = 3, r = 2, R = 6, -15 \leq t \leq 15&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_hypozykloide.jpg|300px|center]]

* Testen Sie bei den obigen Übungsaufgaben verschiedene Linienstile und Farben. Farben können mit dem plt.plot()-Parameter color gewählt werden.

* Testen Sie bei den obigen Übungsaufgaben verschiedene Werte für a, c, r und R.

* Zeichnen Sie folgendes Bild (die Achsenbeschriftungen positionieren Sie z.B. mit den Befehlen &lt;code&gt;ax.set_xlabel(&quot;x&quot;, loc=&quot;right&quot;); ax.set_ylabel(&quot;y&quot;, loc=&quot;top&quot;)&lt;/code&gt;):

[[Bild:PythonIng_aufgabe24.svg|400px|center]] 

* Zeichnen Sie mit Python, matplotlib und NumPy folgendes Bild:

[[Bild:PythonIng_figure41.svg|400px|center]]

* Zeichnen Sie mit GridSpec ein Layout, das in etwa wie folgendes aussieht (&lt;code&gt;height_ratios=[1, 2], width_ratios=[2, 1]&lt;/code&gt;):

[[Bild:PythonIng_aufgabe23.svg|300px|center]]

== 3D ==
=== Räumliche Kurven ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0, 6*np.pi, 0.1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 z = t
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot(x, y, z)
 
 plt.show()

[[Datei:PythonIng_raumkurve1.png]]

=== Flächen ===
 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche1.png]]

Das Ganze in Netzdarstellung läßt sich so programmieren: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.5)
 y = np.arange(0, 10, 0.5)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_wireframe(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche2.png]]

Ein etwas komplexeres Beispiel:

 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0.1, 10, 0.1)
 y = np.arange(0.1, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z1 = np.sin(x) + 3 * np.cos(y)
 z2 = np.sin(x) + np.log(y)
 z3 = x + np.cos(y)
 z4 = x**2 - y
  
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;}, nrows=2, ncols=2)
 
 ax[0][0].plot_surface(x, y, z1)
 ax[0][1].plot_surface(x, y, z2)
 ax[1][0].plot_surface(x, y, z3)
 ax[1][1].plot_surface(x, y, z4)
 
 plt.show()

[[Datei:PythonIng_subplot1.png]]

Man beachte, dass man die Unterbilder im Bild nach dem Ausführen des Scripts z.B. mit der mittleren Maustaste einzeln drehen, oder über die Einträge in der Menüzeile einzeln bearbeiten kann. Mit ein paar Zeilen Programmtext lässt sich also eine Menge an Funktionalität generieren.

Die Farbgebung lässt sich über &lt;code&gt;colormaps&lt;/code&gt; variieren.

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm)
 
 plt.show()

[[Datei:PythonIng_colormap1.png]]

Es gibt eine Menge an Colormaps, z.B. &lt;code&gt;plasma, Greys, Dark2, ocean&lt;/code&gt;. Zwecks detaillierterer Infos siehe die matplotlib-Dokumentation. &lt;small&gt;Verwendet man die IDE namens IDLE, so gibt es dort auch die automatische Codevervollständigung. D.h. es werden alle Möglichkeiten (in unserem Fall nach dem Eintippen von &lt;code&gt;cm.&lt;/code&gt; alle verfügbaren Colormaps) angezeigt.&lt;/small&gt;

Die &quot;edgecolor&quot; und Linienbreite können auch frei gewählt werden:

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm, edgecolor=&quot;black&quot;, linewidth=1.0)
 
 plt.show()

[[Datei:PythonIng_colormap2.png]]

=== Höhenlinien ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 ax.contour(x, y, z)
 
 plt.show()

[[Datei:PythonIng_höhenlinien1.png|400px]]

Etwas abgewandelt sieht das so aus: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contour(x, y, z)
 ax.clabel(hl, inline = True)
 
 plt.show()

[[Datei:PythonIng_höhenlinien2.png|400px]]

Und noch eine Variante (mit einem Farbbalken) sei gezeigt. 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contourf(x, y, z)
 fig.colorbar(hl) 
 
 plt.show()

[[Datei:PythonIng_höhenlinien5.svg|400px]]

=== Aufgaben ===
* Zeichnen Sie die räumliche Kurve &lt;math&gt;x = 2 \cdot \cosh(t)&lt;/math&gt;, &lt;math&gt;y = 5 \cdot \sin(t)&lt;/math&gt;, &lt;math&gt; z = t^{2} - t&lt;/math&gt;, &lt;math&gt;0 \leq t \leq 3\pi&lt;/math&gt;.
* Zeichnen Sie die Fläche &lt;math&gt;z = \log(x) + \cos(y)&lt;/math&gt;.

== Animationen und fortgeschrittenes 3D ==
=== Mit matplotlib ===
Auch mit matplotlib sind Animationen möglich. Das ist ein bisschen komplizierter und wird deshalb hier nur mit einem sehr einfachen Beispiel dargestellt (bei Interesse siehe z.B. auch das [https://matplotlib.org/stable/users/explain/animations/animations.html#animations Animations using Matplotlib-Tutorial]).

 import matplotlib.pyplot as plt
 import matplotlib.animation as ani
 import matplotlib
 import numpy as np
 
 def update(frame):
     line.set_xdata(x[:frame])
     line.set_ydata(y[:frame])
     return (line)
 
 fig, ax = plt.subplots()
 
 x = np.arange(0, 10, .1)
 y = np.sin(x)
 
 line, = ax.plot(x[0], y[0])
 ax.set(xlim=[0, 10], ylim=[-1, 1])
 
 a = ani.FuncAnimation(fig=fig, func=update, frames=100, interval=20)
 plt.show()
 
 # Speichere die Animation in einem animierten GIF (optional)
 a.save(filename=&quot;c:/tmp/PythonIng_anim5.gif&quot;, writer=&quot;pillow&quot;)

[[Datei:PythonIng_anim5.gif]]

Es wird eine Sinuskurve auf den Bildschirm gezeichnet. In der letzten Zeile wird diese Animation in ein animiertes GIF gespeichert. Das ist natürlich optional und kann auch weggelassen werden.

=== Mit VPython ===
Aber auch mit dem Modul VPython lassen sich einfache 3D-Animationen erstellen. VPython ist ein externes Modul, das vorab installiert werden muss. Unter openSUSE Tumbleweed gibt es dzt. kein entsprechendes rpm-Paket. Die übliche Methode der Installation mittels YaST oder zypper ist somit nicht möglich. Auch eine direkte Verwendung von pip führt nur zu einer Fehlermeldung (&lt;code&gt;error: externally-managed-environment&lt;/code&gt;). Es empfiehlt sich dort folgende Vorgehensweise:
# Erstelle zuerst eine virtuelle Umgebung, z.B.: &lt;code&gt;python3.11 -m venv ~/tmp/venv1&lt;/code&gt;
# Wechsle das Verzeichnis: &lt;code&gt;cd ~/tmp/venv1/bin&lt;/code&gt;
# Installiere das entsprechende Paket: &lt;code&gt;./pip install vpython&lt;/code&gt;
# Führe das entsprechende Skript aus: &lt;code&gt;./python ~/tmp/test1.py&lt;/code&gt;

Aktuell (März 2026) ist dieses Programmpaket lt. der [https://vpython.org/presentation2018/install.html VPython-Homepage] nur für die Python-Versionen 3.8 bis 3.12 verfügbar.

Ein Beispiel zu einer einfachen Animation wird nachfolgend geliefert.

 from vpython import *
 
 scene.width = 1200
 scene.height = 600
 scene.center = vector(20,0,0)
 scene.background = color.white
 
 cylinder(pos=vector(0,0,0), axis=vector(20,0,0), radius=5, 
         color=color.blue)
 cone(pos=vector(0,0,0), axis=vector(-10,0,0), radius=5, 
         color=color.blue)
 helix(pos=vector(20,0,0), axis=vector(40,0,0), radius=2, 
         coils=10, thickness=0.5, color=color.blue)
 
 ball = sphere(pos=vector(20,0,0), color = color.green, radius = 1)
 ball.p = vector(0.15, 0, 0)
 
 toc = True
 
 while True:
     rate(200)
     if(ball.pos.x &lt;= 60 and toc == True):
         ball.pos += ball.p
     else:
         toc = False
         ball.pos -= ball.p
         if(ball.pos.x &lt;= 20 and toc == False):
             toc = True

[[Datei:PythonIng_vpython_anim.JPG]]

Idealerweise öffnet sich beim Ausführen des Scripts ein Browserfenster. Darin wird die programmierte Animation gezeigt (siehe auch den obigen Screenshot). Eine Größenänderung können Sie mit der mittleren Maustaste initiieren. Die Szenerie drehen können Sie mit der rechten Maustaste.

=== Mit build123d ===
Hiermit lassen sich einfach 3D-Modelle für CAD-Systeme erstellen. [https://build123d.readthedocs.io/en/latest/ build123d] ist ein externes Modul und muss vorab, wie schon für mehrere andere Module gezeigt, installiert werden (pip, venv etc.).

Beispielcode:

 from build123d import *
 
 # Bauteil
 with BuildPart() as bauteil: 
     # Zylinder erstellen
     Cylinder(100, 60)
        
     # Bohrung
     with BuildSketch(bauteil.faces().sort_by(Axis.Z)[-1]) as loch:
         Circle(radius=10)
     # negativ extrudieren
     extrude(amount=-60, mode=Mode.SUBTRACT)
     
     # Dem Bauteil z.B. die Farbe rot zuweisen
     # bauteil.part.color = Color(&quot;red&quot;, alpha=1.0)
 
     # Fertiges Modell exportieren
     export_step(bauteil.part, &quot;bauteil.step&quot;)

Ausgabe ({{W|Standard for the exchange of product model data | STEP}}-Datei, z.B. in {{W|FreeCAD}} importiert, Screenshot):

[[Datei:PythonIng_build123d.jpg | 300px]]

FreeCAD ist ein freies 3D-CAD-System. Die [[Ing_Mathematik:_Python#FreeCAD | Makroprogrammierung]] in diesem System wird später noch gezeigt. STEP steht für &quot;'''St'''andard for the '''e'''xchange of '''p'''roduct model data&quot; und ist ein Datenaustauschformat.

=== Mit VTK ===
Komplexer, aber auch mächtiger als VPython ist die Verwendung von VTK ('''V'''isualization '''T'''ool'''k'''it). Genauer gesagt des Python-Wrappers von VTK. Dieses externe Python-Modul muss vorab installiert werden (z.B. mittels YaST, pip oder in eine virtuelle Umgebung). VTK ist eine Softwarebibliothek zur 3D-Visualisierung und wurde ursprünglich in C++ geschrieben. Verbreitet eingesetzt wird diese Bibliothek in der Wissenschaft und Forschung, z.B. 
* in der medizinischen Bildgebung
* für Strömungssimulationen
* für Klimadaten

VTK funktioniert nach dem {{W|Grafikpipeline|Pipeline-Prinzip}}:

 Source (Quellen) -&gt;  Filter -&gt; Mapper (Senken) -&gt; Actor/Renderer

Daten fließen von den Quellen zu den Senken.

Als einfaches Beispiel wird die Darstellung eines Zylinders gezeigt, der mit den Maustasten gedreht oder in der Größe geändert werden kann:

 import vtk
 
 # Zylinder erzeugen
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 # Geometrie in darstellbare Daten umwandeln
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 # Objekt in der Szene
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 # Szene verwalten
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 # Render-Fenster
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 # Maus/Tastatur-Steuerung
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 # Starten
 render_window.Render()
 interactor.Start()

Ausgabe:

[[Datei:PythonIng_VTK_1.png]]

Gleiches Beispiel wie oben, aber mit einer Animationssequenz:

 import vtk
 import time
 
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     render_window.Render()
     time.sleep(0.01)

Das Grafikfenster schließt sich nach Ablauf der Schleife. Das Fenster bleibt geöffnet, wenn Sie am Programmende folgenden Befehl hinschreiben

 interactor.Start()

Um den animierten Zylinder grün einzufärben, müssen Sie Folgendes im obigen Programm ergänzen (Farbnamen):

 colors = vtk.vtkNamedColors()
 actor.GetProperty().SetColor(colors.GetColor3d(&quot;Green&quot;))

Als Namen können Sie u.a. die CSS3 Web-Farben verwenden (siehe z.B. [https://wiki.selfhtml.org/wiki/Farbe/Farbangaben] und {{W|Webfarbe#CSS_3}}).

Alternativ funktioniert auch das ({{W|RGB-Farbraum|RGB}}):

 actor.GetProperty().SetColor(0.0, 0.6, 0.0)

Wie der Zylinder mit einer Textur versehen wird, zeigt folgendes Programm:

 import vtk
 import time
 
 cylinder = vtk.vtkCylinderSource()
 cylinder.SetResolution(30)
 cylinder.SetHeight(3.0)
 cylinder.SetRadius(1.0)
 cylinder.CappingOn()
 
 texture_coords = vtk.vtkTextureMapToCylinder()
 texture_coords.SetInputConnection(cylinder.GetOutputPort())
 texture_coords.PreventSeamOn()
 
 reader = vtk.vtkJPEGReader()
 reader.SetFileName(&quot;PythonIng_textur.jpg&quot;)
 
 texture = vtk.vtkTexture()
 texture.SetInputConnection(reader.GetOutputPort()) 
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(texture_coords.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 actor.SetTexture(texture)
 
 renderer = vtk.vtkRenderer()
 renderWindow = vtk.vtkRenderWindow()
 renderWindow.AddRenderer(renderer)
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(renderWindow)
 
 renderer.AddActor(actor)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     renderWindow.Render()
     time.sleep(0.01)
 
 interactor.Start()

&lt;gallery&gt;
PythonIng_textur.jpg | Textur-Datei
PythonIng_VTK_2.png | Ausgabe (Screenshot)
&lt;/gallery&gt;

== Sonstige Grafikbibliotheken ==
=== Py5 ===
Im Buch ''Iacono et al.: Programmieren trainieren, mit über 150 Workouts in Java und Python; 3. Aufl., Hanser, 2023'' werden zahlreiche Aufgaben gestellt, die u.a. mit Processing zu lösen sind.  Processing ist eine einfache Programmiersprache und Entwicklungsumgebung. Warum ich das erwähne? Weil in älteren Processing-Versionen auch die Programmiersprache Python 2 abgedeckt war. Bei neueren Versionen gibt es keine Python-Anbindung mehr (getestet nur mit openSUSE Tumbleweed und Python 3). Somit funktioniert der Python-Teil im genannten Buch zum Teil nicht mehr. Ist das tragisch, oder kann das Buch weggeschmissen werden? Nein! Es gibt Alternativen zu Processing. Zum einen die im Buch selbst genannten Bibliotheken tkinter oder pygame. Pygame wird dort auch kurz anhand eines Beispiels thematisiert. Aber noch besser ist es, die py5-Bibliothek zu verwenden (lt. Google KI vom 30. Sept. 2026: ''Der echte, moderne „spirituelle Nachfolger“''). Damit ist die Funktionalität von Processing gewährleistet. Man kann aber beliebige Editoren oder IDEs zur Programmerstellung verwenden, ohne an Processing als IDE gebunden zu sein. Nachfolgend werden ein paar Beispiele zu dieser externen Bibliothek gegeben. Der erste Schritt ist wieder, die py5-Bibliothek zu installieren (z.B. mittels pip in eine virtuelle Umgebung; Python&gt;=3.10 und ein JDK&gt;=17 müssen auch installiert sein (Stand Okt. 2026)). Dann kann es schon mit dem Programmieren losgehen.

Beispiel (angelehnt an die ''Aufgabe W.2.3 Haus'' des genannten Buchs, jedoch etwas erweitert):

 import py5
 
 def setup():
     py5.size(600, 600)            # Fenstergröße 600px x 600px 
     py5.background(255, 255, 255) # Hintergrundfarbe ... weiss
     
 def draw():
     # Haus zeichnen
     py5.fill(255, 255, 255)       # Hintergrundfarbe ... weiss
     py5.stroke(255, 0, 0)         # Linienfarbe ... rot 
     py5.stroke_weight(3)          # Linienbreite ... 3px
     py5.rect(150, 200, 300, 300)  # Rechteck zeichnen (x, y, b, h)
     py5.triangle(150, 200, 300, 100, 450, 200) # Dreieck zeichnen
     py5.circle(250, 300, 70)      # Kreis zeichnen (x, y, d)   
     
     # Bemassung zeichnen
     py5.stroke(0, 255, 0)
     py5.stroke_weight(1)
     py5.line(300, 100, 550, 100)  # Linie zeichnen
     py5.line(450, 200, 550, 200) 
     py5.line(450, 500, 550, 500) 
     py5.line(150, 500, 150, 550)
     py5.line(450, 500, 450, 550)
     py5.text_size(20)             # Textgroesse
     py5.fill(0, 255, 0)           # Textfarbe
     py5.text(&quot;300&quot;, 280, 550)     # Text zeichnen
     py5.text(&quot;100&quot;, 500, 150)
     py5.text(&quot;300&quot;, 500, 350)  
 
     # Gedrehtes Rechteck zeichnen
     py5.stroke(255, 255, 0)
     py5.stroke_weight(3)
     py5.fill(200, 200, 200) 
     py5.translate(320, 260)  
     py5.rotate(0.3)               # Drehung (in Radiant)
     py5.rect(0, 0, 100, 50)
 
 # Startet den Sketch
 py5.run_sketch()


Ausgabe:

[[Datei:PythonIng_py5_1.png|300px]]

Das skizzierte Haus ist mit einer rudimentären Bemaßung versehen und hat zwei Fenster, ein rundes und ein gedrehtes, trübes rechteckiges. 

Beispiel (Mausoperationen):

 import py5
 
 def setup():
     py5.size(600, 600)            
     py5.background(255, 255, 255)
 
 def draw():
     pass
    
 def mouse_pressed():
     py5.text_size(15) 
     py5.fill(0, 0, 255)
     x = py5.mouse_x
     y = py5.mouse_y
     py5.text(&quot;(%d, %d)&quot; %(x, y), x, y) # Positionsdaten bei Maus-Klick schreiben
 
 py5.run_sketch()

Ausgabe:

[[Datei:PythonIng_py5_2.png|300px]]

Obiges Bild zeigt das Resultat nach einigen Mausklicks. Man erkennt, dass links-oben der Koordinatennullpunkt ist. Die x-Achse zeigt nach rechts, die y-Achse nach unten.

Beispiel (Fünfeck):

 import py5
 import random 
 
 def setup():
     py5.size(400, 400)
     py5.no_loop()       # statisches Bild (schont die Ressourcen)
 
 def draw():
     py5.translate(py5.width / 2, py5.height / 2)  # KS setzen
 
     radius = 150
     eck_anzahl = 5
 
     py5.fill(random.randint(0, 255), random.randint(0, 255), 
              random.randint(0, 255))    # Füllfarbe auf Zufallswert setzen
     py5.stroke(155, 0, 0)            
     py5.stroke_weight(5)     
     
     # Fünfeck als Polygon zeichnen
     py5.begin_shape()
     for i in range(eck_anzahl):
         winkel = i * py5.TWO_PI / eck_anzahl - py5.HALF_PI
         x = py5.cos(winkel) * radius
         y = py5.sin(winkel) * radius
         py5.vertex(x, y)
     py5.end_shape(py5.CLOSE)
 
 py5.run_sketch()

Ausgabe, bspw.:

[[Datei:PythonIng_py5_5.png|200px]]

&lt;u&gt;Kleine Aufgaben:&lt;/u&gt;
* Um die Funktionsweise von &lt;code&gt;py5.no_loop()&lt;/code&gt; zu verstehen, kommentieren Sie die Anweisung im Beispiel einfach aus, und starten Sie das Programm erneut.
* Zeichnen Sie ein Siebeneck.
* Was passiert, wenn man &lt;code&gt;py5.CLOSE&lt;/code&gt; im &lt;code&gt;py5.end_shape()&lt;/code&gt;-Befehl weglässt?

Beispiel (Grafik laden und zeichnen):

 import py5
 
 image1 = None
 
 def setup():
     global image1
     py5.size(600, 600)
     py5.no_loop()
     image1 = py5.load_image(&quot;PythonIng_py5_1.png&quot;)
 
 def draw():
     py5.image(image1, 0, 0)
 
 py5.run_sketch()

Hier wird einfach das Bild vom Haus-Beispiel (Screenshot von weiter oben) geladen und gezeichnet.

Beispiel (angelehnt an ''W.5.10 Wurfparabel'' des genannten Buches; mit OOP erstellt):

 import py5
 
 class Wurfparabel(py5.Sketch):
     def __init__(self, v0, angle):
         super().__init__()
         self.v0 = v0
         self.angle = self.radians(angle)
         self.g = 9.81
         self.t = 0.0
         self.scale = 1.5
 
     def settings(self):
         self.size(800, 600)
 
     def setup(self):        
         self.background(0, 0, 0)
         
     def draw(self):
         self.t += 0.1
 
         self.translate(50, 500)
       
         # KS Zeichnen
         self.fill(255, 255, 0)
         self.stroke(255, 255, 0)
         self.stroke_weight(1)
         self.line(0, 0, 0, -300)
         self.line(0, 0, 700, 0)
 
         # Punkt zeichnen
         cx = self.v0 * self.cos(self.angle) * self.t * self.scale
         cy = -(self.v0 * self.sin(self.angle) * self.t - \
                self.g/2 * self.t**2) * self.scale
         self.fill(255, 0, 0)
         self.stroke(255, 0, 0)
         self.circle(cx, cy, 3)
        
         # Stoppen bei Bodenkontakt
         if cy &gt;= -5:
             self.no_loop()
            
 def wurfparabel(v0=50, angle=45):
     sketch = Wurfparabel(v0, angle)
     sketch.run_sketch()
 
 v0 = float(input(&quot;v0 = &quot;))
 winkel = float(input(&quot;winkel = &quot;))
 wurfparabel(v0=v0, angle=winkel)

Eingabe auf der Konsole:

 v0 = 60
 winkel = 45

Ausgabe:

[[Datei:PythonIng_py5_13.png|200px]]

Die benötigten Formeln der Bewegungsgleichung kann man leicht herleiten, bzw. man benutzt folgende Grafik als Hilfestellung:

[[Datei:Wurfparabel_Zusammenfassung_aktualisierung.png|700px]]

&lt;u&gt;Aufgabe:&lt;/u&gt; Berechnen Sie den Scheitelpunkt und die Wurfweite bei gegebener Anfangsgeschwindigkeit und gegebenem Abwurfwinkel. Die Abwurfhöhe &lt;math&gt;y_0&lt;/math&gt; sei 0. Der Wurf soll auf der Erde stattfinden (g = 9.81 m/s²). Die dazu benötigten Formeln können aus obiger Grafik entnommen werden (oder Sie leiten sie selbst her). Geben Sie die Ergebnisse auf der Konsole aus.

Beispiel (eine einfache Animation):

 import py5
 
 i = 0
 
 def setup():
     py5.size(600, 600)
     py5.frame_rate(5)
     py5.stroke_weight(20)
 
 def draw():
     global i
     
     py5.background(255, 255, 255)
     py5.translate(py5.width/2, py5.height/2)
     py5.rotate(py5.PI/8 * i)    
 
     py5.line(-100, 0, 100, 0)
     i += 1
 
 py5.run_sketch()

Es wird eine rotierende Linie gezeichnet (z.B. wie bei einem Installationsprozess verwendet - zeigt an, dass der Installationsfortschritt nicht eingefroren ist). Hierbei ist nur aufzupassen, dass der Hintergrund in &lt;code&gt;draw()&lt;/code&gt; gesetzt wird, ansonsten würden die Linien additiv gezeichnet. Das ist zwar auch schön, aber eben nicht das gewünschte Resultat.

Hiermit belassen wir es mit der py5-Bibliothek und wenden uns wieder &quot;mathematischeren&quot; Themen zu.

= Vektoren und Matrizen =
== Zahlenfolgen ==
Für das Erstellen von Zahlenfolgen bieten sich die Funktionen &lt;code&gt;arange&lt;/code&gt; und &lt;code&gt;linspace&lt;/code&gt; aus dem &lt;code&gt;numpy&lt;/code&gt;-Modul an.

 from numpy import *
 
 start = 0
 stop = 10
 step = 2
 num = 10
 
 r = arange(start, stop, step)   # step ... Schrittweite
 l = linspace(start, stop, num)  # num ... Anzahl der Werte
 
 print(&quot;r = &quot;, r)
 print(&quot;l = &quot;, l)

Ausgabe:
 r =  [0 2 4 6 8]
 l =  [ 0.          1.11111111  2.22222222  3.33333333  4.44444444  5.55555556
   6.66666667  7.77777778  8.88888889 10.        ]

Bei &lt;code&gt;arange&lt;/code&gt; ist der &lt;code&gt;stop&lt;/code&gt;-Wert nicht im Ergebnis enthalten, bei &lt;code&gt;linspace&lt;/code&gt; standardmäßig aber sehr wohl. Jedoch kann man das bei &lt;code&gt;linspace&lt;/code&gt; auch ändern. Dann ist der Stoppwert nicht mehr enthalten: 

 linspace(start, stop, num, endpoint=False)

== Vektoren ==
Vektoren sollten jedem aus der Linearen Algebra bekannt sein. 

=== Arrays ===
In Python mit NumPy kann man Vektoren durch die Funktion array erzeugen.

 import numpy as np
 
 l1 = (-5, 3, 2)
 l2 = (1, 1, 4)
 
 a1 = np.array(l1)
 a2 = np.array(l2)
 
 a3 = a1 + a2
 a4 = 2 * a2
 
 print(a1)
 print(a2)
 print(a3)
 print(a3[2])
 print(a4)

Ausgabe:
 [-5  3  2]
 [1 1 4]
 [-4  4  6]
 6
 [2 2 8]

=== Zeilen- und Spaltenvektoren ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 print(z)
 print(s)

Ausgabe:
 [ [-5  3  2] ]
 [[1]
  [1]
  [4]]

=== Skalarprodukt ===
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4))
 
 skalarprodukt = np.dot(a1, a2)  
 
 print(skalarprodukt)

Ausgabe:
 6

=== Vektorprodukt ===
&lt;math&gt;a\ast b=\left(\begin{array}{c}
a_{1}\\
a_{2}\\
a_{3}
\end{array}\right)\ast\left(\begin{array}{c}
b_{1}\\
b_{2}\\
b_{3}
\end{array}\right)=\left(\begin{array}{c}
a_{2}b_{3}-a_{3}b_{2}\\
a_{3}b_{1}-a_{1}b_{3}\\
a_{1}b_{2}-a_{2}b_{1}
\end{array}\right)
&lt;/math&gt; 

Python-Code:
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4)) 
 
 vektorprodukt = np.cross(a1, a2) 
 
 print(vektorprodukt)

Ausgabe:
 [10 22 -8]

=== Transponierter Vektor ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 # transponierter Vektor
 z_tp = np.transpose(z)
 # transponierter Vektor
 s_tp = np.transpose(s)
 
 print(z_tp)
 print(s_tp)

Ausgabe:
 [[-5]
  [ 3]
  [ 2]]
 [ [1 1 4] ]

=== Vektorfelder visualisieren ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 # Daten generieren
 x = np.arange(0, 10, 1)
 y = np.arange(0, 10, 1)
 X, Y = np.meshgrid(x, y)
 U = X * Y
 V = Y + X
 
 # Plotten
 fig, ax = plt.subplots()
 
 ax.quiver(X, Y, U, V, angles='xy')
 
 plt.show()

Ausgabe:

[[Datei:PythonIng_quiver1.png]]

== Matrizen==
 import numpy as np
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 print(m1)

Ausgabe:
 [[1 2 3]
  [4 5 6]]

=== Zugriff auf Matrizenelemente ===
Beispiel:

 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 
 # Element aus Zeile 2 und Spalte 3 (Achtung! Index startet bei Null)
 print(m1[1,2])

Ausgabe:
 6

Visualisierung:
  
     0   1   2
   +-----------+
 0 | 1 | 2 | 3 |
   +-----------+
 1 | 4 | 5 | '''6''' |
   +-----------+


Beispiel:

 import numpy as np
 
 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
 
 B = np.matrix(A)     
 
 print(B[2::, ::2])

Ausgabe:

 [['20' '22']
  ['30' '32']
  ['40' '42']]

Mit der NumPy-Bibliothek funktioniert das zweidimensionale Slicing. Mit normalen Listen/Tupels geht das nicht, was wir schon früher thematisiert haben.

=== Addition und Subtraktion von Matrizen ===
 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 m2 = np.matrix([[0, 0, 2], [1, 3, 2]])
 
 print(m1 + m2)
 print(m1 - m2)

Ausgabe:
 [[1 2 5]
  [5 8 8]]
 [[1 2 1]
  [3 2 4]]

=== Transponierte Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 2, 3], [4, 5, 6]])
 mt = np.transpose(m) 
 
 print(m)
 print(mt)

Ausgabe:
 [[1 2 3]
  [4 5 6]]
 [[1 4]
  [2 5]
  [3 6]]

=== Rang einer Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 rg = np.linalg.matrix_rank(m)
 
 print(rg)

Ausgabe:
 2

=== Inverse Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 mi = np.linalg.inv(m)
 
 print(mi)

Ausgabe:
 [[ 1.   0.6]
  [-0.  -0.2]]

=== Multiplikation von Matrizen (falksches Schema) ===
 import numpy as np
 
 m1 = np.matrix([[1, 3, 4],  [0, -5, 1]])
 m2 = np.matrix([[1, 2], [2, 3], [0, 2]])
 
 print(m1 @ m2)

Ausgabe:
 [[  7  19]
  [-10 -13]]

=== Eigenwerte und Eigenvektoren ===
 import numpy as np
 
 m = np.matrix([[5, 8],  [1, 3]])
 D,V = np.linalg.eig(m)
 
 # Eigenwerte
 print(D)
 # Eigenvektoren
 print(V)

Ausgabe:
 [7. 1.]
 [[ 0.9701425  -0.89442719]
  [ 0.24253563  0.4472136 ]]

=== Teilmatrizen ===
 import numpy as np
 m = np.matrix([[1, 3, 4],  [0, -5, 1]])
 print(&quot;m = &quot;, m)
 
 # Erste Zeile extrahieren
 m1 = m[0,:]
 print(&quot;m1 = &quot;, m1)
 
 # Das Element aus der 1. Zeile und der 2. Spalte extrahieren
 m2 = m[0,1]
 print(&quot;m2 = &quot;, m2)
 
 # Zweite Spalte extrahieren
 m3 = m[:, 1]
 print(&quot;m3 = &quot;, m3)

Ausgabe:
 m =  [[ 1  3  4]
  [ 0 -5  1]]
 m1 =  [ [1 3 4] ]
 m2 =  3
 m3 =  [[ 3]
  [-5]]

=== Spezielle Matrizen ===
==== Nullmatrix ====
 import numpy as np
 z = np.zeros((3, 2))
 print(z)

Ausgabe:
 [[0. 0.]
  [0. 0.]
  [0. 0.]]

==== Einheitsmatrix ====
 import numpy as np
 z = np.eye(3)
 print(z)

Ausgabe:
 [[1. 0. 0.]
  [0. 1. 0.]
  [0. 0. 1.]]

==== Matrix mit lauter Einsen ====
 import numpy as np
 z = np.ones((3, 2))
 print(z)

Ausgabe:
 [[1. 1.]
  [1. 1.]
  [1. 1.]]

=== Spärlich besetzte Matrizen ===
Das Thema spärlich besetzter Matrizen wird hier nur kurz angerissen. Nähere Details siehe unter dem Weblink  [https://docs.scipy.org/doc/scipy/reference/sparse.html#module-scipy.sparse]. 

Beispiel:

 import numpy as np
 import scipy
 
 A = scipy.sparse.csr_array(np.eye(5))
 
 print(A)

Ausgabe:
 &lt;Compressed Sparse Row sparse array of dtype 'float64'
         with 5 stored elements and shape (5, 5)&gt;
   Coords        Values
   (0, 0)        1.0
   (1, 1)        1.0
   (2, 2)        1.0
   (3, 3)        1.0
   (4, 4)        1.0

csr steht für '''c'''ompressed '''s'''parse '''r'''ow.

Andere Möglichkeiten:
* coo-Format ('''coo'''rdinate Format): &lt;code&gt;scipy.sparse.coo_array()&lt;/code&gt;
* lil-Format ('''li'''st of '''l'''ists): &lt;code&gt;scipy.sparse.lil_array()&lt;/code&gt;
* csc-Format ('''c'''ompressed '''s'''parse '''c'''olumn): &lt;code&gt;scipy.sparse.csc_array()&lt;/code&gt;

Es gibt auch &lt;code&gt;scipy.sparse.csr_matrix()&lt;/code&gt; etc. Diese Befehle sind aber veraltet und es wird empfohlen, statt dessen die &lt;code&gt;..._array()&lt;/code&gt;-Funktionen zu verwenden.

&lt;u&gt;Aufgaben:&lt;/u&gt; 
Recherchieren Sie im Internet 
* generell zum Thema &quot;spärlich besetzte Matrizen mit Python&quot;.
* Was sind die Vor-/Nachteile von csr-arrays gegenüber coo- und lil-arrays?
* Wann verwendet man sinnvollerweise csr- und wann csc-arrays?
* Wie wandelt man coo-arrays in csr-arrays um?

= Lineare Gleichungssysteme =
Sei &lt;math&gt;Ax = b&lt;/math&gt; ein lineares Gleichungssystem. &lt;math&gt;A&lt;/math&gt; sei die Koeffizientenmatrix, &lt;math&gt;x&lt;/math&gt; der Lösungsvektor und &lt;math&gt;b&lt;/math&gt; ein bekannter Vektor.

Beispiel:
 import numpy as np
 
 A = np.array([[5, 1], [0, 2]])
 b = np.array([1, 2])
 
 x = np.linalg.solve(A, b)
 
 print(x)

Ausgabe:
 [0. 1.]

Siehe dazu auch das Kapitel [[Ing Mathematik: Numerisches Lösen von linearen Gleichungssystemen]]. Dort wird dieses Themengebiet u.a. mit weitergehenden Python-Skripten vertieft.

== Aufgabe ==
* Lösen Sie folgendes Gleichungssystem mittels Python (und zur Kontrolle auch händisch): 
 5x + 6y - 2z = 12
 3x - y  - 3z = 6
 2x + 2y + 4z = 5

= Polynome =
== Ein erstes einfaches Beispiel ==
Gegeben sei das Polynom &lt;math&gt;7x^3+5x^2+1&lt;/math&gt;. In Python:

 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p)

Ausgabe:
    3     2
 7 x + 5 x + 1

== Einzelne Polynomwerte berechnen ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p(1.5))

Ausgabe:
 35.875

== Polynome integrieren und differenzieren ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 
 # 1. Ableitung
 p1 = p.deriv()
 p2 = p.deriv(1)
 
 # 2. Ableitung
 p3 = p.deriv(2)
 
 # Integral
 p4 = p.integ()
 
 print(p1)
 print(p2)
 print(p3)
 print(p4)

Ausgabe:
     2
 21 x + 10 x
     2
 21 x + 10 x
 
 42 x + 10
       4         3
 1.75 x + 1.667 x + 1 x

== Nullstellen bestimmen ==
 import numpy as np
 
 p = np.poly1d([2, 5, 0, 4])
 r = np.roots(p)
 
 print(r)

Ausgabe:
 [-2.7621427 +0.j          0.13107135+0.84077099j  0.13107135-0.84077099j]

== Aufgaben ==
* Berechnen Sie den Wert für x = 3 des Polynoms &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Differenzieren und integrieren Sie das Polynom &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Berechnen Sie die Nullstellen von &lt;math&gt;y = 7x^5 - 3x^2 + 12&lt;/math&gt;.

= Nichtlineare Gleichungen und Gleichungssysteme =
== Nullstellenbestimmung ==
Löse eine beliebige Gleichung f(x) = 0, z.B. &lt;math&gt; f(x) = x^2 - 5\cos(x) - 10 = 0 &lt;/math&gt;:
 import scipy
 import numpy as np
 
 def f(x):
     return x**2 - 5*np.cos(x) - 10
    
 xstart = [-1, 1]        # Startwerte
 xn = scipy.optimize.root(f, xstart)
 
 print(xn.x)

Ausgabe:
 [-2.46813009  2.46813009]

Funktionsgraph:

[[Datei:octave_nichtlin2.jpg]]

== Gleichungssysteme ==
SymPy ist ein externes Modul, das symbolisches Rechnen ('''Sym'''bolic '''Py'''thon) ermöglicht. 

Folgende Aufgabe ist dem Buch &quot;Knorrenschild: Numerische Mathematik, Hanser, 2017, Seite 72&quot; entnommen. Zu lösen ist das nichtlineare Gleichungssystem

&lt;math&gt;f_1 = 2x_1 + 4x_2 = 0 &lt;/math&gt;

&lt;math&gt;f_2 = 4x_1 + 8x_2^3 = 0&lt;/math&gt;

Mit Python ist das so möglich:
 import sympy
 
 x1, x2 = sympy.symbols(&quot;x1 x2&quot;) 
 
 f1 = 2*x1 + 4*x2
 f2 = 4*x1 + 8*x2**3
 
 s = sympy.solve((f1, f2), x1, x2) 
 
 print(s)

Ausgabe:
 [(-2, 1), (0, 0), (2, -1)]

Plot:

[[Datei:IngPython_nl_gleichung1.svg|500px]]

= Komplexe Zahlen =
Die imaginäre Einheit wird in Python durch den Buchstaben &lt;code&gt;j&lt;/code&gt; symbolisiert. Darstellen kann man eine komplexe Zahl bekannterweise in mehreren Formen:
* Kartesische Darstellung &lt;math&gt;z = \Re(z) + j \cdot \Im(z)&lt;/math&gt;
* Polardarstellungen &lt;math&gt;z = r \cdot (\cos(\phi) + j \cdot \sin(\phi)) = r \cdot e^{j\cdot \phi}&lt;/math&gt;

Die konjugiert komplexe Zahl ist &lt;math&gt;z^* = \Re(z) - j \cdot \Im(z)&lt;/math&gt;

Nachfolgend einige mathematische Operationen mit Python und NumPy.

 import numpy as np
 
 z1 = 2 + 5j           # kartesische Darstellung
 z2 = 3 * np.exp(3j)   # Polardarstellung
  
 # Addition
 res = z1 + z2
 print(&quot;z1 + z2 = &quot;, res)
 
 # Multiplikation
 res = z1 * z2
 print(&quot;z1 * z2 = &quot;, res)
 
 # Realteil
 res = np.real(z2)
 print(&quot;Realteil von z2 = &quot;, res)
 
 # Imaginärteil
 res = np.imag(z2)
 print(&quot;Imaginaerteil von z2 = &quot;, res)
 
 # Betrag
 res = np.abs(z1)
 print(&quot;Betrag von z1 = &quot;, res)
 
 # Argument
 res = np.angle(z1)
 print(&quot;Argument von z1 = &quot;, res)
 
 # Konjugiert komplexe Zahl
 res = np.conj(z1)
 print(&quot;Konjugiert komplexe Zahl von z1 = &quot;, res)

Ausgabe:
 z1 + z2 =  (-0.9699774898013365+5.423360024179601j)
 z1 * z2 =  (-8.05675510050068-14.003167400647481j)
 Realteil von z2 =  -2.9699774898013365
 Imaginaerteil von z2 =  0.4233600241796016
 Betrag von z1 =  5.385164807134504
 Argument von z1 =  1.1902899496825317
 Konjugiert komplexe Zahl von z1 =  (2-5j)

= Interpolation =
 import numpy as np
 import scipy
 import matplotlib.pyplot as plt
 
 # Stützpunkte
 xp = np.arange(1, 6)
 yp = (0, -5, 2, 7, 6)
 
 ti = np.arange(1, 5, 0.01)
 
 i1 = scipy.interpolate.interp1d(xp, yp, kind = &quot;linear&quot;)
 i2 = scipy.interpolate.interp1d(xp, yp, kind = &quot;cubic&quot;) 
 
 plt.plot(xp, yp, &quot;rx&quot;)
 plt.plot(xp, i1(xp))
 plt.plot(ti, i2(ti))
 plt.show()

Ausgabe:

[[Datei:PythonIng_interpol1.png]]

= Differenzialrechnung =
== Numerisches Differenzieren ==
Als Beispiel differenzieren wir &lt;math&gt;y = 5x\sin{x}&lt;/math&gt; und stellen das Ganze grafisch dar.

 from findiff import Diff
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.linspace(0, 10, 1000)
 f = 5 * x * np.sin(x)
 dx = x[1] - x[0]
 
 # Ableitung
 d_dx = Diff(0, dx)
 df_dx = d_dx(f)
 
 # Grafik
 plt.plot(x, f, label = &quot;y&quot;)
 plt.plot(x, df_dx, label = &quot;y'&quot;)
 plt.grid()
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

Ausgabe:

[[Datei:octave_diff1.jpg]]

&lt;small&gt;findiff ist ein externes Modul. Dieses muss installiert werden (z.B. so: ...\Python\Scripts\pip.exe install --upgrade findiff). Für die Vorgehensweise unter openSUSE Tumbleweed siehe das Kapitel [[Ing_Mathematik:_Python#Mit_VPython | VPython]], nur dass das Ganze mit einer aktuelleren Python-Version exekutiert wird, z.B. mit Python 3.13.  Das im Buch &quot;Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler, Rheinwerk&quot; verwendete Modul &quot;scipy.misc&quot; ist veraltet (deprecated ... missbilligt). Lt. [https://docs.scipy.org/doc/scipy-1.17.0/dev/roadmap-detailed.html#misc SciPy-Dokumentation für die Version 1.17.0] wurden alle entsprechenden Features schon entfernt.&lt;/small&gt;

== Symbolisches Differenzieren ==
Differenzieren Sie die Funktionen &lt;math&gt;f_1(x) = x^2&lt;/math&gt; und &lt;math&gt;f_2(x) = \sin(x)\cos\left(\frac{x}{2}\right)&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2;
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 d1 = sympy.diff(f1, x)
 d2 = sympy.diff(f2, x)
 
 print(d1)
 print(d2)

Ausgabe:
 2*x
 -0.5*sin(0.5*x)*sin(x) + cos(0.5*x)*cos(x)

== Aufgaben ==
* Differenzieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.
* Differenzieren Sie die Funktion &lt;math&gt;y = \frac{\sinh(x)}{(1+x)}&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.

= Integralrechnung =
== Numerisches Integrieren ==
Berechnen Sie das Integral &lt;math&gt;\int_{0}^{3}x^2 dx&lt;/math&gt;.

 import scipy
 
 def f(x):
     return x**2
    
 i = scipy.integrate.quad(f, 0, 3)
 print(i)

Ausgabe:
 (9.000000000000002, 9.992007221626411e-14)

Das trifft den exakten Wert 9.0 ziemlich genau.

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} dx&lt;/math&gt;.

 import scipy
 import numpy as np
 
 def f(x):
     return 2**(-x)
   
 i = scipy.integrate.quad(f, 0, np.inf)
 print(i)

Ausgabe:
 (1.4426950408889556, 4.486558477977586e-09)

== Symbolisches Integrieren ==
Berechnen Sie &lt;math&gt;\int x^2 \text{d}x&lt;/math&gt; und &lt;math&gt;\int \sin{x}\cos{\frac{x}{2}} \text{d}x&lt;/math&gt;.
 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 i1 = sympy.integrate(f1, x)
 i2 = sympy.integrate(f2, x)
 
 print(i1)
 print(i2)

Ausgabe:
 x**3/3
 -0.666666666666667*sin(0.5*x)*sin(x) - 1.33333333333333*cos(0.5*x)*cos(x)

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} \text{d}x&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f = 2**(-x)
 i = sympy.integrate(f, (x, 0, sympy.oo))
 print(i)

Ausgabe:
 1/log(2)

&lt;code&gt;sympy.oo&lt;/code&gt; steht für das {{W|Unendlichzeichen}} &lt;math&gt;\infty&lt;/math&gt; (die liegende Acht oder das Möbiusband). Mit &lt;code&gt;sympy.pprint(i)&lt;/code&gt; ließe sich letzere Ausgabe etwas schöner schreiben:

   1   
 ──────
 log(2)

Man beachtete, &lt;code&gt;log&lt;/code&gt; steht hier für den natürlichen Logarithmus &lt;code&gt;ln&lt;/code&gt;.

== Aufgaben ==
* Integrieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; von 1 bis 5.
* Integrieren Sie die Funktion &lt;math&gt;y = x^3&lt;/math&gt; von 0 bis 4.
* Integrieren Sie &lt;math&gt;\int x^x(\log (x) + 1)\mathrm dx&lt;/math&gt; symbolisch.

= Gewöhnliche Differenzialgleichungen =
== DGL numerisch lösen ==
Für die Lösung von Differenzialgleichungen steht u.a. die Funktion scipy.integrate.solve_ivp() zur Verfügung. Diese Funktion implementiert auch das Runge-Kutta-Verfahren (RK45).

{{Wikipedia | Runge-Kutta-Verfahren}}

Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import scipy
 import numpy as np
 import matplotlib.pyplot as plt
 
 def dy_dx(x, y):
     return x**2 + y**3
 
 y0 = [1]
 xi = [0, 1]
 x = np.arange(0, 1, 0.01)
 
 z = scipy.integrate.solve_ivp(dy_dx, xi, y0, method=&quot;RK45&quot;, dense_output=True)
 y = z.sol(x)
 
 plt.plot(x, y.T)
 plt.grid()
 plt.show()

[[Datei:PythonIng_dgl1.png]]

== DGL symbolisch lösen ==
Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 print(lsg)

Ausgabe:
 [Eq(f(x), (-x**2)**(1/3)), Eq(f(x), (-x**2)**(1/3)*(-1 - sqrt(3)*I)/2), Eq(f(x), (-x**2)**(1/3)*(-1 + sqrt(3)*I)/2)]

Mit &lt;code&gt;sympy.pprint&lt;/code&gt; (pretty print) lässt sich die Ausgabe etwas übersichtlicher darstellen.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 sympy.pprint(lsg)

Ausgabe:
 ⎡                           _____                        _____            ⎤
 ⎢          _____         3 ╱   2                      3 ╱   2             ⎥
 ⎢       3 ╱   2          ╲╱  -x  ⋅(-1 - √3⋅ⅈ)         ╲╱  -x  ⋅(-1 + √3⋅ⅈ)⎥
 ⎢f(x) = ╲╱  -x  , f(x) = ────────────────────, f(x) = ────────────────────⎥
 ⎣                                 2                            2          ⎦

== Aufgaben ==
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \frac{1}{x\cdot y}&lt;/math&gt; mit Python. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;m' = -k\cdot m&lt;/math&gt;. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \sqrt{|y|}&lt;/math&gt;.

=Laplace-Transformation=
Laplace-Transformation:

&lt;math&gt;F(s) =\mathcal{L} \left\{f\right\}(s) = \int_{0}^{\infty} f(t) \mathrm e^{-st} \,\mathrm{d}t, \qquad s\in\mathbb{C}
&lt;/math&gt;

Inverse Laplace-Transformation:

&lt;math&gt;\mathcal{L}^{-1} \left\{F\right\}(t)
  = \frac{1}{2 \pi \mathrm j} \int_{ \gamma - \mathrm j \infty}^{ \gamma + \mathrm j \infty} \mathrm e^{st} F(s)\,\mathrm ds 
= \begin{cases}
      f(t) &amp; \text{für } t \geq 0 \\
      0    &amp; \text{für } t &lt; 0
    \end{cases}
&lt;/math&gt;

Siehe auch [[Ing_Mathematik:_Laplace-Transformation]]

Code:
 import sympy
 from sympy.abc import t, s
 
 # Laplace-Transformation der Funktion f(t) = 1 (Heaviside-Fkt.)
 f = 1
 # alternativ: f = sympy.Heaviside(t)
 F = sympy.laplace_transform(f, t, s, noconds=True)
 print(&quot;Laplace-Transformierte F(s):&quot;, F) 
 
 # Inverse Laplace-Transformation zurück in den Zeitbereich
 f_inv = sympy.inverse_laplace_transform(F, s, t)
 print(&quot;Inverse Transformation f(t):&quot;, f_inv)

Ausgabe:
 Laplace-Transformierte F(s): 1/s
 Inverse Transformation f(t): Heaviside(t)

Die Zeile

 from sympy.abc import t, s

steht alternativ für

 t = sympy.symbols(&quot;t&quot;)
 s = sympy.symbols(&quot;s&quot;)

&lt;u&gt;Aufgaben&lt;/u&gt;: Ermitteln Sie mittels SymPy die &lt;math&gt;\mathcal{L}&lt;/math&gt;-Transformierten und dann wieder die  &lt;math&gt;\mathcal{L}^{-1}&lt;/math&gt;-Transformationen (ähnlich wie beim obigen Beispiel):
* &lt;math&gt;\sin(t) \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;t^3 \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;\text{e}^{\omega t} \circ\! -\! \bullet \ ?&lt;/math&gt;

=Fourier-Reihen=
&lt;math&gt;
f(x)\approx \frac{a_{0}}{2}+\sum_{k=1}^{\infty}\left(a_{k}\cos\left(kx\right)+b_{k}\sin\left(kx\right)\right)
&lt;/math&gt;

&lt;math&gt;
a_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\cos\left(kx\right)\mathrm dx\quad\text{für }k\geq0
&lt;/math&gt;

&lt;math&gt;
b_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\sin\left(kx\right)\mathrm dx\quad\text{für }k\geq1
&lt;/math&gt;

Für die Sägezahnfunktion &lt;math&gt;y=x;\, 0 &lt; x &lt; 2\pi&lt;/math&gt; sei die Fourierreihe mit einem Python-Programm (unter Mithilfe von sympy) hergeleitet.

Code:

 from sympy import fourier_series, pi, symbols, pprint
 
 x = symbols('x')
 f = x
 s = fourier_series(f, (x, 0, 2*pi))
 pprint(s.truncate(n=4))

Ausgabe:

                        2⋅sin(3⋅x)    
 -2⋅sin(x) - sin(2⋅x) - ────────── + π
                            3

Siehe auch [[Ing Mathematik: Fourierreihen]].

Ein komplizierteres Beispiel:

[[Datei:IngMath fourier bsp13.svg | 300px]]

&lt;math&gt;0\le t &lt; T/2\text{:}\quad f(t) = H&lt;/math&gt;

&lt;math&gt;T/2 \le t \le T\text{:}\quad f(t) = \frac{2H}{T}\left( t-\frac{T}{2}\right)&lt;/math&gt;

Code:

 import sympy as sp
 
 H = sp.Symbol('H', positive=True)
 T = sp.Symbol('T', positive=True)
 t = sp.Symbol('t')
 
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T/2)),
     (2*H/T*(t-T/2), (t &gt; T/2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Ausgabe:

      ⎛2⋅π⋅t⎞        ⎛4⋅π⋅t⎞        ⎛6⋅π⋅t⎞          ⎛2⋅π⋅t⎞          ⎛6⋅π⋅t⎞      
 H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   2⋅H⋅cos⎜─────⎟   2⋅H⋅cos⎜─────⎟      
      ⎝  T  ⎠        ⎝  T  ⎠        ⎝  T  ⎠          ⎝  T  ⎠          ⎝  T  ⎠   3⋅H
 ──────────── - ──────────── + ──────────── + ────────────── + ────────────── + ───
      π             2⋅π            3⋅π               2                 2         4 
                                                    π               9⋅π

=Rechnen mit wirklich großen Zahlen=
Bekannt ist, dass Python kaum Einschränkungen beim Wertebereich von Ganzzahlen hat, z.B.

 print(10**300)

Ausgabe (gekürzt):

 100000000000000000000...00000000000000000000000000000000000000000000000000000000000000000000000

Ähnliches geht auch mit Gleitpunktzahlen, z.B. durch die Verwendung des Moduls [https://mpmath.org/ mpmath]:

 import mpmath
 print(mpmath.mpf(1500.4)**mpmath.mpf(300))

Ausgabe:

 7.27975299218612e+952

Anderes Beispiel:

 from mpmath import mp, pi
 mp.dps = 100
 print(pi)

Ausgabe:

 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068

mpmath kann noch einiges mehr, dazu sei aber auf die entsprechende Dokumentation auf der mpmath-Homepage verwiesen. mpmath ist Bestandteil von SymPy, kann aber auch separat installiert werden.

Aber auch Python selbst besitzt eine Möglichkeit, um mit großen bzw. exakten Gleitpunktzahlen zu rechnen, nämlich das interne Modul decimal. Dieses hat einige Vorteile gegenüber mpmath, aber auch gravierende Nachteile. Diese seien hier nicht detailliert aufgezählt. Grob gesagt hat decimal im Finanzwesen seine Berechtigung. Für wissenschaftliche Anwendungen wird aber mpmath vorzuziehen sein, da es u.a. vielfältige mathematische Funktionen bereit stellt. Nachfolgend ein einfaches Beispiel mit decimal:

 import decimal
 print(&quot;Potenzierung:&quot;, decimal.Decimal(1500.4) ** decimal.Decimal(300.0))
 print(&quot;Einfache Addition:&quot;, 0.1 + 0.2)
 decimal.getcontext().prec = 50
 print(&quot;Addition mit decimal:&quot;, decimal.Decimal(&quot;0.1&quot;) + decimal.Decimal(&quot;0.2&quot;))

Ausgabe:

 Potenzierung: 7.279752992186121551039839134E+952
 Einfache Addition: 0.30000000000000004
 Addition mit decimal: 0.3

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet die genauen Vor- und Nachteile von decimal und mpmath. Verwenden Sie dazu auch KI (z.B. von Google, chatgpt).

= pint - mit physikalischen Größen rechnen = 
[[File:Pint-Glas_UK.jpg|right|100px]]
pint ist ein externes Python-Paket zur Manipulation von physikalischen Einheiten. Es muss vor der ersten Benutzung installiert werden (Vorgehensweise wie immer: pip, YaST, via venv etc.).

Beispiel:

 import pint
 import numpy as np
 
 ureg = pint.UnitRegistry()
 
 # Einfache Berechnung
 print(3 * ureg.meter + 4 * ureg.cm)
 
 # Mit NumPy
 npeinzel = [3, 4] * ureg.meter + [2, 5] * ureg.cm
 print(npeinzel)
 npsum = np.sum(npeinzel)
 print(npsum)
 
 # Konvertierung von Einheiten
 npsum_inch = npsum.to(ureg.inch)
 print(npsum_inch)
 
 print(npeinzel.magnitude)
 print(npeinzel.units)
 print(npeinzel.dimensionality)

Ausgabe:

 3.04 meter
 [3.02 4.05] meter
 7.07 meter
 278.3464566929134 inch
 [3.02 4.05]
 meter
 [length]

Die Dokumentation zu pint findet sich auf [https://pint.readthedocs.io/en/stable/].

=Regelungstechnische Aufgabenstellungen=
Für regelungstechnische Aufgaben gibt es u.a. das externe Paket &lt;code&gt;control&lt;/code&gt;. Hier soll nicht detailliert darauf eingegangen werden. Anhand eines Beispiels soll anschließend nur die Visualisierung in Form eines Bode-Diagramms und der Sprungantwort gezeigt werden. Gegeben sei ein P-Regler mit &lt;math&gt;R = \frac{5}{2}&lt;/math&gt; und eine Strecke &lt;math&gt;S= \frac{1}{30s^3+20s^2+10s+1,5}&lt;/math&gt;. Gesucht sei vorerst ein Bode-Diagramm für den offenen Regelkreis und das Führungsverhalten.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke  # oder: G0 = ct.series(regler, strecke)
 Gw = ct.feedback(G0)
 
 ct.bode_plot(G0, label='G0')
 ct.bode_plot(Gw, label='Gw')
 plt.show()

[[Datei:PythonIng_bode1.svg]]

Nun noch für obiges Beispiel die Sprungantwort. Diese zeigt einige große Überschwinger, d.h. der Regler kann sicher noch optimiert werden.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke 
 Gw = ct.feedback(G0) 
 
 t, y = ct.step_response(Gw)
 
 plt.plot(t,y)
 plt.title('Sprungantwort')
 plt.xlabel('t')
 plt.ylabel('h(t)')
 plt.grid()
 plt.show()

[[Datei:PythonIng_bode3.svg]]

Einige weitere wichtige Daten (Phasenreserve, Amplitudenreserve, Durchtrittsfrequenz) lassen sich mittels der &lt;code&gt;control&lt;/code&gt;-Funktion &lt;code&gt;margin()&lt;/code&gt; ermitteln. Die Ortskurve lässt sich mit der Funktion &lt;code&gt;nyquist_plot()&lt;/code&gt; zeichnen. Dies sei hier aber nicht weiter ausgeführt.

==Aufgaben==
* Zeichen Sie mit Python die Ortskurve für obiges Beispiel.
* Was passiert, wenn man die Reglerverstärkung weiter aufdreht (z.B. auf &lt;math&gt;R = \frac{25}{2}&lt;/math&gt;)?
* Wie sehen das Bode-Diagramm und die Sprungantwort aus, wenn ein PI-Regler verwendet wird?

= Stereostatik etc. =
Das Modul SymPy bietet einige Möglichkeiten einfache Bauwerke zu berechnen, z.B. Balken oder Fachwerke. Nachfolgend wird ein einfaches Fachwerk berechnet und gezeichnet.

Python-Code:
 from sympy.physics.continuum_mechanics.truss import Truss 
 
 t = Truss()
 # Knoten
 t.add_node((&quot;A&quot;, -3, 0), (&quot;B&quot;, 0, 0), (&quot;C&quot;, 4, 0), (&quot;D&quot;, 7, 0),
            (&quot;E&quot;, 6, 1.5), (&quot;F&quot;, 2, 3), (&quot;G&quot;, -2, 1.5))
 # Stäbe
 t.add_member((&quot;AB&quot;,&quot;A&quot;,&quot;B&quot;), (&quot;BC&quot;,&quot;B&quot;,&quot;C&quot;), (&quot;CD&quot;,&quot;C&quot;,&quot;D&quot;))
 t.add_member((&quot;AG&quot;,&quot;A&quot;,&quot;G&quot;), (&quot;GB&quot;,&quot;G&quot;,&quot;B&quot;), (&quot;GF&quot;,&quot;G&quot;,&quot;F&quot;))
 t.add_member((&quot;BF&quot;,&quot;B&quot;,&quot;F&quot;), (&quot;FC&quot;,&quot;F&quot;,&quot;C&quot;), (&quot;CE&quot;,&quot;C&quot;,&quot;E&quot;))
 t.add_member((&quot;FE&quot;,&quot;F&quot;,&quot;E&quot;), (&quot;DE&quot;,&quot;D&quot;,&quot;E&quot;))
 # Auflager; roller ... Loslager, pinned ... Festlager
 t.apply_support((&quot;A&quot;,&quot;roller&quot;), (&quot;D&quot;,&quot;pinned&quot;))
 # Einwirkende Kräfte
 t.apply_load((&quot;G&quot;, 5, 270), (&quot;E&quot;, 3, 90))
 
 # Berechnung 
 t.solve()
 print(&quot;Reaction Forces: &quot;, t.reaction_loads)
 print(&quot;Internal Forces: &quot;, t.internal_forces)
 
 # Fachwerk zeichnen
 p = t.draw()
 p.show()

Ausgabe auf der Konsole:

 Reaction Forces:  {'R_A_y': 4.20000000000000, 'R_D_x': 0, 'R_D_y': -2.20000000000000}
 Internal Forces:  {'AB': 2.80000000000000, 'BC': 0.333333333333333, 'CD': -1.46666666666667, 
 'AG': -5.04777178564958, 'GB': -2.05555555555556, 'GF': -1.23413387432364, 
 'BF': 0.411111111111111*sqrt(13), 'FC': -0.3*sqrt(13), 'CE': 1.50000000000000, 
 'FE': 0.284800124843917, 'DE': 2.64407093534026}

Zeichnung:

[[File:PythonIng_fachwerk1.svg|300px]]

Details zu diesem Thema siehe z.B. [https://docs.sympy.org/latest/modules/physics/continuum_mechanics/index.html Continuum Mechanics] oder [https://docs.sympy.org/latest/tutorials/physics/continuum_mechanics/index.html Continuum Mechanics Tutorials]. Auch andere mechanische Probleme werden von SymPy abgehandelt ([https://docs.sympy.org/latest/tutorials/physics/index.html Physics Tutorials]).

== Aufgabe ==
Gegeben sei ein einseitig eingespannter Kragträger. Belastet wird er durch eine Einzellast am Trägerende. Für die Daten siehe folgende ASCII-Skizze:

                            | 20 kN  
    //|---&gt; x               |
    //|                     V
    //|----------------------
    //|         10 m        |
 
 Elastizitätsmodul E = 2,1*10⁵ N/mm²
 Flächenträgheitsmoment I = 0.001 m⁴

Berechnen Sie die Auflagerreaktionen, den Querkraft- und Biegemomentenverlauf, sowie die Verformungen.
Stellen Sie dies mit Hilfe von SymPy graphisch und auch mittels Formeln dar. Verwenden Sie dazu auch pprint (pretty print) aus dem SymPy-Modul. Zwecks Lösungsansatz siehe die oben aufgeführte Seite &quot;Continuum Mechanics Tutorials&quot;. Achten Sie auch auf die Einheiten! Kontrollieren Sie das Ganze mittels händischer Rechnung. In dem genannten Tutorial ist von &quot;Singularity Functions&quot; die Rede. Gemeint ist damit in diesem Kontext die {{W|Föppl-Klammer}}.

Einige Python-Programme, vorrangig zu Maschinenelementen, finden sich auf [https://baymp.de/download_python.html BayMP für Python] (Balken, Zahnräder, Stabknickung usw.).

=Thermodynamik= 
== PYroMat ==
Für thermodynamische Aufgabenstellungen gibt es verschiedene externe Module. Eines davon ist PYroMat (siehe auch [http://pyromat.org]). Damit lassen sich thermodynamische Stoffdaten für viele Substanzen berechnen.

Beispiel (einige Stoffdaten für Wasser bei 400°C und 20 bar berechnen):

 import pyromat as pm
 
 # Wasserdaten laden:
 H2O = pm.get('mp.H2O')
 
 # Stoffdaten berechnen:
 T = 673.15  # Temperatur in Kelvin
 p = 20      # Druck in bar
 v = H2O.v(T, p)
 h = H2O.h(T, p)
 s = H2O.s(T, p)
 print(f&quot;Spezifisches Volumen: {v} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {h} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {s} kJ/(kg K)&quot;)

Ausgabe:

 Spezifisches Volumen: [0.1512163] m³/kg
 Spezifische Enthalpie: [3248.3789473] kJ/kg
 Spezifische Entropie: [7.12924142] kJ/(kg K)

&lt;small&gt;
PYroMat muss vorab installiert werden (z.B. mittels pip, in eine virtuelle Umgebung)
&lt;/small&gt;

&lt;code&gt;mp&lt;/code&gt; steht für &quot;multi phase&quot;. Für ein ideales Gas wäre &lt;code&gt;ig&lt;/code&gt; zuständig, z.B. &lt;code&gt;'ig.O2'&lt;/code&gt;.

Beispiel (T-s-Diagramm für Wasser zeichnen):
 import numpy as np
 import matplotlib.pyplot as plt
 import pyromat as pm
 
 # Konfigurieren
 pm.config[&quot;unit_pressure&quot;] = &quot;bar&quot;
 pm.config[&quot;unit_temperature&quot;] = &quot;K&quot;
 fluid = pm.get(&quot;mp.H2O&quot;)
 
 # Temperaturbereich für das Nassdampfgebiet
 T_tripel = 273.16
 T_crit = 647.096
 T = np.linspace(T_tripel, T_crit - 0.1, 200)
 
 # Sättigungslinien berechnen und zeichnen
 for x in np.linspace(0.0, 1.0, 5):
     s = fluid.s(T=T, x=x)
     if(x&lt;=0.0):
         plt.plot(s, T, label=&quot;Siedelinie x=%3.1f&quot; % x, linewidth=2.0)
     elif(x&gt;=1.0):
         plt.plot(s, T, label=&quot;Taulinie x=%3.1f&quot; % x, linewidth=2.0)
     else:
         plt.plot(s, T, label=&quot;x=%3.1f&quot; % x, linewidth=1.0)
 
 # Isobaren zeichnen
 p_values = [0.1, 1, 10, 50, 100]
 T_isobar = np.linspace(T_tripel, 1000, 200)
 t = 0.7
 
 for p in p_values:
     s_iso = fluid.s(T=T_isobar, p=p)
     plt.plot(s_iso, T_isobar, 'k-', alpha=0.8, linewidth=0.8)
 
     t += .05
     idx = int(len(s_iso) * t)
     plt.text(s_iso[idx], T_isobar[idx], f&quot;{p} bar&quot;, fontsize=9, alpha=0.8)
 
 # Diagramm zeichnen
 plt.title(&quot;T-s-Diagramm für Wasser&quot;)
 plt.xlabel(&quot;Spezifische Entropie s in kJ/kg K&quot;, fontsize=10)
 plt.ylabel(&quot;Temperatur T in K&quot;, fontsize=10)
 plt.legend(loc=&quot;best&quot;)
 plt.grid(True)
 plt.show()

Ausgabe (in etwa so):

[[Datei:T-s-Diagramm fuer Wasser.svg|400px]]

== CoolProp ==
Auch mit CoolProp können Stoffdaten berechnet werden. Siehe auch [https://coolprop.org/coolprop/wrappers/Python/index.html]

Beispiel (Wasser bei 20bar und 400°C):
 import CoolProp.CoolProp as CP
 
 fluid = 'Water'
 T = 673.15   # Temperatur in Kelvin
 P = 20e5     # Druck in Pascal
 
 dichte = CP.PropsSI('D', 'T', T, 'P', P, fluid)
 enthalpie = CP.PropsSI('H', 'T', T, 'P', P, fluid)
 entropie = CP.PropsSI('S', 'T', T, 'P', P, fluid)
 
 print(f&quot;Spez. Volumen: {1/dichte:.6f} m³/kg&quot;)
 print(f&quot;Spez. Enthalpie: {enthalpie:.2f} J/kg&quot;)
 print(f&quot;Spez. Entropie: {entropie:.2f} J/kgK&quot;)

Ausgabe:
 Spez. Volumen: 0.151215 m³/kg
 Spez. Enthalpie: 3248344.02 J/kg
 Spez. Entropie: 7129.16 J/kgK

== iapws ==
Um Werte für Wasser(dampf) zu erhalten (IAPWS; '''I'''nternational '''A'''ssociation for the '''P'''roperties of '''W'''ater and '''S'''team) gibt es die Bibliothek iapws. Siehe auch [https://iapws.org/] und [https://pypi.org/project/iapws/]

Beispiel (Wasser für 20bar und 400°C):
 from iapws import IAPWS97
 
 dampf = IAPWS97(P=2.0, T=673.15)
 
 print(f&quot;Spezifisches Volumen: {dampf.v:.6f} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {dampf.h:.2f} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {dampf.s:.4f} kJ/(kgK)&quot;)
 print(f&quot;Phase: {dampf.phase}&quot;)

Ausgabe:
 Spezifisches Volumen: 0.151208 m³/kg
 Spezifische Enthalpie: 3248.23 kJ/kg
 Spezifische Entropie: 7.1290 kJ/(kgK)
 Phase: Gas

== TESPy ==
Ein anderes Modul für einen anderen Aufgabenzweck ist TESPy ('''T'''hermal '''E'''ngineering '''S'''ystems in '''Py'''thon). Dieses Modul ist für die Anlagensimulation zuständig. Für nähere Informationen siehe [https://tespy.readthedocs.io/en/main/getting_started/introduction.html]. Als Beipiel sei hier vorerst Code, der von der Google KI generiert wurde, angeführt. Der Code wurde überarbeitet, damit keine Warnungen auftreten. Bitte aber den Code trotzdem mit Vorsicht genießen, auch KI-generierter Code kann Fehler aufweisen. Eine Pumpe wird berechnet:

 from tespy.components import Sink, Source, Pump
 from tespy.connections import Connection
 from tespy.networks import Network
 
 # 1. Netzwerk definieren (Zentrales Steuerungselement)
 # Wir wählen Wasser als Fluid und bar/Celsius als Einheiten
 nw = Network(fluids=[&quot;water&quot;])
 nw.units.set_defaults(pressure=&quot;bar&quot;, pressure_difference=&quot;bar&quot;, 
                       temperature=&quot;°C&quot;, enthalpy=&quot;kJ / kg&quot;)
 
 # 2. Komponenten erstellen
 eingang = Source(&quot;Wasserquelle&quot;)
 ausgang = Sink(&quot;Wasserspeicher&quot;)
 pumpe = Pump(&quot;Speisewasserpumpe&quot;)
 
 # 3. Verbindungen definieren (Komponenten miteinander verknüpfen)
 c1 = Connection(eingang, &quot;out1&quot;, pumpe, &quot;in1&quot;)
 c2 = Connection(pumpe, &quot;out1&quot;, ausgang, &quot;in1&quot;)
 
 # Verbindungen dem Netzwerk hinzufügen
 nw.add_conns(c1, c2)
 
 # 4. Randbedingungen und Parameter festlegen
 # Zustand am Eingang (Druck, Temperatur, Massenstrom, Fluid-Zusammensetzung)
 c1.set_attr(
     v=1,  # Massenstrom: 1 kg/s
     T=20,  # Temperatur: 20 °C
     p=1,  # Druck: 1 bar
     fluid={&quot;water&quot;: 1},  # 100% Wasser
 )
 
 # Zustand am Ausgang / Zielwerte der Pumpe
 c2.set_attr(p=10)  # Ziel-Druck nach der Pumpe: 10 bar
 
 # Pumpeneigenschaften festlegen
 pumpe.set_attr(eta_s=0.8)  # Isentroper Wirkungsgrad von 80%
 
 # 5. Simulation ausführen
 nw.solve(mode=&quot;design&quot;)
 
 # 6. Ergebnisse ausgeben
 nw.print_results()
 
 # Spezifische Werte direkt auslesen
 print(&quot;\n--- Auswertung ---&quot;)
 print(f&quot;Erforderliche Pumpenleistung: {pumpe.P.val / 1000:.2f} kW&quot;)
 print(f&quot;Temperatur nach der Pumpe: {c2.T.val:.2f} °C&quot;)

Ausgabe (gekürzt):
  iter  | residual   | progress   | massflow   | pressure   | enthalpy   | fluid      | component  
 -------+------------+------------+------------+------------+------------+------------+------------
  1     | 7.04e+04   | 12 %       | 9.96e+02   | 0.00e+00   | 8.81e+04   | 0.00e+00   | 0.00e+00   
  2     | 5.91e-12   | 100 %      | 1.11e-13   | 0.00e+00   | 7.39e-12   | 0.00e+00   | 0.00e+00   
  3     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
  4     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
 Total iterations: 4, Calculation time: 0.01 s, Iterations per second: 480.85
 
 ##### RESULTS (Pump) #####
 +-------------------+----------+----------+-----------+----------+----------+----------+
 |                   |        P |       pr |        dp |      eta |    eta_s |     head |
 |-------------------+----------+----------+-----------+----------+----------+----------|
 | Speisewasserpumpe | 1.12e+06 | 1.00e+01 | -9.00e+00 | 8.00e-01 | 8.00e-01 | 9.19e+01 |
 +-------------------+----------+----------+-----------+----------+----------+----------+
 ...
 ...
 --- Auswertung ---
 Erforderliche Pumpenleistung: 1124.77 kW
 Temperatur nach der Pumpe: 20.07 °C

= Stochastik =
Die {{W|Stochastik}} ist ein sehr weites Feld. Hier werden etliche wichtige Themen kurz angerissen. Python stellt mit den Moduln math und statistics Software zu diesem Zwecke bereit. math und statistics sind bereits im Lieferumfang von Python enthalten. Aber auch mit den externen Modulen NumPy, SciPy, stochastic und pandas kann man Stochastik in Python betreiben. Die Theorie der Wahrscheinlichkeitsrechnung und Statistik soll etwas später in Band 5 dieser Buchreihe behandelt werden.

== Lageparameter == 
 import statistics
 
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 
 m1 = statistics.mean(werte)
 m2 = statistics.mode(werte)
 m3 = statistics.median(werte)
 
 print(&quot;Arithmetischer Mittelwert = &quot;, m1)
 print(&quot;Modalwert = &quot;, m2)
 print(&quot;Median = &quot;, m3)

Ausgabe:
 Arithmetischer Mittelwert =  3.5
 Modalwert =  1
 Median =  3.0

== Streuungsparameter ==
Beispiel (Berechnung der Standardabweichung):
 import statistics
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 s = statistics.stdev(werte)
 print(&quot;Standardabweichung = &quot;, s)

Ausgabe:
 Standardabweichung =  2.6770630673681683

Beispiel (Berechnung des Variationskoeffizienten V = Standardabweichung/Mittelwert)
 import numpy as np
 from scipy import stats
 import statistics
 
 k = 50
 
 dat1 = [14, 21, 18, 25, 30, 17, 20]
 dat = np.array(dat1)
 
 # Mit SciPy
 v = stats.variation(dat)
 vddof = stats.variation(dat, ddof=1)
 print(&quot;V SciPy: &quot;, v)
 print(&quot;V DDOF SciPy: &quot;, vddof)
 print(k*&quot;-&quot;)
 
 # mit NumPy
 mittelwert1 = np.mean(dat)
 std_abw1 = np.std(dat)
 std_abw1ddof = np.std(dat, ddof=1) 
 v1= std_abw1 / mittelwert1
 v1ddof = std_abw1ddof / mittelwert1
 print(&quot;Mittelwert NumPy: &quot;, mittelwert1)
 print(&quot;Std.abw. NumPy: &quot;, std_abw1)
 print(&quot;Std.abw. DDOF NumPy: &quot;, std_abw1ddof)
 print(&quot;V NumPy: &quot;, v1)
 print(&quot;V DDOF NumPy: &quot;, v1ddof)
 print(k*&quot;-&quot;)
 
 # nur mit reinem Python
 mittelwert2 = statistics.mean(dat1)
 std_abw2 = statistics.stdev(dat1)
 v2 = std_abw2 / mittelwert2
 print(&quot;Mittelwert Python: &quot;, mittelwert2)
 print(&quot;Std.abw. Python: &quot;, std_abw2)
 print(&quot;V Python:&quot;, v2)
 print(k*&quot;-&quot;)

Ausgabe:
 V SciPy:  0.23890355966467272
 V DDOF SciPy:  0.25804533701889254
 --------------------------------------------------
 Mittelwert NumPy:  20.714285714285715
 Std.abw. NumPy:  4.948716593053935
 Std.abw. DDOF NumPy:  5.3452248382484875
 V NumPy:  0.23890355966467272
 V DDOF NumPy:  0.2580453370188925
 --------------------------------------------------
 Mittelwert Python:  20.714285714285715
 Std.abw. Python:  5.3452248382484875
 V Python: 0.2580453370188925
 --------------------------------------------------

Der Unterschied bei der Standardabweichung zwischen reinem Python und den externen Bibliotheken SciPy und NumPy entsteht dadurch, dass einmal durch (n-1) und das andere Mal nur durch n dividiert wird. Dies kann bei NumPy und SciPy dadurch entschärft werden, indem &lt;code&gt;ddof=1&lt;/code&gt; gesetzt wird. ddof steht für '''D'''elta '''D'''egrees '''o'''f '''F'''reedom. &lt;small&gt;Je größer die Anzahl der Datensätze n wird, umso weniger spielt das eine Rolle.&lt;/small&gt;

== Kombinatorik ==
Beispiel:

 import math
 
 n = 7
 k = 5
 
 print(&quot;n! = &quot;, math.factorial(n))
 print(&quot;Kombinationen (n über k) = &quot;, math.comb(n, k))

Ausgabe:
 n! =  5040
 Kombinationen (n über k) =  21

Siehe zu diesem Thema auch [[Ing Mathematik: Permutationen, Kombinationen, binomischer Lehrsatz]]. Die Anzahlen lassen sich einfach aus den dortigen Formeln ermitteln, z.B. bei Permutationen mit &lt;math&gt;n!&lt;/math&gt; oder Variationen mit Wiederholungen als &lt;math&gt;n^k&lt;/math&gt;. Will man die Kombinationen oder Variationen aber auch als Liste ausgeben, so kann das Modul &lt;code&gt;itertools&lt;/code&gt; nützlich sein.  

Beispiel (Variationen ohne Wiederholung):

 from itertools import permutations
 
 menge = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]  # n = 4
 k = 3
 
 variationen = list(permutations(menge, k))
 
 for v in variationen:
     print(&quot;&quot;.join(v))
 
 print(50*&quot;-&quot;)
 print(len(variationen))

Ausgabe (gekürzt):
 ABC
 ABD
 ACB
 ...
 DCA
 DCB
 --------------------------------------------------
 24

Siehe zum Modul &lt;code&gt;itertools&lt;/code&gt; auch die Website [https://docs.python.org/3/library/itertools.html].

* Variationen mit Wiederholung: &lt;code&gt;itertools.product()&lt;/code&gt;
* Kombinationen ohne Wiederholung: &lt;code&gt;itertools.combinations()&lt;/code&gt;
* Kombinationen mit Wiederholung: &lt;code&gt;itertools.combinations_with_replacement()&lt;/code&gt;

== Zufallszahlen ==
Beispiel:
 import random
 
 # Ganzzahlige Zufallszahl von 1 bis 10
 zufallszahl1 = random.randint(1, 10)
 
 # Gleitpunktzahlen
 # zwischen 0.0 und 1.0
 zufallszahl2 = random.random()
 # Zahl zwischen 1.5 und 9.5
 zufallszahl3 = random.uniform(1.5, 9.5)
 
 # aus Liste auswählen
 farbe = [&quot;Rot&quot;, &quot;Grün&quot;, &quot;Blau&quot;]
 zufallswert = random.choice(farbe)
 
 print(zufallszahl1)
 print(zufallszahl2)
 print(zufallszahl3)
 print(zufallswert)

Ausgabe, z.B.:
 5
 0.14147945849015753
 6.894003397570905
 Rot

Benötigt man mehrere Zufallszahlen, so ist das Modul &lt;code&gt;numpy&lt;/code&gt; zu bevorzugen, z.B.:
* Normalverteilung: &lt;code&gt;np.random.normal(...)&lt;/code&gt;
* Gleichverteilung: &lt;code&gt;np.random.uniform(...)&lt;/code&gt;

== Histogramm ==
Zum Thema Histogramm siehe {{W|Histogramm}}.

Beispiel (mit Matplotlib):

 import matplotlib.pyplot as plt
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 
 plt.hist(daten, bins=25, edgecolor='darkgray')
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm.svg|300px]]

Beispiel (mit Seaborn):

 import matplotlib.pyplot as plt
 import seaborn as sns
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 sns.set_theme(style=&quot;darkgrid&quot;)
 sns.histplot(data=daten)
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm2.svg|300px]]

Das Kürzel &lt;code&gt;sns&lt;/code&gt; ist Konvention und steht für die fiktive Figur '''S'''amuel '''N'''orman '''S'''eaborn aus der US-Fernsehserie {{W|The West Wing – Im Zentrum der Macht | The West Wing}}.

== Box-Plot ==
[[File:Elements of a boxplot.svg|400px]]

Siehe auch {{W|Box-Plot}}.

Beispiel (mit Seaborn erstellt):
 import seaborn as sns
 import matplotlib.pyplot as plt
 
 df = sns.load_dataset(&quot;tips&quot;)
 sns.boxplot(data=df, x=&quot;day&quot;, y=&quot;tip&quot;, hue=&quot;day&quot;, legend=False)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot.svg|400px]]

Beispiel (mit Matplotlib erstellt):

 import matplotlib.pyplot as plt
 
 daten = [12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25]
 
 plt.boxplot(daten, patch_artist=True)
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot2.svg|300px]]

Um mehrere Box-Plots unterschiedlicher Farbe mit Matplotlib in einem Diagramm zu zeichnen, können Sie folgendermaßen vorgehen:

 import matplotlib.pyplot as plt
 
 daten = [[12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25],
          [10, 19, 20, 21, 20, 30, 19, 40, 11, 17, 19, 21]]
 
 farben = [&quot;green&quot;, &quot;blue&quot;]
 
 boxplot = plt.boxplot(daten, patch_artist=True)
 
 for patch, farbe in zip(boxplot['boxes'], farben):
     patch.set_facecolor(farbe)
 
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

== Regressionsrechnung ==
Beispiel:
 import numpy as np
 import matplotlib.pyplot as plt
 
 # Messpunkte
 x = np.array([1, 3, 5, 6, 8, 10, 20])
 y = np.array([3, 4, 5, 5, 7, 9, 11])
 
 # Regressionskurve (Grad 1 = lineare Regression, 2 = Polynom-Regression 2. Gr.)
 # y = kx + d
 k, d = np.polyfit(x, y, deg=1)
 # y = ax**2 + bx + c
 a, b, c = np.polyfit(x, y, deg=2)
 
 x_l = np.linspace(1, 20, 100)
 y_p = a * x_l**2 + b * x_l + c
 
 # Zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.plot(x, k*x + d, color='blue', label='Regressionsgerade')
 plt.plot(x_l, y_p, color='red', label='Regressionspolynom 2. Gr.')
 plt.xlabel('x')
 plt.ylabel('y')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_regression.svg|400px]]

== Korrelationsrechnung ==
Beispiel:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 # Messdaten
 x = [1, 3, 4, 5, 6]
 y = [2, 4, 6, 8, 5]
 
 daten = {'X': x, 'Y': y}
 df = pd.DataFrame(daten)
 
 # Korrelation
 korr = df['X'].corr(df['Y'])
 print(f&quot;Korrelationskoeff.: {korr}&quot;) 
 
 # Messpunkte zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:
 Korrelationskoeff.: 0.7556096518348252

[[Datei:IngMath_korrelation.svg|300px]]

== Mengen und Venn-Diagramme ==
Beispiel: 
 import matplotlib.pyplot as plt
 from matplotlib_venn import venn2
 
 menge_a = {1, 2, 3, 4, 5, 6}
 menge_b = {4, 5, 6, 7, 8}
 
 vereinigung = menge_a | menge_b
 schnitt = menge_a &amp; menge_b
 print(&quot;Vereinigungsmenge = &quot;, vereinigung)
 print(&quot;Schnittmenge = &quot;, schnitt)
 
 venn2([menge_a, menge_b], set_labels=('Menge A', 'Menge B'))
 plt.show()

Ausgabe:
 Vereinigungsmenge =  {1, 2, 3, 4, 5, 6, 7, 8}
 Schnittmenge =  {4, 5, 6}

[[Datei:IngMath_venn.svg|300px]]

Siehe auch {{W|Mengendiagramm#Venn-Diagramme}}.

== Verteilungs- und Dichtefunktion ==
* CDF ... '''C'''umulative '''D'''istribution '''F'''unction, Verteilungsfunktion
* PDF ... '''P'''robability '''D'''ensity '''F'''unction, Dichtefunktion

Beispiel (Normalverteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 from scipy.stats import norm
 
 my, sigma = 0, 1
 x = np.linspace(-4, 4, 50)
 
 pdf = norm.pdf(x, my, sigma)
 cdf = norm.cdf(x, my, sigma)
 
 plt.plot(x, pdf, lw=2, label=&quot;Dichtefunktion&quot;)
 plt.plot(x, cdf, lw=2, label=&quot;Verteilungsfunktion&quot;)
 plt.legend()
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:IngMath_cdf_pdf.svg|300px]]

Beispiel (&lt;math&gt;\chi^2&lt;/math&gt;-Verteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 import scipy.stats as stats
 
 x = np.linspace(0, 20, 500)
 
 # df ... degree of freedom, Freiheitsgrad
 pdf = (stats.chi2.pdf(x, df=2), stats.chi2.pdf(x, df=5), stats.chi2.pdf(x, df=10))
 
 for i in range(0,3):
     if(i==0):
         lab = &quot;Freiheitsgrad 2&quot;
     elif(i==1):
         lab = &quot;Freiheitsgrad 5&quot;
     else:
         lab = &quot;Freiheitsgrad 10&quot;
 
     plt.plot(x, pdf[i], label=lab, lw=2)
 
 plt.grid()
 plt.legend()
 plt.show()

Ausgabe:

[[Datei:IngMath_chi2.svg | 300px]]

== Schätzen und Testen ==
=== Intervallschätzung ===
Als Beispiel seien Daten gegeben, die von ''Dürr, Mayer: Wahrscheinlichkeitsrechnung und Schließende Statistik; 7. Aufl., Hanser, 2014, Seite 137'' stammen. Und zwar soll das 95%-Vertrauensintervall für den Mittelwert des Kaloriengehalts (kcal/100g) von Hähnchen ermittelt werden. Wir wollen das mit Python inkl. NumPy und SciPy durchführen. Die Stichprobe ist groß (50 Hähnchen):

Python-Code:
 import numpy as np
 import scipy.stats as stats
 
 # Stichprobe
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203]
 
 # Parameter definieren
 konfidenzniveau = 0.95
 mean = np.mean(daten)
 std = np.std(daten, ddof=1)
 stdfehler = stats.sem(daten)
 
 intervall = stats.norm.interval(confidence=konfidenzniveau, loc=mean, scale=stdfehler)
 
 print(f&quot;Mittelwert: {mean}&quot;)
 print(f&quot;Standardabweichung: {std}&quot;)
 print(f&quot;Konfidenzintervall: {intervall}&quot;)

Ausgabe:
 Mittelwert: 215.48
 Standardabweichung: 33.14238915925757
 Konfidenzintervall: (np.float64(206.29356722321992), np.float64(224.66643277678006))

Diese Werte stimmen gerundet mit denen im genannten Buch überein. Zum Code selbst:
* sem steht für '''s'''tandard '''e'''rror of the '''m'''ean.
* &lt;code&gt;scipy.stats.norm&lt;/code&gt; ... Modul für die Normalverteilung.

=== Punktschätzung ===
Gleiche Daten wie oben bei der Intervallschätzung.

Python-Code:
 import numpy as np
 from scipy import stats
 
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203
         ]
 
 mu_hat, sigma_hat = stats.norm.fit(daten) 
 
 print(f&quot;Schätzer für den Erwartungswert (μ): {mu_hat:.4f}&quot;)
 print(f&quot;Schätzer für die Standardabweichung (σ): {sigma_hat:.4f}&quot;)

Ausgabe:
 Schätzer für den Erwartungswert (μ): 215.4800
 Schätzer für die Standardabweichung (σ): 32.8093

=== Hypothesentests ===
Beispiel:

 import numpy as np
 import scipy.stats as stats
 
 x_quer = 12.075      # Stichproben-Mittelwert
 var    = 0.069       # Stichproben-Varianz
 n      = 90          # Stichprobengröße
 my_0   = 12.0        # Nullhypothese
 alpha  = 0.05        # Signifikanzniveau
 
 z_stat = (x_quer - my_0) / np.sqrt(var / n)
 p_val = 2 * (1 - stats.norm.cdf(np.abs(z_stat)))
 
 print(f&quot;Z-Statistik: {z_stat:.4f}&quot;)
 
 if p_val &lt; alpha:
     print(f&quot;p-Wert: {p_val:.6f} &lt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird verworfen.&quot;)
 else:
     print(f&quot;p-Wert: {p_val:.6f} &gt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird nicht verworfen.&quot;)

Ausgabe:

 Z-Statistik: 2.7087
 p-Wert: 0.006755 &lt; alpha: 0.05
 Die Nullhypothese wird verworfen.

== Statistische Qualitätskontrolle ==
Beispiel (Mittelwertkarte):

 import numpy as np
 import matplotlib.pyplot as plt
 
 # Gegeben
 sollwert = 50.0
 varianz = 4.0
 stichproben_umfang = 1
 daten = [49.5, 50.2, 53.0, 48.1, 52.6, 53.4, 49.8]
 
 # Berechnung
 standardabweichung = np.sqrt(varianz)
 streuung = standardabweichung / np.sqrt(stichproben_umfang)
 
 cl = sollwert
 ucl = cl + 3 * streuung
 lcl = cl - 3 * streuung
 
 # Darstellung
 plt.plot(daten, marker='o', linestyle='-', color='b', label='Messdaten')
 plt.axhline(cl, color='green', linestyle='-', label=f'CL: {cl}')
 plt.axhline(ucl, color='red', linestyle='--', label=f'UCL: {ucl:.2f}')
 plt.axhline(lcl, color='red', linestyle='--', label=f'LCL: {lcl:.2f}')
 
 plt.title('Mittelwertkarte')
 plt.xlabel('Stichprobe')
 plt.ylabel('Wert')
 plt.legend(loc='lower left')
 plt.grid(True)
 plt.show()

Ausgabe:

[[Datei:IngMath_mittelwertkarte.svg|300px]]

Siehe auch {{W|Shewhart-Regelkarte}} und {{W|Qualitätsregelkarte}}.

* UCL ... '''U'''pper '''C'''ontrol '''Limit''', Obere Eingriffsgrenze
* LCL ... '''L'''ower '''C'''ontrol '''Limit''', Untere Eingriffsgrenze
* CL ... '''C'''enter '''L'''ine, Mittellinie

= Ein- und Ausgabe =
== print ==
Die Anweisung print haben wir schon oft verwendet. Hier soll anhand von Beispielen kurz beschrieben werden, was der Befehl print leisten kann.

 print(&quot;Hallo&quot;, &quot;Welt&quot;, 1, sep=&quot;-&quot;)
 print(&quot;Hallo&quot;, end=&quot; &quot;)
 print(&quot;Welt&quot;)

Ausgabe:
 Hallo-Welt-1
 Hallo Welt

== input ==
 a = int(input(&quot;Zahl 1: &quot;))
 b = int(input(&quot;Zahl 2: &quot;))
 
 print(&quot;a + b = &quot;, a+b)

Ausgabe (nach Eingabe der beiden Ganzzahlen):
 Zahl 1: 4
 Zahl 2: 5
 a + b =  9

== Aus Dateien lesen ==
Es seinen die datei.txt
 Hallo Welt.
 Wie geht es dir?
 ...

und test1.py
 dat = open(&quot;datei.txt&quot;, mode = &quot;r&quot;)
 print(dat.read())
 dat.close()

Ausgabe
 Hallo Welt.
 Wie geht es dir?
 ...

Mit dem open()-Befehl wird die Datei datei.txt im Lesemodus geöffnet (r ... read). Mit dem read()-Befehl wird die Datei eingelesen und mittels print ausgegeben.

== In Dateien schreiben ==
 dat = open(&quot;datei.txt&quot;, mode = &quot;a&quot;, encoding = &quot;utf-8&quot;)
 dat.write(&quot;Hänge Zeile an\n&quot;)
 dat.close()

Die Datei datei.txt sieht nach Abarbeitung des obigen Skripts nun so aus
 Hallo Welt.
 Wie geht es dir?
 ...
 Hänge Zeile an

Es wird die Datei im Schreibmodus geöffnet (a ... append (anhängend), w ... write (überschreibend)).
write() fügt hier also eine Zeile Text am Dateiende ein. close() schließt die Datei wieder.

Das close() kann man sich mit der with-Anweisung auch sparen.

 with open(&quot;datei.txt&quot;, mode=&quot;a&quot;, encoding=&quot;utf-8&quot;) as dat:
     dat.write(&quot;Hänge Zeile an\n&quot;)

= Benutzeroberflächen erstellen =
== tkinter ==
{{Wikipedia | Tkinter}}

Python bietet standardmäßig das Modul tkinter zur Programmierung von Benutzeroberflächen. Es müssen also bei der Verwendung von tkinter keine externen Module installiert werden. Hier wird eine (sehr) kurze Einführung in das Erstellen von grafischen Oberflächen mittels tkinter gegeben.

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 win.minsize(300, 50)
 but = tk.Button(win, text = &quot;Push the button&quot;)
 but.pack()
 win.mainloop()

Ausgabe:

[[Datei:PythonIng_gui1.jpg]]

Ein etwas komplizierteres Beispiel sei nachfolgend gezeigt. Es sollen zwei Strings miteinander verknüpft und ausgegeben werden. 

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 
 def on_button_clicked():
     str = ent1.get() + ent2.get()
     lab2[&quot;text&quot;] = str
  
 ent1 = tk.Entry(win)
 ent2 = tk.Entry(win)
 lab1 = tk.Label(win, text=&quot;verknuepfen mit&quot;)
 lab2 = tk.Label(win, text=&quot;&quot;) 
 but = tk.Button(win, text = &quot;=&quot;, command=on_button_clicked)
 
 ent1.pack(side=&quot;left&quot;)
 lab1.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 but.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 lab2.pack(side=&quot;left&quot;)
 
 win.mainloop()

Ausgabe  (vor der Eingabe der Teilstrings): 

[[Datei:PythonIng_gui2.jpg]]

Ausgabe (nach der Eingabe der Teilstrings und dem Drücken des =-Buttons): 

[[Datei:PythonIng_gui3.jpg]]

== curses ==
{{Wikipedia | curses}}

Mit dem curses-Modul lassen sich u.a. TUIs ('''T'''ext '''U'''ser '''I'''nterfaces) erstellen. Ein sehr einfaches Beispiel zur allgemeinen Funktionsweise wird nachstehend geliefert.
 
 import curses
 
 stdscr = curses.initscr()
 curses.start_color()
 curses.init_pair(1, curses.COLOR_RED, curses.COLOR_WHITE)
 stdscr.clear()
 
 stdscr.addstr(&quot;Hallo Welt&quot;, curses.color_pair(1))
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()
 
Als Ausgabe sollte &lt;span style=&quot;color:#FF0000;&quot;&gt;Hallo Welt&lt;/span&gt; (rote Schrift auf weißem Hintergrund) auf dem Terminal/der Konsole erscheinen. Getestet wurde dies mit openSUSE Tumbleweed, Python-Version 3.13.12. Das entsprechende Python-curses-Package muss installiert sein.

Allgemeine Informationen zur Terminal-/Konsolengröße und Cursorposition liefert folgendes Programm:
 
 import curses
 
 stdscr = curses.initscr()
 
 stdscr.addstr(3, 5, &quot;LINES: %d&quot; % curses.LINES)
 stdscr.addstr(4, 5, &quot;COLS:  %d&quot; % curses.COLS)
 
 (y,x) = stdscr.getyx()
 stdscr.addstr(5, 5, &quot;Momentane Cursorposition:  [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getbegyx()
 stdscr.addstr(6, 5, &quot;Koordinatenursprung:       [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getmaxyx()
 stdscr.addstr(7, 5, &quot;Fenstergröße:              [%d, %d]&quot; % (y, x))
 
 stdscr.addstr(11, 2, &quot;Taste drücken -&gt; Ende&quot;)
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()

Es sollte sich in etwa folgende Ausgabe ergeben:

     LINES: 44
     COLS:  110
     Momentane Cursorposition:  [4, 15]
     Koordinatenursprung:       [0, 0]
     Fenstergröße:              [44, 110]
 
 
 Taste drücken -&gt; Ende

Zur Funktionsweise von curses siehe auch das Wikibook [[ncurses]]. Zum Verständnis sind dort allerdings elementare Kenntnisse in der Programmiersprache C erforderlich.

== Qt ==
{{Wikipedia | Qt (Bibliothek)}}

Auch für das Qt-Framework gibt es eine Anbindung an Python. Nachfolgend ein einfaches Beispiel.

 import sys
 from PySide6.QtWidgets import QApplication, QLabel
 
 app = QApplication(sys.argv)
 label = QLabel(&quot;Hallo Welt!&quot;)
 label.show()
 sys.exit(app.exec())

Ausgabe:

[[Datei:PythonIng_gui10.png]]

== Gtk ==
{{Wikipedia | GTK (Programmbibliothek)}}

Eine idente Ausgabe, wie oben für Qt gezeigt, erzeugt z.B. folgendes Gtk-Programm:

 import gi
 gi.require_version(&quot;Gtk&quot;, &quot;4.0&quot;)
 from gi.repository import Gtk
 
 def on_activate(app):
     win = Gtk.ApplicationWindow(application=app)
     lab = Gtk.Label(label=&quot;Hallo Welt!&quot;)
     win.set_child(lab)
     win.present()
 
 app = Gtk.Application()
 app.connect('activate', on_activate)
 app.run(None)

Auch für die Benutzung von Qt und Gtk müssen die jeweiligen Packages installiert sein. Getestet wurden die entsprechenden Python-Programme nur unter openSUSE Tumbleweed. Wie das GTK-Paket unter MS Windows 11 installiert wird, siehe z.B. [https://www.gtk.org/docs/installations/windows Setting up GTK for Windows].

Damit sei aber das Thema &quot;Benutzeroberflächen erstellen&quot; hier abgeschlossen, da dies schon ein sehr spezielles Aufgabengebiet ist, das eher Informatiker und nicht so sehr Ingenieure anspricht. Bei Bedarf siehe aber ggf. die entsprechenden Links unten in diesem Tutorial. Dort sind weiterführende Informationen zu finden.

= Pandas kurz erklärt =
Hier wird kurz auf das externe Modul Pandas eingegangen. Pandas steht für '''Pan'''el '''Da'''ta und ist ein Modul für die Datenanalyse und -manipulation.

== Series ==
Vorstellbar ist eine &quot;Series&quot; wie eine einzelne Spalte in einem Tabellenkalkulationsprogramm.

Beispiel (Index implizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5]) # Temperaturwerte
 print(temp)

Ausgabe:
 0     8.5
 1    11.0
 2    12.5
 3    10.0
 4    13.0
 5    11.0
 6    14.5
 dtype: float64

Das Kürzel &lt;code&gt;pd&lt;/code&gt; ist Konvention. Es seien Temperaturwerte gegeben. Die erste Spalte bei der Ausgabe ist der Index. Die zweite Spalte enthält die Werte.

Beispiel (separater Zugriff auf den Index und auf die Werte):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5])
 print(temp.index)
 print(temp.values)

Ausgabe:
 RangeIndex(start=0, stop=7, step=1)
 [ 8.5 11.  12.5 10.  13.  11.  14.5]

Beispiel (Index explizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 print(&quot;*** Die gesamte Series ***&quot;)
 print(temp)
 
 print(&quot;*** Temperatur am Donnerstag ***&quot;)
 print(temp[&quot;Do&quot;])
 
 print(&quot;*** Tage wärmer als 12 Grad ***&quot;)
 temp_gr_12 = temp[temp &gt; 12]
 print(temp_gr_12)

Ausgabe:
 *** Die gesamte Series ***
 Mo     8.5
 Di    11.0
 Mi    12.5
 Do    10.0
 Fr    13.0
 Sa    11.0
 So    14.5
 dtype: float64
 *** Temperatur am Donnerstag ***
 10.0
 *** Tage wärmer als 12 Grad ***
 Mi    12.5
 Fr    13.0
 So    14.5
 dtype: float64

== DataFrame ==
Ein DataFrame entspricht einer Tabelle.

Beispiel (Erzeugen eines DataFrames):
 import pandas as pd
 
 tag   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 v1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=tag)
 v2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=tag)
 v3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=tag)
 
 tab = pd.concat([v1, v2, v3], axis=1)
 tab.columns = stadt
 
 print(tab)
 print(type(tab))

Ausgabe:
     Linz  Salzburg Innsbruck
 Mo     1         8     Hallo
 Di     2         9        16
 Mi     3        10        17
 Do     4        11        18
 Fr     5        12        19
 Sa     6        13        20
 So     7        14        21
 &lt;class 'pandas.core.frame.DataFrame'&gt;

Wir haben hier drei Datenspalten (v1, v2, v3) mit den Spaltennamen &quot;Linz&quot;, &quot;Salzburg&quot; und &quot;Innsbruck&quot;, sowie sieben Zeilen &quot;Mo&quot; bis &quot;So&quot;.

Beispiel (Zugriff auf eine Spalte):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab[&quot;Salzburg&quot;])

Ausgabe:
 Mo     8
 Di     9
 Mi    10
 Do    11
 Fr    12
 Sa    13
 So    14
 Name: Salzburg, dtype: int64

Beispiel (Zugriff auf eine Zeile):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab.loc[&quot;Di&quot;])

Ausgabe:
 Linz          2
 Salzburg      9
 Innsbruck    16
 Name: Di, dtype: object

== Grafiken erstellen ==
Hier sei nur ein Torten- oder Kreisdiagramm gezeichnet:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 expl = [0, 0.2, 0, 0, 0, 0, 0]
 temp.plot.pie(figsize=(5,5), explode=expl)
 plt.show()

Ausgabe:

[[Datei:IngPython_pandas1.svg|350px]]

Die &lt;code&gt;figsize&lt;/code&gt; hat nichts mit der Spaltenanzahl zu tun, sondern setzt die Fenster- oder Diagrammgröße in Inches (Breite * Höhe).
 
Mit Pandas kann man auch noch andere Diagrammarten erstellen, z.B. Linien- oder Balkendiagramme. Dies wird hier aber nicht vorgeführt.

== Arbeiten mit CSV- und LibreOffice-Dateien ==
Gegeben sei eine CSV-Datei test1.csv:
 Mai;Juni;Juli
 12;17;45
 15;65;65
 16;32;23
 4;14;7
 23;17;Keine Daten verfügbar
 67;Keine Daten verfügbar;45
 15;24;12

Lesen von dieser CSV-Datei:
 import pandas as pd
 
 tab = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 print(tab)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Schreiben in eine CSV-Datei test2.csv:
 import pandas as pd
 
 val = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 val.to_csv(&quot;test2.csv&quot;, index=False)

Ausgabedatei:
 Mai,Juni,Juli
 12,17,45
 15,65,65
 16,32,23
 4,14,7
 23,17,Keine Daten verfügbar
 67,Keine Daten verfügbar,45
 15,24,12

Die Ausgabedatei ist beinahe gleich wie die Eingabedatei. Es werden aber Kommas statt Strichpunkten verwendet. Daher kommt auch der Name CSV ('''C'''omma '''S'''eparated '''V'''alue). Will man wieder Strichpunkte, so kann man dies über den Parameter &lt;code&gt;sep=&quot;;&quot;&lt;/code&gt; in der &lt;code&gt;to_csv&lt;/code&gt;-Funktion machen.

Um direkt von einer ODS-Datei (LibreOffice Calc, '''O'''pen '''D'''ocument '''S'''preadsheet) zu lesen muss das Modul odfpy extra installiert sein (per YaST, pip etc.). Gelesen wird dann folgendermaßen:
 import pandas as pd
 
 df = pd.read_excel('test1.ods', engine='odf')
 print(df)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Die Datei &quot;test1.ods&quot; sei die Datei, aus der das obige &quot;test1.csv&quot; generiert wurde. Schreiben kann man ebenfalls in eine ODS-Datei:

 import pandas as pd
 
 daten = {
     &quot;Name&quot;: [&quot;Hugo&quot;, &quot;Richie&quot;, &quot;Wilhelmine&quot;],
     &quot;Alter&quot;: [38, 30, 29],
     &quot;Ort&quot;: [&quot;Linz&quot;, &quot;Innsbruck&quot;, &quot;Salzburg&quot;]
 }
 
 tab = pd.DataFrame(daten)
 
 with pd.ExcelWriter(&quot;test2.ods&quot;, engine=&quot;odf&quot;) as writer:
     tab.to_excel(writer, sheet_name=&quot;Daten&quot;, index=False)

Es ergibt sich eine &quot;test2.ods&quot;-Datei (Screenshot):

[[Datei:IngPython_pandas2.png|250px]]

== Sonstiges ==
Hier seien stichpunktartig einige weitere Features von Pandas angeführt:
* {{W|Pivot-Tabelle|Pivot-Tabellen}} (pivot ... Dreh-, Angelpunkt): Zweck - große Datenmengen schnell zusammenfassen, filtern und analysieren.
* NaN ('''n'''ot '''a''' '''n'''umber): In einem Datensatz fehlt ein Wert oder ist nicht definiert.
* groupby-Funktion: Daten strukturieren, aggregieren oder Zwischensummen bilden. 
* {{W|Binning#Datenverarbeitung_und_-analyse|Binning}}: Klassenbildung.
* Mehrstufige Indizierung (Hierarchical Indexing oder MultiIndex)
* Zeitreihen (Time Series)

Für tiefergehende und weiterführende Informationen wird auf das Buch von ''Klein: Numerisches Python; Hanser, 2023'' und [https://pandas.pydata.org/ pandas] verwiesen.

= Style Guide, flake8, pylint, Black etc. =
== Style Guide ==
Wie man schönen und richtigen Python-Code schreibt, erfahren Sie in
* [https://peps.python.org/pep-0008/ PEP 8 – Style Guide for Python Code]

== Formatter und Linter ==
Ein Modul, das prüft, ob die Richtlinien im Style Guide eingehalten wurden, ist ''flake8'':
* [https://flake8.pycqa.org/en/latest/ Flake8: Your Tool For Style Guide Enforcement]

Code formatieren kann man auch mit [https://pypi.org/project/black/ Black]. Z.B. übersetzt &lt;code&gt;black test1.py&lt;/code&gt; die Datei &lt;code&gt;test1.py&lt;/code&gt;

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)),
     (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

in 

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)), (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Die Programmausgabe ist 

 reformatted test1.py
 
 All done! ✨ 🍰 ✨
 1 file reformatted.

Der Unterschied zwischen Black und Flake8:
* Black ist ein Code-Formatter. Er formatiert Ihren Code um, sodass er im Einklang mit PEP 8 steht.
* Flake8 ist ein {{W|Lint (Programmierwerkzeug) | Code-Linter}}. Flake8 verändert Ihren Code nicht, sondern durchsucht ihn nach potenziellen Fehlern etc.

Am obigen Beispiel sieht man auch, dass flake8 und Black nicht immer einer Meinung sind. Flake8 (&lt;code&gt;flake8 test1.py&lt;/code&gt;) würde standardmäßig den mit Black formatierten Code bemängeln:

 test1.py:8:80: E501 line too long (80 &gt; 79 characters)

Diese Diskrepanz kann beseitigt werden. Da 79 Zeichen auf modernen Bildschirmen meist als zu kurz empfunden werden, ist ein Limit von 88 Zeichen (Black-Standard) oder mehr empfehlenswert. Um dies zu implementieren, erstellen Sie in Ihrem Projektverzeichnis eine &lt;code&gt;.flake8&lt;/code&gt;-Datei mit dem Inhalt

 [flake8]
 max-line-length = 88

Und schon ignoriert Flake8 dieses Problem.

Ein anderer Linter ist pylint. Der würde beim Abarbeiten des obigen Beispiels, z.B. mit &lt;code&gt;pylint test1.py&lt;/code&gt; noch eine Kleinigkeit bemängeln:

 ************* Module test1
 /home/hr/tmp/test1.py:1:0: C0114: Missing module docstring (missing-module-docstring)
 
 ------------------------------------------------------------------
 Your code has been rated at 8.57/10 (previous run: 8.57/10, +0.00)

Auch pylint muss vor der ersten Verwendung installiert werden (z.B. mittels pip, virtuelle Umgebung, YaST). Die Dokumentation zu pylint findet sich auf [https://pylint.readthedocs.io/en/latest/].

&lt;u&gt;Aufgabe:&lt;/u&gt; Fügen Sie einen &quot;module docstring&quot; in die &lt;code&gt;test1.py&lt;/code&gt;-Datei ein und testen Sie erneut mit flake8, Black und pylint. &lt;small&gt;Sehen Sie zum Thema docstrings auch [https://peps.python.org/pep-0257/#what-is-a-docstring PEP 257 – Docstring Conventions].&lt;/small&gt;

Es gibt noch weitere Formatierungswerkzeuge für Python-Code. Z.B. [https://docs.astral.sh/ruff/ Ruff], ein moderner Code-Formatter und -Linter. Mittels &lt;code&gt;ruff check test1.py&lt;/code&gt; würde obiger Code geprüft (Linter). &lt;code&gt;ruff format test1.py&lt;/code&gt; formatiert den Code (Formatter).

== Type Checker ==
&quot;Type Checker&quot; sind z.B.
* mypy
* pyright
* ty

Diese prüfen die Datentypen, z.B. in folgendem Code

 def greetings(name: str) -&gt; str:
     return &quot;Hello, %s&quot; % name
 
 
 print(greetings(42))

Python selbst, flake8, ruff oder black würden diesen Code ohne zu murren akzeptieren. &quot;Type Checker&quot; würden aber sehr wohl Alarm schlagen, z.B. liefert &lt;code&gt;mypy&lt;/code&gt; folgende Ausgabe

 test1.py:5: error: Argument 1 to &quot;greetings&quot; has incompatible type &quot;int&quot;; expected &quot;str&quot;  [arg-type]
 Found 1 error in 1 file (checked 1 source file)

Das funktioniert übrigens nicht nur bei Funktionsannotationen, sondern auch mit Variablen etc.

 from typing import Final
 
 # &quot;Konstante&quot;, ab Python 3.8
 NUMBER: Final = 123
 print(NUMBER)
 NUMBER = 125
 print(NUMBER)
 
 # Variable
 a: int = 345
 print(a)
 a = &quot;Irgendwas&quot;
 print(a)
 
 # Variable (Pipe-Symbol), ab Python 3.10
 b : int|str = 567
 print(b)
 b = &quot;sonstiges&quot;
 print(b)

Ausgabe mit python:
 123
 125
 345
 Irgendwas
 567
 sonstiges

Ausgabe mit mypy:
 test3.py:6: error: Cannot assign to final name &quot;NUMBER&quot;  [misc]
 test3.py:12: error: Incompatible types in assignment (expression has type &quot;str&quot;, variable has type &quot;int&quot;)  [assignment]
 Found 2 errors in 1 file (checked 1 source file)

Python kennt übrigens keine Konstanten. Man kann diese mittels Großbuchstaben andeuten. Das ist aber nur Konvention, hat aber keine sonstigen Auswirkungen. Oder man verwendet wie oben gezeigt &lt;code&gt;Final&lt;/code&gt;. Dann werfen Typchecker Errors aus.

==pydoc==
pydoc ist ein Werkzeug, um Python-Module, -Funktionen und -Klassen zu dokumentieren.

Beispiel &lt;code&gt;test1.py&lt;/code&gt;:
 &quot;&quot;&quot;Rechen-Modul.
 
 Funktionen die von pydoc gelesen werden.
 &quot;&quot;&quot;
 
 def multiply(a, b):
     &quot;&quot;&quot;Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
     
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a * b
     
 def add(a, b):
     &quot;&quot;&quot;Addiert zwei Zahlen und gibt das Ergebnis zurück.
    
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a + b
    
 
 if __name__ == '__main__':
     print(multiply(3, 5))
     print(add(4, 6))

Ausgabe mit &lt;code&gt;python3.13 -m pydoc test1&lt;/code&gt; auf der Konsole:

 Help on module test1:
 
 NAME
     test1 - Rechen-Modul. 
 
 DESCRIPTION
     Funktionen die von pydoc gelesen werden.
 
 FUNCTIONS
     add(a, b)
         Addiert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
     multiply(a, b)
         Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
 FILE
     /home/xyz/tmp/test1.py

Siehe zu diesem Thema z.B. auch [https://docs.python.org/3/library/pydoc.html]. Mittels &lt;code&gt;python3.13 -m pydoc -w test1&lt;/code&gt; kann man auch eine HTML-Dokumentation erstellen.

Wofür &lt;code&gt;if __name__ == '__main__':&lt;/code&gt; steht, siehe z.B. etwas später im Abschnitt [[Ing_Mathematik:_Python#Doctests]].

== Sonstige Tools ==
Andere Tools für die {{W|Statische Code-Analyse|statische Codeanalyse}}, die aber für Ingenieure weniger interessant sein dürften, sind z.B.
* Radon: Liefert verschiedene {{W|Softwaremetrik|Codemetriken}} (Komplexität, Wartbarkeitsindex ...)
* Bandit: Findet Sicherheitslücken

Tools für die {{W|Dynamisches Software-Testverfahren|dynamische Codeanalyse}}, z.B.:
* DynaPyt (Framework zur dynamischen Programmanalyse)
* cProfile (Profiler)
* Memory Profiler (Speicheranalyse)
* Memray (Speicheranalyse)
* tracemalloc (Speicheranalyse)

Paket- und Projektmanagement (pip-Ersatz etc.):
* uv
* Poetry
* Conda
* pipx

Packaging-Tools (Freezer) und {{W|Compiler#Sonderformen|Transpiler}} :
* pyinstaller
** erstellt eigenständige, ausführbare Binärdatei
** kein Cross-Compiler
** kein Schutz vor Reverse-Engineering
** langsam
** packt alles in eine Datei
** sehr große Datei
** Befehl, z.B.: &lt;code&gt;pyinstaller --onefile test1.py&lt;/code&gt;
** GUI: &lt;code&gt;auto-py-to-exe&lt;/code&gt;
* cx_Freeze
* nuitka
** Übersetzt Python-Code in C/C++-Code und weiter in eine ausführbare Datei
** kein Cross-Compiler
** Schutz vor Reverse-Engineering
** Befehl, z.B.: &lt;code&gt;nuitka --standalone --onefile test1.py&lt;/code&gt;
* cython

= Einige Integrierte Entwicklungsumgebungen (IDEs)=
Werden Programmtexte größer und umfangreicher, so ist das Arbeiten mit der interaktiven Programmierumgebung bzw. das direkte Ausführen von Python-Skripten mühsam. Man wünscht sich z.B. Hilfen zum Debuggen oder die automatische Code-Vervollständigung. Zu diesem Zweck wurden IDEs (Integrated Development Environments) geschaffen. Von diesen seinen nachfolgend auszugsweise einige kurz beschrieben. Testen Sie einfach aus, welche davon für Sie bzw. für Ihr Python-Projekt geeignet sind.

== IDLE ==
IDLE ist die mit dem Python-Programmpaket mitgelieferte IDE. Der Name leitet sich einerseits ab vom Monty-Python-Mitglied Eric Idle, andererseits steht es als Abkürzung für &quot;'''I'''ntegrated '''D'''evelopment and '''L'''earning '''E'''nvironment. IDLE ist einfach zu bedienen, bietet aber schon einen beachtlichen Leistungsumfang. Nachfolgend wird ein Screenshot zu IDLE geliefert. Rechts ist das Editor-Fenster zu sehen, links die interaktive Programmierumgebung. Um das Beispiel selbst nachvollziehen zu können, starten Sie IDLE. Das geht ähnlich, wie Sie die interaktive Programmierumgebung von Python starten (nur, dass Sie eben das IDLE-Icon doppelklicken und nicht das Python-Icon. Unter Linux geben Sie einfach in einem Terminal &lt;code&gt;idle3.13&lt;/code&gt; o. Ä. ein). Weiter geht es mit &quot;File - Open - ...&quot;. Die auszuführende Datei auswählen (im konkreten Fall ein &quot;Hallo-Welt&quot;-Programm). Es erscheint das rechte Fenster. Dort &quot;Run - Run Module&quot; auswählen. Und schon wird im linken Fenster &quot;Hallo Welt!&quot; ausgegeben.

[[Datei:PythonIng_idle1.jpg | 600px]]

Siehe auch {{W|IDLE}}.

== PyCharm ==
PyCharm ist ein kommerzielles Produkt. Es gab aber auch eine kostenlose Community Edition. Seit 2025 sind beide Varianten vereint. Für die ersten 30 Tage sind die Pro-Funktionen frei verfügbar, danach nur noch die Kernfunktionalitäten (oder man bezieht kostenpflichtig  die Pro-Version). Zu beziehen ist PyCharm unter dem Weblink [https://www.jetbrains.com/pycharm/]. Nachfolgend ein etwas abgewandeltes &quot;Hallo Welt&quot;-Programm, editiert und ausgeführt mit PyCharm.

[[Datei:PyCharm_IDE_2023_screenshot.png | 600px]]

Siehe auch {{W|PyCharm}}.

== Eric ==
Auch eric ist Open Source und steht unter der  GNU General Public License Version 3 oder später. Zu beziehen ist diese Software unter [https://eric-ide.python-projects.org/].

[[Datei:Screenshot_Eric_4.png | 600px]]

Siehe auch {{W|eric (Software)}}.

&lt;small&gt;
Unter openSUSE Tumbleweed sollte sich eric auch mit YaST installieren lassen. Bei mir gibt es aber dann beim Ausführen des eric-Programms eine Fehlermeldung (Stand März 2026): 
 
 ...
 ModuleNotFoundError: No module named 'PyQt6.QtPdfWidgets'

Umgehen kann man dieses Problem aber wieder mit dem Erstellen einer virtuellen Umgebung, in etwa so

 python3.13 -m venv ~/tmp/venv1
 cd ~/tmp/venv1/bin
 ./python3.13 -m pip install --upgrade --prefer-binary eric-ide
 ./eric7_ide
&lt;/small&gt;

== PyScripter ==
Vom Funktionsumfang vergleichbar mit den vorherigen IDEs ist PyScripter. Auch PyScripter ist Open Source. Die Projekt-Homepage findet sich auf [https://sourceforge.net/projects/pyscripter/]. PyScripter ist nur für MS Windows verfügbar.

[[Datei:PythonIng_pyscripter1.jpg | 600px]]

== Spyder IDE ==
Spyder enthält bereits eine stabile Python-Version und etliche Module (z.B. matplotlib, numpy, control). Ansonsten kann dieses Softwarepaket vom Funktionsumfang her mit den anderen genannten IDEs locker mithalten. Spyder wurde unter der MIT-Lizenz veröffentlicht. Diese Software findet sich auf [https://www.spyder-ide.org].

[[Datei:Spyder-windows-screenshot.png | 600px]]

Siehe auch {{W|Spyder (Software)}}

== Eclipse IDE==
Die {{W|Eclipse_(IDE)|Eclipse-IDE}} kann für Python aufgerüstet werden. Dazu gibt es das PyDev-Plugin. Installiert wird es über 
* Help &gt; Eclipse Marketplace... 
* Find - PyDev - Install
Danach muss noch der Pfad zum Python-Interpreter festgelegt werden 
* Window &gt; Preferences &gt; PyDev &gt; Interpreters &gt; Python Interpreter &gt; New ... 
Das Ergebnis ist ähnlich wie im folgenden Bild, nur dass statt C/C++ Python Verwendung findet. 

[[Datei:Setting Up Eclipse CDT helloout.png | 600px]]

== Sonstige ==
Die genannten IDEs sind nicht die Einzigen. Es gibt, um dem Image Pythons als beliebteste Programmiersprache gerecht zu werden, noch einige andere. Sowohl Open Source-Programme als auch kommerzielle Programme sind im Web zu finden, z.B. Thonny oder {{W|Visual Studio Code}}. Unter Linux kann man auch {{W|KDevelop}}, ausgestattet mit dem Python3-Plugin, einsetzen. Braucht man den Umfang von ausgewachsenen IDEs nicht, so kann man auch normale Texteditoren verwenden (z.B. {{W|Geany}} oder {{W|Kate_(Texteditor)|Kate}}).

= Debuggen und Testen =
Das Debuggen und Testen von Programmen sind wichtige Bestandteile der Programmierung. Syntaxfehler lassen sich i.A. leicht beheben. Schwieriger ist das Eingrenzen von logischen Fehlern, die ev. nur in bestimmten Situationen auftreten und keine explizite Fehlermeldung hervorrufen. Das Programm liefert falsche Ergebnisse oder es stürzt aus heiterem Himmel ab. Um das zu verhindern gibt es verschiedene Werkzeuge, die bei der Fehlersuche behilflich sein können. Vorerst siehe aber zwecks Begriffsklärung noch folgende Links: 
 
* {{W|Debuggen}}
* {{W|Debugger}}
* {{W|Softwaretest}}

&lt;gallery&gt;
First Computer Bug, 1947.jpg
Test ganzheitlich.png
V-Modell.svg
&lt;/gallery&gt;

== Das Modul pdb ==
Python bringt schon ein Modul zum Debuggen mit. Siehe z.B. [https://docs.python.org/3/library/pdb.html pdb — The Python Debugger].
Komfortabler lässt sich das aber mittels Integrierter Entwicklungsumgebungen (IDEs) angehen.

== Debuggen mit IDEs ==
Für die IDEs IDLE und Spyder sei kurz auf die entsprechenden Webseiten verwiesen:

* [https://www.cs.uky.edu/~keen/help/debug-tutorial/debug.html Debugging under IDLE].
* [https://docs.spyder-ide.org/current/panes/debugging.html Spyder Debugger]

Dort wird die Vorgehensweise auch mittels Screenshots erläutert.

== assert ==
assert ... behaupten, zusichern ({{W|Assertion (Informatik)}})

Python-Code:
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10., 0.)

Ausgabe:

 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10., 0.)
   File &quot;/home/hr/Develop/test1.py&quot;, line 4, in print1
     assert y != 0.0
            ^^^^^^^^
 AssertionError
 
Python-Code: 
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)
 
Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(&quot;10.&quot;, &quot;5.&quot;)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError
 
Aber auch bei nachfolgendem Code gibt es eine Fehlermeldung:

 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10, 5)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError

Damit letzteres funktioniert, kann man den Programmcode so umschreiben:
 def print1(x, y):
     assert type(x) == float or type(x) == int
     assert type(y) == float or type(y) == int
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 2.0
 
Und jetzt fangen wir den &lt;code&gt;AssertionError&lt;/code&gt; auf:
 def print1(x, y):
     try:
         assert type(x) == float or type(x) == int
         assert type(y) == float or type(y) == int
         assert y != 0.0
         print(x/y)
     except(AssertionError):
         print(&quot;Hallo&quot;)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)

Ausgabe:
 2.0
 Hallo

Ich hoffe, es ist wenigstens im Ansatz klar geworden, wofür &lt;code&gt;assert&lt;/code&gt; gut sein kann. Ausschalten kann man die &lt;code&gt;assert&lt;/code&gt;-Überprüfung übrigens mit dem Python-Schalter &lt;code&gt;-O&lt;/code&gt;.

== Doctests == 
Innerhalb eines Docstrings kann die Arbeit im interaktiven Modus simuliert werden. Nach den Promptzeichen (&gt;&gt;&gt;) erfolgen dann bei unserem Beispiel innerhalb des Docstrings simulierte Aufrufe der Funktion &lt;code&gt;print1()&lt;/code&gt;. Danach folgen jeweils die Sollresultate. Wird das Modul oder die Datei als Hauptprogramm aufgerufen, so wird die Funktion &lt;code&gt;doctest.testmode()&lt;/code&gt; aufgerufen und ein Bericht auf der Konsole ausgegeben. Wird das Modul nicht als Hauptprogramm aufgerufen, sondern importiert, dann wird diese &lt;code&gt;testmod&lt;/code&gt;-Funktion nicht aufgerufen. D.h. dieser Code kann sowohl für Testzwecke als auch für den produktiven Einsatz verwendet werden. Das ist auch sinnvoll, weil wenn man Teile der Datei immer löschen bzw. einfügen müsste, so würden sich Fehlerquellen auftun. Das würde den Sinn und Zweck von Doctests konterkarieren.  

 def print1(x=0., y=1.):
     &quot;&quot;&quot; Dividiere zwei Zahlen
     Autor: Intruder
     Datum: 12.08.2025
 
     &gt;&gt;&gt; print1(2., 1.)
     2.0
     &gt;&gt;&gt; print1(5., 2.)
     2.5
     &gt;&gt;&gt; print1(5.)
     5.0
     &quot;&quot;&quot;
     print(x/y)
 
 if __name__ == &quot;__main__&quot;:
     import doctest
     doctest.testmod(verbose=True)

Ausgabe:
 Trying:
     print1(2., 1.)
 Expecting:
     2.0
 ok
 Trying:
     print1(5., 2)
 Expecting:
     2.5
 ok
 Trying:
     print1(5.)
 Expecting:
     5.0
 ok
 1 items had no tests:
     __main__
 1 items passed all tests:
    3 tests in __main__.print1
 3 tests in 2 items.
 3 passed and 0 failed.
 Test passed.

Das gezeigte Beispiel ist so ziemlich das einfachste, das es gibt. Für weiterführende Details siehe z.B.:
* [https://peps.python.org/pep-0257/ PEP 257 – Docstring Conventions]
* [https://docs.python.org/3/library/doctest.html doctest — Test interactive Python examples]

''Einschub:'' Ganz ähnlich kann man auch Klassen testen, z.B. in folgendem Code-Fragment

 class Fahrzeug:
   # siehe Abschnitt &quot;Objektorientierte Programmierung&quot;
   # ...
 
 if __name__ == &quot;__main__&quot;:
   vauweh = Fahrzeug(170, 90)
   beemweh = Fahrzeug(200, 120)
   print(vauweh.convertGeschw())
   print(beemweh.convertGeschw())

Wird das Script als Hauptprogramm ausgeführt (z.B. zu Testzwecken), so erfolgt die Ausgabe der zwei, via &lt;code&gt;convertGeschw()&lt;/code&gt;, umgerechneten Geschwindigkeiten. Wird es aber als Modul eingebunden, so wird der letzte Programmabschnitt nicht ausgeführt (&lt;code&gt;__name__ == &quot;__main__&quot;&lt;/code&gt; ergibt &lt;code&gt;False&lt;/code&gt;).

== pytest ==
Siehe zu diesem Thema auch {{W|Modultest}}.

pytest ist ein externes Modul und muss vorab installiert werden, z.B. mittels 
 pip install -U pytest
 pip install -U pytest-html 

Python-Code, Datei test1.py:
 def add(x, y):
     return x + y
 
 def test_answer():
     assert add(1, 1) == 3

Starten von pytest in der Konsole:
 pytest test1.py
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py F                                                                                                            [100%]
 
 ========================================================= FAILURES ==========================================================
 ________________________________________________________ test_answer ________________________________________________________
 
     def test_answer():
 &gt;       assert add(1, 1) == 3
 E       assert 2 == 3
 E        +  where 2 = add(1, 1)
 
 test1.py:6: AssertionError
 ================================================== short test summary info ==================================================
 FAILED test1.py::test_answer - assert 2 == 3
 ===================================================== 1 failed in 0.09s =====================================================

Hier erhalten wir einen Fehler, da 1+1 eindeutig ungleich 3 ist. Aber aus irgendeinem Grund wollte der Programmierer oder Tester in diesem Fall, dass dies so ist. Testfälle werden übrigens mit dem Präfix &lt;code&gt;test_&lt;/code&gt; eingeleitet.

Python-Code:
 def add(x, y):
     return x + y + 1
 
 def test_answer():
     assert add(1, 1) == 3 
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py .                                                                                                            [100%]
 
 ===================================================== 1 passed in 0.01s =====================================================

Jetzt ist alles in Ordnung. Weiterführendes siehe z.B.

* [https://docs.pytest.org/en/stable/ pytest: helps you write better programs]

== unittest ==
Auch unittest dient zur Durchführung von Testreihen, ist aber Bestandteil von Python. Hier wird vorerst nicht näher darauf eingegangen. Siehe z.B. 
* [https://docs.python.org/3/library/unittest.html unittest — Unit testing framework]

Lt. ''Inden: Python Challenge; dpunkt, 2021, Seite 481''  soll unittest weniger komfortabel als pytest sein.

Einen Vergleich von unittest mit pytest findet man in
* [https://knapsackpro.com/testing_frameworks/difference_between/pytest/vs/unittest pytest vs unittest]

= Python und Anwendungsprogramme =
Bisher stand immer alleine die Programmiersprache Python (ev. unter Einbeziehung von Modulen) im Mittelpunkt der Betrachtungen. Aber Python kann auch als Makrosprache für Anwendungsprogramme auftreten. Als Beispiele seien {{W|FreeCAD}} und {{W|LibreOffice}} genannt.

== FreeCAD ==
FreeCAD ist ein freies 3D-CAD-Programm. Hier soll nicht auf die Bedienung dieses CAD-Pakets eingegangen werden, sondern nur auf die Möglichkeit, mittels Python Makros zu schreiben. Als einfacher Einstieg soll ein Makro erstellt werden, welches eine Kugel (rot) und einen Quader (blau) zeichnet. Folgende Vorbereitungsschritte sind erforderlich (es sei vorausgesetzt, dass FreeCAD schon am Rechner installiert ist. Downloaden können Sie das Programm von der Website [https://www.freecad.org/downloads.php?lang=en]):

* FreeCAD starten
* Leere Datei erstellen
* Makro &gt; Makros &gt; Erstellen ...

Es öffnet sich ein leeres Editorfenster, in das Sie folgenden Code eingeben können:

 import FreeCAD
 import Part
 
 doc = FreeCAD.newDocument()
 
 # Kugel
 kugel = Part.makeSphere(10)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Kugel&quot;)
 form_element.Shape = kugel
 kug = FreeCAD.ActiveDocument.getObject(&quot;Kugel&quot;)
 kug.ViewObject.ShapeColor = (1.0, 0.0, 0.0)
 neuePosition = App.Vector(5, 2.5, 2.5)
 kug.Placement = App.Placement(neuePosition, kug.Placement.Rotation)
 
 # Quader
 quader = Part.makeBox(5, 5, 50)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Quader&quot;)
 form_element.Shape = quader
 quad = FreeCAD.ActiveDocument.getObject(&quot;Quader&quot;)
 quad.ViewObject.ShapeColor = (0.0, 0.0, 1.0)
 
 doc.recompute()

Diesen Code können Sie nun ausführen:
* Makro &gt; Makro ausführen

Es ergibt sich folgende Ausgabe (gedreht und gezoomt):

[[Datei: PythonIng_freecad1.png|500px]]

Siehe auch [https://wiki.freecad.org/Python_scripting_tutorial/de# Anleitung Skripterstellung mit Python]. Getestet wurde obiges Beispiel mit FreeCAD 1.1.3 unter Linux und 1.1.1 unter MS Windows.

== LibreOffice ==
LibreOffice ist ein freies Officepaket ([https://de.libreoffice.org/]). Hier soll nur das Tabellenkalkulationsprogramm Calc kurz betrachtet werden. Es seinen in den ersten 3 Zellen (A1 bis A3) Zahlen gegeben. Diese sollen mit einem Python-Makro addiert und das Resultat in der Zelle A5 ausgegeben werden. Auch hier sind Vorbereitungsarbeiten nötig: 
* zuerst muss unter Linux das Verzeichnis &lt;code&gt;~/.config/libreoffice/4/user/Scripts/python&lt;/code&gt; erstellt werden
* für MS Windows ist es das Verzeichnis &lt;code&gt;%APPDATA%\LibreOffice\4\user\Scripts\python&lt;/code&gt; 
** drücken Sie zuerst Win + R (es öffnet sich das Ausführen-Fenster)
** geben Sie &lt;code&gt;%appdata%&lt;/code&gt; ein, danach drücken Sie Enter (es öffnet sich der Explorer)
** navigieren Sie zu dem genannten Verzeichnis bzw. erstellen Sie das Verzeichnis 
* in diesem Verzeichnis wird dann mit einem beliebigen Texteditor das Python-Makro erstellt, in unserem Fall die Datei &lt;code&gt;summiere_zellen.py&lt;/code&gt;:

 import uno
 
 def summiere_zellen(*args):
     # Zugriff auf das aktuelle Dokument und das aktive Tabellenblatt
     ctx = uno.getComponentContext()
     smgr = ctx.getServiceManager()
     desktop = smgr.createInstanceWithContext(&quot;com.sun.star.frame.Desktop&quot;, ctx)
     doc = desktop.getCurrentComponent()
     sheet = doc.getCurrentController().getActiveSheet()
 
     # Werte aus den Zellen A1 bis A3 auslesen
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
 
     # Addition der drei Werte
     summe = w1 + w2 + w3
 
     # Ergebnis in die Zelle A5 schreiben
     sheet.getCellRangeByName(&quot;A5&quot;).Value = summe

* siehe dazu ggf. auch [https://help.libreoffice.org/latest/de/text/sbasic/python/python_locations.html?DbPAR=BASIC].

Weiter geht es in LibreOffice Calc mit dem Menü ''Extras &gt; Makros &gt; Makros verwalten &gt; Python''. Dort wird das Makro &lt;code&gt;summiere_zellen&lt;/code&gt; ausgeführt. Es ergibt sich z.B. folgendes Resultat

[[Datei:PythonIng_libreoffice1.png]]

Das Kürzel &lt;code&gt;uno&lt;/code&gt; steht für '''U'''niversal '''N'''etwork '''O'''bjects. Etwas einfacher geht's auch so:

 def summiere_zellen():
     desktop = XSCRIPTCONTEXT.getDesktop()
     model = desktop.getCurrentComponent()
     sheets = model.getSheets()
     sheet = sheets.getByIndex(0)
     
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
     
     cell = sheet.getCellRangeByName(&quot;A5&quot;)    
     cell.setValue(w1 + w2 + w3) 

Empfohlen wird auch, das Erweiterungspaket APSO ('''A'''lternative '''P'''ython '''S'''cript '''O'''rganizer, apso.oxt) zu installieren. Die Vorgehensweise wird hier nicht gezeigt, sondern nur darauf hingewiesen, dass man das einfach &quot;googeln&quot; kann. Siehe zur Python-Programmierung für LibreOffice auch [https://wiki.documentfoundation.org/Macros/Python_Guide/de Makros/Python-Handbuch]. Getestet wurden obige Beispiele mit LibreOffice 26.2.5.1 unter Linux und 26.2.1.2 unter MS Windows.

= Ausblick =
Dies war eine kurze Einführung in die Berechnungs- und Darstellungsmöglichkeiten mit Python. Es sollten etliche relevante Themen behandelt, oder zumindest kurz angesprochen worden sein. Wem dieser Text nicht ausreichend ist, der sei auf die entsprechenden weiterführenden Weblinks, Bücher und die Python-Hilfefunktion verwiesen. Python kennt noch viel mehr Befehle, als hier dargestellt wurden. Das Themenspektrum ist auch durch die Einbindung externer Module fast beliebig erweiterbar.

= Weblinks=
== Python allgemein ==
* [https://www.python.org/ Python Homepage]

== Externe mathematische Module ==
* [https://numpy.org/ NumPy]
* [https://numpy.org/doc/stable/user/numpy-for-matlab-users.html NumPy for MATLAB users]
* [https://scipy.org/ SciPy]
* [https://www.sympy.org/en/index.html SymPy]
* [https://pandas.pydata.org/ pandas]
* [https://github.com/maroba/findiff findiff]
* [https://mpmath.org/ mpmath]

== Externe Module für Grafiken ==
* [https://matplotlib.org/ Matplotlib]
* [https://vpython.org/ VPython]
* [https://build123d.readthedocs.io/en/latest/ build123d]
* [https://docs.vtk.org/en/latest/api/python.html VTK]
* [https://docs.bokeh.org/en/latest/docs/first_steps.html bokeh]
* [https://py5coding.org/ py5]

== Erstellung von User Interfaces ==
* [https://docs.python.org/3/library/tkinter.html tkinter - Python interface to Tcl/Tk]
* [https://docs.python.org/3/library/curses.html curses - Terminal handling for character-cell displays]
* [https://wiki.qt.io/Qt_for_Python Qt for Python]
* [https://www.gtk.org/docs/language-bindings/python GTK and Python]

== Erstellen virtueller Umgebungen ==
* [https://docs.python.org/3/library/venv.html venv - Creation of virtual environments]

== Sonstige ==
* [https://python-control.readthedocs.io/en/stable/ Python Control Systems Library]
* [https://pypi.org/project/regex/ regex - Regular Expressions]
* [http://pyromat.org/ PYroMat]
* [https://coolprop.org/coolprop/wrappers/Python/index.html CoolProp]
* [https://pypi.org/project/iapws/ iapws]
* [https://tespy.readthedocs.io/en/main/getting_started/introduction.html TESPy - Thermal Engineering Systems in Python]
* [https://pint.readthedocs.io/en/stable/ pint]

= Bücher =
== Gedruckte Bücher, OpenBooks, Magazine ==
* Diverse: c't Python Lernen, Verstehen, Anwenden; Heise, 2022 
* Ernesti, Kaiser: Python3 - das umfassende Handbuch; 5. Aufl., Rheinwerk, [https://openbook.rheinwerk-verlag.de/python/ OpenBook]
* Iacono et al.: Programmieren trainieren; 3. Aufl., Hanser, 2023, ISBN 978-3-446-47766-7
* Inden: Python Challenge; dpunkt, 2021, ISBN 978-3-86490-809-5
* Klein: Numerisches Python; 2. Aufl., Hanser, 2023, ISBN 978-3-446-47170-2 
* Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler; Rheinwerk, 2021, ISBN 978-3-8362-7316-9
* Weigend: Python 3 - Das umfassende Praxisbuch; 9. Aufl., mitp, 2022, ISBN 978-3-7475-0544-1
* Woyand: Python für Ingenieure und Naturwissenschaftler; 4. Aufl., Hanser, 2021, ISBN 978-3-446-46483-4

== Andere Wikibooks ==
* [[:en:Subject:Python_programming_language | Englische Wikibooks zum Thema Python]]
* [[Python|Deutschsprachiges Python-Wikibook]] [[Bild:2von10.png|20%]]
* [[Python unter Linux|Python 2.7 unter Linux]] [[Bild:10von10.png|100%]]


{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}</text>
      <sha1>kd4ppf5k6nqfj7zo67kbc91bh7bswp7</sha1>
    </revision>
    <revision>
      <id>1092171</id>
      <parentid>1092170</parentid>
      <timestamp>2026-10-16T18:07:58Z</timestamp>
      <contributor>
        <username>Intruder</username>
        <id>1513</id>
      </contributor>
      <comment>/* Statische Attribute, statische Methoden und Klassenmethoden */</comment>
      <origin>1092171</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="189404" sha1="pf4yh2yqaxdercmdubaae75686ygl8i" xml:space="preserve">{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}


= Hallo Welt und allgemeine Hinweise =
== Was ist Python ==
* Python ist eine universelle höhere Programmiersprache.
* Python ist objektorientiert.
* Python ist Open-Source (Python Software Foundation License).
* Python ist für viele Betriebssysteme erhältlich (z.B. für Linux, MS Windows, macOS).
* Python ist ein Interpreter.
* Python ist durch Module fast beliebig erweiterbar.
* Python als Programmiersprache ist case-sensitive - d.h. Groß- und Kleinschreibung ist relevant bei der Eingabe von Befehlen.
* Python ist in etlichen Anwendungsprogrammen (z.B. {{W|FreeCAD}}, {{W|LibreOffice}}, {{W|GIMP}}, {{W|Blender (Software) | Blender}}) als Makrosprache verwendbar.

{{Wikipedia | Python (Programmiersprache)}}

== Python installieren ==
=== MS Windows ===
Laden Sie das aktuelle Python-Paket von der Webseite [https://www.python.org/] herunter. Weiter geht es wie bei jedem anderen größeren zu installierenden Programm. Einfach das Installationsprogramm im Explorer doppelklicken und den Anweisungen des Setup-Programmes folgen.

=== Linux ===
Entweder ist Python bereits standardmäßig installiert, ansonsten ist die Installation mittels Paketmanagementsystem einfach möglich. Aber auch die Spyder-Entwicklungsumgebung ([https://www.spyder-ide.org]) bietet einen guten Einstieg mit Python (das gilt auch für MS Windows). Spyder bringt auch schon etliche wichtige Module standardmäßig mit.

== Python starten ==
=== MS Windows ===
Das Icon für das Python-Programm doppelklicken. Und schon startet das Programm.

[[Datei:PythonIng_start1.jpg]]

Python im interaktiven Modus (REPL ... '''R'''ead-'''E'''valuate-'''P'''rint-'''L'''oop) präsentiert sich dann so:

 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

Alternativ kann das Programm auch über die Eingabeaufforderung oder die PowerShell gestartet werden:

 c:\devel\Python&gt;python.exe
 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

=== Linux ===
Tippen Sie einfach das Wort „python“ (oder unter openSUSE Tumbleweed z.B. auch „python3.11“ oder „python3.13“) in einem Linux-Terminal ein, schließen den Befehl mit der RETURN-Taste ab, und schon startet Python im interaktiven Modus:
 
 Python 3.13.12 (main, Feb 09 2026, 22:37:44) [GCC] on linux
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt; 

Es gibt auch noch andere Möglichkeiten Python zwecks Programmausführung zu starten, z.&amp;nbsp;B. den {{W|Shebang}} (&lt;code&gt;#!&lt;/code&gt;) am Beginn eines Python-Scripts. Das Script sei als Script.py gespeichert. Dann kann das Script mit ./Script.py ausgeführt werden. Für openSUSE Tumbleweed sei nachfolgend ein lauffähiges &quot;Hallo Welt!&quot;-Script angegeben. Es wird in diesem Script der Python-Interpreter in der Version 3.13 verwendet :

 #!/usr/bin/python3.13
 print(&quot;Hallo Welt!&quot;)

Die Berechtigungen zum Ausführen der Datei müssen natürlich noch richtig gesetzt werden, z.B. mittels &lt;code&gt;chmod 777 Script.py&lt;/code&gt;. &lt;small&gt;&lt;code&gt;chmod&lt;/code&gt; ist die Abkürzung für&quot;'''ch'''ange file '''mod'''e bits&quot;.&lt;/small&gt; 

&lt;small&gt;Die &quot;Maske&quot; &lt;code&gt;777&lt;/code&gt; ist nur für Testzwecke sinnvoll, weil sie leicht zu merken ist und für alle Benutzer alle Zugriffsberechtigungen ('''r'''ead/'''w'''rite/e'''x'''ecute für owner/group/others) setzt. Im richtigen Einsatz wird man das aus Sicherheitsgründen nicht so handhaben, sondern nur die Berechtigungen setzen, die unbedingt erforderlich sind. Welche Zugriffsberechtigungen gesetzt sind, kann man z.B. mit dem Befehl &lt;code&gt;ls -l&lt;/code&gt; oder &lt;code&gt;ll&lt;/code&gt; ('''l'''i'''s'''t directory contents) erfragen. Aber dazu im Moment genug. Erfahrene Linux-Nutzer kennen das ohnehin und Anfänger sollen jetzt nicht mit Linux-Interna überfordert werden. Bei Bedarf siehe die Linux-Man-Pages oder dezidierte Bücher zu Linux.&lt;/code&gt;&lt;/small&gt;

&lt;small&gt;Oder das Script wird in einen Pfad verschoben, in dem sich ausführbare Programme generell befinden (welche Verzeichnisse im PATH liegen, kann bspw. mit &lt;code&gt;echo $PATH&lt;/code&gt; abgefragt werden). Das Script kann dann wie ein normales Programm ohne weitere Angaben mit Script.py gestartet werden. Alternativ wird nicht das Script an sich verschoben, sondern nur ein symbolischer Link angelegt, z.B. mit &lt;code&gt;ln -s ~/tmp/Script.py ~/.local/bin/Script.py&lt;/code&gt;. &lt;code&gt;~/.local/bin&lt;/code&gt; sei ein im PATH gelegenes Verzeichnis. Dies sind aber schon Features für fortgeschrittene Linux-Benutzer und werden am Anfang eher selten benötigt.&lt;/small&gt;

== Ein paar Worte zur Erklärung ==
=== Tests ===
Getestet wurden die Beispiele unter den Betriebssystemen 
* MS Windows 10 mit der Python-Version 3.12.0 (teilweise auch mit 3.12.2 und 3.13.1; nur die Inhalte die bis spätestens Juli 2025 erstellt wurden) 
* MS Windows 11 ab der Python-Version 3.13.4 (nur zum Teil; ab Juli 2025)
* openSUSE Leap 15.6 mit der Python-Version 3.11.12 (Spyder, nur vereinzelt) und zum Teil mit 3.12.11 (ab Juli 2025 bis November 2025).
* openSUSE Tumbleweed ab der Python-Version 3.13.9 (nur vereinzelt, ab November 2025)

=== Popularität ===
* An Beliebtheit rangiert Python mit Stand September 2026 mit einem Rating von 17,76% an 1. Stelle vor C und C++ (lt. [https://www.tiobe.com/tiobe-index/ TPCI - TIOBE Programming Community Index]). 
* Lt. [https://innovationgraph.github.com/global-metrics/programming-languages GitHub Top 50 Programming Languages Globally] lag Python im Q1/2026 auf Rang 2, vor TypeScript und hinter JavaScript. 
* [https://pypl.github.io/PYPL.html PYPL] (Popularity of Programming Language Index) ist ein anderer Popularitätsindex für Programmiersprachen. Auch hier liegt Python mit großem Vorsprung auf dem ersten Platz (52,08%), gefolgt von Java (13,34%) und C/C++ (7,99%) (Stand September 2026). 

=== Namensgebung ===
Der Name &quot;Python&quot; rührt von der Komikertruppe {{W|Monty Python}} her. Die Icons für Python (z.B. Python selbst, Eric IDE, IDLE) sind aber durch die Python-Schlangenart symbolisiert.

&lt;gallery&gt;
Python-logo-notext.svg|Python-Logo
Guido van Rossum in PyConUS24.jpg|{{W|Guido van Rossum}} (geb. 1956), der Erfinder von Python
&lt;/gallery&gt;

== Ein erstes Programm ==
Kommentare werden in Python mit der Raute (#) eingeleitet. Sie werden vom Python-Interpreter ignoriert. Text kann mit der print-Funktion ausgegeben werden. Starten Sie Python und geben sie folgende Anweisungen zeilenweise ein

 &gt;&gt;&gt; # Das ist ein Kommentar
 &gt;&gt;&gt; print(&quot;Hallo Welt!&quot;)

Als Ergebnis erhalten Sie

 Hallo Welt!

Der Prompt (&gt;&gt;&gt;) ist selbstverständlich nicht einzutippen, sondern wird vom Python-System geliefert.

Strings können in Python entweder in Anführungszeichen (&quot;) gesetzt werden oder in Hochkommatas('). In diesem Text wird die erste Variante bevorzugt eingesetzt.

Im Gegensatz zu Julia ist es hier egal, ob zwischen &lt;code&gt;print&lt;/code&gt; und der öffnenden Klammer Leerzeichen stehen.

= Python als Taschenrechner =
== Allgemeines ==
Wir wollen 3 * 5 berechnen. Dazu starten wir Python im interaktiven Modus. Geben Sie dann die Formel  

 &gt;&gt;&gt; 3 * 5

ein, drücken die Taste ENTER/RETURN ({{Taste|↵}}) und erhalten als Ergebnis

 15

Auch kompliziertere Ausdrücke sind möglich. Beispielsweise mit Winkelfunktionen, Quadratwurzeln etc. Wir wollen nun den Ausdruck &lt;math&gt;\sin\sqrt{15}&lt;/math&gt; berechnen :

 &gt;&gt;&gt; import math
 &gt;&gt;&gt; math.sin(math.sqrt(15))
 -0.6679052983383519

Als erstes wird das math-Modul importiert. Dann wird der mathematische Ausdruck berechnet.

Eine andere Variante, die dasselbe Ergebnis liefert, ist

 &gt;&gt;&gt; from math import *
 &gt;&gt;&gt; sin(sqrt(15))
 -0.6679052983383519

Es wird also aus dem Modul &lt;code&gt;math&lt;/code&gt; alles importiert (erkennbar am &lt;code&gt;*&lt;/code&gt;). Will man nicht alles importieren, so kann man das auch einschränken:

 &gt;&gt;&gt; from math import sin, sqrt

Beenden lässt sich das Python-Programm durch Eingabe von &lt;code&gt;exit()&lt;/code&gt; (und natürlich ist zur Bestätigung die RETURN-Taste zu drücken). &lt;code&gt;exit&lt;/code&gt; (ohne Klammern) oder &lt;code&gt;quit&lt;/code&gt; werden auch akzeptiert.

== Die Hilfefunktion von Python ==
Bei Eingabe der Anweisung &lt;code&gt;help&lt;/code&gt; oder &lt;code&gt;help()&lt;/code&gt; springt Python in den Hilfemodus. 

Eingabe:
 &gt;&gt;&gt; help()
 
Eingabe:
 help&gt; math.sin

Ausgabe:
 Help on built-in function sin in math:
 
 math.sin = sin(x, /)
     Return the sine of x (measured in radians).

Für die komplette Python-Dokumentation siehe [https://docs.python.org/3/]. Verlassen kann man den Hilfemodus durch das Drücken von STRG-C, bzw. der Eingabe von q, quit oder exit mit anschließendem Drücken der RETURN-Taste.

== Aufgaben ==
* Erkunden Sie die Tangensfunktion &quot;tan&quot; mittels Python-Hilfe (vergessen Sie nicht das math-Modul zu importieren und das &lt;code&gt;math.&lt;/code&gt; vor &lt;code&gt;tan&lt;/code&gt;)
* Berechnen Sie mit Python den Ausdruck &lt;math&gt;\frac{1}{2}\cdot \text{e}^2 \cdot \tan(\pi/3)&lt;/math&gt;. Siehe für die Exponentialfunktion im Python-Hilfesystem auch den Befehl &lt;code&gt;math.exp&lt;/code&gt;. Alternativ kann auch die Konstante &lt;code&gt;math.e&lt;/code&gt; eingesetzt werden. Potenzieren kann man bei Python mit dem **-Operator (z.B. 2**3 = 8). Für &lt;math&gt;\pi&lt;/math&gt; gibt es &lt;code&gt;math.pi&lt;/code&gt;.

= Python als Scriptsprache =
Häufig wird man aber kompliziertere Anweisungsfolgen verarbeiten müssen. Diese will man normalerweise nicht jedesmal neu eingeben, sondern in einer Datei speichern und diese Datei dann zur Ausführung bringen. Speichern Sie dazu folgenden Code in einer Textdatei, z.B. unter MS Windows als c:\tmp\test1.py

 # Das ist ein Kommentar
 print(&quot;Hallo Welt!&quot;)

Python-Dateien werden mit der Dateiendung .py versehen. Achten Sie darauf, dass vor dem print keine Leerzeichen vorhanden sind. Das ist eine Python-Eigenheit. Wie wir später sehen werden, nutzt Python Einrückungen als syntaktisches Mittel, z.B. um bei Schleifen den Schleifenkörper zu kennzeichnen. 

Danach bringen Sie die Skriptdatei test1.py (sozusagen das Hauptprogramm) folgendermaßen zur Ausführung:

1) Starten Sie unter MS Windows die Eingabeaufforderung (oder alternativ auch die Windows PowerShell). Das sieht dann etwa so aus:

 Microsoft Windows [Version 10.0.19045.3693]
 (c) Microsoft Corporation. Alle Rechte vorbehalten.
 
 C:\Users\xyz&gt;

: &lt;small&gt;Falls jemand nicht weiß, wie man die Eingabeaufforderung startet: Eine Möglichkeit ist, einfach in der Taskleiste von Windows das &quot;Start&quot;-Symbol &amp;nbsp;([[Image:Windows_logo_-_2021_(Black).svg|10px]])&amp;nbsp; mit der rechten Maustaste anklicken. &quot;Ausführen&quot; auswählen (oder alternativ für die PowerShell unter Windows 10 den Eintrag &quot;Windows PowerShell&quot;, unter Windows 11 den Eintrag &quot;Terminal&quot;). Im sich öffnenden Dialogfenster gibt man in die &quot;Öffnen&quot;-Zeile das Wort &lt;code&gt;cmd&lt;/code&gt; ein und mit &quot;OK&quot; wird das Ganze bestätigt.&lt;/small&gt; 
 
2) Wechseln Sie mittels &lt;code&gt;cd c:\tmp&lt;/code&gt; in das Verzeichnis c:\tmp

3) Angenommen, Sie haben Python unter dem Pfad &lt;code&gt;c:\devel\Python\&lt;/code&gt; installiert. Starten Sie das Programm so (der Prompt &lt;code&gt;c:\tmp&gt;&lt;/code&gt;ist natürlich nicht mit einzutippen): 

 c:\tmp&gt;c:\devel\Python\python.exe test1.py

4) Wie erwartet ergibt sich folgende Ausgabe am Bildschirm

 Hallo Welt!

Die Vorgehensweise unter Linux ist prinzipiell gleich. Die kleinen Unterschiede, wie z.B. der Slash statt dem Backslash in Pfadangaben, sollten für Linux-Benutzer keine Hürde darstellen.

== Variablen ==
Variablenbezeichner können aus Buchstaben (A-Za-z), Ziffern (0-9) und Underscores (_) bestehen, dürfen aber nicht mit einer Zahl beginnen. Führende Underscores haben u.a. im Kontext mit der Objektorientierten Programmierung eine spezielle Bedeutung und sollten nicht für &quot;normale&quot; Variablenbezeichner verwendet werden.

Gültige Variablenbezeichner wären also:
 xyz
 x1
 _wert
 name_anzahl

Theoretisch kann man auch Umlaute, griechische Buchstaben u.ä. in Variablenbezeichnern nutzen, z.B.

 ößÜ = 16
 α = 134 
 print(ößÜ)
 print(α)

Ausgabe:
 16
 134

Davon wird aber aus offensichtlichen Gründen ({{W|Englisch als Lingua franca}}) abgeraten. Das Eurozeichen (€) etc. darf man ohnehin nicht in Variablenbezeichnern verwenden, dies ergäbe einen Syntaxfehler. Siehe dazu auch [https://peps.python.org/pep-3131/].

Es gibt in Python etliche Schlüsselwörter (z.B. for, if oder return). Diese dürfen nicht als eigene Variablenbezeichner verwendet werden. Eine Liste aller Schlüsselwörter liefert das Script

 import keyword
 print(keyword.kwlist)

&lt;small&gt;Übung: Speichern Sie dieses Script in eine Datei, z.B. in c:\tmp\test1.py. Führen Sie diese Datei aus, um die Liste der Schlüsselwörter auszugeben.&lt;/small&gt;

Da Python case-sensitiv ist, repräsentieren folgende Bezeichner verschiedene Variablen:
 xyz
 XYZ
 xYz

Werte werden an Variablen mittels Gleich-Zeichen (=) zugewiesen. Im Folgenden wird der Code immer in der Datei c:\tmp\test1.py gespeichert.

 x = 5
 y = 10
 z = x*y
 print(z)

Bringen Sie die Datei test1.py zur Ausführung, so erhalten Sie folgende Bildschirmausgabe

 50

Sie können auch mehrere Anweisungen in einer Zeile durch Semikolon getrennt schreiben. Dies führt aber zu unübersichtlichem Code.

 x = 5; y = 10; z = x*y; print(z)

Ausgabe:
 50

Auch aus der Programmiersprache C/C++ oder Java bekannte Konstrukte können Sie verwenden, z.B.
 x = 5
 # x = x - 2
 x -= 2
 print(x)

Bildschirmausgabe:

 3
 
Beachten Sie, dass mit dem =-Zeichen eine Wertezuweisung durchgeführt wird. Dies ist nicht äquivalent zum mathematischen =-Zeichen, wie am vorigen Beispiel zu ersehen ist. Den Inkrement-/Dekrementoperator (z.B. x++ oder x--) aus C/C++ oder Java kennt Python aber nicht.

Variablen sind nicht an einen bestimmten Datentyp gebunden, folgendes ist mit Python problemlos möglich:

 import math
 wert = 10
 print(wert)
 wert = 35.5
 print(wert)
 wert = &quot;Hallo&quot;
 print(wert)
 wert = math.pi
 print(wert)

Ausgabe:
 10
 35.5
 Hallo
 3.141592653589793

== Physische und logische Zeilen ==
In Python muss eine Anweisung in einer logischen Zeile Platz finden. Wird eine Anweisung aber zu lang für eine Zeile, dann kann sie in mehrere physische Zeilen unterteilt werden. Dies kann einerseits durch einen Backslash am Ende einer Zeile geschehen, z.B.

 a = 2 + \
 5
 
Dies stellt eine logische Zeile dar, die in zwei physische Zeilen unterbrochen ist.

Geklammerte Ausdrücke werden automatisch zu einer logischen Zeile verbunden, z.B.

 a = (2 + 
 5)
 
Achtung: Im ersten Beispiel darf nach dem Backslash nichts mehr stehen, auch kein Kommentar. Dies trifft im zweiten Bespiel nicht zu, hier könnte noch ein Kommentar folgen, z.B.

 a = (2 +    # Kommentar 
 5)

Auch für Strings gibt es Möglichkeiten, diese auf mehrere Zeilen aufzuspalten.

 # Kurzer String
 str1 = &quot;ABC&quot;
 
 # Langer String
 str2 = &quot;&quot;&quot;Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle&quot;&quot;&quot;
 
 # Backslash
 str3 = &quot;UVW\
 XYZ&quot;
 
 # Mit Klammern
 str4 = (&quot;Sehr langer Text, der automatisch .............. &quot;
         &quot;in einer einzigen Variable zusammengefügt wird.&quot;
 )
 
 print(str1)
 print(str2)
 print(str3)
 print(str4)

Ausgabe:

 ABC
 Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle
 UVWXYZ
 Sehr langer Text, der automatisch .............. in einer einzigen Variable zusammengefügt wird.

==Hexadezimale, oktale, binäre und andere Zahlen==
 d = 1050         # Dezimalzahl
 h = 0xAA2        # Hexadezimalzahl
 o = 0o12         # Oktalzahl
 b = 0b100001101  # Binärzahl
 
 print(d)
 print(h)
 print(o)
 print(b)

Ausgabe:
 1050
 2722
 10
 269

Groß- und Kleinbuchstaben sind in obigen Literalen übrigens egal. So kann man z.B. statt &lt;code&gt;0b1001&lt;/code&gt; auch &lt;code&gt;0B1001&lt;/code&gt; schreiben (siehe dazu [https://docs.python.org/3/reference/lexical_analysis.html#integer-literals]).

Sie können auch dezimale in hexadezimale Zahlen umwandeln, usw.:
 h = hex(1050)    # Dezimalzahl -&gt; Hexadezimalzahl
 b = bin(1050)    # Dezimalzahl -&gt; Binärzahl
 o = oct(1050)    # Dezimalzahl -&gt; Oktalzahl
 print(h)
 print(b)
 print(o)

Ausgabe:
 0x41a
 0b10000011010
 0o2032

Gegeben sei die Zahl 121 zur Basis 3. Diese soll in eine Dezimalzahl umgewandelt werden. Das kann so geschehen:

 z = int(&quot;121&quot;, 3)
 print(z)

Ausgabe:
 16

Dass dies richtig ist, davon kann man sich folgendermaßen überzeugen:
 &lt;math&gt; 1 \cdot 3^2 + 2 \cdot 3^1 + 1 \cdot 3^0 = 9 + 6+ 1 = 16 &lt;/math&gt;

Zahlen übersichtlicher schreiben kann man auch mittels Underscore, z.B.:

 print(&quot;Eine Million (Variante 1) =&quot;, 1000000)
 print(&quot;Eine Million (Variante 2) =&quot;, 1_000_000)
 print(&quot;Eine Rechnung:&quot;, 2_000 * 400_000);

Es ergibt sich bei beiden Varianten die gleiche Ausgabe. Variante 2 ist aber im Sourcecode leichter lesbar, detto die Zahlen in der Rechnung:

 Eine Million (Variante 1) = 1000000
 Eine Million (Variante 2) = 1000000
 Eine Rechnung: 800000000

== Strings und Platzhalter==
Ein paar einfache Beispiele:

 print(&quot;Hallo {}&quot; . format(&quot;Hugo&quot;))     # new style string formatting
 print(&quot;Hallo {:s}&quot; . format(&quot;Hugo&quot;))   # new style string formatting
 print(&quot;Hallo %s&quot; % &quot;Hugo&quot;)             # %-String

Ausgabe:

 Hallo Hugo
 Hallo Hugo
 Hallo Hugo

Python-Code (formatted string literals, Beispiel 1):
 str1 = &quot;Hallo&quot;
 str2 = &quot;Hugo&quot;
 print(f&quot;{str1} {str2}&quot;)

Ausgabe:
 Hallo Hugo

f-Strings (ab Python 3.6) sind die modernere Variante gegenüber %-Strings oder das ''new style string formatting''. Sie sind in der Regel auch schneller.

Python-Code (formatted string literals, Beispiel 2):
 wert = 11.567
 print(f&quot;Ausgabe: {wert:.5f}&quot;)

Ausgabe:
 Ausgabe: 11.56700

Komplexere Beispiele:

 print(&quot;Hallo {} und {}&quot; . format(&quot;Hugo&quot;, &quot;Mike&quot;))
 print(&quot;Hallo {name1} und {name2}&quot; . format(name2=&quot;Hugo&quot;, name1=&quot;Mike&quot;))
 # Füllzeichen: *
 # Bündigkeit: &gt; (=rechts), &lt; (=links), ^ (=zentriert)
 # Feldweite: 10
 # Typ: s (=String), f (=Gleitkommazahl), d (=Dezimalzahl) etc.
 print(&quot;Hallo {:*&gt;10s}&quot; . format(&quot;Hugo&quot;))
 print(&quot;Hallo {:*&lt;10s}&quot; . format(&quot;Hugo&quot;))

Ausgabe:

 Hallo Hugo und Mike
 Hallo Mike und Hugo
 Hallo ******Hugo
 Hallo Hugo******

Python-Code:
 str = &quot;Hallo\t%s\t%7.2f\t%10.2e\t%i&quot; % (&quot;Hugo&quot;, 12.34567, 34.567, 264)
 print(str)

Ausgabe:
 Hallo	Hugo	  12.35	  3.46e+01	264

== Unicode ==
Neben den bekannten ASCII-Zeichen lassen sich Zeichen auch mittels Unicode beschreiben. Griechische Buchstaben oder komplexere mathematische Operatoren - all das sollte kein Problem sein. Siehe auch {{W|Unicode}}, {{W|Liste der Unicodeblöcke}} und {{W|Unicodeblock Mathematische Operatoren}}. Im Folgenden werden ein paar Zeichen (Allquantor, Nabla-Operator, Existenzquantor), die man aus der Mathematik kennt, erzeugt. 
 
 ch1 = &quot;\N{FOR ALL}&quot;
 ch2 = &quot;\N{NABLA}&quot;
 ch3 = &quot;\u2203&quot;
 print(ch1, ch2, ch3)

Ausgabe:
 ∀ ∇ ∃

&lt;small&gt;Diese Ausgabe ergibt sich z.B. mit der IDLE-Shell oder mit Cygwin. Beim Ausführen über die Windows-Eingabeaufforderung oder Windows PowerShell unter MS Windows 10 erfolgt keine korrekte Darstellung. IDLE ist die mit Python mitgelieferte IDE ('''I'''ntegrated '''D'''evelopment '''E'''nvironment, Integrierte Entwicklungsumgebung). Gegen Ende dieses Textes wird IDLE kurz beschrieben.
Das Problem mit der Windows Eingabeaufforderung lässt sich aber umgehen. Man muss nur eine Schriftart auswählen, die die Zeichen kennt, z.B. &quot;DejaVu Sans Mono&quot;. Dazu klicken Sie einfach bei der Eingabeaufforderung mit der rechten Maustaste oben auf die weiße Leiste und wählen im aufpoppenden Fenster den Menüpunkt &quot;Eigenschaften&quot;. Es öffnet sich ein Dialogfenster. Über den Reiter &quot;Schriftart&quot; lässt sich nun die Schriftart einstellen. Unter MS Windows 11 oder openSUSE Leap 15.6 (bash-Konsole) gibt es dieses Problem ohnehin nicht.&lt;/small&gt;

== Reguläre Ausdrücke ==
Python kennt auch {{W|Regulärer Ausdruck|reguläre Ausdrücke}}. Dazu gibt es in Python das Modul &lt;code&gt;re&lt;/code&gt;. Beipielsweise sollen alle Zahlen (&lt;math&gt;\text{zahl}\in\mathbb{N}_0&lt;/math&gt;) in einem String gesucht und ausgegeben werden. Als String sei gegeben: &lt;code&gt;3x Grüße und 100 Kekse.&lt;/code&gt; Das Muster (Pattern) ist &lt;code&gt;\d+&lt;/code&gt;. &lt;code&gt;\d&lt;/code&gt; steht für eine Dezimalziffer 0-9. Das Plus-Zeichen (+) steht symbolisch für ein oder mehrere Zeichen des vorherigen Ausdrucks. Hier also ein oder mehrere Dezimalziffern. Es wird die Funktion &lt;code&gt;findall&lt;/code&gt; aus dem Modul &lt;code&gt;re&lt;/code&gt;verwendet.

Python-Code:
 from re import findall
 
 str = &quot;3x Grüße und 100 Kekse.&quot;
 pat = &quot;\\d+&quot;  # Doppel-Backslashes müssen verwendet werden, sonst gibt Python eine Warnung aus!
               # alternativ: pat = r&quot;\d+&quot; 
               # oder: pat = &quot;[0-9]+&quot;
 
 numb = findall(pat, str)
 print(numb)

Ausgabe:
 ['3', '100']

Python kennt noch viele weitere Möglichkeiten mittels regulärer Ausdrücke zu hantieren. Dies soll hier aber nicht vertieft werden, da das Thema schon ziemlich speziell und komplex ist. Bei Bedarf siehe aber z.B. die Bücher ''Weigend, Seite 380ff'' und ''Ernesti, Kaiser'' [https://openbook.rheinwerk-verlag.de/python/28_001.html] oder die Python-Dokumentation [https://docs.python.org/3/library/re.html]. Auch [[Python unter Linux: Reguläre Ausdrücke]] liefert ein umfangreiches und brauchbares Python-2-Kapitel zu den regulären Ausdrücken. Die dort gelisteten Beispiele müssten ggf. vor Verwendung auf Python-3 umgeschrieben werden. &lt;small&gt;Wie macht  man das? Dazu siehe z.B. [https://openbook.rheinwerk-verlag.de/python/43_001.html], [https://portingguide.readthedocs.io/en/latest/] oder [https://www.digitalocean.com/community/tutorials/how-to-port-python-2-code-to-python-3]&lt;/small&gt;

&lt;small&gt;Es gibt auch ein externes Modul ''regex'', das bei Bedarf extra installiert werden muss ([https://pypi.org/project/regex/]). Es bietet zusätzliche Funktionalität und gründlicheren Unicode-Support. Dies sei hier aber nur der Vollständigkeit halber erwähnt.&lt;/small&gt;

== Verzweigungen ==
=== if ===
Die IF-Verzweigung sei aus anderen Programmiersprachen bereits bekannt. In {{W|Pseudocode}} lässt sie sich folgendermaßen darstellen:

 WENN bedingung TRUE
   führe block1 aus
 SONST
   führe block2 aus
 ENDE 

Als {{W|Aktivitätsdiagramm|UML-Aktivitätsdiagramm}} sieht das in etwa so aus:

[[File:If-Then-Else-diagram.svg|200px]]

Und als {{W|Nassi-Shneiderman-Diagramm|Nassi-Shneiderman-Struktogramm}} so:

[[File:Zweiseitige Auswahl.png|250px]]

In Python gibt es keinen expliziten ENDE-Kennzeichner. Stattdessen wird der Code durch Einrückungen strukturiert. Alles mit der gleichen Einrückungstiefe gehört zum selben Block. Dies zeichnet Python vor anderen Programmiersprachen aus.

Die test1.py-Datei laute also wie folgt:

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
   print(&quot;x ist groesser oder gleich 4&quot;)  

Ausgabe:

 Der else-Zweig wird ausgefuehrt
 x ist groesser oder gleich 4

Man achte auch auf die Doppelpunkte in der if- und else-Zeile. Darauf vergisst man gerne, wenn man von anderen Programmiersprachen kommt.

Folgendes wäre in Python ein Fehler (genauer gesagt ein IndentationError).

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
     print(&quot;x ist groesser oder gleich 4&quot;)  

Auch Nachstehendes würde nicht zum gewünschten Ergebnis führen (löst aber keine Fehlermeldung aus). Der letzte print-Befehl ist schon außerhalb der IF-ELSE-Verzweigung.

 x = 3
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
 print(&quot;x ist groesser oder gleich 4&quot;)

Ausgabe:

 x ist kleiner als 4
 x ist groesser oder gleich 4

Python kennt eine Reihe von Vergleichs- und Verknüpfungsoperatoren:

    &lt;, &lt;= ... kleiner (gleich)
    &gt;, &gt;= ... größer (gleich)
    == ... gleich
    != ... ungleich
    is ... identisch
    is not ... nicht identisch
    and ... AND
    or ... OR
    not ... NOT

Beispielsweise:

 a = 5
 b = 9
 
 if a&lt;=10 and b!=7:
   print(&quot;OK&quot;)
 else
   print(&quot;Nicht OK&quot;)

Ausgabe:

 OK

Der else-Block kann übrigens auch ersatzlos entfallen. Als Pseudocode sieht das so aus

 WENN bedingung TRUE
   führe block aus
 ENDE

Mehrfache Verzweigungen werden durch das elif-Konstrukt erstellt. In Pseudocode:

 WENN bedingung1 TRUE
   führe block1 aus
 SONST WENN bedingung2 TRUE
   führe block2 aus
 SONST WENN bedingung3 TRUE
   führe block3 aus
 SONST
   führe block4 aus
 ENDE

Ein Python-Beispiel:
 a = 14
 
 if a&lt;=10:   
   print(&quot;&lt;=10&quot;)
 elif a&gt;=11 and a&lt;=15:
   print(&quot;11 bis 15&quot;)
 elif a&gt;=16 and a&lt;=20:
   print(&quot;16 bis 20&quot;)
 else:
   print(&quot;&gt;20&quot;)

Ausgabe:

 11 bis 15

In Python gibt es auch die Schlüsselwörter &lt;code&gt;True&lt;/code&gt; (für wahr) und &lt;code&gt;False&lt;/code&gt; (für falsch). Man beachte, dass sie mit Großbuchstaben beginnen. Andere Schreibweisen wären ein Fehler. Sie gehören zum Datentyp &lt;code&gt;bool&lt;/code&gt;. Ihnen sind auch die Zahlen &lt;code&gt;1&lt;/code&gt; und &lt;code&gt;0&lt;/code&gt; zugewiesen.

Man beachte, dass {{W|Rundungsfehler}} auftreten können. D.h. man sollte  bei der Verwendung von {{W|Gleitkommazahl|Gleitpunktzahlen}} niemals auf absolute Genauigkeit prüfen, sondern eine Toleranz (einen &lt;math&gt;\varepsilon&lt;/math&gt;-Wert) vorgeben.
 
Ein klassisches Beispiel, das ein falsches Ergebnis liefert, ist:

 i = 0.1 + 0.2
 
 print(i)
 
 if i == 0.3:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 NOK

Und das, obwohl man schon in der Volksschule lernt, dass 0.1 + 0.2 gleich 0.3 ist.

Korrekt muss das obige Beispiel z.B. so umgeschrieben werden:

 ist = 0.1 + 0.2
 soll = 0.3
 epsilon = 0.000001
 
 print(ist)
 
 if abs(ist-soll) &lt; epsilon:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 OK

Alternativ kann auch die &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion verwendet werden. Das sei aber hier nur erwähnt und nicht konkret ausgeführt.

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet zum Thema &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion.

=== match ===
Ab Python 3.10 gibt es auch die match-Anweisung. Dies ist das Python-Pendant für die switch-Anweisung in anderen Programmiersprachen, geht aber bei näherer Betrachtung weit darüber hinaus. Hier nur ein einfaches Beispiel:

 x = &quot;Hello&quot;
 
 match x:
     case &quot;Servus&quot; | &quot;Ciao&quot;:         # or
         print(&quot;Servus an alle&quot;)
     case &quot;Grüetzi&quot;:
         print(&quot;Grüetzi Schwyzer&quot;)  
     case _:                         # other, default, sonstiges ...
         print(&quot;Hallo Welt&quot;)

Ausgabe: 
 Hallo Welt

Als Struktogramm sieht das in etwa so aus:

[[File:Mehrseitige Auswahl.png|250px]]

Für nähere Details siehe z.B. [https://www.geeksforgeeks.org/python-match-case-statement/], [https://learnpython.com/blog/python-match-case-statement/], [https://docs.python.org/3/tutorial/controlflow.html#match-statements] und das Python Enhancement Proposal (PEP) 636 – Structural Pattern Matching: Tutorial [https://peps.python.org/pep-0636] und dort insbesondere den Anhang A - Quick Intro.

&lt;small&gt;&lt;code&gt;match, case, _&lt;/code&gt; etc. sind sogenannte ''soft keywords''. Im Gegensatz zu den normalen Schlüsselwörtern dürfen ihnen auch Werte zugewiesen werden. Eine Liste der weichen Schlüsselwörter lässt sich durch &lt;code&gt;keyword.softkwlist&lt;/code&gt; erstellen (die Anweisung gibt es seit Python 3.9). Siehe dazu auch [https://stackoverflow.com/questions/65800344/what-are-soft-keywords] und [https://docs.python.org/3/library/keyword.html#keyword.softkwlist].&lt;/small&gt;

== Schleifen ==
Kopfgesteuerte Schleife, Endlosschleife und fußgesteuerte Schleife:

[[File:Programmingloops.svg|450px]]

=== while ===
Die WHILE-Schleife ist kopfgesteuert. Sie funktioniert wie aus anderen Programmiersprachen bekannt. 

In Pseudocode:
 SOLANGE bedingung TRUE
   führe block aus
 ENDE

In Python:
 x = 0
 
 while x &lt;= 10:
   print(x)
   x += 1

Ausgabe:
 0
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10

Eine Endlosschleife ergibt sich z.B. so:
 i = 5
 
 while True:
     print(i)
     i-=1

Beendet werden kann sie mit der Tastenkombination STRG-C.

Eine fußgesteuerte Schleife kann so simuliert werden:
 i = 5
 
 while True:
     print(i)
     i-=1
 
     if i&lt;=0:
         print(&quot;Fire&quot;)
         break

Ausgabe:
 5
 4
 3
 2
 1
 Fire

Der &lt;code&gt;break&lt;/code&gt;-Befehl wird etwas [[Ing_Mathematik:_Python#break|später]] noch einmal kurz thematisiert.

=== for ===
Struktogramm einer for-Schleife:

[[File:Zählschleife.png|200px]]

In Python bspw. so:

 for x in range(6):
   print(x*2)

Ausgabe:
 0
 2
 4
 6
 8
 10

Die Schleife läuft von 0 bis 5. Ausgegeben wird jeweils der Wert x*2. Aquivalent kann diese Schleife auch so geschrieben werden:
 for x in range(0, 11, 2):
   print(x)

Die Ausgabe ist wie oben. Der Startwert sei 0, der Endwert ist 11-1 und die Schrittweite ist 2.

Ein anderes Beispiel sei
 for x in &quot;text&quot;:
   print(x)

Ausgabe:
 t
 e
 x
 t

== Schleifen abbrechen ==
=== break ===
&lt;code&gt;break&lt;/code&gt; bricht die Schleife ab und setzt mit dem nächsten Befehl außerhalb der Schleife fort.

 for var in range(100):
   print(var) 
   if var == 5:
     break

Ausgabe:
 0
 1
 2
 3
 4
 5

=== continue ===
&lt;code&gt;continue&lt;/code&gt; bricht den aktuellen Schleifendurchlauf ab und setzt mit dem nächsten Schleifendurchlauf fort.

 for var in range (11):
   if var == 5:
     continue
   print(var)

Ausgabe:
 0
 1
 2 
 3
 4
 6
 7
 8
 9
 10

== try - except ==
 try:
     z1 = 12 / 0
     print(z1)
 except ZeroDivisionError:
     print(&quot;Das Ergebnis ist unendlich&quot;)
 except:
     print(&quot;Kann nicht berechnet werden!&quot;)
     print(&quot;Bitte die Formel korrigieren!&quot;)
 
 print(&quot;Setze Programm fort!&quot;)

Ausgabe:
 Das Ergebnis ist unendlich
 Setze Programm fort!

Es wird versucht, eine Zahl durch Null zu dividieren. Das ist nicht möglich, es wird eine Ausnahme ausgelöst. Das Programm springt daher in den except-ZeroDivisionError-Block und führt die dort gelisteten Anweisungen aus (in unserem Fall eine print-Anweisung). Danach wird das Programm fortgesetzt. Würden wir dieses Programm ohne try-except ausführen, so ergibt sich aus

 z1 = 12 / 0
 print(z1)

folgende Fehlermeldung und ein unmittelbarer Programmabbruch

 Traceback (most recent call last):
   File &quot;C:\tmp\test1.py&quot;, line 1, in &lt;module&gt;
     z1 = 12 / 0
 ZeroDivisionError: division by zero

Mit dem try-except-Mechanismus können also Ausnahmen oder Fehler aufgefangen und behandelt werden. In unserem Beispiel ist das eher trivial, aber bei größeren Programmen kann das durchaus Sinn machen.

Neu in Python 3.14 ist, dass mehrere Ausnahmen auch ohne Klammern angegeben werden können, z.B.:

bis inkl. Python 3.13 nur:
 except (ZeroDivisionError, ValueError):

ab Python 3.14 auch:
 except ZeroDivisionError, ValueError:

== pass ==
Ein leerer Block muss in Python mittels dem Schlüsselwort &lt;code&gt;pass&lt;/code&gt; dargestellt werden. Z.B.

 x = 2
 
 if x == 1:
     print(&quot;Wert ist &quot;, x)
 else:
     pass

Würde man das &lt;code&gt;pass&lt;/code&gt; im else-Block weglassen, so würde man eine Fehlermeldung erhalten:

 IndentationError: expected an indented block after 'else' statement on line 5

= Funktionen =
== Aufrufen von Funktionen ==
Funktionen sind uns im Rahmen dieses Kurses schon zuhauf begegnet. Sei es die print()-, die math.sin()- oder die hex()-Funktion. All diese Funktionen werden von Python zur Verfügung gestellt, ohne dass man sie explizit programmieren müsste. Aufgerufen werden diese Funktionen, indem man ihren Namen eintippt, gefolgt von runden Klammern. In diesen Klammern können noch Argumente übergeben werden. Auch Rückgabewerte sind möglich.

== Funktionen selber schreiben ==
Funktionen werden mit dem def-Schlüsselwort (man definiert die Funktion) eingeleitet, danach folgt der Funktionsname, danach wiederum runde Klammern, in denen formale Argumente stehen können. Abgeschlossen wird die def-Zeile mit einem Doppelpunkt. Danach folgt der Funktionskörper. Dieser Funktionskörper muss wiederum eingerückt werden (wie von den Verzweigungen und Schleifen bekannt). Aufgerufen wird diese Funktion, indem man ihren Funktionsnamen eingibt, gefolgt von runden Klammern (ggf. mit den aktuellen Parametern). Z.B.

 # Funktion definieren
 def halloWelt(i):
     # i ... beliebige Ganzzahl
     print(&quot;Hallo &quot; * i, end=&quot;&quot;)
     print(&quot;Welt!&quot;)
    
 # Funktion aufrufen
 halloWelt(3)

Ausgabe:
 Hallo Hallo Hallo Welt!

Unterschied zwischen formalen und aktuellen Parametern:

[[Datei:PythonIng_func1.jpg]]

&lt;small&gt;Aktuelle Parameter werden auch Argumente genannt.&lt;/small&gt;

Rückgabe von Funktionswerten:
 # Funktion definieren
 def mathFunc(a, b):
     r1 = a + b
     r2 = a * b
     return r1, r2
    
 # Funktion aufrufen
 c, d = mathFunc(3, 5)
 
 # Ausgabe der zurückgegebenen Werte
 print(c)
 print(d)

Ausgabe:
 8
 15

Es werden r1 und r2 zurückgegeben und den Variablen c und d zugewiesen. (r1, r2) und (c, d) sind Tupel. Was Tupel konkret sind, siehe etwas später in diesem Kapitel. 3 und 5 sind die aktuellen Parameter (die Argumente). a und b sind die formalen Parameter. Die Zuweisung der aktuellen zu den formalen Parametern erfolgt in der gegebenen Reihenfolge, also die Zahl 3 wird an a übergeben und die Zahl 5 an b.

Vorgabeparameter, z.B.:
 def mathFunc(a=10, b=20):
     r1 = a + b
     r2 = a * b
     return r1, r2
 
 c, d = mathFunc(3, 5)
 print(c)
 print(d) 
 
 e, f = mathFunc(5)
 print(e)
 print(f)
 
 g, h = mathFunc(b=6)
 print(g)
 print(h)

Ausgabe:
 8
 15
 25
 100
 16
 60

Erklärung:
* Erster &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es werden, wie weiter oben, die Argumente 3 und 5 an die formalen Parameter a und b übergeben. Die Rückgabewerte r1 und r2 werden an c und d übergeben. Somit ist c=8 und d=15.
* Zweiter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur das Argment 5 an a übergeben. b behält den Vorgabewert 20. D.h. e= 25 und f=100.
* Dritter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur die Zahl 6 an b übergeben, a behält seinen Vorgabewert 10. Somit ergibt sich g=16 und h=60.

Beispiel (Schlüsselwortargumente vs. Positionsargumente):
 def mathFunc(a, b):
     r1 = a - b
     r2 = a / b
     return r1, r2
 
 c, d = mathFunc(b=3, a=5)  # Schlüsselwortargumente
 e, f = mathFunc(3, 5)      # Positionsargumente

 print(c)
 print(d)
 print(e)
 print(f)

Ausgabe:
 2
 1.6666666666666667
 -2
 0.6

Durch die Verwendung von Schlüsselwortargumenten können die Argumente in beliebiger Reihenfolge angegeben werden. Bei den Positionsargumenten ist die Reihenfolge vorgegeben. Daraus resultiert auch der Unterschied bei den obigen Ausgaben. Werden beide Arten in einem Aufruf gemischt, so müssen die Positionsargumente zuerst angegeben werden. Den Unterschied zwischen beiden Argumentarten zu kennen ist wichtig, nicht nur bei selbst erstellten Funktionen. Auch beim Aufruf von Python-Funktionen verfolgt einen die Mischung von Schlüsselwort- und Positionsargumenten auf Schritt und Tritt, z.B. beim etwas später folgenden Abschnitt über &quot;Grafiken zeichnen&quot;:

 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)

Bei dieser &lt;code&gt;plot&lt;/code&gt;-Funktion aus dem Modul &lt;code&gt;matplotlib.pyplot&lt;/code&gt; sind &lt;code&gt;x&lt;/code&gt; und &lt;code&gt;y1&lt;/code&gt; Positionsargumente. &lt;code&gt;label, lw&lt;/code&gt; und &lt;code&gt;ls&lt;/code&gt; sind die Namen der Schlüsselwortargumente. Die Schlüsselwortargumente könnten auch in anderer Reihenfolge angeschrieben werden, nicht jedoch die Positionsargumente!
Siehe zu &lt;code&gt;matplotlib.pyplot.plot&lt;/code&gt; auch die Seite [https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html].

== Lambda-Funktionen ==
 print((lambda a, b: a*b) (3, 5))

Ausgabe:
 15

Eingeleitet wird eine Lambda-Funktion (auch Lambda-Form, Lambda-Operator oder anonyme Funktion genannt) mit dem Schlüsselwort &lt;code&gt;lambda&lt;/code&gt;. Es folgen die formalen Argumente, danach ein Doppelpunkt, die Berechnungsvorschrift und ggf. abschliessend in Klammern die aktuellen Parameter.

Man kann einer Lambda-Funktion auch einen Funktionsnamen geben und die Funktion über diesen Namen aufrufen, z.B.

 prod = lambda a, b: a*b
 print(prod(3, 5))

Als Ausgabe wird wieder die Zahl 15 geliefert.

== Rekursive Funktionen ==
Funktionen können wiederum andere Funktionen aufrufen. Von einem {{W|Rekursion|rekursiven Funktionsaufruf}} spricht man, wenn die aufgerufene Funktion gleich der aufrufenden ist. 

 def printFunc(i):
     if (i &gt;= 5):
         return 
     else:
         print(&quot;Hallo Welt&quot;)
         printFunc(i+1)
         
 printFunc(1)

Ausgabe:
 Hallo Welt
 Hallo Welt
 Hallo Welt
 Hallo Welt

Typische Beispiele für die Abarbeitung als rekursive Funktionen sind die {{W|Fibonacci-Folge}} und die {{W|Fakultät_(Mathematik)|Fakultät}}. Jedoch ist der iterative Ansatz (mit konventionellen Schleifen) meist schneller und speicherplatzschonender.

== Funktionsannotationen ==
Python ist sehr flexibel, was Typen angeht. Im Vorhergehenden haben wir generell keine Typangaben gemacht. Will man Typen angeben, so bietet Python das Konzept der Funktionsannotation.

 def calcFunc(a: int, b: int) -&gt; int:
     return a+b
 
 r1 = calcFunc(8, 9)
 r2 = calcFunc(8.0, 9.0)
 r3 = calcFunc(&quot;Hallo&quot;, &quot;Welt&quot;)
 
 print(r1)
 print(r2)
 print(r3)

Ausgabe:
 17
 17.0
 HalloWelt

Jetzt sieht man auf den ersten Blick, welche Typen der Programmierer im Sinn hatte, als er die Funktion erstellte. Das Problem dabei ist nur, dass es Python ziemlich egal ist, welche Typen man im Endeffekt eingibt. Im obigen Beispiel können statt Integer-Typen u.a. auch Float- oder String-Typen eingegeben werden.

&lt;small&gt;
Siehe zum Thema &quot;Type Checking&quot; aber auch den später folgenden Abschnitt [[Ing_Mathematik:_Python#Type_Checker]].
&lt;/small&gt;

== Variadische Funktionen ==
Python-Code:

 def test1(a, *b):
     print(a);
      
     for c in b:
         print(c);
        
 test1(&quot;Hallo&quot;, &quot;Welt&quot;, &quot;Schweizer&quot;, &quot;und alle anderen&quot;)

Ausgabe:

 Hallo
 Welt
 Schweizer
 und alle anderen

Mit dem Stern (auch als Splat-Operator bezeichnet) in der formalen Parameterliste bei der Funktion &lt;code&gt;test1&lt;/code&gt; wird angezeigt, dass eine beliebige Anzahl von Argumenten übergeben wird. &lt;small&gt; Dies entspricht in etwa dem, was in anderen Programmiersprachen (PHP etc.) mittels Ellipse (&lt;code&gt;...&lt;/code&gt;) angezeigt wird.&lt;/small&gt;

= Tupel, Listen und andere =
[[Datei:Python 3. The standard type hierarchy.png|mini|hochkant=1.7|Datentypen und Strukturen]]

== Tupel und Listen ==
Tupel, Listen und einige andere sind Datenstrukturen oder Sequenzen.

Listen (z.B. eine Einkaufsliste) sind veränderbar (mutable). Ein Tupel kann dagegen nicht verändert werden (immutable). Listen werden beim Anlegen in eckige Klammern eingeschlossen, Tupel in runde Klammern. Beim Tupel können die Klammern auch weggelassen werden. Ein Tupel mit nur einem Element muss mit einem Beistrich abgeschlossen werden. Der Grund ist, dass Python sonst nicht entscheiden kann, ob ein Tupel angelegt werden soll, oder nur ein geklammerter Wert. 

Als Gedächtnisstütze kann man sich den Unterschied zwischen Tupel und Liste ev. so leichter merken:
: T'''u'''pel ... r'''u'''nde Klammern, '''u'''nveränderlich
: L'''i'''ste ... eck'''i'''ge Klammern, veränderl'''i'''ch.

Nachfolgend werden einige Operationen mit Listen und Tupel dargestellt.

 # Liste und Tupel
 liste = [1, 2, &quot;Hallo&quot;]
 tupel = (1, 2, &quot;Hallo&quot;) 
 
 # Ausgabe von liste und tupel
 print(liste)
 print(tupel)
 
 # Ausgabe von Einzelelementen
 print(liste[1])
 print(tupel[2])
 
 # Element an Liste anhängen und einfügen 
 liste.append(55)
 liste.insert(4, &quot;Welt&quot;)
 print(liste)
 
 # Element aus Liste entfernen
 liste.remove(1)
 print(liste)
 
 # einige weitere Beispiele
 liste2 = [1,]
 tupel2 = 1, 2
 tupel3 = (1,) 
 print(liste2)
 print(tupel2)
 print(tupel3)

Ausgabe:
 [1, 2, 'Hallo']
 (1, 2, 'Hallo')
 2
 Hallo
 [1, 2, 'Hallo', 55, 'Welt']
 [2, 'Hallo', 55, 'Welt']
 [1]
 (1, 2)
 (1,)

Beispiel (eine Liste von Wörtern zu einem einzigen zusammenhängenden Text verbinden):

 woerter = [&quot;Hallo&quot;, &quot;Welt&quot;]
 satz = &quot; &quot;.join(woerter)
 print(satz)

Ausgabe:

 Hallo Welt

== Dictionaries und Mengen ==
Zu den Datenstrukturen gehören weiters auch Mengen und Dictionaries. Mengen sind von der Mathematik bekannt, sie sind ungeordnet und es kommen keine mehrfachen Elemente vor. Dictionaries sind durch Schlüssel :Wert-Paare gekennzeichnet. Mengen werden beim Anlegen wie Dictionaries in geschweifte Klammern eingeschlossen.

 dict = {&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot; }
 menge = {1, 1, 3, 4, 4, 4, &quot;Hallo&quot;}
 
 print(dict)
 print(menge)
 print(dict[&quot;vorname&quot;])

Ausgabe:
 {'vorname': 'Hugo', 'nachname': 'Meister'}
 {1, 3, 4, 'Hallo'}
 Hugo

Geschweifte Klammern ohne Inhalt stellen Dictionaries dar und keine Mengen:

 di = {}
 print(type(di))

Ausgabe:
 &lt;class 'dict'&gt;

Leere Mengen lassen sich mit &lt;code&gt;set()&lt;/code&gt; erzeugen:

 menge = set()      # leere Menge
 print(menge)
 menge.add(&quot;Hallo&quot;) # Element hinzufügen
 print(menge)

Ausgabe:
 set()
 {'Hallo'}

Beispiel (einige Mengenoperationen):
 mengeA = {&quot;Hallo&quot;, &quot;Welt&quot;}
 mengeB = {1, 2, &quot;Welt&quot;, 3}
 
 # Vereinigung
 print(mengeA | mengeB)
 print(mengeA.union(mengeB))
 
 # Durchschnitt
 print(mengeA &amp; mengeB)
 print(mengeA.intersection(mengeB))
 
 # Differenz
 print(mengeA - mengeB)
 print(mengeA.difference(mengeB))
 
 # Symmetrische Differenz
 print(mengeA ^ mengeB)
 print(mengeA.symmetric_difference(mengeB))
 
 # Teilmenge
 print(mengeA.issubset(mengeB))
 
 # Mehrere Elemente hinzu
 mengeA.update([&quot;Super&quot;, 67, 125])
 print(mengeA)
 
 # Element löschen
 mengeA.discard(&quot;Hallo&quot;)
 print(mengeA)

Ausgabe:
 {1, 2, 3, 'Welt', 'Hallo'}
 {1, 2, 3, 'Welt', 'Hallo'}
 {'Welt'}
 {'Welt'}
 {'Hallo'}
 {'Hallo'}
 {1, 2, 3, 'Hallo'}
 {1, 2, 3, 'Hallo'}
 False
 {67, 'Super', 'Welt', 'Hallo', 125}
 {67, 'Super', 'Welt', 125}

Es gibt schon seit &quot;ewigen&quot; Zeiten unveränderbare Mengen, die mittels &lt;code&gt;frozenset&lt;/code&gt; eingeleitet werden. Neu ab Python 3.15 ist dagegen das Pendant &lt;code&gt;frozendict&lt;/code&gt;, das unveränderbare Dictionaries darstellt.

 fdict = frozendict({&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot;})
 fset = frozenset({&quot;A&quot;, 1, &quot;A&quot;})
 
 print(fdict)
 print(fdict[&quot;vorname&quot;])
 print (fset) 
 
 try:
     fdict[&quot;vorname&quot;] = &quot;Max&quot;
     print(fdict[&quot;vorname&quot;])
 except TypeError as e:
     print(f&quot;Fehler: {e}&quot;)
 
 try:
     fset.add(&quot;B&quot;)
     print(fset)
 except AttributeError as e:
     print(f&quot;Fehler: {e}&quot;)

Ausgabe:
 frozendict({'vorname': 'Hugo', 'nachname': 'Meister'})
 Hugo
 frozenset({1, 'A'})
 Fehler: 'frozendict' object does not support item assignment
 Fehler: 'frozenset' object has no attribute 'add'

== List Comprehensions ==
Aus einer Eingabeliste soll eine Ausgabeliste erzeugt werden. Das kann folgendermaßen geschehen.

Mathematische Schreibweise: &lt;math&gt;lc = \{2x|x\in\ \mathbb{N}, 1\le x &lt; 11\}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11)]
 print(lc)

Ausgabe:
 [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Mathematische Schreibweise: &lt;math&gt;lc = \{2x | x \in \mathbb{N}, 1\le x &lt; 11, x \bmod 2 = 0 \}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11) if x%2 == 0]
 print(lc)

Ausgabe:
 [4, 8, 12, 16, 20]

Siehe auch {{W|List Comprehension}}.

== Set Comprehensions ==
Dies ist sehr ähnlich wie im vorigen Abschnitt beschrieben. Es wird aber keine Liste, sondern eine Menge erzeugt.

 sc = {x*2 for x in range(1,11)}
 print(sc)

Ausgabe:
 {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}

== Listen zusammenführen - zip() ==
 li1 = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]
 li2 = [1, 2, 3, 4]
 li3 = [5.5, 6.6, 7.7, 8.8]
 
 z = zip(li1, li2, li3)
 print(z)
 
 li4 = list(z)
 print(li4)

Ausgabe:
 &lt;zip object at 0x00000283B6C6AC80&gt;
 [('A', 1, 5.5), ('B', 2, 6.6), ('C', 3, 7.7), ('D', 4, 8.8)]

== Generatorausdruck ==
 g = (i*2 for i in range(1,11))
 print(g)
 t = tuple(g)
 print(t)
 print(t[1:3])

Ausgabe:
 &lt;generator object &lt;genexpr&gt; at 0x00000241D2A4A5A0&gt;
 (2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
 (4, 6)

== Slicing ==
slice ... Scheibe, Teil, in Scheiben schneiden

Beispiel: Zugriff auf Elemente eines geordneten sequentiellen Objekttyps (Liste, Tupel oder String):

 str1 = &quot;Hallo&quot;
 # Das erste Element wird mit dem Index 0 angesprochen
 # [start (inkl.) : stop (exkl.) : step (default=1)]
 str2 = str1[0:2]
 # Alternativ auch: str2 = str1[:2] 
 print(str2)
 
 tup1 = (0,1,2,3)
 # Das letzte Element hat auch den Index -1, das vorletzte den Index -2 usw.
 tup2 = tup1[-3:-1]
 print(tup2)
 
 lst1 = [[1,  5,  10, 20],
         [30, 40, 50, 60]]
 lst2 = lst1[1][1]
 print(lst2)
 
Ausgabe:
 Ha
 (1, 2)
 40

Beispiel:

 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2])
 print(x[-3]) 
 print(x)
 print(x[:])
 print(x[2:])
 print(x[:2])
 print(x[::-1])

Ausgabe:

 c
 c
 ('a', 'b', 'c', 'd', 'e')
 ('a', 'b', 'c', 'd', 'e')
 ('c', 'd', 'e')
 ('a', 'b')
 ('e', 'd', 'c', 'b', 'a')

Visualisierung:

    '''a'''     '''b'''     '''c'''     '''d'''     '''e'''
 +-----------------------------+
 |  0  |  1  |//'''2'''//|  3  |  4  |
 +-----------------------------+
 | -5  | -4  |/'''-3'''//| -2  | -1  | 
 +-----------------------------+
 |/////////////////////////////|
 +-----------------------------+
 |/////////////''':'''///////////////|
 +-----------------------------+
 |     |     |///////'''2:'''////////|
 +-----------------------------+
 |////''':2'''/////|     |     |     |
 +-----------------------------+
 |\\\\\&lt;--\\\\\'''::-1'''\\\\&lt;--\\\\\|
 +-----------------------------+

Beispiel:
 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2::2])
 print(x[2::-1])
 print(x[2:0:-1])

Ausgabe:

 ('c', 'e')
 ('c', 'b', 'a')
 ('c', 'b')

Hier sieht man sehr schön, dass beim letzen &lt;code&gt;print&lt;/code&gt;-Befehl die 0, die in diesem Fall den Buchstaben &quot;a&quot; repräsentiert, als letzer Wert nicht mehr dazugehört (wie weiter oben angedeutet ist der End- oder Stoppwert exklusiv). Will man den Buchstaben &quot;a&quot; dazunehmen, so ist die vorletzte Zeile die richtige.

Beispiel: Umdrehen von Strings

 str1 = &quot;Hallo&quot;
 str2 = str1[::-1]
 print(str2)

Ausgabe:
 ollaH

Mit zweidimensionalen Listen/Tupels wird das Ganze schon bedeutend komplexer.

Beispiel: Verkettetes Slicing

 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
     
 print(A[2::][::2])

Ausgabe:

 [['20', '21', '22', '23'], ['40', '41', '42', '43']]

Das erste Slicing erstellt folgenden Slice:

 [[&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
  [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
  [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]

Das zweite Slicing wird dann auf diesen Slice angewendet und ergibt das genannte Endergebnis. Will man Spalten statt Zeilen, so funktioniert dieser direkte Weg nicht. Man verwendet dann List Comprehensions oder die NumPy-Bibliothek. Diese Bibliothek erlaubt [[Ing_Mathematik:_Python#Zugriff_auf_Matrizenelemente|zweidimensionales Slicing]]. Sie wird erst später bei den Grafiken eingeführt. Deshalb wird hier dazu noch kein Beispiel gezeigt.

= Objektorientierte Programmierung =
{{Wikipedia|Objektorientierte Programmierung}}

* {{W|Klasse (Objektorientierung)|Klasse}} ... die Schablone oder der Bauplan, enthält Methoden und Attribute
* {{W|Objekt (Programmierung)|Objekt}} ... eine Klasseninstanz (die konkrete Ausprägung der Klasse)
* {{W|Attribut (Programmierung)|Attribute}} ... die Eigenschaften eines Objekts
* {{W|Methode (Programmierung)|Methoden}} ... die Aktionen (Operationen), die ein Objekt ausführen kann
* {{W|Vererbung (Programmierung)|Vererbung}} ... neue Klassen (Subklassen, Unterklassen, abgeleitete Klassen) aus vorhandenen Klassen (Superklassen, Oberklassen, Basisklassen, Elternklassen) ableiten. Ermöglicht den Aufbau von Klassenhierarchien. Die Subklasse &quot;erbt&quot; Attribute und Methoden von der Superklasse. Python unterstützt (so wie C++, aber im Gegensatz zu Java) Mehrfachvererbung.

== UML ==
* {{W|Unified Modeling Language|UML}} ... '''U'''nified '''M'''odeling '''L'''anguage, eine Modellierungssprache. Die UML enthält zahlreiche Diagrammarten, um Programme zu modellieren. Im Nachfolgenden wird nur das {{W|Klassendiagramm}} verwendet.

[[File:UmlCd Klasse-3.svg|300px]]

* {{W|Sichtbarkeit (Programmierung)|Sichtbarkeit}}:
** + ... public (öffentlich)
** - ... private
** # ... protected 

* {{W|Attribut_(UML)#Attribute_für_Instanzen_und_für_Klassen|Klassenattribute}} (statische Attribute): Werden nur einmal pro Klasse angelegt. Im Klassendiagramm werden sie unterstrichen.

[[File:Attribute-3.png|200px]]

* Vererbung:

&lt;gallery&gt;
InheritancePgmUML.svg | Abgeleitete Klasse erbt von Basisklasse (Einfachvererbung)
Diamond inheritance.svg | D erbt von B und C (Mehrfachvererbung). B und C erben von A (Einfachvererbung)
&lt;/gallery&gt;

Für weitergehende Betrachtungen zur UML wird auf Spezialliteratur verwiesen, z.B.:
* Seidl et al.: UML@Classroom. dpunkt, 2012, ISBN 978-3-89864-776-2
* Rupp et al.: UML 2 glasklar. Hanser, 4. Aufl., 2012, ISBN 978-3-446-43057-0

== Eine einfache Klasse ==

[[Datei:PythonIng_uml1.svg | 200px]]

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
 
 fahr = Fahrzeug(150, 90)
 
 print(fahr.convertGeschw())
 
Ausgabe:
 41.666666666666664

Die Klasse Fahrzeug wird durch das class-Schlüsselwort eingeleitet. raeder ist ein Klassenattribut und public. __init__ wird bei der Objekterzeugung automatisch aufgerufen (ist der sogenannte Konstruktor). Man achte darauf, dass diese Methode immer mit zwei Unterstrichen eingeleitet und abgeschlossen wird. Instanzattributen wird das Wort self vorangestellt. Wir sehen uns z.B. das Attribut self.__geschwind an. Auch hier werden zwei Unterstriche verwendet. Das bedeutet, dass dieses Attribut strikt/stark private ist. Wird nur ein Unterstrich verwendet, so deutet dies auf schwach/weakly private hin. Letzteres wird in Python deutlich häufiger verwendet. Bei den Methoden wird immer self als erster Parameter angegeben. Beim Aufruf der entsprechenden Funktion wird das self aber nicht berücksichtigt.

Besonderheiten bei stark und schwach private:
* '''stark private''':
** zwei führende Unterstriche
** Name Mangling: Name wird zu &lt;code&gt;_Klassenname__variablenname&lt;/code&gt;
** Schutz vor Namenskollisionen bei Vererbung
** am Ende des Namens dürfen keine zwei Unterstriche verwendet werden. Das wären dann Magic Methods oder Dunder-Methods (z.B. __init__). Diese sind public.

* '''schwach private''':
** ein führender Unterstrich
** Name bleibt gleich
** ist nur ein Hinweis an die Programmierer, kein starker Schutz
** &lt;code&gt;from modul import *&lt;/code&gt;: Objekte mit einem führenden Unterstrich werden standardmäßig nicht importiert
** Standard für die Kapselung bei Python. Schätzung: Weit mehr als 80% der nicht-öffentlichen Attribute/Methoden werden als schwach private deklariert. Weniger als 5-10% als stark private (Quelle: Google KI)

== Klassen importieren ==
Häufig ist es sinnvoll und übersichtlicher Klassen in eigenen Dateien zu speichern. Das sind dann eigene Module. Abgespeichert werden Sie mit der Endung py, wie bisher auch praktiziert. Aufgerufen werden Sie mit der import-Anweisung. Dann ist aber nur der Dateiname ohne Endung py zu verwenden. Klarer wird das mit einem Beispiel.

Datei c:\tmp\fahrzeug.py

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6

Datei c:\tmp\test1.py

 import fahrzeug
 fahr = fahrzeug.Fahrzeug(150, 90)
 print(fahr.convertGeschw())

Ausgabe:
 41.666666666666664

Die üblichen import-Anweisungen lauten wie folgt:
{| {{prettytable}}
! import-Befehl
! Instanz
|-
| import xyz      || xyz.Klasse
|-
| import xyz as x || x.Klasse
|-
| from xyz import Klasse || Klasse
|-
| from xyz import * || Klasse 
|}

Der Vorteil der ersten beiden import-Anweisungen ist, dass es kaum zu Namenskollisionen kommen kann. Dafür hat man bei den letzten beiden Varianten weniger Tipparbeit.

== Vererbung ==
=== Einfachvererbung ===

[[Datei:PythonIng_uml2.svg | 200px]]

Datei fahrzeug.py:
 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
        
     def setLeistung(self, leistung):
         self.__leistung = leistung
        
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
        
 class Luftfahrzeug(Fahrzeug):
     def __init__(self, geschwindigkeit, leistung, fluegel):
         super().__init__(geschwindigkeit, leistung)
         self.__flueg = fluegel
     
     def getFlueg(self):
         return self.__flueg

Datei test1.py:
 import fahrzeug
 fahr = fahrzeug.Luftfahrzeug(150, 90, 4)
 print(fahr.getFlueg())

Ausgabe:
 4

=== Mehrfachvererbung ===
Mit Python ist auch Mehrfachvererbung möglich, z.B.:

 class A:
     def _printA(self):
         print(&quot;Klasse A&quot;)
 
 class B:
     def _printB(self):
         print(&quot;Klasse B&quot;)
 
 class C(A,B):
     def __init__(self):
         self._printA()
         self._printB()
 
 c = C()

Ausgabe:

 Klasse A
 Klasse B

Die Klasse C erbt von A und B. In UML sieht das in etwa so aus:

 +-----------------------------+   +-------------------------+
 |            A                |   |          B              |
 +-----------------------------+   +-------------------------+
 |                             |   |                         |
 +-----------------------------+   +-------------------------+
 | # printA()                  |   | # printB()              |
 +-----------------------------+   +-------------------------+
                           .              .
                          / \            / \
                          ---            ---
                           |              |
                           |              |
                        +---------------------+
                        |          C          |
                        +---------------------+
                        |                     |
                        +---------------------+
                        |                     |
                        +---------------------+

&lt;code&gt;printA()&lt;/code&gt; und &lt;code&gt;printB()&lt;/code&gt; sind schwach private (in UML als &lt;code&gt;protected&lt;/code&gt; mit einem # dargestellt). Es ist aber zu beachten, dass schwach private nur Konvention ist. Praktisch könnte man auch von außerhalb auf diese Methoden zugreifen. Das soll man aber nicht tun, und das wird in Python durch einen Unterstrich angedeutet.

== Statische Attribute, statische Methoden und Klassenmethoden ==
Beispiel:

 class Math:
     pi = 3.14159265
     cnt = 0
     
     @staticmethod
     def expo():
         return 2.71828183
    
     @classmethod    
     def counterPlus(cls):
         cls.cnt += 1
        
 print(Math.pi)
 print(Math.expo())
 
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)

Ausgabe:

 3.14159265
 2.71828183
 1
 2
 3

Statische Attribute und Methoden, bzw. Klassenmethoden, sind direkt einer Klasse zugeordnet und nicht einem Objekt. Der Unterschied zwischen statischen Methoden und Klassenmethoden ist, dass statische Methoden nicht auf Klassenattribute (bzw. statische Attribute) zugreifen können, Klassenmethoden aber schon. &lt;code&gt;pi&lt;/code&gt; und &lt;code&gt;cnt&lt;/code&gt; sind statische Attribute. &lt;code&gt;expo()&lt;/code&gt; ist eine statische Methode. &lt;code&gt;counterPlus(cls)&lt;/code&gt; ist eine Klassenmethode. Die Bezeichnung des Parameters als &lt;code&gt;cls&lt;/code&gt; ist reine Konvention, man sollte sich aber daran halten. &lt;code&gt;@staticmethod&lt;/code&gt; und &lt;code&gt;@classmethod&lt;/code&gt; nennt man auch Dekoratoren.

= Grafiken zeichnen =
Für das Zeichnen von Grafiken wird hier das Modul &lt;code&gt;matplotlib&lt;/code&gt; verwendet. &lt;code&gt;matplotlib&lt;/code&gt; ist ein externes Modul und muss vor der ersten Verwendung installiert werden. Das geht so:

# Starten Sie ein Terminal (bei Windows die Eingabeaufforderung).
# Führen Sie darin folgenden Befehl aus &lt;code&gt;c:\devel\Python\Scripts\pip.exe install matplotlib&lt;/code&gt;

pip ist übrigens der Paketmanager von Python ({{W|Pip_(Python)}}). 

Optimalerweise installieren wir auch gleich das Modul &lt;code&gt;numpy&lt;/code&gt; (Numerical Python). Wir werden es im Folgenden oft benötigen (nicht nur bei den Grafiken). Das funktioniert vom Prinzip her genauso, wie für &lt;code&gt;matplotlib&lt;/code&gt; gezeigt.

&lt;small&gt;Verwenden Sie Spyder, so sind diese Schritte nicht nötig. Spyder inkludiert diese Pakete standardmäßig. Unter openSUSE Tumbleweed lassen sich diese Pakete mittels YaST oder zypper installieren.&lt;/small&gt;

== 2D ==
=== Graph einer Funktion ===
Es soll die cosh-Funktion im Intervall &lt;math&gt;x\in[-3,3]&lt;/math&gt; gezeichnet werden. Der Programmcode lautet in der einfachsten Form:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x)
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:PythonIng_cosh1.jpg]]

Der Code ist quasi selbsterklärend. Das Untermodul pyplot des matplotlib-Moduls und das numpy-Modul werden importiert. x läuft von -3 bis +3. y wird für jeden x-Wert per Formel ausgerechnet. &quot;plt.plot()&quot; ist der Zeichenbefehl. &quot;plt.show&quot; ist notwendig, um das Fenster mit der Grafik anzuzeigen.
Die Schrittweite 0.1 wurde so gewählt, um einen ausreichend glatten Verlauf des Graphen zu gewährleisten. Das ist immer ein Kompromiss zwischen Berechnungszeit und Ansehnlichkeit. Testen Sie einfach ein paar verschiedene Werte, um ein Gefühl dafür zu zu bekommen. &quot;plt.grid()&quot; zeichnet ein Gitter in die Grafik (kann auch weggelassen werden).
Die Bezeichnungen plt und np könnten auch anders gewählt werden. Es ist aber Konvention, diese so wie hier gezeigt zu wählen. Die &quot;arange&quot;-Funktion aus der NumPy-Bibliothek wird später ein bisschen genauer behandelt (siehe [[Ing_Mathematik:_Python#Zahlenfolgen|Zahlenfolgen]]).  

&lt;small&gt;Mit der im obigen Bild gezeigten Menüleiste kann die dargestellte Grafik nachträglich noch geändert werden (Zoom, Pan, Achsenparameter, Kurvenparameter etc.). Natürlich kann man das alles auch direkt programmieren. Wie das funktioniert wird ansatzweise etwas später gezeigt.&lt;/small&gt;

Ein etwas komplexeres Beispiel ist Folgendes:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x) + 2**x
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:
[[Datei:PythonIng_cosh4.png]]

Man beachte, dass im Gegensatz zu Octave und Julia der ominöse Punkt (.) bei 2**x mit Python nicht benötigt wird. Das macht das Programmiererleben etwas einfacher.

Die Farbe des Graphen kann man über den &lt;code&gt;color&lt;/code&gt;-Schalter einstellen, z.B. auf rot setzen:
 plt.plot(x, y, color=&quot;red&quot;)

Das ist nur eine Möglichkeit, es gibt auch andere, z.B. mittels
* hexadezimaler Zahl, z.B. &lt;code&gt;color=&quot;#ff0000&quot;&lt;/code&gt;
* Kurzform, z.B. &lt;code&gt;&quot;r&quot;&lt;/code&gt;

Statt &lt;code&gt;color&lt;/code&gt; kann auch die Kurzform &lt;code&gt;c&lt;/code&gt; verwendet werden.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie diese &quot;Farbspielereien&quot; am Computer aus.

=== Graphen mehrerer Funktionen und weiteres ===
==== Mehrere Funktionen in einen Plot zeichnen ==== 
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh2.png]]

Um die Linienstile etwas individueller zu gestalten, ist folgender Programmcode gedacht: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;, lw=3, ls=&quot;--&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh3.png]]

Einige weitere Bespiele zu &lt;code&gt;ls&lt;/code&gt;&lt;/code&gt;:
* - ... durchgezogene Linie
* -. ... Strichpunkt-Linie
* dashed ... gestrichelte Linie 

==== Marker ====
Desweiteren kann man Marker verwenden.

Beispiel:

 import matplotlib.pyplot as plt
 
 plt.plot(10, 10, &quot;ob&quot;, markersize=30)
 plt.plot(20,20, &quot;.r&quot;)
 plt.plot(30,30, &quot;Dg&quot;, ms=15)
 plt.plot(40, 40, &quot;ok&quot;, ms=20, mec=&quot;#FF5733&quot;, mew=3)
 plt.plot(50, 50, &quot;vk&quot;, ms=20, mec=&quot;yellow&quot;, mew=3)
 plt.grid()
 plt.show()


Das erste Zeichen im String nach den Koordinaten im plot-Befehl symbolisiert die Form (z.B. o für einen Kreis). Das zweite Zeichen steht für die Farbe (z.B. b für blue). &lt;code&gt;markersize&lt;/code&gt; oder &lt;code&gt;ms&lt;/code&gt; setzt die Größe des Markers.

Ausgabe:

[[Bild:PythonIng_formatpara1.svg|200px]]

Einige weitere Marker:
* * ... Stern
* + ... Plus
* h oder H ... Sechseck

Man kann mit den Parametern 
* &lt;code&gt;markeredgecolor&lt;/code&gt; oder kurz &lt;code&gt;mec&lt;/code&gt; die Farbe des Markerrandes
* &lt;code&gt;markeredgewidth&lt;/code&gt; oder kurz &lt;code&gt;mew&lt;/code&gt; die Dicke des Randes
* &lt;code&gt;markerfacecolor&lt;/code&gt; oder kurz &lt;code&gt;mfc&lt;/code&gt; die Innenfarbe des Markers
bestimmen.

=== Funktion in Parameterdarstellung ===
Es soll die archimedische Spirale &lt;math&gt;x = t \cos(t), y = t  \sin(t)&lt;/math&gt; im Intervall &lt;math&gt;[0, 6\pi[&lt;/math&gt; gezeichnet werden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
  
 plt.show()

[[Datei:PythonIng_spirale1.png]]

Diese Darstellung erscheint verzerrt. Will man gleiche Achsenskalierungen, so kann man den plt.axis()-Befehl verwenden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
 plt.axis(&quot;equal&quot;)
 
 plt.show()
 
[[Datei:PythonIng_spirale2.png]]

=== Funktion in Polardarstellung ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 fig = plt.figure()
 ax = fig.add_subplot(projection=&quot;polar&quot;)
 r = np.arange(0, 1, 0.01)
 theta = r**3
 line = ax.plot(theta, r)
 
 plt.show()

[[Datei:PythonIng_polar1.png]]

=== Logarithmische Achsenskalierung ===
==== Semilog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.semilogy()
 plt.show()

Ausgabe:

[[Datei:PythonIng_semilog1.png]]

==== LogLog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.loglog()
 plt.show()

[[Datei:PythonIng_loglog1.png]]

=== Gefüllte Fläche ===
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.arange(0, 3, 0.1)
 
 y1 = 3*x - 1
 y2 = x**2
 
 plt.plot(x, y1, x, y2, color='black')
 plt.fill_between(x, y1, y2, where=y1&gt;=y2)
 
 plt.show()

[[Datei:PythonIng_gefuellt.png]]

=== Linien, Pfeile, Rechtecke, Kreise und Texte ===
 import matplotlib as mpl
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 r = mpl.patches.Rectangle((0, 0), 3, 3, angle=30, fill=False)
 c = mpl.patches.Circle((4, 4), 2, fill=False)
 
 ax.add_patch(r)
 ax.add_patch(c)
 ax.plot([-2, 7], [-2, 0], color=&quot;black&quot;)
 ax.arrow(0, 7, 5, 0, length_includes_head=True, head_width=0.5, head_length=1.5,
          color=&quot;black&quot;)
 
 ax.set_aspect(&quot;equal&quot;)
 
 plt.axis([-3, 8, -3, 8])
 plt.show() 

[[Datei:PythonIng_linien_pfeile_etc.png]]

Text kann mit &lt;code&gt;ax.text(x, y, &quot;Text&quot;)&lt;/code&gt; hinzugefügt werden, bspw.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 ax.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

Oder einfacher auch ohne &lt;code&gt;subplots&lt;/code&gt;

 import matplotlib.pyplot as plt
 
 plt.text(0.1, 0.1, &quot;Hallo&quot;)
 plt.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

[[Datei:PythonIng_text1.png]]

Auch Sonderzeichen (griechische Buchstaben etc.) können verwendet werden (siehe dazu auch [https://matplotlib.org/stable/users/explain/text/mathtext.html]).

 import matplotlib.pyplot as plt
 
 plt.text(.3, .5,
          r'$\Omega\ \psi\ \oint\ \nabla\ \dot a\ \frac{a}{b}\ a_b$',
          size=&quot;20&quot;)
 plt.show() 

[[Datei:PythonIng_text20.svg]]

Jetzt wird noch gezeigt, wofür &lt;code&gt;subplots&lt;/code&gt; sinnvoll eingesetzt werden können.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(0.1, 0.1, &quot;Hallo&quot;)
 ax[1].text(0.1, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
            rotation=30.0)
 
 plt.show()

[[Datei:PythonIng_text2.png]]

=== Anmerkungen hinzufügen ===
Anmerkungen (engl. annotations) lassen sich mit matplotlib einfach hinzufügen. Unter Anmerkung wird hier ein Pfeil mit Text verstanden.

Beispiel:

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 ax.plot([1,10], [1,10])
 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
             arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0))
 plt.show()

Ausgabe:

[[Datei: PythonIng_ann1.svg|400px]]

&lt;code&gt;shrink&lt;/code&gt; verkürzt den Pfeil. Sinnvoll sind beim obigen Beispiel Werte irgendwo zwischen 0.0 und 0.3.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie verschiedene Pfeillängen aus. 

Die Schriftgröße verändern können Sie übrigens mit &lt;code&gt;fontsize&lt;/code&gt; oder &lt;code&gt;size&lt;/code&gt;, z.B.

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0), fontsize=25)

Eine andere Schreibweise für Dictionaries, die wir weiter oben schon kennengelernt haben, die wir aber nochmals explizit aufschreiben wollen, ist

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops={&quot;facecolor&quot;:&quot;red&quot;, &quot;shrink&quot;:0.0})

=== Figure, Axes etc.===
[[Bild:PythonIng_figure33.svg|350px]]

* fig (figure) ... das übergeordnete Fenster
* ax (axes) ... &quot;Plot&quot;, das eigentliche Zeichenfenster
* axis ... die Koordinatenachsen
* spine ... Begrenzungslinien des Zeichenfensters
* tick ... Markierung an den Achsen des Zeichenfensters

Beispiel (eine figure mit 6 axes, ax-Titel, y-axis-Titel):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=3, ncols=2)
 
 ax[0][0].text(0.1, 0.5, &quot;11&quot;)
 ax[0][1].text(0.1, 0.5, &quot;12&quot;)
 ax[1][0].text(0.1, 0.5, &quot;21&quot;)
 ax[1][1].text(0.1, 0.5, &quot;22&quot;)
 ax[2][0].text(0.1, 0.5, &quot;31&quot;)
 ax[2][1].text(0.1, 0.5, &quot;32&quot;)
 
 ax[0][0].set(ylabel=&quot;y-label&quot;, title=&quot;axes 1&quot;)
 
 plt.show()

[[Bild:PythonIng_figure34.png|350px]]

Beispiel (Achsenbereiche setzen):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 
 ax[0].axis((-1, 10, 1, 12))
 
 plt.show()

[[Bild:PythonIng_figure35.svg|350px]]

Beispiel (Gitter einschalten): 

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 ax[0].axis((-5, 10, 1, 12))
 ax[0].minorticks_on()
 ax[0].grid(which='minor')
 ax[1].grid(which='major')
 plt.show()

[[Bild:PythonIng_figure36.svg|350px]]

Beispiel (ticks setzen)

 import matplotlib.pyplot as plt
 import matplotlib.ticker as tick
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 pos = [0, .2, .5]
 lab = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
 
 ax.xaxis.set_major_locator(tick.FixedLocator(pos))
 ax.xaxis.set_major_formatter(tick.FixedFormatter(lab))
 
 plt.show()

[[Bild:PythonIng_figure37.svg|350px]]

Beispiel (Achsenkreuz beliebig setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 ax.spines['top'].set_color('none')
 ax.spines['right'].set_color('none')
 ax.spines['bottom'].set_position(('data', 0.3))
 ax.spines['left'].set_position(('data', 0.5))
 
 plt.show()

[[Bild:PythonIng_figure38.svg|350px]]

Beispiel (Inset):

 import matplotlib.pyplot as plt
 
 # Hauptplot erstellen
 fig, ax = plt.subplots()
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 
 # Inset hinzu:
 axin = ax.inset_axes([0.4, 0.4, 0.3, 0.3])
 axin.text(0, 0, &quot;Servus&quot;)
 axin.plot()
 
 plt.show()

[[Bild:PythonIng_figure40.svg|350px]]

Beispiel (Hintergrundfarben setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.set_facecolor(&quot;green&quot;)
 fig.set_facecolor(&quot;yellow&quot;)
 
 plt.plot([1, 3], [6, 8])
 plt.show()

[[Bild:PythonIng_figure39.svg|300px]]

=== GridSpec ===
Mit figures und axes lassen sich schon jede Menge an Grafikdetails einstellen. GridSpec ist dann der Turbo oder Raketenantrieb den matplotlib eingebaut hat. Naja, vielleicht ist das etwas übertrieben, aber GridSpec ist sozusagen ein flexibler Layout-Manager. Bisher haben wir immer gleich große axes gezeichnet. Mit GridSpec können wir Subplots über mehrere Zeilen und Spalten ziehen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 gs = fig.add_gridspec(3, 3)
 
 ax1 = fig.add_subplot(gs[0, :])
 ax1.set_title(&quot;Bereich 1: gs[0, :]&quot;)
 
 ax2 = fig.add_subplot(gs[1:, 0])
 ax2.set_title(&quot;Bereich 2: gs[1:, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 1:])
 ax3.set_title(&quot;Bereich 3: gs[1, 1:]&quot;)
 
 ax4 = fig.add_subplot(gs[2, 1:])
 ax4.set_title(&quot;Bereich 4: gs[2, 1:]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec1.svg|350px]]

Erklärung zu &lt;code&gt;(gs[zeile, spalte])&lt;/code&gt;: Slicing; damit legen Sie fest, welche Zellen ein Subplot belegt. Achtung! Die Indizes beginnen bei 0 und nicht bei 1 (d.h., die erste Zeile/Spalte hat den Index 0)
* : ... alle 
* 1: ... 1 bis Ende
* etc.

&lt;code&gt;constrained_layout=True&lt;/code&gt; sorgt dafür, dass sich die Subplots nicht überlappen.

Aber auch die Spaltenbreiten und Zeilenhöhen lassen sich anpassen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 
 # Verhältnis erste zu zweite Zeile = 1.5:1
 # Verhältnis erste zu zweite Spalte  = 1:4
 gs = fig.add_gridspec(2, 2, figure=fig, height_ratios=[1.5, 1], width_ratios=[1, 4])
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax1.set_title(&quot;Bereich 1: gs[0, 0]&quot;)
 
 ax2 = fig.add_subplot(gs[0, 1])
 ax2.set_title(&quot;Bereich 2: gs[0, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 0])
 ax3.set_title(&quot;Bereich 3: gs[1, 0]&quot;)
 
 ax4 = fig.add_subplot(gs[1, 1:])
 ax4.set_title(&quot;Bereich 4: gs[1, 1]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec2.svg|350px]]

Auch die Ränder lassen sich einstellen.

Beispiel 1:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.1, right=0.9, bottom=0.1,
                        top=0.9, wspace=0.2, hspace=0.2)
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec3.svg|300px]]

* hspace ... height space, vertikaler Abstand zwischen den Zeilen
* wspace ... width space, horizontaler Abstand zwischen den Spalten

Und im Vergleich dazu Beispiel 2:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.3, right=0.7, bottom=0.3, 
                        top=0.7, wspace=0.3, hspace=0.3) 
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec4.svg|300px]]

Es gibt noch einige weitere Details, die sich mit GridSpec variieren lassen (z.B. SubGridSpec ... verschachtelte Grid-Layouts). Aber wir belassen es vorerst dabei. Das bisher Gezeigte sollte für die meisten Probleme ausreichend sein.

=== Aufgaben ===
* Zeichnen Sie die Strophoide &lt;math&gt;x = \frac{a(t^2-1)}{t^2+1}, y = \frac{at(t^2-1)}{t^2+1}, a = 2, -3 \leq t \leq 3&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_strophoide.jpg|300px|center]]

* Zeichnen Sie die verschlungene Hypozykloide &lt;math&gt;x = (R-r)\cos t + c\cos\frac{R-r}{r}t, y = (R-r)\sin t - c\sin\frac{R-r}{r}t, c = 3, r = 2, R = 6, -15 \leq t \leq 15&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_hypozykloide.jpg|300px|center]]

* Testen Sie bei den obigen Übungsaufgaben verschiedene Linienstile und Farben. Farben können mit dem plt.plot()-Parameter color gewählt werden.

* Testen Sie bei den obigen Übungsaufgaben verschiedene Werte für a, c, r und R.

* Zeichnen Sie folgendes Bild (die Achsenbeschriftungen positionieren Sie z.B. mit den Befehlen &lt;code&gt;ax.set_xlabel(&quot;x&quot;, loc=&quot;right&quot;); ax.set_ylabel(&quot;y&quot;, loc=&quot;top&quot;)&lt;/code&gt;):

[[Bild:PythonIng_aufgabe24.svg|400px|center]] 

* Zeichnen Sie mit Python, matplotlib und NumPy folgendes Bild:

[[Bild:PythonIng_figure41.svg|400px|center]]

* Zeichnen Sie mit GridSpec ein Layout, das in etwa wie folgendes aussieht (&lt;code&gt;height_ratios=[1, 2], width_ratios=[2, 1]&lt;/code&gt;):

[[Bild:PythonIng_aufgabe23.svg|300px|center]]

== 3D ==
=== Räumliche Kurven ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0, 6*np.pi, 0.1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 z = t
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot(x, y, z)
 
 plt.show()

[[Datei:PythonIng_raumkurve1.png]]

=== Flächen ===
 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche1.png]]

Das Ganze in Netzdarstellung läßt sich so programmieren: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.5)
 y = np.arange(0, 10, 0.5)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_wireframe(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche2.png]]

Ein etwas komplexeres Beispiel:

 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0.1, 10, 0.1)
 y = np.arange(0.1, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z1 = np.sin(x) + 3 * np.cos(y)
 z2 = np.sin(x) + np.log(y)
 z3 = x + np.cos(y)
 z4 = x**2 - y
  
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;}, nrows=2, ncols=2)
 
 ax[0][0].plot_surface(x, y, z1)
 ax[0][1].plot_surface(x, y, z2)
 ax[1][0].plot_surface(x, y, z3)
 ax[1][1].plot_surface(x, y, z4)
 
 plt.show()

[[Datei:PythonIng_subplot1.png]]

Man beachte, dass man die Unterbilder im Bild nach dem Ausführen des Scripts z.B. mit der mittleren Maustaste einzeln drehen, oder über die Einträge in der Menüzeile einzeln bearbeiten kann. Mit ein paar Zeilen Programmtext lässt sich also eine Menge an Funktionalität generieren.

Die Farbgebung lässt sich über &lt;code&gt;colormaps&lt;/code&gt; variieren.

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm)
 
 plt.show()

[[Datei:PythonIng_colormap1.png]]

Es gibt eine Menge an Colormaps, z.B. &lt;code&gt;plasma, Greys, Dark2, ocean&lt;/code&gt;. Zwecks detaillierterer Infos siehe die matplotlib-Dokumentation. &lt;small&gt;Verwendet man die IDE namens IDLE, so gibt es dort auch die automatische Codevervollständigung. D.h. es werden alle Möglichkeiten (in unserem Fall nach dem Eintippen von &lt;code&gt;cm.&lt;/code&gt; alle verfügbaren Colormaps) angezeigt.&lt;/small&gt;

Die &quot;edgecolor&quot; und Linienbreite können auch frei gewählt werden:

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm, edgecolor=&quot;black&quot;, linewidth=1.0)
 
 plt.show()

[[Datei:PythonIng_colormap2.png]]

=== Höhenlinien ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 ax.contour(x, y, z)
 
 plt.show()

[[Datei:PythonIng_höhenlinien1.png|400px]]

Etwas abgewandelt sieht das so aus: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contour(x, y, z)
 ax.clabel(hl, inline = True)
 
 plt.show()

[[Datei:PythonIng_höhenlinien2.png|400px]]

Und noch eine Variante (mit einem Farbbalken) sei gezeigt. 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contourf(x, y, z)
 fig.colorbar(hl) 
 
 plt.show()

[[Datei:PythonIng_höhenlinien5.svg|400px]]

=== Aufgaben ===
* Zeichnen Sie die räumliche Kurve &lt;math&gt;x = 2 \cdot \cosh(t)&lt;/math&gt;, &lt;math&gt;y = 5 \cdot \sin(t)&lt;/math&gt;, &lt;math&gt; z = t^{2} - t&lt;/math&gt;, &lt;math&gt;0 \leq t \leq 3\pi&lt;/math&gt;.
* Zeichnen Sie die Fläche &lt;math&gt;z = \log(x) + \cos(y)&lt;/math&gt;.

== Animationen und fortgeschrittenes 3D ==
=== Mit matplotlib ===
Auch mit matplotlib sind Animationen möglich. Das ist ein bisschen komplizierter und wird deshalb hier nur mit einem sehr einfachen Beispiel dargestellt (bei Interesse siehe z.B. auch das [https://matplotlib.org/stable/users/explain/animations/animations.html#animations Animations using Matplotlib-Tutorial]).

 import matplotlib.pyplot as plt
 import matplotlib.animation as ani
 import matplotlib
 import numpy as np
 
 def update(frame):
     line.set_xdata(x[:frame])
     line.set_ydata(y[:frame])
     return (line)
 
 fig, ax = plt.subplots()
 
 x = np.arange(0, 10, .1)
 y = np.sin(x)
 
 line, = ax.plot(x[0], y[0])
 ax.set(xlim=[0, 10], ylim=[-1, 1])
 
 a = ani.FuncAnimation(fig=fig, func=update, frames=100, interval=20)
 plt.show()
 
 # Speichere die Animation in einem animierten GIF (optional)
 a.save(filename=&quot;c:/tmp/PythonIng_anim5.gif&quot;, writer=&quot;pillow&quot;)

[[Datei:PythonIng_anim5.gif]]

Es wird eine Sinuskurve auf den Bildschirm gezeichnet. In der letzten Zeile wird diese Animation in ein animiertes GIF gespeichert. Das ist natürlich optional und kann auch weggelassen werden.

=== Mit VPython ===
Aber auch mit dem Modul VPython lassen sich einfache 3D-Animationen erstellen. VPython ist ein externes Modul, das vorab installiert werden muss. Unter openSUSE Tumbleweed gibt es dzt. kein entsprechendes rpm-Paket. Die übliche Methode der Installation mittels YaST oder zypper ist somit nicht möglich. Auch eine direkte Verwendung von pip führt nur zu einer Fehlermeldung (&lt;code&gt;error: externally-managed-environment&lt;/code&gt;). Es empfiehlt sich dort folgende Vorgehensweise:
# Erstelle zuerst eine virtuelle Umgebung, z.B.: &lt;code&gt;python3.11 -m venv ~/tmp/venv1&lt;/code&gt;
# Wechsle das Verzeichnis: &lt;code&gt;cd ~/tmp/venv1/bin&lt;/code&gt;
# Installiere das entsprechende Paket: &lt;code&gt;./pip install vpython&lt;/code&gt;
# Führe das entsprechende Skript aus: &lt;code&gt;./python ~/tmp/test1.py&lt;/code&gt;

Aktuell (März 2026) ist dieses Programmpaket lt. der [https://vpython.org/presentation2018/install.html VPython-Homepage] nur für die Python-Versionen 3.8 bis 3.12 verfügbar.

Ein Beispiel zu einer einfachen Animation wird nachfolgend geliefert.

 from vpython import *
 
 scene.width = 1200
 scene.height = 600
 scene.center = vector(20,0,0)
 scene.background = color.white
 
 cylinder(pos=vector(0,0,0), axis=vector(20,0,0), radius=5, 
         color=color.blue)
 cone(pos=vector(0,0,0), axis=vector(-10,0,0), radius=5, 
         color=color.blue)
 helix(pos=vector(20,0,0), axis=vector(40,0,0), radius=2, 
         coils=10, thickness=0.5, color=color.blue)
 
 ball = sphere(pos=vector(20,0,0), color = color.green, radius = 1)
 ball.p = vector(0.15, 0, 0)
 
 toc = True
 
 while True:
     rate(200)
     if(ball.pos.x &lt;= 60 and toc == True):
         ball.pos += ball.p
     else:
         toc = False
         ball.pos -= ball.p
         if(ball.pos.x &lt;= 20 and toc == False):
             toc = True

[[Datei:PythonIng_vpython_anim.JPG]]

Idealerweise öffnet sich beim Ausführen des Scripts ein Browserfenster. Darin wird die programmierte Animation gezeigt (siehe auch den obigen Screenshot). Eine Größenänderung können Sie mit der mittleren Maustaste initiieren. Die Szenerie drehen können Sie mit der rechten Maustaste.

=== Mit build123d ===
Hiermit lassen sich einfach 3D-Modelle für CAD-Systeme erstellen. [https://build123d.readthedocs.io/en/latest/ build123d] ist ein externes Modul und muss vorab, wie schon für mehrere andere Module gezeigt, installiert werden (pip, venv etc.).

Beispielcode:

 from build123d import *
 
 # Bauteil
 with BuildPart() as bauteil: 
     # Zylinder erstellen
     Cylinder(100, 60)
        
     # Bohrung
     with BuildSketch(bauteil.faces().sort_by(Axis.Z)[-1]) as loch:
         Circle(radius=10)
     # negativ extrudieren
     extrude(amount=-60, mode=Mode.SUBTRACT)
     
     # Dem Bauteil z.B. die Farbe rot zuweisen
     # bauteil.part.color = Color(&quot;red&quot;, alpha=1.0)
 
     # Fertiges Modell exportieren
     export_step(bauteil.part, &quot;bauteil.step&quot;)

Ausgabe ({{W|Standard for the exchange of product model data | STEP}}-Datei, z.B. in {{W|FreeCAD}} importiert, Screenshot):

[[Datei:PythonIng_build123d.jpg | 300px]]

FreeCAD ist ein freies 3D-CAD-System. Die [[Ing_Mathematik:_Python#FreeCAD | Makroprogrammierung]] in diesem System wird später noch gezeigt. STEP steht für &quot;'''St'''andard for the '''e'''xchange of '''p'''roduct model data&quot; und ist ein Datenaustauschformat.

=== Mit VTK ===
Komplexer, aber auch mächtiger als VPython ist die Verwendung von VTK ('''V'''isualization '''T'''ool'''k'''it). Genauer gesagt des Python-Wrappers von VTK. Dieses externe Python-Modul muss vorab installiert werden (z.B. mittels YaST, pip oder in eine virtuelle Umgebung). VTK ist eine Softwarebibliothek zur 3D-Visualisierung und wurde ursprünglich in C++ geschrieben. Verbreitet eingesetzt wird diese Bibliothek in der Wissenschaft und Forschung, z.B. 
* in der medizinischen Bildgebung
* für Strömungssimulationen
* für Klimadaten

VTK funktioniert nach dem {{W|Grafikpipeline|Pipeline-Prinzip}}:

 Source (Quellen) -&gt;  Filter -&gt; Mapper (Senken) -&gt; Actor/Renderer

Daten fließen von den Quellen zu den Senken.

Als einfaches Beispiel wird die Darstellung eines Zylinders gezeigt, der mit den Maustasten gedreht oder in der Größe geändert werden kann:

 import vtk
 
 # Zylinder erzeugen
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 # Geometrie in darstellbare Daten umwandeln
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 # Objekt in der Szene
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 # Szene verwalten
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 # Render-Fenster
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 # Maus/Tastatur-Steuerung
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 # Starten
 render_window.Render()
 interactor.Start()

Ausgabe:

[[Datei:PythonIng_VTK_1.png]]

Gleiches Beispiel wie oben, aber mit einer Animationssequenz:

 import vtk
 import time
 
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     render_window.Render()
     time.sleep(0.01)

Das Grafikfenster schließt sich nach Ablauf der Schleife. Das Fenster bleibt geöffnet, wenn Sie am Programmende folgenden Befehl hinschreiben

 interactor.Start()

Um den animierten Zylinder grün einzufärben, müssen Sie Folgendes im obigen Programm ergänzen (Farbnamen):

 colors = vtk.vtkNamedColors()
 actor.GetProperty().SetColor(colors.GetColor3d(&quot;Green&quot;))

Als Namen können Sie u.a. die CSS3 Web-Farben verwenden (siehe z.B. [https://wiki.selfhtml.org/wiki/Farbe/Farbangaben] und {{W|Webfarbe#CSS_3}}).

Alternativ funktioniert auch das ({{W|RGB-Farbraum|RGB}}):

 actor.GetProperty().SetColor(0.0, 0.6, 0.0)

Wie der Zylinder mit einer Textur versehen wird, zeigt folgendes Programm:

 import vtk
 import time
 
 cylinder = vtk.vtkCylinderSource()
 cylinder.SetResolution(30)
 cylinder.SetHeight(3.0)
 cylinder.SetRadius(1.0)
 cylinder.CappingOn()
 
 texture_coords = vtk.vtkTextureMapToCylinder()
 texture_coords.SetInputConnection(cylinder.GetOutputPort())
 texture_coords.PreventSeamOn()
 
 reader = vtk.vtkJPEGReader()
 reader.SetFileName(&quot;PythonIng_textur.jpg&quot;)
 
 texture = vtk.vtkTexture()
 texture.SetInputConnection(reader.GetOutputPort()) 
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(texture_coords.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 actor.SetTexture(texture)
 
 renderer = vtk.vtkRenderer()
 renderWindow = vtk.vtkRenderWindow()
 renderWindow.AddRenderer(renderer)
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(renderWindow)
 
 renderer.AddActor(actor)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     renderWindow.Render()
     time.sleep(0.01)
 
 interactor.Start()

&lt;gallery&gt;
PythonIng_textur.jpg | Textur-Datei
PythonIng_VTK_2.png | Ausgabe (Screenshot)
&lt;/gallery&gt;

== Sonstige Grafikbibliotheken ==
=== Py5 ===
Im Buch ''Iacono et al.: Programmieren trainieren, mit über 150 Workouts in Java und Python; 3. Aufl., Hanser, 2023'' werden zahlreiche Aufgaben gestellt, die u.a. mit Processing zu lösen sind.  Processing ist eine einfache Programmiersprache und Entwicklungsumgebung. Warum ich das erwähne? Weil in älteren Processing-Versionen auch die Programmiersprache Python 2 abgedeckt war. Bei neueren Versionen gibt es keine Python-Anbindung mehr (getestet nur mit openSUSE Tumbleweed und Python 3). Somit funktioniert der Python-Teil im genannten Buch zum Teil nicht mehr. Ist das tragisch, oder kann das Buch weggeschmissen werden? Nein! Es gibt Alternativen zu Processing. Zum einen die im Buch selbst genannten Bibliotheken tkinter oder pygame. Pygame wird dort auch kurz anhand eines Beispiels thematisiert. Aber noch besser ist es, die py5-Bibliothek zu verwenden (lt. Google KI vom 30. Sept. 2026: ''Der echte, moderne „spirituelle Nachfolger“''). Damit ist die Funktionalität von Processing gewährleistet. Man kann aber beliebige Editoren oder IDEs zur Programmerstellung verwenden, ohne an Processing als IDE gebunden zu sein. Nachfolgend werden ein paar Beispiele zu dieser externen Bibliothek gegeben. Der erste Schritt ist wieder, die py5-Bibliothek zu installieren (z.B. mittels pip in eine virtuelle Umgebung; Python&gt;=3.10 und ein JDK&gt;=17 müssen auch installiert sein (Stand Okt. 2026)). Dann kann es schon mit dem Programmieren losgehen.

Beispiel (angelehnt an die ''Aufgabe W.2.3 Haus'' des genannten Buchs, jedoch etwas erweitert):

 import py5
 
 def setup():
     py5.size(600, 600)            # Fenstergröße 600px x 600px 
     py5.background(255, 255, 255) # Hintergrundfarbe ... weiss
     
 def draw():
     # Haus zeichnen
     py5.fill(255, 255, 255)       # Hintergrundfarbe ... weiss
     py5.stroke(255, 0, 0)         # Linienfarbe ... rot 
     py5.stroke_weight(3)          # Linienbreite ... 3px
     py5.rect(150, 200, 300, 300)  # Rechteck zeichnen (x, y, b, h)
     py5.triangle(150, 200, 300, 100, 450, 200) # Dreieck zeichnen
     py5.circle(250, 300, 70)      # Kreis zeichnen (x, y, d)   
     
     # Bemassung zeichnen
     py5.stroke(0, 255, 0)
     py5.stroke_weight(1)
     py5.line(300, 100, 550, 100)  # Linie zeichnen
     py5.line(450, 200, 550, 200) 
     py5.line(450, 500, 550, 500) 
     py5.line(150, 500, 150, 550)
     py5.line(450, 500, 450, 550)
     py5.text_size(20)             # Textgroesse
     py5.fill(0, 255, 0)           # Textfarbe
     py5.text(&quot;300&quot;, 280, 550)     # Text zeichnen
     py5.text(&quot;100&quot;, 500, 150)
     py5.text(&quot;300&quot;, 500, 350)  
 
     # Gedrehtes Rechteck zeichnen
     py5.stroke(255, 255, 0)
     py5.stroke_weight(3)
     py5.fill(200, 200, 200) 
     py5.translate(320, 260)  
     py5.rotate(0.3)               # Drehung (in Radiant)
     py5.rect(0, 0, 100, 50)
 
 # Startet den Sketch
 py5.run_sketch()


Ausgabe:

[[Datei:PythonIng_py5_1.png|300px]]

Das skizzierte Haus ist mit einer rudimentären Bemaßung versehen und hat zwei Fenster, ein rundes und ein gedrehtes, trübes rechteckiges. 

Beispiel (Mausoperationen):

 import py5
 
 def setup():
     py5.size(600, 600)            
     py5.background(255, 255, 255)
 
 def draw():
     pass
    
 def mouse_pressed():
     py5.text_size(15) 
     py5.fill(0, 0, 255)
     x = py5.mouse_x
     y = py5.mouse_y
     py5.text(&quot;(%d, %d)&quot; %(x, y), x, y) # Positionsdaten bei Maus-Klick schreiben
 
 py5.run_sketch()

Ausgabe:

[[Datei:PythonIng_py5_2.png|300px]]

Obiges Bild zeigt das Resultat nach einigen Mausklicks. Man erkennt, dass links-oben der Koordinatennullpunkt ist. Die x-Achse zeigt nach rechts, die y-Achse nach unten.

Beispiel (Fünfeck):

 import py5
 import random 
 
 def setup():
     py5.size(400, 400)
     py5.no_loop()       # statisches Bild (schont die Ressourcen)
 
 def draw():
     py5.translate(py5.width / 2, py5.height / 2)  # KS setzen
 
     radius = 150
     eck_anzahl = 5
 
     py5.fill(random.randint(0, 255), random.randint(0, 255), 
              random.randint(0, 255))    # Füllfarbe auf Zufallswert setzen
     py5.stroke(155, 0, 0)            
     py5.stroke_weight(5)     
     
     # Fünfeck als Polygon zeichnen
     py5.begin_shape()
     for i in range(eck_anzahl):
         winkel = i * py5.TWO_PI / eck_anzahl - py5.HALF_PI
         x = py5.cos(winkel) * radius
         y = py5.sin(winkel) * radius
         py5.vertex(x, y)
     py5.end_shape(py5.CLOSE)
 
 py5.run_sketch()

Ausgabe, bspw.:

[[Datei:PythonIng_py5_5.png|200px]]

&lt;u&gt;Kleine Aufgaben:&lt;/u&gt;
* Um die Funktionsweise von &lt;code&gt;py5.no_loop()&lt;/code&gt; zu verstehen, kommentieren Sie die Anweisung im Beispiel einfach aus, und starten Sie das Programm erneut.
* Zeichnen Sie ein Siebeneck.
* Was passiert, wenn man &lt;code&gt;py5.CLOSE&lt;/code&gt; im &lt;code&gt;py5.end_shape()&lt;/code&gt;-Befehl weglässt?

Beispiel (Grafik laden und zeichnen):

 import py5
 
 image1 = None
 
 def setup():
     global image1
     py5.size(600, 600)
     py5.no_loop()
     image1 = py5.load_image(&quot;PythonIng_py5_1.png&quot;)
 
 def draw():
     py5.image(image1, 0, 0)
 
 py5.run_sketch()

Hier wird einfach das Bild vom Haus-Beispiel (Screenshot von weiter oben) geladen und gezeichnet.

Beispiel (angelehnt an ''W.5.10 Wurfparabel'' des genannten Buches; mit OOP erstellt):

 import py5
 
 class Wurfparabel(py5.Sketch):
     def __init__(self, v0, angle):
         super().__init__()
         self.v0 = v0
         self.angle = self.radians(angle)
         self.g = 9.81
         self.t = 0.0
         self.scale = 1.5
 
     def settings(self):
         self.size(800, 600)
 
     def setup(self):        
         self.background(0, 0, 0)
         
     def draw(self):
         self.t += 0.1
 
         self.translate(50, 500)
       
         # KS Zeichnen
         self.fill(255, 255, 0)
         self.stroke(255, 255, 0)
         self.stroke_weight(1)
         self.line(0, 0, 0, -300)
         self.line(0, 0, 700, 0)
 
         # Punkt zeichnen
         cx = self.v0 * self.cos(self.angle) * self.t * self.scale
         cy = -(self.v0 * self.sin(self.angle) * self.t - \
                self.g/2 * self.t**2) * self.scale
         self.fill(255, 0, 0)
         self.stroke(255, 0, 0)
         self.circle(cx, cy, 3)
        
         # Stoppen bei Bodenkontakt
         if cy &gt;= -5:
             self.no_loop()
            
 def wurfparabel(v0=50, angle=45):
     sketch = Wurfparabel(v0, angle)
     sketch.run_sketch()
 
 v0 = float(input(&quot;v0 = &quot;))
 winkel = float(input(&quot;winkel = &quot;))
 wurfparabel(v0=v0, angle=winkel)

Eingabe auf der Konsole:

 v0 = 60
 winkel = 45

Ausgabe:

[[Datei:PythonIng_py5_13.png|200px]]

Die benötigten Formeln der Bewegungsgleichung kann man leicht herleiten, bzw. man benutzt folgende Grafik als Hilfestellung:

[[Datei:Wurfparabel_Zusammenfassung_aktualisierung.png|700px]]

&lt;u&gt;Aufgabe:&lt;/u&gt; Berechnen Sie den Scheitelpunkt und die Wurfweite bei gegebener Anfangsgeschwindigkeit und gegebenem Abwurfwinkel. Die Abwurfhöhe &lt;math&gt;y_0&lt;/math&gt; sei 0. Der Wurf soll auf der Erde stattfinden (g = 9.81 m/s²). Die dazu benötigten Formeln können aus obiger Grafik entnommen werden (oder Sie leiten sie selbst her). Geben Sie die Ergebnisse auf der Konsole aus.

Beispiel (eine einfache Animation):

 import py5
 
 i = 0
 
 def setup():
     py5.size(600, 600)
     py5.frame_rate(5)
     py5.stroke_weight(20)
 
 def draw():
     global i
     
     py5.background(255, 255, 255)
     py5.translate(py5.width/2, py5.height/2)
     py5.rotate(py5.PI/8 * i)    
 
     py5.line(-100, 0, 100, 0)
     i += 1
 
 py5.run_sketch()

Es wird eine rotierende Linie gezeichnet (z.B. wie bei einem Installationsprozess verwendet - zeigt an, dass der Installationsfortschritt nicht eingefroren ist). Hierbei ist nur aufzupassen, dass der Hintergrund in &lt;code&gt;draw()&lt;/code&gt; gesetzt wird, ansonsten würden die Linien additiv gezeichnet. Das ist zwar auch schön, aber eben nicht das gewünschte Resultat.

Hiermit belassen wir es mit der py5-Bibliothek und wenden uns wieder &quot;mathematischeren&quot; Themen zu.

= Vektoren und Matrizen =
== Zahlenfolgen ==
Für das Erstellen von Zahlenfolgen bieten sich die Funktionen &lt;code&gt;arange&lt;/code&gt; und &lt;code&gt;linspace&lt;/code&gt; aus dem &lt;code&gt;numpy&lt;/code&gt;-Modul an.

 from numpy import *
 
 start = 0
 stop = 10
 step = 2
 num = 10
 
 r = arange(start, stop, step)   # step ... Schrittweite
 l = linspace(start, stop, num)  # num ... Anzahl der Werte
 
 print(&quot;r = &quot;, r)
 print(&quot;l = &quot;, l)

Ausgabe:
 r =  [0 2 4 6 8]
 l =  [ 0.          1.11111111  2.22222222  3.33333333  4.44444444  5.55555556
   6.66666667  7.77777778  8.88888889 10.        ]

Bei &lt;code&gt;arange&lt;/code&gt; ist der &lt;code&gt;stop&lt;/code&gt;-Wert nicht im Ergebnis enthalten, bei &lt;code&gt;linspace&lt;/code&gt; standardmäßig aber sehr wohl. Jedoch kann man das bei &lt;code&gt;linspace&lt;/code&gt; auch ändern. Dann ist der Stoppwert nicht mehr enthalten: 

 linspace(start, stop, num, endpoint=False)

== Vektoren ==
Vektoren sollten jedem aus der Linearen Algebra bekannt sein. 

=== Arrays ===
In Python mit NumPy kann man Vektoren durch die Funktion array erzeugen.

 import numpy as np
 
 l1 = (-5, 3, 2)
 l2 = (1, 1, 4)
 
 a1 = np.array(l1)
 a2 = np.array(l2)
 
 a3 = a1 + a2
 a4 = 2 * a2
 
 print(a1)
 print(a2)
 print(a3)
 print(a3[2])
 print(a4)

Ausgabe:
 [-5  3  2]
 [1 1 4]
 [-4  4  6]
 6
 [2 2 8]

=== Zeilen- und Spaltenvektoren ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 print(z)
 print(s)

Ausgabe:
 [ [-5  3  2] ]
 [[1]
  [1]
  [4]]

=== Skalarprodukt ===
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4))
 
 skalarprodukt = np.dot(a1, a2)  
 
 print(skalarprodukt)

Ausgabe:
 6

=== Vektorprodukt ===
&lt;math&gt;a\ast b=\left(\begin{array}{c}
a_{1}\\
a_{2}\\
a_{3}
\end{array}\right)\ast\left(\begin{array}{c}
b_{1}\\
b_{2}\\
b_{3}
\end{array}\right)=\left(\begin{array}{c}
a_{2}b_{3}-a_{3}b_{2}\\
a_{3}b_{1}-a_{1}b_{3}\\
a_{1}b_{2}-a_{2}b_{1}
\end{array}\right)
&lt;/math&gt; 

Python-Code:
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4)) 
 
 vektorprodukt = np.cross(a1, a2) 
 
 print(vektorprodukt)

Ausgabe:
 [10 22 -8]

=== Transponierter Vektor ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 # transponierter Vektor
 z_tp = np.transpose(z)
 # transponierter Vektor
 s_tp = np.transpose(s)
 
 print(z_tp)
 print(s_tp)

Ausgabe:
 [[-5]
  [ 3]
  [ 2]]
 [ [1 1 4] ]

=== Vektorfelder visualisieren ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 # Daten generieren
 x = np.arange(0, 10, 1)
 y = np.arange(0, 10, 1)
 X, Y = np.meshgrid(x, y)
 U = X * Y
 V = Y + X
 
 # Plotten
 fig, ax = plt.subplots()
 
 ax.quiver(X, Y, U, V, angles='xy')
 
 plt.show()

Ausgabe:

[[Datei:PythonIng_quiver1.png]]

== Matrizen==
 import numpy as np
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 print(m1)

Ausgabe:
 [[1 2 3]
  [4 5 6]]

=== Zugriff auf Matrizenelemente ===
Beispiel:

 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 
 # Element aus Zeile 2 und Spalte 3 (Achtung! Index startet bei Null)
 print(m1[1,2])

Ausgabe:
 6

Visualisierung:
  
     0   1   2
   +-----------+
 0 | 1 | 2 | 3 |
   +-----------+
 1 | 4 | 5 | '''6''' |
   +-----------+


Beispiel:

 import numpy as np
 
 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
 
 B = np.matrix(A)     
 
 print(B[2::, ::2])

Ausgabe:

 [['20' '22']
  ['30' '32']
  ['40' '42']]

Mit der NumPy-Bibliothek funktioniert das zweidimensionale Slicing. Mit normalen Listen/Tupels geht das nicht, was wir schon früher thematisiert haben.

=== Addition und Subtraktion von Matrizen ===
 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 m2 = np.matrix([[0, 0, 2], [1, 3, 2]])
 
 print(m1 + m2)
 print(m1 - m2)

Ausgabe:
 [[1 2 5]
  [5 8 8]]
 [[1 2 1]
  [3 2 4]]

=== Transponierte Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 2, 3], [4, 5, 6]])
 mt = np.transpose(m) 
 
 print(m)
 print(mt)

Ausgabe:
 [[1 2 3]
  [4 5 6]]
 [[1 4]
  [2 5]
  [3 6]]

=== Rang einer Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 rg = np.linalg.matrix_rank(m)
 
 print(rg)

Ausgabe:
 2

=== Inverse Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 mi = np.linalg.inv(m)
 
 print(mi)

Ausgabe:
 [[ 1.   0.6]
  [-0.  -0.2]]

=== Multiplikation von Matrizen (falksches Schema) ===
 import numpy as np
 
 m1 = np.matrix([[1, 3, 4],  [0, -5, 1]])
 m2 = np.matrix([[1, 2], [2, 3], [0, 2]])
 
 print(m1 @ m2)

Ausgabe:
 [[  7  19]
  [-10 -13]]

=== Eigenwerte und Eigenvektoren ===
 import numpy as np
 
 m = np.matrix([[5, 8],  [1, 3]])
 D,V = np.linalg.eig(m)
 
 # Eigenwerte
 print(D)
 # Eigenvektoren
 print(V)

Ausgabe:
 [7. 1.]
 [[ 0.9701425  -0.89442719]
  [ 0.24253563  0.4472136 ]]

=== Teilmatrizen ===
 import numpy as np
 m = np.matrix([[1, 3, 4],  [0, -5, 1]])
 print(&quot;m = &quot;, m)
 
 # Erste Zeile extrahieren
 m1 = m[0,:]
 print(&quot;m1 = &quot;, m1)
 
 # Das Element aus der 1. Zeile und der 2. Spalte extrahieren
 m2 = m[0,1]
 print(&quot;m2 = &quot;, m2)
 
 # Zweite Spalte extrahieren
 m3 = m[:, 1]
 print(&quot;m3 = &quot;, m3)

Ausgabe:
 m =  [[ 1  3  4]
  [ 0 -5  1]]
 m1 =  [ [1 3 4] ]
 m2 =  3
 m3 =  [[ 3]
  [-5]]

=== Spezielle Matrizen ===
==== Nullmatrix ====
 import numpy as np
 z = np.zeros((3, 2))
 print(z)

Ausgabe:
 [[0. 0.]
  [0. 0.]
  [0. 0.]]

==== Einheitsmatrix ====
 import numpy as np
 z = np.eye(3)
 print(z)

Ausgabe:
 [[1. 0. 0.]
  [0. 1. 0.]
  [0. 0. 1.]]

==== Matrix mit lauter Einsen ====
 import numpy as np
 z = np.ones((3, 2))
 print(z)

Ausgabe:
 [[1. 1.]
  [1. 1.]
  [1. 1.]]

=== Spärlich besetzte Matrizen ===
Das Thema spärlich besetzter Matrizen wird hier nur kurz angerissen. Nähere Details siehe unter dem Weblink  [https://docs.scipy.org/doc/scipy/reference/sparse.html#module-scipy.sparse]. 

Beispiel:

 import numpy as np
 import scipy
 
 A = scipy.sparse.csr_array(np.eye(5))
 
 print(A)

Ausgabe:
 &lt;Compressed Sparse Row sparse array of dtype 'float64'
         with 5 stored elements and shape (5, 5)&gt;
   Coords        Values
   (0, 0)        1.0
   (1, 1)        1.0
   (2, 2)        1.0
   (3, 3)        1.0
   (4, 4)        1.0

csr steht für '''c'''ompressed '''s'''parse '''r'''ow.

Andere Möglichkeiten:
* coo-Format ('''coo'''rdinate Format): &lt;code&gt;scipy.sparse.coo_array()&lt;/code&gt;
* lil-Format ('''li'''st of '''l'''ists): &lt;code&gt;scipy.sparse.lil_array()&lt;/code&gt;
* csc-Format ('''c'''ompressed '''s'''parse '''c'''olumn): &lt;code&gt;scipy.sparse.csc_array()&lt;/code&gt;

Es gibt auch &lt;code&gt;scipy.sparse.csr_matrix()&lt;/code&gt; etc. Diese Befehle sind aber veraltet und es wird empfohlen, statt dessen die &lt;code&gt;..._array()&lt;/code&gt;-Funktionen zu verwenden.

&lt;u&gt;Aufgaben:&lt;/u&gt; 
Recherchieren Sie im Internet 
* generell zum Thema &quot;spärlich besetzte Matrizen mit Python&quot;.
* Was sind die Vor-/Nachteile von csr-arrays gegenüber coo- und lil-arrays?
* Wann verwendet man sinnvollerweise csr- und wann csc-arrays?
* Wie wandelt man coo-arrays in csr-arrays um?

= Lineare Gleichungssysteme =
Sei &lt;math&gt;Ax = b&lt;/math&gt; ein lineares Gleichungssystem. &lt;math&gt;A&lt;/math&gt; sei die Koeffizientenmatrix, &lt;math&gt;x&lt;/math&gt; der Lösungsvektor und &lt;math&gt;b&lt;/math&gt; ein bekannter Vektor.

Beispiel:
 import numpy as np
 
 A = np.array([[5, 1], [0, 2]])
 b = np.array([1, 2])
 
 x = np.linalg.solve(A, b)
 
 print(x)

Ausgabe:
 [0. 1.]

Siehe dazu auch das Kapitel [[Ing Mathematik: Numerisches Lösen von linearen Gleichungssystemen]]. Dort wird dieses Themengebiet u.a. mit weitergehenden Python-Skripten vertieft.

== Aufgabe ==
* Lösen Sie folgendes Gleichungssystem mittels Python (und zur Kontrolle auch händisch): 
 5x + 6y - 2z = 12
 3x - y  - 3z = 6
 2x + 2y + 4z = 5

= Polynome =
== Ein erstes einfaches Beispiel ==
Gegeben sei das Polynom &lt;math&gt;7x^3+5x^2+1&lt;/math&gt;. In Python:

 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p)

Ausgabe:
    3     2
 7 x + 5 x + 1

== Einzelne Polynomwerte berechnen ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p(1.5))

Ausgabe:
 35.875

== Polynome integrieren und differenzieren ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 
 # 1. Ableitung
 p1 = p.deriv()
 p2 = p.deriv(1)
 
 # 2. Ableitung
 p3 = p.deriv(2)
 
 # Integral
 p4 = p.integ()
 
 print(p1)
 print(p2)
 print(p3)
 print(p4)

Ausgabe:
     2
 21 x + 10 x
     2
 21 x + 10 x
 
 42 x + 10
       4         3
 1.75 x + 1.667 x + 1 x

== Nullstellen bestimmen ==
 import numpy as np
 
 p = np.poly1d([2, 5, 0, 4])
 r = np.roots(p)
 
 print(r)

Ausgabe:
 [-2.7621427 +0.j          0.13107135+0.84077099j  0.13107135-0.84077099j]

== Aufgaben ==
* Berechnen Sie den Wert für x = 3 des Polynoms &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Differenzieren und integrieren Sie das Polynom &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Berechnen Sie die Nullstellen von &lt;math&gt;y = 7x^5 - 3x^2 + 12&lt;/math&gt;.

= Nichtlineare Gleichungen und Gleichungssysteme =
== Nullstellenbestimmung ==
Löse eine beliebige Gleichung f(x) = 0, z.B. &lt;math&gt; f(x) = x^2 - 5\cos(x) - 10 = 0 &lt;/math&gt;:
 import scipy
 import numpy as np
 
 def f(x):
     return x**2 - 5*np.cos(x) - 10
    
 xstart = [-1, 1]        # Startwerte
 xn = scipy.optimize.root(f, xstart)
 
 print(xn.x)

Ausgabe:
 [-2.46813009  2.46813009]

Funktionsgraph:

[[Datei:octave_nichtlin2.jpg]]

== Gleichungssysteme ==
SymPy ist ein externes Modul, das symbolisches Rechnen ('''Sym'''bolic '''Py'''thon) ermöglicht. 

Folgende Aufgabe ist dem Buch &quot;Knorrenschild: Numerische Mathematik, Hanser, 2017, Seite 72&quot; entnommen. Zu lösen ist das nichtlineare Gleichungssystem

&lt;math&gt;f_1 = 2x_1 + 4x_2 = 0 &lt;/math&gt;

&lt;math&gt;f_2 = 4x_1 + 8x_2^3 = 0&lt;/math&gt;

Mit Python ist das so möglich:
 import sympy
 
 x1, x2 = sympy.symbols(&quot;x1 x2&quot;) 
 
 f1 = 2*x1 + 4*x2
 f2 = 4*x1 + 8*x2**3
 
 s = sympy.solve((f1, f2), x1, x2) 
 
 print(s)

Ausgabe:
 [(-2, 1), (0, 0), (2, -1)]

Plot:

[[Datei:IngPython_nl_gleichung1.svg|500px]]

= Komplexe Zahlen =
Die imaginäre Einheit wird in Python durch den Buchstaben &lt;code&gt;j&lt;/code&gt; symbolisiert. Darstellen kann man eine komplexe Zahl bekannterweise in mehreren Formen:
* Kartesische Darstellung &lt;math&gt;z = \Re(z) + j \cdot \Im(z)&lt;/math&gt;
* Polardarstellungen &lt;math&gt;z = r \cdot (\cos(\phi) + j \cdot \sin(\phi)) = r \cdot e^{j\cdot \phi}&lt;/math&gt;

Die konjugiert komplexe Zahl ist &lt;math&gt;z^* = \Re(z) - j \cdot \Im(z)&lt;/math&gt;

Nachfolgend einige mathematische Operationen mit Python und NumPy.

 import numpy as np
 
 z1 = 2 + 5j           # kartesische Darstellung
 z2 = 3 * np.exp(3j)   # Polardarstellung
  
 # Addition
 res = z1 + z2
 print(&quot;z1 + z2 = &quot;, res)
 
 # Multiplikation
 res = z1 * z2
 print(&quot;z1 * z2 = &quot;, res)
 
 # Realteil
 res = np.real(z2)
 print(&quot;Realteil von z2 = &quot;, res)
 
 # Imaginärteil
 res = np.imag(z2)
 print(&quot;Imaginaerteil von z2 = &quot;, res)
 
 # Betrag
 res = np.abs(z1)
 print(&quot;Betrag von z1 = &quot;, res)
 
 # Argument
 res = np.angle(z1)
 print(&quot;Argument von z1 = &quot;, res)
 
 # Konjugiert komplexe Zahl
 res = np.conj(z1)
 print(&quot;Konjugiert komplexe Zahl von z1 = &quot;, res)

Ausgabe:
 z1 + z2 =  (-0.9699774898013365+5.423360024179601j)
 z1 * z2 =  (-8.05675510050068-14.003167400647481j)
 Realteil von z2 =  -2.9699774898013365
 Imaginaerteil von z2 =  0.4233600241796016
 Betrag von z1 =  5.385164807134504
 Argument von z1 =  1.1902899496825317
 Konjugiert komplexe Zahl von z1 =  (2-5j)

= Interpolation =
 import numpy as np
 import scipy
 import matplotlib.pyplot as plt
 
 # Stützpunkte
 xp = np.arange(1, 6)
 yp = (0, -5, 2, 7, 6)
 
 ti = np.arange(1, 5, 0.01)
 
 i1 = scipy.interpolate.interp1d(xp, yp, kind = &quot;linear&quot;)
 i2 = scipy.interpolate.interp1d(xp, yp, kind = &quot;cubic&quot;) 
 
 plt.plot(xp, yp, &quot;rx&quot;)
 plt.plot(xp, i1(xp))
 plt.plot(ti, i2(ti))
 plt.show()

Ausgabe:

[[Datei:PythonIng_interpol1.png]]

= Differenzialrechnung =
== Numerisches Differenzieren ==
Als Beispiel differenzieren wir &lt;math&gt;y = 5x\sin{x}&lt;/math&gt; und stellen das Ganze grafisch dar.

 from findiff import Diff
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.linspace(0, 10, 1000)
 f = 5 * x * np.sin(x)
 dx = x[1] - x[0]
 
 # Ableitung
 d_dx = Diff(0, dx)
 df_dx = d_dx(f)
 
 # Grafik
 plt.plot(x, f, label = &quot;y&quot;)
 plt.plot(x, df_dx, label = &quot;y'&quot;)
 plt.grid()
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

Ausgabe:

[[Datei:octave_diff1.jpg]]

&lt;small&gt;findiff ist ein externes Modul. Dieses muss installiert werden (z.B. so: ...\Python\Scripts\pip.exe install --upgrade findiff). Für die Vorgehensweise unter openSUSE Tumbleweed siehe das Kapitel [[Ing_Mathematik:_Python#Mit_VPython | VPython]], nur dass das Ganze mit einer aktuelleren Python-Version exekutiert wird, z.B. mit Python 3.13.  Das im Buch &quot;Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler, Rheinwerk&quot; verwendete Modul &quot;scipy.misc&quot; ist veraltet (deprecated ... missbilligt). Lt. [https://docs.scipy.org/doc/scipy-1.17.0/dev/roadmap-detailed.html#misc SciPy-Dokumentation für die Version 1.17.0] wurden alle entsprechenden Features schon entfernt.&lt;/small&gt;

== Symbolisches Differenzieren ==
Differenzieren Sie die Funktionen &lt;math&gt;f_1(x) = x^2&lt;/math&gt; und &lt;math&gt;f_2(x) = \sin(x)\cos\left(\frac{x}{2}\right)&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2;
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 d1 = sympy.diff(f1, x)
 d2 = sympy.diff(f2, x)
 
 print(d1)
 print(d2)

Ausgabe:
 2*x
 -0.5*sin(0.5*x)*sin(x) + cos(0.5*x)*cos(x)

== Aufgaben ==
* Differenzieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.
* Differenzieren Sie die Funktion &lt;math&gt;y = \frac{\sinh(x)}{(1+x)}&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.

= Integralrechnung =
== Numerisches Integrieren ==
Berechnen Sie das Integral &lt;math&gt;\int_{0}^{3}x^2 dx&lt;/math&gt;.

 import scipy
 
 def f(x):
     return x**2
    
 i = scipy.integrate.quad(f, 0, 3)
 print(i)

Ausgabe:
 (9.000000000000002, 9.992007221626411e-14)

Das trifft den exakten Wert 9.0 ziemlich genau.

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} dx&lt;/math&gt;.

 import scipy
 import numpy as np
 
 def f(x):
     return 2**(-x)
   
 i = scipy.integrate.quad(f, 0, np.inf)
 print(i)

Ausgabe:
 (1.4426950408889556, 4.486558477977586e-09)

== Symbolisches Integrieren ==
Berechnen Sie &lt;math&gt;\int x^2 \text{d}x&lt;/math&gt; und &lt;math&gt;\int \sin{x}\cos{\frac{x}{2}} \text{d}x&lt;/math&gt;.
 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 i1 = sympy.integrate(f1, x)
 i2 = sympy.integrate(f2, x)
 
 print(i1)
 print(i2)

Ausgabe:
 x**3/3
 -0.666666666666667*sin(0.5*x)*sin(x) - 1.33333333333333*cos(0.5*x)*cos(x)

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} \text{d}x&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f = 2**(-x)
 i = sympy.integrate(f, (x, 0, sympy.oo))
 print(i)

Ausgabe:
 1/log(2)

&lt;code&gt;sympy.oo&lt;/code&gt; steht für das {{W|Unendlichzeichen}} &lt;math&gt;\infty&lt;/math&gt; (die liegende Acht oder das Möbiusband). Mit &lt;code&gt;sympy.pprint(i)&lt;/code&gt; ließe sich letzere Ausgabe etwas schöner schreiben:

   1   
 ──────
 log(2)

Man beachtete, &lt;code&gt;log&lt;/code&gt; steht hier für den natürlichen Logarithmus &lt;code&gt;ln&lt;/code&gt;.

== Aufgaben ==
* Integrieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; von 1 bis 5.
* Integrieren Sie die Funktion &lt;math&gt;y = x^3&lt;/math&gt; von 0 bis 4.
* Integrieren Sie &lt;math&gt;\int x^x(\log (x) + 1)\mathrm dx&lt;/math&gt; symbolisch.

= Gewöhnliche Differenzialgleichungen =
== DGL numerisch lösen ==
Für die Lösung von Differenzialgleichungen steht u.a. die Funktion scipy.integrate.solve_ivp() zur Verfügung. Diese Funktion implementiert auch das Runge-Kutta-Verfahren (RK45).

{{Wikipedia | Runge-Kutta-Verfahren}}

Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import scipy
 import numpy as np
 import matplotlib.pyplot as plt
 
 def dy_dx(x, y):
     return x**2 + y**3
 
 y0 = [1]
 xi = [0, 1]
 x = np.arange(0, 1, 0.01)
 
 z = scipy.integrate.solve_ivp(dy_dx, xi, y0, method=&quot;RK45&quot;, dense_output=True)
 y = z.sol(x)
 
 plt.plot(x, y.T)
 plt.grid()
 plt.show()

[[Datei:PythonIng_dgl1.png]]

== DGL symbolisch lösen ==
Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 print(lsg)

Ausgabe:
 [Eq(f(x), (-x**2)**(1/3)), Eq(f(x), (-x**2)**(1/3)*(-1 - sqrt(3)*I)/2), Eq(f(x), (-x**2)**(1/3)*(-1 + sqrt(3)*I)/2)]

Mit &lt;code&gt;sympy.pprint&lt;/code&gt; (pretty print) lässt sich die Ausgabe etwas übersichtlicher darstellen.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 sympy.pprint(lsg)

Ausgabe:
 ⎡                           _____                        _____            ⎤
 ⎢          _____         3 ╱   2                      3 ╱   2             ⎥
 ⎢       3 ╱   2          ╲╱  -x  ⋅(-1 - √3⋅ⅈ)         ╲╱  -x  ⋅(-1 + √3⋅ⅈ)⎥
 ⎢f(x) = ╲╱  -x  , f(x) = ────────────────────, f(x) = ────────────────────⎥
 ⎣                                 2                            2          ⎦

== Aufgaben ==
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \frac{1}{x\cdot y}&lt;/math&gt; mit Python. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;m' = -k\cdot m&lt;/math&gt;. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \sqrt{|y|}&lt;/math&gt;.

=Laplace-Transformation=
Laplace-Transformation:

&lt;math&gt;F(s) =\mathcal{L} \left\{f\right\}(s) = \int_{0}^{\infty} f(t) \mathrm e^{-st} \,\mathrm{d}t, \qquad s\in\mathbb{C}
&lt;/math&gt;

Inverse Laplace-Transformation:

&lt;math&gt;\mathcal{L}^{-1} \left\{F\right\}(t)
  = \frac{1}{2 \pi \mathrm j} \int_{ \gamma - \mathrm j \infty}^{ \gamma + \mathrm j \infty} \mathrm e^{st} F(s)\,\mathrm ds 
= \begin{cases}
      f(t) &amp; \text{für } t \geq 0 \\
      0    &amp; \text{für } t &lt; 0
    \end{cases}
&lt;/math&gt;

Siehe auch [[Ing_Mathematik:_Laplace-Transformation]]

Code:
 import sympy
 from sympy.abc import t, s
 
 # Laplace-Transformation der Funktion f(t) = 1 (Heaviside-Fkt.)
 f = 1
 # alternativ: f = sympy.Heaviside(t)
 F = sympy.laplace_transform(f, t, s, noconds=True)
 print(&quot;Laplace-Transformierte F(s):&quot;, F) 
 
 # Inverse Laplace-Transformation zurück in den Zeitbereich
 f_inv = sympy.inverse_laplace_transform(F, s, t)
 print(&quot;Inverse Transformation f(t):&quot;, f_inv)

Ausgabe:
 Laplace-Transformierte F(s): 1/s
 Inverse Transformation f(t): Heaviside(t)

Die Zeile

 from sympy.abc import t, s

steht alternativ für

 t = sympy.symbols(&quot;t&quot;)
 s = sympy.symbols(&quot;s&quot;)

&lt;u&gt;Aufgaben&lt;/u&gt;: Ermitteln Sie mittels SymPy die &lt;math&gt;\mathcal{L}&lt;/math&gt;-Transformierten und dann wieder die  &lt;math&gt;\mathcal{L}^{-1}&lt;/math&gt;-Transformationen (ähnlich wie beim obigen Beispiel):
* &lt;math&gt;\sin(t) \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;t^3 \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;\text{e}^{\omega t} \circ\! -\! \bullet \ ?&lt;/math&gt;

=Fourier-Reihen=
&lt;math&gt;
f(x)\approx \frac{a_{0}}{2}+\sum_{k=1}^{\infty}\left(a_{k}\cos\left(kx\right)+b_{k}\sin\left(kx\right)\right)
&lt;/math&gt;

&lt;math&gt;
a_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\cos\left(kx\right)\mathrm dx\quad\text{für }k\geq0
&lt;/math&gt;

&lt;math&gt;
b_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\sin\left(kx\right)\mathrm dx\quad\text{für }k\geq1
&lt;/math&gt;

Für die Sägezahnfunktion &lt;math&gt;y=x;\, 0 &lt; x &lt; 2\pi&lt;/math&gt; sei die Fourierreihe mit einem Python-Programm (unter Mithilfe von sympy) hergeleitet.

Code:

 from sympy import fourier_series, pi, symbols, pprint
 
 x = symbols('x')
 f = x
 s = fourier_series(f, (x, 0, 2*pi))
 pprint(s.truncate(n=4))

Ausgabe:

                        2⋅sin(3⋅x)    
 -2⋅sin(x) - sin(2⋅x) - ────────── + π
                            3

Siehe auch [[Ing Mathematik: Fourierreihen]].

Ein komplizierteres Beispiel:

[[Datei:IngMath fourier bsp13.svg | 300px]]

&lt;math&gt;0\le t &lt; T/2\text{:}\quad f(t) = H&lt;/math&gt;

&lt;math&gt;T/2 \le t \le T\text{:}\quad f(t) = \frac{2H}{T}\left( t-\frac{T}{2}\right)&lt;/math&gt;

Code:

 import sympy as sp
 
 H = sp.Symbol('H', positive=True)
 T = sp.Symbol('T', positive=True)
 t = sp.Symbol('t')
 
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T/2)),
     (2*H/T*(t-T/2), (t &gt; T/2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Ausgabe:

      ⎛2⋅π⋅t⎞        ⎛4⋅π⋅t⎞        ⎛6⋅π⋅t⎞          ⎛2⋅π⋅t⎞          ⎛6⋅π⋅t⎞      
 H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   2⋅H⋅cos⎜─────⎟   2⋅H⋅cos⎜─────⎟      
      ⎝  T  ⎠        ⎝  T  ⎠        ⎝  T  ⎠          ⎝  T  ⎠          ⎝  T  ⎠   3⋅H
 ──────────── - ──────────── + ──────────── + ────────────── + ────────────── + ───
      π             2⋅π            3⋅π               2                 2         4 
                                                    π               9⋅π

=Rechnen mit wirklich großen Zahlen=
Bekannt ist, dass Python kaum Einschränkungen beim Wertebereich von Ganzzahlen hat, z.B.

 print(10**300)

Ausgabe (gekürzt):

 100000000000000000000...00000000000000000000000000000000000000000000000000000000000000000000000

Ähnliches geht auch mit Gleitpunktzahlen, z.B. durch die Verwendung des Moduls [https://mpmath.org/ mpmath]:

 import mpmath
 print(mpmath.mpf(1500.4)**mpmath.mpf(300))

Ausgabe:

 7.27975299218612e+952

Anderes Beispiel:

 from mpmath import mp, pi
 mp.dps = 100
 print(pi)

Ausgabe:

 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068

mpmath kann noch einiges mehr, dazu sei aber auf die entsprechende Dokumentation auf der mpmath-Homepage verwiesen. mpmath ist Bestandteil von SymPy, kann aber auch separat installiert werden.

Aber auch Python selbst besitzt eine Möglichkeit, um mit großen bzw. exakten Gleitpunktzahlen zu rechnen, nämlich das interne Modul decimal. Dieses hat einige Vorteile gegenüber mpmath, aber auch gravierende Nachteile. Diese seien hier nicht detailliert aufgezählt. Grob gesagt hat decimal im Finanzwesen seine Berechtigung. Für wissenschaftliche Anwendungen wird aber mpmath vorzuziehen sein, da es u.a. vielfältige mathematische Funktionen bereit stellt. Nachfolgend ein einfaches Beispiel mit decimal:

 import decimal
 print(&quot;Potenzierung:&quot;, decimal.Decimal(1500.4) ** decimal.Decimal(300.0))
 print(&quot;Einfache Addition:&quot;, 0.1 + 0.2)
 decimal.getcontext().prec = 50
 print(&quot;Addition mit decimal:&quot;, decimal.Decimal(&quot;0.1&quot;) + decimal.Decimal(&quot;0.2&quot;))

Ausgabe:

 Potenzierung: 7.279752992186121551039839134E+952
 Einfache Addition: 0.30000000000000004
 Addition mit decimal: 0.3

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet die genauen Vor- und Nachteile von decimal und mpmath. Verwenden Sie dazu auch KI (z.B. von Google, chatgpt).

= pint - mit physikalischen Größen rechnen = 
[[File:Pint-Glas_UK.jpg|right|100px]]
pint ist ein externes Python-Paket zur Manipulation von physikalischen Einheiten. Es muss vor der ersten Benutzung installiert werden (Vorgehensweise wie immer: pip, YaST, via venv etc.).

Beispiel:

 import pint
 import numpy as np
 
 ureg = pint.UnitRegistry()
 
 # Einfache Berechnung
 print(3 * ureg.meter + 4 * ureg.cm)
 
 # Mit NumPy
 npeinzel = [3, 4] * ureg.meter + [2, 5] * ureg.cm
 print(npeinzel)
 npsum = np.sum(npeinzel)
 print(npsum)
 
 # Konvertierung von Einheiten
 npsum_inch = npsum.to(ureg.inch)
 print(npsum_inch)
 
 print(npeinzel.magnitude)
 print(npeinzel.units)
 print(npeinzel.dimensionality)

Ausgabe:

 3.04 meter
 [3.02 4.05] meter
 7.07 meter
 278.3464566929134 inch
 [3.02 4.05]
 meter
 [length]

Die Dokumentation zu pint findet sich auf [https://pint.readthedocs.io/en/stable/].

=Regelungstechnische Aufgabenstellungen=
Für regelungstechnische Aufgaben gibt es u.a. das externe Paket &lt;code&gt;control&lt;/code&gt;. Hier soll nicht detailliert darauf eingegangen werden. Anhand eines Beispiels soll anschließend nur die Visualisierung in Form eines Bode-Diagramms und der Sprungantwort gezeigt werden. Gegeben sei ein P-Regler mit &lt;math&gt;R = \frac{5}{2}&lt;/math&gt; und eine Strecke &lt;math&gt;S= \frac{1}{30s^3+20s^2+10s+1,5}&lt;/math&gt;. Gesucht sei vorerst ein Bode-Diagramm für den offenen Regelkreis und das Führungsverhalten.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke  # oder: G0 = ct.series(regler, strecke)
 Gw = ct.feedback(G0)
 
 ct.bode_plot(G0, label='G0')
 ct.bode_plot(Gw, label='Gw')
 plt.show()

[[Datei:PythonIng_bode1.svg]]

Nun noch für obiges Beispiel die Sprungantwort. Diese zeigt einige große Überschwinger, d.h. der Regler kann sicher noch optimiert werden.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke 
 Gw = ct.feedback(G0) 
 
 t, y = ct.step_response(Gw)
 
 plt.plot(t,y)
 plt.title('Sprungantwort')
 plt.xlabel('t')
 plt.ylabel('h(t)')
 plt.grid()
 plt.show()

[[Datei:PythonIng_bode3.svg]]

Einige weitere wichtige Daten (Phasenreserve, Amplitudenreserve, Durchtrittsfrequenz) lassen sich mittels der &lt;code&gt;control&lt;/code&gt;-Funktion &lt;code&gt;margin()&lt;/code&gt; ermitteln. Die Ortskurve lässt sich mit der Funktion &lt;code&gt;nyquist_plot()&lt;/code&gt; zeichnen. Dies sei hier aber nicht weiter ausgeführt.

==Aufgaben==
* Zeichen Sie mit Python die Ortskurve für obiges Beispiel.
* Was passiert, wenn man die Reglerverstärkung weiter aufdreht (z.B. auf &lt;math&gt;R = \frac{25}{2}&lt;/math&gt;)?
* Wie sehen das Bode-Diagramm und die Sprungantwort aus, wenn ein PI-Regler verwendet wird?

= Stereostatik etc. =
Das Modul SymPy bietet einige Möglichkeiten einfache Bauwerke zu berechnen, z.B. Balken oder Fachwerke. Nachfolgend wird ein einfaches Fachwerk berechnet und gezeichnet.

Python-Code:
 from sympy.physics.continuum_mechanics.truss import Truss 
 
 t = Truss()
 # Knoten
 t.add_node((&quot;A&quot;, -3, 0), (&quot;B&quot;, 0, 0), (&quot;C&quot;, 4, 0), (&quot;D&quot;, 7, 0),
            (&quot;E&quot;, 6, 1.5), (&quot;F&quot;, 2, 3), (&quot;G&quot;, -2, 1.5))
 # Stäbe
 t.add_member((&quot;AB&quot;,&quot;A&quot;,&quot;B&quot;), (&quot;BC&quot;,&quot;B&quot;,&quot;C&quot;), (&quot;CD&quot;,&quot;C&quot;,&quot;D&quot;))
 t.add_member((&quot;AG&quot;,&quot;A&quot;,&quot;G&quot;), (&quot;GB&quot;,&quot;G&quot;,&quot;B&quot;), (&quot;GF&quot;,&quot;G&quot;,&quot;F&quot;))
 t.add_member((&quot;BF&quot;,&quot;B&quot;,&quot;F&quot;), (&quot;FC&quot;,&quot;F&quot;,&quot;C&quot;), (&quot;CE&quot;,&quot;C&quot;,&quot;E&quot;))
 t.add_member((&quot;FE&quot;,&quot;F&quot;,&quot;E&quot;), (&quot;DE&quot;,&quot;D&quot;,&quot;E&quot;))
 # Auflager; roller ... Loslager, pinned ... Festlager
 t.apply_support((&quot;A&quot;,&quot;roller&quot;), (&quot;D&quot;,&quot;pinned&quot;))
 # Einwirkende Kräfte
 t.apply_load((&quot;G&quot;, 5, 270), (&quot;E&quot;, 3, 90))
 
 # Berechnung 
 t.solve()
 print(&quot;Reaction Forces: &quot;, t.reaction_loads)
 print(&quot;Internal Forces: &quot;, t.internal_forces)
 
 # Fachwerk zeichnen
 p = t.draw()
 p.show()

Ausgabe auf der Konsole:

 Reaction Forces:  {'R_A_y': 4.20000000000000, 'R_D_x': 0, 'R_D_y': -2.20000000000000}
 Internal Forces:  {'AB': 2.80000000000000, 'BC': 0.333333333333333, 'CD': -1.46666666666667, 
 'AG': -5.04777178564958, 'GB': -2.05555555555556, 'GF': -1.23413387432364, 
 'BF': 0.411111111111111*sqrt(13), 'FC': -0.3*sqrt(13), 'CE': 1.50000000000000, 
 'FE': 0.284800124843917, 'DE': 2.64407093534026}

Zeichnung:

[[File:PythonIng_fachwerk1.svg|300px]]

Details zu diesem Thema siehe z.B. [https://docs.sympy.org/latest/modules/physics/continuum_mechanics/index.html Continuum Mechanics] oder [https://docs.sympy.org/latest/tutorials/physics/continuum_mechanics/index.html Continuum Mechanics Tutorials]. Auch andere mechanische Probleme werden von SymPy abgehandelt ([https://docs.sympy.org/latest/tutorials/physics/index.html Physics Tutorials]).

== Aufgabe ==
Gegeben sei ein einseitig eingespannter Kragträger. Belastet wird er durch eine Einzellast am Trägerende. Für die Daten siehe folgende ASCII-Skizze:

                            | 20 kN  
    //|---&gt; x               |
    //|                     V
    //|----------------------
    //|         10 m        |
 
 Elastizitätsmodul E = 2,1*10⁵ N/mm²
 Flächenträgheitsmoment I = 0.001 m⁴

Berechnen Sie die Auflagerreaktionen, den Querkraft- und Biegemomentenverlauf, sowie die Verformungen.
Stellen Sie dies mit Hilfe von SymPy graphisch und auch mittels Formeln dar. Verwenden Sie dazu auch pprint (pretty print) aus dem SymPy-Modul. Zwecks Lösungsansatz siehe die oben aufgeführte Seite &quot;Continuum Mechanics Tutorials&quot;. Achten Sie auch auf die Einheiten! Kontrollieren Sie das Ganze mittels händischer Rechnung. In dem genannten Tutorial ist von &quot;Singularity Functions&quot; die Rede. Gemeint ist damit in diesem Kontext die {{W|Föppl-Klammer}}.

Einige Python-Programme, vorrangig zu Maschinenelementen, finden sich auf [https://baymp.de/download_python.html BayMP für Python] (Balken, Zahnräder, Stabknickung usw.).

=Thermodynamik= 
== PYroMat ==
Für thermodynamische Aufgabenstellungen gibt es verschiedene externe Module. Eines davon ist PYroMat (siehe auch [http://pyromat.org]). Damit lassen sich thermodynamische Stoffdaten für viele Substanzen berechnen.

Beispiel (einige Stoffdaten für Wasser bei 400°C und 20 bar berechnen):

 import pyromat as pm
 
 # Wasserdaten laden:
 H2O = pm.get('mp.H2O')
 
 # Stoffdaten berechnen:
 T = 673.15  # Temperatur in Kelvin
 p = 20      # Druck in bar
 v = H2O.v(T, p)
 h = H2O.h(T, p)
 s = H2O.s(T, p)
 print(f&quot;Spezifisches Volumen: {v} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {h} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {s} kJ/(kg K)&quot;)

Ausgabe:

 Spezifisches Volumen: [0.1512163] m³/kg
 Spezifische Enthalpie: [3248.3789473] kJ/kg
 Spezifische Entropie: [7.12924142] kJ/(kg K)

&lt;small&gt;
PYroMat muss vorab installiert werden (z.B. mittels pip, in eine virtuelle Umgebung)
&lt;/small&gt;

&lt;code&gt;mp&lt;/code&gt; steht für &quot;multi phase&quot;. Für ein ideales Gas wäre &lt;code&gt;ig&lt;/code&gt; zuständig, z.B. &lt;code&gt;'ig.O2'&lt;/code&gt;.

Beispiel (T-s-Diagramm für Wasser zeichnen):
 import numpy as np
 import matplotlib.pyplot as plt
 import pyromat as pm
 
 # Konfigurieren
 pm.config[&quot;unit_pressure&quot;] = &quot;bar&quot;
 pm.config[&quot;unit_temperature&quot;] = &quot;K&quot;
 fluid = pm.get(&quot;mp.H2O&quot;)
 
 # Temperaturbereich für das Nassdampfgebiet
 T_tripel = 273.16
 T_crit = 647.096
 T = np.linspace(T_tripel, T_crit - 0.1, 200)
 
 # Sättigungslinien berechnen und zeichnen
 for x in np.linspace(0.0, 1.0, 5):
     s = fluid.s(T=T, x=x)
     if(x&lt;=0.0):
         plt.plot(s, T, label=&quot;Siedelinie x=%3.1f&quot; % x, linewidth=2.0)
     elif(x&gt;=1.0):
         plt.plot(s, T, label=&quot;Taulinie x=%3.1f&quot; % x, linewidth=2.0)
     else:
         plt.plot(s, T, label=&quot;x=%3.1f&quot; % x, linewidth=1.0)
 
 # Isobaren zeichnen
 p_values = [0.1, 1, 10, 50, 100]
 T_isobar = np.linspace(T_tripel, 1000, 200)
 t = 0.7
 
 for p in p_values:
     s_iso = fluid.s(T=T_isobar, p=p)
     plt.plot(s_iso, T_isobar, 'k-', alpha=0.8, linewidth=0.8)
 
     t += .05
     idx = int(len(s_iso) * t)
     plt.text(s_iso[idx], T_isobar[idx], f&quot;{p} bar&quot;, fontsize=9, alpha=0.8)
 
 # Diagramm zeichnen
 plt.title(&quot;T-s-Diagramm für Wasser&quot;)
 plt.xlabel(&quot;Spezifische Entropie s in kJ/kg K&quot;, fontsize=10)
 plt.ylabel(&quot;Temperatur T in K&quot;, fontsize=10)
 plt.legend(loc=&quot;best&quot;)
 plt.grid(True)
 plt.show()

Ausgabe (in etwa so):

[[Datei:T-s-Diagramm fuer Wasser.svg|400px]]

== CoolProp ==
Auch mit CoolProp können Stoffdaten berechnet werden. Siehe auch [https://coolprop.org/coolprop/wrappers/Python/index.html]

Beispiel (Wasser bei 20bar und 400°C):
 import CoolProp.CoolProp as CP
 
 fluid = 'Water'
 T = 673.15   # Temperatur in Kelvin
 P = 20e5     # Druck in Pascal
 
 dichte = CP.PropsSI('D', 'T', T, 'P', P, fluid)
 enthalpie = CP.PropsSI('H', 'T', T, 'P', P, fluid)
 entropie = CP.PropsSI('S', 'T', T, 'P', P, fluid)
 
 print(f&quot;Spez. Volumen: {1/dichte:.6f} m³/kg&quot;)
 print(f&quot;Spez. Enthalpie: {enthalpie:.2f} J/kg&quot;)
 print(f&quot;Spez. Entropie: {entropie:.2f} J/kgK&quot;)

Ausgabe:
 Spez. Volumen: 0.151215 m³/kg
 Spez. Enthalpie: 3248344.02 J/kg
 Spez. Entropie: 7129.16 J/kgK

== iapws ==
Um Werte für Wasser(dampf) zu erhalten (IAPWS; '''I'''nternational '''A'''ssociation for the '''P'''roperties of '''W'''ater and '''S'''team) gibt es die Bibliothek iapws. Siehe auch [https://iapws.org/] und [https://pypi.org/project/iapws/]

Beispiel (Wasser für 20bar und 400°C):
 from iapws import IAPWS97
 
 dampf = IAPWS97(P=2.0, T=673.15)
 
 print(f&quot;Spezifisches Volumen: {dampf.v:.6f} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {dampf.h:.2f} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {dampf.s:.4f} kJ/(kgK)&quot;)
 print(f&quot;Phase: {dampf.phase}&quot;)

Ausgabe:
 Spezifisches Volumen: 0.151208 m³/kg
 Spezifische Enthalpie: 3248.23 kJ/kg
 Spezifische Entropie: 7.1290 kJ/(kgK)
 Phase: Gas

== TESPy ==
Ein anderes Modul für einen anderen Aufgabenzweck ist TESPy ('''T'''hermal '''E'''ngineering '''S'''ystems in '''Py'''thon). Dieses Modul ist für die Anlagensimulation zuständig. Für nähere Informationen siehe [https://tespy.readthedocs.io/en/main/getting_started/introduction.html]. Als Beipiel sei hier vorerst Code, der von der Google KI generiert wurde, angeführt. Der Code wurde überarbeitet, damit keine Warnungen auftreten. Bitte aber den Code trotzdem mit Vorsicht genießen, auch KI-generierter Code kann Fehler aufweisen. Eine Pumpe wird berechnet:

 from tespy.components import Sink, Source, Pump
 from tespy.connections import Connection
 from tespy.networks import Network
 
 # 1. Netzwerk definieren (Zentrales Steuerungselement)
 # Wir wählen Wasser als Fluid und bar/Celsius als Einheiten
 nw = Network(fluids=[&quot;water&quot;])
 nw.units.set_defaults(pressure=&quot;bar&quot;, pressure_difference=&quot;bar&quot;, 
                       temperature=&quot;°C&quot;, enthalpy=&quot;kJ / kg&quot;)
 
 # 2. Komponenten erstellen
 eingang = Source(&quot;Wasserquelle&quot;)
 ausgang = Sink(&quot;Wasserspeicher&quot;)
 pumpe = Pump(&quot;Speisewasserpumpe&quot;)
 
 # 3. Verbindungen definieren (Komponenten miteinander verknüpfen)
 c1 = Connection(eingang, &quot;out1&quot;, pumpe, &quot;in1&quot;)
 c2 = Connection(pumpe, &quot;out1&quot;, ausgang, &quot;in1&quot;)
 
 # Verbindungen dem Netzwerk hinzufügen
 nw.add_conns(c1, c2)
 
 # 4. Randbedingungen und Parameter festlegen
 # Zustand am Eingang (Druck, Temperatur, Massenstrom, Fluid-Zusammensetzung)
 c1.set_attr(
     v=1,  # Massenstrom: 1 kg/s
     T=20,  # Temperatur: 20 °C
     p=1,  # Druck: 1 bar
     fluid={&quot;water&quot;: 1},  # 100% Wasser
 )
 
 # Zustand am Ausgang / Zielwerte der Pumpe
 c2.set_attr(p=10)  # Ziel-Druck nach der Pumpe: 10 bar
 
 # Pumpeneigenschaften festlegen
 pumpe.set_attr(eta_s=0.8)  # Isentroper Wirkungsgrad von 80%
 
 # 5. Simulation ausführen
 nw.solve(mode=&quot;design&quot;)
 
 # 6. Ergebnisse ausgeben
 nw.print_results()
 
 # Spezifische Werte direkt auslesen
 print(&quot;\n--- Auswertung ---&quot;)
 print(f&quot;Erforderliche Pumpenleistung: {pumpe.P.val / 1000:.2f} kW&quot;)
 print(f&quot;Temperatur nach der Pumpe: {c2.T.val:.2f} °C&quot;)

Ausgabe (gekürzt):
  iter  | residual   | progress   | massflow   | pressure   | enthalpy   | fluid      | component  
 -------+------------+------------+------------+------------+------------+------------+------------
  1     | 7.04e+04   | 12 %       | 9.96e+02   | 0.00e+00   | 8.81e+04   | 0.00e+00   | 0.00e+00   
  2     | 5.91e-12   | 100 %      | 1.11e-13   | 0.00e+00   | 7.39e-12   | 0.00e+00   | 0.00e+00   
  3     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
  4     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
 Total iterations: 4, Calculation time: 0.01 s, Iterations per second: 480.85
 
 ##### RESULTS (Pump) #####
 +-------------------+----------+----------+-----------+----------+----------+----------+
 |                   |        P |       pr |        dp |      eta |    eta_s |     head |
 |-------------------+----------+----------+-----------+----------+----------+----------|
 | Speisewasserpumpe | 1.12e+06 | 1.00e+01 | -9.00e+00 | 8.00e-01 | 8.00e-01 | 9.19e+01 |
 +-------------------+----------+----------+-----------+----------+----------+----------+
 ...
 ...
 --- Auswertung ---
 Erforderliche Pumpenleistung: 1124.77 kW
 Temperatur nach der Pumpe: 20.07 °C

= Stochastik =
Die {{W|Stochastik}} ist ein sehr weites Feld. Hier werden etliche wichtige Themen kurz angerissen. Python stellt mit den Moduln math und statistics Software zu diesem Zwecke bereit. math und statistics sind bereits im Lieferumfang von Python enthalten. Aber auch mit den externen Modulen NumPy, SciPy, stochastic und pandas kann man Stochastik in Python betreiben. Die Theorie der Wahrscheinlichkeitsrechnung und Statistik soll etwas später in Band 5 dieser Buchreihe behandelt werden.

== Lageparameter == 
 import statistics
 
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 
 m1 = statistics.mean(werte)
 m2 = statistics.mode(werte)
 m3 = statistics.median(werte)
 
 print(&quot;Arithmetischer Mittelwert = &quot;, m1)
 print(&quot;Modalwert = &quot;, m2)
 print(&quot;Median = &quot;, m3)

Ausgabe:
 Arithmetischer Mittelwert =  3.5
 Modalwert =  1
 Median =  3.0

== Streuungsparameter ==
Beispiel (Berechnung der Standardabweichung):
 import statistics
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 s = statistics.stdev(werte)
 print(&quot;Standardabweichung = &quot;, s)

Ausgabe:
 Standardabweichung =  2.6770630673681683

Beispiel (Berechnung des Variationskoeffizienten V = Standardabweichung/Mittelwert)
 import numpy as np
 from scipy import stats
 import statistics
 
 k = 50
 
 dat1 = [14, 21, 18, 25, 30, 17, 20]
 dat = np.array(dat1)
 
 # Mit SciPy
 v = stats.variation(dat)
 vddof = stats.variation(dat, ddof=1)
 print(&quot;V SciPy: &quot;, v)
 print(&quot;V DDOF SciPy: &quot;, vddof)
 print(k*&quot;-&quot;)
 
 # mit NumPy
 mittelwert1 = np.mean(dat)
 std_abw1 = np.std(dat)
 std_abw1ddof = np.std(dat, ddof=1) 
 v1= std_abw1 / mittelwert1
 v1ddof = std_abw1ddof / mittelwert1
 print(&quot;Mittelwert NumPy: &quot;, mittelwert1)
 print(&quot;Std.abw. NumPy: &quot;, std_abw1)
 print(&quot;Std.abw. DDOF NumPy: &quot;, std_abw1ddof)
 print(&quot;V NumPy: &quot;, v1)
 print(&quot;V DDOF NumPy: &quot;, v1ddof)
 print(k*&quot;-&quot;)
 
 # nur mit reinem Python
 mittelwert2 = statistics.mean(dat1)
 std_abw2 = statistics.stdev(dat1)
 v2 = std_abw2 / mittelwert2
 print(&quot;Mittelwert Python: &quot;, mittelwert2)
 print(&quot;Std.abw. Python: &quot;, std_abw2)
 print(&quot;V Python:&quot;, v2)
 print(k*&quot;-&quot;)

Ausgabe:
 V SciPy:  0.23890355966467272
 V DDOF SciPy:  0.25804533701889254
 --------------------------------------------------
 Mittelwert NumPy:  20.714285714285715
 Std.abw. NumPy:  4.948716593053935
 Std.abw. DDOF NumPy:  5.3452248382484875
 V NumPy:  0.23890355966467272
 V DDOF NumPy:  0.2580453370188925
 --------------------------------------------------
 Mittelwert Python:  20.714285714285715
 Std.abw. Python:  5.3452248382484875
 V Python: 0.2580453370188925
 --------------------------------------------------

Der Unterschied bei der Standardabweichung zwischen reinem Python und den externen Bibliotheken SciPy und NumPy entsteht dadurch, dass einmal durch (n-1) und das andere Mal nur durch n dividiert wird. Dies kann bei NumPy und SciPy dadurch entschärft werden, indem &lt;code&gt;ddof=1&lt;/code&gt; gesetzt wird. ddof steht für '''D'''elta '''D'''egrees '''o'''f '''F'''reedom. &lt;small&gt;Je größer die Anzahl der Datensätze n wird, umso weniger spielt das eine Rolle.&lt;/small&gt;

== Kombinatorik ==
Beispiel:

 import math
 
 n = 7
 k = 5
 
 print(&quot;n! = &quot;, math.factorial(n))
 print(&quot;Kombinationen (n über k) = &quot;, math.comb(n, k))

Ausgabe:
 n! =  5040
 Kombinationen (n über k) =  21

Siehe zu diesem Thema auch [[Ing Mathematik: Permutationen, Kombinationen, binomischer Lehrsatz]]. Die Anzahlen lassen sich einfach aus den dortigen Formeln ermitteln, z.B. bei Permutationen mit &lt;math&gt;n!&lt;/math&gt; oder Variationen mit Wiederholungen als &lt;math&gt;n^k&lt;/math&gt;. Will man die Kombinationen oder Variationen aber auch als Liste ausgeben, so kann das Modul &lt;code&gt;itertools&lt;/code&gt; nützlich sein.  

Beispiel (Variationen ohne Wiederholung):

 from itertools import permutations
 
 menge = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]  # n = 4
 k = 3
 
 variationen = list(permutations(menge, k))
 
 for v in variationen:
     print(&quot;&quot;.join(v))
 
 print(50*&quot;-&quot;)
 print(len(variationen))

Ausgabe (gekürzt):
 ABC
 ABD
 ACB
 ...
 DCA
 DCB
 --------------------------------------------------
 24

Siehe zum Modul &lt;code&gt;itertools&lt;/code&gt; auch die Website [https://docs.python.org/3/library/itertools.html].

* Variationen mit Wiederholung: &lt;code&gt;itertools.product()&lt;/code&gt;
* Kombinationen ohne Wiederholung: &lt;code&gt;itertools.combinations()&lt;/code&gt;
* Kombinationen mit Wiederholung: &lt;code&gt;itertools.combinations_with_replacement()&lt;/code&gt;

== Zufallszahlen ==
Beispiel:
 import random
 
 # Ganzzahlige Zufallszahl von 1 bis 10
 zufallszahl1 = random.randint(1, 10)
 
 # Gleitpunktzahlen
 # zwischen 0.0 und 1.0
 zufallszahl2 = random.random()
 # Zahl zwischen 1.5 und 9.5
 zufallszahl3 = random.uniform(1.5, 9.5)
 
 # aus Liste auswählen
 farbe = [&quot;Rot&quot;, &quot;Grün&quot;, &quot;Blau&quot;]
 zufallswert = random.choice(farbe)
 
 print(zufallszahl1)
 print(zufallszahl2)
 print(zufallszahl3)
 print(zufallswert)

Ausgabe, z.B.:
 5
 0.14147945849015753
 6.894003397570905
 Rot

Benötigt man mehrere Zufallszahlen, so ist das Modul &lt;code&gt;numpy&lt;/code&gt; zu bevorzugen, z.B.:
* Normalverteilung: &lt;code&gt;np.random.normal(...)&lt;/code&gt;
* Gleichverteilung: &lt;code&gt;np.random.uniform(...)&lt;/code&gt;

== Histogramm ==
Zum Thema Histogramm siehe {{W|Histogramm}}.

Beispiel (mit Matplotlib):

 import matplotlib.pyplot as plt
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 
 plt.hist(daten, bins=25, edgecolor='darkgray')
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm.svg|300px]]

Beispiel (mit Seaborn):

 import matplotlib.pyplot as plt
 import seaborn as sns
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 sns.set_theme(style=&quot;darkgrid&quot;)
 sns.histplot(data=daten)
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm2.svg|300px]]

Das Kürzel &lt;code&gt;sns&lt;/code&gt; ist Konvention und steht für die fiktive Figur '''S'''amuel '''N'''orman '''S'''eaborn aus der US-Fernsehserie {{W|The West Wing – Im Zentrum der Macht | The West Wing}}.

== Box-Plot ==
[[File:Elements of a boxplot.svg|400px]]

Siehe auch {{W|Box-Plot}}.

Beispiel (mit Seaborn erstellt):
 import seaborn as sns
 import matplotlib.pyplot as plt
 
 df = sns.load_dataset(&quot;tips&quot;)
 sns.boxplot(data=df, x=&quot;day&quot;, y=&quot;tip&quot;, hue=&quot;day&quot;, legend=False)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot.svg|400px]]

Beispiel (mit Matplotlib erstellt):

 import matplotlib.pyplot as plt
 
 daten = [12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25]
 
 plt.boxplot(daten, patch_artist=True)
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot2.svg|300px]]

Um mehrere Box-Plots unterschiedlicher Farbe mit Matplotlib in einem Diagramm zu zeichnen, können Sie folgendermaßen vorgehen:

 import matplotlib.pyplot as plt
 
 daten = [[12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25],
          [10, 19, 20, 21, 20, 30, 19, 40, 11, 17, 19, 21]]
 
 farben = [&quot;green&quot;, &quot;blue&quot;]
 
 boxplot = plt.boxplot(daten, patch_artist=True)
 
 for patch, farbe in zip(boxplot['boxes'], farben):
     patch.set_facecolor(farbe)
 
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

== Regressionsrechnung ==
Beispiel:
 import numpy as np
 import matplotlib.pyplot as plt
 
 # Messpunkte
 x = np.array([1, 3, 5, 6, 8, 10, 20])
 y = np.array([3, 4, 5, 5, 7, 9, 11])
 
 # Regressionskurve (Grad 1 = lineare Regression, 2 = Polynom-Regression 2. Gr.)
 # y = kx + d
 k, d = np.polyfit(x, y, deg=1)
 # y = ax**2 + bx + c
 a, b, c = np.polyfit(x, y, deg=2)
 
 x_l = np.linspace(1, 20, 100)
 y_p = a * x_l**2 + b * x_l + c
 
 # Zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.plot(x, k*x + d, color='blue', label='Regressionsgerade')
 plt.plot(x_l, y_p, color='red', label='Regressionspolynom 2. Gr.')
 plt.xlabel('x')
 plt.ylabel('y')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_regression.svg|400px]]

== Korrelationsrechnung ==
Beispiel:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 # Messdaten
 x = [1, 3, 4, 5, 6]
 y = [2, 4, 6, 8, 5]
 
 daten = {'X': x, 'Y': y}
 df = pd.DataFrame(daten)
 
 # Korrelation
 korr = df['X'].corr(df['Y'])
 print(f&quot;Korrelationskoeff.: {korr}&quot;) 
 
 # Messpunkte zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:
 Korrelationskoeff.: 0.7556096518348252

[[Datei:IngMath_korrelation.svg|300px]]

== Mengen und Venn-Diagramme ==
Beispiel: 
 import matplotlib.pyplot as plt
 from matplotlib_venn import venn2
 
 menge_a = {1, 2, 3, 4, 5, 6}
 menge_b = {4, 5, 6, 7, 8}
 
 vereinigung = menge_a | menge_b
 schnitt = menge_a &amp; menge_b
 print(&quot;Vereinigungsmenge = &quot;, vereinigung)
 print(&quot;Schnittmenge = &quot;, schnitt)
 
 venn2([menge_a, menge_b], set_labels=('Menge A', 'Menge B'))
 plt.show()

Ausgabe:
 Vereinigungsmenge =  {1, 2, 3, 4, 5, 6, 7, 8}
 Schnittmenge =  {4, 5, 6}

[[Datei:IngMath_venn.svg|300px]]

Siehe auch {{W|Mengendiagramm#Venn-Diagramme}}.

== Verteilungs- und Dichtefunktion ==
* CDF ... '''C'''umulative '''D'''istribution '''F'''unction, Verteilungsfunktion
* PDF ... '''P'''robability '''D'''ensity '''F'''unction, Dichtefunktion

Beispiel (Normalverteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 from scipy.stats import norm
 
 my, sigma = 0, 1
 x = np.linspace(-4, 4, 50)
 
 pdf = norm.pdf(x, my, sigma)
 cdf = norm.cdf(x, my, sigma)
 
 plt.plot(x, pdf, lw=2, label=&quot;Dichtefunktion&quot;)
 plt.plot(x, cdf, lw=2, label=&quot;Verteilungsfunktion&quot;)
 plt.legend()
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:IngMath_cdf_pdf.svg|300px]]

Beispiel (&lt;math&gt;\chi^2&lt;/math&gt;-Verteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 import scipy.stats as stats
 
 x = np.linspace(0, 20, 500)
 
 # df ... degree of freedom, Freiheitsgrad
 pdf = (stats.chi2.pdf(x, df=2), stats.chi2.pdf(x, df=5), stats.chi2.pdf(x, df=10))
 
 for i in range(0,3):
     if(i==0):
         lab = &quot;Freiheitsgrad 2&quot;
     elif(i==1):
         lab = &quot;Freiheitsgrad 5&quot;
     else:
         lab = &quot;Freiheitsgrad 10&quot;
 
     plt.plot(x, pdf[i], label=lab, lw=2)
 
 plt.grid()
 plt.legend()
 plt.show()

Ausgabe:

[[Datei:IngMath_chi2.svg | 300px]]

== Schätzen und Testen ==
=== Intervallschätzung ===
Als Beispiel seien Daten gegeben, die von ''Dürr, Mayer: Wahrscheinlichkeitsrechnung und Schließende Statistik; 7. Aufl., Hanser, 2014, Seite 137'' stammen. Und zwar soll das 95%-Vertrauensintervall für den Mittelwert des Kaloriengehalts (kcal/100g) von Hähnchen ermittelt werden. Wir wollen das mit Python inkl. NumPy und SciPy durchführen. Die Stichprobe ist groß (50 Hähnchen):

Python-Code:
 import numpy as np
 import scipy.stats as stats
 
 # Stichprobe
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203]
 
 # Parameter definieren
 konfidenzniveau = 0.95
 mean = np.mean(daten)
 std = np.std(daten, ddof=1)
 stdfehler = stats.sem(daten)
 
 intervall = stats.norm.interval(confidence=konfidenzniveau, loc=mean, scale=stdfehler)
 
 print(f&quot;Mittelwert: {mean}&quot;)
 print(f&quot;Standardabweichung: {std}&quot;)
 print(f&quot;Konfidenzintervall: {intervall}&quot;)

Ausgabe:
 Mittelwert: 215.48
 Standardabweichung: 33.14238915925757
 Konfidenzintervall: (np.float64(206.29356722321992), np.float64(224.66643277678006))

Diese Werte stimmen gerundet mit denen im genannten Buch überein. Zum Code selbst:
* sem steht für '''s'''tandard '''e'''rror of the '''m'''ean.
* &lt;code&gt;scipy.stats.norm&lt;/code&gt; ... Modul für die Normalverteilung.

=== Punktschätzung ===
Gleiche Daten wie oben bei der Intervallschätzung.

Python-Code:
 import numpy as np
 from scipy import stats
 
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203
         ]
 
 mu_hat, sigma_hat = stats.norm.fit(daten) 
 
 print(f&quot;Schätzer für den Erwartungswert (μ): {mu_hat:.4f}&quot;)
 print(f&quot;Schätzer für die Standardabweichung (σ): {sigma_hat:.4f}&quot;)

Ausgabe:
 Schätzer für den Erwartungswert (μ): 215.4800
 Schätzer für die Standardabweichung (σ): 32.8093

=== Hypothesentests ===
Beispiel:

 import numpy as np
 import scipy.stats as stats
 
 x_quer = 12.075      # Stichproben-Mittelwert
 var    = 0.069       # Stichproben-Varianz
 n      = 90          # Stichprobengröße
 my_0   = 12.0        # Nullhypothese
 alpha  = 0.05        # Signifikanzniveau
 
 z_stat = (x_quer - my_0) / np.sqrt(var / n)
 p_val = 2 * (1 - stats.norm.cdf(np.abs(z_stat)))
 
 print(f&quot;Z-Statistik: {z_stat:.4f}&quot;)
 
 if p_val &lt; alpha:
     print(f&quot;p-Wert: {p_val:.6f} &lt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird verworfen.&quot;)
 else:
     print(f&quot;p-Wert: {p_val:.6f} &gt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird nicht verworfen.&quot;)

Ausgabe:

 Z-Statistik: 2.7087
 p-Wert: 0.006755 &lt; alpha: 0.05
 Die Nullhypothese wird verworfen.

== Statistische Qualitätskontrolle ==
Beispiel (Mittelwertkarte):

 import numpy as np
 import matplotlib.pyplot as plt
 
 # Gegeben
 sollwert = 50.0
 varianz = 4.0
 stichproben_umfang = 1
 daten = [49.5, 50.2, 53.0, 48.1, 52.6, 53.4, 49.8]
 
 # Berechnung
 standardabweichung = np.sqrt(varianz)
 streuung = standardabweichung / np.sqrt(stichproben_umfang)
 
 cl = sollwert
 ucl = cl + 3 * streuung
 lcl = cl - 3 * streuung
 
 # Darstellung
 plt.plot(daten, marker='o', linestyle='-', color='b', label='Messdaten')
 plt.axhline(cl, color='green', linestyle='-', label=f'CL: {cl}')
 plt.axhline(ucl, color='red', linestyle='--', label=f'UCL: {ucl:.2f}')
 plt.axhline(lcl, color='red', linestyle='--', label=f'LCL: {lcl:.2f}')
 
 plt.title('Mittelwertkarte')
 plt.xlabel('Stichprobe')
 plt.ylabel('Wert')
 plt.legend(loc='lower left')
 plt.grid(True)
 plt.show()

Ausgabe:

[[Datei:IngMath_mittelwertkarte.svg|300px]]

Siehe auch {{W|Shewhart-Regelkarte}} und {{W|Qualitätsregelkarte}}.

* UCL ... '''U'''pper '''C'''ontrol '''Limit''', Obere Eingriffsgrenze
* LCL ... '''L'''ower '''C'''ontrol '''Limit''', Untere Eingriffsgrenze
* CL ... '''C'''enter '''L'''ine, Mittellinie

= Ein- und Ausgabe =
== print ==
Die Anweisung print haben wir schon oft verwendet. Hier soll anhand von Beispielen kurz beschrieben werden, was der Befehl print leisten kann.

 print(&quot;Hallo&quot;, &quot;Welt&quot;, 1, sep=&quot;-&quot;)
 print(&quot;Hallo&quot;, end=&quot; &quot;)
 print(&quot;Welt&quot;)

Ausgabe:
 Hallo-Welt-1
 Hallo Welt

== input ==
 a = int(input(&quot;Zahl 1: &quot;))
 b = int(input(&quot;Zahl 2: &quot;))
 
 print(&quot;a + b = &quot;, a+b)

Ausgabe (nach Eingabe der beiden Ganzzahlen):
 Zahl 1: 4
 Zahl 2: 5
 a + b =  9

== Aus Dateien lesen ==
Es seinen die datei.txt
 Hallo Welt.
 Wie geht es dir?
 ...

und test1.py
 dat = open(&quot;datei.txt&quot;, mode = &quot;r&quot;)
 print(dat.read())
 dat.close()

Ausgabe
 Hallo Welt.
 Wie geht es dir?
 ...

Mit dem open()-Befehl wird die Datei datei.txt im Lesemodus geöffnet (r ... read). Mit dem read()-Befehl wird die Datei eingelesen und mittels print ausgegeben.

== In Dateien schreiben ==
 dat = open(&quot;datei.txt&quot;, mode = &quot;a&quot;, encoding = &quot;utf-8&quot;)
 dat.write(&quot;Hänge Zeile an\n&quot;)
 dat.close()

Die Datei datei.txt sieht nach Abarbeitung des obigen Skripts nun so aus
 Hallo Welt.
 Wie geht es dir?
 ...
 Hänge Zeile an

Es wird die Datei im Schreibmodus geöffnet (a ... append (anhängend), w ... write (überschreibend)).
write() fügt hier also eine Zeile Text am Dateiende ein. close() schließt die Datei wieder.

Das close() kann man sich mit der with-Anweisung auch sparen.

 with open(&quot;datei.txt&quot;, mode=&quot;a&quot;, encoding=&quot;utf-8&quot;) as dat:
     dat.write(&quot;Hänge Zeile an\n&quot;)

= Benutzeroberflächen erstellen =
== tkinter ==
{{Wikipedia | Tkinter}}

Python bietet standardmäßig das Modul tkinter zur Programmierung von Benutzeroberflächen. Es müssen also bei der Verwendung von tkinter keine externen Module installiert werden. Hier wird eine (sehr) kurze Einführung in das Erstellen von grafischen Oberflächen mittels tkinter gegeben.

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 win.minsize(300, 50)
 but = tk.Button(win, text = &quot;Push the button&quot;)
 but.pack()
 win.mainloop()

Ausgabe:

[[Datei:PythonIng_gui1.jpg]]

Ein etwas komplizierteres Beispiel sei nachfolgend gezeigt. Es sollen zwei Strings miteinander verknüpft und ausgegeben werden. 

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 
 def on_button_clicked():
     str = ent1.get() + ent2.get()
     lab2[&quot;text&quot;] = str
  
 ent1 = tk.Entry(win)
 ent2 = tk.Entry(win)
 lab1 = tk.Label(win, text=&quot;verknuepfen mit&quot;)
 lab2 = tk.Label(win, text=&quot;&quot;) 
 but = tk.Button(win, text = &quot;=&quot;, command=on_button_clicked)
 
 ent1.pack(side=&quot;left&quot;)
 lab1.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 but.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 lab2.pack(side=&quot;left&quot;)
 
 win.mainloop()

Ausgabe  (vor der Eingabe der Teilstrings): 

[[Datei:PythonIng_gui2.jpg]]

Ausgabe (nach der Eingabe der Teilstrings und dem Drücken des =-Buttons): 

[[Datei:PythonIng_gui3.jpg]]

== curses ==
{{Wikipedia | curses}}

Mit dem curses-Modul lassen sich u.a. TUIs ('''T'''ext '''U'''ser '''I'''nterfaces) erstellen. Ein sehr einfaches Beispiel zur allgemeinen Funktionsweise wird nachstehend geliefert.
 
 import curses
 
 stdscr = curses.initscr()
 curses.start_color()
 curses.init_pair(1, curses.COLOR_RED, curses.COLOR_WHITE)
 stdscr.clear()
 
 stdscr.addstr(&quot;Hallo Welt&quot;, curses.color_pair(1))
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()
 
Als Ausgabe sollte &lt;span style=&quot;color:#FF0000;&quot;&gt;Hallo Welt&lt;/span&gt; (rote Schrift auf weißem Hintergrund) auf dem Terminal/der Konsole erscheinen. Getestet wurde dies mit openSUSE Tumbleweed, Python-Version 3.13.12. Das entsprechende Python-curses-Package muss installiert sein.

Allgemeine Informationen zur Terminal-/Konsolengröße und Cursorposition liefert folgendes Programm:
 
 import curses
 
 stdscr = curses.initscr()
 
 stdscr.addstr(3, 5, &quot;LINES: %d&quot; % curses.LINES)
 stdscr.addstr(4, 5, &quot;COLS:  %d&quot; % curses.COLS)
 
 (y,x) = stdscr.getyx()
 stdscr.addstr(5, 5, &quot;Momentane Cursorposition:  [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getbegyx()
 stdscr.addstr(6, 5, &quot;Koordinatenursprung:       [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getmaxyx()
 stdscr.addstr(7, 5, &quot;Fenstergröße:              [%d, %d]&quot; % (y, x))
 
 stdscr.addstr(11, 2, &quot;Taste drücken -&gt; Ende&quot;)
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()

Es sollte sich in etwa folgende Ausgabe ergeben:

     LINES: 44
     COLS:  110
     Momentane Cursorposition:  [4, 15]
     Koordinatenursprung:       [0, 0]
     Fenstergröße:              [44, 110]
 
 
 Taste drücken -&gt; Ende

Zur Funktionsweise von curses siehe auch das Wikibook [[ncurses]]. Zum Verständnis sind dort allerdings elementare Kenntnisse in der Programmiersprache C erforderlich.

== Qt ==
{{Wikipedia | Qt (Bibliothek)}}

Auch für das Qt-Framework gibt es eine Anbindung an Python. Nachfolgend ein einfaches Beispiel.

 import sys
 from PySide6.QtWidgets import QApplication, QLabel
 
 app = QApplication(sys.argv)
 label = QLabel(&quot;Hallo Welt!&quot;)
 label.show()
 sys.exit(app.exec())

Ausgabe:

[[Datei:PythonIng_gui10.png]]

== Gtk ==
{{Wikipedia | GTK (Programmbibliothek)}}

Eine idente Ausgabe, wie oben für Qt gezeigt, erzeugt z.B. folgendes Gtk-Programm:

 import gi
 gi.require_version(&quot;Gtk&quot;, &quot;4.0&quot;)
 from gi.repository import Gtk
 
 def on_activate(app):
     win = Gtk.ApplicationWindow(application=app)
     lab = Gtk.Label(label=&quot;Hallo Welt!&quot;)
     win.set_child(lab)
     win.present()
 
 app = Gtk.Application()
 app.connect('activate', on_activate)
 app.run(None)

Auch für die Benutzung von Qt und Gtk müssen die jeweiligen Packages installiert sein. Getestet wurden die entsprechenden Python-Programme nur unter openSUSE Tumbleweed. Wie das GTK-Paket unter MS Windows 11 installiert wird, siehe z.B. [https://www.gtk.org/docs/installations/windows Setting up GTK for Windows].

Damit sei aber das Thema &quot;Benutzeroberflächen erstellen&quot; hier abgeschlossen, da dies schon ein sehr spezielles Aufgabengebiet ist, das eher Informatiker und nicht so sehr Ingenieure anspricht. Bei Bedarf siehe aber ggf. die entsprechenden Links unten in diesem Tutorial. Dort sind weiterführende Informationen zu finden.

= Pandas kurz erklärt =
Hier wird kurz auf das externe Modul Pandas eingegangen. Pandas steht für '''Pan'''el '''Da'''ta und ist ein Modul für die Datenanalyse und -manipulation.

== Series ==
Vorstellbar ist eine &quot;Series&quot; wie eine einzelne Spalte in einem Tabellenkalkulationsprogramm.

Beispiel (Index implizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5]) # Temperaturwerte
 print(temp)

Ausgabe:
 0     8.5
 1    11.0
 2    12.5
 3    10.0
 4    13.0
 5    11.0
 6    14.5
 dtype: float64

Das Kürzel &lt;code&gt;pd&lt;/code&gt; ist Konvention. Es seien Temperaturwerte gegeben. Die erste Spalte bei der Ausgabe ist der Index. Die zweite Spalte enthält die Werte.

Beispiel (separater Zugriff auf den Index und auf die Werte):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5])
 print(temp.index)
 print(temp.values)

Ausgabe:
 RangeIndex(start=0, stop=7, step=1)
 [ 8.5 11.  12.5 10.  13.  11.  14.5]

Beispiel (Index explizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 print(&quot;*** Die gesamte Series ***&quot;)
 print(temp)
 
 print(&quot;*** Temperatur am Donnerstag ***&quot;)
 print(temp[&quot;Do&quot;])
 
 print(&quot;*** Tage wärmer als 12 Grad ***&quot;)
 temp_gr_12 = temp[temp &gt; 12]
 print(temp_gr_12)

Ausgabe:
 *** Die gesamte Series ***
 Mo     8.5
 Di    11.0
 Mi    12.5
 Do    10.0
 Fr    13.0
 Sa    11.0
 So    14.5
 dtype: float64
 *** Temperatur am Donnerstag ***
 10.0
 *** Tage wärmer als 12 Grad ***
 Mi    12.5
 Fr    13.0
 So    14.5
 dtype: float64

== DataFrame ==
Ein DataFrame entspricht einer Tabelle.

Beispiel (Erzeugen eines DataFrames):
 import pandas as pd
 
 tag   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 v1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=tag)
 v2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=tag)
 v3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=tag)
 
 tab = pd.concat([v1, v2, v3], axis=1)
 tab.columns = stadt
 
 print(tab)
 print(type(tab))

Ausgabe:
     Linz  Salzburg Innsbruck
 Mo     1         8     Hallo
 Di     2         9        16
 Mi     3        10        17
 Do     4        11        18
 Fr     5        12        19
 Sa     6        13        20
 So     7        14        21
 &lt;class 'pandas.core.frame.DataFrame'&gt;

Wir haben hier drei Datenspalten (v1, v2, v3) mit den Spaltennamen &quot;Linz&quot;, &quot;Salzburg&quot; und &quot;Innsbruck&quot;, sowie sieben Zeilen &quot;Mo&quot; bis &quot;So&quot;.

Beispiel (Zugriff auf eine Spalte):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab[&quot;Salzburg&quot;])

Ausgabe:
 Mo     8
 Di     9
 Mi    10
 Do    11
 Fr    12
 Sa    13
 So    14
 Name: Salzburg, dtype: int64

Beispiel (Zugriff auf eine Zeile):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab.loc[&quot;Di&quot;])

Ausgabe:
 Linz          2
 Salzburg      9
 Innsbruck    16
 Name: Di, dtype: object

== Grafiken erstellen ==
Hier sei nur ein Torten- oder Kreisdiagramm gezeichnet:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 expl = [0, 0.2, 0, 0, 0, 0, 0]
 temp.plot.pie(figsize=(5,5), explode=expl)
 plt.show()

Ausgabe:

[[Datei:IngPython_pandas1.svg|350px]]

Die &lt;code&gt;figsize&lt;/code&gt; hat nichts mit der Spaltenanzahl zu tun, sondern setzt die Fenster- oder Diagrammgröße in Inches (Breite * Höhe).
 
Mit Pandas kann man auch noch andere Diagrammarten erstellen, z.B. Linien- oder Balkendiagramme. Dies wird hier aber nicht vorgeführt.

== Arbeiten mit CSV- und LibreOffice-Dateien ==
Gegeben sei eine CSV-Datei test1.csv:
 Mai;Juni;Juli
 12;17;45
 15;65;65
 16;32;23
 4;14;7
 23;17;Keine Daten verfügbar
 67;Keine Daten verfügbar;45
 15;24;12

Lesen von dieser CSV-Datei:
 import pandas as pd
 
 tab = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 print(tab)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Schreiben in eine CSV-Datei test2.csv:
 import pandas as pd
 
 val = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 val.to_csv(&quot;test2.csv&quot;, index=False)

Ausgabedatei:
 Mai,Juni,Juli
 12,17,45
 15,65,65
 16,32,23
 4,14,7
 23,17,Keine Daten verfügbar
 67,Keine Daten verfügbar,45
 15,24,12

Die Ausgabedatei ist beinahe gleich wie die Eingabedatei. Es werden aber Kommas statt Strichpunkten verwendet. Daher kommt auch der Name CSV ('''C'''omma '''S'''eparated '''V'''alue). Will man wieder Strichpunkte, so kann man dies über den Parameter &lt;code&gt;sep=&quot;;&quot;&lt;/code&gt; in der &lt;code&gt;to_csv&lt;/code&gt;-Funktion machen.

Um direkt von einer ODS-Datei (LibreOffice Calc, '''O'''pen '''D'''ocument '''S'''preadsheet) zu lesen muss das Modul odfpy extra installiert sein (per YaST, pip etc.). Gelesen wird dann folgendermaßen:
 import pandas as pd
 
 df = pd.read_excel('test1.ods', engine='odf')
 print(df)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Die Datei &quot;test1.ods&quot; sei die Datei, aus der das obige &quot;test1.csv&quot; generiert wurde. Schreiben kann man ebenfalls in eine ODS-Datei:

 import pandas as pd
 
 daten = {
     &quot;Name&quot;: [&quot;Hugo&quot;, &quot;Richie&quot;, &quot;Wilhelmine&quot;],
     &quot;Alter&quot;: [38, 30, 29],
     &quot;Ort&quot;: [&quot;Linz&quot;, &quot;Innsbruck&quot;, &quot;Salzburg&quot;]
 }
 
 tab = pd.DataFrame(daten)
 
 with pd.ExcelWriter(&quot;test2.ods&quot;, engine=&quot;odf&quot;) as writer:
     tab.to_excel(writer, sheet_name=&quot;Daten&quot;, index=False)

Es ergibt sich eine &quot;test2.ods&quot;-Datei (Screenshot):

[[Datei:IngPython_pandas2.png|250px]]

== Sonstiges ==
Hier seien stichpunktartig einige weitere Features von Pandas angeführt:
* {{W|Pivot-Tabelle|Pivot-Tabellen}} (pivot ... Dreh-, Angelpunkt): Zweck - große Datenmengen schnell zusammenfassen, filtern und analysieren.
* NaN ('''n'''ot '''a''' '''n'''umber): In einem Datensatz fehlt ein Wert oder ist nicht definiert.
* groupby-Funktion: Daten strukturieren, aggregieren oder Zwischensummen bilden. 
* {{W|Binning#Datenverarbeitung_und_-analyse|Binning}}: Klassenbildung.
* Mehrstufige Indizierung (Hierarchical Indexing oder MultiIndex)
* Zeitreihen (Time Series)

Für tiefergehende und weiterführende Informationen wird auf das Buch von ''Klein: Numerisches Python; Hanser, 2023'' und [https://pandas.pydata.org/ pandas] verwiesen.

= Style Guide, flake8, pylint, Black etc. =
== Style Guide ==
Wie man schönen und richtigen Python-Code schreibt, erfahren Sie in
* [https://peps.python.org/pep-0008/ PEP 8 – Style Guide for Python Code]

== Formatter und Linter ==
Ein Modul, das prüft, ob die Richtlinien im Style Guide eingehalten wurden, ist ''flake8'':
* [https://flake8.pycqa.org/en/latest/ Flake8: Your Tool For Style Guide Enforcement]

Code formatieren kann man auch mit [https://pypi.org/project/black/ Black]. Z.B. übersetzt &lt;code&gt;black test1.py&lt;/code&gt; die Datei &lt;code&gt;test1.py&lt;/code&gt;

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)),
     (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

in 

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)), (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Die Programmausgabe ist 

 reformatted test1.py
 
 All done! ✨ 🍰 ✨
 1 file reformatted.

Der Unterschied zwischen Black und Flake8:
* Black ist ein Code-Formatter. Er formatiert Ihren Code um, sodass er im Einklang mit PEP 8 steht.
* Flake8 ist ein {{W|Lint (Programmierwerkzeug) | Code-Linter}}. Flake8 verändert Ihren Code nicht, sondern durchsucht ihn nach potenziellen Fehlern etc.

Am obigen Beispiel sieht man auch, dass flake8 und Black nicht immer einer Meinung sind. Flake8 (&lt;code&gt;flake8 test1.py&lt;/code&gt;) würde standardmäßig den mit Black formatierten Code bemängeln:

 test1.py:8:80: E501 line too long (80 &gt; 79 characters)

Diese Diskrepanz kann beseitigt werden. Da 79 Zeichen auf modernen Bildschirmen meist als zu kurz empfunden werden, ist ein Limit von 88 Zeichen (Black-Standard) oder mehr empfehlenswert. Um dies zu implementieren, erstellen Sie in Ihrem Projektverzeichnis eine &lt;code&gt;.flake8&lt;/code&gt;-Datei mit dem Inhalt

 [flake8]
 max-line-length = 88

Und schon ignoriert Flake8 dieses Problem.

Ein anderer Linter ist pylint. Der würde beim Abarbeiten des obigen Beispiels, z.B. mit &lt;code&gt;pylint test1.py&lt;/code&gt; noch eine Kleinigkeit bemängeln:

 ************* Module test1
 /home/hr/tmp/test1.py:1:0: C0114: Missing module docstring (missing-module-docstring)
 
 ------------------------------------------------------------------
 Your code has been rated at 8.57/10 (previous run: 8.57/10, +0.00)

Auch pylint muss vor der ersten Verwendung installiert werden (z.B. mittels pip, virtuelle Umgebung, YaST). Die Dokumentation zu pylint findet sich auf [https://pylint.readthedocs.io/en/latest/].

&lt;u&gt;Aufgabe:&lt;/u&gt; Fügen Sie einen &quot;module docstring&quot; in die &lt;code&gt;test1.py&lt;/code&gt;-Datei ein und testen Sie erneut mit flake8, Black und pylint. &lt;small&gt;Sehen Sie zum Thema docstrings auch [https://peps.python.org/pep-0257/#what-is-a-docstring PEP 257 – Docstring Conventions].&lt;/small&gt;

Es gibt noch weitere Formatierungswerkzeuge für Python-Code. Z.B. [https://docs.astral.sh/ruff/ Ruff], ein moderner Code-Formatter und -Linter. Mittels &lt;code&gt;ruff check test1.py&lt;/code&gt; würde obiger Code geprüft (Linter). &lt;code&gt;ruff format test1.py&lt;/code&gt; formatiert den Code (Formatter).

== Type Checker ==
&quot;Type Checker&quot; sind z.B.
* mypy
* pyright
* ty

Diese prüfen die Datentypen, z.B. in folgendem Code

 def greetings(name: str) -&gt; str:
     return &quot;Hello, %s&quot; % name
 
 
 print(greetings(42))

Python selbst, flake8, ruff oder black würden diesen Code ohne zu murren akzeptieren. &quot;Type Checker&quot; würden aber sehr wohl Alarm schlagen, z.B. liefert &lt;code&gt;mypy&lt;/code&gt; folgende Ausgabe

 test1.py:5: error: Argument 1 to &quot;greetings&quot; has incompatible type &quot;int&quot;; expected &quot;str&quot;  [arg-type]
 Found 1 error in 1 file (checked 1 source file)

Das funktioniert übrigens nicht nur bei Funktionsannotationen, sondern auch mit Variablen etc.

 from typing import Final
 
 # &quot;Konstante&quot;, ab Python 3.8
 NUMBER: Final = 123
 print(NUMBER)
 NUMBER = 125
 print(NUMBER)
 
 # Variable
 a: int = 345
 print(a)
 a = &quot;Irgendwas&quot;
 print(a)
 
 # Variable (Pipe-Symbol), ab Python 3.10
 b : int|str = 567
 print(b)
 b = &quot;sonstiges&quot;
 print(b)

Ausgabe mit python:
 123
 125
 345
 Irgendwas
 567
 sonstiges

Ausgabe mit mypy:
 test3.py:6: error: Cannot assign to final name &quot;NUMBER&quot;  [misc]
 test3.py:12: error: Incompatible types in assignment (expression has type &quot;str&quot;, variable has type &quot;int&quot;)  [assignment]
 Found 2 errors in 1 file (checked 1 source file)

Python kennt übrigens keine Konstanten. Man kann diese mittels Großbuchstaben andeuten. Das ist aber nur Konvention, hat aber keine sonstigen Auswirkungen. Oder man verwendet wie oben gezeigt &lt;code&gt;Final&lt;/code&gt;. Dann werfen Typchecker Errors aus.

==pydoc==
pydoc ist ein Werkzeug, um Python-Module, -Funktionen und -Klassen zu dokumentieren.

Beispiel &lt;code&gt;test1.py&lt;/code&gt;:
 &quot;&quot;&quot;Rechen-Modul.
 
 Funktionen die von pydoc gelesen werden.
 &quot;&quot;&quot;
 
 def multiply(a, b):
     &quot;&quot;&quot;Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
     
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a * b
     
 def add(a, b):
     &quot;&quot;&quot;Addiert zwei Zahlen und gibt das Ergebnis zurück.
    
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a + b
    
 
 if __name__ == '__main__':
     print(multiply(3, 5))
     print(add(4, 6))

Ausgabe mit &lt;code&gt;python3.13 -m pydoc test1&lt;/code&gt; auf der Konsole:

 Help on module test1:
 
 NAME
     test1 - Rechen-Modul. 
 
 DESCRIPTION
     Funktionen die von pydoc gelesen werden.
 
 FUNCTIONS
     add(a, b)
         Addiert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
     multiply(a, b)
         Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
 FILE
     /home/xyz/tmp/test1.py

Siehe zu diesem Thema z.B. auch [https://docs.python.org/3/library/pydoc.html]. Mittels &lt;code&gt;python3.13 -m pydoc -w test1&lt;/code&gt; kann man auch eine HTML-Dokumentation erstellen.

Wofür &lt;code&gt;if __name__ == '__main__':&lt;/code&gt; steht, siehe z.B. etwas später im Abschnitt [[Ing_Mathematik:_Python#Doctests]].

== Sonstige Tools ==
Andere Tools für die {{W|Statische Code-Analyse|statische Codeanalyse}}, die aber für Ingenieure weniger interessant sein dürften, sind z.B.
* Radon: Liefert verschiedene {{W|Softwaremetrik|Codemetriken}} (Komplexität, Wartbarkeitsindex ...)
* Bandit: Findet Sicherheitslücken

Tools für die {{W|Dynamisches Software-Testverfahren|dynamische Codeanalyse}}, z.B.:
* DynaPyt (Framework zur dynamischen Programmanalyse)
* cProfile (Profiler)
* Memory Profiler (Speicheranalyse)
* Memray (Speicheranalyse)
* tracemalloc (Speicheranalyse)

Paket- und Projektmanagement (pip-Ersatz etc.):
* uv
* Poetry
* Conda
* pipx

Packaging-Tools (Freezer) und {{W|Compiler#Sonderformen|Transpiler}} :
* pyinstaller
** erstellt eigenständige, ausführbare Binärdatei
** kein Cross-Compiler
** kein Schutz vor Reverse-Engineering
** langsam
** packt alles in eine Datei
** sehr große Datei
** Befehl, z.B.: &lt;code&gt;pyinstaller --onefile test1.py&lt;/code&gt;
** GUI: &lt;code&gt;auto-py-to-exe&lt;/code&gt;
* cx_Freeze
* nuitka
** Übersetzt Python-Code in C/C++-Code und weiter in eine ausführbare Datei
** kein Cross-Compiler
** Schutz vor Reverse-Engineering
** Befehl, z.B.: &lt;code&gt;nuitka --standalone --onefile test1.py&lt;/code&gt;
* cython

= Einige Integrierte Entwicklungsumgebungen (IDEs)=
Werden Programmtexte größer und umfangreicher, so ist das Arbeiten mit der interaktiven Programmierumgebung bzw. das direkte Ausführen von Python-Skripten mühsam. Man wünscht sich z.B. Hilfen zum Debuggen oder die automatische Code-Vervollständigung. Zu diesem Zweck wurden IDEs (Integrated Development Environments) geschaffen. Von diesen seinen nachfolgend auszugsweise einige kurz beschrieben. Testen Sie einfach aus, welche davon für Sie bzw. für Ihr Python-Projekt geeignet sind.

== IDLE ==
IDLE ist die mit dem Python-Programmpaket mitgelieferte IDE. Der Name leitet sich einerseits ab vom Monty-Python-Mitglied Eric Idle, andererseits steht es als Abkürzung für &quot;'''I'''ntegrated '''D'''evelopment and '''L'''earning '''E'''nvironment. IDLE ist einfach zu bedienen, bietet aber schon einen beachtlichen Leistungsumfang. Nachfolgend wird ein Screenshot zu IDLE geliefert. Rechts ist das Editor-Fenster zu sehen, links die interaktive Programmierumgebung. Um das Beispiel selbst nachvollziehen zu können, starten Sie IDLE. Das geht ähnlich, wie Sie die interaktive Programmierumgebung von Python starten (nur, dass Sie eben das IDLE-Icon doppelklicken und nicht das Python-Icon. Unter Linux geben Sie einfach in einem Terminal &lt;code&gt;idle3.13&lt;/code&gt; o. Ä. ein). Weiter geht es mit &quot;File - Open - ...&quot;. Die auszuführende Datei auswählen (im konkreten Fall ein &quot;Hallo-Welt&quot;-Programm). Es erscheint das rechte Fenster. Dort &quot;Run - Run Module&quot; auswählen. Und schon wird im linken Fenster &quot;Hallo Welt!&quot; ausgegeben.

[[Datei:PythonIng_idle1.jpg | 600px]]

Siehe auch {{W|IDLE}}.

== PyCharm ==
PyCharm ist ein kommerzielles Produkt. Es gab aber auch eine kostenlose Community Edition. Seit 2025 sind beide Varianten vereint. Für die ersten 30 Tage sind die Pro-Funktionen frei verfügbar, danach nur noch die Kernfunktionalitäten (oder man bezieht kostenpflichtig  die Pro-Version). Zu beziehen ist PyCharm unter dem Weblink [https://www.jetbrains.com/pycharm/]. Nachfolgend ein etwas abgewandeltes &quot;Hallo Welt&quot;-Programm, editiert und ausgeführt mit PyCharm.

[[Datei:PyCharm_IDE_2023_screenshot.png | 600px]]

Siehe auch {{W|PyCharm}}.

== Eric ==
Auch eric ist Open Source und steht unter der  GNU General Public License Version 3 oder später. Zu beziehen ist diese Software unter [https://eric-ide.python-projects.org/].

[[Datei:Screenshot_Eric_4.png | 600px]]

Siehe auch {{W|eric (Software)}}.

&lt;small&gt;
Unter openSUSE Tumbleweed sollte sich eric auch mit YaST installieren lassen. Bei mir gibt es aber dann beim Ausführen des eric-Programms eine Fehlermeldung (Stand März 2026): 
 
 ...
 ModuleNotFoundError: No module named 'PyQt6.QtPdfWidgets'

Umgehen kann man dieses Problem aber wieder mit dem Erstellen einer virtuellen Umgebung, in etwa so

 python3.13 -m venv ~/tmp/venv1
 cd ~/tmp/venv1/bin
 ./python3.13 -m pip install --upgrade --prefer-binary eric-ide
 ./eric7_ide
&lt;/small&gt;

== PyScripter ==
Vom Funktionsumfang vergleichbar mit den vorherigen IDEs ist PyScripter. Auch PyScripter ist Open Source. Die Projekt-Homepage findet sich auf [https://sourceforge.net/projects/pyscripter/]. PyScripter ist nur für MS Windows verfügbar.

[[Datei:PythonIng_pyscripter1.jpg | 600px]]

== Spyder IDE ==
Spyder enthält bereits eine stabile Python-Version und etliche Module (z.B. matplotlib, numpy, control). Ansonsten kann dieses Softwarepaket vom Funktionsumfang her mit den anderen genannten IDEs locker mithalten. Spyder wurde unter der MIT-Lizenz veröffentlicht. Diese Software findet sich auf [https://www.spyder-ide.org].

[[Datei:Spyder-windows-screenshot.png | 600px]]

Siehe auch {{W|Spyder (Software)}}

== Eclipse IDE==
Die {{W|Eclipse_(IDE)|Eclipse-IDE}} kann für Python aufgerüstet werden. Dazu gibt es das PyDev-Plugin. Installiert wird es über 
* Help &gt; Eclipse Marketplace... 
* Find - PyDev - Install
Danach muss noch der Pfad zum Python-Interpreter festgelegt werden 
* Window &gt; Preferences &gt; PyDev &gt; Interpreters &gt; Python Interpreter &gt; New ... 
Das Ergebnis ist ähnlich wie im folgenden Bild, nur dass statt C/C++ Python Verwendung findet. 

[[Datei:Setting Up Eclipse CDT helloout.png | 600px]]

== Sonstige ==
Die genannten IDEs sind nicht die Einzigen. Es gibt, um dem Image Pythons als beliebteste Programmiersprache gerecht zu werden, noch einige andere. Sowohl Open Source-Programme als auch kommerzielle Programme sind im Web zu finden, z.B. Thonny oder {{W|Visual Studio Code}}. Unter Linux kann man auch {{W|KDevelop}}, ausgestattet mit dem Python3-Plugin, einsetzen. Braucht man den Umfang von ausgewachsenen IDEs nicht, so kann man auch normale Texteditoren verwenden (z.B. {{W|Geany}} oder {{W|Kate_(Texteditor)|Kate}}).

= Debuggen und Testen =
Das Debuggen und Testen von Programmen sind wichtige Bestandteile der Programmierung. Syntaxfehler lassen sich i.A. leicht beheben. Schwieriger ist das Eingrenzen von logischen Fehlern, die ev. nur in bestimmten Situationen auftreten und keine explizite Fehlermeldung hervorrufen. Das Programm liefert falsche Ergebnisse oder es stürzt aus heiterem Himmel ab. Um das zu verhindern gibt es verschiedene Werkzeuge, die bei der Fehlersuche behilflich sein können. Vorerst siehe aber zwecks Begriffsklärung noch folgende Links: 
 
* {{W|Debuggen}}
* {{W|Debugger}}
* {{W|Softwaretest}}

&lt;gallery&gt;
First Computer Bug, 1947.jpg
Test ganzheitlich.png
V-Modell.svg
&lt;/gallery&gt;

== Das Modul pdb ==
Python bringt schon ein Modul zum Debuggen mit. Siehe z.B. [https://docs.python.org/3/library/pdb.html pdb — The Python Debugger].
Komfortabler lässt sich das aber mittels Integrierter Entwicklungsumgebungen (IDEs) angehen.

== Debuggen mit IDEs ==
Für die IDEs IDLE und Spyder sei kurz auf die entsprechenden Webseiten verwiesen:

* [https://www.cs.uky.edu/~keen/help/debug-tutorial/debug.html Debugging under IDLE].
* [https://docs.spyder-ide.org/current/panes/debugging.html Spyder Debugger]

Dort wird die Vorgehensweise auch mittels Screenshots erläutert.

== assert ==
assert ... behaupten, zusichern ({{W|Assertion (Informatik)}})

Python-Code:
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10., 0.)

Ausgabe:

 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10., 0.)
   File &quot;/home/hr/Develop/test1.py&quot;, line 4, in print1
     assert y != 0.0
            ^^^^^^^^
 AssertionError
 
Python-Code: 
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)
 
Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(&quot;10.&quot;, &quot;5.&quot;)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError
 
Aber auch bei nachfolgendem Code gibt es eine Fehlermeldung:

 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10, 5)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError

Damit letzteres funktioniert, kann man den Programmcode so umschreiben:
 def print1(x, y):
     assert type(x) == float or type(x) == int
     assert type(y) == float or type(y) == int
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 2.0
 
Und jetzt fangen wir den &lt;code&gt;AssertionError&lt;/code&gt; auf:
 def print1(x, y):
     try:
         assert type(x) == float or type(x) == int
         assert type(y) == float or type(y) == int
         assert y != 0.0
         print(x/y)
     except(AssertionError):
         print(&quot;Hallo&quot;)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)

Ausgabe:
 2.0
 Hallo

Ich hoffe, es ist wenigstens im Ansatz klar geworden, wofür &lt;code&gt;assert&lt;/code&gt; gut sein kann. Ausschalten kann man die &lt;code&gt;assert&lt;/code&gt;-Überprüfung übrigens mit dem Python-Schalter &lt;code&gt;-O&lt;/code&gt;.

== Doctests == 
Innerhalb eines Docstrings kann die Arbeit im interaktiven Modus simuliert werden. Nach den Promptzeichen (&gt;&gt;&gt;) erfolgen dann bei unserem Beispiel innerhalb des Docstrings simulierte Aufrufe der Funktion &lt;code&gt;print1()&lt;/code&gt;. Danach folgen jeweils die Sollresultate. Wird das Modul oder die Datei als Hauptprogramm aufgerufen, so wird die Funktion &lt;code&gt;doctest.testmode()&lt;/code&gt; aufgerufen und ein Bericht auf der Konsole ausgegeben. Wird das Modul nicht als Hauptprogramm aufgerufen, sondern importiert, dann wird diese &lt;code&gt;testmod&lt;/code&gt;-Funktion nicht aufgerufen. D.h. dieser Code kann sowohl für Testzwecke als auch für den produktiven Einsatz verwendet werden. Das ist auch sinnvoll, weil wenn man Teile der Datei immer löschen bzw. einfügen müsste, so würden sich Fehlerquellen auftun. Das würde den Sinn und Zweck von Doctests konterkarieren.  

 def print1(x=0., y=1.):
     &quot;&quot;&quot; Dividiere zwei Zahlen
     Autor: Intruder
     Datum: 12.08.2025
 
     &gt;&gt;&gt; print1(2., 1.)
     2.0
     &gt;&gt;&gt; print1(5., 2.)
     2.5
     &gt;&gt;&gt; print1(5.)
     5.0
     &quot;&quot;&quot;
     print(x/y)
 
 if __name__ == &quot;__main__&quot;:
     import doctest
     doctest.testmod(verbose=True)

Ausgabe:
 Trying:
     print1(2., 1.)
 Expecting:
     2.0
 ok
 Trying:
     print1(5., 2)
 Expecting:
     2.5
 ok
 Trying:
     print1(5.)
 Expecting:
     5.0
 ok
 1 items had no tests:
     __main__
 1 items passed all tests:
    3 tests in __main__.print1
 3 tests in 2 items.
 3 passed and 0 failed.
 Test passed.

Das gezeigte Beispiel ist so ziemlich das einfachste, das es gibt. Für weiterführende Details siehe z.B.:
* [https://peps.python.org/pep-0257/ PEP 257 – Docstring Conventions]
* [https://docs.python.org/3/library/doctest.html doctest — Test interactive Python examples]

''Einschub:'' Ganz ähnlich kann man auch Klassen testen, z.B. in folgendem Code-Fragment

 class Fahrzeug:
   # siehe Abschnitt &quot;Objektorientierte Programmierung&quot;
   # ...
 
 if __name__ == &quot;__main__&quot;:
   vauweh = Fahrzeug(170, 90)
   beemweh = Fahrzeug(200, 120)
   print(vauweh.convertGeschw())
   print(beemweh.convertGeschw())

Wird das Script als Hauptprogramm ausgeführt (z.B. zu Testzwecken), so erfolgt die Ausgabe der zwei, via &lt;code&gt;convertGeschw()&lt;/code&gt;, umgerechneten Geschwindigkeiten. Wird es aber als Modul eingebunden, so wird der letzte Programmabschnitt nicht ausgeführt (&lt;code&gt;__name__ == &quot;__main__&quot;&lt;/code&gt; ergibt &lt;code&gt;False&lt;/code&gt;).

== pytest ==
Siehe zu diesem Thema auch {{W|Modultest}}.

pytest ist ein externes Modul und muss vorab installiert werden, z.B. mittels 
 pip install -U pytest
 pip install -U pytest-html 

Python-Code, Datei test1.py:
 def add(x, y):
     return x + y
 
 def test_answer():
     assert add(1, 1) == 3

Starten von pytest in der Konsole:
 pytest test1.py
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py F                                                                                                            [100%]
 
 ========================================================= FAILURES ==========================================================
 ________________________________________________________ test_answer ________________________________________________________
 
     def test_answer():
 &gt;       assert add(1, 1) == 3
 E       assert 2 == 3
 E        +  where 2 = add(1, 1)
 
 test1.py:6: AssertionError
 ================================================== short test summary info ==================================================
 FAILED test1.py::test_answer - assert 2 == 3
 ===================================================== 1 failed in 0.09s =====================================================

Hier erhalten wir einen Fehler, da 1+1 eindeutig ungleich 3 ist. Aber aus irgendeinem Grund wollte der Programmierer oder Tester in diesem Fall, dass dies so ist. Testfälle werden übrigens mit dem Präfix &lt;code&gt;test_&lt;/code&gt; eingeleitet.

Python-Code:
 def add(x, y):
     return x + y + 1
 
 def test_answer():
     assert add(1, 1) == 3 
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py .                                                                                                            [100%]
 
 ===================================================== 1 passed in 0.01s =====================================================

Jetzt ist alles in Ordnung. Weiterführendes siehe z.B.

* [https://docs.pytest.org/en/stable/ pytest: helps you write better programs]

== unittest ==
Auch unittest dient zur Durchführung von Testreihen, ist aber Bestandteil von Python. Hier wird vorerst nicht näher darauf eingegangen. Siehe z.B. 
* [https://docs.python.org/3/library/unittest.html unittest — Unit testing framework]

Lt. ''Inden: Python Challenge; dpunkt, 2021, Seite 481''  soll unittest weniger komfortabel als pytest sein.

Einen Vergleich von unittest mit pytest findet man in
* [https://knapsackpro.com/testing_frameworks/difference_between/pytest/vs/unittest pytest vs unittest]

= Python und Anwendungsprogramme =
Bisher stand immer alleine die Programmiersprache Python (ev. unter Einbeziehung von Modulen) im Mittelpunkt der Betrachtungen. Aber Python kann auch als Makrosprache für Anwendungsprogramme auftreten. Als Beispiele seien {{W|FreeCAD}} und {{W|LibreOffice}} genannt.

== FreeCAD ==
FreeCAD ist ein freies 3D-CAD-Programm. Hier soll nicht auf die Bedienung dieses CAD-Pakets eingegangen werden, sondern nur auf die Möglichkeit, mittels Python Makros zu schreiben. Als einfacher Einstieg soll ein Makro erstellt werden, welches eine Kugel (rot) und einen Quader (blau) zeichnet. Folgende Vorbereitungsschritte sind erforderlich (es sei vorausgesetzt, dass FreeCAD schon am Rechner installiert ist. Downloaden können Sie das Programm von der Website [https://www.freecad.org/downloads.php?lang=en]):

* FreeCAD starten
* Leere Datei erstellen
* Makro &gt; Makros &gt; Erstellen ...

Es öffnet sich ein leeres Editorfenster, in das Sie folgenden Code eingeben können:

 import FreeCAD
 import Part
 
 doc = FreeCAD.newDocument()
 
 # Kugel
 kugel = Part.makeSphere(10)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Kugel&quot;)
 form_element.Shape = kugel
 kug = FreeCAD.ActiveDocument.getObject(&quot;Kugel&quot;)
 kug.ViewObject.ShapeColor = (1.0, 0.0, 0.0)
 neuePosition = App.Vector(5, 2.5, 2.5)
 kug.Placement = App.Placement(neuePosition, kug.Placement.Rotation)
 
 # Quader
 quader = Part.makeBox(5, 5, 50)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Quader&quot;)
 form_element.Shape = quader
 quad = FreeCAD.ActiveDocument.getObject(&quot;Quader&quot;)
 quad.ViewObject.ShapeColor = (0.0, 0.0, 1.0)
 
 doc.recompute()

Diesen Code können Sie nun ausführen:
* Makro &gt; Makro ausführen

Es ergibt sich folgende Ausgabe (gedreht und gezoomt):

[[Datei: PythonIng_freecad1.png|500px]]

Siehe auch [https://wiki.freecad.org/Python_scripting_tutorial/de# Anleitung Skripterstellung mit Python]. Getestet wurde obiges Beispiel mit FreeCAD 1.1.3 unter Linux und 1.1.1 unter MS Windows.

== LibreOffice ==
LibreOffice ist ein freies Officepaket ([https://de.libreoffice.org/]). Hier soll nur das Tabellenkalkulationsprogramm Calc kurz betrachtet werden. Es seinen in den ersten 3 Zellen (A1 bis A3) Zahlen gegeben. Diese sollen mit einem Python-Makro addiert und das Resultat in der Zelle A5 ausgegeben werden. Auch hier sind Vorbereitungsarbeiten nötig: 
* zuerst muss unter Linux das Verzeichnis &lt;code&gt;~/.config/libreoffice/4/user/Scripts/python&lt;/code&gt; erstellt werden
* für MS Windows ist es das Verzeichnis &lt;code&gt;%APPDATA%\LibreOffice\4\user\Scripts\python&lt;/code&gt; 
** drücken Sie zuerst Win + R (es öffnet sich das Ausführen-Fenster)
** geben Sie &lt;code&gt;%appdata%&lt;/code&gt; ein, danach drücken Sie Enter (es öffnet sich der Explorer)
** navigieren Sie zu dem genannten Verzeichnis bzw. erstellen Sie das Verzeichnis 
* in diesem Verzeichnis wird dann mit einem beliebigen Texteditor das Python-Makro erstellt, in unserem Fall die Datei &lt;code&gt;summiere_zellen.py&lt;/code&gt;:

 import uno
 
 def summiere_zellen(*args):
     # Zugriff auf das aktuelle Dokument und das aktive Tabellenblatt
     ctx = uno.getComponentContext()
     smgr = ctx.getServiceManager()
     desktop = smgr.createInstanceWithContext(&quot;com.sun.star.frame.Desktop&quot;, ctx)
     doc = desktop.getCurrentComponent()
     sheet = doc.getCurrentController().getActiveSheet()
 
     # Werte aus den Zellen A1 bis A3 auslesen
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
 
     # Addition der drei Werte
     summe = w1 + w2 + w3
 
     # Ergebnis in die Zelle A5 schreiben
     sheet.getCellRangeByName(&quot;A5&quot;).Value = summe

* siehe dazu ggf. auch [https://help.libreoffice.org/latest/de/text/sbasic/python/python_locations.html?DbPAR=BASIC].

Weiter geht es in LibreOffice Calc mit dem Menü ''Extras &gt; Makros &gt; Makros verwalten &gt; Python''. Dort wird das Makro &lt;code&gt;summiere_zellen&lt;/code&gt; ausgeführt. Es ergibt sich z.B. folgendes Resultat

[[Datei:PythonIng_libreoffice1.png]]

Das Kürzel &lt;code&gt;uno&lt;/code&gt; steht für '''U'''niversal '''N'''etwork '''O'''bjects. Etwas einfacher geht's auch so:

 def summiere_zellen():
     desktop = XSCRIPTCONTEXT.getDesktop()
     model = desktop.getCurrentComponent()
     sheets = model.getSheets()
     sheet = sheets.getByIndex(0)
     
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
     
     cell = sheet.getCellRangeByName(&quot;A5&quot;)    
     cell.setValue(w1 + w2 + w3) 

Empfohlen wird auch, das Erweiterungspaket APSO ('''A'''lternative '''P'''ython '''S'''cript '''O'''rganizer, apso.oxt) zu installieren. Die Vorgehensweise wird hier nicht gezeigt, sondern nur darauf hingewiesen, dass man das einfach &quot;googeln&quot; kann. Siehe zur Python-Programmierung für LibreOffice auch [https://wiki.documentfoundation.org/Macros/Python_Guide/de Makros/Python-Handbuch]. Getestet wurden obige Beispiele mit LibreOffice 26.2.5.1 unter Linux und 26.2.1.2 unter MS Windows.

= Ausblick =
Dies war eine kurze Einführung in die Berechnungs- und Darstellungsmöglichkeiten mit Python. Es sollten etliche relevante Themen behandelt, oder zumindest kurz angesprochen worden sein. Wem dieser Text nicht ausreichend ist, der sei auf die entsprechenden weiterführenden Weblinks, Bücher und die Python-Hilfefunktion verwiesen. Python kennt noch viel mehr Befehle, als hier dargestellt wurden. Das Themenspektrum ist auch durch die Einbindung externer Module fast beliebig erweiterbar.

= Weblinks=
== Python allgemein ==
* [https://www.python.org/ Python Homepage]

== Externe mathematische Module ==
* [https://numpy.org/ NumPy]
* [https://numpy.org/doc/stable/user/numpy-for-matlab-users.html NumPy for MATLAB users]
* [https://scipy.org/ SciPy]
* [https://www.sympy.org/en/index.html SymPy]
* [https://pandas.pydata.org/ pandas]
* [https://github.com/maroba/findiff findiff]
* [https://mpmath.org/ mpmath]

== Externe Module für Grafiken ==
* [https://matplotlib.org/ Matplotlib]
* [https://vpython.org/ VPython]
* [https://build123d.readthedocs.io/en/latest/ build123d]
* [https://docs.vtk.org/en/latest/api/python.html VTK]
* [https://docs.bokeh.org/en/latest/docs/first_steps.html bokeh]
* [https://py5coding.org/ py5]

== Erstellung von User Interfaces ==
* [https://docs.python.org/3/library/tkinter.html tkinter - Python interface to Tcl/Tk]
* [https://docs.python.org/3/library/curses.html curses - Terminal handling for character-cell displays]
* [https://wiki.qt.io/Qt_for_Python Qt for Python]
* [https://www.gtk.org/docs/language-bindings/python GTK and Python]

== Erstellen virtueller Umgebungen ==
* [https://docs.python.org/3/library/venv.html venv - Creation of virtual environments]

== Sonstige ==
* [https://python-control.readthedocs.io/en/stable/ Python Control Systems Library]
* [https://pypi.org/project/regex/ regex - Regular Expressions]
* [http://pyromat.org/ PYroMat]
* [https://coolprop.org/coolprop/wrappers/Python/index.html CoolProp]
* [https://pypi.org/project/iapws/ iapws]
* [https://tespy.readthedocs.io/en/main/getting_started/introduction.html TESPy - Thermal Engineering Systems in Python]
* [https://pint.readthedocs.io/en/stable/ pint]

= Bücher =
== Gedruckte Bücher, OpenBooks, Magazine ==
* Diverse: c't Python Lernen, Verstehen, Anwenden; Heise, 2022 
* Ernesti, Kaiser: Python3 - das umfassende Handbuch; 5. Aufl., Rheinwerk, [https://openbook.rheinwerk-verlag.de/python/ OpenBook]
* Iacono et al.: Programmieren trainieren; 3. Aufl., Hanser, 2023, ISBN 978-3-446-47766-7
* Inden: Python Challenge; dpunkt, 2021, ISBN 978-3-86490-809-5
* Klein: Numerisches Python; 2. Aufl., Hanser, 2023, ISBN 978-3-446-47170-2 
* Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler; Rheinwerk, 2021, ISBN 978-3-8362-7316-9
* Weigend: Python 3 - Das umfassende Praxisbuch; 9. Aufl., mitp, 2022, ISBN 978-3-7475-0544-1
* Woyand: Python für Ingenieure und Naturwissenschaftler; 4. Aufl., Hanser, 2021, ISBN 978-3-446-46483-4

== Andere Wikibooks ==
* [[:en:Subject:Python_programming_language | Englische Wikibooks zum Thema Python]]
* [[Python|Deutschsprachiges Python-Wikibook]] [[Bild:2von10.png|20%]]
* [[Python unter Linux|Python 2.7 unter Linux]] [[Bild:10von10.png|100%]]


{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}</text>
      <sha1>pf4yh2yqaxdercmdubaae75686ygl8i</sha1>
    </revision>
    <revision>
      <id>1092172</id>
      <parentid>1092171</parentid>
      <timestamp>2026-10-16T18:44:38Z</timestamp>
      <contributor>
        <username>Intruder</username>
        <id>1513</id>
      </contributor>
      <comment>/* Sonstiges */</comment>
      <origin>1092172</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="189482" sha1="k17uh10wpey3zmnryua2qufgj4o0xbp" xml:space="preserve">{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}


= Hallo Welt und allgemeine Hinweise =
== Was ist Python ==
* Python ist eine universelle höhere Programmiersprache.
* Python ist objektorientiert.
* Python ist Open-Source (Python Software Foundation License).
* Python ist für viele Betriebssysteme erhältlich (z.B. für Linux, MS Windows, macOS).
* Python ist ein Interpreter.
* Python ist durch Module fast beliebig erweiterbar.
* Python als Programmiersprache ist case-sensitive - d.h. Groß- und Kleinschreibung ist relevant bei der Eingabe von Befehlen.
* Python ist in etlichen Anwendungsprogrammen (z.B. {{W|FreeCAD}}, {{W|LibreOffice}}, {{W|GIMP}}, {{W|Blender (Software) | Blender}}) als Makrosprache verwendbar.

{{Wikipedia | Python (Programmiersprache)}}

== Python installieren ==
=== MS Windows ===
Laden Sie das aktuelle Python-Paket von der Webseite [https://www.python.org/] herunter. Weiter geht es wie bei jedem anderen größeren zu installierenden Programm. Einfach das Installationsprogramm im Explorer doppelklicken und den Anweisungen des Setup-Programmes folgen.

=== Linux ===
Entweder ist Python bereits standardmäßig installiert, ansonsten ist die Installation mittels Paketmanagementsystem einfach möglich. Aber auch die Spyder-Entwicklungsumgebung ([https://www.spyder-ide.org]) bietet einen guten Einstieg mit Python (das gilt auch für MS Windows). Spyder bringt auch schon etliche wichtige Module standardmäßig mit.

== Python starten ==
=== MS Windows ===
Das Icon für das Python-Programm doppelklicken. Und schon startet das Programm.

[[Datei:PythonIng_start1.jpg]]

Python im interaktiven Modus (REPL ... '''R'''ead-'''E'''valuate-'''P'''rint-'''L'''oop) präsentiert sich dann so:

 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

Alternativ kann das Programm auch über die Eingabeaufforderung oder die PowerShell gestartet werden:

 c:\devel\Python&gt;python.exe
 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

=== Linux ===
Tippen Sie einfach das Wort „python“ (oder unter openSUSE Tumbleweed z.B. auch „python3.11“ oder „python3.13“) in einem Linux-Terminal ein, schließen den Befehl mit der RETURN-Taste ab, und schon startet Python im interaktiven Modus:
 
 Python 3.13.12 (main, Feb 09 2026, 22:37:44) [GCC] on linux
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt; 

Es gibt auch noch andere Möglichkeiten Python zwecks Programmausführung zu starten, z.&amp;nbsp;B. den {{W|Shebang}} (&lt;code&gt;#!&lt;/code&gt;) am Beginn eines Python-Scripts. Das Script sei als Script.py gespeichert. Dann kann das Script mit ./Script.py ausgeführt werden. Für openSUSE Tumbleweed sei nachfolgend ein lauffähiges &quot;Hallo Welt!&quot;-Script angegeben. Es wird in diesem Script der Python-Interpreter in der Version 3.13 verwendet :

 #!/usr/bin/python3.13
 print(&quot;Hallo Welt!&quot;)

Die Berechtigungen zum Ausführen der Datei müssen natürlich noch richtig gesetzt werden, z.B. mittels &lt;code&gt;chmod 777 Script.py&lt;/code&gt;. &lt;small&gt;&lt;code&gt;chmod&lt;/code&gt; ist die Abkürzung für&quot;'''ch'''ange file '''mod'''e bits&quot;.&lt;/small&gt; 

&lt;small&gt;Die &quot;Maske&quot; &lt;code&gt;777&lt;/code&gt; ist nur für Testzwecke sinnvoll, weil sie leicht zu merken ist und für alle Benutzer alle Zugriffsberechtigungen ('''r'''ead/'''w'''rite/e'''x'''ecute für owner/group/others) setzt. Im richtigen Einsatz wird man das aus Sicherheitsgründen nicht so handhaben, sondern nur die Berechtigungen setzen, die unbedingt erforderlich sind. Welche Zugriffsberechtigungen gesetzt sind, kann man z.B. mit dem Befehl &lt;code&gt;ls -l&lt;/code&gt; oder &lt;code&gt;ll&lt;/code&gt; ('''l'''i'''s'''t directory contents) erfragen. Aber dazu im Moment genug. Erfahrene Linux-Nutzer kennen das ohnehin und Anfänger sollen jetzt nicht mit Linux-Interna überfordert werden. Bei Bedarf siehe die Linux-Man-Pages oder dezidierte Bücher zu Linux.&lt;/code&gt;&lt;/small&gt;

&lt;small&gt;Oder das Script wird in einen Pfad verschoben, in dem sich ausführbare Programme generell befinden (welche Verzeichnisse im PATH liegen, kann bspw. mit &lt;code&gt;echo $PATH&lt;/code&gt; abgefragt werden). Das Script kann dann wie ein normales Programm ohne weitere Angaben mit Script.py gestartet werden. Alternativ wird nicht das Script an sich verschoben, sondern nur ein symbolischer Link angelegt, z.B. mit &lt;code&gt;ln -s ~/tmp/Script.py ~/.local/bin/Script.py&lt;/code&gt;. &lt;code&gt;~/.local/bin&lt;/code&gt; sei ein im PATH gelegenes Verzeichnis. Dies sind aber schon Features für fortgeschrittene Linux-Benutzer und werden am Anfang eher selten benötigt.&lt;/small&gt;

== Ein paar Worte zur Erklärung ==
=== Tests ===
Getestet wurden die Beispiele unter den Betriebssystemen 
* MS Windows 10 mit der Python-Version 3.12.0 (teilweise auch mit 3.12.2 und 3.13.1; nur die Inhalte die bis spätestens Juli 2025 erstellt wurden) 
* MS Windows 11 ab der Python-Version 3.13.4 (nur zum Teil; ab Juli 2025)
* openSUSE Leap 15.6 mit der Python-Version 3.11.12 (Spyder, nur vereinzelt) und zum Teil mit 3.12.11 (ab Juli 2025 bis November 2025).
* openSUSE Tumbleweed ab der Python-Version 3.13.9 (nur vereinzelt, ab November 2025)

=== Popularität ===
* An Beliebtheit rangiert Python mit Stand September 2026 mit einem Rating von 17,76% an 1. Stelle vor C und C++ (lt. [https://www.tiobe.com/tiobe-index/ TPCI - TIOBE Programming Community Index]). 
* Lt. [https://innovationgraph.github.com/global-metrics/programming-languages GitHub Top 50 Programming Languages Globally] lag Python im Q1/2026 auf Rang 2, vor TypeScript und hinter JavaScript. 
* [https://pypl.github.io/PYPL.html PYPL] (Popularity of Programming Language Index) ist ein anderer Popularitätsindex für Programmiersprachen. Auch hier liegt Python mit großem Vorsprung auf dem ersten Platz (52,08%), gefolgt von Java (13,34%) und C/C++ (7,99%) (Stand September 2026). 

=== Namensgebung ===
Der Name &quot;Python&quot; rührt von der Komikertruppe {{W|Monty Python}} her. Die Icons für Python (z.B. Python selbst, Eric IDE, IDLE) sind aber durch die Python-Schlangenart symbolisiert.

&lt;gallery&gt;
Python-logo-notext.svg|Python-Logo
Guido van Rossum in PyConUS24.jpg|{{W|Guido van Rossum}} (geb. 1956), der Erfinder von Python
&lt;/gallery&gt;

== Ein erstes Programm ==
Kommentare werden in Python mit der Raute (#) eingeleitet. Sie werden vom Python-Interpreter ignoriert. Text kann mit der print-Funktion ausgegeben werden. Starten Sie Python und geben sie folgende Anweisungen zeilenweise ein

 &gt;&gt;&gt; # Das ist ein Kommentar
 &gt;&gt;&gt; print(&quot;Hallo Welt!&quot;)

Als Ergebnis erhalten Sie

 Hallo Welt!

Der Prompt (&gt;&gt;&gt;) ist selbstverständlich nicht einzutippen, sondern wird vom Python-System geliefert.

Strings können in Python entweder in Anführungszeichen (&quot;) gesetzt werden oder in Hochkommatas('). In diesem Text wird die erste Variante bevorzugt eingesetzt.

Im Gegensatz zu Julia ist es hier egal, ob zwischen &lt;code&gt;print&lt;/code&gt; und der öffnenden Klammer Leerzeichen stehen.

= Python als Taschenrechner =
== Allgemeines ==
Wir wollen 3 * 5 berechnen. Dazu starten wir Python im interaktiven Modus. Geben Sie dann die Formel  

 &gt;&gt;&gt; 3 * 5

ein, drücken die Taste ENTER/RETURN ({{Taste|↵}}) und erhalten als Ergebnis

 15

Auch kompliziertere Ausdrücke sind möglich. Beispielsweise mit Winkelfunktionen, Quadratwurzeln etc. Wir wollen nun den Ausdruck &lt;math&gt;\sin\sqrt{15}&lt;/math&gt; berechnen :

 &gt;&gt;&gt; import math
 &gt;&gt;&gt; math.sin(math.sqrt(15))
 -0.6679052983383519

Als erstes wird das math-Modul importiert. Dann wird der mathematische Ausdruck berechnet.

Eine andere Variante, die dasselbe Ergebnis liefert, ist

 &gt;&gt;&gt; from math import *
 &gt;&gt;&gt; sin(sqrt(15))
 -0.6679052983383519

Es wird also aus dem Modul &lt;code&gt;math&lt;/code&gt; alles importiert (erkennbar am &lt;code&gt;*&lt;/code&gt;). Will man nicht alles importieren, so kann man das auch einschränken:

 &gt;&gt;&gt; from math import sin, sqrt

Beenden lässt sich das Python-Programm durch Eingabe von &lt;code&gt;exit()&lt;/code&gt; (und natürlich ist zur Bestätigung die RETURN-Taste zu drücken). &lt;code&gt;exit&lt;/code&gt; (ohne Klammern) oder &lt;code&gt;quit&lt;/code&gt; werden auch akzeptiert.

== Die Hilfefunktion von Python ==
Bei Eingabe der Anweisung &lt;code&gt;help&lt;/code&gt; oder &lt;code&gt;help()&lt;/code&gt; springt Python in den Hilfemodus. 

Eingabe:
 &gt;&gt;&gt; help()
 
Eingabe:
 help&gt; math.sin

Ausgabe:
 Help on built-in function sin in math:
 
 math.sin = sin(x, /)
     Return the sine of x (measured in radians).

Für die komplette Python-Dokumentation siehe [https://docs.python.org/3/]. Verlassen kann man den Hilfemodus durch das Drücken von STRG-C, bzw. der Eingabe von q, quit oder exit mit anschließendem Drücken der RETURN-Taste.

== Aufgaben ==
* Erkunden Sie die Tangensfunktion &quot;tan&quot; mittels Python-Hilfe (vergessen Sie nicht das math-Modul zu importieren und das &lt;code&gt;math.&lt;/code&gt; vor &lt;code&gt;tan&lt;/code&gt;)
* Berechnen Sie mit Python den Ausdruck &lt;math&gt;\frac{1}{2}\cdot \text{e}^2 \cdot \tan(\pi/3)&lt;/math&gt;. Siehe für die Exponentialfunktion im Python-Hilfesystem auch den Befehl &lt;code&gt;math.exp&lt;/code&gt;. Alternativ kann auch die Konstante &lt;code&gt;math.e&lt;/code&gt; eingesetzt werden. Potenzieren kann man bei Python mit dem **-Operator (z.B. 2**3 = 8). Für &lt;math&gt;\pi&lt;/math&gt; gibt es &lt;code&gt;math.pi&lt;/code&gt;.

= Python als Scriptsprache =
Häufig wird man aber kompliziertere Anweisungsfolgen verarbeiten müssen. Diese will man normalerweise nicht jedesmal neu eingeben, sondern in einer Datei speichern und diese Datei dann zur Ausführung bringen. Speichern Sie dazu folgenden Code in einer Textdatei, z.B. unter MS Windows als c:\tmp\test1.py

 # Das ist ein Kommentar
 print(&quot;Hallo Welt!&quot;)

Python-Dateien werden mit der Dateiendung .py versehen. Achten Sie darauf, dass vor dem print keine Leerzeichen vorhanden sind. Das ist eine Python-Eigenheit. Wie wir später sehen werden, nutzt Python Einrückungen als syntaktisches Mittel, z.B. um bei Schleifen den Schleifenkörper zu kennzeichnen. 

Danach bringen Sie die Skriptdatei test1.py (sozusagen das Hauptprogramm) folgendermaßen zur Ausführung:

1) Starten Sie unter MS Windows die Eingabeaufforderung (oder alternativ auch die Windows PowerShell). Das sieht dann etwa so aus:

 Microsoft Windows [Version 10.0.19045.3693]
 (c) Microsoft Corporation. Alle Rechte vorbehalten.
 
 C:\Users\xyz&gt;

: &lt;small&gt;Falls jemand nicht weiß, wie man die Eingabeaufforderung startet: Eine Möglichkeit ist, einfach in der Taskleiste von Windows das &quot;Start&quot;-Symbol &amp;nbsp;([[Image:Windows_logo_-_2021_(Black).svg|10px]])&amp;nbsp; mit der rechten Maustaste anklicken. &quot;Ausführen&quot; auswählen (oder alternativ für die PowerShell unter Windows 10 den Eintrag &quot;Windows PowerShell&quot;, unter Windows 11 den Eintrag &quot;Terminal&quot;). Im sich öffnenden Dialogfenster gibt man in die &quot;Öffnen&quot;-Zeile das Wort &lt;code&gt;cmd&lt;/code&gt; ein und mit &quot;OK&quot; wird das Ganze bestätigt.&lt;/small&gt; 
 
2) Wechseln Sie mittels &lt;code&gt;cd c:\tmp&lt;/code&gt; in das Verzeichnis c:\tmp

3) Angenommen, Sie haben Python unter dem Pfad &lt;code&gt;c:\devel\Python\&lt;/code&gt; installiert. Starten Sie das Programm so (der Prompt &lt;code&gt;c:\tmp&gt;&lt;/code&gt;ist natürlich nicht mit einzutippen): 

 c:\tmp&gt;c:\devel\Python\python.exe test1.py

4) Wie erwartet ergibt sich folgende Ausgabe am Bildschirm

 Hallo Welt!

Die Vorgehensweise unter Linux ist prinzipiell gleich. Die kleinen Unterschiede, wie z.B. der Slash statt dem Backslash in Pfadangaben, sollten für Linux-Benutzer keine Hürde darstellen.

== Variablen ==
Variablenbezeichner können aus Buchstaben (A-Za-z), Ziffern (0-9) und Underscores (_) bestehen, dürfen aber nicht mit einer Zahl beginnen. Führende Underscores haben u.a. im Kontext mit der Objektorientierten Programmierung eine spezielle Bedeutung und sollten nicht für &quot;normale&quot; Variablenbezeichner verwendet werden.

Gültige Variablenbezeichner wären also:
 xyz
 x1
 _wert
 name_anzahl

Theoretisch kann man auch Umlaute, griechische Buchstaben u.ä. in Variablenbezeichnern nutzen, z.B.

 ößÜ = 16
 α = 134 
 print(ößÜ)
 print(α)

Ausgabe:
 16
 134

Davon wird aber aus offensichtlichen Gründen ({{W|Englisch als Lingua franca}}) abgeraten. Das Eurozeichen (€) etc. darf man ohnehin nicht in Variablenbezeichnern verwenden, dies ergäbe einen Syntaxfehler. Siehe dazu auch [https://peps.python.org/pep-3131/].

Es gibt in Python etliche Schlüsselwörter (z.B. for, if oder return). Diese dürfen nicht als eigene Variablenbezeichner verwendet werden. Eine Liste aller Schlüsselwörter liefert das Script

 import keyword
 print(keyword.kwlist)

&lt;small&gt;Übung: Speichern Sie dieses Script in eine Datei, z.B. in c:\tmp\test1.py. Führen Sie diese Datei aus, um die Liste der Schlüsselwörter auszugeben.&lt;/small&gt;

Da Python case-sensitiv ist, repräsentieren folgende Bezeichner verschiedene Variablen:
 xyz
 XYZ
 xYz

Werte werden an Variablen mittels Gleich-Zeichen (=) zugewiesen. Im Folgenden wird der Code immer in der Datei c:\tmp\test1.py gespeichert.

 x = 5
 y = 10
 z = x*y
 print(z)

Bringen Sie die Datei test1.py zur Ausführung, so erhalten Sie folgende Bildschirmausgabe

 50

Sie können auch mehrere Anweisungen in einer Zeile durch Semikolon getrennt schreiben. Dies führt aber zu unübersichtlichem Code.

 x = 5; y = 10; z = x*y; print(z)

Ausgabe:
 50

Auch aus der Programmiersprache C/C++ oder Java bekannte Konstrukte können Sie verwenden, z.B.
 x = 5
 # x = x - 2
 x -= 2
 print(x)

Bildschirmausgabe:

 3
 
Beachten Sie, dass mit dem =-Zeichen eine Wertezuweisung durchgeführt wird. Dies ist nicht äquivalent zum mathematischen =-Zeichen, wie am vorigen Beispiel zu ersehen ist. Den Inkrement-/Dekrementoperator (z.B. x++ oder x--) aus C/C++ oder Java kennt Python aber nicht.

Variablen sind nicht an einen bestimmten Datentyp gebunden, folgendes ist mit Python problemlos möglich:

 import math
 wert = 10
 print(wert)
 wert = 35.5
 print(wert)
 wert = &quot;Hallo&quot;
 print(wert)
 wert = math.pi
 print(wert)

Ausgabe:
 10
 35.5
 Hallo
 3.141592653589793

== Physische und logische Zeilen ==
In Python muss eine Anweisung in einer logischen Zeile Platz finden. Wird eine Anweisung aber zu lang für eine Zeile, dann kann sie in mehrere physische Zeilen unterteilt werden. Dies kann einerseits durch einen Backslash am Ende einer Zeile geschehen, z.B.

 a = 2 + \
 5
 
Dies stellt eine logische Zeile dar, die in zwei physische Zeilen unterbrochen ist.

Geklammerte Ausdrücke werden automatisch zu einer logischen Zeile verbunden, z.B.

 a = (2 + 
 5)
 
Achtung: Im ersten Beispiel darf nach dem Backslash nichts mehr stehen, auch kein Kommentar. Dies trifft im zweiten Bespiel nicht zu, hier könnte noch ein Kommentar folgen, z.B.

 a = (2 +    # Kommentar 
 5)

Auch für Strings gibt es Möglichkeiten, diese auf mehrere Zeilen aufzuspalten.

 # Kurzer String
 str1 = &quot;ABC&quot;
 
 # Langer String
 str2 = &quot;&quot;&quot;Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle&quot;&quot;&quot;
 
 # Backslash
 str3 = &quot;UVW\
 XYZ&quot;
 
 # Mit Klammern
 str4 = (&quot;Sehr langer Text, der automatisch .............. &quot;
         &quot;in einer einzigen Variable zusammengefügt wird.&quot;
 )
 
 print(str1)
 print(str2)
 print(str3)
 print(str4)

Ausgabe:

 ABC
 Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle
 UVWXYZ
 Sehr langer Text, der automatisch .............. in einer einzigen Variable zusammengefügt wird.

==Hexadezimale, oktale, binäre und andere Zahlen==
 d = 1050         # Dezimalzahl
 h = 0xAA2        # Hexadezimalzahl
 o = 0o12         # Oktalzahl
 b = 0b100001101  # Binärzahl
 
 print(d)
 print(h)
 print(o)
 print(b)

Ausgabe:
 1050
 2722
 10
 269

Groß- und Kleinbuchstaben sind in obigen Literalen übrigens egal. So kann man z.B. statt &lt;code&gt;0b1001&lt;/code&gt; auch &lt;code&gt;0B1001&lt;/code&gt; schreiben (siehe dazu [https://docs.python.org/3/reference/lexical_analysis.html#integer-literals]).

Sie können auch dezimale in hexadezimale Zahlen umwandeln, usw.:
 h = hex(1050)    # Dezimalzahl -&gt; Hexadezimalzahl
 b = bin(1050)    # Dezimalzahl -&gt; Binärzahl
 o = oct(1050)    # Dezimalzahl -&gt; Oktalzahl
 print(h)
 print(b)
 print(o)

Ausgabe:
 0x41a
 0b10000011010
 0o2032

Gegeben sei die Zahl 121 zur Basis 3. Diese soll in eine Dezimalzahl umgewandelt werden. Das kann so geschehen:

 z = int(&quot;121&quot;, 3)
 print(z)

Ausgabe:
 16

Dass dies richtig ist, davon kann man sich folgendermaßen überzeugen:
 &lt;math&gt; 1 \cdot 3^2 + 2 \cdot 3^1 + 1 \cdot 3^0 = 9 + 6+ 1 = 16 &lt;/math&gt;

Zahlen übersichtlicher schreiben kann man auch mittels Underscore, z.B.:

 print(&quot;Eine Million (Variante 1) =&quot;, 1000000)
 print(&quot;Eine Million (Variante 2) =&quot;, 1_000_000)
 print(&quot;Eine Rechnung:&quot;, 2_000 * 400_000);

Es ergibt sich bei beiden Varianten die gleiche Ausgabe. Variante 2 ist aber im Sourcecode leichter lesbar, detto die Zahlen in der Rechnung:

 Eine Million (Variante 1) = 1000000
 Eine Million (Variante 2) = 1000000
 Eine Rechnung: 800000000

== Strings und Platzhalter==
Ein paar einfache Beispiele:

 print(&quot;Hallo {}&quot; . format(&quot;Hugo&quot;))     # new style string formatting
 print(&quot;Hallo {:s}&quot; . format(&quot;Hugo&quot;))   # new style string formatting
 print(&quot;Hallo %s&quot; % &quot;Hugo&quot;)             # %-String

Ausgabe:

 Hallo Hugo
 Hallo Hugo
 Hallo Hugo

Python-Code (formatted string literals, Beispiel 1):
 str1 = &quot;Hallo&quot;
 str2 = &quot;Hugo&quot;
 print(f&quot;{str1} {str2}&quot;)

Ausgabe:
 Hallo Hugo

f-Strings (ab Python 3.6) sind die modernere Variante gegenüber %-Strings oder das ''new style string formatting''. Sie sind in der Regel auch schneller.

Python-Code (formatted string literals, Beispiel 2):
 wert = 11.567
 print(f&quot;Ausgabe: {wert:.5f}&quot;)

Ausgabe:
 Ausgabe: 11.56700

Komplexere Beispiele:

 print(&quot;Hallo {} und {}&quot; . format(&quot;Hugo&quot;, &quot;Mike&quot;))
 print(&quot;Hallo {name1} und {name2}&quot; . format(name2=&quot;Hugo&quot;, name1=&quot;Mike&quot;))
 # Füllzeichen: *
 # Bündigkeit: &gt; (=rechts), &lt; (=links), ^ (=zentriert)
 # Feldweite: 10
 # Typ: s (=String), f (=Gleitkommazahl), d (=Dezimalzahl) etc.
 print(&quot;Hallo {:*&gt;10s}&quot; . format(&quot;Hugo&quot;))
 print(&quot;Hallo {:*&lt;10s}&quot; . format(&quot;Hugo&quot;))

Ausgabe:

 Hallo Hugo und Mike
 Hallo Mike und Hugo
 Hallo ******Hugo
 Hallo Hugo******

Python-Code:
 str = &quot;Hallo\t%s\t%7.2f\t%10.2e\t%i&quot; % (&quot;Hugo&quot;, 12.34567, 34.567, 264)
 print(str)

Ausgabe:
 Hallo	Hugo	  12.35	  3.46e+01	264

== Unicode ==
Neben den bekannten ASCII-Zeichen lassen sich Zeichen auch mittels Unicode beschreiben. Griechische Buchstaben oder komplexere mathematische Operatoren - all das sollte kein Problem sein. Siehe auch {{W|Unicode}}, {{W|Liste der Unicodeblöcke}} und {{W|Unicodeblock Mathematische Operatoren}}. Im Folgenden werden ein paar Zeichen (Allquantor, Nabla-Operator, Existenzquantor), die man aus der Mathematik kennt, erzeugt. 
 
 ch1 = &quot;\N{FOR ALL}&quot;
 ch2 = &quot;\N{NABLA}&quot;
 ch3 = &quot;\u2203&quot;
 print(ch1, ch2, ch3)

Ausgabe:
 ∀ ∇ ∃

&lt;small&gt;Diese Ausgabe ergibt sich z.B. mit der IDLE-Shell oder mit Cygwin. Beim Ausführen über die Windows-Eingabeaufforderung oder Windows PowerShell unter MS Windows 10 erfolgt keine korrekte Darstellung. IDLE ist die mit Python mitgelieferte IDE ('''I'''ntegrated '''D'''evelopment '''E'''nvironment, Integrierte Entwicklungsumgebung). Gegen Ende dieses Textes wird IDLE kurz beschrieben.
Das Problem mit der Windows Eingabeaufforderung lässt sich aber umgehen. Man muss nur eine Schriftart auswählen, die die Zeichen kennt, z.B. &quot;DejaVu Sans Mono&quot;. Dazu klicken Sie einfach bei der Eingabeaufforderung mit der rechten Maustaste oben auf die weiße Leiste und wählen im aufpoppenden Fenster den Menüpunkt &quot;Eigenschaften&quot;. Es öffnet sich ein Dialogfenster. Über den Reiter &quot;Schriftart&quot; lässt sich nun die Schriftart einstellen. Unter MS Windows 11 oder openSUSE Leap 15.6 (bash-Konsole) gibt es dieses Problem ohnehin nicht.&lt;/small&gt;

== Reguläre Ausdrücke ==
Python kennt auch {{W|Regulärer Ausdruck|reguläre Ausdrücke}}. Dazu gibt es in Python das Modul &lt;code&gt;re&lt;/code&gt;. Beipielsweise sollen alle Zahlen (&lt;math&gt;\text{zahl}\in\mathbb{N}_0&lt;/math&gt;) in einem String gesucht und ausgegeben werden. Als String sei gegeben: &lt;code&gt;3x Grüße und 100 Kekse.&lt;/code&gt; Das Muster (Pattern) ist &lt;code&gt;\d+&lt;/code&gt;. &lt;code&gt;\d&lt;/code&gt; steht für eine Dezimalziffer 0-9. Das Plus-Zeichen (+) steht symbolisch für ein oder mehrere Zeichen des vorherigen Ausdrucks. Hier also ein oder mehrere Dezimalziffern. Es wird die Funktion &lt;code&gt;findall&lt;/code&gt; aus dem Modul &lt;code&gt;re&lt;/code&gt;verwendet.

Python-Code:
 from re import findall
 
 str = &quot;3x Grüße und 100 Kekse.&quot;
 pat = &quot;\\d+&quot;  # Doppel-Backslashes müssen verwendet werden, sonst gibt Python eine Warnung aus!
               # alternativ: pat = r&quot;\d+&quot; 
               # oder: pat = &quot;[0-9]+&quot;
 
 numb = findall(pat, str)
 print(numb)

Ausgabe:
 ['3', '100']

Python kennt noch viele weitere Möglichkeiten mittels regulärer Ausdrücke zu hantieren. Dies soll hier aber nicht vertieft werden, da das Thema schon ziemlich speziell und komplex ist. Bei Bedarf siehe aber z.B. die Bücher ''Weigend, Seite 380ff'' und ''Ernesti, Kaiser'' [https://openbook.rheinwerk-verlag.de/python/28_001.html] oder die Python-Dokumentation [https://docs.python.org/3/library/re.html]. Auch [[Python unter Linux: Reguläre Ausdrücke]] liefert ein umfangreiches und brauchbares Python-2-Kapitel zu den regulären Ausdrücken. Die dort gelisteten Beispiele müssten ggf. vor Verwendung auf Python-3 umgeschrieben werden. &lt;small&gt;Wie macht  man das? Dazu siehe z.B. [https://openbook.rheinwerk-verlag.de/python/43_001.html], [https://portingguide.readthedocs.io/en/latest/] oder [https://www.digitalocean.com/community/tutorials/how-to-port-python-2-code-to-python-3]&lt;/small&gt;

&lt;small&gt;Es gibt auch ein externes Modul ''regex'', das bei Bedarf extra installiert werden muss ([https://pypi.org/project/regex/]). Es bietet zusätzliche Funktionalität und gründlicheren Unicode-Support. Dies sei hier aber nur der Vollständigkeit halber erwähnt.&lt;/small&gt;

== Verzweigungen ==
=== if ===
Die IF-Verzweigung sei aus anderen Programmiersprachen bereits bekannt. In {{W|Pseudocode}} lässt sie sich folgendermaßen darstellen:

 WENN bedingung TRUE
   führe block1 aus
 SONST
   führe block2 aus
 ENDE 

Als {{W|Aktivitätsdiagramm|UML-Aktivitätsdiagramm}} sieht das in etwa so aus:

[[File:If-Then-Else-diagram.svg|200px]]

Und als {{W|Nassi-Shneiderman-Diagramm|Nassi-Shneiderman-Struktogramm}} so:

[[File:Zweiseitige Auswahl.png|250px]]

In Python gibt es keinen expliziten ENDE-Kennzeichner. Stattdessen wird der Code durch Einrückungen strukturiert. Alles mit der gleichen Einrückungstiefe gehört zum selben Block. Dies zeichnet Python vor anderen Programmiersprachen aus.

Die test1.py-Datei laute also wie folgt:

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
   print(&quot;x ist groesser oder gleich 4&quot;)  

Ausgabe:

 Der else-Zweig wird ausgefuehrt
 x ist groesser oder gleich 4

Man achte auch auf die Doppelpunkte in der if- und else-Zeile. Darauf vergisst man gerne, wenn man von anderen Programmiersprachen kommt.

Folgendes wäre in Python ein Fehler (genauer gesagt ein IndentationError).

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
     print(&quot;x ist groesser oder gleich 4&quot;)  

Auch Nachstehendes würde nicht zum gewünschten Ergebnis führen (löst aber keine Fehlermeldung aus). Der letzte print-Befehl ist schon außerhalb der IF-ELSE-Verzweigung.

 x = 3
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
 print(&quot;x ist groesser oder gleich 4&quot;)

Ausgabe:

 x ist kleiner als 4
 x ist groesser oder gleich 4

Python kennt eine Reihe von Vergleichs- und Verknüpfungsoperatoren:

    &lt;, &lt;= ... kleiner (gleich)
    &gt;, &gt;= ... größer (gleich)
    == ... gleich
    != ... ungleich
    is ... identisch
    is not ... nicht identisch
    and ... AND
    or ... OR
    not ... NOT

Beispielsweise:

 a = 5
 b = 9
 
 if a&lt;=10 and b!=7:
   print(&quot;OK&quot;)
 else
   print(&quot;Nicht OK&quot;)

Ausgabe:

 OK

Der else-Block kann übrigens auch ersatzlos entfallen. Als Pseudocode sieht das so aus

 WENN bedingung TRUE
   führe block aus
 ENDE

Mehrfache Verzweigungen werden durch das elif-Konstrukt erstellt. In Pseudocode:

 WENN bedingung1 TRUE
   führe block1 aus
 SONST WENN bedingung2 TRUE
   führe block2 aus
 SONST WENN bedingung3 TRUE
   führe block3 aus
 SONST
   führe block4 aus
 ENDE

Ein Python-Beispiel:
 a = 14
 
 if a&lt;=10:   
   print(&quot;&lt;=10&quot;)
 elif a&gt;=11 and a&lt;=15:
   print(&quot;11 bis 15&quot;)
 elif a&gt;=16 and a&lt;=20:
   print(&quot;16 bis 20&quot;)
 else:
   print(&quot;&gt;20&quot;)

Ausgabe:

 11 bis 15

In Python gibt es auch die Schlüsselwörter &lt;code&gt;True&lt;/code&gt; (für wahr) und &lt;code&gt;False&lt;/code&gt; (für falsch). Man beachte, dass sie mit Großbuchstaben beginnen. Andere Schreibweisen wären ein Fehler. Sie gehören zum Datentyp &lt;code&gt;bool&lt;/code&gt;. Ihnen sind auch die Zahlen &lt;code&gt;1&lt;/code&gt; und &lt;code&gt;0&lt;/code&gt; zugewiesen.

Man beachte, dass {{W|Rundungsfehler}} auftreten können. D.h. man sollte  bei der Verwendung von {{W|Gleitkommazahl|Gleitpunktzahlen}} niemals auf absolute Genauigkeit prüfen, sondern eine Toleranz (einen &lt;math&gt;\varepsilon&lt;/math&gt;-Wert) vorgeben.
 
Ein klassisches Beispiel, das ein falsches Ergebnis liefert, ist:

 i = 0.1 + 0.2
 
 print(i)
 
 if i == 0.3:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 NOK

Und das, obwohl man schon in der Volksschule lernt, dass 0.1 + 0.2 gleich 0.3 ist.

Korrekt muss das obige Beispiel z.B. so umgeschrieben werden:

 ist = 0.1 + 0.2
 soll = 0.3
 epsilon = 0.000001
 
 print(ist)
 
 if abs(ist-soll) &lt; epsilon:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 OK

Alternativ kann auch die &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion verwendet werden. Das sei aber hier nur erwähnt und nicht konkret ausgeführt.

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet zum Thema &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion.

=== match ===
Ab Python 3.10 gibt es auch die match-Anweisung. Dies ist das Python-Pendant für die switch-Anweisung in anderen Programmiersprachen, geht aber bei näherer Betrachtung weit darüber hinaus. Hier nur ein einfaches Beispiel:

 x = &quot;Hello&quot;
 
 match x:
     case &quot;Servus&quot; | &quot;Ciao&quot;:         # or
         print(&quot;Servus an alle&quot;)
     case &quot;Grüetzi&quot;:
         print(&quot;Grüetzi Schwyzer&quot;)  
     case _:                         # other, default, sonstiges ...
         print(&quot;Hallo Welt&quot;)

Ausgabe: 
 Hallo Welt

Als Struktogramm sieht das in etwa so aus:

[[File:Mehrseitige Auswahl.png|250px]]

Für nähere Details siehe z.B. [https://www.geeksforgeeks.org/python-match-case-statement/], [https://learnpython.com/blog/python-match-case-statement/], [https://docs.python.org/3/tutorial/controlflow.html#match-statements] und das Python Enhancement Proposal (PEP) 636 – Structural Pattern Matching: Tutorial [https://peps.python.org/pep-0636] und dort insbesondere den Anhang A - Quick Intro.

&lt;small&gt;&lt;code&gt;match, case, _&lt;/code&gt; etc. sind sogenannte ''soft keywords''. Im Gegensatz zu den normalen Schlüsselwörtern dürfen ihnen auch Werte zugewiesen werden. Eine Liste der weichen Schlüsselwörter lässt sich durch &lt;code&gt;keyword.softkwlist&lt;/code&gt; erstellen (die Anweisung gibt es seit Python 3.9). Siehe dazu auch [https://stackoverflow.com/questions/65800344/what-are-soft-keywords] und [https://docs.python.org/3/library/keyword.html#keyword.softkwlist].&lt;/small&gt;

== Schleifen ==
Kopfgesteuerte Schleife, Endlosschleife und fußgesteuerte Schleife:

[[File:Programmingloops.svg|450px]]

=== while ===
Die WHILE-Schleife ist kopfgesteuert. Sie funktioniert wie aus anderen Programmiersprachen bekannt. 

In Pseudocode:
 SOLANGE bedingung TRUE
   führe block aus
 ENDE

In Python:
 x = 0
 
 while x &lt;= 10:
   print(x)
   x += 1

Ausgabe:
 0
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10

Eine Endlosschleife ergibt sich z.B. so:
 i = 5
 
 while True:
     print(i)
     i-=1

Beendet werden kann sie mit der Tastenkombination STRG-C.

Eine fußgesteuerte Schleife kann so simuliert werden:
 i = 5
 
 while True:
     print(i)
     i-=1
 
     if i&lt;=0:
         print(&quot;Fire&quot;)
         break

Ausgabe:
 5
 4
 3
 2
 1
 Fire

Der &lt;code&gt;break&lt;/code&gt;-Befehl wird etwas [[Ing_Mathematik:_Python#break|später]] noch einmal kurz thematisiert.

=== for ===
Struktogramm einer for-Schleife:

[[File:Zählschleife.png|200px]]

In Python bspw. so:

 for x in range(6):
   print(x*2)

Ausgabe:
 0
 2
 4
 6
 8
 10

Die Schleife läuft von 0 bis 5. Ausgegeben wird jeweils der Wert x*2. Aquivalent kann diese Schleife auch so geschrieben werden:
 for x in range(0, 11, 2):
   print(x)

Die Ausgabe ist wie oben. Der Startwert sei 0, der Endwert ist 11-1 und die Schrittweite ist 2.

Ein anderes Beispiel sei
 for x in &quot;text&quot;:
   print(x)

Ausgabe:
 t
 e
 x
 t

== Schleifen abbrechen ==
=== break ===
&lt;code&gt;break&lt;/code&gt; bricht die Schleife ab und setzt mit dem nächsten Befehl außerhalb der Schleife fort.

 for var in range(100):
   print(var) 
   if var == 5:
     break

Ausgabe:
 0
 1
 2
 3
 4
 5

=== continue ===
&lt;code&gt;continue&lt;/code&gt; bricht den aktuellen Schleifendurchlauf ab und setzt mit dem nächsten Schleifendurchlauf fort.

 for var in range (11):
   if var == 5:
     continue
   print(var)

Ausgabe:
 0
 1
 2 
 3
 4
 6
 7
 8
 9
 10

== try - except ==
 try:
     z1 = 12 / 0
     print(z1)
 except ZeroDivisionError:
     print(&quot;Das Ergebnis ist unendlich&quot;)
 except:
     print(&quot;Kann nicht berechnet werden!&quot;)
     print(&quot;Bitte die Formel korrigieren!&quot;)
 
 print(&quot;Setze Programm fort!&quot;)

Ausgabe:
 Das Ergebnis ist unendlich
 Setze Programm fort!

Es wird versucht, eine Zahl durch Null zu dividieren. Das ist nicht möglich, es wird eine Ausnahme ausgelöst. Das Programm springt daher in den except-ZeroDivisionError-Block und führt die dort gelisteten Anweisungen aus (in unserem Fall eine print-Anweisung). Danach wird das Programm fortgesetzt. Würden wir dieses Programm ohne try-except ausführen, so ergibt sich aus

 z1 = 12 / 0
 print(z1)

folgende Fehlermeldung und ein unmittelbarer Programmabbruch

 Traceback (most recent call last):
   File &quot;C:\tmp\test1.py&quot;, line 1, in &lt;module&gt;
     z1 = 12 / 0
 ZeroDivisionError: division by zero

Mit dem try-except-Mechanismus können also Ausnahmen oder Fehler aufgefangen und behandelt werden. In unserem Beispiel ist das eher trivial, aber bei größeren Programmen kann das durchaus Sinn machen.

Neu in Python 3.14 ist, dass mehrere Ausnahmen auch ohne Klammern angegeben werden können, z.B.:

bis inkl. Python 3.13 nur:
 except (ZeroDivisionError, ValueError):

ab Python 3.14 auch:
 except ZeroDivisionError, ValueError:

== pass ==
Ein leerer Block muss in Python mittels dem Schlüsselwort &lt;code&gt;pass&lt;/code&gt; dargestellt werden. Z.B.

 x = 2
 
 if x == 1:
     print(&quot;Wert ist &quot;, x)
 else:
     pass

Würde man das &lt;code&gt;pass&lt;/code&gt; im else-Block weglassen, so würde man eine Fehlermeldung erhalten:

 IndentationError: expected an indented block after 'else' statement on line 5

= Funktionen =
== Aufrufen von Funktionen ==
Funktionen sind uns im Rahmen dieses Kurses schon zuhauf begegnet. Sei es die print()-, die math.sin()- oder die hex()-Funktion. All diese Funktionen werden von Python zur Verfügung gestellt, ohne dass man sie explizit programmieren müsste. Aufgerufen werden diese Funktionen, indem man ihren Namen eintippt, gefolgt von runden Klammern. In diesen Klammern können noch Argumente übergeben werden. Auch Rückgabewerte sind möglich.

== Funktionen selber schreiben ==
Funktionen werden mit dem def-Schlüsselwort (man definiert die Funktion) eingeleitet, danach folgt der Funktionsname, danach wiederum runde Klammern, in denen formale Argumente stehen können. Abgeschlossen wird die def-Zeile mit einem Doppelpunkt. Danach folgt der Funktionskörper. Dieser Funktionskörper muss wiederum eingerückt werden (wie von den Verzweigungen und Schleifen bekannt). Aufgerufen wird diese Funktion, indem man ihren Funktionsnamen eingibt, gefolgt von runden Klammern (ggf. mit den aktuellen Parametern). Z.B.

 # Funktion definieren
 def halloWelt(i):
     # i ... beliebige Ganzzahl
     print(&quot;Hallo &quot; * i, end=&quot;&quot;)
     print(&quot;Welt!&quot;)
    
 # Funktion aufrufen
 halloWelt(3)

Ausgabe:
 Hallo Hallo Hallo Welt!

Unterschied zwischen formalen und aktuellen Parametern:

[[Datei:PythonIng_func1.jpg]]

&lt;small&gt;Aktuelle Parameter werden auch Argumente genannt.&lt;/small&gt;

Rückgabe von Funktionswerten:
 # Funktion definieren
 def mathFunc(a, b):
     r1 = a + b
     r2 = a * b
     return r1, r2
    
 # Funktion aufrufen
 c, d = mathFunc(3, 5)
 
 # Ausgabe der zurückgegebenen Werte
 print(c)
 print(d)

Ausgabe:
 8
 15

Es werden r1 und r2 zurückgegeben und den Variablen c und d zugewiesen. (r1, r2) und (c, d) sind Tupel. Was Tupel konkret sind, siehe etwas später in diesem Kapitel. 3 und 5 sind die aktuellen Parameter (die Argumente). a und b sind die formalen Parameter. Die Zuweisung der aktuellen zu den formalen Parametern erfolgt in der gegebenen Reihenfolge, also die Zahl 3 wird an a übergeben und die Zahl 5 an b.

Vorgabeparameter, z.B.:
 def mathFunc(a=10, b=20):
     r1 = a + b
     r2 = a * b
     return r1, r2
 
 c, d = mathFunc(3, 5)
 print(c)
 print(d) 
 
 e, f = mathFunc(5)
 print(e)
 print(f)
 
 g, h = mathFunc(b=6)
 print(g)
 print(h)

Ausgabe:
 8
 15
 25
 100
 16
 60

Erklärung:
* Erster &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es werden, wie weiter oben, die Argumente 3 und 5 an die formalen Parameter a und b übergeben. Die Rückgabewerte r1 und r2 werden an c und d übergeben. Somit ist c=8 und d=15.
* Zweiter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur das Argment 5 an a übergeben. b behält den Vorgabewert 20. D.h. e= 25 und f=100.
* Dritter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur die Zahl 6 an b übergeben, a behält seinen Vorgabewert 10. Somit ergibt sich g=16 und h=60.

Beispiel (Schlüsselwortargumente vs. Positionsargumente):
 def mathFunc(a, b):
     r1 = a - b
     r2 = a / b
     return r1, r2
 
 c, d = mathFunc(b=3, a=5)  # Schlüsselwortargumente
 e, f = mathFunc(3, 5)      # Positionsargumente

 print(c)
 print(d)
 print(e)
 print(f)

Ausgabe:
 2
 1.6666666666666667
 -2
 0.6

Durch die Verwendung von Schlüsselwortargumenten können die Argumente in beliebiger Reihenfolge angegeben werden. Bei den Positionsargumenten ist die Reihenfolge vorgegeben. Daraus resultiert auch der Unterschied bei den obigen Ausgaben. Werden beide Arten in einem Aufruf gemischt, so müssen die Positionsargumente zuerst angegeben werden. Den Unterschied zwischen beiden Argumentarten zu kennen ist wichtig, nicht nur bei selbst erstellten Funktionen. Auch beim Aufruf von Python-Funktionen verfolgt einen die Mischung von Schlüsselwort- und Positionsargumenten auf Schritt und Tritt, z.B. beim etwas später folgenden Abschnitt über &quot;Grafiken zeichnen&quot;:

 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)

Bei dieser &lt;code&gt;plot&lt;/code&gt;-Funktion aus dem Modul &lt;code&gt;matplotlib.pyplot&lt;/code&gt; sind &lt;code&gt;x&lt;/code&gt; und &lt;code&gt;y1&lt;/code&gt; Positionsargumente. &lt;code&gt;label, lw&lt;/code&gt; und &lt;code&gt;ls&lt;/code&gt; sind die Namen der Schlüsselwortargumente. Die Schlüsselwortargumente könnten auch in anderer Reihenfolge angeschrieben werden, nicht jedoch die Positionsargumente!
Siehe zu &lt;code&gt;matplotlib.pyplot.plot&lt;/code&gt; auch die Seite [https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html].

== Lambda-Funktionen ==
 print((lambda a, b: a*b) (3, 5))

Ausgabe:
 15

Eingeleitet wird eine Lambda-Funktion (auch Lambda-Form, Lambda-Operator oder anonyme Funktion genannt) mit dem Schlüsselwort &lt;code&gt;lambda&lt;/code&gt;. Es folgen die formalen Argumente, danach ein Doppelpunkt, die Berechnungsvorschrift und ggf. abschliessend in Klammern die aktuellen Parameter.

Man kann einer Lambda-Funktion auch einen Funktionsnamen geben und die Funktion über diesen Namen aufrufen, z.B.

 prod = lambda a, b: a*b
 print(prod(3, 5))

Als Ausgabe wird wieder die Zahl 15 geliefert.

== Rekursive Funktionen ==
Funktionen können wiederum andere Funktionen aufrufen. Von einem {{W|Rekursion|rekursiven Funktionsaufruf}} spricht man, wenn die aufgerufene Funktion gleich der aufrufenden ist. 

 def printFunc(i):
     if (i &gt;= 5):
         return 
     else:
         print(&quot;Hallo Welt&quot;)
         printFunc(i+1)
         
 printFunc(1)

Ausgabe:
 Hallo Welt
 Hallo Welt
 Hallo Welt
 Hallo Welt

Typische Beispiele für die Abarbeitung als rekursive Funktionen sind die {{W|Fibonacci-Folge}} und die {{W|Fakultät_(Mathematik)|Fakultät}}. Jedoch ist der iterative Ansatz (mit konventionellen Schleifen) meist schneller und speicherplatzschonender.

== Funktionsannotationen ==
Python ist sehr flexibel, was Typen angeht. Im Vorhergehenden haben wir generell keine Typangaben gemacht. Will man Typen angeben, so bietet Python das Konzept der Funktionsannotation.

 def calcFunc(a: int, b: int) -&gt; int:
     return a+b
 
 r1 = calcFunc(8, 9)
 r2 = calcFunc(8.0, 9.0)
 r3 = calcFunc(&quot;Hallo&quot;, &quot;Welt&quot;)
 
 print(r1)
 print(r2)
 print(r3)

Ausgabe:
 17
 17.0
 HalloWelt

Jetzt sieht man auf den ersten Blick, welche Typen der Programmierer im Sinn hatte, als er die Funktion erstellte. Das Problem dabei ist nur, dass es Python ziemlich egal ist, welche Typen man im Endeffekt eingibt. Im obigen Beispiel können statt Integer-Typen u.a. auch Float- oder String-Typen eingegeben werden.

&lt;small&gt;
Siehe zum Thema &quot;Type Checking&quot; aber auch den später folgenden Abschnitt [[Ing_Mathematik:_Python#Type_Checker]].
&lt;/small&gt;

== Variadische Funktionen ==
Python-Code:

 def test1(a, *b):
     print(a);
      
     for c in b:
         print(c);
        
 test1(&quot;Hallo&quot;, &quot;Welt&quot;, &quot;Schweizer&quot;, &quot;und alle anderen&quot;)

Ausgabe:

 Hallo
 Welt
 Schweizer
 und alle anderen

Mit dem Stern (auch als Splat-Operator bezeichnet) in der formalen Parameterliste bei der Funktion &lt;code&gt;test1&lt;/code&gt; wird angezeigt, dass eine beliebige Anzahl von Argumenten übergeben wird. &lt;small&gt; Dies entspricht in etwa dem, was in anderen Programmiersprachen (PHP etc.) mittels Ellipse (&lt;code&gt;...&lt;/code&gt;) angezeigt wird.&lt;/small&gt;

= Tupel, Listen und andere =
[[Datei:Python 3. The standard type hierarchy.png|mini|hochkant=1.7|Datentypen und Strukturen]]

== Tupel und Listen ==
Tupel, Listen und einige andere sind Datenstrukturen oder Sequenzen.

Listen (z.B. eine Einkaufsliste) sind veränderbar (mutable). Ein Tupel kann dagegen nicht verändert werden (immutable). Listen werden beim Anlegen in eckige Klammern eingeschlossen, Tupel in runde Klammern. Beim Tupel können die Klammern auch weggelassen werden. Ein Tupel mit nur einem Element muss mit einem Beistrich abgeschlossen werden. Der Grund ist, dass Python sonst nicht entscheiden kann, ob ein Tupel angelegt werden soll, oder nur ein geklammerter Wert. 

Als Gedächtnisstütze kann man sich den Unterschied zwischen Tupel und Liste ev. so leichter merken:
: T'''u'''pel ... r'''u'''nde Klammern, '''u'''nveränderlich
: L'''i'''ste ... eck'''i'''ge Klammern, veränderl'''i'''ch.

Nachfolgend werden einige Operationen mit Listen und Tupel dargestellt.

 # Liste und Tupel
 liste = [1, 2, &quot;Hallo&quot;]
 tupel = (1, 2, &quot;Hallo&quot;) 
 
 # Ausgabe von liste und tupel
 print(liste)
 print(tupel)
 
 # Ausgabe von Einzelelementen
 print(liste[1])
 print(tupel[2])
 
 # Element an Liste anhängen und einfügen 
 liste.append(55)
 liste.insert(4, &quot;Welt&quot;)
 print(liste)
 
 # Element aus Liste entfernen
 liste.remove(1)
 print(liste)
 
 # einige weitere Beispiele
 liste2 = [1,]
 tupel2 = 1, 2
 tupel3 = (1,) 
 print(liste2)
 print(tupel2)
 print(tupel3)

Ausgabe:
 [1, 2, 'Hallo']
 (1, 2, 'Hallo')
 2
 Hallo
 [1, 2, 'Hallo', 55, 'Welt']
 [2, 'Hallo', 55, 'Welt']
 [1]
 (1, 2)
 (1,)

Beispiel (eine Liste von Wörtern zu einem einzigen zusammenhängenden Text verbinden):

 woerter = [&quot;Hallo&quot;, &quot;Welt&quot;]
 satz = &quot; &quot;.join(woerter)
 print(satz)

Ausgabe:

 Hallo Welt

== Dictionaries und Mengen ==
Zu den Datenstrukturen gehören weiters auch Mengen und Dictionaries. Mengen sind von der Mathematik bekannt, sie sind ungeordnet und es kommen keine mehrfachen Elemente vor. Dictionaries sind durch Schlüssel :Wert-Paare gekennzeichnet. Mengen werden beim Anlegen wie Dictionaries in geschweifte Klammern eingeschlossen.

 dict = {&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot; }
 menge = {1, 1, 3, 4, 4, 4, &quot;Hallo&quot;}
 
 print(dict)
 print(menge)
 print(dict[&quot;vorname&quot;])

Ausgabe:
 {'vorname': 'Hugo', 'nachname': 'Meister'}
 {1, 3, 4, 'Hallo'}
 Hugo

Geschweifte Klammern ohne Inhalt stellen Dictionaries dar und keine Mengen:

 di = {}
 print(type(di))

Ausgabe:
 &lt;class 'dict'&gt;

Leere Mengen lassen sich mit &lt;code&gt;set()&lt;/code&gt; erzeugen:

 menge = set()      # leere Menge
 print(menge)
 menge.add(&quot;Hallo&quot;) # Element hinzufügen
 print(menge)

Ausgabe:
 set()
 {'Hallo'}

Beispiel (einige Mengenoperationen):
 mengeA = {&quot;Hallo&quot;, &quot;Welt&quot;}
 mengeB = {1, 2, &quot;Welt&quot;, 3}
 
 # Vereinigung
 print(mengeA | mengeB)
 print(mengeA.union(mengeB))
 
 # Durchschnitt
 print(mengeA &amp; mengeB)
 print(mengeA.intersection(mengeB))
 
 # Differenz
 print(mengeA - mengeB)
 print(mengeA.difference(mengeB))
 
 # Symmetrische Differenz
 print(mengeA ^ mengeB)
 print(mengeA.symmetric_difference(mengeB))
 
 # Teilmenge
 print(mengeA.issubset(mengeB))
 
 # Mehrere Elemente hinzu
 mengeA.update([&quot;Super&quot;, 67, 125])
 print(mengeA)
 
 # Element löschen
 mengeA.discard(&quot;Hallo&quot;)
 print(mengeA)

Ausgabe:
 {1, 2, 3, 'Welt', 'Hallo'}
 {1, 2, 3, 'Welt', 'Hallo'}
 {'Welt'}
 {'Welt'}
 {'Hallo'}
 {'Hallo'}
 {1, 2, 3, 'Hallo'}
 {1, 2, 3, 'Hallo'}
 False
 {67, 'Super', 'Welt', 'Hallo', 125}
 {67, 'Super', 'Welt', 125}

Es gibt schon seit &quot;ewigen&quot; Zeiten unveränderbare Mengen, die mittels &lt;code&gt;frozenset&lt;/code&gt; eingeleitet werden. Neu ab Python 3.15 ist dagegen das Pendant &lt;code&gt;frozendict&lt;/code&gt;, das unveränderbare Dictionaries darstellt.

 fdict = frozendict({&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot;})
 fset = frozenset({&quot;A&quot;, 1, &quot;A&quot;})
 
 print(fdict)
 print(fdict[&quot;vorname&quot;])
 print (fset) 
 
 try:
     fdict[&quot;vorname&quot;] = &quot;Max&quot;
     print(fdict[&quot;vorname&quot;])
 except TypeError as e:
     print(f&quot;Fehler: {e}&quot;)
 
 try:
     fset.add(&quot;B&quot;)
     print(fset)
 except AttributeError as e:
     print(f&quot;Fehler: {e}&quot;)

Ausgabe:
 frozendict({'vorname': 'Hugo', 'nachname': 'Meister'})
 Hugo
 frozenset({1, 'A'})
 Fehler: 'frozendict' object does not support item assignment
 Fehler: 'frozenset' object has no attribute 'add'

== List Comprehensions ==
Aus einer Eingabeliste soll eine Ausgabeliste erzeugt werden. Das kann folgendermaßen geschehen.

Mathematische Schreibweise: &lt;math&gt;lc = \{2x|x\in\ \mathbb{N}, 1\le x &lt; 11\}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11)]
 print(lc)

Ausgabe:
 [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Mathematische Schreibweise: &lt;math&gt;lc = \{2x | x \in \mathbb{N}, 1\le x &lt; 11, x \bmod 2 = 0 \}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11) if x%2 == 0]
 print(lc)

Ausgabe:
 [4, 8, 12, 16, 20]

Siehe auch {{W|List Comprehension}}.

== Set Comprehensions ==
Dies ist sehr ähnlich wie im vorigen Abschnitt beschrieben. Es wird aber keine Liste, sondern eine Menge erzeugt.

 sc = {x*2 for x in range(1,11)}
 print(sc)

Ausgabe:
 {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}

== Listen zusammenführen - zip() ==
 li1 = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]
 li2 = [1, 2, 3, 4]
 li3 = [5.5, 6.6, 7.7, 8.8]
 
 z = zip(li1, li2, li3)
 print(z)
 
 li4 = list(z)
 print(li4)

Ausgabe:
 &lt;zip object at 0x00000283B6C6AC80&gt;
 [('A', 1, 5.5), ('B', 2, 6.6), ('C', 3, 7.7), ('D', 4, 8.8)]

== Generatorausdruck ==
 g = (i*2 for i in range(1,11))
 print(g)
 t = tuple(g)
 print(t)
 print(t[1:3])

Ausgabe:
 &lt;generator object &lt;genexpr&gt; at 0x00000241D2A4A5A0&gt;
 (2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
 (4, 6)

== Slicing ==
slice ... Scheibe, Teil, in Scheiben schneiden

Beispiel: Zugriff auf Elemente eines geordneten sequentiellen Objekttyps (Liste, Tupel oder String):

 str1 = &quot;Hallo&quot;
 # Das erste Element wird mit dem Index 0 angesprochen
 # [start (inkl.) : stop (exkl.) : step (default=1)]
 str2 = str1[0:2]
 # Alternativ auch: str2 = str1[:2] 
 print(str2)
 
 tup1 = (0,1,2,3)
 # Das letzte Element hat auch den Index -1, das vorletzte den Index -2 usw.
 tup2 = tup1[-3:-1]
 print(tup2)
 
 lst1 = [[1,  5,  10, 20],
         [30, 40, 50, 60]]
 lst2 = lst1[1][1]
 print(lst2)
 
Ausgabe:
 Ha
 (1, 2)
 40

Beispiel:

 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2])
 print(x[-3]) 
 print(x)
 print(x[:])
 print(x[2:])
 print(x[:2])
 print(x[::-1])

Ausgabe:

 c
 c
 ('a', 'b', 'c', 'd', 'e')
 ('a', 'b', 'c', 'd', 'e')
 ('c', 'd', 'e')
 ('a', 'b')
 ('e', 'd', 'c', 'b', 'a')

Visualisierung:

    '''a'''     '''b'''     '''c'''     '''d'''     '''e'''
 +-----------------------------+
 |  0  |  1  |//'''2'''//|  3  |  4  |
 +-----------------------------+
 | -5  | -4  |/'''-3'''//| -2  | -1  | 
 +-----------------------------+
 |/////////////////////////////|
 +-----------------------------+
 |/////////////''':'''///////////////|
 +-----------------------------+
 |     |     |///////'''2:'''////////|
 +-----------------------------+
 |////''':2'''/////|     |     |     |
 +-----------------------------+
 |\\\\\&lt;--\\\\\'''::-1'''\\\\&lt;--\\\\\|
 +-----------------------------+

Beispiel:
 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2::2])
 print(x[2::-1])
 print(x[2:0:-1])

Ausgabe:

 ('c', 'e')
 ('c', 'b', 'a')
 ('c', 'b')

Hier sieht man sehr schön, dass beim letzen &lt;code&gt;print&lt;/code&gt;-Befehl die 0, die in diesem Fall den Buchstaben &quot;a&quot; repräsentiert, als letzer Wert nicht mehr dazugehört (wie weiter oben angedeutet ist der End- oder Stoppwert exklusiv). Will man den Buchstaben &quot;a&quot; dazunehmen, so ist die vorletzte Zeile die richtige.

Beispiel: Umdrehen von Strings

 str1 = &quot;Hallo&quot;
 str2 = str1[::-1]
 print(str2)

Ausgabe:
 ollaH

Mit zweidimensionalen Listen/Tupels wird das Ganze schon bedeutend komplexer.

Beispiel: Verkettetes Slicing

 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
     
 print(A[2::][::2])

Ausgabe:

 [['20', '21', '22', '23'], ['40', '41', '42', '43']]

Das erste Slicing erstellt folgenden Slice:

 [[&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
  [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
  [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]

Das zweite Slicing wird dann auf diesen Slice angewendet und ergibt das genannte Endergebnis. Will man Spalten statt Zeilen, so funktioniert dieser direkte Weg nicht. Man verwendet dann List Comprehensions oder die NumPy-Bibliothek. Diese Bibliothek erlaubt [[Ing_Mathematik:_Python#Zugriff_auf_Matrizenelemente|zweidimensionales Slicing]]. Sie wird erst später bei den Grafiken eingeführt. Deshalb wird hier dazu noch kein Beispiel gezeigt.

= Objektorientierte Programmierung =
{{Wikipedia|Objektorientierte Programmierung}}

* {{W|Klasse (Objektorientierung)|Klasse}} ... die Schablone oder der Bauplan, enthält Methoden und Attribute
* {{W|Objekt (Programmierung)|Objekt}} ... eine Klasseninstanz (die konkrete Ausprägung der Klasse)
* {{W|Attribut (Programmierung)|Attribute}} ... die Eigenschaften eines Objekts
* {{W|Methode (Programmierung)|Methoden}} ... die Aktionen (Operationen), die ein Objekt ausführen kann
* {{W|Vererbung (Programmierung)|Vererbung}} ... neue Klassen (Subklassen, Unterklassen, abgeleitete Klassen) aus vorhandenen Klassen (Superklassen, Oberklassen, Basisklassen, Elternklassen) ableiten. Ermöglicht den Aufbau von Klassenhierarchien. Die Subklasse &quot;erbt&quot; Attribute und Methoden von der Superklasse. Python unterstützt (so wie C++, aber im Gegensatz zu Java) Mehrfachvererbung.

== UML ==
* {{W|Unified Modeling Language|UML}} ... '''U'''nified '''M'''odeling '''L'''anguage, eine Modellierungssprache. Die UML enthält zahlreiche Diagrammarten, um Programme zu modellieren. Im Nachfolgenden wird nur das {{W|Klassendiagramm}} verwendet.

[[File:UmlCd Klasse-3.svg|300px]]

* {{W|Sichtbarkeit (Programmierung)|Sichtbarkeit}}:
** + ... public (öffentlich)
** - ... private
** # ... protected 

* {{W|Attribut_(UML)#Attribute_für_Instanzen_und_für_Klassen|Klassenattribute}} (statische Attribute): Werden nur einmal pro Klasse angelegt. Im Klassendiagramm werden sie unterstrichen.

[[File:Attribute-3.png|200px]]

* Vererbung:

&lt;gallery&gt;
InheritancePgmUML.svg | Abgeleitete Klasse erbt von Basisklasse (Einfachvererbung)
Diamond inheritance.svg | D erbt von B und C (Mehrfachvererbung). B und C erben von A (Einfachvererbung)
&lt;/gallery&gt;

Für weitergehende Betrachtungen zur UML wird auf Spezialliteratur verwiesen, z.B.:
* Seidl et al.: UML@Classroom. dpunkt, 2012, ISBN 978-3-89864-776-2
* Rupp et al.: UML 2 glasklar. Hanser, 4. Aufl., 2012, ISBN 978-3-446-43057-0

== Eine einfache Klasse ==

[[Datei:PythonIng_uml1.svg | 200px]]

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
 
 fahr = Fahrzeug(150, 90)
 
 print(fahr.convertGeschw())
 
Ausgabe:
 41.666666666666664

Die Klasse Fahrzeug wird durch das class-Schlüsselwort eingeleitet. raeder ist ein Klassenattribut und public. __init__ wird bei der Objekterzeugung automatisch aufgerufen (ist der sogenannte Konstruktor). Man achte darauf, dass diese Methode immer mit zwei Unterstrichen eingeleitet und abgeschlossen wird. Instanzattributen wird das Wort self vorangestellt. Wir sehen uns z.B. das Attribut self.__geschwind an. Auch hier werden zwei Unterstriche verwendet. Das bedeutet, dass dieses Attribut strikt/stark private ist. Wird nur ein Unterstrich verwendet, so deutet dies auf schwach/weakly private hin. Letzteres wird in Python deutlich häufiger verwendet. Bei den Methoden wird immer self als erster Parameter angegeben. Beim Aufruf der entsprechenden Funktion wird das self aber nicht berücksichtigt.

Besonderheiten bei stark und schwach private:
* '''stark private''':
** zwei führende Unterstriche
** Name Mangling: Name wird zu &lt;code&gt;_Klassenname__variablenname&lt;/code&gt;
** Schutz vor Namenskollisionen bei Vererbung
** am Ende des Namens dürfen keine zwei Unterstriche verwendet werden. Das wären dann Magic Methods oder Dunder-Methods (z.B. __init__). Diese sind public.

* '''schwach private''':
** ein führender Unterstrich
** Name bleibt gleich
** ist nur ein Hinweis an die Programmierer, kein starker Schutz
** &lt;code&gt;from modul import *&lt;/code&gt;: Objekte mit einem führenden Unterstrich werden standardmäßig nicht importiert
** Standard für die Kapselung bei Python. Schätzung: Weit mehr als 80% der nicht-öffentlichen Attribute/Methoden werden als schwach private deklariert. Weniger als 5-10% als stark private (Quelle: Google KI)

== Klassen importieren ==
Häufig ist es sinnvoll und übersichtlicher Klassen in eigenen Dateien zu speichern. Das sind dann eigene Module. Abgespeichert werden Sie mit der Endung py, wie bisher auch praktiziert. Aufgerufen werden Sie mit der import-Anweisung. Dann ist aber nur der Dateiname ohne Endung py zu verwenden. Klarer wird das mit einem Beispiel.

Datei c:\tmp\fahrzeug.py

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6

Datei c:\tmp\test1.py

 import fahrzeug
 fahr = fahrzeug.Fahrzeug(150, 90)
 print(fahr.convertGeschw())

Ausgabe:
 41.666666666666664

Die üblichen import-Anweisungen lauten wie folgt:
{| {{prettytable}}
! import-Befehl
! Instanz
|-
| import xyz      || xyz.Klasse
|-
| import xyz as x || x.Klasse
|-
| from xyz import Klasse || Klasse
|-
| from xyz import * || Klasse 
|}

Der Vorteil der ersten beiden import-Anweisungen ist, dass es kaum zu Namenskollisionen kommen kann. Dafür hat man bei den letzten beiden Varianten weniger Tipparbeit.

== Vererbung ==
=== Einfachvererbung ===

[[Datei:PythonIng_uml2.svg | 200px]]

Datei fahrzeug.py:
 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
        
     def setLeistung(self, leistung):
         self.__leistung = leistung
        
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
        
 class Luftfahrzeug(Fahrzeug):
     def __init__(self, geschwindigkeit, leistung, fluegel):
         super().__init__(geschwindigkeit, leistung)
         self.__flueg = fluegel
     
     def getFlueg(self):
         return self.__flueg

Datei test1.py:
 import fahrzeug
 fahr = fahrzeug.Luftfahrzeug(150, 90, 4)
 print(fahr.getFlueg())

Ausgabe:
 4

=== Mehrfachvererbung ===
Mit Python ist auch Mehrfachvererbung möglich, z.B.:

 class A:
     def _printA(self):
         print(&quot;Klasse A&quot;)
 
 class B:
     def _printB(self):
         print(&quot;Klasse B&quot;)
 
 class C(A,B):
     def __init__(self):
         self._printA()
         self._printB()
 
 c = C()

Ausgabe:

 Klasse A
 Klasse B

Die Klasse C erbt von A und B. In UML sieht das in etwa so aus:

 +-----------------------------+   +-------------------------+
 |            A                |   |          B              |
 +-----------------------------+   +-------------------------+
 |                             |   |                         |
 +-----------------------------+   +-------------------------+
 | # printA()                  |   | # printB()              |
 +-----------------------------+   +-------------------------+
                           .              .
                          / \            / \
                          ---            ---
                           |              |
                           |              |
                        +---------------------+
                        |          C          |
                        +---------------------+
                        |                     |
                        +---------------------+
                        |                     |
                        +---------------------+

&lt;code&gt;printA()&lt;/code&gt; und &lt;code&gt;printB()&lt;/code&gt; sind schwach private (in UML als &lt;code&gt;protected&lt;/code&gt; mit einem # dargestellt). Es ist aber zu beachten, dass schwach private nur Konvention ist. Praktisch könnte man auch von außerhalb auf diese Methoden zugreifen. Das soll man aber nicht tun, und das wird in Python durch einen Unterstrich angedeutet.

== Statische Attribute, statische Methoden und Klassenmethoden ==
Beispiel:

 class Math:
     pi = 3.14159265
     cnt = 0
     
     @staticmethod
     def expo():
         return 2.71828183
    
     @classmethod    
     def counterPlus(cls):
         cls.cnt += 1
        
 print(Math.pi)
 print(Math.expo())
 
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)

Ausgabe:

 3.14159265
 2.71828183
 1
 2
 3

Statische Attribute und Methoden, bzw. Klassenmethoden, sind direkt einer Klasse zugeordnet und nicht einem Objekt. Der Unterschied zwischen statischen Methoden und Klassenmethoden ist, dass statische Methoden nicht auf Klassenattribute (bzw. statische Attribute) zugreifen können, Klassenmethoden aber schon. &lt;code&gt;pi&lt;/code&gt; und &lt;code&gt;cnt&lt;/code&gt; sind statische Attribute. &lt;code&gt;expo()&lt;/code&gt; ist eine statische Methode. &lt;code&gt;counterPlus(cls)&lt;/code&gt; ist eine Klassenmethode. Die Bezeichnung des Parameters als &lt;code&gt;cls&lt;/code&gt; ist reine Konvention, man sollte sich aber daran halten. &lt;code&gt;@staticmethod&lt;/code&gt; und &lt;code&gt;@classmethod&lt;/code&gt; nennt man auch Dekoratoren.

= Grafiken zeichnen =
Für das Zeichnen von Grafiken wird hier das Modul &lt;code&gt;matplotlib&lt;/code&gt; verwendet. &lt;code&gt;matplotlib&lt;/code&gt; ist ein externes Modul und muss vor der ersten Verwendung installiert werden. Das geht so:

# Starten Sie ein Terminal (bei Windows die Eingabeaufforderung).
# Führen Sie darin folgenden Befehl aus &lt;code&gt;c:\devel\Python\Scripts\pip.exe install matplotlib&lt;/code&gt;

pip ist übrigens der Paketmanager von Python ({{W|Pip_(Python)}}). 

Optimalerweise installieren wir auch gleich das Modul &lt;code&gt;numpy&lt;/code&gt; (Numerical Python). Wir werden es im Folgenden oft benötigen (nicht nur bei den Grafiken). Das funktioniert vom Prinzip her genauso, wie für &lt;code&gt;matplotlib&lt;/code&gt; gezeigt.

&lt;small&gt;Verwenden Sie Spyder, so sind diese Schritte nicht nötig. Spyder inkludiert diese Pakete standardmäßig. Unter openSUSE Tumbleweed lassen sich diese Pakete mittels YaST oder zypper installieren.&lt;/small&gt;

== 2D ==
=== Graph einer Funktion ===
Es soll die cosh-Funktion im Intervall &lt;math&gt;x\in[-3,3]&lt;/math&gt; gezeichnet werden. Der Programmcode lautet in der einfachsten Form:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x)
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:PythonIng_cosh1.jpg]]

Der Code ist quasi selbsterklärend. Das Untermodul pyplot des matplotlib-Moduls und das numpy-Modul werden importiert. x läuft von -3 bis +3. y wird für jeden x-Wert per Formel ausgerechnet. &quot;plt.plot()&quot; ist der Zeichenbefehl. &quot;plt.show&quot; ist notwendig, um das Fenster mit der Grafik anzuzeigen.
Die Schrittweite 0.1 wurde so gewählt, um einen ausreichend glatten Verlauf des Graphen zu gewährleisten. Das ist immer ein Kompromiss zwischen Berechnungszeit und Ansehnlichkeit. Testen Sie einfach ein paar verschiedene Werte, um ein Gefühl dafür zu zu bekommen. &quot;plt.grid()&quot; zeichnet ein Gitter in die Grafik (kann auch weggelassen werden).
Die Bezeichnungen plt und np könnten auch anders gewählt werden. Es ist aber Konvention, diese so wie hier gezeigt zu wählen. Die &quot;arange&quot;-Funktion aus der NumPy-Bibliothek wird später ein bisschen genauer behandelt (siehe [[Ing_Mathematik:_Python#Zahlenfolgen|Zahlenfolgen]]).  

&lt;small&gt;Mit der im obigen Bild gezeigten Menüleiste kann die dargestellte Grafik nachträglich noch geändert werden (Zoom, Pan, Achsenparameter, Kurvenparameter etc.). Natürlich kann man das alles auch direkt programmieren. Wie das funktioniert wird ansatzweise etwas später gezeigt.&lt;/small&gt;

Ein etwas komplexeres Beispiel ist Folgendes:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x) + 2**x
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:
[[Datei:PythonIng_cosh4.png]]

Man beachte, dass im Gegensatz zu Octave und Julia der ominöse Punkt (.) bei 2**x mit Python nicht benötigt wird. Das macht das Programmiererleben etwas einfacher.

Die Farbe des Graphen kann man über den &lt;code&gt;color&lt;/code&gt;-Schalter einstellen, z.B. auf rot setzen:
 plt.plot(x, y, color=&quot;red&quot;)

Das ist nur eine Möglichkeit, es gibt auch andere, z.B. mittels
* hexadezimaler Zahl, z.B. &lt;code&gt;color=&quot;#ff0000&quot;&lt;/code&gt;
* Kurzform, z.B. &lt;code&gt;&quot;r&quot;&lt;/code&gt;

Statt &lt;code&gt;color&lt;/code&gt; kann auch die Kurzform &lt;code&gt;c&lt;/code&gt; verwendet werden.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie diese &quot;Farbspielereien&quot; am Computer aus.

=== Graphen mehrerer Funktionen und weiteres ===
==== Mehrere Funktionen in einen Plot zeichnen ==== 
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh2.png]]

Um die Linienstile etwas individueller zu gestalten, ist folgender Programmcode gedacht: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;, lw=3, ls=&quot;--&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh3.png]]

Einige weitere Bespiele zu &lt;code&gt;ls&lt;/code&gt;&lt;/code&gt;:
* - ... durchgezogene Linie
* -. ... Strichpunkt-Linie
* dashed ... gestrichelte Linie 

==== Marker ====
Desweiteren kann man Marker verwenden.

Beispiel:

 import matplotlib.pyplot as plt
 
 plt.plot(10, 10, &quot;ob&quot;, markersize=30)
 plt.plot(20,20, &quot;.r&quot;)
 plt.plot(30,30, &quot;Dg&quot;, ms=15)
 plt.plot(40, 40, &quot;ok&quot;, ms=20, mec=&quot;#FF5733&quot;, mew=3)
 plt.plot(50, 50, &quot;vk&quot;, ms=20, mec=&quot;yellow&quot;, mew=3)
 plt.grid()
 plt.show()


Das erste Zeichen im String nach den Koordinaten im plot-Befehl symbolisiert die Form (z.B. o für einen Kreis). Das zweite Zeichen steht für die Farbe (z.B. b für blue). &lt;code&gt;markersize&lt;/code&gt; oder &lt;code&gt;ms&lt;/code&gt; setzt die Größe des Markers.

Ausgabe:

[[Bild:PythonIng_formatpara1.svg|200px]]

Einige weitere Marker:
* * ... Stern
* + ... Plus
* h oder H ... Sechseck

Man kann mit den Parametern 
* &lt;code&gt;markeredgecolor&lt;/code&gt; oder kurz &lt;code&gt;mec&lt;/code&gt; die Farbe des Markerrandes
* &lt;code&gt;markeredgewidth&lt;/code&gt; oder kurz &lt;code&gt;mew&lt;/code&gt; die Dicke des Randes
* &lt;code&gt;markerfacecolor&lt;/code&gt; oder kurz &lt;code&gt;mfc&lt;/code&gt; die Innenfarbe des Markers
bestimmen.

=== Funktion in Parameterdarstellung ===
Es soll die archimedische Spirale &lt;math&gt;x = t \cos(t), y = t  \sin(t)&lt;/math&gt; im Intervall &lt;math&gt;[0, 6\pi[&lt;/math&gt; gezeichnet werden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
  
 plt.show()

[[Datei:PythonIng_spirale1.png]]

Diese Darstellung erscheint verzerrt. Will man gleiche Achsenskalierungen, so kann man den plt.axis()-Befehl verwenden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
 plt.axis(&quot;equal&quot;)
 
 plt.show()
 
[[Datei:PythonIng_spirale2.png]]

=== Funktion in Polardarstellung ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 fig = plt.figure()
 ax = fig.add_subplot(projection=&quot;polar&quot;)
 r = np.arange(0, 1, 0.01)
 theta = r**3
 line = ax.plot(theta, r)
 
 plt.show()

[[Datei:PythonIng_polar1.png]]

=== Logarithmische Achsenskalierung ===
==== Semilog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.semilogy()
 plt.show()

Ausgabe:

[[Datei:PythonIng_semilog1.png]]

==== LogLog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.loglog()
 plt.show()

[[Datei:PythonIng_loglog1.png]]

=== Gefüllte Fläche ===
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.arange(0, 3, 0.1)
 
 y1 = 3*x - 1
 y2 = x**2
 
 plt.plot(x, y1, x, y2, color='black')
 plt.fill_between(x, y1, y2, where=y1&gt;=y2)
 
 plt.show()

[[Datei:PythonIng_gefuellt.png]]

=== Linien, Pfeile, Rechtecke, Kreise und Texte ===
 import matplotlib as mpl
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 r = mpl.patches.Rectangle((0, 0), 3, 3, angle=30, fill=False)
 c = mpl.patches.Circle((4, 4), 2, fill=False)
 
 ax.add_patch(r)
 ax.add_patch(c)
 ax.plot([-2, 7], [-2, 0], color=&quot;black&quot;)
 ax.arrow(0, 7, 5, 0, length_includes_head=True, head_width=0.5, head_length=1.5,
          color=&quot;black&quot;)
 
 ax.set_aspect(&quot;equal&quot;)
 
 plt.axis([-3, 8, -3, 8])
 plt.show() 

[[Datei:PythonIng_linien_pfeile_etc.png]]

Text kann mit &lt;code&gt;ax.text(x, y, &quot;Text&quot;)&lt;/code&gt; hinzugefügt werden, bspw.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 ax.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

Oder einfacher auch ohne &lt;code&gt;subplots&lt;/code&gt;

 import matplotlib.pyplot as plt
 
 plt.text(0.1, 0.1, &quot;Hallo&quot;)
 plt.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

[[Datei:PythonIng_text1.png]]

Auch Sonderzeichen (griechische Buchstaben etc.) können verwendet werden (siehe dazu auch [https://matplotlib.org/stable/users/explain/text/mathtext.html]).

 import matplotlib.pyplot as plt
 
 plt.text(.3, .5,
          r'$\Omega\ \psi\ \oint\ \nabla\ \dot a\ \frac{a}{b}\ a_b$',
          size=&quot;20&quot;)
 plt.show() 

[[Datei:PythonIng_text20.svg]]

Jetzt wird noch gezeigt, wofür &lt;code&gt;subplots&lt;/code&gt; sinnvoll eingesetzt werden können.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(0.1, 0.1, &quot;Hallo&quot;)
 ax[1].text(0.1, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
            rotation=30.0)
 
 plt.show()

[[Datei:PythonIng_text2.png]]

=== Anmerkungen hinzufügen ===
Anmerkungen (engl. annotations) lassen sich mit matplotlib einfach hinzufügen. Unter Anmerkung wird hier ein Pfeil mit Text verstanden.

Beispiel:

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 ax.plot([1,10], [1,10])
 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
             arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0))
 plt.show()

Ausgabe:

[[Datei: PythonIng_ann1.svg|400px]]

&lt;code&gt;shrink&lt;/code&gt; verkürzt den Pfeil. Sinnvoll sind beim obigen Beispiel Werte irgendwo zwischen 0.0 und 0.3.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie verschiedene Pfeillängen aus. 

Die Schriftgröße verändern können Sie übrigens mit &lt;code&gt;fontsize&lt;/code&gt; oder &lt;code&gt;size&lt;/code&gt;, z.B.

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0), fontsize=25)

Eine andere Schreibweise für Dictionaries, die wir weiter oben schon kennengelernt haben, die wir aber nochmals explizit aufschreiben wollen, ist

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops={&quot;facecolor&quot;:&quot;red&quot;, &quot;shrink&quot;:0.0})

=== Figure, Axes etc.===
[[Bild:PythonIng_figure33.svg|350px]]

* fig (figure) ... das übergeordnete Fenster
* ax (axes) ... &quot;Plot&quot;, das eigentliche Zeichenfenster
* axis ... die Koordinatenachsen
* spine ... Begrenzungslinien des Zeichenfensters
* tick ... Markierung an den Achsen des Zeichenfensters

Beispiel (eine figure mit 6 axes, ax-Titel, y-axis-Titel):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=3, ncols=2)
 
 ax[0][0].text(0.1, 0.5, &quot;11&quot;)
 ax[0][1].text(0.1, 0.5, &quot;12&quot;)
 ax[1][0].text(0.1, 0.5, &quot;21&quot;)
 ax[1][1].text(0.1, 0.5, &quot;22&quot;)
 ax[2][0].text(0.1, 0.5, &quot;31&quot;)
 ax[2][1].text(0.1, 0.5, &quot;32&quot;)
 
 ax[0][0].set(ylabel=&quot;y-label&quot;, title=&quot;axes 1&quot;)
 
 plt.show()

[[Bild:PythonIng_figure34.png|350px]]

Beispiel (Achsenbereiche setzen):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 
 ax[0].axis((-1, 10, 1, 12))
 
 plt.show()

[[Bild:PythonIng_figure35.svg|350px]]

Beispiel (Gitter einschalten): 

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 ax[0].axis((-5, 10, 1, 12))
 ax[0].minorticks_on()
 ax[0].grid(which='minor')
 ax[1].grid(which='major')
 plt.show()

[[Bild:PythonIng_figure36.svg|350px]]

Beispiel (ticks setzen)

 import matplotlib.pyplot as plt
 import matplotlib.ticker as tick
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 pos = [0, .2, .5]
 lab = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
 
 ax.xaxis.set_major_locator(tick.FixedLocator(pos))
 ax.xaxis.set_major_formatter(tick.FixedFormatter(lab))
 
 plt.show()

[[Bild:PythonIng_figure37.svg|350px]]

Beispiel (Achsenkreuz beliebig setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 ax.spines['top'].set_color('none')
 ax.spines['right'].set_color('none')
 ax.spines['bottom'].set_position(('data', 0.3))
 ax.spines['left'].set_position(('data', 0.5))
 
 plt.show()

[[Bild:PythonIng_figure38.svg|350px]]

Beispiel (Inset):

 import matplotlib.pyplot as plt
 
 # Hauptplot erstellen
 fig, ax = plt.subplots()
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 
 # Inset hinzu:
 axin = ax.inset_axes([0.4, 0.4, 0.3, 0.3])
 axin.text(0, 0, &quot;Servus&quot;)
 axin.plot()
 
 plt.show()

[[Bild:PythonIng_figure40.svg|350px]]

Beispiel (Hintergrundfarben setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.set_facecolor(&quot;green&quot;)
 fig.set_facecolor(&quot;yellow&quot;)
 
 plt.plot([1, 3], [6, 8])
 plt.show()

[[Bild:PythonIng_figure39.svg|300px]]

=== GridSpec ===
Mit figures und axes lassen sich schon jede Menge an Grafikdetails einstellen. GridSpec ist dann der Turbo oder Raketenantrieb den matplotlib eingebaut hat. Naja, vielleicht ist das etwas übertrieben, aber GridSpec ist sozusagen ein flexibler Layout-Manager. Bisher haben wir immer gleich große axes gezeichnet. Mit GridSpec können wir Subplots über mehrere Zeilen und Spalten ziehen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 gs = fig.add_gridspec(3, 3)
 
 ax1 = fig.add_subplot(gs[0, :])
 ax1.set_title(&quot;Bereich 1: gs[0, :]&quot;)
 
 ax2 = fig.add_subplot(gs[1:, 0])
 ax2.set_title(&quot;Bereich 2: gs[1:, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 1:])
 ax3.set_title(&quot;Bereich 3: gs[1, 1:]&quot;)
 
 ax4 = fig.add_subplot(gs[2, 1:])
 ax4.set_title(&quot;Bereich 4: gs[2, 1:]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec1.svg|350px]]

Erklärung zu &lt;code&gt;(gs[zeile, spalte])&lt;/code&gt;: Slicing; damit legen Sie fest, welche Zellen ein Subplot belegt. Achtung! Die Indizes beginnen bei 0 und nicht bei 1 (d.h., die erste Zeile/Spalte hat den Index 0)
* : ... alle 
* 1: ... 1 bis Ende
* etc.

&lt;code&gt;constrained_layout=True&lt;/code&gt; sorgt dafür, dass sich die Subplots nicht überlappen.

Aber auch die Spaltenbreiten und Zeilenhöhen lassen sich anpassen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 
 # Verhältnis erste zu zweite Zeile = 1.5:1
 # Verhältnis erste zu zweite Spalte  = 1:4
 gs = fig.add_gridspec(2, 2, figure=fig, height_ratios=[1.5, 1], width_ratios=[1, 4])
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax1.set_title(&quot;Bereich 1: gs[0, 0]&quot;)
 
 ax2 = fig.add_subplot(gs[0, 1])
 ax2.set_title(&quot;Bereich 2: gs[0, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 0])
 ax3.set_title(&quot;Bereich 3: gs[1, 0]&quot;)
 
 ax4 = fig.add_subplot(gs[1, 1:])
 ax4.set_title(&quot;Bereich 4: gs[1, 1]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec2.svg|350px]]

Auch die Ränder lassen sich einstellen.

Beispiel 1:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.1, right=0.9, bottom=0.1,
                        top=0.9, wspace=0.2, hspace=0.2)
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec3.svg|300px]]

* hspace ... height space, vertikaler Abstand zwischen den Zeilen
* wspace ... width space, horizontaler Abstand zwischen den Spalten

Und im Vergleich dazu Beispiel 2:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.3, right=0.7, bottom=0.3, 
                        top=0.7, wspace=0.3, hspace=0.3) 
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec4.svg|300px]]

Es gibt noch einige weitere Details, die sich mit GridSpec variieren lassen (z.B. SubGridSpec ... verschachtelte Grid-Layouts). Aber wir belassen es vorerst dabei. Das bisher Gezeigte sollte für die meisten Probleme ausreichend sein.

=== Aufgaben ===
* Zeichnen Sie die Strophoide &lt;math&gt;x = \frac{a(t^2-1)}{t^2+1}, y = \frac{at(t^2-1)}{t^2+1}, a = 2, -3 \leq t \leq 3&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_strophoide.jpg|300px|center]]

* Zeichnen Sie die verschlungene Hypozykloide &lt;math&gt;x = (R-r)\cos t + c\cos\frac{R-r}{r}t, y = (R-r)\sin t - c\sin\frac{R-r}{r}t, c = 3, r = 2, R = 6, -15 \leq t \leq 15&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_hypozykloide.jpg|300px|center]]

* Testen Sie bei den obigen Übungsaufgaben verschiedene Linienstile und Farben. Farben können mit dem plt.plot()-Parameter color gewählt werden.

* Testen Sie bei den obigen Übungsaufgaben verschiedene Werte für a, c, r und R.

* Zeichnen Sie folgendes Bild (die Achsenbeschriftungen positionieren Sie z.B. mit den Befehlen &lt;code&gt;ax.set_xlabel(&quot;x&quot;, loc=&quot;right&quot;); ax.set_ylabel(&quot;y&quot;, loc=&quot;top&quot;)&lt;/code&gt;):

[[Bild:PythonIng_aufgabe24.svg|400px|center]] 

* Zeichnen Sie mit Python, matplotlib und NumPy folgendes Bild:

[[Bild:PythonIng_figure41.svg|400px|center]]

* Zeichnen Sie mit GridSpec ein Layout, das in etwa wie folgendes aussieht (&lt;code&gt;height_ratios=[1, 2], width_ratios=[2, 1]&lt;/code&gt;):

[[Bild:PythonIng_aufgabe23.svg|300px|center]]

== 3D ==
=== Räumliche Kurven ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0, 6*np.pi, 0.1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 z = t
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot(x, y, z)
 
 plt.show()

[[Datei:PythonIng_raumkurve1.png]]

=== Flächen ===
 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche1.png]]

Das Ganze in Netzdarstellung läßt sich so programmieren: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.5)
 y = np.arange(0, 10, 0.5)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_wireframe(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche2.png]]

Ein etwas komplexeres Beispiel:

 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0.1, 10, 0.1)
 y = np.arange(0.1, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z1 = np.sin(x) + 3 * np.cos(y)
 z2 = np.sin(x) + np.log(y)
 z3 = x + np.cos(y)
 z4 = x**2 - y
  
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;}, nrows=2, ncols=2)
 
 ax[0][0].plot_surface(x, y, z1)
 ax[0][1].plot_surface(x, y, z2)
 ax[1][0].plot_surface(x, y, z3)
 ax[1][1].plot_surface(x, y, z4)
 
 plt.show()

[[Datei:PythonIng_subplot1.png]]

Man beachte, dass man die Unterbilder im Bild nach dem Ausführen des Scripts z.B. mit der mittleren Maustaste einzeln drehen, oder über die Einträge in der Menüzeile einzeln bearbeiten kann. Mit ein paar Zeilen Programmtext lässt sich also eine Menge an Funktionalität generieren.

Die Farbgebung lässt sich über &lt;code&gt;colormaps&lt;/code&gt; variieren.

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm)
 
 plt.show()

[[Datei:PythonIng_colormap1.png]]

Es gibt eine Menge an Colormaps, z.B. &lt;code&gt;plasma, Greys, Dark2, ocean&lt;/code&gt;. Zwecks detaillierterer Infos siehe die matplotlib-Dokumentation. &lt;small&gt;Verwendet man die IDE namens IDLE, so gibt es dort auch die automatische Codevervollständigung. D.h. es werden alle Möglichkeiten (in unserem Fall nach dem Eintippen von &lt;code&gt;cm.&lt;/code&gt; alle verfügbaren Colormaps) angezeigt.&lt;/small&gt;

Die &quot;edgecolor&quot; und Linienbreite können auch frei gewählt werden:

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm, edgecolor=&quot;black&quot;, linewidth=1.0)
 
 plt.show()

[[Datei:PythonIng_colormap2.png]]

=== Höhenlinien ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 ax.contour(x, y, z)
 
 plt.show()

[[Datei:PythonIng_höhenlinien1.png|400px]]

Etwas abgewandelt sieht das so aus: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contour(x, y, z)
 ax.clabel(hl, inline = True)
 
 plt.show()

[[Datei:PythonIng_höhenlinien2.png|400px]]

Und noch eine Variante (mit einem Farbbalken) sei gezeigt. 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contourf(x, y, z)
 fig.colorbar(hl) 
 
 plt.show()

[[Datei:PythonIng_höhenlinien5.svg|400px]]

=== Aufgaben ===
* Zeichnen Sie die räumliche Kurve &lt;math&gt;x = 2 \cdot \cosh(t)&lt;/math&gt;, &lt;math&gt;y = 5 \cdot \sin(t)&lt;/math&gt;, &lt;math&gt; z = t^{2} - t&lt;/math&gt;, &lt;math&gt;0 \leq t \leq 3\pi&lt;/math&gt;.
* Zeichnen Sie die Fläche &lt;math&gt;z = \log(x) + \cos(y)&lt;/math&gt;.

== Animationen und fortgeschrittenes 3D ==
=== Mit matplotlib ===
Auch mit matplotlib sind Animationen möglich. Das ist ein bisschen komplizierter und wird deshalb hier nur mit einem sehr einfachen Beispiel dargestellt (bei Interesse siehe z.B. auch das [https://matplotlib.org/stable/users/explain/animations/animations.html#animations Animations using Matplotlib-Tutorial]).

 import matplotlib.pyplot as plt
 import matplotlib.animation as ani
 import matplotlib
 import numpy as np
 
 def update(frame):
     line.set_xdata(x[:frame])
     line.set_ydata(y[:frame])
     return (line)
 
 fig, ax = plt.subplots()
 
 x = np.arange(0, 10, .1)
 y = np.sin(x)
 
 line, = ax.plot(x[0], y[0])
 ax.set(xlim=[0, 10], ylim=[-1, 1])
 
 a = ani.FuncAnimation(fig=fig, func=update, frames=100, interval=20)
 plt.show()
 
 # Speichere die Animation in einem animierten GIF (optional)
 a.save(filename=&quot;c:/tmp/PythonIng_anim5.gif&quot;, writer=&quot;pillow&quot;)

[[Datei:PythonIng_anim5.gif]]

Es wird eine Sinuskurve auf den Bildschirm gezeichnet. In der letzten Zeile wird diese Animation in ein animiertes GIF gespeichert. Das ist natürlich optional und kann auch weggelassen werden.

=== Mit VPython ===
Aber auch mit dem Modul VPython lassen sich einfache 3D-Animationen erstellen. VPython ist ein externes Modul, das vorab installiert werden muss. Unter openSUSE Tumbleweed gibt es dzt. kein entsprechendes rpm-Paket. Die übliche Methode der Installation mittels YaST oder zypper ist somit nicht möglich. Auch eine direkte Verwendung von pip führt nur zu einer Fehlermeldung (&lt;code&gt;error: externally-managed-environment&lt;/code&gt;). Es empfiehlt sich dort folgende Vorgehensweise:
# Erstelle zuerst eine virtuelle Umgebung, z.B.: &lt;code&gt;python3.11 -m venv ~/tmp/venv1&lt;/code&gt;
# Wechsle das Verzeichnis: &lt;code&gt;cd ~/tmp/venv1/bin&lt;/code&gt;
# Installiere das entsprechende Paket: &lt;code&gt;./pip install vpython&lt;/code&gt;
# Führe das entsprechende Skript aus: &lt;code&gt;./python ~/tmp/test1.py&lt;/code&gt;

Aktuell (März 2026) ist dieses Programmpaket lt. der [https://vpython.org/presentation2018/install.html VPython-Homepage] nur für die Python-Versionen 3.8 bis 3.12 verfügbar.

Ein Beispiel zu einer einfachen Animation wird nachfolgend geliefert.

 from vpython import *
 
 scene.width = 1200
 scene.height = 600
 scene.center = vector(20,0,0)
 scene.background = color.white
 
 cylinder(pos=vector(0,0,0), axis=vector(20,0,0), radius=5, 
         color=color.blue)
 cone(pos=vector(0,0,0), axis=vector(-10,0,0), radius=5, 
         color=color.blue)
 helix(pos=vector(20,0,0), axis=vector(40,0,0), radius=2, 
         coils=10, thickness=0.5, color=color.blue)
 
 ball = sphere(pos=vector(20,0,0), color = color.green, radius = 1)
 ball.p = vector(0.15, 0, 0)
 
 toc = True
 
 while True:
     rate(200)
     if(ball.pos.x &lt;= 60 and toc == True):
         ball.pos += ball.p
     else:
         toc = False
         ball.pos -= ball.p
         if(ball.pos.x &lt;= 20 and toc == False):
             toc = True

[[Datei:PythonIng_vpython_anim.JPG]]

Idealerweise öffnet sich beim Ausführen des Scripts ein Browserfenster. Darin wird die programmierte Animation gezeigt (siehe auch den obigen Screenshot). Eine Größenänderung können Sie mit der mittleren Maustaste initiieren. Die Szenerie drehen können Sie mit der rechten Maustaste.

=== Mit build123d ===
Hiermit lassen sich einfach 3D-Modelle für CAD-Systeme erstellen. [https://build123d.readthedocs.io/en/latest/ build123d] ist ein externes Modul und muss vorab, wie schon für mehrere andere Module gezeigt, installiert werden (pip, venv etc.).

Beispielcode:

 from build123d import *
 
 # Bauteil
 with BuildPart() as bauteil: 
     # Zylinder erstellen
     Cylinder(100, 60)
        
     # Bohrung
     with BuildSketch(bauteil.faces().sort_by(Axis.Z)[-1]) as loch:
         Circle(radius=10)
     # negativ extrudieren
     extrude(amount=-60, mode=Mode.SUBTRACT)
     
     # Dem Bauteil z.B. die Farbe rot zuweisen
     # bauteil.part.color = Color(&quot;red&quot;, alpha=1.0)
 
     # Fertiges Modell exportieren
     export_step(bauteil.part, &quot;bauteil.step&quot;)

Ausgabe ({{W|Standard for the exchange of product model data | STEP}}-Datei, z.B. in {{W|FreeCAD}} importiert, Screenshot):

[[Datei:PythonIng_build123d.jpg | 300px]]

FreeCAD ist ein freies 3D-CAD-System. Die [[Ing_Mathematik:_Python#FreeCAD | Makroprogrammierung]] in diesem System wird später noch gezeigt. STEP steht für &quot;'''St'''andard for the '''e'''xchange of '''p'''roduct model data&quot; und ist ein Datenaustauschformat.

=== Mit VTK ===
Komplexer, aber auch mächtiger als VPython ist die Verwendung von VTK ('''V'''isualization '''T'''ool'''k'''it). Genauer gesagt des Python-Wrappers von VTK. Dieses externe Python-Modul muss vorab installiert werden (z.B. mittels YaST, pip oder in eine virtuelle Umgebung). VTK ist eine Softwarebibliothek zur 3D-Visualisierung und wurde ursprünglich in C++ geschrieben. Verbreitet eingesetzt wird diese Bibliothek in der Wissenschaft und Forschung, z.B. 
* in der medizinischen Bildgebung
* für Strömungssimulationen
* für Klimadaten

VTK funktioniert nach dem {{W|Grafikpipeline|Pipeline-Prinzip}}:

 Source (Quellen) -&gt;  Filter -&gt; Mapper (Senken) -&gt; Actor/Renderer

Daten fließen von den Quellen zu den Senken.

Als einfaches Beispiel wird die Darstellung eines Zylinders gezeigt, der mit den Maustasten gedreht oder in der Größe geändert werden kann:

 import vtk
 
 # Zylinder erzeugen
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 # Geometrie in darstellbare Daten umwandeln
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 # Objekt in der Szene
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 # Szene verwalten
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 # Render-Fenster
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 # Maus/Tastatur-Steuerung
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 # Starten
 render_window.Render()
 interactor.Start()

Ausgabe:

[[Datei:PythonIng_VTK_1.png]]

Gleiches Beispiel wie oben, aber mit einer Animationssequenz:

 import vtk
 import time
 
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     render_window.Render()
     time.sleep(0.01)

Das Grafikfenster schließt sich nach Ablauf der Schleife. Das Fenster bleibt geöffnet, wenn Sie am Programmende folgenden Befehl hinschreiben

 interactor.Start()

Um den animierten Zylinder grün einzufärben, müssen Sie Folgendes im obigen Programm ergänzen (Farbnamen):

 colors = vtk.vtkNamedColors()
 actor.GetProperty().SetColor(colors.GetColor3d(&quot;Green&quot;))

Als Namen können Sie u.a. die CSS3 Web-Farben verwenden (siehe z.B. [https://wiki.selfhtml.org/wiki/Farbe/Farbangaben] und {{W|Webfarbe#CSS_3}}).

Alternativ funktioniert auch das ({{W|RGB-Farbraum|RGB}}):

 actor.GetProperty().SetColor(0.0, 0.6, 0.0)

Wie der Zylinder mit einer Textur versehen wird, zeigt folgendes Programm:

 import vtk
 import time
 
 cylinder = vtk.vtkCylinderSource()
 cylinder.SetResolution(30)
 cylinder.SetHeight(3.0)
 cylinder.SetRadius(1.0)
 cylinder.CappingOn()
 
 texture_coords = vtk.vtkTextureMapToCylinder()
 texture_coords.SetInputConnection(cylinder.GetOutputPort())
 texture_coords.PreventSeamOn()
 
 reader = vtk.vtkJPEGReader()
 reader.SetFileName(&quot;PythonIng_textur.jpg&quot;)
 
 texture = vtk.vtkTexture()
 texture.SetInputConnection(reader.GetOutputPort()) 
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(texture_coords.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 actor.SetTexture(texture)
 
 renderer = vtk.vtkRenderer()
 renderWindow = vtk.vtkRenderWindow()
 renderWindow.AddRenderer(renderer)
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(renderWindow)
 
 renderer.AddActor(actor)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     renderWindow.Render()
     time.sleep(0.01)
 
 interactor.Start()

&lt;gallery&gt;
PythonIng_textur.jpg | Textur-Datei
PythonIng_VTK_2.png | Ausgabe (Screenshot)
&lt;/gallery&gt;

== Sonstige Grafikbibliotheken ==
=== Py5 ===
Im Buch ''Iacono et al.: Programmieren trainieren, mit über 150 Workouts in Java und Python; 3. Aufl., Hanser, 2023'' werden zahlreiche Aufgaben gestellt, die u.a. mit Processing zu lösen sind.  Processing ist eine einfache Programmiersprache und Entwicklungsumgebung. Warum ich das erwähne? Weil in älteren Processing-Versionen auch die Programmiersprache Python 2 abgedeckt war. Bei neueren Versionen gibt es keine Python-Anbindung mehr (getestet nur mit openSUSE Tumbleweed und Python 3). Somit funktioniert der Python-Teil im genannten Buch zum Teil nicht mehr. Ist das tragisch, oder kann das Buch weggeschmissen werden? Nein! Es gibt Alternativen zu Processing. Zum einen die im Buch selbst genannten Bibliotheken tkinter oder pygame. Pygame wird dort auch kurz anhand eines Beispiels thematisiert. Aber noch besser ist es, die py5-Bibliothek zu verwenden (lt. Google KI vom 30. Sept. 2026: ''Der echte, moderne „spirituelle Nachfolger“''). Damit ist die Funktionalität von Processing gewährleistet. Man kann aber beliebige Editoren oder IDEs zur Programmerstellung verwenden, ohne an Processing als IDE gebunden zu sein. Nachfolgend werden ein paar Beispiele zu dieser externen Bibliothek gegeben. Der erste Schritt ist wieder, die py5-Bibliothek zu installieren (z.B. mittels pip in eine virtuelle Umgebung; Python&gt;=3.10 und ein JDK&gt;=17 müssen auch installiert sein (Stand Okt. 2026)). Dann kann es schon mit dem Programmieren losgehen.

Beispiel (angelehnt an die ''Aufgabe W.2.3 Haus'' des genannten Buchs, jedoch etwas erweitert):

 import py5
 
 def setup():
     py5.size(600, 600)            # Fenstergröße 600px x 600px 
     py5.background(255, 255, 255) # Hintergrundfarbe ... weiss
     
 def draw():
     # Haus zeichnen
     py5.fill(255, 255, 255)       # Hintergrundfarbe ... weiss
     py5.stroke(255, 0, 0)         # Linienfarbe ... rot 
     py5.stroke_weight(3)          # Linienbreite ... 3px
     py5.rect(150, 200, 300, 300)  # Rechteck zeichnen (x, y, b, h)
     py5.triangle(150, 200, 300, 100, 450, 200) # Dreieck zeichnen
     py5.circle(250, 300, 70)      # Kreis zeichnen (x, y, d)   
     
     # Bemassung zeichnen
     py5.stroke(0, 255, 0)
     py5.stroke_weight(1)
     py5.line(300, 100, 550, 100)  # Linie zeichnen
     py5.line(450, 200, 550, 200) 
     py5.line(450, 500, 550, 500) 
     py5.line(150, 500, 150, 550)
     py5.line(450, 500, 450, 550)
     py5.text_size(20)             # Textgroesse
     py5.fill(0, 255, 0)           # Textfarbe
     py5.text(&quot;300&quot;, 280, 550)     # Text zeichnen
     py5.text(&quot;100&quot;, 500, 150)
     py5.text(&quot;300&quot;, 500, 350)  
 
     # Gedrehtes Rechteck zeichnen
     py5.stroke(255, 255, 0)
     py5.stroke_weight(3)
     py5.fill(200, 200, 200) 
     py5.translate(320, 260)  
     py5.rotate(0.3)               # Drehung (in Radiant)
     py5.rect(0, 0, 100, 50)
 
 # Startet den Sketch
 py5.run_sketch()


Ausgabe:

[[Datei:PythonIng_py5_1.png|300px]]

Das skizzierte Haus ist mit einer rudimentären Bemaßung versehen und hat zwei Fenster, ein rundes und ein gedrehtes, trübes rechteckiges. 

Beispiel (Mausoperationen):

 import py5
 
 def setup():
     py5.size(600, 600)            
     py5.background(255, 255, 255)
 
 def draw():
     pass
    
 def mouse_pressed():
     py5.text_size(15) 
     py5.fill(0, 0, 255)
     x = py5.mouse_x
     y = py5.mouse_y
     py5.text(&quot;(%d, %d)&quot; %(x, y), x, y) # Positionsdaten bei Maus-Klick schreiben
 
 py5.run_sketch()

Ausgabe:

[[Datei:PythonIng_py5_2.png|300px]]

Obiges Bild zeigt das Resultat nach einigen Mausklicks. Man erkennt, dass links-oben der Koordinatennullpunkt ist. Die x-Achse zeigt nach rechts, die y-Achse nach unten.

Beispiel (Fünfeck):

 import py5
 import random 
 
 def setup():
     py5.size(400, 400)
     py5.no_loop()       # statisches Bild (schont die Ressourcen)
 
 def draw():
     py5.translate(py5.width / 2, py5.height / 2)  # KS setzen
 
     radius = 150
     eck_anzahl = 5
 
     py5.fill(random.randint(0, 255), random.randint(0, 255), 
              random.randint(0, 255))    # Füllfarbe auf Zufallswert setzen
     py5.stroke(155, 0, 0)            
     py5.stroke_weight(5)     
     
     # Fünfeck als Polygon zeichnen
     py5.begin_shape()
     for i in range(eck_anzahl):
         winkel = i * py5.TWO_PI / eck_anzahl - py5.HALF_PI
         x = py5.cos(winkel) * radius
         y = py5.sin(winkel) * radius
         py5.vertex(x, y)
     py5.end_shape(py5.CLOSE)
 
 py5.run_sketch()

Ausgabe, bspw.:

[[Datei:PythonIng_py5_5.png|200px]]

&lt;u&gt;Kleine Aufgaben:&lt;/u&gt;
* Um die Funktionsweise von &lt;code&gt;py5.no_loop()&lt;/code&gt; zu verstehen, kommentieren Sie die Anweisung im Beispiel einfach aus, und starten Sie das Programm erneut.
* Zeichnen Sie ein Siebeneck.
* Was passiert, wenn man &lt;code&gt;py5.CLOSE&lt;/code&gt; im &lt;code&gt;py5.end_shape()&lt;/code&gt;-Befehl weglässt?

Beispiel (Grafik laden und zeichnen):

 import py5
 
 image1 = None
 
 def setup():
     global image1
     py5.size(600, 600)
     py5.no_loop()
     image1 = py5.load_image(&quot;PythonIng_py5_1.png&quot;)
 
 def draw():
     py5.image(image1, 0, 0)
 
 py5.run_sketch()

Hier wird einfach das Bild vom Haus-Beispiel (Screenshot von weiter oben) geladen und gezeichnet.

Beispiel (angelehnt an ''W.5.10 Wurfparabel'' des genannten Buches; mit OOP erstellt):

 import py5
 
 class Wurfparabel(py5.Sketch):
     def __init__(self, v0, angle):
         super().__init__()
         self.v0 = v0
         self.angle = self.radians(angle)
         self.g = 9.81
         self.t = 0.0
         self.scale = 1.5
 
     def settings(self):
         self.size(800, 600)
 
     def setup(self):        
         self.background(0, 0, 0)
         
     def draw(self):
         self.t += 0.1
 
         self.translate(50, 500)
       
         # KS Zeichnen
         self.fill(255, 255, 0)
         self.stroke(255, 255, 0)
         self.stroke_weight(1)
         self.line(0, 0, 0, -300)
         self.line(0, 0, 700, 0)
 
         # Punkt zeichnen
         cx = self.v0 * self.cos(self.angle) * self.t * self.scale
         cy = -(self.v0 * self.sin(self.angle) * self.t - \
                self.g/2 * self.t**2) * self.scale
         self.fill(255, 0, 0)
         self.stroke(255, 0, 0)
         self.circle(cx, cy, 3)
        
         # Stoppen bei Bodenkontakt
         if cy &gt;= -5:
             self.no_loop()
            
 def wurfparabel(v0=50, angle=45):
     sketch = Wurfparabel(v0, angle)
     sketch.run_sketch()
 
 v0 = float(input(&quot;v0 = &quot;))
 winkel = float(input(&quot;winkel = &quot;))
 wurfparabel(v0=v0, angle=winkel)

Eingabe auf der Konsole:

 v0 = 60
 winkel = 45

Ausgabe:

[[Datei:PythonIng_py5_13.png|200px]]

Die benötigten Formeln der Bewegungsgleichung kann man leicht herleiten, bzw. man benutzt folgende Grafik als Hilfestellung:

[[Datei:Wurfparabel_Zusammenfassung_aktualisierung.png|700px]]

&lt;u&gt;Aufgabe:&lt;/u&gt; Berechnen Sie den Scheitelpunkt und die Wurfweite bei gegebener Anfangsgeschwindigkeit und gegebenem Abwurfwinkel. Die Abwurfhöhe &lt;math&gt;y_0&lt;/math&gt; sei 0. Der Wurf soll auf der Erde stattfinden (g = 9.81 m/s²). Die dazu benötigten Formeln können aus obiger Grafik entnommen werden (oder Sie leiten sie selbst her). Geben Sie die Ergebnisse auf der Konsole aus.

Beispiel (eine einfache Animation):

 import py5
 
 i = 0
 
 def setup():
     py5.size(600, 600)
     py5.frame_rate(5)
     py5.stroke_weight(20)
 
 def draw():
     global i
     
     py5.background(255, 255, 255)
     py5.translate(py5.width/2, py5.height/2)
     py5.rotate(py5.PI/8 * i)    
 
     py5.line(-100, 0, 100, 0)
     i += 1
 
 py5.run_sketch()

Es wird eine rotierende Linie gezeichnet (z.B. wie bei einem Installationsprozess verwendet - zeigt an, dass der Installationsfortschritt nicht eingefroren ist). Hierbei ist nur aufzupassen, dass der Hintergrund in &lt;code&gt;draw()&lt;/code&gt; gesetzt wird, ansonsten würden die Linien additiv gezeichnet. Das ist zwar auch schön, aber eben nicht das gewünschte Resultat.

Hiermit belassen wir es mit der py5-Bibliothek und wenden uns wieder &quot;mathematischeren&quot; Themen zu.

= Vektoren und Matrizen =
== Zahlenfolgen ==
Für das Erstellen von Zahlenfolgen bieten sich die Funktionen &lt;code&gt;arange&lt;/code&gt; und &lt;code&gt;linspace&lt;/code&gt; aus dem &lt;code&gt;numpy&lt;/code&gt;-Modul an.

 from numpy import *
 
 start = 0
 stop = 10
 step = 2
 num = 10
 
 r = arange(start, stop, step)   # step ... Schrittweite
 l = linspace(start, stop, num)  # num ... Anzahl der Werte
 
 print(&quot;r = &quot;, r)
 print(&quot;l = &quot;, l)

Ausgabe:
 r =  [0 2 4 6 8]
 l =  [ 0.          1.11111111  2.22222222  3.33333333  4.44444444  5.55555556
   6.66666667  7.77777778  8.88888889 10.        ]

Bei &lt;code&gt;arange&lt;/code&gt; ist der &lt;code&gt;stop&lt;/code&gt;-Wert nicht im Ergebnis enthalten, bei &lt;code&gt;linspace&lt;/code&gt; standardmäßig aber sehr wohl. Jedoch kann man das bei &lt;code&gt;linspace&lt;/code&gt; auch ändern. Dann ist der Stoppwert nicht mehr enthalten: 

 linspace(start, stop, num, endpoint=False)

== Vektoren ==
Vektoren sollten jedem aus der Linearen Algebra bekannt sein. 

=== Arrays ===
In Python mit NumPy kann man Vektoren durch die Funktion array erzeugen.

 import numpy as np
 
 l1 = (-5, 3, 2)
 l2 = (1, 1, 4)
 
 a1 = np.array(l1)
 a2 = np.array(l2)
 
 a3 = a1 + a2
 a4 = 2 * a2
 
 print(a1)
 print(a2)
 print(a3)
 print(a3[2])
 print(a4)

Ausgabe:
 [-5  3  2]
 [1 1 4]
 [-4  4  6]
 6
 [2 2 8]

=== Zeilen- und Spaltenvektoren ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 print(z)
 print(s)

Ausgabe:
 [ [-5  3  2] ]
 [[1]
  [1]
  [4]]

=== Skalarprodukt ===
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4))
 
 skalarprodukt = np.dot(a1, a2)  
 
 print(skalarprodukt)

Ausgabe:
 6

=== Vektorprodukt ===
&lt;math&gt;a\ast b=\left(\begin{array}{c}
a_{1}\\
a_{2}\\
a_{3}
\end{array}\right)\ast\left(\begin{array}{c}
b_{1}\\
b_{2}\\
b_{3}
\end{array}\right)=\left(\begin{array}{c}
a_{2}b_{3}-a_{3}b_{2}\\
a_{3}b_{1}-a_{1}b_{3}\\
a_{1}b_{2}-a_{2}b_{1}
\end{array}\right)
&lt;/math&gt; 

Python-Code:
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4)) 
 
 vektorprodukt = np.cross(a1, a2) 
 
 print(vektorprodukt)

Ausgabe:
 [10 22 -8]

=== Transponierter Vektor ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 # transponierter Vektor
 z_tp = np.transpose(z)
 # transponierter Vektor
 s_tp = np.transpose(s)
 
 print(z_tp)
 print(s_tp)

Ausgabe:
 [[-5]
  [ 3]
  [ 2]]
 [ [1 1 4] ]

=== Vektorfelder visualisieren ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 # Daten generieren
 x = np.arange(0, 10, 1)
 y = np.arange(0, 10, 1)
 X, Y = np.meshgrid(x, y)
 U = X * Y
 V = Y + X
 
 # Plotten
 fig, ax = plt.subplots()
 
 ax.quiver(X, Y, U, V, angles='xy')
 
 plt.show()

Ausgabe:

[[Datei:PythonIng_quiver1.png]]

== Matrizen==
 import numpy as np
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 print(m1)

Ausgabe:
 [[1 2 3]
  [4 5 6]]

=== Zugriff auf Matrizenelemente ===
Beispiel:

 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 
 # Element aus Zeile 2 und Spalte 3 (Achtung! Index startet bei Null)
 print(m1[1,2])

Ausgabe:
 6

Visualisierung:
  
     0   1   2
   +-----------+
 0 | 1 | 2 | 3 |
   +-----------+
 1 | 4 | 5 | '''6''' |
   +-----------+


Beispiel:

 import numpy as np
 
 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
 
 B = np.matrix(A)     
 
 print(B[2::, ::2])

Ausgabe:

 [['20' '22']
  ['30' '32']
  ['40' '42']]

Mit der NumPy-Bibliothek funktioniert das zweidimensionale Slicing. Mit normalen Listen/Tupels geht das nicht, was wir schon früher thematisiert haben.

=== Addition und Subtraktion von Matrizen ===
 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 m2 = np.matrix([[0, 0, 2], [1, 3, 2]])
 
 print(m1 + m2)
 print(m1 - m2)

Ausgabe:
 [[1 2 5]
  [5 8 8]]
 [[1 2 1]
  [3 2 4]]

=== Transponierte Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 2, 3], [4, 5, 6]])
 mt = np.transpose(m) 
 
 print(m)
 print(mt)

Ausgabe:
 [[1 2 3]
  [4 5 6]]
 [[1 4]
  [2 5]
  [3 6]]

=== Rang einer Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 rg = np.linalg.matrix_rank(m)
 
 print(rg)

Ausgabe:
 2

=== Inverse Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 mi = np.linalg.inv(m)
 
 print(mi)

Ausgabe:
 [[ 1.   0.6]
  [-0.  -0.2]]

=== Multiplikation von Matrizen (falksches Schema) ===
 import numpy as np
 
 m1 = np.matrix([[1, 3, 4],  [0, -5, 1]])
 m2 = np.matrix([[1, 2], [2, 3], [0, 2]])
 
 print(m1 @ m2)

Ausgabe:
 [[  7  19]
  [-10 -13]]

=== Eigenwerte und Eigenvektoren ===
 import numpy as np
 
 m = np.matrix([[5, 8],  [1, 3]])
 D,V = np.linalg.eig(m)
 
 # Eigenwerte
 print(D)
 # Eigenvektoren
 print(V)

Ausgabe:
 [7. 1.]
 [[ 0.9701425  -0.89442719]
  [ 0.24253563  0.4472136 ]]

=== Teilmatrizen ===
 import numpy as np
 m = np.matrix([[1, 3, 4],  [0, -5, 1]])
 print(&quot;m = &quot;, m)
 
 # Erste Zeile extrahieren
 m1 = m[0,:]
 print(&quot;m1 = &quot;, m1)
 
 # Das Element aus der 1. Zeile und der 2. Spalte extrahieren
 m2 = m[0,1]
 print(&quot;m2 = &quot;, m2)
 
 # Zweite Spalte extrahieren
 m3 = m[:, 1]
 print(&quot;m3 = &quot;, m3)

Ausgabe:
 m =  [[ 1  3  4]
  [ 0 -5  1]]
 m1 =  [ [1 3 4] ]
 m2 =  3
 m3 =  [[ 3]
  [-5]]

=== Spezielle Matrizen ===
==== Nullmatrix ====
 import numpy as np
 z = np.zeros((3, 2))
 print(z)

Ausgabe:
 [[0. 0.]
  [0. 0.]
  [0. 0.]]

==== Einheitsmatrix ====
 import numpy as np
 z = np.eye(3)
 print(z)

Ausgabe:
 [[1. 0. 0.]
  [0. 1. 0.]
  [0. 0. 1.]]

==== Matrix mit lauter Einsen ====
 import numpy as np
 z = np.ones((3, 2))
 print(z)

Ausgabe:
 [[1. 1.]
  [1. 1.]
  [1. 1.]]

=== Spärlich besetzte Matrizen ===
Das Thema spärlich besetzter Matrizen wird hier nur kurz angerissen. Nähere Details siehe unter dem Weblink  [https://docs.scipy.org/doc/scipy/reference/sparse.html#module-scipy.sparse]. 

Beispiel:

 import numpy as np
 import scipy
 
 A = scipy.sparse.csr_array(np.eye(5))
 
 print(A)

Ausgabe:
 &lt;Compressed Sparse Row sparse array of dtype 'float64'
         with 5 stored elements and shape (5, 5)&gt;
   Coords        Values
   (0, 0)        1.0
   (1, 1)        1.0
   (2, 2)        1.0
   (3, 3)        1.0
   (4, 4)        1.0

csr steht für '''c'''ompressed '''s'''parse '''r'''ow.

Andere Möglichkeiten:
* coo-Format ('''coo'''rdinate Format): &lt;code&gt;scipy.sparse.coo_array()&lt;/code&gt;
* lil-Format ('''li'''st of '''l'''ists): &lt;code&gt;scipy.sparse.lil_array()&lt;/code&gt;
* csc-Format ('''c'''ompressed '''s'''parse '''c'''olumn): &lt;code&gt;scipy.sparse.csc_array()&lt;/code&gt;

Es gibt auch &lt;code&gt;scipy.sparse.csr_matrix()&lt;/code&gt; etc. Diese Befehle sind aber veraltet und es wird empfohlen, statt dessen die &lt;code&gt;..._array()&lt;/code&gt;-Funktionen zu verwenden.

&lt;u&gt;Aufgaben:&lt;/u&gt; 
Recherchieren Sie im Internet 
* generell zum Thema &quot;spärlich besetzte Matrizen mit Python&quot;.
* Was sind die Vor-/Nachteile von csr-arrays gegenüber coo- und lil-arrays?
* Wann verwendet man sinnvollerweise csr- und wann csc-arrays?
* Wie wandelt man coo-arrays in csr-arrays um?

= Lineare Gleichungssysteme =
Sei &lt;math&gt;Ax = b&lt;/math&gt; ein lineares Gleichungssystem. &lt;math&gt;A&lt;/math&gt; sei die Koeffizientenmatrix, &lt;math&gt;x&lt;/math&gt; der Lösungsvektor und &lt;math&gt;b&lt;/math&gt; ein bekannter Vektor.

Beispiel:
 import numpy as np
 
 A = np.array([[5, 1], [0, 2]])
 b = np.array([1, 2])
 
 x = np.linalg.solve(A, b)
 
 print(x)

Ausgabe:
 [0. 1.]

Siehe dazu auch das Kapitel [[Ing Mathematik: Numerisches Lösen von linearen Gleichungssystemen]]. Dort wird dieses Themengebiet u.a. mit weitergehenden Python-Skripten vertieft.

== Aufgabe ==
* Lösen Sie folgendes Gleichungssystem mittels Python (und zur Kontrolle auch händisch): 
 5x + 6y - 2z = 12
 3x - y  - 3z = 6
 2x + 2y + 4z = 5

= Polynome =
== Ein erstes einfaches Beispiel ==
Gegeben sei das Polynom &lt;math&gt;7x^3+5x^2+1&lt;/math&gt;. In Python:

 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p)

Ausgabe:
    3     2
 7 x + 5 x + 1

== Einzelne Polynomwerte berechnen ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p(1.5))

Ausgabe:
 35.875

== Polynome integrieren und differenzieren ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 
 # 1. Ableitung
 p1 = p.deriv()
 p2 = p.deriv(1)
 
 # 2. Ableitung
 p3 = p.deriv(2)
 
 # Integral
 p4 = p.integ()
 
 print(p1)
 print(p2)
 print(p3)
 print(p4)

Ausgabe:
     2
 21 x + 10 x
     2
 21 x + 10 x
 
 42 x + 10
       4         3
 1.75 x + 1.667 x + 1 x

== Nullstellen bestimmen ==
 import numpy as np
 
 p = np.poly1d([2, 5, 0, 4])
 r = np.roots(p)
 
 print(r)

Ausgabe:
 [-2.7621427 +0.j          0.13107135+0.84077099j  0.13107135-0.84077099j]

== Aufgaben ==
* Berechnen Sie den Wert für x = 3 des Polynoms &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Differenzieren und integrieren Sie das Polynom &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Berechnen Sie die Nullstellen von &lt;math&gt;y = 7x^5 - 3x^2 + 12&lt;/math&gt;.

= Nichtlineare Gleichungen und Gleichungssysteme =
== Nullstellenbestimmung ==
Löse eine beliebige Gleichung f(x) = 0, z.B. &lt;math&gt; f(x) = x^2 - 5\cos(x) - 10 = 0 &lt;/math&gt;:
 import scipy
 import numpy as np
 
 def f(x):
     return x**2 - 5*np.cos(x) - 10
    
 xstart = [-1, 1]        # Startwerte
 xn = scipy.optimize.root(f, xstart)
 
 print(xn.x)

Ausgabe:
 [-2.46813009  2.46813009]

Funktionsgraph:

[[Datei:octave_nichtlin2.jpg]]

== Gleichungssysteme ==
SymPy ist ein externes Modul, das symbolisches Rechnen ('''Sym'''bolic '''Py'''thon) ermöglicht. 

Folgende Aufgabe ist dem Buch &quot;Knorrenschild: Numerische Mathematik, Hanser, 2017, Seite 72&quot; entnommen. Zu lösen ist das nichtlineare Gleichungssystem

&lt;math&gt;f_1 = 2x_1 + 4x_2 = 0 &lt;/math&gt;

&lt;math&gt;f_2 = 4x_1 + 8x_2^3 = 0&lt;/math&gt;

Mit Python ist das so möglich:
 import sympy
 
 x1, x2 = sympy.symbols(&quot;x1 x2&quot;) 
 
 f1 = 2*x1 + 4*x2
 f2 = 4*x1 + 8*x2**3
 
 s = sympy.solve((f1, f2), x1, x2) 
 
 print(s)

Ausgabe:
 [(-2, 1), (0, 0), (2, -1)]

Plot:

[[Datei:IngPython_nl_gleichung1.svg|500px]]

= Komplexe Zahlen =
Die imaginäre Einheit wird in Python durch den Buchstaben &lt;code&gt;j&lt;/code&gt; symbolisiert. Darstellen kann man eine komplexe Zahl bekannterweise in mehreren Formen:
* Kartesische Darstellung &lt;math&gt;z = \Re(z) + j \cdot \Im(z)&lt;/math&gt;
* Polardarstellungen &lt;math&gt;z = r \cdot (\cos(\phi) + j \cdot \sin(\phi)) = r \cdot e^{j\cdot \phi}&lt;/math&gt;

Die konjugiert komplexe Zahl ist &lt;math&gt;z^* = \Re(z) - j \cdot \Im(z)&lt;/math&gt;

Nachfolgend einige mathematische Operationen mit Python und NumPy.

 import numpy as np
 
 z1 = 2 + 5j           # kartesische Darstellung
 z2 = 3 * np.exp(3j)   # Polardarstellung
  
 # Addition
 res = z1 + z2
 print(&quot;z1 + z2 = &quot;, res)
 
 # Multiplikation
 res = z1 * z2
 print(&quot;z1 * z2 = &quot;, res)
 
 # Realteil
 res = np.real(z2)
 print(&quot;Realteil von z2 = &quot;, res)
 
 # Imaginärteil
 res = np.imag(z2)
 print(&quot;Imaginaerteil von z2 = &quot;, res)
 
 # Betrag
 res = np.abs(z1)
 print(&quot;Betrag von z1 = &quot;, res)
 
 # Argument
 res = np.angle(z1)
 print(&quot;Argument von z1 = &quot;, res)
 
 # Konjugiert komplexe Zahl
 res = np.conj(z1)
 print(&quot;Konjugiert komplexe Zahl von z1 = &quot;, res)

Ausgabe:
 z1 + z2 =  (-0.9699774898013365+5.423360024179601j)
 z1 * z2 =  (-8.05675510050068-14.003167400647481j)
 Realteil von z2 =  -2.9699774898013365
 Imaginaerteil von z2 =  0.4233600241796016
 Betrag von z1 =  5.385164807134504
 Argument von z1 =  1.1902899496825317
 Konjugiert komplexe Zahl von z1 =  (2-5j)

= Interpolation =
 import numpy as np
 import scipy
 import matplotlib.pyplot as plt
 
 # Stützpunkte
 xp = np.arange(1, 6)
 yp = (0, -5, 2, 7, 6)
 
 ti = np.arange(1, 5, 0.01)
 
 i1 = scipy.interpolate.interp1d(xp, yp, kind = &quot;linear&quot;)
 i2 = scipy.interpolate.interp1d(xp, yp, kind = &quot;cubic&quot;) 
 
 plt.plot(xp, yp, &quot;rx&quot;)
 plt.plot(xp, i1(xp))
 plt.plot(ti, i2(ti))
 plt.show()

Ausgabe:

[[Datei:PythonIng_interpol1.png]]

= Differenzialrechnung =
== Numerisches Differenzieren ==
Als Beispiel differenzieren wir &lt;math&gt;y = 5x\sin{x}&lt;/math&gt; und stellen das Ganze grafisch dar.

 from findiff import Diff
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.linspace(0, 10, 1000)
 f = 5 * x * np.sin(x)
 dx = x[1] - x[0]
 
 # Ableitung
 d_dx = Diff(0, dx)
 df_dx = d_dx(f)
 
 # Grafik
 plt.plot(x, f, label = &quot;y&quot;)
 plt.plot(x, df_dx, label = &quot;y'&quot;)
 plt.grid()
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

Ausgabe:

[[Datei:octave_diff1.jpg]]

&lt;small&gt;findiff ist ein externes Modul. Dieses muss installiert werden (z.B. so: ...\Python\Scripts\pip.exe install --upgrade findiff). Für die Vorgehensweise unter openSUSE Tumbleweed siehe das Kapitel [[Ing_Mathematik:_Python#Mit_VPython | VPython]], nur dass das Ganze mit einer aktuelleren Python-Version exekutiert wird, z.B. mit Python 3.13.  Das im Buch &quot;Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler, Rheinwerk&quot; verwendete Modul &quot;scipy.misc&quot; ist veraltet (deprecated ... missbilligt). Lt. [https://docs.scipy.org/doc/scipy-1.17.0/dev/roadmap-detailed.html#misc SciPy-Dokumentation für die Version 1.17.0] wurden alle entsprechenden Features schon entfernt.&lt;/small&gt;

== Symbolisches Differenzieren ==
Differenzieren Sie die Funktionen &lt;math&gt;f_1(x) = x^2&lt;/math&gt; und &lt;math&gt;f_2(x) = \sin(x)\cos\left(\frac{x}{2}\right)&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2;
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 d1 = sympy.diff(f1, x)
 d2 = sympy.diff(f2, x)
 
 print(d1)
 print(d2)

Ausgabe:
 2*x
 -0.5*sin(0.5*x)*sin(x) + cos(0.5*x)*cos(x)

== Aufgaben ==
* Differenzieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.
* Differenzieren Sie die Funktion &lt;math&gt;y = \frac{\sinh(x)}{(1+x)}&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.

= Integralrechnung =
== Numerisches Integrieren ==
Berechnen Sie das Integral &lt;math&gt;\int_{0}^{3}x^2 dx&lt;/math&gt;.

 import scipy
 
 def f(x):
     return x**2
    
 i = scipy.integrate.quad(f, 0, 3)
 print(i)

Ausgabe:
 (9.000000000000002, 9.992007221626411e-14)

Das trifft den exakten Wert 9.0 ziemlich genau.

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} dx&lt;/math&gt;.

 import scipy
 import numpy as np
 
 def f(x):
     return 2**(-x)
   
 i = scipy.integrate.quad(f, 0, np.inf)
 print(i)

Ausgabe:
 (1.4426950408889556, 4.486558477977586e-09)

== Symbolisches Integrieren ==
Berechnen Sie &lt;math&gt;\int x^2 \text{d}x&lt;/math&gt; und &lt;math&gt;\int \sin{x}\cos{\frac{x}{2}} \text{d}x&lt;/math&gt;.
 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 i1 = sympy.integrate(f1, x)
 i2 = sympy.integrate(f2, x)
 
 print(i1)
 print(i2)

Ausgabe:
 x**3/3
 -0.666666666666667*sin(0.5*x)*sin(x) - 1.33333333333333*cos(0.5*x)*cos(x)

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} \text{d}x&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f = 2**(-x)
 i = sympy.integrate(f, (x, 0, sympy.oo))
 print(i)

Ausgabe:
 1/log(2)

&lt;code&gt;sympy.oo&lt;/code&gt; steht für das {{W|Unendlichzeichen}} &lt;math&gt;\infty&lt;/math&gt; (die liegende Acht oder das Möbiusband). Mit &lt;code&gt;sympy.pprint(i)&lt;/code&gt; ließe sich letzere Ausgabe etwas schöner schreiben:

   1   
 ──────
 log(2)

Man beachtete, &lt;code&gt;log&lt;/code&gt; steht hier für den natürlichen Logarithmus &lt;code&gt;ln&lt;/code&gt;.

== Aufgaben ==
* Integrieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; von 1 bis 5.
* Integrieren Sie die Funktion &lt;math&gt;y = x^3&lt;/math&gt; von 0 bis 4.
* Integrieren Sie &lt;math&gt;\int x^x(\log (x) + 1)\mathrm dx&lt;/math&gt; symbolisch.

= Gewöhnliche Differenzialgleichungen =
== DGL numerisch lösen ==
Für die Lösung von Differenzialgleichungen steht u.a. die Funktion scipy.integrate.solve_ivp() zur Verfügung. Diese Funktion implementiert auch das Runge-Kutta-Verfahren (RK45).

{{Wikipedia | Runge-Kutta-Verfahren}}

Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import scipy
 import numpy as np
 import matplotlib.pyplot as plt
 
 def dy_dx(x, y):
     return x**2 + y**3
 
 y0 = [1]
 xi = [0, 1]
 x = np.arange(0, 1, 0.01)
 
 z = scipy.integrate.solve_ivp(dy_dx, xi, y0, method=&quot;RK45&quot;, dense_output=True)
 y = z.sol(x)
 
 plt.plot(x, y.T)
 plt.grid()
 plt.show()

[[Datei:PythonIng_dgl1.png]]

== DGL symbolisch lösen ==
Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 print(lsg)

Ausgabe:
 [Eq(f(x), (-x**2)**(1/3)), Eq(f(x), (-x**2)**(1/3)*(-1 - sqrt(3)*I)/2), Eq(f(x), (-x**2)**(1/3)*(-1 + sqrt(3)*I)/2)]

Mit &lt;code&gt;sympy.pprint&lt;/code&gt; (pretty print) lässt sich die Ausgabe etwas übersichtlicher darstellen.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 sympy.pprint(lsg)

Ausgabe:
 ⎡                           _____                        _____            ⎤
 ⎢          _____         3 ╱   2                      3 ╱   2             ⎥
 ⎢       3 ╱   2          ╲╱  -x  ⋅(-1 - √3⋅ⅈ)         ╲╱  -x  ⋅(-1 + √3⋅ⅈ)⎥
 ⎢f(x) = ╲╱  -x  , f(x) = ────────────────────, f(x) = ────────────────────⎥
 ⎣                                 2                            2          ⎦

== Aufgaben ==
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \frac{1}{x\cdot y}&lt;/math&gt; mit Python. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;m' = -k\cdot m&lt;/math&gt;. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \sqrt{|y|}&lt;/math&gt;.

=Laplace-Transformation=
Laplace-Transformation:

&lt;math&gt;F(s) =\mathcal{L} \left\{f\right\}(s) = \int_{0}^{\infty} f(t) \mathrm e^{-st} \,\mathrm{d}t, \qquad s\in\mathbb{C}
&lt;/math&gt;

Inverse Laplace-Transformation:

&lt;math&gt;\mathcal{L}^{-1} \left\{F\right\}(t)
  = \frac{1}{2 \pi \mathrm j} \int_{ \gamma - \mathrm j \infty}^{ \gamma + \mathrm j \infty} \mathrm e^{st} F(s)\,\mathrm ds 
= \begin{cases}
      f(t) &amp; \text{für } t \geq 0 \\
      0    &amp; \text{für } t &lt; 0
    \end{cases}
&lt;/math&gt;

Siehe auch [[Ing_Mathematik:_Laplace-Transformation]]

Code:
 import sympy
 from sympy.abc import t, s
 
 # Laplace-Transformation der Funktion f(t) = 1 (Heaviside-Fkt.)
 f = 1
 # alternativ: f = sympy.Heaviside(t)
 F = sympy.laplace_transform(f, t, s, noconds=True)
 print(&quot;Laplace-Transformierte F(s):&quot;, F) 
 
 # Inverse Laplace-Transformation zurück in den Zeitbereich
 f_inv = sympy.inverse_laplace_transform(F, s, t)
 print(&quot;Inverse Transformation f(t):&quot;, f_inv)

Ausgabe:
 Laplace-Transformierte F(s): 1/s
 Inverse Transformation f(t): Heaviside(t)

Die Zeile

 from sympy.abc import t, s

steht alternativ für

 t = sympy.symbols(&quot;t&quot;)
 s = sympy.symbols(&quot;s&quot;)

&lt;u&gt;Aufgaben&lt;/u&gt;: Ermitteln Sie mittels SymPy die &lt;math&gt;\mathcal{L}&lt;/math&gt;-Transformierten und dann wieder die  &lt;math&gt;\mathcal{L}^{-1}&lt;/math&gt;-Transformationen (ähnlich wie beim obigen Beispiel):
* &lt;math&gt;\sin(t) \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;t^3 \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;\text{e}^{\omega t} \circ\! -\! \bullet \ ?&lt;/math&gt;

=Fourier-Reihen=
&lt;math&gt;
f(x)\approx \frac{a_{0}}{2}+\sum_{k=1}^{\infty}\left(a_{k}\cos\left(kx\right)+b_{k}\sin\left(kx\right)\right)
&lt;/math&gt;

&lt;math&gt;
a_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\cos\left(kx\right)\mathrm dx\quad\text{für }k\geq0
&lt;/math&gt;

&lt;math&gt;
b_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\sin\left(kx\right)\mathrm dx\quad\text{für }k\geq1
&lt;/math&gt;

Für die Sägezahnfunktion &lt;math&gt;y=x;\, 0 &lt; x &lt; 2\pi&lt;/math&gt; sei die Fourierreihe mit einem Python-Programm (unter Mithilfe von sympy) hergeleitet.

Code:

 from sympy import fourier_series, pi, symbols, pprint
 
 x = symbols('x')
 f = x
 s = fourier_series(f, (x, 0, 2*pi))
 pprint(s.truncate(n=4))

Ausgabe:

                        2⋅sin(3⋅x)    
 -2⋅sin(x) - sin(2⋅x) - ────────── + π
                            3

Siehe auch [[Ing Mathematik: Fourierreihen]].

Ein komplizierteres Beispiel:

[[Datei:IngMath fourier bsp13.svg | 300px]]

&lt;math&gt;0\le t &lt; T/2\text{:}\quad f(t) = H&lt;/math&gt;

&lt;math&gt;T/2 \le t \le T\text{:}\quad f(t) = \frac{2H}{T}\left( t-\frac{T}{2}\right)&lt;/math&gt;

Code:

 import sympy as sp
 
 H = sp.Symbol('H', positive=True)
 T = sp.Symbol('T', positive=True)
 t = sp.Symbol('t')
 
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T/2)),
     (2*H/T*(t-T/2), (t &gt; T/2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Ausgabe:

      ⎛2⋅π⋅t⎞        ⎛4⋅π⋅t⎞        ⎛6⋅π⋅t⎞          ⎛2⋅π⋅t⎞          ⎛6⋅π⋅t⎞      
 H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   2⋅H⋅cos⎜─────⎟   2⋅H⋅cos⎜─────⎟      
      ⎝  T  ⎠        ⎝  T  ⎠        ⎝  T  ⎠          ⎝  T  ⎠          ⎝  T  ⎠   3⋅H
 ──────────── - ──────────── + ──────────── + ────────────── + ────────────── + ───
      π             2⋅π            3⋅π               2                 2         4 
                                                    π               9⋅π

=Rechnen mit wirklich großen Zahlen=
Bekannt ist, dass Python kaum Einschränkungen beim Wertebereich von Ganzzahlen hat, z.B.

 print(10**300)

Ausgabe (gekürzt):

 100000000000000000000...00000000000000000000000000000000000000000000000000000000000000000000000

Ähnliches geht auch mit Gleitpunktzahlen, z.B. durch die Verwendung des Moduls [https://mpmath.org/ mpmath]:

 import mpmath
 print(mpmath.mpf(1500.4)**mpmath.mpf(300))

Ausgabe:

 7.27975299218612e+952

Anderes Beispiel:

 from mpmath import mp, pi
 mp.dps = 100
 print(pi)

Ausgabe:

 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068

mpmath kann noch einiges mehr, dazu sei aber auf die entsprechende Dokumentation auf der mpmath-Homepage verwiesen. mpmath ist Bestandteil von SymPy, kann aber auch separat installiert werden.

Aber auch Python selbst besitzt eine Möglichkeit, um mit großen bzw. exakten Gleitpunktzahlen zu rechnen, nämlich das interne Modul decimal. Dieses hat einige Vorteile gegenüber mpmath, aber auch gravierende Nachteile. Diese seien hier nicht detailliert aufgezählt. Grob gesagt hat decimal im Finanzwesen seine Berechtigung. Für wissenschaftliche Anwendungen wird aber mpmath vorzuziehen sein, da es u.a. vielfältige mathematische Funktionen bereit stellt. Nachfolgend ein einfaches Beispiel mit decimal:

 import decimal
 print(&quot;Potenzierung:&quot;, decimal.Decimal(1500.4) ** decimal.Decimal(300.0))
 print(&quot;Einfache Addition:&quot;, 0.1 + 0.2)
 decimal.getcontext().prec = 50
 print(&quot;Addition mit decimal:&quot;, decimal.Decimal(&quot;0.1&quot;) + decimal.Decimal(&quot;0.2&quot;))

Ausgabe:

 Potenzierung: 7.279752992186121551039839134E+952
 Einfache Addition: 0.30000000000000004
 Addition mit decimal: 0.3

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet die genauen Vor- und Nachteile von decimal und mpmath. Verwenden Sie dazu auch KI (z.B. von Google, chatgpt).

= pint - mit physikalischen Größen rechnen = 
[[File:Pint-Glas_UK.jpg|right|100px]]
pint ist ein externes Python-Paket zur Manipulation von physikalischen Einheiten. Es muss vor der ersten Benutzung installiert werden (Vorgehensweise wie immer: pip, YaST, via venv etc.).

Beispiel:

 import pint
 import numpy as np
 
 ureg = pint.UnitRegistry()
 
 # Einfache Berechnung
 print(3 * ureg.meter + 4 * ureg.cm)
 
 # Mit NumPy
 npeinzel = [3, 4] * ureg.meter + [2, 5] * ureg.cm
 print(npeinzel)
 npsum = np.sum(npeinzel)
 print(npsum)
 
 # Konvertierung von Einheiten
 npsum_inch = npsum.to(ureg.inch)
 print(npsum_inch)
 
 print(npeinzel.magnitude)
 print(npeinzel.units)
 print(npeinzel.dimensionality)

Ausgabe:

 3.04 meter
 [3.02 4.05] meter
 7.07 meter
 278.3464566929134 inch
 [3.02 4.05]
 meter
 [length]

Die Dokumentation zu pint findet sich auf [https://pint.readthedocs.io/en/stable/].

=Regelungstechnische Aufgabenstellungen=
Für regelungstechnische Aufgaben gibt es u.a. das externe Paket &lt;code&gt;control&lt;/code&gt;. Hier soll nicht detailliert darauf eingegangen werden. Anhand eines Beispiels soll anschließend nur die Visualisierung in Form eines Bode-Diagramms und der Sprungantwort gezeigt werden. Gegeben sei ein P-Regler mit &lt;math&gt;R = \frac{5}{2}&lt;/math&gt; und eine Strecke &lt;math&gt;S= \frac{1}{30s^3+20s^2+10s+1,5}&lt;/math&gt;. Gesucht sei vorerst ein Bode-Diagramm für den offenen Regelkreis und das Führungsverhalten.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke  # oder: G0 = ct.series(regler, strecke)
 Gw = ct.feedback(G0)
 
 ct.bode_plot(G0, label='G0')
 ct.bode_plot(Gw, label='Gw')
 plt.show()

[[Datei:PythonIng_bode1.svg]]

Nun noch für obiges Beispiel die Sprungantwort. Diese zeigt einige große Überschwinger, d.h. der Regler kann sicher noch optimiert werden.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke 
 Gw = ct.feedback(G0) 
 
 t, y = ct.step_response(Gw)
 
 plt.plot(t,y)
 plt.title('Sprungantwort')
 plt.xlabel('t')
 plt.ylabel('h(t)')
 plt.grid()
 plt.show()

[[Datei:PythonIng_bode3.svg]]

Einige weitere wichtige Daten (Phasenreserve, Amplitudenreserve, Durchtrittsfrequenz) lassen sich mittels der &lt;code&gt;control&lt;/code&gt;-Funktion &lt;code&gt;margin()&lt;/code&gt; ermitteln. Die Ortskurve lässt sich mit der Funktion &lt;code&gt;nyquist_plot()&lt;/code&gt; zeichnen. Dies sei hier aber nicht weiter ausgeführt.

==Aufgaben==
* Zeichen Sie mit Python die Ortskurve für obiges Beispiel.
* Was passiert, wenn man die Reglerverstärkung weiter aufdreht (z.B. auf &lt;math&gt;R = \frac{25}{2}&lt;/math&gt;)?
* Wie sehen das Bode-Diagramm und die Sprungantwort aus, wenn ein PI-Regler verwendet wird?

= Stereostatik etc. =
Das Modul SymPy bietet einige Möglichkeiten einfache Bauwerke zu berechnen, z.B. Balken oder Fachwerke. Nachfolgend wird ein einfaches Fachwerk berechnet und gezeichnet.

Python-Code:
 from sympy.physics.continuum_mechanics.truss import Truss 
 
 t = Truss()
 # Knoten
 t.add_node((&quot;A&quot;, -3, 0), (&quot;B&quot;, 0, 0), (&quot;C&quot;, 4, 0), (&quot;D&quot;, 7, 0),
            (&quot;E&quot;, 6, 1.5), (&quot;F&quot;, 2, 3), (&quot;G&quot;, -2, 1.5))
 # Stäbe
 t.add_member((&quot;AB&quot;,&quot;A&quot;,&quot;B&quot;), (&quot;BC&quot;,&quot;B&quot;,&quot;C&quot;), (&quot;CD&quot;,&quot;C&quot;,&quot;D&quot;))
 t.add_member((&quot;AG&quot;,&quot;A&quot;,&quot;G&quot;), (&quot;GB&quot;,&quot;G&quot;,&quot;B&quot;), (&quot;GF&quot;,&quot;G&quot;,&quot;F&quot;))
 t.add_member((&quot;BF&quot;,&quot;B&quot;,&quot;F&quot;), (&quot;FC&quot;,&quot;F&quot;,&quot;C&quot;), (&quot;CE&quot;,&quot;C&quot;,&quot;E&quot;))
 t.add_member((&quot;FE&quot;,&quot;F&quot;,&quot;E&quot;), (&quot;DE&quot;,&quot;D&quot;,&quot;E&quot;))
 # Auflager; roller ... Loslager, pinned ... Festlager
 t.apply_support((&quot;A&quot;,&quot;roller&quot;), (&quot;D&quot;,&quot;pinned&quot;))
 # Einwirkende Kräfte
 t.apply_load((&quot;G&quot;, 5, 270), (&quot;E&quot;, 3, 90))
 
 # Berechnung 
 t.solve()
 print(&quot;Reaction Forces: &quot;, t.reaction_loads)
 print(&quot;Internal Forces: &quot;, t.internal_forces)
 
 # Fachwerk zeichnen
 p = t.draw()
 p.show()

Ausgabe auf der Konsole:

 Reaction Forces:  {'R_A_y': 4.20000000000000, 'R_D_x': 0, 'R_D_y': -2.20000000000000}
 Internal Forces:  {'AB': 2.80000000000000, 'BC': 0.333333333333333, 'CD': -1.46666666666667, 
 'AG': -5.04777178564958, 'GB': -2.05555555555556, 'GF': -1.23413387432364, 
 'BF': 0.411111111111111*sqrt(13), 'FC': -0.3*sqrt(13), 'CE': 1.50000000000000, 
 'FE': 0.284800124843917, 'DE': 2.64407093534026}

Zeichnung:

[[File:PythonIng_fachwerk1.svg|300px]]

Details zu diesem Thema siehe z.B. [https://docs.sympy.org/latest/modules/physics/continuum_mechanics/index.html Continuum Mechanics] oder [https://docs.sympy.org/latest/tutorials/physics/continuum_mechanics/index.html Continuum Mechanics Tutorials]. Auch andere mechanische Probleme werden von SymPy abgehandelt ([https://docs.sympy.org/latest/tutorials/physics/index.html Physics Tutorials]).

== Aufgabe ==
Gegeben sei ein einseitig eingespannter Kragträger. Belastet wird er durch eine Einzellast am Trägerende. Für die Daten siehe folgende ASCII-Skizze:

                            | 20 kN  
    //|---&gt; x               |
    //|                     V
    //|----------------------
    //|         10 m        |
 
 Elastizitätsmodul E = 2,1*10⁵ N/mm²
 Flächenträgheitsmoment I = 0.001 m⁴

Berechnen Sie die Auflagerreaktionen, den Querkraft- und Biegemomentenverlauf, sowie die Verformungen.
Stellen Sie dies mit Hilfe von SymPy graphisch und auch mittels Formeln dar. Verwenden Sie dazu auch pprint (pretty print) aus dem SymPy-Modul. Zwecks Lösungsansatz siehe die oben aufgeführte Seite &quot;Continuum Mechanics Tutorials&quot;. Achten Sie auch auf die Einheiten! Kontrollieren Sie das Ganze mittels händischer Rechnung. In dem genannten Tutorial ist von &quot;Singularity Functions&quot; die Rede. Gemeint ist damit in diesem Kontext die {{W|Föppl-Klammer}}.

Einige Python-Programme, vorrangig zu Maschinenelementen, finden sich auf [https://baymp.de/download_python.html BayMP für Python] (Balken, Zahnräder, Stabknickung usw.).

=Thermodynamik= 
== PYroMat ==
Für thermodynamische Aufgabenstellungen gibt es verschiedene externe Module. Eines davon ist PYroMat (siehe auch [http://pyromat.org]). Damit lassen sich thermodynamische Stoffdaten für viele Substanzen berechnen.

Beispiel (einige Stoffdaten für Wasser bei 400°C und 20 bar berechnen):

 import pyromat as pm
 
 # Wasserdaten laden:
 H2O = pm.get('mp.H2O')
 
 # Stoffdaten berechnen:
 T = 673.15  # Temperatur in Kelvin
 p = 20      # Druck in bar
 v = H2O.v(T, p)
 h = H2O.h(T, p)
 s = H2O.s(T, p)
 print(f&quot;Spezifisches Volumen: {v} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {h} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {s} kJ/(kg K)&quot;)

Ausgabe:

 Spezifisches Volumen: [0.1512163] m³/kg
 Spezifische Enthalpie: [3248.3789473] kJ/kg
 Spezifische Entropie: [7.12924142] kJ/(kg K)

&lt;small&gt;
PYroMat muss vorab installiert werden (z.B. mittels pip, in eine virtuelle Umgebung)
&lt;/small&gt;

&lt;code&gt;mp&lt;/code&gt; steht für &quot;multi phase&quot;. Für ein ideales Gas wäre &lt;code&gt;ig&lt;/code&gt; zuständig, z.B. &lt;code&gt;'ig.O2'&lt;/code&gt;.

Beispiel (T-s-Diagramm für Wasser zeichnen):
 import numpy as np
 import matplotlib.pyplot as plt
 import pyromat as pm
 
 # Konfigurieren
 pm.config[&quot;unit_pressure&quot;] = &quot;bar&quot;
 pm.config[&quot;unit_temperature&quot;] = &quot;K&quot;
 fluid = pm.get(&quot;mp.H2O&quot;)
 
 # Temperaturbereich für das Nassdampfgebiet
 T_tripel = 273.16
 T_crit = 647.096
 T = np.linspace(T_tripel, T_crit - 0.1, 200)
 
 # Sättigungslinien berechnen und zeichnen
 for x in np.linspace(0.0, 1.0, 5):
     s = fluid.s(T=T, x=x)
     if(x&lt;=0.0):
         plt.plot(s, T, label=&quot;Siedelinie x=%3.1f&quot; % x, linewidth=2.0)
     elif(x&gt;=1.0):
         plt.plot(s, T, label=&quot;Taulinie x=%3.1f&quot; % x, linewidth=2.0)
     else:
         plt.plot(s, T, label=&quot;x=%3.1f&quot; % x, linewidth=1.0)
 
 # Isobaren zeichnen
 p_values = [0.1, 1, 10, 50, 100]
 T_isobar = np.linspace(T_tripel, 1000, 200)
 t = 0.7
 
 for p in p_values:
     s_iso = fluid.s(T=T_isobar, p=p)
     plt.plot(s_iso, T_isobar, 'k-', alpha=0.8, linewidth=0.8)
 
     t += .05
     idx = int(len(s_iso) * t)
     plt.text(s_iso[idx], T_isobar[idx], f&quot;{p} bar&quot;, fontsize=9, alpha=0.8)
 
 # Diagramm zeichnen
 plt.title(&quot;T-s-Diagramm für Wasser&quot;)
 plt.xlabel(&quot;Spezifische Entropie s in kJ/kg K&quot;, fontsize=10)
 plt.ylabel(&quot;Temperatur T in K&quot;, fontsize=10)
 plt.legend(loc=&quot;best&quot;)
 plt.grid(True)
 plt.show()

Ausgabe (in etwa so):

[[Datei:T-s-Diagramm fuer Wasser.svg|400px]]

== CoolProp ==
Auch mit CoolProp können Stoffdaten berechnet werden. Siehe auch [https://coolprop.org/coolprop/wrappers/Python/index.html]

Beispiel (Wasser bei 20bar und 400°C):
 import CoolProp.CoolProp as CP
 
 fluid = 'Water'
 T = 673.15   # Temperatur in Kelvin
 P = 20e5     # Druck in Pascal
 
 dichte = CP.PropsSI('D', 'T', T, 'P', P, fluid)
 enthalpie = CP.PropsSI('H', 'T', T, 'P', P, fluid)
 entropie = CP.PropsSI('S', 'T', T, 'P', P, fluid)
 
 print(f&quot;Spez. Volumen: {1/dichte:.6f} m³/kg&quot;)
 print(f&quot;Spez. Enthalpie: {enthalpie:.2f} J/kg&quot;)
 print(f&quot;Spez. Entropie: {entropie:.2f} J/kgK&quot;)

Ausgabe:
 Spez. Volumen: 0.151215 m³/kg
 Spez. Enthalpie: 3248344.02 J/kg
 Spez. Entropie: 7129.16 J/kgK

== iapws ==
Um Werte für Wasser(dampf) zu erhalten (IAPWS; '''I'''nternational '''A'''ssociation for the '''P'''roperties of '''W'''ater and '''S'''team) gibt es die Bibliothek iapws. Siehe auch [https://iapws.org/] und [https://pypi.org/project/iapws/]

Beispiel (Wasser für 20bar und 400°C):
 from iapws import IAPWS97
 
 dampf = IAPWS97(P=2.0, T=673.15)
 
 print(f&quot;Spezifisches Volumen: {dampf.v:.6f} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {dampf.h:.2f} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {dampf.s:.4f} kJ/(kgK)&quot;)
 print(f&quot;Phase: {dampf.phase}&quot;)

Ausgabe:
 Spezifisches Volumen: 0.151208 m³/kg
 Spezifische Enthalpie: 3248.23 kJ/kg
 Spezifische Entropie: 7.1290 kJ/(kgK)
 Phase: Gas

== TESPy ==
Ein anderes Modul für einen anderen Aufgabenzweck ist TESPy ('''T'''hermal '''E'''ngineering '''S'''ystems in '''Py'''thon). Dieses Modul ist für die Anlagensimulation zuständig. Für nähere Informationen siehe [https://tespy.readthedocs.io/en/main/getting_started/introduction.html]. Als Beipiel sei hier vorerst Code, der von der Google KI generiert wurde, angeführt. Der Code wurde überarbeitet, damit keine Warnungen auftreten. Bitte aber den Code trotzdem mit Vorsicht genießen, auch KI-generierter Code kann Fehler aufweisen. Eine Pumpe wird berechnet:

 from tespy.components import Sink, Source, Pump
 from tespy.connections import Connection
 from tespy.networks import Network
 
 # 1. Netzwerk definieren (Zentrales Steuerungselement)
 # Wir wählen Wasser als Fluid und bar/Celsius als Einheiten
 nw = Network(fluids=[&quot;water&quot;])
 nw.units.set_defaults(pressure=&quot;bar&quot;, pressure_difference=&quot;bar&quot;, 
                       temperature=&quot;°C&quot;, enthalpy=&quot;kJ / kg&quot;)
 
 # 2. Komponenten erstellen
 eingang = Source(&quot;Wasserquelle&quot;)
 ausgang = Sink(&quot;Wasserspeicher&quot;)
 pumpe = Pump(&quot;Speisewasserpumpe&quot;)
 
 # 3. Verbindungen definieren (Komponenten miteinander verknüpfen)
 c1 = Connection(eingang, &quot;out1&quot;, pumpe, &quot;in1&quot;)
 c2 = Connection(pumpe, &quot;out1&quot;, ausgang, &quot;in1&quot;)
 
 # Verbindungen dem Netzwerk hinzufügen
 nw.add_conns(c1, c2)
 
 # 4. Randbedingungen und Parameter festlegen
 # Zustand am Eingang (Druck, Temperatur, Massenstrom, Fluid-Zusammensetzung)
 c1.set_attr(
     v=1,  # Massenstrom: 1 kg/s
     T=20,  # Temperatur: 20 °C
     p=1,  # Druck: 1 bar
     fluid={&quot;water&quot;: 1},  # 100% Wasser
 )
 
 # Zustand am Ausgang / Zielwerte der Pumpe
 c2.set_attr(p=10)  # Ziel-Druck nach der Pumpe: 10 bar
 
 # Pumpeneigenschaften festlegen
 pumpe.set_attr(eta_s=0.8)  # Isentroper Wirkungsgrad von 80%
 
 # 5. Simulation ausführen
 nw.solve(mode=&quot;design&quot;)
 
 # 6. Ergebnisse ausgeben
 nw.print_results()
 
 # Spezifische Werte direkt auslesen
 print(&quot;\n--- Auswertung ---&quot;)
 print(f&quot;Erforderliche Pumpenleistung: {pumpe.P.val / 1000:.2f} kW&quot;)
 print(f&quot;Temperatur nach der Pumpe: {c2.T.val:.2f} °C&quot;)

Ausgabe (gekürzt):
  iter  | residual   | progress   | massflow   | pressure   | enthalpy   | fluid      | component  
 -------+------------+------------+------------+------------+------------+------------+------------
  1     | 7.04e+04   | 12 %       | 9.96e+02   | 0.00e+00   | 8.81e+04   | 0.00e+00   | 0.00e+00   
  2     | 5.91e-12   | 100 %      | 1.11e-13   | 0.00e+00   | 7.39e-12   | 0.00e+00   | 0.00e+00   
  3     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
  4     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
 Total iterations: 4, Calculation time: 0.01 s, Iterations per second: 480.85
 
 ##### RESULTS (Pump) #####
 +-------------------+----------+----------+-----------+----------+----------+----------+
 |                   |        P |       pr |        dp |      eta |    eta_s |     head |
 |-------------------+----------+----------+-----------+----------+----------+----------|
 | Speisewasserpumpe | 1.12e+06 | 1.00e+01 | -9.00e+00 | 8.00e-01 | 8.00e-01 | 9.19e+01 |
 +-------------------+----------+----------+-----------+----------+----------+----------+
 ...
 ...
 --- Auswertung ---
 Erforderliche Pumpenleistung: 1124.77 kW
 Temperatur nach der Pumpe: 20.07 °C

= Stochastik =
Die {{W|Stochastik}} ist ein sehr weites Feld. Hier werden etliche wichtige Themen kurz angerissen. Python stellt mit den Moduln math und statistics Software zu diesem Zwecke bereit. math und statistics sind bereits im Lieferumfang von Python enthalten. Aber auch mit den externen Modulen NumPy, SciPy, stochastic und pandas kann man Stochastik in Python betreiben. Die Theorie der Wahrscheinlichkeitsrechnung und Statistik soll etwas später in Band 5 dieser Buchreihe behandelt werden.

== Lageparameter == 
 import statistics
 
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 
 m1 = statistics.mean(werte)
 m2 = statistics.mode(werte)
 m3 = statistics.median(werte)
 
 print(&quot;Arithmetischer Mittelwert = &quot;, m1)
 print(&quot;Modalwert = &quot;, m2)
 print(&quot;Median = &quot;, m3)

Ausgabe:
 Arithmetischer Mittelwert =  3.5
 Modalwert =  1
 Median =  3.0

== Streuungsparameter ==
Beispiel (Berechnung der Standardabweichung):
 import statistics
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 s = statistics.stdev(werte)
 print(&quot;Standardabweichung = &quot;, s)

Ausgabe:
 Standardabweichung =  2.6770630673681683

Beispiel (Berechnung des Variationskoeffizienten V = Standardabweichung/Mittelwert)
 import numpy as np
 from scipy import stats
 import statistics
 
 k = 50
 
 dat1 = [14, 21, 18, 25, 30, 17, 20]
 dat = np.array(dat1)
 
 # Mit SciPy
 v = stats.variation(dat)
 vddof = stats.variation(dat, ddof=1)
 print(&quot;V SciPy: &quot;, v)
 print(&quot;V DDOF SciPy: &quot;, vddof)
 print(k*&quot;-&quot;)
 
 # mit NumPy
 mittelwert1 = np.mean(dat)
 std_abw1 = np.std(dat)
 std_abw1ddof = np.std(dat, ddof=1) 
 v1= std_abw1 / mittelwert1
 v1ddof = std_abw1ddof / mittelwert1
 print(&quot;Mittelwert NumPy: &quot;, mittelwert1)
 print(&quot;Std.abw. NumPy: &quot;, std_abw1)
 print(&quot;Std.abw. DDOF NumPy: &quot;, std_abw1ddof)
 print(&quot;V NumPy: &quot;, v1)
 print(&quot;V DDOF NumPy: &quot;, v1ddof)
 print(k*&quot;-&quot;)
 
 # nur mit reinem Python
 mittelwert2 = statistics.mean(dat1)
 std_abw2 = statistics.stdev(dat1)
 v2 = std_abw2 / mittelwert2
 print(&quot;Mittelwert Python: &quot;, mittelwert2)
 print(&quot;Std.abw. Python: &quot;, std_abw2)
 print(&quot;V Python:&quot;, v2)
 print(k*&quot;-&quot;)

Ausgabe:
 V SciPy:  0.23890355966467272
 V DDOF SciPy:  0.25804533701889254
 --------------------------------------------------
 Mittelwert NumPy:  20.714285714285715
 Std.abw. NumPy:  4.948716593053935
 Std.abw. DDOF NumPy:  5.3452248382484875
 V NumPy:  0.23890355966467272
 V DDOF NumPy:  0.2580453370188925
 --------------------------------------------------
 Mittelwert Python:  20.714285714285715
 Std.abw. Python:  5.3452248382484875
 V Python: 0.2580453370188925
 --------------------------------------------------

Der Unterschied bei der Standardabweichung zwischen reinem Python und den externen Bibliotheken SciPy und NumPy entsteht dadurch, dass einmal durch (n-1) und das andere Mal nur durch n dividiert wird. Dies kann bei NumPy und SciPy dadurch entschärft werden, indem &lt;code&gt;ddof=1&lt;/code&gt; gesetzt wird. ddof steht für '''D'''elta '''D'''egrees '''o'''f '''F'''reedom. &lt;small&gt;Je größer die Anzahl der Datensätze n wird, umso weniger spielt das eine Rolle.&lt;/small&gt;

== Kombinatorik ==
Beispiel:

 import math
 
 n = 7
 k = 5
 
 print(&quot;n! = &quot;, math.factorial(n))
 print(&quot;Kombinationen (n über k) = &quot;, math.comb(n, k))

Ausgabe:
 n! =  5040
 Kombinationen (n über k) =  21

Siehe zu diesem Thema auch [[Ing Mathematik: Permutationen, Kombinationen, binomischer Lehrsatz]]. Die Anzahlen lassen sich einfach aus den dortigen Formeln ermitteln, z.B. bei Permutationen mit &lt;math&gt;n!&lt;/math&gt; oder Variationen mit Wiederholungen als &lt;math&gt;n^k&lt;/math&gt;. Will man die Kombinationen oder Variationen aber auch als Liste ausgeben, so kann das Modul &lt;code&gt;itertools&lt;/code&gt; nützlich sein.  

Beispiel (Variationen ohne Wiederholung):

 from itertools import permutations
 
 menge = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]  # n = 4
 k = 3
 
 variationen = list(permutations(menge, k))
 
 for v in variationen:
     print(&quot;&quot;.join(v))
 
 print(50*&quot;-&quot;)
 print(len(variationen))

Ausgabe (gekürzt):
 ABC
 ABD
 ACB
 ...
 DCA
 DCB
 --------------------------------------------------
 24

Siehe zum Modul &lt;code&gt;itertools&lt;/code&gt; auch die Website [https://docs.python.org/3/library/itertools.html].

* Variationen mit Wiederholung: &lt;code&gt;itertools.product()&lt;/code&gt;
* Kombinationen ohne Wiederholung: &lt;code&gt;itertools.combinations()&lt;/code&gt;
* Kombinationen mit Wiederholung: &lt;code&gt;itertools.combinations_with_replacement()&lt;/code&gt;

== Zufallszahlen ==
Beispiel:
 import random
 
 # Ganzzahlige Zufallszahl von 1 bis 10
 zufallszahl1 = random.randint(1, 10)
 
 # Gleitpunktzahlen
 # zwischen 0.0 und 1.0
 zufallszahl2 = random.random()
 # Zahl zwischen 1.5 und 9.5
 zufallszahl3 = random.uniform(1.5, 9.5)
 
 # aus Liste auswählen
 farbe = [&quot;Rot&quot;, &quot;Grün&quot;, &quot;Blau&quot;]
 zufallswert = random.choice(farbe)
 
 print(zufallszahl1)
 print(zufallszahl2)
 print(zufallszahl3)
 print(zufallswert)

Ausgabe, z.B.:
 5
 0.14147945849015753
 6.894003397570905
 Rot

Benötigt man mehrere Zufallszahlen, so ist das Modul &lt;code&gt;numpy&lt;/code&gt; zu bevorzugen, z.B.:
* Normalverteilung: &lt;code&gt;np.random.normal(...)&lt;/code&gt;
* Gleichverteilung: &lt;code&gt;np.random.uniform(...)&lt;/code&gt;

== Histogramm ==
Zum Thema Histogramm siehe {{W|Histogramm}}.

Beispiel (mit Matplotlib):

 import matplotlib.pyplot as plt
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 
 plt.hist(daten, bins=25, edgecolor='darkgray')
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm.svg|300px]]

Beispiel (mit Seaborn):

 import matplotlib.pyplot as plt
 import seaborn as sns
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 sns.set_theme(style=&quot;darkgrid&quot;)
 sns.histplot(data=daten)
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm2.svg|300px]]

Das Kürzel &lt;code&gt;sns&lt;/code&gt; ist Konvention und steht für die fiktive Figur '''S'''amuel '''N'''orman '''S'''eaborn aus der US-Fernsehserie {{W|The West Wing – Im Zentrum der Macht | The West Wing}}.

== Box-Plot ==
[[File:Elements of a boxplot.svg|400px]]

Siehe auch {{W|Box-Plot}}.

Beispiel (mit Seaborn erstellt):
 import seaborn as sns
 import matplotlib.pyplot as plt
 
 df = sns.load_dataset(&quot;tips&quot;)
 sns.boxplot(data=df, x=&quot;day&quot;, y=&quot;tip&quot;, hue=&quot;day&quot;, legend=False)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot.svg|400px]]

Beispiel (mit Matplotlib erstellt):

 import matplotlib.pyplot as plt
 
 daten = [12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25]
 
 plt.boxplot(daten, patch_artist=True)
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot2.svg|300px]]

Um mehrere Box-Plots unterschiedlicher Farbe mit Matplotlib in einem Diagramm zu zeichnen, können Sie folgendermaßen vorgehen:

 import matplotlib.pyplot as plt
 
 daten = [[12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25],
          [10, 19, 20, 21, 20, 30, 19, 40, 11, 17, 19, 21]]
 
 farben = [&quot;green&quot;, &quot;blue&quot;]
 
 boxplot = plt.boxplot(daten, patch_artist=True)
 
 for patch, farbe in zip(boxplot['boxes'], farben):
     patch.set_facecolor(farbe)
 
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

== Regressionsrechnung ==
Beispiel:
 import numpy as np
 import matplotlib.pyplot as plt
 
 # Messpunkte
 x = np.array([1, 3, 5, 6, 8, 10, 20])
 y = np.array([3, 4, 5, 5, 7, 9, 11])
 
 # Regressionskurve (Grad 1 = lineare Regression, 2 = Polynom-Regression 2. Gr.)
 # y = kx + d
 k, d = np.polyfit(x, y, deg=1)
 # y = ax**2 + bx + c
 a, b, c = np.polyfit(x, y, deg=2)
 
 x_l = np.linspace(1, 20, 100)
 y_p = a * x_l**2 + b * x_l + c
 
 # Zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.plot(x, k*x + d, color='blue', label='Regressionsgerade')
 plt.plot(x_l, y_p, color='red', label='Regressionspolynom 2. Gr.')
 plt.xlabel('x')
 plt.ylabel('y')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_regression.svg|400px]]

== Korrelationsrechnung ==
Beispiel:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 # Messdaten
 x = [1, 3, 4, 5, 6]
 y = [2, 4, 6, 8, 5]
 
 daten = {'X': x, 'Y': y}
 df = pd.DataFrame(daten)
 
 # Korrelation
 korr = df['X'].corr(df['Y'])
 print(f&quot;Korrelationskoeff.: {korr}&quot;) 
 
 # Messpunkte zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:
 Korrelationskoeff.: 0.7556096518348252

[[Datei:IngMath_korrelation.svg|300px]]

== Mengen und Venn-Diagramme ==
Beispiel: 
 import matplotlib.pyplot as plt
 from matplotlib_venn import venn2
 
 menge_a = {1, 2, 3, 4, 5, 6}
 menge_b = {4, 5, 6, 7, 8}
 
 vereinigung = menge_a | menge_b
 schnitt = menge_a &amp; menge_b
 print(&quot;Vereinigungsmenge = &quot;, vereinigung)
 print(&quot;Schnittmenge = &quot;, schnitt)
 
 venn2([menge_a, menge_b], set_labels=('Menge A', 'Menge B'))
 plt.show()

Ausgabe:
 Vereinigungsmenge =  {1, 2, 3, 4, 5, 6, 7, 8}
 Schnittmenge =  {4, 5, 6}

[[Datei:IngMath_venn.svg|300px]]

Siehe auch {{W|Mengendiagramm#Venn-Diagramme}}.

== Verteilungs- und Dichtefunktion ==
* CDF ... '''C'''umulative '''D'''istribution '''F'''unction, Verteilungsfunktion
* PDF ... '''P'''robability '''D'''ensity '''F'''unction, Dichtefunktion

Beispiel (Normalverteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 from scipy.stats import norm
 
 my, sigma = 0, 1
 x = np.linspace(-4, 4, 50)
 
 pdf = norm.pdf(x, my, sigma)
 cdf = norm.cdf(x, my, sigma)
 
 plt.plot(x, pdf, lw=2, label=&quot;Dichtefunktion&quot;)
 plt.plot(x, cdf, lw=2, label=&quot;Verteilungsfunktion&quot;)
 plt.legend()
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:IngMath_cdf_pdf.svg|300px]]

Beispiel (&lt;math&gt;\chi^2&lt;/math&gt;-Verteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 import scipy.stats as stats
 
 x = np.linspace(0, 20, 500)
 
 # df ... degree of freedom, Freiheitsgrad
 pdf = (stats.chi2.pdf(x, df=2), stats.chi2.pdf(x, df=5), stats.chi2.pdf(x, df=10))
 
 for i in range(0,3):
     if(i==0):
         lab = &quot;Freiheitsgrad 2&quot;
     elif(i==1):
         lab = &quot;Freiheitsgrad 5&quot;
     else:
         lab = &quot;Freiheitsgrad 10&quot;
 
     plt.plot(x, pdf[i], label=lab, lw=2)
 
 plt.grid()
 plt.legend()
 plt.show()

Ausgabe:

[[Datei:IngMath_chi2.svg | 300px]]

== Schätzen und Testen ==
=== Intervallschätzung ===
Als Beispiel seien Daten gegeben, die von ''Dürr, Mayer: Wahrscheinlichkeitsrechnung und Schließende Statistik; 7. Aufl., Hanser, 2014, Seite 137'' stammen. Und zwar soll das 95%-Vertrauensintervall für den Mittelwert des Kaloriengehalts (kcal/100g) von Hähnchen ermittelt werden. Wir wollen das mit Python inkl. NumPy und SciPy durchführen. Die Stichprobe ist groß (50 Hähnchen):

Python-Code:
 import numpy as np
 import scipy.stats as stats
 
 # Stichprobe
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203]
 
 # Parameter definieren
 konfidenzniveau = 0.95
 mean = np.mean(daten)
 std = np.std(daten, ddof=1)
 stdfehler = stats.sem(daten)
 
 intervall = stats.norm.interval(confidence=konfidenzniveau, loc=mean, scale=stdfehler)
 
 print(f&quot;Mittelwert: {mean}&quot;)
 print(f&quot;Standardabweichung: {std}&quot;)
 print(f&quot;Konfidenzintervall: {intervall}&quot;)

Ausgabe:
 Mittelwert: 215.48
 Standardabweichung: 33.14238915925757
 Konfidenzintervall: (np.float64(206.29356722321992), np.float64(224.66643277678006))

Diese Werte stimmen gerundet mit denen im genannten Buch überein. Zum Code selbst:
* sem steht für '''s'''tandard '''e'''rror of the '''m'''ean.
* &lt;code&gt;scipy.stats.norm&lt;/code&gt; ... Modul für die Normalverteilung.

=== Punktschätzung ===
Gleiche Daten wie oben bei der Intervallschätzung.

Python-Code:
 import numpy as np
 from scipy import stats
 
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203
         ]
 
 mu_hat, sigma_hat = stats.norm.fit(daten) 
 
 print(f&quot;Schätzer für den Erwartungswert (μ): {mu_hat:.4f}&quot;)
 print(f&quot;Schätzer für die Standardabweichung (σ): {sigma_hat:.4f}&quot;)

Ausgabe:
 Schätzer für den Erwartungswert (μ): 215.4800
 Schätzer für die Standardabweichung (σ): 32.8093

=== Hypothesentests ===
Beispiel:

 import numpy as np
 import scipy.stats as stats
 
 x_quer = 12.075      # Stichproben-Mittelwert
 var    = 0.069       # Stichproben-Varianz
 n      = 90          # Stichprobengröße
 my_0   = 12.0        # Nullhypothese
 alpha  = 0.05        # Signifikanzniveau
 
 z_stat = (x_quer - my_0) / np.sqrt(var / n)
 p_val = 2 * (1 - stats.norm.cdf(np.abs(z_stat)))
 
 print(f&quot;Z-Statistik: {z_stat:.4f}&quot;)
 
 if p_val &lt; alpha:
     print(f&quot;p-Wert: {p_val:.6f} &lt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird verworfen.&quot;)
 else:
     print(f&quot;p-Wert: {p_val:.6f} &gt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird nicht verworfen.&quot;)

Ausgabe:

 Z-Statistik: 2.7087
 p-Wert: 0.006755 &lt; alpha: 0.05
 Die Nullhypothese wird verworfen.

== Statistische Qualitätskontrolle ==
Beispiel (Mittelwertkarte):

 import numpy as np
 import matplotlib.pyplot as plt
 
 # Gegeben
 sollwert = 50.0
 varianz = 4.0
 stichproben_umfang = 1
 daten = [49.5, 50.2, 53.0, 48.1, 52.6, 53.4, 49.8]
 
 # Berechnung
 standardabweichung = np.sqrt(varianz)
 streuung = standardabweichung / np.sqrt(stichproben_umfang)
 
 cl = sollwert
 ucl = cl + 3 * streuung
 lcl = cl - 3 * streuung
 
 # Darstellung
 plt.plot(daten, marker='o', linestyle='-', color='b', label='Messdaten')
 plt.axhline(cl, color='green', linestyle='-', label=f'CL: {cl}')
 plt.axhline(ucl, color='red', linestyle='--', label=f'UCL: {ucl:.2f}')
 plt.axhline(lcl, color='red', linestyle='--', label=f'LCL: {lcl:.2f}')
 
 plt.title('Mittelwertkarte')
 plt.xlabel('Stichprobe')
 plt.ylabel('Wert')
 plt.legend(loc='lower left')
 plt.grid(True)
 plt.show()

Ausgabe:

[[Datei:IngMath_mittelwertkarte.svg|300px]]

Siehe auch {{W|Shewhart-Regelkarte}} und {{W|Qualitätsregelkarte}}.

* UCL ... '''U'''pper '''C'''ontrol '''Limit''', Obere Eingriffsgrenze
* LCL ... '''L'''ower '''C'''ontrol '''Limit''', Untere Eingriffsgrenze
* CL ... '''C'''enter '''L'''ine, Mittellinie

= Ein- und Ausgabe =
== print ==
Die Anweisung print haben wir schon oft verwendet. Hier soll anhand von Beispielen kurz beschrieben werden, was der Befehl print leisten kann.

 print(&quot;Hallo&quot;, &quot;Welt&quot;, 1, sep=&quot;-&quot;)
 print(&quot;Hallo&quot;, end=&quot; &quot;)
 print(&quot;Welt&quot;)

Ausgabe:
 Hallo-Welt-1
 Hallo Welt

== input ==
 a = int(input(&quot;Zahl 1: &quot;))
 b = int(input(&quot;Zahl 2: &quot;))
 
 print(&quot;a + b = &quot;, a+b)

Ausgabe (nach Eingabe der beiden Ganzzahlen):
 Zahl 1: 4
 Zahl 2: 5
 a + b =  9

== Aus Dateien lesen ==
Es seinen die datei.txt
 Hallo Welt.
 Wie geht es dir?
 ...

und test1.py
 dat = open(&quot;datei.txt&quot;, mode = &quot;r&quot;)
 print(dat.read())
 dat.close()

Ausgabe
 Hallo Welt.
 Wie geht es dir?
 ...

Mit dem open()-Befehl wird die Datei datei.txt im Lesemodus geöffnet (r ... read). Mit dem read()-Befehl wird die Datei eingelesen und mittels print ausgegeben.

== In Dateien schreiben ==
 dat = open(&quot;datei.txt&quot;, mode = &quot;a&quot;, encoding = &quot;utf-8&quot;)
 dat.write(&quot;Hänge Zeile an\n&quot;)
 dat.close()

Die Datei datei.txt sieht nach Abarbeitung des obigen Skripts nun so aus
 Hallo Welt.
 Wie geht es dir?
 ...
 Hänge Zeile an

Es wird die Datei im Schreibmodus geöffnet (a ... append (anhängend), w ... write (überschreibend)).
write() fügt hier also eine Zeile Text am Dateiende ein. close() schließt die Datei wieder.

Das close() kann man sich mit der with-Anweisung auch sparen.

 with open(&quot;datei.txt&quot;, mode=&quot;a&quot;, encoding=&quot;utf-8&quot;) as dat:
     dat.write(&quot;Hänge Zeile an\n&quot;)

= Benutzeroberflächen erstellen =
== tkinter ==
{{Wikipedia | Tkinter}}

Python bietet standardmäßig das Modul tkinter zur Programmierung von Benutzeroberflächen. Es müssen also bei der Verwendung von tkinter keine externen Module installiert werden. Hier wird eine (sehr) kurze Einführung in das Erstellen von grafischen Oberflächen mittels tkinter gegeben.

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 win.minsize(300, 50)
 but = tk.Button(win, text = &quot;Push the button&quot;)
 but.pack()
 win.mainloop()

Ausgabe:

[[Datei:PythonIng_gui1.jpg]]

Ein etwas komplizierteres Beispiel sei nachfolgend gezeigt. Es sollen zwei Strings miteinander verknüpft und ausgegeben werden. 

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 
 def on_button_clicked():
     str = ent1.get() + ent2.get()
     lab2[&quot;text&quot;] = str
  
 ent1 = tk.Entry(win)
 ent2 = tk.Entry(win)
 lab1 = tk.Label(win, text=&quot;verknuepfen mit&quot;)
 lab2 = tk.Label(win, text=&quot;&quot;) 
 but = tk.Button(win, text = &quot;=&quot;, command=on_button_clicked)
 
 ent1.pack(side=&quot;left&quot;)
 lab1.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 but.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 lab2.pack(side=&quot;left&quot;)
 
 win.mainloop()

Ausgabe  (vor der Eingabe der Teilstrings): 

[[Datei:PythonIng_gui2.jpg]]

Ausgabe (nach der Eingabe der Teilstrings und dem Drücken des =-Buttons): 

[[Datei:PythonIng_gui3.jpg]]

== curses ==
{{Wikipedia | curses}}

Mit dem curses-Modul lassen sich u.a. TUIs ('''T'''ext '''U'''ser '''I'''nterfaces) erstellen. Ein sehr einfaches Beispiel zur allgemeinen Funktionsweise wird nachstehend geliefert.
 
 import curses
 
 stdscr = curses.initscr()
 curses.start_color()
 curses.init_pair(1, curses.COLOR_RED, curses.COLOR_WHITE)
 stdscr.clear()
 
 stdscr.addstr(&quot;Hallo Welt&quot;, curses.color_pair(1))
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()
 
Als Ausgabe sollte &lt;span style=&quot;color:#FF0000;&quot;&gt;Hallo Welt&lt;/span&gt; (rote Schrift auf weißem Hintergrund) auf dem Terminal/der Konsole erscheinen. Getestet wurde dies mit openSUSE Tumbleweed, Python-Version 3.13.12. Das entsprechende Python-curses-Package muss installiert sein.

Allgemeine Informationen zur Terminal-/Konsolengröße und Cursorposition liefert folgendes Programm:
 
 import curses
 
 stdscr = curses.initscr()
 
 stdscr.addstr(3, 5, &quot;LINES: %d&quot; % curses.LINES)
 stdscr.addstr(4, 5, &quot;COLS:  %d&quot; % curses.COLS)
 
 (y,x) = stdscr.getyx()
 stdscr.addstr(5, 5, &quot;Momentane Cursorposition:  [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getbegyx()
 stdscr.addstr(6, 5, &quot;Koordinatenursprung:       [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getmaxyx()
 stdscr.addstr(7, 5, &quot;Fenstergröße:              [%d, %d]&quot; % (y, x))
 
 stdscr.addstr(11, 2, &quot;Taste drücken -&gt; Ende&quot;)
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()

Es sollte sich in etwa folgende Ausgabe ergeben:

     LINES: 44
     COLS:  110
     Momentane Cursorposition:  [4, 15]
     Koordinatenursprung:       [0, 0]
     Fenstergröße:              [44, 110]
 
 
 Taste drücken -&gt; Ende

Zur Funktionsweise von curses siehe auch das Wikibook [[ncurses]]. Zum Verständnis sind dort allerdings elementare Kenntnisse in der Programmiersprache C erforderlich.

== Qt ==
{{Wikipedia | Qt (Bibliothek)}}

Auch für das Qt-Framework gibt es eine Anbindung an Python. Nachfolgend ein einfaches Beispiel.

 import sys
 from PySide6.QtWidgets import QApplication, QLabel
 
 app = QApplication(sys.argv)
 label = QLabel(&quot;Hallo Welt!&quot;)
 label.show()
 sys.exit(app.exec())

Ausgabe:

[[Datei:PythonIng_gui10.png]]

== Gtk ==
{{Wikipedia | GTK (Programmbibliothek)}}

Eine idente Ausgabe, wie oben für Qt gezeigt, erzeugt z.B. folgendes Gtk-Programm:

 import gi
 gi.require_version(&quot;Gtk&quot;, &quot;4.0&quot;)
 from gi.repository import Gtk
 
 def on_activate(app):
     win = Gtk.ApplicationWindow(application=app)
     lab = Gtk.Label(label=&quot;Hallo Welt!&quot;)
     win.set_child(lab)
     win.present()
 
 app = Gtk.Application()
 app.connect('activate', on_activate)
 app.run(None)

Auch für die Benutzung von Qt und Gtk müssen die jeweiligen Packages installiert sein. Getestet wurden die entsprechenden Python-Programme nur unter openSUSE Tumbleweed. Wie das GTK-Paket unter MS Windows 11 installiert wird, siehe z.B. [https://www.gtk.org/docs/installations/windows Setting up GTK for Windows].

Damit sei aber das Thema &quot;Benutzeroberflächen erstellen&quot; hier abgeschlossen, da dies schon ein sehr spezielles Aufgabengebiet ist, das eher Informatiker und nicht so sehr Ingenieure anspricht. Bei Bedarf siehe aber ggf. die entsprechenden Links unten in diesem Tutorial. Dort sind weiterführende Informationen zu finden.

= Pandas kurz erklärt =
Hier wird kurz auf das externe Modul Pandas eingegangen. Pandas steht für '''Pan'''el '''Da'''ta und ist ein Modul für die Datenanalyse und -manipulation.

== Series ==
Vorstellbar ist eine &quot;Series&quot; wie eine einzelne Spalte in einem Tabellenkalkulationsprogramm.

Beispiel (Index implizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5]) # Temperaturwerte
 print(temp)

Ausgabe:
 0     8.5
 1    11.0
 2    12.5
 3    10.0
 4    13.0
 5    11.0
 6    14.5
 dtype: float64

Das Kürzel &lt;code&gt;pd&lt;/code&gt; ist Konvention. Es seien Temperaturwerte gegeben. Die erste Spalte bei der Ausgabe ist der Index. Die zweite Spalte enthält die Werte.

Beispiel (separater Zugriff auf den Index und auf die Werte):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5])
 print(temp.index)
 print(temp.values)

Ausgabe:
 RangeIndex(start=0, stop=7, step=1)
 [ 8.5 11.  12.5 10.  13.  11.  14.5]

Beispiel (Index explizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 print(&quot;*** Die gesamte Series ***&quot;)
 print(temp)
 
 print(&quot;*** Temperatur am Donnerstag ***&quot;)
 print(temp[&quot;Do&quot;])
 
 print(&quot;*** Tage wärmer als 12 Grad ***&quot;)
 temp_gr_12 = temp[temp &gt; 12]
 print(temp_gr_12)

Ausgabe:
 *** Die gesamte Series ***
 Mo     8.5
 Di    11.0
 Mi    12.5
 Do    10.0
 Fr    13.0
 Sa    11.0
 So    14.5
 dtype: float64
 *** Temperatur am Donnerstag ***
 10.0
 *** Tage wärmer als 12 Grad ***
 Mi    12.5
 Fr    13.0
 So    14.5
 dtype: float64

== DataFrame ==
Ein DataFrame entspricht einer Tabelle.

Beispiel (Erzeugen eines DataFrames):
 import pandas as pd
 
 tag   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 v1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=tag)
 v2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=tag)
 v3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=tag)
 
 tab = pd.concat([v1, v2, v3], axis=1)
 tab.columns = stadt
 
 print(tab)
 print(type(tab))

Ausgabe:
     Linz  Salzburg Innsbruck
 Mo     1         8     Hallo
 Di     2         9        16
 Mi     3        10        17
 Do     4        11        18
 Fr     5        12        19
 Sa     6        13        20
 So     7        14        21
 &lt;class 'pandas.core.frame.DataFrame'&gt;

Wir haben hier drei Datenspalten (v1, v2, v3) mit den Spaltennamen &quot;Linz&quot;, &quot;Salzburg&quot; und &quot;Innsbruck&quot;, sowie sieben Zeilen &quot;Mo&quot; bis &quot;So&quot;.

Beispiel (Zugriff auf eine Spalte):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab[&quot;Salzburg&quot;])

Ausgabe:
 Mo     8
 Di     9
 Mi    10
 Do    11
 Fr    12
 Sa    13
 So    14
 Name: Salzburg, dtype: int64

Beispiel (Zugriff auf eine Zeile):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab.loc[&quot;Di&quot;])

Ausgabe:
 Linz          2
 Salzburg      9
 Innsbruck    16
 Name: Di, dtype: object

== Grafiken erstellen ==
Hier sei nur ein Torten- oder Kreisdiagramm gezeichnet:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 expl = [0, 0.2, 0, 0, 0, 0, 0]
 temp.plot.pie(figsize=(5,5), explode=expl)
 plt.show()

Ausgabe:

[[Datei:IngPython_pandas1.svg|350px]]

Die &lt;code&gt;figsize&lt;/code&gt; hat nichts mit der Spaltenanzahl zu tun, sondern setzt die Fenster- oder Diagrammgröße in Inches (Breite * Höhe).
 
Mit Pandas kann man auch noch andere Diagrammarten erstellen, z.B. Linien- oder Balkendiagramme. Dies wird hier aber nicht vorgeführt.

== Arbeiten mit CSV- und LibreOffice-Dateien ==
Gegeben sei eine CSV-Datei test1.csv:
 Mai;Juni;Juli
 12;17;45
 15;65;65
 16;32;23
 4;14;7
 23;17;Keine Daten verfügbar
 67;Keine Daten verfügbar;45
 15;24;12

Lesen von dieser CSV-Datei:
 import pandas as pd
 
 tab = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 print(tab)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Schreiben in eine CSV-Datei test2.csv:
 import pandas as pd
 
 val = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 val.to_csv(&quot;test2.csv&quot;, index=False)

Ausgabedatei:
 Mai,Juni,Juli
 12,17,45
 15,65,65
 16,32,23
 4,14,7
 23,17,Keine Daten verfügbar
 67,Keine Daten verfügbar,45
 15,24,12

Die Ausgabedatei ist beinahe gleich wie die Eingabedatei. Es werden aber Kommas statt Strichpunkten verwendet. Daher kommt auch der Name CSV ('''C'''omma '''S'''eparated '''V'''alue). Will man wieder Strichpunkte, so kann man dies über den Parameter &lt;code&gt;sep=&quot;;&quot;&lt;/code&gt; in der &lt;code&gt;to_csv&lt;/code&gt;-Funktion machen.

Um direkt von einer ODS-Datei (LibreOffice Calc, '''O'''pen '''D'''ocument '''S'''preadsheet) zu lesen muss das Modul odfpy extra installiert sein (per YaST, pip etc.). Gelesen wird dann folgendermaßen:
 import pandas as pd
 
 df = pd.read_excel('test1.ods', engine='odf')
 print(df)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Die Datei &quot;test1.ods&quot; sei die Datei, aus der das obige &quot;test1.csv&quot; generiert wurde. Schreiben kann man ebenfalls in eine ODS-Datei:

 import pandas as pd
 
 daten = {
     &quot;Name&quot;: [&quot;Hugo&quot;, &quot;Richie&quot;, &quot;Wilhelmine&quot;],
     &quot;Alter&quot;: [38, 30, 29],
     &quot;Ort&quot;: [&quot;Linz&quot;, &quot;Innsbruck&quot;, &quot;Salzburg&quot;]
 }
 
 tab = pd.DataFrame(daten)
 
 with pd.ExcelWriter(&quot;test2.ods&quot;, engine=&quot;odf&quot;) as writer:
     tab.to_excel(writer, sheet_name=&quot;Daten&quot;, index=False)

Es ergibt sich eine &quot;test2.ods&quot;-Datei (Screenshot):

[[Datei:IngPython_pandas2.png|250px]]

== Sonstiges ==
Hier seien stichpunktartig einige weitere Features von Pandas angeführt:
* {{W|Pivot-Tabelle|Pivot-Tabellen}} (pivot ... Dreh-, Angelpunkt): Zweck - große Datenmengen schnell zusammenfassen, filtern und analysieren.
* NaN ('''n'''ot '''a''' '''n'''umber): In einem Datensatz fehlt ein Wert oder ist nicht definiert.
* groupby-Funktion: Daten strukturieren, aggregieren oder Zwischensummen bilden. 
* {{W|Binning#Datenverarbeitung_und_-analyse|Binning}}: Klassenbildung.
* Mehrstufige Indizierung (Hierarchical Indexing oder MultiIndex)
* Zeitreihen (Time Series)
* MS Excel-Dateien schreiben mit dem Parameter &lt;code&gt;engine=&quot;openpyxl&quot;&lt;/code&gt;

Für tiefergehende und weiterführende Informationen wird auf das Buch von ''Klein: Numerisches Python; Hanser, 2023'' und [https://pandas.pydata.org/ pandas] verwiesen.

= Style Guide, flake8, pylint, Black etc. =
== Style Guide ==
Wie man schönen und richtigen Python-Code schreibt, erfahren Sie in
* [https://peps.python.org/pep-0008/ PEP 8 – Style Guide for Python Code]

== Formatter und Linter ==
Ein Modul, das prüft, ob die Richtlinien im Style Guide eingehalten wurden, ist ''flake8'':
* [https://flake8.pycqa.org/en/latest/ Flake8: Your Tool For Style Guide Enforcement]

Code formatieren kann man auch mit [https://pypi.org/project/black/ Black]. Z.B. übersetzt &lt;code&gt;black test1.py&lt;/code&gt; die Datei &lt;code&gt;test1.py&lt;/code&gt;

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)),
     (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

in 

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)), (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Die Programmausgabe ist 

 reformatted test1.py
 
 All done! ✨ 🍰 ✨
 1 file reformatted.

Der Unterschied zwischen Black und Flake8:
* Black ist ein Code-Formatter. Er formatiert Ihren Code um, sodass er im Einklang mit PEP 8 steht.
* Flake8 ist ein {{W|Lint (Programmierwerkzeug) | Code-Linter}}. Flake8 verändert Ihren Code nicht, sondern durchsucht ihn nach potenziellen Fehlern etc.

Am obigen Beispiel sieht man auch, dass flake8 und Black nicht immer einer Meinung sind. Flake8 (&lt;code&gt;flake8 test1.py&lt;/code&gt;) würde standardmäßig den mit Black formatierten Code bemängeln:

 test1.py:8:80: E501 line too long (80 &gt; 79 characters)

Diese Diskrepanz kann beseitigt werden. Da 79 Zeichen auf modernen Bildschirmen meist als zu kurz empfunden werden, ist ein Limit von 88 Zeichen (Black-Standard) oder mehr empfehlenswert. Um dies zu implementieren, erstellen Sie in Ihrem Projektverzeichnis eine &lt;code&gt;.flake8&lt;/code&gt;-Datei mit dem Inhalt

 [flake8]
 max-line-length = 88

Und schon ignoriert Flake8 dieses Problem.

Ein anderer Linter ist pylint. Der würde beim Abarbeiten des obigen Beispiels, z.B. mit &lt;code&gt;pylint test1.py&lt;/code&gt; noch eine Kleinigkeit bemängeln:

 ************* Module test1
 /home/hr/tmp/test1.py:1:0: C0114: Missing module docstring (missing-module-docstring)
 
 ------------------------------------------------------------------
 Your code has been rated at 8.57/10 (previous run: 8.57/10, +0.00)

Auch pylint muss vor der ersten Verwendung installiert werden (z.B. mittels pip, virtuelle Umgebung, YaST). Die Dokumentation zu pylint findet sich auf [https://pylint.readthedocs.io/en/latest/].

&lt;u&gt;Aufgabe:&lt;/u&gt; Fügen Sie einen &quot;module docstring&quot; in die &lt;code&gt;test1.py&lt;/code&gt;-Datei ein und testen Sie erneut mit flake8, Black und pylint. &lt;small&gt;Sehen Sie zum Thema docstrings auch [https://peps.python.org/pep-0257/#what-is-a-docstring PEP 257 – Docstring Conventions].&lt;/small&gt;

Es gibt noch weitere Formatierungswerkzeuge für Python-Code. Z.B. [https://docs.astral.sh/ruff/ Ruff], ein moderner Code-Formatter und -Linter. Mittels &lt;code&gt;ruff check test1.py&lt;/code&gt; würde obiger Code geprüft (Linter). &lt;code&gt;ruff format test1.py&lt;/code&gt; formatiert den Code (Formatter).

== Type Checker ==
&quot;Type Checker&quot; sind z.B.
* mypy
* pyright
* ty

Diese prüfen die Datentypen, z.B. in folgendem Code

 def greetings(name: str) -&gt; str:
     return &quot;Hello, %s&quot; % name
 
 
 print(greetings(42))

Python selbst, flake8, ruff oder black würden diesen Code ohne zu murren akzeptieren. &quot;Type Checker&quot; würden aber sehr wohl Alarm schlagen, z.B. liefert &lt;code&gt;mypy&lt;/code&gt; folgende Ausgabe

 test1.py:5: error: Argument 1 to &quot;greetings&quot; has incompatible type &quot;int&quot;; expected &quot;str&quot;  [arg-type]
 Found 1 error in 1 file (checked 1 source file)

Das funktioniert übrigens nicht nur bei Funktionsannotationen, sondern auch mit Variablen etc.

 from typing import Final
 
 # &quot;Konstante&quot;, ab Python 3.8
 NUMBER: Final = 123
 print(NUMBER)
 NUMBER = 125
 print(NUMBER)
 
 # Variable
 a: int = 345
 print(a)
 a = &quot;Irgendwas&quot;
 print(a)
 
 # Variable (Pipe-Symbol), ab Python 3.10
 b : int|str = 567
 print(b)
 b = &quot;sonstiges&quot;
 print(b)

Ausgabe mit python:
 123
 125
 345
 Irgendwas
 567
 sonstiges

Ausgabe mit mypy:
 test3.py:6: error: Cannot assign to final name &quot;NUMBER&quot;  [misc]
 test3.py:12: error: Incompatible types in assignment (expression has type &quot;str&quot;, variable has type &quot;int&quot;)  [assignment]
 Found 2 errors in 1 file (checked 1 source file)

Python kennt übrigens keine Konstanten. Man kann diese mittels Großbuchstaben andeuten. Das ist aber nur Konvention, hat aber keine sonstigen Auswirkungen. Oder man verwendet wie oben gezeigt &lt;code&gt;Final&lt;/code&gt;. Dann werfen Typchecker Errors aus.

==pydoc==
pydoc ist ein Werkzeug, um Python-Module, -Funktionen und -Klassen zu dokumentieren.

Beispiel &lt;code&gt;test1.py&lt;/code&gt;:
 &quot;&quot;&quot;Rechen-Modul.
 
 Funktionen die von pydoc gelesen werden.
 &quot;&quot;&quot;
 
 def multiply(a, b):
     &quot;&quot;&quot;Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
     
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a * b
     
 def add(a, b):
     &quot;&quot;&quot;Addiert zwei Zahlen und gibt das Ergebnis zurück.
    
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a + b
    
 
 if __name__ == '__main__':
     print(multiply(3, 5))
     print(add(4, 6))

Ausgabe mit &lt;code&gt;python3.13 -m pydoc test1&lt;/code&gt; auf der Konsole:

 Help on module test1:
 
 NAME
     test1 - Rechen-Modul. 
 
 DESCRIPTION
     Funktionen die von pydoc gelesen werden.
 
 FUNCTIONS
     add(a, b)
         Addiert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
     multiply(a, b)
         Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
 FILE
     /home/xyz/tmp/test1.py

Siehe zu diesem Thema z.B. auch [https://docs.python.org/3/library/pydoc.html]. Mittels &lt;code&gt;python3.13 -m pydoc -w test1&lt;/code&gt; kann man auch eine HTML-Dokumentation erstellen.

Wofür &lt;code&gt;if __name__ == '__main__':&lt;/code&gt; steht, siehe z.B. etwas später im Abschnitt [[Ing_Mathematik:_Python#Doctests]].

== Sonstige Tools ==
Andere Tools für die {{W|Statische Code-Analyse|statische Codeanalyse}}, die aber für Ingenieure weniger interessant sein dürften, sind z.B.
* Radon: Liefert verschiedene {{W|Softwaremetrik|Codemetriken}} (Komplexität, Wartbarkeitsindex ...)
* Bandit: Findet Sicherheitslücken

Tools für die {{W|Dynamisches Software-Testverfahren|dynamische Codeanalyse}}, z.B.:
* DynaPyt (Framework zur dynamischen Programmanalyse)
* cProfile (Profiler)
* Memory Profiler (Speicheranalyse)
* Memray (Speicheranalyse)
* tracemalloc (Speicheranalyse)

Paket- und Projektmanagement (pip-Ersatz etc.):
* uv
* Poetry
* Conda
* pipx

Packaging-Tools (Freezer) und {{W|Compiler#Sonderformen|Transpiler}} :
* pyinstaller
** erstellt eigenständige, ausführbare Binärdatei
** kein Cross-Compiler
** kein Schutz vor Reverse-Engineering
** langsam
** packt alles in eine Datei
** sehr große Datei
** Befehl, z.B.: &lt;code&gt;pyinstaller --onefile test1.py&lt;/code&gt;
** GUI: &lt;code&gt;auto-py-to-exe&lt;/code&gt;
* cx_Freeze
* nuitka
** Übersetzt Python-Code in C/C++-Code und weiter in eine ausführbare Datei
** kein Cross-Compiler
** Schutz vor Reverse-Engineering
** Befehl, z.B.: &lt;code&gt;nuitka --standalone --onefile test1.py&lt;/code&gt;
* cython

= Einige Integrierte Entwicklungsumgebungen (IDEs)=
Werden Programmtexte größer und umfangreicher, so ist das Arbeiten mit der interaktiven Programmierumgebung bzw. das direkte Ausführen von Python-Skripten mühsam. Man wünscht sich z.B. Hilfen zum Debuggen oder die automatische Code-Vervollständigung. Zu diesem Zweck wurden IDEs (Integrated Development Environments) geschaffen. Von diesen seinen nachfolgend auszugsweise einige kurz beschrieben. Testen Sie einfach aus, welche davon für Sie bzw. für Ihr Python-Projekt geeignet sind.

== IDLE ==
IDLE ist die mit dem Python-Programmpaket mitgelieferte IDE. Der Name leitet sich einerseits ab vom Monty-Python-Mitglied Eric Idle, andererseits steht es als Abkürzung für &quot;'''I'''ntegrated '''D'''evelopment and '''L'''earning '''E'''nvironment. IDLE ist einfach zu bedienen, bietet aber schon einen beachtlichen Leistungsumfang. Nachfolgend wird ein Screenshot zu IDLE geliefert. Rechts ist das Editor-Fenster zu sehen, links die interaktive Programmierumgebung. Um das Beispiel selbst nachvollziehen zu können, starten Sie IDLE. Das geht ähnlich, wie Sie die interaktive Programmierumgebung von Python starten (nur, dass Sie eben das IDLE-Icon doppelklicken und nicht das Python-Icon. Unter Linux geben Sie einfach in einem Terminal &lt;code&gt;idle3.13&lt;/code&gt; o. Ä. ein). Weiter geht es mit &quot;File - Open - ...&quot;. Die auszuführende Datei auswählen (im konkreten Fall ein &quot;Hallo-Welt&quot;-Programm). Es erscheint das rechte Fenster. Dort &quot;Run - Run Module&quot; auswählen. Und schon wird im linken Fenster &quot;Hallo Welt!&quot; ausgegeben.

[[Datei:PythonIng_idle1.jpg | 600px]]

Siehe auch {{W|IDLE}}.

== PyCharm ==
PyCharm ist ein kommerzielles Produkt. Es gab aber auch eine kostenlose Community Edition. Seit 2025 sind beide Varianten vereint. Für die ersten 30 Tage sind die Pro-Funktionen frei verfügbar, danach nur noch die Kernfunktionalitäten (oder man bezieht kostenpflichtig  die Pro-Version). Zu beziehen ist PyCharm unter dem Weblink [https://www.jetbrains.com/pycharm/]. Nachfolgend ein etwas abgewandeltes &quot;Hallo Welt&quot;-Programm, editiert und ausgeführt mit PyCharm.

[[Datei:PyCharm_IDE_2023_screenshot.png | 600px]]

Siehe auch {{W|PyCharm}}.

== Eric ==
Auch eric ist Open Source und steht unter der  GNU General Public License Version 3 oder später. Zu beziehen ist diese Software unter [https://eric-ide.python-projects.org/].

[[Datei:Screenshot_Eric_4.png | 600px]]

Siehe auch {{W|eric (Software)}}.

&lt;small&gt;
Unter openSUSE Tumbleweed sollte sich eric auch mit YaST installieren lassen. Bei mir gibt es aber dann beim Ausführen des eric-Programms eine Fehlermeldung (Stand März 2026): 
 
 ...
 ModuleNotFoundError: No module named 'PyQt6.QtPdfWidgets'

Umgehen kann man dieses Problem aber wieder mit dem Erstellen einer virtuellen Umgebung, in etwa so

 python3.13 -m venv ~/tmp/venv1
 cd ~/tmp/venv1/bin
 ./python3.13 -m pip install --upgrade --prefer-binary eric-ide
 ./eric7_ide
&lt;/small&gt;

== PyScripter ==
Vom Funktionsumfang vergleichbar mit den vorherigen IDEs ist PyScripter. Auch PyScripter ist Open Source. Die Projekt-Homepage findet sich auf [https://sourceforge.net/projects/pyscripter/]. PyScripter ist nur für MS Windows verfügbar.

[[Datei:PythonIng_pyscripter1.jpg | 600px]]

== Spyder IDE ==
Spyder enthält bereits eine stabile Python-Version und etliche Module (z.B. matplotlib, numpy, control). Ansonsten kann dieses Softwarepaket vom Funktionsumfang her mit den anderen genannten IDEs locker mithalten. Spyder wurde unter der MIT-Lizenz veröffentlicht. Diese Software findet sich auf [https://www.spyder-ide.org].

[[Datei:Spyder-windows-screenshot.png | 600px]]

Siehe auch {{W|Spyder (Software)}}

== Eclipse IDE==
Die {{W|Eclipse_(IDE)|Eclipse-IDE}} kann für Python aufgerüstet werden. Dazu gibt es das PyDev-Plugin. Installiert wird es über 
* Help &gt; Eclipse Marketplace... 
* Find - PyDev - Install
Danach muss noch der Pfad zum Python-Interpreter festgelegt werden 
* Window &gt; Preferences &gt; PyDev &gt; Interpreters &gt; Python Interpreter &gt; New ... 
Das Ergebnis ist ähnlich wie im folgenden Bild, nur dass statt C/C++ Python Verwendung findet. 

[[Datei:Setting Up Eclipse CDT helloout.png | 600px]]

== Sonstige ==
Die genannten IDEs sind nicht die Einzigen. Es gibt, um dem Image Pythons als beliebteste Programmiersprache gerecht zu werden, noch einige andere. Sowohl Open Source-Programme als auch kommerzielle Programme sind im Web zu finden, z.B. Thonny oder {{W|Visual Studio Code}}. Unter Linux kann man auch {{W|KDevelop}}, ausgestattet mit dem Python3-Plugin, einsetzen. Braucht man den Umfang von ausgewachsenen IDEs nicht, so kann man auch normale Texteditoren verwenden (z.B. {{W|Geany}} oder {{W|Kate_(Texteditor)|Kate}}).

= Debuggen und Testen =
Das Debuggen und Testen von Programmen sind wichtige Bestandteile der Programmierung. Syntaxfehler lassen sich i.A. leicht beheben. Schwieriger ist das Eingrenzen von logischen Fehlern, die ev. nur in bestimmten Situationen auftreten und keine explizite Fehlermeldung hervorrufen. Das Programm liefert falsche Ergebnisse oder es stürzt aus heiterem Himmel ab. Um das zu verhindern gibt es verschiedene Werkzeuge, die bei der Fehlersuche behilflich sein können. Vorerst siehe aber zwecks Begriffsklärung noch folgende Links: 
 
* {{W|Debuggen}}
* {{W|Debugger}}
* {{W|Softwaretest}}

&lt;gallery&gt;
First Computer Bug, 1947.jpg
Test ganzheitlich.png
V-Modell.svg
&lt;/gallery&gt;

== Das Modul pdb ==
Python bringt schon ein Modul zum Debuggen mit. Siehe z.B. [https://docs.python.org/3/library/pdb.html pdb — The Python Debugger].
Komfortabler lässt sich das aber mittels Integrierter Entwicklungsumgebungen (IDEs) angehen.

== Debuggen mit IDEs ==
Für die IDEs IDLE und Spyder sei kurz auf die entsprechenden Webseiten verwiesen:

* [https://www.cs.uky.edu/~keen/help/debug-tutorial/debug.html Debugging under IDLE].
* [https://docs.spyder-ide.org/current/panes/debugging.html Spyder Debugger]

Dort wird die Vorgehensweise auch mittels Screenshots erläutert.

== assert ==
assert ... behaupten, zusichern ({{W|Assertion (Informatik)}})

Python-Code:
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10., 0.)

Ausgabe:

 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10., 0.)
   File &quot;/home/hr/Develop/test1.py&quot;, line 4, in print1
     assert y != 0.0
            ^^^^^^^^
 AssertionError
 
Python-Code: 
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)
 
Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(&quot;10.&quot;, &quot;5.&quot;)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError
 
Aber auch bei nachfolgendem Code gibt es eine Fehlermeldung:

 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10, 5)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError

Damit letzteres funktioniert, kann man den Programmcode so umschreiben:
 def print1(x, y):
     assert type(x) == float or type(x) == int
     assert type(y) == float or type(y) == int
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 2.0
 
Und jetzt fangen wir den &lt;code&gt;AssertionError&lt;/code&gt; auf:
 def print1(x, y):
     try:
         assert type(x) == float or type(x) == int
         assert type(y) == float or type(y) == int
         assert y != 0.0
         print(x/y)
     except(AssertionError):
         print(&quot;Hallo&quot;)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)

Ausgabe:
 2.0
 Hallo

Ich hoffe, es ist wenigstens im Ansatz klar geworden, wofür &lt;code&gt;assert&lt;/code&gt; gut sein kann. Ausschalten kann man die &lt;code&gt;assert&lt;/code&gt;-Überprüfung übrigens mit dem Python-Schalter &lt;code&gt;-O&lt;/code&gt;.

== Doctests == 
Innerhalb eines Docstrings kann die Arbeit im interaktiven Modus simuliert werden. Nach den Promptzeichen (&gt;&gt;&gt;) erfolgen dann bei unserem Beispiel innerhalb des Docstrings simulierte Aufrufe der Funktion &lt;code&gt;print1()&lt;/code&gt;. Danach folgen jeweils die Sollresultate. Wird das Modul oder die Datei als Hauptprogramm aufgerufen, so wird die Funktion &lt;code&gt;doctest.testmode()&lt;/code&gt; aufgerufen und ein Bericht auf der Konsole ausgegeben. Wird das Modul nicht als Hauptprogramm aufgerufen, sondern importiert, dann wird diese &lt;code&gt;testmod&lt;/code&gt;-Funktion nicht aufgerufen. D.h. dieser Code kann sowohl für Testzwecke als auch für den produktiven Einsatz verwendet werden. Das ist auch sinnvoll, weil wenn man Teile der Datei immer löschen bzw. einfügen müsste, so würden sich Fehlerquellen auftun. Das würde den Sinn und Zweck von Doctests konterkarieren.  

 def print1(x=0., y=1.):
     &quot;&quot;&quot; Dividiere zwei Zahlen
     Autor: Intruder
     Datum: 12.08.2025
 
     &gt;&gt;&gt; print1(2., 1.)
     2.0
     &gt;&gt;&gt; print1(5., 2.)
     2.5
     &gt;&gt;&gt; print1(5.)
     5.0
     &quot;&quot;&quot;
     print(x/y)
 
 if __name__ == &quot;__main__&quot;:
     import doctest
     doctest.testmod(verbose=True)

Ausgabe:
 Trying:
     print1(2., 1.)
 Expecting:
     2.0
 ok
 Trying:
     print1(5., 2)
 Expecting:
     2.5
 ok
 Trying:
     print1(5.)
 Expecting:
     5.0
 ok
 1 items had no tests:
     __main__
 1 items passed all tests:
    3 tests in __main__.print1
 3 tests in 2 items.
 3 passed and 0 failed.
 Test passed.

Das gezeigte Beispiel ist so ziemlich das einfachste, das es gibt. Für weiterführende Details siehe z.B.:
* [https://peps.python.org/pep-0257/ PEP 257 – Docstring Conventions]
* [https://docs.python.org/3/library/doctest.html doctest — Test interactive Python examples]

''Einschub:'' Ganz ähnlich kann man auch Klassen testen, z.B. in folgendem Code-Fragment

 class Fahrzeug:
   # siehe Abschnitt &quot;Objektorientierte Programmierung&quot;
   # ...
 
 if __name__ == &quot;__main__&quot;:
   vauweh = Fahrzeug(170, 90)
   beemweh = Fahrzeug(200, 120)
   print(vauweh.convertGeschw())
   print(beemweh.convertGeschw())

Wird das Script als Hauptprogramm ausgeführt (z.B. zu Testzwecken), so erfolgt die Ausgabe der zwei, via &lt;code&gt;convertGeschw()&lt;/code&gt;, umgerechneten Geschwindigkeiten. Wird es aber als Modul eingebunden, so wird der letzte Programmabschnitt nicht ausgeführt (&lt;code&gt;__name__ == &quot;__main__&quot;&lt;/code&gt; ergibt &lt;code&gt;False&lt;/code&gt;).

== pytest ==
Siehe zu diesem Thema auch {{W|Modultest}}.

pytest ist ein externes Modul und muss vorab installiert werden, z.B. mittels 
 pip install -U pytest
 pip install -U pytest-html 

Python-Code, Datei test1.py:
 def add(x, y):
     return x + y
 
 def test_answer():
     assert add(1, 1) == 3

Starten von pytest in der Konsole:
 pytest test1.py
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py F                                                                                                            [100%]
 
 ========================================================= FAILURES ==========================================================
 ________________________________________________________ test_answer ________________________________________________________
 
     def test_answer():
 &gt;       assert add(1, 1) == 3
 E       assert 2 == 3
 E        +  where 2 = add(1, 1)
 
 test1.py:6: AssertionError
 ================================================== short test summary info ==================================================
 FAILED test1.py::test_answer - assert 2 == 3
 ===================================================== 1 failed in 0.09s =====================================================

Hier erhalten wir einen Fehler, da 1+1 eindeutig ungleich 3 ist. Aber aus irgendeinem Grund wollte der Programmierer oder Tester in diesem Fall, dass dies so ist. Testfälle werden übrigens mit dem Präfix &lt;code&gt;test_&lt;/code&gt; eingeleitet.

Python-Code:
 def add(x, y):
     return x + y + 1
 
 def test_answer():
     assert add(1, 1) == 3 
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py .                                                                                                            [100%]
 
 ===================================================== 1 passed in 0.01s =====================================================

Jetzt ist alles in Ordnung. Weiterführendes siehe z.B.

* [https://docs.pytest.org/en/stable/ pytest: helps you write better programs]

== unittest ==
Auch unittest dient zur Durchführung von Testreihen, ist aber Bestandteil von Python. Hier wird vorerst nicht näher darauf eingegangen. Siehe z.B. 
* [https://docs.python.org/3/library/unittest.html unittest — Unit testing framework]

Lt. ''Inden: Python Challenge; dpunkt, 2021, Seite 481''  soll unittest weniger komfortabel als pytest sein.

Einen Vergleich von unittest mit pytest findet man in
* [https://knapsackpro.com/testing_frameworks/difference_between/pytest/vs/unittest pytest vs unittest]

= Python und Anwendungsprogramme =
Bisher stand immer alleine die Programmiersprache Python (ev. unter Einbeziehung von Modulen) im Mittelpunkt der Betrachtungen. Aber Python kann auch als Makrosprache für Anwendungsprogramme auftreten. Als Beispiele seien {{W|FreeCAD}} und {{W|LibreOffice}} genannt.

== FreeCAD ==
FreeCAD ist ein freies 3D-CAD-Programm. Hier soll nicht auf die Bedienung dieses CAD-Pakets eingegangen werden, sondern nur auf die Möglichkeit, mittels Python Makros zu schreiben. Als einfacher Einstieg soll ein Makro erstellt werden, welches eine Kugel (rot) und einen Quader (blau) zeichnet. Folgende Vorbereitungsschritte sind erforderlich (es sei vorausgesetzt, dass FreeCAD schon am Rechner installiert ist. Downloaden können Sie das Programm von der Website [https://www.freecad.org/downloads.php?lang=en]):

* FreeCAD starten
* Leere Datei erstellen
* Makro &gt; Makros &gt; Erstellen ...

Es öffnet sich ein leeres Editorfenster, in das Sie folgenden Code eingeben können:

 import FreeCAD
 import Part
 
 doc = FreeCAD.newDocument()
 
 # Kugel
 kugel = Part.makeSphere(10)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Kugel&quot;)
 form_element.Shape = kugel
 kug = FreeCAD.ActiveDocument.getObject(&quot;Kugel&quot;)
 kug.ViewObject.ShapeColor = (1.0, 0.0, 0.0)
 neuePosition = App.Vector(5, 2.5, 2.5)
 kug.Placement = App.Placement(neuePosition, kug.Placement.Rotation)
 
 # Quader
 quader = Part.makeBox(5, 5, 50)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Quader&quot;)
 form_element.Shape = quader
 quad = FreeCAD.ActiveDocument.getObject(&quot;Quader&quot;)
 quad.ViewObject.ShapeColor = (0.0, 0.0, 1.0)
 
 doc.recompute()

Diesen Code können Sie nun ausführen:
* Makro &gt; Makro ausführen

Es ergibt sich folgende Ausgabe (gedreht und gezoomt):

[[Datei: PythonIng_freecad1.png|500px]]

Siehe auch [https://wiki.freecad.org/Python_scripting_tutorial/de# Anleitung Skripterstellung mit Python]. Getestet wurde obiges Beispiel mit FreeCAD 1.1.3 unter Linux und 1.1.1 unter MS Windows.

== LibreOffice ==
LibreOffice ist ein freies Officepaket ([https://de.libreoffice.org/]). Hier soll nur das Tabellenkalkulationsprogramm Calc kurz betrachtet werden. Es seinen in den ersten 3 Zellen (A1 bis A3) Zahlen gegeben. Diese sollen mit einem Python-Makro addiert und das Resultat in der Zelle A5 ausgegeben werden. Auch hier sind Vorbereitungsarbeiten nötig: 
* zuerst muss unter Linux das Verzeichnis &lt;code&gt;~/.config/libreoffice/4/user/Scripts/python&lt;/code&gt; erstellt werden
* für MS Windows ist es das Verzeichnis &lt;code&gt;%APPDATA%\LibreOffice\4\user\Scripts\python&lt;/code&gt; 
** drücken Sie zuerst Win + R (es öffnet sich das Ausführen-Fenster)
** geben Sie &lt;code&gt;%appdata%&lt;/code&gt; ein, danach drücken Sie Enter (es öffnet sich der Explorer)
** navigieren Sie zu dem genannten Verzeichnis bzw. erstellen Sie das Verzeichnis 
* in diesem Verzeichnis wird dann mit einem beliebigen Texteditor das Python-Makro erstellt, in unserem Fall die Datei &lt;code&gt;summiere_zellen.py&lt;/code&gt;:

 import uno
 
 def summiere_zellen(*args):
     # Zugriff auf das aktuelle Dokument und das aktive Tabellenblatt
     ctx = uno.getComponentContext()
     smgr = ctx.getServiceManager()
     desktop = smgr.createInstanceWithContext(&quot;com.sun.star.frame.Desktop&quot;, ctx)
     doc = desktop.getCurrentComponent()
     sheet = doc.getCurrentController().getActiveSheet()
 
     # Werte aus den Zellen A1 bis A3 auslesen
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
 
     # Addition der drei Werte
     summe = w1 + w2 + w3
 
     # Ergebnis in die Zelle A5 schreiben
     sheet.getCellRangeByName(&quot;A5&quot;).Value = summe

* siehe dazu ggf. auch [https://help.libreoffice.org/latest/de/text/sbasic/python/python_locations.html?DbPAR=BASIC].

Weiter geht es in LibreOffice Calc mit dem Menü ''Extras &gt; Makros &gt; Makros verwalten &gt; Python''. Dort wird das Makro &lt;code&gt;summiere_zellen&lt;/code&gt; ausgeführt. Es ergibt sich z.B. folgendes Resultat

[[Datei:PythonIng_libreoffice1.png]]

Das Kürzel &lt;code&gt;uno&lt;/code&gt; steht für '''U'''niversal '''N'''etwork '''O'''bjects. Etwas einfacher geht's auch so:

 def summiere_zellen():
     desktop = XSCRIPTCONTEXT.getDesktop()
     model = desktop.getCurrentComponent()
     sheets = model.getSheets()
     sheet = sheets.getByIndex(0)
     
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
     
     cell = sheet.getCellRangeByName(&quot;A5&quot;)    
     cell.setValue(w1 + w2 + w3) 

Empfohlen wird auch, das Erweiterungspaket APSO ('''A'''lternative '''P'''ython '''S'''cript '''O'''rganizer, apso.oxt) zu installieren. Die Vorgehensweise wird hier nicht gezeigt, sondern nur darauf hingewiesen, dass man das einfach &quot;googeln&quot; kann. Siehe zur Python-Programmierung für LibreOffice auch [https://wiki.documentfoundation.org/Macros/Python_Guide/de Makros/Python-Handbuch]. Getestet wurden obige Beispiele mit LibreOffice 26.2.5.1 unter Linux und 26.2.1.2 unter MS Windows.

= Ausblick =
Dies war eine kurze Einführung in die Berechnungs- und Darstellungsmöglichkeiten mit Python. Es sollten etliche relevante Themen behandelt, oder zumindest kurz angesprochen worden sein. Wem dieser Text nicht ausreichend ist, der sei auf die entsprechenden weiterführenden Weblinks, Bücher und die Python-Hilfefunktion verwiesen. Python kennt noch viel mehr Befehle, als hier dargestellt wurden. Das Themenspektrum ist auch durch die Einbindung externer Module fast beliebig erweiterbar.

= Weblinks=
== Python allgemein ==
* [https://www.python.org/ Python Homepage]

== Externe mathematische Module ==
* [https://numpy.org/ NumPy]
* [https://numpy.org/doc/stable/user/numpy-for-matlab-users.html NumPy for MATLAB users]
* [https://scipy.org/ SciPy]
* [https://www.sympy.org/en/index.html SymPy]
* [https://pandas.pydata.org/ pandas]
* [https://github.com/maroba/findiff findiff]
* [https://mpmath.org/ mpmath]

== Externe Module für Grafiken ==
* [https://matplotlib.org/ Matplotlib]
* [https://vpython.org/ VPython]
* [https://build123d.readthedocs.io/en/latest/ build123d]
* [https://docs.vtk.org/en/latest/api/python.html VTK]
* [https://docs.bokeh.org/en/latest/docs/first_steps.html bokeh]
* [https://py5coding.org/ py5]

== Erstellung von User Interfaces ==
* [https://docs.python.org/3/library/tkinter.html tkinter - Python interface to Tcl/Tk]
* [https://docs.python.org/3/library/curses.html curses - Terminal handling for character-cell displays]
* [https://wiki.qt.io/Qt_for_Python Qt for Python]
* [https://www.gtk.org/docs/language-bindings/python GTK and Python]

== Erstellen virtueller Umgebungen ==
* [https://docs.python.org/3/library/venv.html venv - Creation of virtual environments]

== Sonstige ==
* [https://python-control.readthedocs.io/en/stable/ Python Control Systems Library]
* [https://pypi.org/project/regex/ regex - Regular Expressions]
* [http://pyromat.org/ PYroMat]
* [https://coolprop.org/coolprop/wrappers/Python/index.html CoolProp]
* [https://pypi.org/project/iapws/ iapws]
* [https://tespy.readthedocs.io/en/main/getting_started/introduction.html TESPy - Thermal Engineering Systems in Python]
* [https://pint.readthedocs.io/en/stable/ pint]

= Bücher =
== Gedruckte Bücher, OpenBooks, Magazine ==
* Diverse: c't Python Lernen, Verstehen, Anwenden; Heise, 2022 
* Ernesti, Kaiser: Python3 - das umfassende Handbuch; 5. Aufl., Rheinwerk, [https://openbook.rheinwerk-verlag.de/python/ OpenBook]
* Iacono et al.: Programmieren trainieren; 3. Aufl., Hanser, 2023, ISBN 978-3-446-47766-7
* Inden: Python Challenge; dpunkt, 2021, ISBN 978-3-86490-809-5
* Klein: Numerisches Python; 2. Aufl., Hanser, 2023, ISBN 978-3-446-47170-2 
* Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler; Rheinwerk, 2021, ISBN 978-3-8362-7316-9
* Weigend: Python 3 - Das umfassende Praxisbuch; 9. Aufl., mitp, 2022, ISBN 978-3-7475-0544-1
* Woyand: Python für Ingenieure und Naturwissenschaftler; 4. Aufl., Hanser, 2021, ISBN 978-3-446-46483-4

== Andere Wikibooks ==
* [[:en:Subject:Python_programming_language | Englische Wikibooks zum Thema Python]]
* [[Python|Deutschsprachiges Python-Wikibook]] [[Bild:2von10.png|20%]]
* [[Python unter Linux|Python 2.7 unter Linux]] [[Bild:10von10.png|100%]]


{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}</text>
      <sha1>k17uh10wpey3zmnryua2qufgj4o0xbp</sha1>
    </revision>
    <revision>
      <id>1092173</id>
      <parentid>1092172</parentid>
      <timestamp>2026-10-16T18:51:05Z</timestamp>
      <contributor>
        <username>Intruder</username>
        <id>1513</id>
      </contributor>
      <minor />
      <comment>/* Sonstiges */ konkretisiert</comment>
      <origin>1092173</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="189459" sha1="5v4fy82tfigcu3c2y0nwycijrj9b0ny" xml:space="preserve">{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}


= Hallo Welt und allgemeine Hinweise =
== Was ist Python ==
* Python ist eine universelle höhere Programmiersprache.
* Python ist objektorientiert.
* Python ist Open-Source (Python Software Foundation License).
* Python ist für viele Betriebssysteme erhältlich (z.B. für Linux, MS Windows, macOS).
* Python ist ein Interpreter.
* Python ist durch Module fast beliebig erweiterbar.
* Python als Programmiersprache ist case-sensitive - d.h. Groß- und Kleinschreibung ist relevant bei der Eingabe von Befehlen.
* Python ist in etlichen Anwendungsprogrammen (z.B. {{W|FreeCAD}}, {{W|LibreOffice}}, {{W|GIMP}}, {{W|Blender (Software) | Blender}}) als Makrosprache verwendbar.

{{Wikipedia | Python (Programmiersprache)}}

== Python installieren ==
=== MS Windows ===
Laden Sie das aktuelle Python-Paket von der Webseite [https://www.python.org/] herunter. Weiter geht es wie bei jedem anderen größeren zu installierenden Programm. Einfach das Installationsprogramm im Explorer doppelklicken und den Anweisungen des Setup-Programmes folgen.

=== Linux ===
Entweder ist Python bereits standardmäßig installiert, ansonsten ist die Installation mittels Paketmanagementsystem einfach möglich. Aber auch die Spyder-Entwicklungsumgebung ([https://www.spyder-ide.org]) bietet einen guten Einstieg mit Python (das gilt auch für MS Windows). Spyder bringt auch schon etliche wichtige Module standardmäßig mit.

== Python starten ==
=== MS Windows ===
Das Icon für das Python-Programm doppelklicken. Und schon startet das Programm.

[[Datei:PythonIng_start1.jpg]]

Python im interaktiven Modus (REPL ... '''R'''ead-'''E'''valuate-'''P'''rint-'''L'''oop) präsentiert sich dann so:

 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

Alternativ kann das Programm auch über die Eingabeaufforderung oder die PowerShell gestartet werden:

 c:\devel\Python&gt;python.exe
 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

=== Linux ===
Tippen Sie einfach das Wort „python“ (oder unter openSUSE Tumbleweed z.B. auch „python3.11“ oder „python3.13“) in einem Linux-Terminal ein, schließen den Befehl mit der RETURN-Taste ab, und schon startet Python im interaktiven Modus:
 
 Python 3.13.12 (main, Feb 09 2026, 22:37:44) [GCC] on linux
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt; 

Es gibt auch noch andere Möglichkeiten Python zwecks Programmausführung zu starten, z.&amp;nbsp;B. den {{W|Shebang}} (&lt;code&gt;#!&lt;/code&gt;) am Beginn eines Python-Scripts. Das Script sei als Script.py gespeichert. Dann kann das Script mit ./Script.py ausgeführt werden. Für openSUSE Tumbleweed sei nachfolgend ein lauffähiges &quot;Hallo Welt!&quot;-Script angegeben. Es wird in diesem Script der Python-Interpreter in der Version 3.13 verwendet :

 #!/usr/bin/python3.13
 print(&quot;Hallo Welt!&quot;)

Die Berechtigungen zum Ausführen der Datei müssen natürlich noch richtig gesetzt werden, z.B. mittels &lt;code&gt;chmod 777 Script.py&lt;/code&gt;. &lt;small&gt;&lt;code&gt;chmod&lt;/code&gt; ist die Abkürzung für&quot;'''ch'''ange file '''mod'''e bits&quot;.&lt;/small&gt; 

&lt;small&gt;Die &quot;Maske&quot; &lt;code&gt;777&lt;/code&gt; ist nur für Testzwecke sinnvoll, weil sie leicht zu merken ist und für alle Benutzer alle Zugriffsberechtigungen ('''r'''ead/'''w'''rite/e'''x'''ecute für owner/group/others) setzt. Im richtigen Einsatz wird man das aus Sicherheitsgründen nicht so handhaben, sondern nur die Berechtigungen setzen, die unbedingt erforderlich sind. Welche Zugriffsberechtigungen gesetzt sind, kann man z.B. mit dem Befehl &lt;code&gt;ls -l&lt;/code&gt; oder &lt;code&gt;ll&lt;/code&gt; ('''l'''i'''s'''t directory contents) erfragen. Aber dazu im Moment genug. Erfahrene Linux-Nutzer kennen das ohnehin und Anfänger sollen jetzt nicht mit Linux-Interna überfordert werden. Bei Bedarf siehe die Linux-Man-Pages oder dezidierte Bücher zu Linux.&lt;/code&gt;&lt;/small&gt;

&lt;small&gt;Oder das Script wird in einen Pfad verschoben, in dem sich ausführbare Programme generell befinden (welche Verzeichnisse im PATH liegen, kann bspw. mit &lt;code&gt;echo $PATH&lt;/code&gt; abgefragt werden). Das Script kann dann wie ein normales Programm ohne weitere Angaben mit Script.py gestartet werden. Alternativ wird nicht das Script an sich verschoben, sondern nur ein symbolischer Link angelegt, z.B. mit &lt;code&gt;ln -s ~/tmp/Script.py ~/.local/bin/Script.py&lt;/code&gt;. &lt;code&gt;~/.local/bin&lt;/code&gt; sei ein im PATH gelegenes Verzeichnis. Dies sind aber schon Features für fortgeschrittene Linux-Benutzer und werden am Anfang eher selten benötigt.&lt;/small&gt;

== Ein paar Worte zur Erklärung ==
=== Tests ===
Getestet wurden die Beispiele unter den Betriebssystemen 
* MS Windows 10 mit der Python-Version 3.12.0 (teilweise auch mit 3.12.2 und 3.13.1; nur die Inhalte die bis spätestens Juli 2025 erstellt wurden) 
* MS Windows 11 ab der Python-Version 3.13.4 (nur zum Teil; ab Juli 2025)
* openSUSE Leap 15.6 mit der Python-Version 3.11.12 (Spyder, nur vereinzelt) und zum Teil mit 3.12.11 (ab Juli 2025 bis November 2025).
* openSUSE Tumbleweed ab der Python-Version 3.13.9 (nur vereinzelt, ab November 2025)

=== Popularität ===
* An Beliebtheit rangiert Python mit Stand September 2026 mit einem Rating von 17,76% an 1. Stelle vor C und C++ (lt. [https://www.tiobe.com/tiobe-index/ TPCI - TIOBE Programming Community Index]). 
* Lt. [https://innovationgraph.github.com/global-metrics/programming-languages GitHub Top 50 Programming Languages Globally] lag Python im Q1/2026 auf Rang 2, vor TypeScript und hinter JavaScript. 
* [https://pypl.github.io/PYPL.html PYPL] (Popularity of Programming Language Index) ist ein anderer Popularitätsindex für Programmiersprachen. Auch hier liegt Python mit großem Vorsprung auf dem ersten Platz (52,08%), gefolgt von Java (13,34%) und C/C++ (7,99%) (Stand September 2026). 

=== Namensgebung ===
Der Name &quot;Python&quot; rührt von der Komikertruppe {{W|Monty Python}} her. Die Icons für Python (z.B. Python selbst, Eric IDE, IDLE) sind aber durch die Python-Schlangenart symbolisiert.

&lt;gallery&gt;
Python-logo-notext.svg|Python-Logo
Guido van Rossum in PyConUS24.jpg|{{W|Guido van Rossum}} (geb. 1956), der Erfinder von Python
&lt;/gallery&gt;

== Ein erstes Programm ==
Kommentare werden in Python mit der Raute (#) eingeleitet. Sie werden vom Python-Interpreter ignoriert. Text kann mit der print-Funktion ausgegeben werden. Starten Sie Python und geben sie folgende Anweisungen zeilenweise ein

 &gt;&gt;&gt; # Das ist ein Kommentar
 &gt;&gt;&gt; print(&quot;Hallo Welt!&quot;)

Als Ergebnis erhalten Sie

 Hallo Welt!

Der Prompt (&gt;&gt;&gt;) ist selbstverständlich nicht einzutippen, sondern wird vom Python-System geliefert.

Strings können in Python entweder in Anführungszeichen (&quot;) gesetzt werden oder in Hochkommatas('). In diesem Text wird die erste Variante bevorzugt eingesetzt.

Im Gegensatz zu Julia ist es hier egal, ob zwischen &lt;code&gt;print&lt;/code&gt; und der öffnenden Klammer Leerzeichen stehen.

= Python als Taschenrechner =
== Allgemeines ==
Wir wollen 3 * 5 berechnen. Dazu starten wir Python im interaktiven Modus. Geben Sie dann die Formel  

 &gt;&gt;&gt; 3 * 5

ein, drücken die Taste ENTER/RETURN ({{Taste|↵}}) und erhalten als Ergebnis

 15

Auch kompliziertere Ausdrücke sind möglich. Beispielsweise mit Winkelfunktionen, Quadratwurzeln etc. Wir wollen nun den Ausdruck &lt;math&gt;\sin\sqrt{15}&lt;/math&gt; berechnen :

 &gt;&gt;&gt; import math
 &gt;&gt;&gt; math.sin(math.sqrt(15))
 -0.6679052983383519

Als erstes wird das math-Modul importiert. Dann wird der mathematische Ausdruck berechnet.

Eine andere Variante, die dasselbe Ergebnis liefert, ist

 &gt;&gt;&gt; from math import *
 &gt;&gt;&gt; sin(sqrt(15))
 -0.6679052983383519

Es wird also aus dem Modul &lt;code&gt;math&lt;/code&gt; alles importiert (erkennbar am &lt;code&gt;*&lt;/code&gt;). Will man nicht alles importieren, so kann man das auch einschränken:

 &gt;&gt;&gt; from math import sin, sqrt

Beenden lässt sich das Python-Programm durch Eingabe von &lt;code&gt;exit()&lt;/code&gt; (und natürlich ist zur Bestätigung die RETURN-Taste zu drücken). &lt;code&gt;exit&lt;/code&gt; (ohne Klammern) oder &lt;code&gt;quit&lt;/code&gt; werden auch akzeptiert.

== Die Hilfefunktion von Python ==
Bei Eingabe der Anweisung &lt;code&gt;help&lt;/code&gt; oder &lt;code&gt;help()&lt;/code&gt; springt Python in den Hilfemodus. 

Eingabe:
 &gt;&gt;&gt; help()
 
Eingabe:
 help&gt; math.sin

Ausgabe:
 Help on built-in function sin in math:
 
 math.sin = sin(x, /)
     Return the sine of x (measured in radians).

Für die komplette Python-Dokumentation siehe [https://docs.python.org/3/]. Verlassen kann man den Hilfemodus durch das Drücken von STRG-C, bzw. der Eingabe von q, quit oder exit mit anschließendem Drücken der RETURN-Taste.

== Aufgaben ==
* Erkunden Sie die Tangensfunktion &quot;tan&quot; mittels Python-Hilfe (vergessen Sie nicht das math-Modul zu importieren und das &lt;code&gt;math.&lt;/code&gt; vor &lt;code&gt;tan&lt;/code&gt;)
* Berechnen Sie mit Python den Ausdruck &lt;math&gt;\frac{1}{2}\cdot \text{e}^2 \cdot \tan(\pi/3)&lt;/math&gt;. Siehe für die Exponentialfunktion im Python-Hilfesystem auch den Befehl &lt;code&gt;math.exp&lt;/code&gt;. Alternativ kann auch die Konstante &lt;code&gt;math.e&lt;/code&gt; eingesetzt werden. Potenzieren kann man bei Python mit dem **-Operator (z.B. 2**3 = 8). Für &lt;math&gt;\pi&lt;/math&gt; gibt es &lt;code&gt;math.pi&lt;/code&gt;.

= Python als Scriptsprache =
Häufig wird man aber kompliziertere Anweisungsfolgen verarbeiten müssen. Diese will man normalerweise nicht jedesmal neu eingeben, sondern in einer Datei speichern und diese Datei dann zur Ausführung bringen. Speichern Sie dazu folgenden Code in einer Textdatei, z.B. unter MS Windows als c:\tmp\test1.py

 # Das ist ein Kommentar
 print(&quot;Hallo Welt!&quot;)

Python-Dateien werden mit der Dateiendung .py versehen. Achten Sie darauf, dass vor dem print keine Leerzeichen vorhanden sind. Das ist eine Python-Eigenheit. Wie wir später sehen werden, nutzt Python Einrückungen als syntaktisches Mittel, z.B. um bei Schleifen den Schleifenkörper zu kennzeichnen. 

Danach bringen Sie die Skriptdatei test1.py (sozusagen das Hauptprogramm) folgendermaßen zur Ausführung:

1) Starten Sie unter MS Windows die Eingabeaufforderung (oder alternativ auch die Windows PowerShell). Das sieht dann etwa so aus:

 Microsoft Windows [Version 10.0.19045.3693]
 (c) Microsoft Corporation. Alle Rechte vorbehalten.
 
 C:\Users\xyz&gt;

: &lt;small&gt;Falls jemand nicht weiß, wie man die Eingabeaufforderung startet: Eine Möglichkeit ist, einfach in der Taskleiste von Windows das &quot;Start&quot;-Symbol &amp;nbsp;([[Image:Windows_logo_-_2021_(Black).svg|10px]])&amp;nbsp; mit der rechten Maustaste anklicken. &quot;Ausführen&quot; auswählen (oder alternativ für die PowerShell unter Windows 10 den Eintrag &quot;Windows PowerShell&quot;, unter Windows 11 den Eintrag &quot;Terminal&quot;). Im sich öffnenden Dialogfenster gibt man in die &quot;Öffnen&quot;-Zeile das Wort &lt;code&gt;cmd&lt;/code&gt; ein und mit &quot;OK&quot; wird das Ganze bestätigt.&lt;/small&gt; 
 
2) Wechseln Sie mittels &lt;code&gt;cd c:\tmp&lt;/code&gt; in das Verzeichnis c:\tmp

3) Angenommen, Sie haben Python unter dem Pfad &lt;code&gt;c:\devel\Python\&lt;/code&gt; installiert. Starten Sie das Programm so (der Prompt &lt;code&gt;c:\tmp&gt;&lt;/code&gt;ist natürlich nicht mit einzutippen): 

 c:\tmp&gt;c:\devel\Python\python.exe test1.py

4) Wie erwartet ergibt sich folgende Ausgabe am Bildschirm

 Hallo Welt!

Die Vorgehensweise unter Linux ist prinzipiell gleich. Die kleinen Unterschiede, wie z.B. der Slash statt dem Backslash in Pfadangaben, sollten für Linux-Benutzer keine Hürde darstellen.

== Variablen ==
Variablenbezeichner können aus Buchstaben (A-Za-z), Ziffern (0-9) und Underscores (_) bestehen, dürfen aber nicht mit einer Zahl beginnen. Führende Underscores haben u.a. im Kontext mit der Objektorientierten Programmierung eine spezielle Bedeutung und sollten nicht für &quot;normale&quot; Variablenbezeichner verwendet werden.

Gültige Variablenbezeichner wären also:
 xyz
 x1
 _wert
 name_anzahl

Theoretisch kann man auch Umlaute, griechische Buchstaben u.ä. in Variablenbezeichnern nutzen, z.B.

 ößÜ = 16
 α = 134 
 print(ößÜ)
 print(α)

Ausgabe:
 16
 134

Davon wird aber aus offensichtlichen Gründen ({{W|Englisch als Lingua franca}}) abgeraten. Das Eurozeichen (€) etc. darf man ohnehin nicht in Variablenbezeichnern verwenden, dies ergäbe einen Syntaxfehler. Siehe dazu auch [https://peps.python.org/pep-3131/].

Es gibt in Python etliche Schlüsselwörter (z.B. for, if oder return). Diese dürfen nicht als eigene Variablenbezeichner verwendet werden. Eine Liste aller Schlüsselwörter liefert das Script

 import keyword
 print(keyword.kwlist)

&lt;small&gt;Übung: Speichern Sie dieses Script in eine Datei, z.B. in c:\tmp\test1.py. Führen Sie diese Datei aus, um die Liste der Schlüsselwörter auszugeben.&lt;/small&gt;

Da Python case-sensitiv ist, repräsentieren folgende Bezeichner verschiedene Variablen:
 xyz
 XYZ
 xYz

Werte werden an Variablen mittels Gleich-Zeichen (=) zugewiesen. Im Folgenden wird der Code immer in der Datei c:\tmp\test1.py gespeichert.

 x = 5
 y = 10
 z = x*y
 print(z)

Bringen Sie die Datei test1.py zur Ausführung, so erhalten Sie folgende Bildschirmausgabe

 50

Sie können auch mehrere Anweisungen in einer Zeile durch Semikolon getrennt schreiben. Dies führt aber zu unübersichtlichem Code.

 x = 5; y = 10; z = x*y; print(z)

Ausgabe:
 50

Auch aus der Programmiersprache C/C++ oder Java bekannte Konstrukte können Sie verwenden, z.B.
 x = 5
 # x = x - 2
 x -= 2
 print(x)

Bildschirmausgabe:

 3
 
Beachten Sie, dass mit dem =-Zeichen eine Wertezuweisung durchgeführt wird. Dies ist nicht äquivalent zum mathematischen =-Zeichen, wie am vorigen Beispiel zu ersehen ist. Den Inkrement-/Dekrementoperator (z.B. x++ oder x--) aus C/C++ oder Java kennt Python aber nicht.

Variablen sind nicht an einen bestimmten Datentyp gebunden, folgendes ist mit Python problemlos möglich:

 import math
 wert = 10
 print(wert)
 wert = 35.5
 print(wert)
 wert = &quot;Hallo&quot;
 print(wert)
 wert = math.pi
 print(wert)

Ausgabe:
 10
 35.5
 Hallo
 3.141592653589793

== Physische und logische Zeilen ==
In Python muss eine Anweisung in einer logischen Zeile Platz finden. Wird eine Anweisung aber zu lang für eine Zeile, dann kann sie in mehrere physische Zeilen unterteilt werden. Dies kann einerseits durch einen Backslash am Ende einer Zeile geschehen, z.B.

 a = 2 + \
 5
 
Dies stellt eine logische Zeile dar, die in zwei physische Zeilen unterbrochen ist.

Geklammerte Ausdrücke werden automatisch zu einer logischen Zeile verbunden, z.B.

 a = (2 + 
 5)
 
Achtung: Im ersten Beispiel darf nach dem Backslash nichts mehr stehen, auch kein Kommentar. Dies trifft im zweiten Bespiel nicht zu, hier könnte noch ein Kommentar folgen, z.B.

 a = (2 +    # Kommentar 
 5)

Auch für Strings gibt es Möglichkeiten, diese auf mehrere Zeilen aufzuspalten.

 # Kurzer String
 str1 = &quot;ABC&quot;
 
 # Langer String
 str2 = &quot;&quot;&quot;Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle&quot;&quot;&quot;
 
 # Backslash
 str3 = &quot;UVW\
 XYZ&quot;
 
 # Mit Klammern
 str4 = (&quot;Sehr langer Text, der automatisch .............. &quot;
         &quot;in einer einzigen Variable zusammengefügt wird.&quot;
 )
 
 print(str1)
 print(str2)
 print(str3)
 print(str4)

Ausgabe:

 ABC
 Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle
 UVWXYZ
 Sehr langer Text, der automatisch .............. in einer einzigen Variable zusammengefügt wird.

==Hexadezimale, oktale, binäre und andere Zahlen==
 d = 1050         # Dezimalzahl
 h = 0xAA2        # Hexadezimalzahl
 o = 0o12         # Oktalzahl
 b = 0b100001101  # Binärzahl
 
 print(d)
 print(h)
 print(o)
 print(b)

Ausgabe:
 1050
 2722
 10
 269

Groß- und Kleinbuchstaben sind in obigen Literalen übrigens egal. So kann man z.B. statt &lt;code&gt;0b1001&lt;/code&gt; auch &lt;code&gt;0B1001&lt;/code&gt; schreiben (siehe dazu [https://docs.python.org/3/reference/lexical_analysis.html#integer-literals]).

Sie können auch dezimale in hexadezimale Zahlen umwandeln, usw.:
 h = hex(1050)    # Dezimalzahl -&gt; Hexadezimalzahl
 b = bin(1050)    # Dezimalzahl -&gt; Binärzahl
 o = oct(1050)    # Dezimalzahl -&gt; Oktalzahl
 print(h)
 print(b)
 print(o)

Ausgabe:
 0x41a
 0b10000011010
 0o2032

Gegeben sei die Zahl 121 zur Basis 3. Diese soll in eine Dezimalzahl umgewandelt werden. Das kann so geschehen:

 z = int(&quot;121&quot;, 3)
 print(z)

Ausgabe:
 16

Dass dies richtig ist, davon kann man sich folgendermaßen überzeugen:
 &lt;math&gt; 1 \cdot 3^2 + 2 \cdot 3^1 + 1 \cdot 3^0 = 9 + 6+ 1 = 16 &lt;/math&gt;

Zahlen übersichtlicher schreiben kann man auch mittels Underscore, z.B.:

 print(&quot;Eine Million (Variante 1) =&quot;, 1000000)
 print(&quot;Eine Million (Variante 2) =&quot;, 1_000_000)
 print(&quot;Eine Rechnung:&quot;, 2_000 * 400_000);

Es ergibt sich bei beiden Varianten die gleiche Ausgabe. Variante 2 ist aber im Sourcecode leichter lesbar, detto die Zahlen in der Rechnung:

 Eine Million (Variante 1) = 1000000
 Eine Million (Variante 2) = 1000000
 Eine Rechnung: 800000000

== Strings und Platzhalter==
Ein paar einfache Beispiele:

 print(&quot;Hallo {}&quot; . format(&quot;Hugo&quot;))     # new style string formatting
 print(&quot;Hallo {:s}&quot; . format(&quot;Hugo&quot;))   # new style string formatting
 print(&quot;Hallo %s&quot; % &quot;Hugo&quot;)             # %-String

Ausgabe:

 Hallo Hugo
 Hallo Hugo
 Hallo Hugo

Python-Code (formatted string literals, Beispiel 1):
 str1 = &quot;Hallo&quot;
 str2 = &quot;Hugo&quot;
 print(f&quot;{str1} {str2}&quot;)

Ausgabe:
 Hallo Hugo

f-Strings (ab Python 3.6) sind die modernere Variante gegenüber %-Strings oder das ''new style string formatting''. Sie sind in der Regel auch schneller.

Python-Code (formatted string literals, Beispiel 2):
 wert = 11.567
 print(f&quot;Ausgabe: {wert:.5f}&quot;)

Ausgabe:
 Ausgabe: 11.56700

Komplexere Beispiele:

 print(&quot;Hallo {} und {}&quot; . format(&quot;Hugo&quot;, &quot;Mike&quot;))
 print(&quot;Hallo {name1} und {name2}&quot; . format(name2=&quot;Hugo&quot;, name1=&quot;Mike&quot;))
 # Füllzeichen: *
 # Bündigkeit: &gt; (=rechts), &lt; (=links), ^ (=zentriert)
 # Feldweite: 10
 # Typ: s (=String), f (=Gleitkommazahl), d (=Dezimalzahl) etc.
 print(&quot;Hallo {:*&gt;10s}&quot; . format(&quot;Hugo&quot;))
 print(&quot;Hallo {:*&lt;10s}&quot; . format(&quot;Hugo&quot;))

Ausgabe:

 Hallo Hugo und Mike
 Hallo Mike und Hugo
 Hallo ******Hugo
 Hallo Hugo******

Python-Code:
 str = &quot;Hallo\t%s\t%7.2f\t%10.2e\t%i&quot; % (&quot;Hugo&quot;, 12.34567, 34.567, 264)
 print(str)

Ausgabe:
 Hallo	Hugo	  12.35	  3.46e+01	264

== Unicode ==
Neben den bekannten ASCII-Zeichen lassen sich Zeichen auch mittels Unicode beschreiben. Griechische Buchstaben oder komplexere mathematische Operatoren - all das sollte kein Problem sein. Siehe auch {{W|Unicode}}, {{W|Liste der Unicodeblöcke}} und {{W|Unicodeblock Mathematische Operatoren}}. Im Folgenden werden ein paar Zeichen (Allquantor, Nabla-Operator, Existenzquantor), die man aus der Mathematik kennt, erzeugt. 
 
 ch1 = &quot;\N{FOR ALL}&quot;
 ch2 = &quot;\N{NABLA}&quot;
 ch3 = &quot;\u2203&quot;
 print(ch1, ch2, ch3)

Ausgabe:
 ∀ ∇ ∃

&lt;small&gt;Diese Ausgabe ergibt sich z.B. mit der IDLE-Shell oder mit Cygwin. Beim Ausführen über die Windows-Eingabeaufforderung oder Windows PowerShell unter MS Windows 10 erfolgt keine korrekte Darstellung. IDLE ist die mit Python mitgelieferte IDE ('''I'''ntegrated '''D'''evelopment '''E'''nvironment, Integrierte Entwicklungsumgebung). Gegen Ende dieses Textes wird IDLE kurz beschrieben.
Das Problem mit der Windows Eingabeaufforderung lässt sich aber umgehen. Man muss nur eine Schriftart auswählen, die die Zeichen kennt, z.B. &quot;DejaVu Sans Mono&quot;. Dazu klicken Sie einfach bei der Eingabeaufforderung mit der rechten Maustaste oben auf die weiße Leiste und wählen im aufpoppenden Fenster den Menüpunkt &quot;Eigenschaften&quot;. Es öffnet sich ein Dialogfenster. Über den Reiter &quot;Schriftart&quot; lässt sich nun die Schriftart einstellen. Unter MS Windows 11 oder openSUSE Leap 15.6 (bash-Konsole) gibt es dieses Problem ohnehin nicht.&lt;/small&gt;

== Reguläre Ausdrücke ==
Python kennt auch {{W|Regulärer Ausdruck|reguläre Ausdrücke}}. Dazu gibt es in Python das Modul &lt;code&gt;re&lt;/code&gt;. Beipielsweise sollen alle Zahlen (&lt;math&gt;\text{zahl}\in\mathbb{N}_0&lt;/math&gt;) in einem String gesucht und ausgegeben werden. Als String sei gegeben: &lt;code&gt;3x Grüße und 100 Kekse.&lt;/code&gt; Das Muster (Pattern) ist &lt;code&gt;\d+&lt;/code&gt;. &lt;code&gt;\d&lt;/code&gt; steht für eine Dezimalziffer 0-9. Das Plus-Zeichen (+) steht symbolisch für ein oder mehrere Zeichen des vorherigen Ausdrucks. Hier also ein oder mehrere Dezimalziffern. Es wird die Funktion &lt;code&gt;findall&lt;/code&gt; aus dem Modul &lt;code&gt;re&lt;/code&gt;verwendet.

Python-Code:
 from re import findall
 
 str = &quot;3x Grüße und 100 Kekse.&quot;
 pat = &quot;\\d+&quot;  # Doppel-Backslashes müssen verwendet werden, sonst gibt Python eine Warnung aus!
               # alternativ: pat = r&quot;\d+&quot; 
               # oder: pat = &quot;[0-9]+&quot;
 
 numb = findall(pat, str)
 print(numb)

Ausgabe:
 ['3', '100']

Python kennt noch viele weitere Möglichkeiten mittels regulärer Ausdrücke zu hantieren. Dies soll hier aber nicht vertieft werden, da das Thema schon ziemlich speziell und komplex ist. Bei Bedarf siehe aber z.B. die Bücher ''Weigend, Seite 380ff'' und ''Ernesti, Kaiser'' [https://openbook.rheinwerk-verlag.de/python/28_001.html] oder die Python-Dokumentation [https://docs.python.org/3/library/re.html]. Auch [[Python unter Linux: Reguläre Ausdrücke]] liefert ein umfangreiches und brauchbares Python-2-Kapitel zu den regulären Ausdrücken. Die dort gelisteten Beispiele müssten ggf. vor Verwendung auf Python-3 umgeschrieben werden. &lt;small&gt;Wie macht  man das? Dazu siehe z.B. [https://openbook.rheinwerk-verlag.de/python/43_001.html], [https://portingguide.readthedocs.io/en/latest/] oder [https://www.digitalocean.com/community/tutorials/how-to-port-python-2-code-to-python-3]&lt;/small&gt;

&lt;small&gt;Es gibt auch ein externes Modul ''regex'', das bei Bedarf extra installiert werden muss ([https://pypi.org/project/regex/]). Es bietet zusätzliche Funktionalität und gründlicheren Unicode-Support. Dies sei hier aber nur der Vollständigkeit halber erwähnt.&lt;/small&gt;

== Verzweigungen ==
=== if ===
Die IF-Verzweigung sei aus anderen Programmiersprachen bereits bekannt. In {{W|Pseudocode}} lässt sie sich folgendermaßen darstellen:

 WENN bedingung TRUE
   führe block1 aus
 SONST
   führe block2 aus
 ENDE 

Als {{W|Aktivitätsdiagramm|UML-Aktivitätsdiagramm}} sieht das in etwa so aus:

[[File:If-Then-Else-diagram.svg|200px]]

Und als {{W|Nassi-Shneiderman-Diagramm|Nassi-Shneiderman-Struktogramm}} so:

[[File:Zweiseitige Auswahl.png|250px]]

In Python gibt es keinen expliziten ENDE-Kennzeichner. Stattdessen wird der Code durch Einrückungen strukturiert. Alles mit der gleichen Einrückungstiefe gehört zum selben Block. Dies zeichnet Python vor anderen Programmiersprachen aus.

Die test1.py-Datei laute also wie folgt:

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
   print(&quot;x ist groesser oder gleich 4&quot;)  

Ausgabe:

 Der else-Zweig wird ausgefuehrt
 x ist groesser oder gleich 4

Man achte auch auf die Doppelpunkte in der if- und else-Zeile. Darauf vergisst man gerne, wenn man von anderen Programmiersprachen kommt.

Folgendes wäre in Python ein Fehler (genauer gesagt ein IndentationError).

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
     print(&quot;x ist groesser oder gleich 4&quot;)  

Auch Nachstehendes würde nicht zum gewünschten Ergebnis führen (löst aber keine Fehlermeldung aus). Der letzte print-Befehl ist schon außerhalb der IF-ELSE-Verzweigung.

 x = 3
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
 print(&quot;x ist groesser oder gleich 4&quot;)

Ausgabe:

 x ist kleiner als 4
 x ist groesser oder gleich 4

Python kennt eine Reihe von Vergleichs- und Verknüpfungsoperatoren:

    &lt;, &lt;= ... kleiner (gleich)
    &gt;, &gt;= ... größer (gleich)
    == ... gleich
    != ... ungleich
    is ... identisch
    is not ... nicht identisch
    and ... AND
    or ... OR
    not ... NOT

Beispielsweise:

 a = 5
 b = 9
 
 if a&lt;=10 and b!=7:
   print(&quot;OK&quot;)
 else
   print(&quot;Nicht OK&quot;)

Ausgabe:

 OK

Der else-Block kann übrigens auch ersatzlos entfallen. Als Pseudocode sieht das so aus

 WENN bedingung TRUE
   führe block aus
 ENDE

Mehrfache Verzweigungen werden durch das elif-Konstrukt erstellt. In Pseudocode:

 WENN bedingung1 TRUE
   führe block1 aus
 SONST WENN bedingung2 TRUE
   führe block2 aus
 SONST WENN bedingung3 TRUE
   führe block3 aus
 SONST
   führe block4 aus
 ENDE

Ein Python-Beispiel:
 a = 14
 
 if a&lt;=10:   
   print(&quot;&lt;=10&quot;)
 elif a&gt;=11 and a&lt;=15:
   print(&quot;11 bis 15&quot;)
 elif a&gt;=16 and a&lt;=20:
   print(&quot;16 bis 20&quot;)
 else:
   print(&quot;&gt;20&quot;)

Ausgabe:

 11 bis 15

In Python gibt es auch die Schlüsselwörter &lt;code&gt;True&lt;/code&gt; (für wahr) und &lt;code&gt;False&lt;/code&gt; (für falsch). Man beachte, dass sie mit Großbuchstaben beginnen. Andere Schreibweisen wären ein Fehler. Sie gehören zum Datentyp &lt;code&gt;bool&lt;/code&gt;. Ihnen sind auch die Zahlen &lt;code&gt;1&lt;/code&gt; und &lt;code&gt;0&lt;/code&gt; zugewiesen.

Man beachte, dass {{W|Rundungsfehler}} auftreten können. D.h. man sollte  bei der Verwendung von {{W|Gleitkommazahl|Gleitpunktzahlen}} niemals auf absolute Genauigkeit prüfen, sondern eine Toleranz (einen &lt;math&gt;\varepsilon&lt;/math&gt;-Wert) vorgeben.
 
Ein klassisches Beispiel, das ein falsches Ergebnis liefert, ist:

 i = 0.1 + 0.2
 
 print(i)
 
 if i == 0.3:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 NOK

Und das, obwohl man schon in der Volksschule lernt, dass 0.1 + 0.2 gleich 0.3 ist.

Korrekt muss das obige Beispiel z.B. so umgeschrieben werden:

 ist = 0.1 + 0.2
 soll = 0.3
 epsilon = 0.000001
 
 print(ist)
 
 if abs(ist-soll) &lt; epsilon:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 OK

Alternativ kann auch die &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion verwendet werden. Das sei aber hier nur erwähnt und nicht konkret ausgeführt.

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet zum Thema &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion.

=== match ===
Ab Python 3.10 gibt es auch die match-Anweisung. Dies ist das Python-Pendant für die switch-Anweisung in anderen Programmiersprachen, geht aber bei näherer Betrachtung weit darüber hinaus. Hier nur ein einfaches Beispiel:

 x = &quot;Hello&quot;
 
 match x:
     case &quot;Servus&quot; | &quot;Ciao&quot;:         # or
         print(&quot;Servus an alle&quot;)
     case &quot;Grüetzi&quot;:
         print(&quot;Grüetzi Schwyzer&quot;)  
     case _:                         # other, default, sonstiges ...
         print(&quot;Hallo Welt&quot;)

Ausgabe: 
 Hallo Welt

Als Struktogramm sieht das in etwa so aus:

[[File:Mehrseitige Auswahl.png|250px]]

Für nähere Details siehe z.B. [https://www.geeksforgeeks.org/python-match-case-statement/], [https://learnpython.com/blog/python-match-case-statement/], [https://docs.python.org/3/tutorial/controlflow.html#match-statements] und das Python Enhancement Proposal (PEP) 636 – Structural Pattern Matching: Tutorial [https://peps.python.org/pep-0636] und dort insbesondere den Anhang A - Quick Intro.

&lt;small&gt;&lt;code&gt;match, case, _&lt;/code&gt; etc. sind sogenannte ''soft keywords''. Im Gegensatz zu den normalen Schlüsselwörtern dürfen ihnen auch Werte zugewiesen werden. Eine Liste der weichen Schlüsselwörter lässt sich durch &lt;code&gt;keyword.softkwlist&lt;/code&gt; erstellen (die Anweisung gibt es seit Python 3.9). Siehe dazu auch [https://stackoverflow.com/questions/65800344/what-are-soft-keywords] und [https://docs.python.org/3/library/keyword.html#keyword.softkwlist].&lt;/small&gt;

== Schleifen ==
Kopfgesteuerte Schleife, Endlosschleife und fußgesteuerte Schleife:

[[File:Programmingloops.svg|450px]]

=== while ===
Die WHILE-Schleife ist kopfgesteuert. Sie funktioniert wie aus anderen Programmiersprachen bekannt. 

In Pseudocode:
 SOLANGE bedingung TRUE
   führe block aus
 ENDE

In Python:
 x = 0
 
 while x &lt;= 10:
   print(x)
   x += 1

Ausgabe:
 0
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10

Eine Endlosschleife ergibt sich z.B. so:
 i = 5
 
 while True:
     print(i)
     i-=1

Beendet werden kann sie mit der Tastenkombination STRG-C.

Eine fußgesteuerte Schleife kann so simuliert werden:
 i = 5
 
 while True:
     print(i)
     i-=1
 
     if i&lt;=0:
         print(&quot;Fire&quot;)
         break

Ausgabe:
 5
 4
 3
 2
 1
 Fire

Der &lt;code&gt;break&lt;/code&gt;-Befehl wird etwas [[Ing_Mathematik:_Python#break|später]] noch einmal kurz thematisiert.

=== for ===
Struktogramm einer for-Schleife:

[[File:Zählschleife.png|200px]]

In Python bspw. so:

 for x in range(6):
   print(x*2)

Ausgabe:
 0
 2
 4
 6
 8
 10

Die Schleife läuft von 0 bis 5. Ausgegeben wird jeweils der Wert x*2. Aquivalent kann diese Schleife auch so geschrieben werden:
 for x in range(0, 11, 2):
   print(x)

Die Ausgabe ist wie oben. Der Startwert sei 0, der Endwert ist 11-1 und die Schrittweite ist 2.

Ein anderes Beispiel sei
 for x in &quot;text&quot;:
   print(x)

Ausgabe:
 t
 e
 x
 t

== Schleifen abbrechen ==
=== break ===
&lt;code&gt;break&lt;/code&gt; bricht die Schleife ab und setzt mit dem nächsten Befehl außerhalb der Schleife fort.

 for var in range(100):
   print(var) 
   if var == 5:
     break

Ausgabe:
 0
 1
 2
 3
 4
 5

=== continue ===
&lt;code&gt;continue&lt;/code&gt; bricht den aktuellen Schleifendurchlauf ab und setzt mit dem nächsten Schleifendurchlauf fort.

 for var in range (11):
   if var == 5:
     continue
   print(var)

Ausgabe:
 0
 1
 2 
 3
 4
 6
 7
 8
 9
 10

== try - except ==
 try:
     z1 = 12 / 0
     print(z1)
 except ZeroDivisionError:
     print(&quot;Das Ergebnis ist unendlich&quot;)
 except:
     print(&quot;Kann nicht berechnet werden!&quot;)
     print(&quot;Bitte die Formel korrigieren!&quot;)
 
 print(&quot;Setze Programm fort!&quot;)

Ausgabe:
 Das Ergebnis ist unendlich
 Setze Programm fort!

Es wird versucht, eine Zahl durch Null zu dividieren. Das ist nicht möglich, es wird eine Ausnahme ausgelöst. Das Programm springt daher in den except-ZeroDivisionError-Block und führt die dort gelisteten Anweisungen aus (in unserem Fall eine print-Anweisung). Danach wird das Programm fortgesetzt. Würden wir dieses Programm ohne try-except ausführen, so ergibt sich aus

 z1 = 12 / 0
 print(z1)

folgende Fehlermeldung und ein unmittelbarer Programmabbruch

 Traceback (most recent call last):
   File &quot;C:\tmp\test1.py&quot;, line 1, in &lt;module&gt;
     z1 = 12 / 0
 ZeroDivisionError: division by zero

Mit dem try-except-Mechanismus können also Ausnahmen oder Fehler aufgefangen und behandelt werden. In unserem Beispiel ist das eher trivial, aber bei größeren Programmen kann das durchaus Sinn machen.

Neu in Python 3.14 ist, dass mehrere Ausnahmen auch ohne Klammern angegeben werden können, z.B.:

bis inkl. Python 3.13 nur:
 except (ZeroDivisionError, ValueError):

ab Python 3.14 auch:
 except ZeroDivisionError, ValueError:

== pass ==
Ein leerer Block muss in Python mittels dem Schlüsselwort &lt;code&gt;pass&lt;/code&gt; dargestellt werden. Z.B.

 x = 2
 
 if x == 1:
     print(&quot;Wert ist &quot;, x)
 else:
     pass

Würde man das &lt;code&gt;pass&lt;/code&gt; im else-Block weglassen, so würde man eine Fehlermeldung erhalten:

 IndentationError: expected an indented block after 'else' statement on line 5

= Funktionen =
== Aufrufen von Funktionen ==
Funktionen sind uns im Rahmen dieses Kurses schon zuhauf begegnet. Sei es die print()-, die math.sin()- oder die hex()-Funktion. All diese Funktionen werden von Python zur Verfügung gestellt, ohne dass man sie explizit programmieren müsste. Aufgerufen werden diese Funktionen, indem man ihren Namen eintippt, gefolgt von runden Klammern. In diesen Klammern können noch Argumente übergeben werden. Auch Rückgabewerte sind möglich.

== Funktionen selber schreiben ==
Funktionen werden mit dem def-Schlüsselwort (man definiert die Funktion) eingeleitet, danach folgt der Funktionsname, danach wiederum runde Klammern, in denen formale Argumente stehen können. Abgeschlossen wird die def-Zeile mit einem Doppelpunkt. Danach folgt der Funktionskörper. Dieser Funktionskörper muss wiederum eingerückt werden (wie von den Verzweigungen und Schleifen bekannt). Aufgerufen wird diese Funktion, indem man ihren Funktionsnamen eingibt, gefolgt von runden Klammern (ggf. mit den aktuellen Parametern). Z.B.

 # Funktion definieren
 def halloWelt(i):
     # i ... beliebige Ganzzahl
     print(&quot;Hallo &quot; * i, end=&quot;&quot;)
     print(&quot;Welt!&quot;)
    
 # Funktion aufrufen
 halloWelt(3)

Ausgabe:
 Hallo Hallo Hallo Welt!

Unterschied zwischen formalen und aktuellen Parametern:

[[Datei:PythonIng_func1.jpg]]

&lt;small&gt;Aktuelle Parameter werden auch Argumente genannt.&lt;/small&gt;

Rückgabe von Funktionswerten:
 # Funktion definieren
 def mathFunc(a, b):
     r1 = a + b
     r2 = a * b
     return r1, r2
    
 # Funktion aufrufen
 c, d = mathFunc(3, 5)
 
 # Ausgabe der zurückgegebenen Werte
 print(c)
 print(d)

Ausgabe:
 8
 15

Es werden r1 und r2 zurückgegeben und den Variablen c und d zugewiesen. (r1, r2) und (c, d) sind Tupel. Was Tupel konkret sind, siehe etwas später in diesem Kapitel. 3 und 5 sind die aktuellen Parameter (die Argumente). a und b sind die formalen Parameter. Die Zuweisung der aktuellen zu den formalen Parametern erfolgt in der gegebenen Reihenfolge, also die Zahl 3 wird an a übergeben und die Zahl 5 an b.

Vorgabeparameter, z.B.:
 def mathFunc(a=10, b=20):
     r1 = a + b
     r2 = a * b
     return r1, r2
 
 c, d = mathFunc(3, 5)
 print(c)
 print(d) 
 
 e, f = mathFunc(5)
 print(e)
 print(f)
 
 g, h = mathFunc(b=6)
 print(g)
 print(h)

Ausgabe:
 8
 15
 25
 100
 16
 60

Erklärung:
* Erster &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es werden, wie weiter oben, die Argumente 3 und 5 an die formalen Parameter a und b übergeben. Die Rückgabewerte r1 und r2 werden an c und d übergeben. Somit ist c=8 und d=15.
* Zweiter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur das Argment 5 an a übergeben. b behält den Vorgabewert 20. D.h. e= 25 und f=100.
* Dritter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur die Zahl 6 an b übergeben, a behält seinen Vorgabewert 10. Somit ergibt sich g=16 und h=60.

Beispiel (Schlüsselwortargumente vs. Positionsargumente):
 def mathFunc(a, b):
     r1 = a - b
     r2 = a / b
     return r1, r2
 
 c, d = mathFunc(b=3, a=5)  # Schlüsselwortargumente
 e, f = mathFunc(3, 5)      # Positionsargumente

 print(c)
 print(d)
 print(e)
 print(f)

Ausgabe:
 2
 1.6666666666666667
 -2
 0.6

Durch die Verwendung von Schlüsselwortargumenten können die Argumente in beliebiger Reihenfolge angegeben werden. Bei den Positionsargumenten ist die Reihenfolge vorgegeben. Daraus resultiert auch der Unterschied bei den obigen Ausgaben. Werden beide Arten in einem Aufruf gemischt, so müssen die Positionsargumente zuerst angegeben werden. Den Unterschied zwischen beiden Argumentarten zu kennen ist wichtig, nicht nur bei selbst erstellten Funktionen. Auch beim Aufruf von Python-Funktionen verfolgt einen die Mischung von Schlüsselwort- und Positionsargumenten auf Schritt und Tritt, z.B. beim etwas später folgenden Abschnitt über &quot;Grafiken zeichnen&quot;:

 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)

Bei dieser &lt;code&gt;plot&lt;/code&gt;-Funktion aus dem Modul &lt;code&gt;matplotlib.pyplot&lt;/code&gt; sind &lt;code&gt;x&lt;/code&gt; und &lt;code&gt;y1&lt;/code&gt; Positionsargumente. &lt;code&gt;label, lw&lt;/code&gt; und &lt;code&gt;ls&lt;/code&gt; sind die Namen der Schlüsselwortargumente. Die Schlüsselwortargumente könnten auch in anderer Reihenfolge angeschrieben werden, nicht jedoch die Positionsargumente!
Siehe zu &lt;code&gt;matplotlib.pyplot.plot&lt;/code&gt; auch die Seite [https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html].

== Lambda-Funktionen ==
 print((lambda a, b: a*b) (3, 5))

Ausgabe:
 15

Eingeleitet wird eine Lambda-Funktion (auch Lambda-Form, Lambda-Operator oder anonyme Funktion genannt) mit dem Schlüsselwort &lt;code&gt;lambda&lt;/code&gt;. Es folgen die formalen Argumente, danach ein Doppelpunkt, die Berechnungsvorschrift und ggf. abschliessend in Klammern die aktuellen Parameter.

Man kann einer Lambda-Funktion auch einen Funktionsnamen geben und die Funktion über diesen Namen aufrufen, z.B.

 prod = lambda a, b: a*b
 print(prod(3, 5))

Als Ausgabe wird wieder die Zahl 15 geliefert.

== Rekursive Funktionen ==
Funktionen können wiederum andere Funktionen aufrufen. Von einem {{W|Rekursion|rekursiven Funktionsaufruf}} spricht man, wenn die aufgerufene Funktion gleich der aufrufenden ist. 

 def printFunc(i):
     if (i &gt;= 5):
         return 
     else:
         print(&quot;Hallo Welt&quot;)
         printFunc(i+1)
         
 printFunc(1)

Ausgabe:
 Hallo Welt
 Hallo Welt
 Hallo Welt
 Hallo Welt

Typische Beispiele für die Abarbeitung als rekursive Funktionen sind die {{W|Fibonacci-Folge}} und die {{W|Fakultät_(Mathematik)|Fakultät}}. Jedoch ist der iterative Ansatz (mit konventionellen Schleifen) meist schneller und speicherplatzschonender.

== Funktionsannotationen ==
Python ist sehr flexibel, was Typen angeht. Im Vorhergehenden haben wir generell keine Typangaben gemacht. Will man Typen angeben, so bietet Python das Konzept der Funktionsannotation.

 def calcFunc(a: int, b: int) -&gt; int:
     return a+b
 
 r1 = calcFunc(8, 9)
 r2 = calcFunc(8.0, 9.0)
 r3 = calcFunc(&quot;Hallo&quot;, &quot;Welt&quot;)
 
 print(r1)
 print(r2)
 print(r3)

Ausgabe:
 17
 17.0
 HalloWelt

Jetzt sieht man auf den ersten Blick, welche Typen der Programmierer im Sinn hatte, als er die Funktion erstellte. Das Problem dabei ist nur, dass es Python ziemlich egal ist, welche Typen man im Endeffekt eingibt. Im obigen Beispiel können statt Integer-Typen u.a. auch Float- oder String-Typen eingegeben werden.

&lt;small&gt;
Siehe zum Thema &quot;Type Checking&quot; aber auch den später folgenden Abschnitt [[Ing_Mathematik:_Python#Type_Checker]].
&lt;/small&gt;

== Variadische Funktionen ==
Python-Code:

 def test1(a, *b):
     print(a);
      
     for c in b:
         print(c);
        
 test1(&quot;Hallo&quot;, &quot;Welt&quot;, &quot;Schweizer&quot;, &quot;und alle anderen&quot;)

Ausgabe:

 Hallo
 Welt
 Schweizer
 und alle anderen

Mit dem Stern (auch als Splat-Operator bezeichnet) in der formalen Parameterliste bei der Funktion &lt;code&gt;test1&lt;/code&gt; wird angezeigt, dass eine beliebige Anzahl von Argumenten übergeben wird. &lt;small&gt; Dies entspricht in etwa dem, was in anderen Programmiersprachen (PHP etc.) mittels Ellipse (&lt;code&gt;...&lt;/code&gt;) angezeigt wird.&lt;/small&gt;

= Tupel, Listen und andere =
[[Datei:Python 3. The standard type hierarchy.png|mini|hochkant=1.7|Datentypen und Strukturen]]

== Tupel und Listen ==
Tupel, Listen und einige andere sind Datenstrukturen oder Sequenzen.

Listen (z.B. eine Einkaufsliste) sind veränderbar (mutable). Ein Tupel kann dagegen nicht verändert werden (immutable). Listen werden beim Anlegen in eckige Klammern eingeschlossen, Tupel in runde Klammern. Beim Tupel können die Klammern auch weggelassen werden. Ein Tupel mit nur einem Element muss mit einem Beistrich abgeschlossen werden. Der Grund ist, dass Python sonst nicht entscheiden kann, ob ein Tupel angelegt werden soll, oder nur ein geklammerter Wert. 

Als Gedächtnisstütze kann man sich den Unterschied zwischen Tupel und Liste ev. so leichter merken:
: T'''u'''pel ... r'''u'''nde Klammern, '''u'''nveränderlich
: L'''i'''ste ... eck'''i'''ge Klammern, veränderl'''i'''ch.

Nachfolgend werden einige Operationen mit Listen und Tupel dargestellt.

 # Liste und Tupel
 liste = [1, 2, &quot;Hallo&quot;]
 tupel = (1, 2, &quot;Hallo&quot;) 
 
 # Ausgabe von liste und tupel
 print(liste)
 print(tupel)
 
 # Ausgabe von Einzelelementen
 print(liste[1])
 print(tupel[2])
 
 # Element an Liste anhängen und einfügen 
 liste.append(55)
 liste.insert(4, &quot;Welt&quot;)
 print(liste)
 
 # Element aus Liste entfernen
 liste.remove(1)
 print(liste)
 
 # einige weitere Beispiele
 liste2 = [1,]
 tupel2 = 1, 2
 tupel3 = (1,) 
 print(liste2)
 print(tupel2)
 print(tupel3)

Ausgabe:
 [1, 2, 'Hallo']
 (1, 2, 'Hallo')
 2
 Hallo
 [1, 2, 'Hallo', 55, 'Welt']
 [2, 'Hallo', 55, 'Welt']
 [1]
 (1, 2)
 (1,)

Beispiel (eine Liste von Wörtern zu einem einzigen zusammenhängenden Text verbinden):

 woerter = [&quot;Hallo&quot;, &quot;Welt&quot;]
 satz = &quot; &quot;.join(woerter)
 print(satz)

Ausgabe:

 Hallo Welt

== Dictionaries und Mengen ==
Zu den Datenstrukturen gehören weiters auch Mengen und Dictionaries. Mengen sind von der Mathematik bekannt, sie sind ungeordnet und es kommen keine mehrfachen Elemente vor. Dictionaries sind durch Schlüssel :Wert-Paare gekennzeichnet. Mengen werden beim Anlegen wie Dictionaries in geschweifte Klammern eingeschlossen.

 dict = {&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot; }
 menge = {1, 1, 3, 4, 4, 4, &quot;Hallo&quot;}
 
 print(dict)
 print(menge)
 print(dict[&quot;vorname&quot;])

Ausgabe:
 {'vorname': 'Hugo', 'nachname': 'Meister'}
 {1, 3, 4, 'Hallo'}
 Hugo

Geschweifte Klammern ohne Inhalt stellen Dictionaries dar und keine Mengen:

 di = {}
 print(type(di))

Ausgabe:
 &lt;class 'dict'&gt;

Leere Mengen lassen sich mit &lt;code&gt;set()&lt;/code&gt; erzeugen:

 menge = set()      # leere Menge
 print(menge)
 menge.add(&quot;Hallo&quot;) # Element hinzufügen
 print(menge)

Ausgabe:
 set()
 {'Hallo'}

Beispiel (einige Mengenoperationen):
 mengeA = {&quot;Hallo&quot;, &quot;Welt&quot;}
 mengeB = {1, 2, &quot;Welt&quot;, 3}
 
 # Vereinigung
 print(mengeA | mengeB)
 print(mengeA.union(mengeB))
 
 # Durchschnitt
 print(mengeA &amp; mengeB)
 print(mengeA.intersection(mengeB))
 
 # Differenz
 print(mengeA - mengeB)
 print(mengeA.difference(mengeB))
 
 # Symmetrische Differenz
 print(mengeA ^ mengeB)
 print(mengeA.symmetric_difference(mengeB))
 
 # Teilmenge
 print(mengeA.issubset(mengeB))
 
 # Mehrere Elemente hinzu
 mengeA.update([&quot;Super&quot;, 67, 125])
 print(mengeA)
 
 # Element löschen
 mengeA.discard(&quot;Hallo&quot;)
 print(mengeA)

Ausgabe:
 {1, 2, 3, 'Welt', 'Hallo'}
 {1, 2, 3, 'Welt', 'Hallo'}
 {'Welt'}
 {'Welt'}
 {'Hallo'}
 {'Hallo'}
 {1, 2, 3, 'Hallo'}
 {1, 2, 3, 'Hallo'}
 False
 {67, 'Super', 'Welt', 'Hallo', 125}
 {67, 'Super', 'Welt', 125}

Es gibt schon seit &quot;ewigen&quot; Zeiten unveränderbare Mengen, die mittels &lt;code&gt;frozenset&lt;/code&gt; eingeleitet werden. Neu ab Python 3.15 ist dagegen das Pendant &lt;code&gt;frozendict&lt;/code&gt;, das unveränderbare Dictionaries darstellt.

 fdict = frozendict({&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot;})
 fset = frozenset({&quot;A&quot;, 1, &quot;A&quot;})
 
 print(fdict)
 print(fdict[&quot;vorname&quot;])
 print (fset) 
 
 try:
     fdict[&quot;vorname&quot;] = &quot;Max&quot;
     print(fdict[&quot;vorname&quot;])
 except TypeError as e:
     print(f&quot;Fehler: {e}&quot;)
 
 try:
     fset.add(&quot;B&quot;)
     print(fset)
 except AttributeError as e:
     print(f&quot;Fehler: {e}&quot;)

Ausgabe:
 frozendict({'vorname': 'Hugo', 'nachname': 'Meister'})
 Hugo
 frozenset({1, 'A'})
 Fehler: 'frozendict' object does not support item assignment
 Fehler: 'frozenset' object has no attribute 'add'

== List Comprehensions ==
Aus einer Eingabeliste soll eine Ausgabeliste erzeugt werden. Das kann folgendermaßen geschehen.

Mathematische Schreibweise: &lt;math&gt;lc = \{2x|x\in\ \mathbb{N}, 1\le x &lt; 11\}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11)]
 print(lc)

Ausgabe:
 [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Mathematische Schreibweise: &lt;math&gt;lc = \{2x | x \in \mathbb{N}, 1\le x &lt; 11, x \bmod 2 = 0 \}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11) if x%2 == 0]
 print(lc)

Ausgabe:
 [4, 8, 12, 16, 20]

Siehe auch {{W|List Comprehension}}.

== Set Comprehensions ==
Dies ist sehr ähnlich wie im vorigen Abschnitt beschrieben. Es wird aber keine Liste, sondern eine Menge erzeugt.

 sc = {x*2 for x in range(1,11)}
 print(sc)

Ausgabe:
 {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}

== Listen zusammenführen - zip() ==
 li1 = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]
 li2 = [1, 2, 3, 4]
 li3 = [5.5, 6.6, 7.7, 8.8]
 
 z = zip(li1, li2, li3)
 print(z)
 
 li4 = list(z)
 print(li4)

Ausgabe:
 &lt;zip object at 0x00000283B6C6AC80&gt;
 [('A', 1, 5.5), ('B', 2, 6.6), ('C', 3, 7.7), ('D', 4, 8.8)]

== Generatorausdruck ==
 g = (i*2 for i in range(1,11))
 print(g)
 t = tuple(g)
 print(t)
 print(t[1:3])

Ausgabe:
 &lt;generator object &lt;genexpr&gt; at 0x00000241D2A4A5A0&gt;
 (2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
 (4, 6)

== Slicing ==
slice ... Scheibe, Teil, in Scheiben schneiden

Beispiel: Zugriff auf Elemente eines geordneten sequentiellen Objekttyps (Liste, Tupel oder String):

 str1 = &quot;Hallo&quot;
 # Das erste Element wird mit dem Index 0 angesprochen
 # [start (inkl.) : stop (exkl.) : step (default=1)]
 str2 = str1[0:2]
 # Alternativ auch: str2 = str1[:2] 
 print(str2)
 
 tup1 = (0,1,2,3)
 # Das letzte Element hat auch den Index -1, das vorletzte den Index -2 usw.
 tup2 = tup1[-3:-1]
 print(tup2)
 
 lst1 = [[1,  5,  10, 20],
         [30, 40, 50, 60]]
 lst2 = lst1[1][1]
 print(lst2)
 
Ausgabe:
 Ha
 (1, 2)
 40

Beispiel:

 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2])
 print(x[-3]) 
 print(x)
 print(x[:])
 print(x[2:])
 print(x[:2])
 print(x[::-1])

Ausgabe:

 c
 c
 ('a', 'b', 'c', 'd', 'e')
 ('a', 'b', 'c', 'd', 'e')
 ('c', 'd', 'e')
 ('a', 'b')
 ('e', 'd', 'c', 'b', 'a')

Visualisierung:

    '''a'''     '''b'''     '''c'''     '''d'''     '''e'''
 +-----------------------------+
 |  0  |  1  |//'''2'''//|  3  |  4  |
 +-----------------------------+
 | -5  | -4  |/'''-3'''//| -2  | -1  | 
 +-----------------------------+
 |/////////////////////////////|
 +-----------------------------+
 |/////////////''':'''///////////////|
 +-----------------------------+
 |     |     |///////'''2:'''////////|
 +-----------------------------+
 |////''':2'''/////|     |     |     |
 +-----------------------------+
 |\\\\\&lt;--\\\\\'''::-1'''\\\\&lt;--\\\\\|
 +-----------------------------+

Beispiel:
 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2::2])
 print(x[2::-1])
 print(x[2:0:-1])

Ausgabe:

 ('c', 'e')
 ('c', 'b', 'a')
 ('c', 'b')

Hier sieht man sehr schön, dass beim letzen &lt;code&gt;print&lt;/code&gt;-Befehl die 0, die in diesem Fall den Buchstaben &quot;a&quot; repräsentiert, als letzer Wert nicht mehr dazugehört (wie weiter oben angedeutet ist der End- oder Stoppwert exklusiv). Will man den Buchstaben &quot;a&quot; dazunehmen, so ist die vorletzte Zeile die richtige.

Beispiel: Umdrehen von Strings

 str1 = &quot;Hallo&quot;
 str2 = str1[::-1]
 print(str2)

Ausgabe:
 ollaH

Mit zweidimensionalen Listen/Tupels wird das Ganze schon bedeutend komplexer.

Beispiel: Verkettetes Slicing

 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
     
 print(A[2::][::2])

Ausgabe:

 [['20', '21', '22', '23'], ['40', '41', '42', '43']]

Das erste Slicing erstellt folgenden Slice:

 [[&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
  [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
  [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]

Das zweite Slicing wird dann auf diesen Slice angewendet und ergibt das genannte Endergebnis. Will man Spalten statt Zeilen, so funktioniert dieser direkte Weg nicht. Man verwendet dann List Comprehensions oder die NumPy-Bibliothek. Diese Bibliothek erlaubt [[Ing_Mathematik:_Python#Zugriff_auf_Matrizenelemente|zweidimensionales Slicing]]. Sie wird erst später bei den Grafiken eingeführt. Deshalb wird hier dazu noch kein Beispiel gezeigt.

= Objektorientierte Programmierung =
{{Wikipedia|Objektorientierte Programmierung}}

* {{W|Klasse (Objektorientierung)|Klasse}} ... die Schablone oder der Bauplan, enthält Methoden und Attribute
* {{W|Objekt (Programmierung)|Objekt}} ... eine Klasseninstanz (die konkrete Ausprägung der Klasse)
* {{W|Attribut (Programmierung)|Attribute}} ... die Eigenschaften eines Objekts
* {{W|Methode (Programmierung)|Methoden}} ... die Aktionen (Operationen), die ein Objekt ausführen kann
* {{W|Vererbung (Programmierung)|Vererbung}} ... neue Klassen (Subklassen, Unterklassen, abgeleitete Klassen) aus vorhandenen Klassen (Superklassen, Oberklassen, Basisklassen, Elternklassen) ableiten. Ermöglicht den Aufbau von Klassenhierarchien. Die Subklasse &quot;erbt&quot; Attribute und Methoden von der Superklasse. Python unterstützt (so wie C++, aber im Gegensatz zu Java) Mehrfachvererbung.

== UML ==
* {{W|Unified Modeling Language|UML}} ... '''U'''nified '''M'''odeling '''L'''anguage, eine Modellierungssprache. Die UML enthält zahlreiche Diagrammarten, um Programme zu modellieren. Im Nachfolgenden wird nur das {{W|Klassendiagramm}} verwendet.

[[File:UmlCd Klasse-3.svg|300px]]

* {{W|Sichtbarkeit (Programmierung)|Sichtbarkeit}}:
** + ... public (öffentlich)
** - ... private
** # ... protected 

* {{W|Attribut_(UML)#Attribute_für_Instanzen_und_für_Klassen|Klassenattribute}} (statische Attribute): Werden nur einmal pro Klasse angelegt. Im Klassendiagramm werden sie unterstrichen.

[[File:Attribute-3.png|200px]]

* Vererbung:

&lt;gallery&gt;
InheritancePgmUML.svg | Abgeleitete Klasse erbt von Basisklasse (Einfachvererbung)
Diamond inheritance.svg | D erbt von B und C (Mehrfachvererbung). B und C erben von A (Einfachvererbung)
&lt;/gallery&gt;

Für weitergehende Betrachtungen zur UML wird auf Spezialliteratur verwiesen, z.B.:
* Seidl et al.: UML@Classroom. dpunkt, 2012, ISBN 978-3-89864-776-2
* Rupp et al.: UML 2 glasklar. Hanser, 4. Aufl., 2012, ISBN 978-3-446-43057-0

== Eine einfache Klasse ==

[[Datei:PythonIng_uml1.svg | 200px]]

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
 
 fahr = Fahrzeug(150, 90)
 
 print(fahr.convertGeschw())
 
Ausgabe:
 41.666666666666664

Die Klasse Fahrzeug wird durch das class-Schlüsselwort eingeleitet. raeder ist ein Klassenattribut und public. __init__ wird bei der Objekterzeugung automatisch aufgerufen (ist der sogenannte Konstruktor). Man achte darauf, dass diese Methode immer mit zwei Unterstrichen eingeleitet und abgeschlossen wird. Instanzattributen wird das Wort self vorangestellt. Wir sehen uns z.B. das Attribut self.__geschwind an. Auch hier werden zwei Unterstriche verwendet. Das bedeutet, dass dieses Attribut strikt/stark private ist. Wird nur ein Unterstrich verwendet, so deutet dies auf schwach/weakly private hin. Letzteres wird in Python deutlich häufiger verwendet. Bei den Methoden wird immer self als erster Parameter angegeben. Beim Aufruf der entsprechenden Funktion wird das self aber nicht berücksichtigt.

Besonderheiten bei stark und schwach private:
* '''stark private''':
** zwei führende Unterstriche
** Name Mangling: Name wird zu &lt;code&gt;_Klassenname__variablenname&lt;/code&gt;
** Schutz vor Namenskollisionen bei Vererbung
** am Ende des Namens dürfen keine zwei Unterstriche verwendet werden. Das wären dann Magic Methods oder Dunder-Methods (z.B. __init__). Diese sind public.

* '''schwach private''':
** ein führender Unterstrich
** Name bleibt gleich
** ist nur ein Hinweis an die Programmierer, kein starker Schutz
** &lt;code&gt;from modul import *&lt;/code&gt;: Objekte mit einem führenden Unterstrich werden standardmäßig nicht importiert
** Standard für die Kapselung bei Python. Schätzung: Weit mehr als 80% der nicht-öffentlichen Attribute/Methoden werden als schwach private deklariert. Weniger als 5-10% als stark private (Quelle: Google KI)

== Klassen importieren ==
Häufig ist es sinnvoll und übersichtlicher Klassen in eigenen Dateien zu speichern. Das sind dann eigene Module. Abgespeichert werden Sie mit der Endung py, wie bisher auch praktiziert. Aufgerufen werden Sie mit der import-Anweisung. Dann ist aber nur der Dateiname ohne Endung py zu verwenden. Klarer wird das mit einem Beispiel.

Datei c:\tmp\fahrzeug.py

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6

Datei c:\tmp\test1.py

 import fahrzeug
 fahr = fahrzeug.Fahrzeug(150, 90)
 print(fahr.convertGeschw())

Ausgabe:
 41.666666666666664

Die üblichen import-Anweisungen lauten wie folgt:
{| {{prettytable}}
! import-Befehl
! Instanz
|-
| import xyz      || xyz.Klasse
|-
| import xyz as x || x.Klasse
|-
| from xyz import Klasse || Klasse
|-
| from xyz import * || Klasse 
|}

Der Vorteil der ersten beiden import-Anweisungen ist, dass es kaum zu Namenskollisionen kommen kann. Dafür hat man bei den letzten beiden Varianten weniger Tipparbeit.

== Vererbung ==
=== Einfachvererbung ===

[[Datei:PythonIng_uml2.svg | 200px]]

Datei fahrzeug.py:
 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
        
     def setLeistung(self, leistung):
         self.__leistung = leistung
        
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
        
 class Luftfahrzeug(Fahrzeug):
     def __init__(self, geschwindigkeit, leistung, fluegel):
         super().__init__(geschwindigkeit, leistung)
         self.__flueg = fluegel
     
     def getFlueg(self):
         return self.__flueg

Datei test1.py:
 import fahrzeug
 fahr = fahrzeug.Luftfahrzeug(150, 90, 4)
 print(fahr.getFlueg())

Ausgabe:
 4

=== Mehrfachvererbung ===
Mit Python ist auch Mehrfachvererbung möglich, z.B.:

 class A:
     def _printA(self):
         print(&quot;Klasse A&quot;)
 
 class B:
     def _printB(self):
         print(&quot;Klasse B&quot;)
 
 class C(A,B):
     def __init__(self):
         self._printA()
         self._printB()
 
 c = C()

Ausgabe:

 Klasse A
 Klasse B

Die Klasse C erbt von A und B. In UML sieht das in etwa so aus:

 +-----------------------------+   +-------------------------+
 |            A                |   |          B              |
 +-----------------------------+   +-------------------------+
 |                             |   |                         |
 +-----------------------------+   +-------------------------+
 | # printA()                  |   | # printB()              |
 +-----------------------------+   +-------------------------+
                           .              .
                          / \            / \
                          ---            ---
                           |              |
                           |              |
                        +---------------------+
                        |          C          |
                        +---------------------+
                        |                     |
                        +---------------------+
                        |                     |
                        +---------------------+

&lt;code&gt;printA()&lt;/code&gt; und &lt;code&gt;printB()&lt;/code&gt; sind schwach private (in UML als &lt;code&gt;protected&lt;/code&gt; mit einem # dargestellt). Es ist aber zu beachten, dass schwach private nur Konvention ist. Praktisch könnte man auch von außerhalb auf diese Methoden zugreifen. Das soll man aber nicht tun, und das wird in Python durch einen Unterstrich angedeutet.

== Statische Attribute, statische Methoden und Klassenmethoden ==
Beispiel:

 class Math:
     pi = 3.14159265
     cnt = 0
     
     @staticmethod
     def expo():
         return 2.71828183
    
     @classmethod    
     def counterPlus(cls):
         cls.cnt += 1
        
 print(Math.pi)
 print(Math.expo())
 
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)

Ausgabe:

 3.14159265
 2.71828183
 1
 2
 3

Statische Attribute und Methoden, bzw. Klassenmethoden, sind direkt einer Klasse zugeordnet und nicht einem Objekt. Der Unterschied zwischen statischen Methoden und Klassenmethoden ist, dass statische Methoden nicht auf Klassenattribute (bzw. statische Attribute) zugreifen können, Klassenmethoden aber schon. &lt;code&gt;pi&lt;/code&gt; und &lt;code&gt;cnt&lt;/code&gt; sind statische Attribute. &lt;code&gt;expo()&lt;/code&gt; ist eine statische Methode. &lt;code&gt;counterPlus(cls)&lt;/code&gt; ist eine Klassenmethode. Die Bezeichnung des Parameters als &lt;code&gt;cls&lt;/code&gt; ist reine Konvention, man sollte sich aber daran halten. &lt;code&gt;@staticmethod&lt;/code&gt; und &lt;code&gt;@classmethod&lt;/code&gt; nennt man auch Dekoratoren.

= Grafiken zeichnen =
Für das Zeichnen von Grafiken wird hier das Modul &lt;code&gt;matplotlib&lt;/code&gt; verwendet. &lt;code&gt;matplotlib&lt;/code&gt; ist ein externes Modul und muss vor der ersten Verwendung installiert werden. Das geht so:

# Starten Sie ein Terminal (bei Windows die Eingabeaufforderung).
# Führen Sie darin folgenden Befehl aus &lt;code&gt;c:\devel\Python\Scripts\pip.exe install matplotlib&lt;/code&gt;

pip ist übrigens der Paketmanager von Python ({{W|Pip_(Python)}}). 

Optimalerweise installieren wir auch gleich das Modul &lt;code&gt;numpy&lt;/code&gt; (Numerical Python). Wir werden es im Folgenden oft benötigen (nicht nur bei den Grafiken). Das funktioniert vom Prinzip her genauso, wie für &lt;code&gt;matplotlib&lt;/code&gt; gezeigt.

&lt;small&gt;Verwenden Sie Spyder, so sind diese Schritte nicht nötig. Spyder inkludiert diese Pakete standardmäßig. Unter openSUSE Tumbleweed lassen sich diese Pakete mittels YaST oder zypper installieren.&lt;/small&gt;

== 2D ==
=== Graph einer Funktion ===
Es soll die cosh-Funktion im Intervall &lt;math&gt;x\in[-3,3]&lt;/math&gt; gezeichnet werden. Der Programmcode lautet in der einfachsten Form:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x)
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:PythonIng_cosh1.jpg]]

Der Code ist quasi selbsterklärend. Das Untermodul pyplot des matplotlib-Moduls und das numpy-Modul werden importiert. x läuft von -3 bis +3. y wird für jeden x-Wert per Formel ausgerechnet. &quot;plt.plot()&quot; ist der Zeichenbefehl. &quot;plt.show&quot; ist notwendig, um das Fenster mit der Grafik anzuzeigen.
Die Schrittweite 0.1 wurde so gewählt, um einen ausreichend glatten Verlauf des Graphen zu gewährleisten. Das ist immer ein Kompromiss zwischen Berechnungszeit und Ansehnlichkeit. Testen Sie einfach ein paar verschiedene Werte, um ein Gefühl dafür zu zu bekommen. &quot;plt.grid()&quot; zeichnet ein Gitter in die Grafik (kann auch weggelassen werden).
Die Bezeichnungen plt und np könnten auch anders gewählt werden. Es ist aber Konvention, diese so wie hier gezeigt zu wählen. Die &quot;arange&quot;-Funktion aus der NumPy-Bibliothek wird später ein bisschen genauer behandelt (siehe [[Ing_Mathematik:_Python#Zahlenfolgen|Zahlenfolgen]]).  

&lt;small&gt;Mit der im obigen Bild gezeigten Menüleiste kann die dargestellte Grafik nachträglich noch geändert werden (Zoom, Pan, Achsenparameter, Kurvenparameter etc.). Natürlich kann man das alles auch direkt programmieren. Wie das funktioniert wird ansatzweise etwas später gezeigt.&lt;/small&gt;

Ein etwas komplexeres Beispiel ist Folgendes:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x) + 2**x
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:
[[Datei:PythonIng_cosh4.png]]

Man beachte, dass im Gegensatz zu Octave und Julia der ominöse Punkt (.) bei 2**x mit Python nicht benötigt wird. Das macht das Programmiererleben etwas einfacher.

Die Farbe des Graphen kann man über den &lt;code&gt;color&lt;/code&gt;-Schalter einstellen, z.B. auf rot setzen:
 plt.plot(x, y, color=&quot;red&quot;)

Das ist nur eine Möglichkeit, es gibt auch andere, z.B. mittels
* hexadezimaler Zahl, z.B. &lt;code&gt;color=&quot;#ff0000&quot;&lt;/code&gt;
* Kurzform, z.B. &lt;code&gt;&quot;r&quot;&lt;/code&gt;

Statt &lt;code&gt;color&lt;/code&gt; kann auch die Kurzform &lt;code&gt;c&lt;/code&gt; verwendet werden.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie diese &quot;Farbspielereien&quot; am Computer aus.

=== Graphen mehrerer Funktionen und weiteres ===
==== Mehrere Funktionen in einen Plot zeichnen ==== 
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh2.png]]

Um die Linienstile etwas individueller zu gestalten, ist folgender Programmcode gedacht: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;, lw=3, ls=&quot;--&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh3.png]]

Einige weitere Bespiele zu &lt;code&gt;ls&lt;/code&gt;&lt;/code&gt;:
* - ... durchgezogene Linie
* -. ... Strichpunkt-Linie
* dashed ... gestrichelte Linie 

==== Marker ====
Desweiteren kann man Marker verwenden.

Beispiel:

 import matplotlib.pyplot as plt
 
 plt.plot(10, 10, &quot;ob&quot;, markersize=30)
 plt.plot(20,20, &quot;.r&quot;)
 plt.plot(30,30, &quot;Dg&quot;, ms=15)
 plt.plot(40, 40, &quot;ok&quot;, ms=20, mec=&quot;#FF5733&quot;, mew=3)
 plt.plot(50, 50, &quot;vk&quot;, ms=20, mec=&quot;yellow&quot;, mew=3)
 plt.grid()
 plt.show()


Das erste Zeichen im String nach den Koordinaten im plot-Befehl symbolisiert die Form (z.B. o für einen Kreis). Das zweite Zeichen steht für die Farbe (z.B. b für blue). &lt;code&gt;markersize&lt;/code&gt; oder &lt;code&gt;ms&lt;/code&gt; setzt die Größe des Markers.

Ausgabe:

[[Bild:PythonIng_formatpara1.svg|200px]]

Einige weitere Marker:
* * ... Stern
* + ... Plus
* h oder H ... Sechseck

Man kann mit den Parametern 
* &lt;code&gt;markeredgecolor&lt;/code&gt; oder kurz &lt;code&gt;mec&lt;/code&gt; die Farbe des Markerrandes
* &lt;code&gt;markeredgewidth&lt;/code&gt; oder kurz &lt;code&gt;mew&lt;/code&gt; die Dicke des Randes
* &lt;code&gt;markerfacecolor&lt;/code&gt; oder kurz &lt;code&gt;mfc&lt;/code&gt; die Innenfarbe des Markers
bestimmen.

=== Funktion in Parameterdarstellung ===
Es soll die archimedische Spirale &lt;math&gt;x = t \cos(t), y = t  \sin(t)&lt;/math&gt; im Intervall &lt;math&gt;[0, 6\pi[&lt;/math&gt; gezeichnet werden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
  
 plt.show()

[[Datei:PythonIng_spirale1.png]]

Diese Darstellung erscheint verzerrt. Will man gleiche Achsenskalierungen, so kann man den plt.axis()-Befehl verwenden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
 plt.axis(&quot;equal&quot;)
 
 plt.show()
 
[[Datei:PythonIng_spirale2.png]]

=== Funktion in Polardarstellung ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 fig = plt.figure()
 ax = fig.add_subplot(projection=&quot;polar&quot;)
 r = np.arange(0, 1, 0.01)
 theta = r**3
 line = ax.plot(theta, r)
 
 plt.show()

[[Datei:PythonIng_polar1.png]]

=== Logarithmische Achsenskalierung ===
==== Semilog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.semilogy()
 plt.show()

Ausgabe:

[[Datei:PythonIng_semilog1.png]]

==== LogLog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.loglog()
 plt.show()

[[Datei:PythonIng_loglog1.png]]

=== Gefüllte Fläche ===
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.arange(0, 3, 0.1)
 
 y1 = 3*x - 1
 y2 = x**2
 
 plt.plot(x, y1, x, y2, color='black')
 plt.fill_between(x, y1, y2, where=y1&gt;=y2)
 
 plt.show()

[[Datei:PythonIng_gefuellt.png]]

=== Linien, Pfeile, Rechtecke, Kreise und Texte ===
 import matplotlib as mpl
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 r = mpl.patches.Rectangle((0, 0), 3, 3, angle=30, fill=False)
 c = mpl.patches.Circle((4, 4), 2, fill=False)
 
 ax.add_patch(r)
 ax.add_patch(c)
 ax.plot([-2, 7], [-2, 0], color=&quot;black&quot;)
 ax.arrow(0, 7, 5, 0, length_includes_head=True, head_width=0.5, head_length=1.5,
          color=&quot;black&quot;)
 
 ax.set_aspect(&quot;equal&quot;)
 
 plt.axis([-3, 8, -3, 8])
 plt.show() 

[[Datei:PythonIng_linien_pfeile_etc.png]]

Text kann mit &lt;code&gt;ax.text(x, y, &quot;Text&quot;)&lt;/code&gt; hinzugefügt werden, bspw.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 ax.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

Oder einfacher auch ohne &lt;code&gt;subplots&lt;/code&gt;

 import matplotlib.pyplot as plt
 
 plt.text(0.1, 0.1, &quot;Hallo&quot;)
 plt.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

[[Datei:PythonIng_text1.png]]

Auch Sonderzeichen (griechische Buchstaben etc.) können verwendet werden (siehe dazu auch [https://matplotlib.org/stable/users/explain/text/mathtext.html]).

 import matplotlib.pyplot as plt
 
 plt.text(.3, .5,
          r'$\Omega\ \psi\ \oint\ \nabla\ \dot a\ \frac{a}{b}\ a_b$',
          size=&quot;20&quot;)
 plt.show() 

[[Datei:PythonIng_text20.svg]]

Jetzt wird noch gezeigt, wofür &lt;code&gt;subplots&lt;/code&gt; sinnvoll eingesetzt werden können.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(0.1, 0.1, &quot;Hallo&quot;)
 ax[1].text(0.1, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
            rotation=30.0)
 
 plt.show()

[[Datei:PythonIng_text2.png]]

=== Anmerkungen hinzufügen ===
Anmerkungen (engl. annotations) lassen sich mit matplotlib einfach hinzufügen. Unter Anmerkung wird hier ein Pfeil mit Text verstanden.

Beispiel:

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 ax.plot([1,10], [1,10])
 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
             arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0))
 plt.show()

Ausgabe:

[[Datei: PythonIng_ann1.svg|400px]]

&lt;code&gt;shrink&lt;/code&gt; verkürzt den Pfeil. Sinnvoll sind beim obigen Beispiel Werte irgendwo zwischen 0.0 und 0.3.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie verschiedene Pfeillängen aus. 

Die Schriftgröße verändern können Sie übrigens mit &lt;code&gt;fontsize&lt;/code&gt; oder &lt;code&gt;size&lt;/code&gt;, z.B.

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0), fontsize=25)

Eine andere Schreibweise für Dictionaries, die wir weiter oben schon kennengelernt haben, die wir aber nochmals explizit aufschreiben wollen, ist

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops={&quot;facecolor&quot;:&quot;red&quot;, &quot;shrink&quot;:0.0})

=== Figure, Axes etc.===
[[Bild:PythonIng_figure33.svg|350px]]

* fig (figure) ... das übergeordnete Fenster
* ax (axes) ... &quot;Plot&quot;, das eigentliche Zeichenfenster
* axis ... die Koordinatenachsen
* spine ... Begrenzungslinien des Zeichenfensters
* tick ... Markierung an den Achsen des Zeichenfensters

Beispiel (eine figure mit 6 axes, ax-Titel, y-axis-Titel):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=3, ncols=2)
 
 ax[0][0].text(0.1, 0.5, &quot;11&quot;)
 ax[0][1].text(0.1, 0.5, &quot;12&quot;)
 ax[1][0].text(0.1, 0.5, &quot;21&quot;)
 ax[1][1].text(0.1, 0.5, &quot;22&quot;)
 ax[2][0].text(0.1, 0.5, &quot;31&quot;)
 ax[2][1].text(0.1, 0.5, &quot;32&quot;)
 
 ax[0][0].set(ylabel=&quot;y-label&quot;, title=&quot;axes 1&quot;)
 
 plt.show()

[[Bild:PythonIng_figure34.png|350px]]

Beispiel (Achsenbereiche setzen):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 
 ax[0].axis((-1, 10, 1, 12))
 
 plt.show()

[[Bild:PythonIng_figure35.svg|350px]]

Beispiel (Gitter einschalten): 

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 ax[0].axis((-5, 10, 1, 12))
 ax[0].minorticks_on()
 ax[0].grid(which='minor')
 ax[1].grid(which='major')
 plt.show()

[[Bild:PythonIng_figure36.svg|350px]]

Beispiel (ticks setzen)

 import matplotlib.pyplot as plt
 import matplotlib.ticker as tick
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 pos = [0, .2, .5]
 lab = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
 
 ax.xaxis.set_major_locator(tick.FixedLocator(pos))
 ax.xaxis.set_major_formatter(tick.FixedFormatter(lab))
 
 plt.show()

[[Bild:PythonIng_figure37.svg|350px]]

Beispiel (Achsenkreuz beliebig setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 ax.spines['top'].set_color('none')
 ax.spines['right'].set_color('none')
 ax.spines['bottom'].set_position(('data', 0.3))
 ax.spines['left'].set_position(('data', 0.5))
 
 plt.show()

[[Bild:PythonIng_figure38.svg|350px]]

Beispiel (Inset):

 import matplotlib.pyplot as plt
 
 # Hauptplot erstellen
 fig, ax = plt.subplots()
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 
 # Inset hinzu:
 axin = ax.inset_axes([0.4, 0.4, 0.3, 0.3])
 axin.text(0, 0, &quot;Servus&quot;)
 axin.plot()
 
 plt.show()

[[Bild:PythonIng_figure40.svg|350px]]

Beispiel (Hintergrundfarben setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.set_facecolor(&quot;green&quot;)
 fig.set_facecolor(&quot;yellow&quot;)
 
 plt.plot([1, 3], [6, 8])
 plt.show()

[[Bild:PythonIng_figure39.svg|300px]]

=== GridSpec ===
Mit figures und axes lassen sich schon jede Menge an Grafikdetails einstellen. GridSpec ist dann der Turbo oder Raketenantrieb den matplotlib eingebaut hat. Naja, vielleicht ist das etwas übertrieben, aber GridSpec ist sozusagen ein flexibler Layout-Manager. Bisher haben wir immer gleich große axes gezeichnet. Mit GridSpec können wir Subplots über mehrere Zeilen und Spalten ziehen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 gs = fig.add_gridspec(3, 3)
 
 ax1 = fig.add_subplot(gs[0, :])
 ax1.set_title(&quot;Bereich 1: gs[0, :]&quot;)
 
 ax2 = fig.add_subplot(gs[1:, 0])
 ax2.set_title(&quot;Bereich 2: gs[1:, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 1:])
 ax3.set_title(&quot;Bereich 3: gs[1, 1:]&quot;)
 
 ax4 = fig.add_subplot(gs[2, 1:])
 ax4.set_title(&quot;Bereich 4: gs[2, 1:]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec1.svg|350px]]

Erklärung zu &lt;code&gt;(gs[zeile, spalte])&lt;/code&gt;: Slicing; damit legen Sie fest, welche Zellen ein Subplot belegt. Achtung! Die Indizes beginnen bei 0 und nicht bei 1 (d.h., die erste Zeile/Spalte hat den Index 0)
* : ... alle 
* 1: ... 1 bis Ende
* etc.

&lt;code&gt;constrained_layout=True&lt;/code&gt; sorgt dafür, dass sich die Subplots nicht überlappen.

Aber auch die Spaltenbreiten und Zeilenhöhen lassen sich anpassen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 
 # Verhältnis erste zu zweite Zeile = 1.5:1
 # Verhältnis erste zu zweite Spalte  = 1:4
 gs = fig.add_gridspec(2, 2, figure=fig, height_ratios=[1.5, 1], width_ratios=[1, 4])
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax1.set_title(&quot;Bereich 1: gs[0, 0]&quot;)
 
 ax2 = fig.add_subplot(gs[0, 1])
 ax2.set_title(&quot;Bereich 2: gs[0, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 0])
 ax3.set_title(&quot;Bereich 3: gs[1, 0]&quot;)
 
 ax4 = fig.add_subplot(gs[1, 1:])
 ax4.set_title(&quot;Bereich 4: gs[1, 1]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec2.svg|350px]]

Auch die Ränder lassen sich einstellen.

Beispiel 1:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.1, right=0.9, bottom=0.1,
                        top=0.9, wspace=0.2, hspace=0.2)
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec3.svg|300px]]

* hspace ... height space, vertikaler Abstand zwischen den Zeilen
* wspace ... width space, horizontaler Abstand zwischen den Spalten

Und im Vergleich dazu Beispiel 2:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.3, right=0.7, bottom=0.3, 
                        top=0.7, wspace=0.3, hspace=0.3) 
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec4.svg|300px]]

Es gibt noch einige weitere Details, die sich mit GridSpec variieren lassen (z.B. SubGridSpec ... verschachtelte Grid-Layouts). Aber wir belassen es vorerst dabei. Das bisher Gezeigte sollte für die meisten Probleme ausreichend sein.

=== Aufgaben ===
* Zeichnen Sie die Strophoide &lt;math&gt;x = \frac{a(t^2-1)}{t^2+1}, y = \frac{at(t^2-1)}{t^2+1}, a = 2, -3 \leq t \leq 3&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_strophoide.jpg|300px|center]]

* Zeichnen Sie die verschlungene Hypozykloide &lt;math&gt;x = (R-r)\cos t + c\cos\frac{R-r}{r}t, y = (R-r)\sin t - c\sin\frac{R-r}{r}t, c = 3, r = 2, R = 6, -15 \leq t \leq 15&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_hypozykloide.jpg|300px|center]]

* Testen Sie bei den obigen Übungsaufgaben verschiedene Linienstile und Farben. Farben können mit dem plt.plot()-Parameter color gewählt werden.

* Testen Sie bei den obigen Übungsaufgaben verschiedene Werte für a, c, r und R.

* Zeichnen Sie folgendes Bild (die Achsenbeschriftungen positionieren Sie z.B. mit den Befehlen &lt;code&gt;ax.set_xlabel(&quot;x&quot;, loc=&quot;right&quot;); ax.set_ylabel(&quot;y&quot;, loc=&quot;top&quot;)&lt;/code&gt;):

[[Bild:PythonIng_aufgabe24.svg|400px|center]] 

* Zeichnen Sie mit Python, matplotlib und NumPy folgendes Bild:

[[Bild:PythonIng_figure41.svg|400px|center]]

* Zeichnen Sie mit GridSpec ein Layout, das in etwa wie folgendes aussieht (&lt;code&gt;height_ratios=[1, 2], width_ratios=[2, 1]&lt;/code&gt;):

[[Bild:PythonIng_aufgabe23.svg|300px|center]]

== 3D ==
=== Räumliche Kurven ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0, 6*np.pi, 0.1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 z = t
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot(x, y, z)
 
 plt.show()

[[Datei:PythonIng_raumkurve1.png]]

=== Flächen ===
 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche1.png]]

Das Ganze in Netzdarstellung läßt sich so programmieren: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.5)
 y = np.arange(0, 10, 0.5)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_wireframe(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche2.png]]

Ein etwas komplexeres Beispiel:

 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0.1, 10, 0.1)
 y = np.arange(0.1, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z1 = np.sin(x) + 3 * np.cos(y)
 z2 = np.sin(x) + np.log(y)
 z3 = x + np.cos(y)
 z4 = x**2 - y
  
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;}, nrows=2, ncols=2)
 
 ax[0][0].plot_surface(x, y, z1)
 ax[0][1].plot_surface(x, y, z2)
 ax[1][0].plot_surface(x, y, z3)
 ax[1][1].plot_surface(x, y, z4)
 
 plt.show()

[[Datei:PythonIng_subplot1.png]]

Man beachte, dass man die Unterbilder im Bild nach dem Ausführen des Scripts z.B. mit der mittleren Maustaste einzeln drehen, oder über die Einträge in der Menüzeile einzeln bearbeiten kann. Mit ein paar Zeilen Programmtext lässt sich also eine Menge an Funktionalität generieren.

Die Farbgebung lässt sich über &lt;code&gt;colormaps&lt;/code&gt; variieren.

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm)
 
 plt.show()

[[Datei:PythonIng_colormap1.png]]

Es gibt eine Menge an Colormaps, z.B. &lt;code&gt;plasma, Greys, Dark2, ocean&lt;/code&gt;. Zwecks detaillierterer Infos siehe die matplotlib-Dokumentation. &lt;small&gt;Verwendet man die IDE namens IDLE, so gibt es dort auch die automatische Codevervollständigung. D.h. es werden alle Möglichkeiten (in unserem Fall nach dem Eintippen von &lt;code&gt;cm.&lt;/code&gt; alle verfügbaren Colormaps) angezeigt.&lt;/small&gt;

Die &quot;edgecolor&quot; und Linienbreite können auch frei gewählt werden:

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm, edgecolor=&quot;black&quot;, linewidth=1.0)
 
 plt.show()

[[Datei:PythonIng_colormap2.png]]

=== Höhenlinien ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 ax.contour(x, y, z)
 
 plt.show()

[[Datei:PythonIng_höhenlinien1.png|400px]]

Etwas abgewandelt sieht das so aus: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contour(x, y, z)
 ax.clabel(hl, inline = True)
 
 plt.show()

[[Datei:PythonIng_höhenlinien2.png|400px]]

Und noch eine Variante (mit einem Farbbalken) sei gezeigt. 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contourf(x, y, z)
 fig.colorbar(hl) 
 
 plt.show()

[[Datei:PythonIng_höhenlinien5.svg|400px]]

=== Aufgaben ===
* Zeichnen Sie die räumliche Kurve &lt;math&gt;x = 2 \cdot \cosh(t)&lt;/math&gt;, &lt;math&gt;y = 5 \cdot \sin(t)&lt;/math&gt;, &lt;math&gt; z = t^{2} - t&lt;/math&gt;, &lt;math&gt;0 \leq t \leq 3\pi&lt;/math&gt;.
* Zeichnen Sie die Fläche &lt;math&gt;z = \log(x) + \cos(y)&lt;/math&gt;.

== Animationen und fortgeschrittenes 3D ==
=== Mit matplotlib ===
Auch mit matplotlib sind Animationen möglich. Das ist ein bisschen komplizierter und wird deshalb hier nur mit einem sehr einfachen Beispiel dargestellt (bei Interesse siehe z.B. auch das [https://matplotlib.org/stable/users/explain/animations/animations.html#animations Animations using Matplotlib-Tutorial]).

 import matplotlib.pyplot as plt
 import matplotlib.animation as ani
 import matplotlib
 import numpy as np
 
 def update(frame):
     line.set_xdata(x[:frame])
     line.set_ydata(y[:frame])
     return (line)
 
 fig, ax = plt.subplots()
 
 x = np.arange(0, 10, .1)
 y = np.sin(x)
 
 line, = ax.plot(x[0], y[0])
 ax.set(xlim=[0, 10], ylim=[-1, 1])
 
 a = ani.FuncAnimation(fig=fig, func=update, frames=100, interval=20)
 plt.show()
 
 # Speichere die Animation in einem animierten GIF (optional)
 a.save(filename=&quot;c:/tmp/PythonIng_anim5.gif&quot;, writer=&quot;pillow&quot;)

[[Datei:PythonIng_anim5.gif]]

Es wird eine Sinuskurve auf den Bildschirm gezeichnet. In der letzten Zeile wird diese Animation in ein animiertes GIF gespeichert. Das ist natürlich optional und kann auch weggelassen werden.

=== Mit VPython ===
Aber auch mit dem Modul VPython lassen sich einfache 3D-Animationen erstellen. VPython ist ein externes Modul, das vorab installiert werden muss. Unter openSUSE Tumbleweed gibt es dzt. kein entsprechendes rpm-Paket. Die übliche Methode der Installation mittels YaST oder zypper ist somit nicht möglich. Auch eine direkte Verwendung von pip führt nur zu einer Fehlermeldung (&lt;code&gt;error: externally-managed-environment&lt;/code&gt;). Es empfiehlt sich dort folgende Vorgehensweise:
# Erstelle zuerst eine virtuelle Umgebung, z.B.: &lt;code&gt;python3.11 -m venv ~/tmp/venv1&lt;/code&gt;
# Wechsle das Verzeichnis: &lt;code&gt;cd ~/tmp/venv1/bin&lt;/code&gt;
# Installiere das entsprechende Paket: &lt;code&gt;./pip install vpython&lt;/code&gt;
# Führe das entsprechende Skript aus: &lt;code&gt;./python ~/tmp/test1.py&lt;/code&gt;

Aktuell (März 2026) ist dieses Programmpaket lt. der [https://vpython.org/presentation2018/install.html VPython-Homepage] nur für die Python-Versionen 3.8 bis 3.12 verfügbar.

Ein Beispiel zu einer einfachen Animation wird nachfolgend geliefert.

 from vpython import *
 
 scene.width = 1200
 scene.height = 600
 scene.center = vector(20,0,0)
 scene.background = color.white
 
 cylinder(pos=vector(0,0,0), axis=vector(20,0,0), radius=5, 
         color=color.blue)
 cone(pos=vector(0,0,0), axis=vector(-10,0,0), radius=5, 
         color=color.blue)
 helix(pos=vector(20,0,0), axis=vector(40,0,0), radius=2, 
         coils=10, thickness=0.5, color=color.blue)
 
 ball = sphere(pos=vector(20,0,0), color = color.green, radius = 1)
 ball.p = vector(0.15, 0, 0)
 
 toc = True
 
 while True:
     rate(200)
     if(ball.pos.x &lt;= 60 and toc == True):
         ball.pos += ball.p
     else:
         toc = False
         ball.pos -= ball.p
         if(ball.pos.x &lt;= 20 and toc == False):
             toc = True

[[Datei:PythonIng_vpython_anim.JPG]]

Idealerweise öffnet sich beim Ausführen des Scripts ein Browserfenster. Darin wird die programmierte Animation gezeigt (siehe auch den obigen Screenshot). Eine Größenänderung können Sie mit der mittleren Maustaste initiieren. Die Szenerie drehen können Sie mit der rechten Maustaste.

=== Mit build123d ===
Hiermit lassen sich einfach 3D-Modelle für CAD-Systeme erstellen. [https://build123d.readthedocs.io/en/latest/ build123d] ist ein externes Modul und muss vorab, wie schon für mehrere andere Module gezeigt, installiert werden (pip, venv etc.).

Beispielcode:

 from build123d import *
 
 # Bauteil
 with BuildPart() as bauteil: 
     # Zylinder erstellen
     Cylinder(100, 60)
        
     # Bohrung
     with BuildSketch(bauteil.faces().sort_by(Axis.Z)[-1]) as loch:
         Circle(radius=10)
     # negativ extrudieren
     extrude(amount=-60, mode=Mode.SUBTRACT)
     
     # Dem Bauteil z.B. die Farbe rot zuweisen
     # bauteil.part.color = Color(&quot;red&quot;, alpha=1.0)
 
     # Fertiges Modell exportieren
     export_step(bauteil.part, &quot;bauteil.step&quot;)

Ausgabe ({{W|Standard for the exchange of product model data | STEP}}-Datei, z.B. in {{W|FreeCAD}} importiert, Screenshot):

[[Datei:PythonIng_build123d.jpg | 300px]]

FreeCAD ist ein freies 3D-CAD-System. Die [[Ing_Mathematik:_Python#FreeCAD | Makroprogrammierung]] in diesem System wird später noch gezeigt. STEP steht für &quot;'''St'''andard for the '''e'''xchange of '''p'''roduct model data&quot; und ist ein Datenaustauschformat.

=== Mit VTK ===
Komplexer, aber auch mächtiger als VPython ist die Verwendung von VTK ('''V'''isualization '''T'''ool'''k'''it). Genauer gesagt des Python-Wrappers von VTK. Dieses externe Python-Modul muss vorab installiert werden (z.B. mittels YaST, pip oder in eine virtuelle Umgebung). VTK ist eine Softwarebibliothek zur 3D-Visualisierung und wurde ursprünglich in C++ geschrieben. Verbreitet eingesetzt wird diese Bibliothek in der Wissenschaft und Forschung, z.B. 
* in der medizinischen Bildgebung
* für Strömungssimulationen
* für Klimadaten

VTK funktioniert nach dem {{W|Grafikpipeline|Pipeline-Prinzip}}:

 Source (Quellen) -&gt;  Filter -&gt; Mapper (Senken) -&gt; Actor/Renderer

Daten fließen von den Quellen zu den Senken.

Als einfaches Beispiel wird die Darstellung eines Zylinders gezeigt, der mit den Maustasten gedreht oder in der Größe geändert werden kann:

 import vtk
 
 # Zylinder erzeugen
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 # Geometrie in darstellbare Daten umwandeln
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 # Objekt in der Szene
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 # Szene verwalten
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 # Render-Fenster
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 # Maus/Tastatur-Steuerung
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 # Starten
 render_window.Render()
 interactor.Start()

Ausgabe:

[[Datei:PythonIng_VTK_1.png]]

Gleiches Beispiel wie oben, aber mit einer Animationssequenz:

 import vtk
 import time
 
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     render_window.Render()
     time.sleep(0.01)

Das Grafikfenster schließt sich nach Ablauf der Schleife. Das Fenster bleibt geöffnet, wenn Sie am Programmende folgenden Befehl hinschreiben

 interactor.Start()

Um den animierten Zylinder grün einzufärben, müssen Sie Folgendes im obigen Programm ergänzen (Farbnamen):

 colors = vtk.vtkNamedColors()
 actor.GetProperty().SetColor(colors.GetColor3d(&quot;Green&quot;))

Als Namen können Sie u.a. die CSS3 Web-Farben verwenden (siehe z.B. [https://wiki.selfhtml.org/wiki/Farbe/Farbangaben] und {{W|Webfarbe#CSS_3}}).

Alternativ funktioniert auch das ({{W|RGB-Farbraum|RGB}}):

 actor.GetProperty().SetColor(0.0, 0.6, 0.0)

Wie der Zylinder mit einer Textur versehen wird, zeigt folgendes Programm:

 import vtk
 import time
 
 cylinder = vtk.vtkCylinderSource()
 cylinder.SetResolution(30)
 cylinder.SetHeight(3.0)
 cylinder.SetRadius(1.0)
 cylinder.CappingOn()
 
 texture_coords = vtk.vtkTextureMapToCylinder()
 texture_coords.SetInputConnection(cylinder.GetOutputPort())
 texture_coords.PreventSeamOn()
 
 reader = vtk.vtkJPEGReader()
 reader.SetFileName(&quot;PythonIng_textur.jpg&quot;)
 
 texture = vtk.vtkTexture()
 texture.SetInputConnection(reader.GetOutputPort()) 
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(texture_coords.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 actor.SetTexture(texture)
 
 renderer = vtk.vtkRenderer()
 renderWindow = vtk.vtkRenderWindow()
 renderWindow.AddRenderer(renderer)
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(renderWindow)
 
 renderer.AddActor(actor)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     renderWindow.Render()
     time.sleep(0.01)
 
 interactor.Start()

&lt;gallery&gt;
PythonIng_textur.jpg | Textur-Datei
PythonIng_VTK_2.png | Ausgabe (Screenshot)
&lt;/gallery&gt;

== Sonstige Grafikbibliotheken ==
=== Py5 ===
Im Buch ''Iacono et al.: Programmieren trainieren, mit über 150 Workouts in Java und Python; 3. Aufl., Hanser, 2023'' werden zahlreiche Aufgaben gestellt, die u.a. mit Processing zu lösen sind.  Processing ist eine einfache Programmiersprache und Entwicklungsumgebung. Warum ich das erwähne? Weil in älteren Processing-Versionen auch die Programmiersprache Python 2 abgedeckt war. Bei neueren Versionen gibt es keine Python-Anbindung mehr (getestet nur mit openSUSE Tumbleweed und Python 3). Somit funktioniert der Python-Teil im genannten Buch zum Teil nicht mehr. Ist das tragisch, oder kann das Buch weggeschmissen werden? Nein! Es gibt Alternativen zu Processing. Zum einen die im Buch selbst genannten Bibliotheken tkinter oder pygame. Pygame wird dort auch kurz anhand eines Beispiels thematisiert. Aber noch besser ist es, die py5-Bibliothek zu verwenden (lt. Google KI vom 30. Sept. 2026: ''Der echte, moderne „spirituelle Nachfolger“''). Damit ist die Funktionalität von Processing gewährleistet. Man kann aber beliebige Editoren oder IDEs zur Programmerstellung verwenden, ohne an Processing als IDE gebunden zu sein. Nachfolgend werden ein paar Beispiele zu dieser externen Bibliothek gegeben. Der erste Schritt ist wieder, die py5-Bibliothek zu installieren (z.B. mittels pip in eine virtuelle Umgebung; Python&gt;=3.10 und ein JDK&gt;=17 müssen auch installiert sein (Stand Okt. 2026)). Dann kann es schon mit dem Programmieren losgehen.

Beispiel (angelehnt an die ''Aufgabe W.2.3 Haus'' des genannten Buchs, jedoch etwas erweitert):

 import py5
 
 def setup():
     py5.size(600, 600)            # Fenstergröße 600px x 600px 
     py5.background(255, 255, 255) # Hintergrundfarbe ... weiss
     
 def draw():
     # Haus zeichnen
     py5.fill(255, 255, 255)       # Hintergrundfarbe ... weiss
     py5.stroke(255, 0, 0)         # Linienfarbe ... rot 
     py5.stroke_weight(3)          # Linienbreite ... 3px
     py5.rect(150, 200, 300, 300)  # Rechteck zeichnen (x, y, b, h)
     py5.triangle(150, 200, 300, 100, 450, 200) # Dreieck zeichnen
     py5.circle(250, 300, 70)      # Kreis zeichnen (x, y, d)   
     
     # Bemassung zeichnen
     py5.stroke(0, 255, 0)
     py5.stroke_weight(1)
     py5.line(300, 100, 550, 100)  # Linie zeichnen
     py5.line(450, 200, 550, 200) 
     py5.line(450, 500, 550, 500) 
     py5.line(150, 500, 150, 550)
     py5.line(450, 500, 450, 550)
     py5.text_size(20)             # Textgroesse
     py5.fill(0, 255, 0)           # Textfarbe
     py5.text(&quot;300&quot;, 280, 550)     # Text zeichnen
     py5.text(&quot;100&quot;, 500, 150)
     py5.text(&quot;300&quot;, 500, 350)  
 
     # Gedrehtes Rechteck zeichnen
     py5.stroke(255, 255, 0)
     py5.stroke_weight(3)
     py5.fill(200, 200, 200) 
     py5.translate(320, 260)  
     py5.rotate(0.3)               # Drehung (in Radiant)
     py5.rect(0, 0, 100, 50)
 
 # Startet den Sketch
 py5.run_sketch()


Ausgabe:

[[Datei:PythonIng_py5_1.png|300px]]

Das skizzierte Haus ist mit einer rudimentären Bemaßung versehen und hat zwei Fenster, ein rundes und ein gedrehtes, trübes rechteckiges. 

Beispiel (Mausoperationen):

 import py5
 
 def setup():
     py5.size(600, 600)            
     py5.background(255, 255, 255)
 
 def draw():
     pass
    
 def mouse_pressed():
     py5.text_size(15) 
     py5.fill(0, 0, 255)
     x = py5.mouse_x
     y = py5.mouse_y
     py5.text(&quot;(%d, %d)&quot; %(x, y), x, y) # Positionsdaten bei Maus-Klick schreiben
 
 py5.run_sketch()

Ausgabe:

[[Datei:PythonIng_py5_2.png|300px]]

Obiges Bild zeigt das Resultat nach einigen Mausklicks. Man erkennt, dass links-oben der Koordinatennullpunkt ist. Die x-Achse zeigt nach rechts, die y-Achse nach unten.

Beispiel (Fünfeck):

 import py5
 import random 
 
 def setup():
     py5.size(400, 400)
     py5.no_loop()       # statisches Bild (schont die Ressourcen)
 
 def draw():
     py5.translate(py5.width / 2, py5.height / 2)  # KS setzen
 
     radius = 150
     eck_anzahl = 5
 
     py5.fill(random.randint(0, 255), random.randint(0, 255), 
              random.randint(0, 255))    # Füllfarbe auf Zufallswert setzen
     py5.stroke(155, 0, 0)            
     py5.stroke_weight(5)     
     
     # Fünfeck als Polygon zeichnen
     py5.begin_shape()
     for i in range(eck_anzahl):
         winkel = i * py5.TWO_PI / eck_anzahl - py5.HALF_PI
         x = py5.cos(winkel) * radius
         y = py5.sin(winkel) * radius
         py5.vertex(x, y)
     py5.end_shape(py5.CLOSE)
 
 py5.run_sketch()

Ausgabe, bspw.:

[[Datei:PythonIng_py5_5.png|200px]]

&lt;u&gt;Kleine Aufgaben:&lt;/u&gt;
* Um die Funktionsweise von &lt;code&gt;py5.no_loop()&lt;/code&gt; zu verstehen, kommentieren Sie die Anweisung im Beispiel einfach aus, und starten Sie das Programm erneut.
* Zeichnen Sie ein Siebeneck.
* Was passiert, wenn man &lt;code&gt;py5.CLOSE&lt;/code&gt; im &lt;code&gt;py5.end_shape()&lt;/code&gt;-Befehl weglässt?

Beispiel (Grafik laden und zeichnen):

 import py5
 
 image1 = None
 
 def setup():
     global image1
     py5.size(600, 600)
     py5.no_loop()
     image1 = py5.load_image(&quot;PythonIng_py5_1.png&quot;)
 
 def draw():
     py5.image(image1, 0, 0)
 
 py5.run_sketch()

Hier wird einfach das Bild vom Haus-Beispiel (Screenshot von weiter oben) geladen und gezeichnet.

Beispiel (angelehnt an ''W.5.10 Wurfparabel'' des genannten Buches; mit OOP erstellt):

 import py5
 
 class Wurfparabel(py5.Sketch):
     def __init__(self, v0, angle):
         super().__init__()
         self.v0 = v0
         self.angle = self.radians(angle)
         self.g = 9.81
         self.t = 0.0
         self.scale = 1.5
 
     def settings(self):
         self.size(800, 600)
 
     def setup(self):        
         self.background(0, 0, 0)
         
     def draw(self):
         self.t += 0.1
 
         self.translate(50, 500)
       
         # KS Zeichnen
         self.fill(255, 255, 0)
         self.stroke(255, 255, 0)
         self.stroke_weight(1)
         self.line(0, 0, 0, -300)
         self.line(0, 0, 700, 0)
 
         # Punkt zeichnen
         cx = self.v0 * self.cos(self.angle) * self.t * self.scale
         cy = -(self.v0 * self.sin(self.angle) * self.t - \
                self.g/2 * self.t**2) * self.scale
         self.fill(255, 0, 0)
         self.stroke(255, 0, 0)
         self.circle(cx, cy, 3)
        
         # Stoppen bei Bodenkontakt
         if cy &gt;= -5:
             self.no_loop()
            
 def wurfparabel(v0=50, angle=45):
     sketch = Wurfparabel(v0, angle)
     sketch.run_sketch()
 
 v0 = float(input(&quot;v0 = &quot;))
 winkel = float(input(&quot;winkel = &quot;))
 wurfparabel(v0=v0, angle=winkel)

Eingabe auf der Konsole:

 v0 = 60
 winkel = 45

Ausgabe:

[[Datei:PythonIng_py5_13.png|200px]]

Die benötigten Formeln der Bewegungsgleichung kann man leicht herleiten, bzw. man benutzt folgende Grafik als Hilfestellung:

[[Datei:Wurfparabel_Zusammenfassung_aktualisierung.png|700px]]

&lt;u&gt;Aufgabe:&lt;/u&gt; Berechnen Sie den Scheitelpunkt und die Wurfweite bei gegebener Anfangsgeschwindigkeit und gegebenem Abwurfwinkel. Die Abwurfhöhe &lt;math&gt;y_0&lt;/math&gt; sei 0. Der Wurf soll auf der Erde stattfinden (g = 9.81 m/s²). Die dazu benötigten Formeln können aus obiger Grafik entnommen werden (oder Sie leiten sie selbst her). Geben Sie die Ergebnisse auf der Konsole aus.

Beispiel (eine einfache Animation):

 import py5
 
 i = 0
 
 def setup():
     py5.size(600, 600)
     py5.frame_rate(5)
     py5.stroke_weight(20)
 
 def draw():
     global i
     
     py5.background(255, 255, 255)
     py5.translate(py5.width/2, py5.height/2)
     py5.rotate(py5.PI/8 * i)    
 
     py5.line(-100, 0, 100, 0)
     i += 1
 
 py5.run_sketch()

Es wird eine rotierende Linie gezeichnet (z.B. wie bei einem Installationsprozess verwendet - zeigt an, dass der Installationsfortschritt nicht eingefroren ist). Hierbei ist nur aufzupassen, dass der Hintergrund in &lt;code&gt;draw()&lt;/code&gt; gesetzt wird, ansonsten würden die Linien additiv gezeichnet. Das ist zwar auch schön, aber eben nicht das gewünschte Resultat.

Hiermit belassen wir es mit der py5-Bibliothek und wenden uns wieder &quot;mathematischeren&quot; Themen zu.

= Vektoren und Matrizen =
== Zahlenfolgen ==
Für das Erstellen von Zahlenfolgen bieten sich die Funktionen &lt;code&gt;arange&lt;/code&gt; und &lt;code&gt;linspace&lt;/code&gt; aus dem &lt;code&gt;numpy&lt;/code&gt;-Modul an.

 from numpy import *
 
 start = 0
 stop = 10
 step = 2
 num = 10
 
 r = arange(start, stop, step)   # step ... Schrittweite
 l = linspace(start, stop, num)  # num ... Anzahl der Werte
 
 print(&quot;r = &quot;, r)
 print(&quot;l = &quot;, l)

Ausgabe:
 r =  [0 2 4 6 8]
 l =  [ 0.          1.11111111  2.22222222  3.33333333  4.44444444  5.55555556
   6.66666667  7.77777778  8.88888889 10.        ]

Bei &lt;code&gt;arange&lt;/code&gt; ist der &lt;code&gt;stop&lt;/code&gt;-Wert nicht im Ergebnis enthalten, bei &lt;code&gt;linspace&lt;/code&gt; standardmäßig aber sehr wohl. Jedoch kann man das bei &lt;code&gt;linspace&lt;/code&gt; auch ändern. Dann ist der Stoppwert nicht mehr enthalten: 

 linspace(start, stop, num, endpoint=False)

== Vektoren ==
Vektoren sollten jedem aus der Linearen Algebra bekannt sein. 

=== Arrays ===
In Python mit NumPy kann man Vektoren durch die Funktion array erzeugen.

 import numpy as np
 
 l1 = (-5, 3, 2)
 l2 = (1, 1, 4)
 
 a1 = np.array(l1)
 a2 = np.array(l2)
 
 a3 = a1 + a2
 a4 = 2 * a2
 
 print(a1)
 print(a2)
 print(a3)
 print(a3[2])
 print(a4)

Ausgabe:
 [-5  3  2]
 [1 1 4]
 [-4  4  6]
 6
 [2 2 8]

=== Zeilen- und Spaltenvektoren ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 print(z)
 print(s)

Ausgabe:
 [ [-5  3  2] ]
 [[1]
  [1]
  [4]]

=== Skalarprodukt ===
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4))
 
 skalarprodukt = np.dot(a1, a2)  
 
 print(skalarprodukt)

Ausgabe:
 6

=== Vektorprodukt ===
&lt;math&gt;a\ast b=\left(\begin{array}{c}
a_{1}\\
a_{2}\\
a_{3}
\end{array}\right)\ast\left(\begin{array}{c}
b_{1}\\
b_{2}\\
b_{3}
\end{array}\right)=\left(\begin{array}{c}
a_{2}b_{3}-a_{3}b_{2}\\
a_{3}b_{1}-a_{1}b_{3}\\
a_{1}b_{2}-a_{2}b_{1}
\end{array}\right)
&lt;/math&gt; 

Python-Code:
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4)) 
 
 vektorprodukt = np.cross(a1, a2) 
 
 print(vektorprodukt)

Ausgabe:
 [10 22 -8]

=== Transponierter Vektor ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 # transponierter Vektor
 z_tp = np.transpose(z)
 # transponierter Vektor
 s_tp = np.transpose(s)
 
 print(z_tp)
 print(s_tp)

Ausgabe:
 [[-5]
  [ 3]
  [ 2]]
 [ [1 1 4] ]

=== Vektorfelder visualisieren ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 # Daten generieren
 x = np.arange(0, 10, 1)
 y = np.arange(0, 10, 1)
 X, Y = np.meshgrid(x, y)
 U = X * Y
 V = Y + X
 
 # Plotten
 fig, ax = plt.subplots()
 
 ax.quiver(X, Y, U, V, angles='xy')
 
 plt.show()

Ausgabe:

[[Datei:PythonIng_quiver1.png]]

== Matrizen==
 import numpy as np
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 print(m1)

Ausgabe:
 [[1 2 3]
  [4 5 6]]

=== Zugriff auf Matrizenelemente ===
Beispiel:

 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 
 # Element aus Zeile 2 und Spalte 3 (Achtung! Index startet bei Null)
 print(m1[1,2])

Ausgabe:
 6

Visualisierung:
  
     0   1   2
   +-----------+
 0 | 1 | 2 | 3 |
   +-----------+
 1 | 4 | 5 | '''6''' |
   +-----------+


Beispiel:

 import numpy as np
 
 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
 
 B = np.matrix(A)     
 
 print(B[2::, ::2])

Ausgabe:

 [['20' '22']
  ['30' '32']
  ['40' '42']]

Mit der NumPy-Bibliothek funktioniert das zweidimensionale Slicing. Mit normalen Listen/Tupels geht das nicht, was wir schon früher thematisiert haben.

=== Addition und Subtraktion von Matrizen ===
 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 m2 = np.matrix([[0, 0, 2], [1, 3, 2]])
 
 print(m1 + m2)
 print(m1 - m2)

Ausgabe:
 [[1 2 5]
  [5 8 8]]
 [[1 2 1]
  [3 2 4]]

=== Transponierte Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 2, 3], [4, 5, 6]])
 mt = np.transpose(m) 
 
 print(m)
 print(mt)

Ausgabe:
 [[1 2 3]
  [4 5 6]]
 [[1 4]
  [2 5]
  [3 6]]

=== Rang einer Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 rg = np.linalg.matrix_rank(m)
 
 print(rg)

Ausgabe:
 2

=== Inverse Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 mi = np.linalg.inv(m)
 
 print(mi)

Ausgabe:
 [[ 1.   0.6]
  [-0.  -0.2]]

=== Multiplikation von Matrizen (falksches Schema) ===
 import numpy as np
 
 m1 = np.matrix([[1, 3, 4],  [0, -5, 1]])
 m2 = np.matrix([[1, 2], [2, 3], [0, 2]])
 
 print(m1 @ m2)

Ausgabe:
 [[  7  19]
  [-10 -13]]

=== Eigenwerte und Eigenvektoren ===
 import numpy as np
 
 m = np.matrix([[5, 8],  [1, 3]])
 D,V = np.linalg.eig(m)
 
 # Eigenwerte
 print(D)
 # Eigenvektoren
 print(V)

Ausgabe:
 [7. 1.]
 [[ 0.9701425  -0.89442719]
  [ 0.24253563  0.4472136 ]]

=== Teilmatrizen ===
 import numpy as np
 m = np.matrix([[1, 3, 4],  [0, -5, 1]])
 print(&quot;m = &quot;, m)
 
 # Erste Zeile extrahieren
 m1 = m[0,:]
 print(&quot;m1 = &quot;, m1)
 
 # Das Element aus der 1. Zeile und der 2. Spalte extrahieren
 m2 = m[0,1]
 print(&quot;m2 = &quot;, m2)
 
 # Zweite Spalte extrahieren
 m3 = m[:, 1]
 print(&quot;m3 = &quot;, m3)

Ausgabe:
 m =  [[ 1  3  4]
  [ 0 -5  1]]
 m1 =  [ [1 3 4] ]
 m2 =  3
 m3 =  [[ 3]
  [-5]]

=== Spezielle Matrizen ===
==== Nullmatrix ====
 import numpy as np
 z = np.zeros((3, 2))
 print(z)

Ausgabe:
 [[0. 0.]
  [0. 0.]
  [0. 0.]]

==== Einheitsmatrix ====
 import numpy as np
 z = np.eye(3)
 print(z)

Ausgabe:
 [[1. 0. 0.]
  [0. 1. 0.]
  [0. 0. 1.]]

==== Matrix mit lauter Einsen ====
 import numpy as np
 z = np.ones((3, 2))
 print(z)

Ausgabe:
 [[1. 1.]
  [1. 1.]
  [1. 1.]]

=== Spärlich besetzte Matrizen ===
Das Thema spärlich besetzter Matrizen wird hier nur kurz angerissen. Nähere Details siehe unter dem Weblink  [https://docs.scipy.org/doc/scipy/reference/sparse.html#module-scipy.sparse]. 

Beispiel:

 import numpy as np
 import scipy
 
 A = scipy.sparse.csr_array(np.eye(5))
 
 print(A)

Ausgabe:
 &lt;Compressed Sparse Row sparse array of dtype 'float64'
         with 5 stored elements and shape (5, 5)&gt;
   Coords        Values
   (0, 0)        1.0
   (1, 1)        1.0
   (2, 2)        1.0
   (3, 3)        1.0
   (4, 4)        1.0

csr steht für '''c'''ompressed '''s'''parse '''r'''ow.

Andere Möglichkeiten:
* coo-Format ('''coo'''rdinate Format): &lt;code&gt;scipy.sparse.coo_array()&lt;/code&gt;
* lil-Format ('''li'''st of '''l'''ists): &lt;code&gt;scipy.sparse.lil_array()&lt;/code&gt;
* csc-Format ('''c'''ompressed '''s'''parse '''c'''olumn): &lt;code&gt;scipy.sparse.csc_array()&lt;/code&gt;

Es gibt auch &lt;code&gt;scipy.sparse.csr_matrix()&lt;/code&gt; etc. Diese Befehle sind aber veraltet und es wird empfohlen, statt dessen die &lt;code&gt;..._array()&lt;/code&gt;-Funktionen zu verwenden.

&lt;u&gt;Aufgaben:&lt;/u&gt; 
Recherchieren Sie im Internet 
* generell zum Thema &quot;spärlich besetzte Matrizen mit Python&quot;.
* Was sind die Vor-/Nachteile von csr-arrays gegenüber coo- und lil-arrays?
* Wann verwendet man sinnvollerweise csr- und wann csc-arrays?
* Wie wandelt man coo-arrays in csr-arrays um?

= Lineare Gleichungssysteme =
Sei &lt;math&gt;Ax = b&lt;/math&gt; ein lineares Gleichungssystem. &lt;math&gt;A&lt;/math&gt; sei die Koeffizientenmatrix, &lt;math&gt;x&lt;/math&gt; der Lösungsvektor und &lt;math&gt;b&lt;/math&gt; ein bekannter Vektor.

Beispiel:
 import numpy as np
 
 A = np.array([[5, 1], [0, 2]])
 b = np.array([1, 2])
 
 x = np.linalg.solve(A, b)
 
 print(x)

Ausgabe:
 [0. 1.]

Siehe dazu auch das Kapitel [[Ing Mathematik: Numerisches Lösen von linearen Gleichungssystemen]]. Dort wird dieses Themengebiet u.a. mit weitergehenden Python-Skripten vertieft.

== Aufgabe ==
* Lösen Sie folgendes Gleichungssystem mittels Python (und zur Kontrolle auch händisch): 
 5x + 6y - 2z = 12
 3x - y  - 3z = 6
 2x + 2y + 4z = 5

= Polynome =
== Ein erstes einfaches Beispiel ==
Gegeben sei das Polynom &lt;math&gt;7x^3+5x^2+1&lt;/math&gt;. In Python:

 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p)

Ausgabe:
    3     2
 7 x + 5 x + 1

== Einzelne Polynomwerte berechnen ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p(1.5))

Ausgabe:
 35.875

== Polynome integrieren und differenzieren ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 
 # 1. Ableitung
 p1 = p.deriv()
 p2 = p.deriv(1)
 
 # 2. Ableitung
 p3 = p.deriv(2)
 
 # Integral
 p4 = p.integ()
 
 print(p1)
 print(p2)
 print(p3)
 print(p4)

Ausgabe:
     2
 21 x + 10 x
     2
 21 x + 10 x
 
 42 x + 10
       4         3
 1.75 x + 1.667 x + 1 x

== Nullstellen bestimmen ==
 import numpy as np
 
 p = np.poly1d([2, 5, 0, 4])
 r = np.roots(p)
 
 print(r)

Ausgabe:
 [-2.7621427 +0.j          0.13107135+0.84077099j  0.13107135-0.84077099j]

== Aufgaben ==
* Berechnen Sie den Wert für x = 3 des Polynoms &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Differenzieren und integrieren Sie das Polynom &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Berechnen Sie die Nullstellen von &lt;math&gt;y = 7x^5 - 3x^2 + 12&lt;/math&gt;.

= Nichtlineare Gleichungen und Gleichungssysteme =
== Nullstellenbestimmung ==
Löse eine beliebige Gleichung f(x) = 0, z.B. &lt;math&gt; f(x) = x^2 - 5\cos(x) - 10 = 0 &lt;/math&gt;:
 import scipy
 import numpy as np
 
 def f(x):
     return x**2 - 5*np.cos(x) - 10
    
 xstart = [-1, 1]        # Startwerte
 xn = scipy.optimize.root(f, xstart)
 
 print(xn.x)

Ausgabe:
 [-2.46813009  2.46813009]

Funktionsgraph:

[[Datei:octave_nichtlin2.jpg]]

== Gleichungssysteme ==
SymPy ist ein externes Modul, das symbolisches Rechnen ('''Sym'''bolic '''Py'''thon) ermöglicht. 

Folgende Aufgabe ist dem Buch &quot;Knorrenschild: Numerische Mathematik, Hanser, 2017, Seite 72&quot; entnommen. Zu lösen ist das nichtlineare Gleichungssystem

&lt;math&gt;f_1 = 2x_1 + 4x_2 = 0 &lt;/math&gt;

&lt;math&gt;f_2 = 4x_1 + 8x_2^3 = 0&lt;/math&gt;

Mit Python ist das so möglich:
 import sympy
 
 x1, x2 = sympy.symbols(&quot;x1 x2&quot;) 
 
 f1 = 2*x1 + 4*x2
 f2 = 4*x1 + 8*x2**3
 
 s = sympy.solve((f1, f2), x1, x2) 
 
 print(s)

Ausgabe:
 [(-2, 1), (0, 0), (2, -1)]

Plot:

[[Datei:IngPython_nl_gleichung1.svg|500px]]

= Komplexe Zahlen =
Die imaginäre Einheit wird in Python durch den Buchstaben &lt;code&gt;j&lt;/code&gt; symbolisiert. Darstellen kann man eine komplexe Zahl bekannterweise in mehreren Formen:
* Kartesische Darstellung &lt;math&gt;z = \Re(z) + j \cdot \Im(z)&lt;/math&gt;
* Polardarstellungen &lt;math&gt;z = r \cdot (\cos(\phi) + j \cdot \sin(\phi)) = r \cdot e^{j\cdot \phi}&lt;/math&gt;

Die konjugiert komplexe Zahl ist &lt;math&gt;z^* = \Re(z) - j \cdot \Im(z)&lt;/math&gt;

Nachfolgend einige mathematische Operationen mit Python und NumPy.

 import numpy as np
 
 z1 = 2 + 5j           # kartesische Darstellung
 z2 = 3 * np.exp(3j)   # Polardarstellung
  
 # Addition
 res = z1 + z2
 print(&quot;z1 + z2 = &quot;, res)
 
 # Multiplikation
 res = z1 * z2
 print(&quot;z1 * z2 = &quot;, res)
 
 # Realteil
 res = np.real(z2)
 print(&quot;Realteil von z2 = &quot;, res)
 
 # Imaginärteil
 res = np.imag(z2)
 print(&quot;Imaginaerteil von z2 = &quot;, res)
 
 # Betrag
 res = np.abs(z1)
 print(&quot;Betrag von z1 = &quot;, res)
 
 # Argument
 res = np.angle(z1)
 print(&quot;Argument von z1 = &quot;, res)
 
 # Konjugiert komplexe Zahl
 res = np.conj(z1)
 print(&quot;Konjugiert komplexe Zahl von z1 = &quot;, res)

Ausgabe:
 z1 + z2 =  (-0.9699774898013365+5.423360024179601j)
 z1 * z2 =  (-8.05675510050068-14.003167400647481j)
 Realteil von z2 =  -2.9699774898013365
 Imaginaerteil von z2 =  0.4233600241796016
 Betrag von z1 =  5.385164807134504
 Argument von z1 =  1.1902899496825317
 Konjugiert komplexe Zahl von z1 =  (2-5j)

= Interpolation =
 import numpy as np
 import scipy
 import matplotlib.pyplot as plt
 
 # Stützpunkte
 xp = np.arange(1, 6)
 yp = (0, -5, 2, 7, 6)
 
 ti = np.arange(1, 5, 0.01)
 
 i1 = scipy.interpolate.interp1d(xp, yp, kind = &quot;linear&quot;)
 i2 = scipy.interpolate.interp1d(xp, yp, kind = &quot;cubic&quot;) 
 
 plt.plot(xp, yp, &quot;rx&quot;)
 plt.plot(xp, i1(xp))
 plt.plot(ti, i2(ti))
 plt.show()

Ausgabe:

[[Datei:PythonIng_interpol1.png]]

= Differenzialrechnung =
== Numerisches Differenzieren ==
Als Beispiel differenzieren wir &lt;math&gt;y = 5x\sin{x}&lt;/math&gt; und stellen das Ganze grafisch dar.

 from findiff import Diff
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.linspace(0, 10, 1000)
 f = 5 * x * np.sin(x)
 dx = x[1] - x[0]
 
 # Ableitung
 d_dx = Diff(0, dx)
 df_dx = d_dx(f)
 
 # Grafik
 plt.plot(x, f, label = &quot;y&quot;)
 plt.plot(x, df_dx, label = &quot;y'&quot;)
 plt.grid()
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

Ausgabe:

[[Datei:octave_diff1.jpg]]

&lt;small&gt;findiff ist ein externes Modul. Dieses muss installiert werden (z.B. so: ...\Python\Scripts\pip.exe install --upgrade findiff). Für die Vorgehensweise unter openSUSE Tumbleweed siehe das Kapitel [[Ing_Mathematik:_Python#Mit_VPython | VPython]], nur dass das Ganze mit einer aktuelleren Python-Version exekutiert wird, z.B. mit Python 3.13.  Das im Buch &quot;Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler, Rheinwerk&quot; verwendete Modul &quot;scipy.misc&quot; ist veraltet (deprecated ... missbilligt). Lt. [https://docs.scipy.org/doc/scipy-1.17.0/dev/roadmap-detailed.html#misc SciPy-Dokumentation für die Version 1.17.0] wurden alle entsprechenden Features schon entfernt.&lt;/small&gt;

== Symbolisches Differenzieren ==
Differenzieren Sie die Funktionen &lt;math&gt;f_1(x) = x^2&lt;/math&gt; und &lt;math&gt;f_2(x) = \sin(x)\cos\left(\frac{x}{2}\right)&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2;
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 d1 = sympy.diff(f1, x)
 d2 = sympy.diff(f2, x)
 
 print(d1)
 print(d2)

Ausgabe:
 2*x
 -0.5*sin(0.5*x)*sin(x) + cos(0.5*x)*cos(x)

== Aufgaben ==
* Differenzieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.
* Differenzieren Sie die Funktion &lt;math&gt;y = \frac{\sinh(x)}{(1+x)}&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.

= Integralrechnung =
== Numerisches Integrieren ==
Berechnen Sie das Integral &lt;math&gt;\int_{0}^{3}x^2 dx&lt;/math&gt;.

 import scipy
 
 def f(x):
     return x**2
    
 i = scipy.integrate.quad(f, 0, 3)
 print(i)

Ausgabe:
 (9.000000000000002, 9.992007221626411e-14)

Das trifft den exakten Wert 9.0 ziemlich genau.

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} dx&lt;/math&gt;.

 import scipy
 import numpy as np
 
 def f(x):
     return 2**(-x)
   
 i = scipy.integrate.quad(f, 0, np.inf)
 print(i)

Ausgabe:
 (1.4426950408889556, 4.486558477977586e-09)

== Symbolisches Integrieren ==
Berechnen Sie &lt;math&gt;\int x^2 \text{d}x&lt;/math&gt; und &lt;math&gt;\int \sin{x}\cos{\frac{x}{2}} \text{d}x&lt;/math&gt;.
 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 i1 = sympy.integrate(f1, x)
 i2 = sympy.integrate(f2, x)
 
 print(i1)
 print(i2)

Ausgabe:
 x**3/3
 -0.666666666666667*sin(0.5*x)*sin(x) - 1.33333333333333*cos(0.5*x)*cos(x)

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} \text{d}x&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f = 2**(-x)
 i = sympy.integrate(f, (x, 0, sympy.oo))
 print(i)

Ausgabe:
 1/log(2)

&lt;code&gt;sympy.oo&lt;/code&gt; steht für das {{W|Unendlichzeichen}} &lt;math&gt;\infty&lt;/math&gt; (die liegende Acht oder das Möbiusband). Mit &lt;code&gt;sympy.pprint(i)&lt;/code&gt; ließe sich letzere Ausgabe etwas schöner schreiben:

   1   
 ──────
 log(2)

Man beachtete, &lt;code&gt;log&lt;/code&gt; steht hier für den natürlichen Logarithmus &lt;code&gt;ln&lt;/code&gt;.

== Aufgaben ==
* Integrieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; von 1 bis 5.
* Integrieren Sie die Funktion &lt;math&gt;y = x^3&lt;/math&gt; von 0 bis 4.
* Integrieren Sie &lt;math&gt;\int x^x(\log (x) + 1)\mathrm dx&lt;/math&gt; symbolisch.

= Gewöhnliche Differenzialgleichungen =
== DGL numerisch lösen ==
Für die Lösung von Differenzialgleichungen steht u.a. die Funktion scipy.integrate.solve_ivp() zur Verfügung. Diese Funktion implementiert auch das Runge-Kutta-Verfahren (RK45).

{{Wikipedia | Runge-Kutta-Verfahren}}

Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import scipy
 import numpy as np
 import matplotlib.pyplot as plt
 
 def dy_dx(x, y):
     return x**2 + y**3
 
 y0 = [1]
 xi = [0, 1]
 x = np.arange(0, 1, 0.01)
 
 z = scipy.integrate.solve_ivp(dy_dx, xi, y0, method=&quot;RK45&quot;, dense_output=True)
 y = z.sol(x)
 
 plt.plot(x, y.T)
 plt.grid()
 plt.show()

[[Datei:PythonIng_dgl1.png]]

== DGL symbolisch lösen ==
Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 print(lsg)

Ausgabe:
 [Eq(f(x), (-x**2)**(1/3)), Eq(f(x), (-x**2)**(1/3)*(-1 - sqrt(3)*I)/2), Eq(f(x), (-x**2)**(1/3)*(-1 + sqrt(3)*I)/2)]

Mit &lt;code&gt;sympy.pprint&lt;/code&gt; (pretty print) lässt sich die Ausgabe etwas übersichtlicher darstellen.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 sympy.pprint(lsg)

Ausgabe:
 ⎡                           _____                        _____            ⎤
 ⎢          _____         3 ╱   2                      3 ╱   2             ⎥
 ⎢       3 ╱   2          ╲╱  -x  ⋅(-1 - √3⋅ⅈ)         ╲╱  -x  ⋅(-1 + √3⋅ⅈ)⎥
 ⎢f(x) = ╲╱  -x  , f(x) = ────────────────────, f(x) = ────────────────────⎥
 ⎣                                 2                            2          ⎦

== Aufgaben ==
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \frac{1}{x\cdot y}&lt;/math&gt; mit Python. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;m' = -k\cdot m&lt;/math&gt;. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \sqrt{|y|}&lt;/math&gt;.

=Laplace-Transformation=
Laplace-Transformation:

&lt;math&gt;F(s) =\mathcal{L} \left\{f\right\}(s) = \int_{0}^{\infty} f(t) \mathrm e^{-st} \,\mathrm{d}t, \qquad s\in\mathbb{C}
&lt;/math&gt;

Inverse Laplace-Transformation:

&lt;math&gt;\mathcal{L}^{-1} \left\{F\right\}(t)
  = \frac{1}{2 \pi \mathrm j} \int_{ \gamma - \mathrm j \infty}^{ \gamma + \mathrm j \infty} \mathrm e^{st} F(s)\,\mathrm ds 
= \begin{cases}
      f(t) &amp; \text{für } t \geq 0 \\
      0    &amp; \text{für } t &lt; 0
    \end{cases}
&lt;/math&gt;

Siehe auch [[Ing_Mathematik:_Laplace-Transformation]]

Code:
 import sympy
 from sympy.abc import t, s
 
 # Laplace-Transformation der Funktion f(t) = 1 (Heaviside-Fkt.)
 f = 1
 # alternativ: f = sympy.Heaviside(t)
 F = sympy.laplace_transform(f, t, s, noconds=True)
 print(&quot;Laplace-Transformierte F(s):&quot;, F) 
 
 # Inverse Laplace-Transformation zurück in den Zeitbereich
 f_inv = sympy.inverse_laplace_transform(F, s, t)
 print(&quot;Inverse Transformation f(t):&quot;, f_inv)

Ausgabe:
 Laplace-Transformierte F(s): 1/s
 Inverse Transformation f(t): Heaviside(t)

Die Zeile

 from sympy.abc import t, s

steht alternativ für

 t = sympy.symbols(&quot;t&quot;)
 s = sympy.symbols(&quot;s&quot;)

&lt;u&gt;Aufgaben&lt;/u&gt;: Ermitteln Sie mittels SymPy die &lt;math&gt;\mathcal{L}&lt;/math&gt;-Transformierten und dann wieder die  &lt;math&gt;\mathcal{L}^{-1}&lt;/math&gt;-Transformationen (ähnlich wie beim obigen Beispiel):
* &lt;math&gt;\sin(t) \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;t^3 \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;\text{e}^{\omega t} \circ\! -\! \bullet \ ?&lt;/math&gt;

=Fourier-Reihen=
&lt;math&gt;
f(x)\approx \frac{a_{0}}{2}+\sum_{k=1}^{\infty}\left(a_{k}\cos\left(kx\right)+b_{k}\sin\left(kx\right)\right)
&lt;/math&gt;

&lt;math&gt;
a_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\cos\left(kx\right)\mathrm dx\quad\text{für }k\geq0
&lt;/math&gt;

&lt;math&gt;
b_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\sin\left(kx\right)\mathrm dx\quad\text{für }k\geq1
&lt;/math&gt;

Für die Sägezahnfunktion &lt;math&gt;y=x;\, 0 &lt; x &lt; 2\pi&lt;/math&gt; sei die Fourierreihe mit einem Python-Programm (unter Mithilfe von sympy) hergeleitet.

Code:

 from sympy import fourier_series, pi, symbols, pprint
 
 x = symbols('x')
 f = x
 s = fourier_series(f, (x, 0, 2*pi))
 pprint(s.truncate(n=4))

Ausgabe:

                        2⋅sin(3⋅x)    
 -2⋅sin(x) - sin(2⋅x) - ────────── + π
                            3

Siehe auch [[Ing Mathematik: Fourierreihen]].

Ein komplizierteres Beispiel:

[[Datei:IngMath fourier bsp13.svg | 300px]]

&lt;math&gt;0\le t &lt; T/2\text{:}\quad f(t) = H&lt;/math&gt;

&lt;math&gt;T/2 \le t \le T\text{:}\quad f(t) = \frac{2H}{T}\left( t-\frac{T}{2}\right)&lt;/math&gt;

Code:

 import sympy as sp
 
 H = sp.Symbol('H', positive=True)
 T = sp.Symbol('T', positive=True)
 t = sp.Symbol('t')
 
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T/2)),
     (2*H/T*(t-T/2), (t &gt; T/2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Ausgabe:

      ⎛2⋅π⋅t⎞        ⎛4⋅π⋅t⎞        ⎛6⋅π⋅t⎞          ⎛2⋅π⋅t⎞          ⎛6⋅π⋅t⎞      
 H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   2⋅H⋅cos⎜─────⎟   2⋅H⋅cos⎜─────⎟      
      ⎝  T  ⎠        ⎝  T  ⎠        ⎝  T  ⎠          ⎝  T  ⎠          ⎝  T  ⎠   3⋅H
 ──────────── - ──────────── + ──────────── + ────────────── + ────────────── + ───
      π             2⋅π            3⋅π               2                 2         4 
                                                    π               9⋅π

=Rechnen mit wirklich großen Zahlen=
Bekannt ist, dass Python kaum Einschränkungen beim Wertebereich von Ganzzahlen hat, z.B.

 print(10**300)

Ausgabe (gekürzt):

 100000000000000000000...00000000000000000000000000000000000000000000000000000000000000000000000

Ähnliches geht auch mit Gleitpunktzahlen, z.B. durch die Verwendung des Moduls [https://mpmath.org/ mpmath]:

 import mpmath
 print(mpmath.mpf(1500.4)**mpmath.mpf(300))

Ausgabe:

 7.27975299218612e+952

Anderes Beispiel:

 from mpmath import mp, pi
 mp.dps = 100
 print(pi)

Ausgabe:

 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068

mpmath kann noch einiges mehr, dazu sei aber auf die entsprechende Dokumentation auf der mpmath-Homepage verwiesen. mpmath ist Bestandteil von SymPy, kann aber auch separat installiert werden.

Aber auch Python selbst besitzt eine Möglichkeit, um mit großen bzw. exakten Gleitpunktzahlen zu rechnen, nämlich das interne Modul decimal. Dieses hat einige Vorteile gegenüber mpmath, aber auch gravierende Nachteile. Diese seien hier nicht detailliert aufgezählt. Grob gesagt hat decimal im Finanzwesen seine Berechtigung. Für wissenschaftliche Anwendungen wird aber mpmath vorzuziehen sein, da es u.a. vielfältige mathematische Funktionen bereit stellt. Nachfolgend ein einfaches Beispiel mit decimal:

 import decimal
 print(&quot;Potenzierung:&quot;, decimal.Decimal(1500.4) ** decimal.Decimal(300.0))
 print(&quot;Einfache Addition:&quot;, 0.1 + 0.2)
 decimal.getcontext().prec = 50
 print(&quot;Addition mit decimal:&quot;, decimal.Decimal(&quot;0.1&quot;) + decimal.Decimal(&quot;0.2&quot;))

Ausgabe:

 Potenzierung: 7.279752992186121551039839134E+952
 Einfache Addition: 0.30000000000000004
 Addition mit decimal: 0.3

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet die genauen Vor- und Nachteile von decimal und mpmath. Verwenden Sie dazu auch KI (z.B. von Google, chatgpt).

= pint - mit physikalischen Größen rechnen = 
[[File:Pint-Glas_UK.jpg|right|100px]]
pint ist ein externes Python-Paket zur Manipulation von physikalischen Einheiten. Es muss vor der ersten Benutzung installiert werden (Vorgehensweise wie immer: pip, YaST, via venv etc.).

Beispiel:

 import pint
 import numpy as np
 
 ureg = pint.UnitRegistry()
 
 # Einfache Berechnung
 print(3 * ureg.meter + 4 * ureg.cm)
 
 # Mit NumPy
 npeinzel = [3, 4] * ureg.meter + [2, 5] * ureg.cm
 print(npeinzel)
 npsum = np.sum(npeinzel)
 print(npsum)
 
 # Konvertierung von Einheiten
 npsum_inch = npsum.to(ureg.inch)
 print(npsum_inch)
 
 print(npeinzel.magnitude)
 print(npeinzel.units)
 print(npeinzel.dimensionality)

Ausgabe:

 3.04 meter
 [3.02 4.05] meter
 7.07 meter
 278.3464566929134 inch
 [3.02 4.05]
 meter
 [length]

Die Dokumentation zu pint findet sich auf [https://pint.readthedocs.io/en/stable/].

=Regelungstechnische Aufgabenstellungen=
Für regelungstechnische Aufgaben gibt es u.a. das externe Paket &lt;code&gt;control&lt;/code&gt;. Hier soll nicht detailliert darauf eingegangen werden. Anhand eines Beispiels soll anschließend nur die Visualisierung in Form eines Bode-Diagramms und der Sprungantwort gezeigt werden. Gegeben sei ein P-Regler mit &lt;math&gt;R = \frac{5}{2}&lt;/math&gt; und eine Strecke &lt;math&gt;S= \frac{1}{30s^3+20s^2+10s+1,5}&lt;/math&gt;. Gesucht sei vorerst ein Bode-Diagramm für den offenen Regelkreis und das Führungsverhalten.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke  # oder: G0 = ct.series(regler, strecke)
 Gw = ct.feedback(G0)
 
 ct.bode_plot(G0, label='G0')
 ct.bode_plot(Gw, label='Gw')
 plt.show()

[[Datei:PythonIng_bode1.svg]]

Nun noch für obiges Beispiel die Sprungantwort. Diese zeigt einige große Überschwinger, d.h. der Regler kann sicher noch optimiert werden.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke 
 Gw = ct.feedback(G0) 
 
 t, y = ct.step_response(Gw)
 
 plt.plot(t,y)
 plt.title('Sprungantwort')
 plt.xlabel('t')
 plt.ylabel('h(t)')
 plt.grid()
 plt.show()

[[Datei:PythonIng_bode3.svg]]

Einige weitere wichtige Daten (Phasenreserve, Amplitudenreserve, Durchtrittsfrequenz) lassen sich mittels der &lt;code&gt;control&lt;/code&gt;-Funktion &lt;code&gt;margin()&lt;/code&gt; ermitteln. Die Ortskurve lässt sich mit der Funktion &lt;code&gt;nyquist_plot()&lt;/code&gt; zeichnen. Dies sei hier aber nicht weiter ausgeführt.

==Aufgaben==
* Zeichen Sie mit Python die Ortskurve für obiges Beispiel.
* Was passiert, wenn man die Reglerverstärkung weiter aufdreht (z.B. auf &lt;math&gt;R = \frac{25}{2}&lt;/math&gt;)?
* Wie sehen das Bode-Diagramm und die Sprungantwort aus, wenn ein PI-Regler verwendet wird?

= Stereostatik etc. =
Das Modul SymPy bietet einige Möglichkeiten einfache Bauwerke zu berechnen, z.B. Balken oder Fachwerke. Nachfolgend wird ein einfaches Fachwerk berechnet und gezeichnet.

Python-Code:
 from sympy.physics.continuum_mechanics.truss import Truss 
 
 t = Truss()
 # Knoten
 t.add_node((&quot;A&quot;, -3, 0), (&quot;B&quot;, 0, 0), (&quot;C&quot;, 4, 0), (&quot;D&quot;, 7, 0),
            (&quot;E&quot;, 6, 1.5), (&quot;F&quot;, 2, 3), (&quot;G&quot;, -2, 1.5))
 # Stäbe
 t.add_member((&quot;AB&quot;,&quot;A&quot;,&quot;B&quot;), (&quot;BC&quot;,&quot;B&quot;,&quot;C&quot;), (&quot;CD&quot;,&quot;C&quot;,&quot;D&quot;))
 t.add_member((&quot;AG&quot;,&quot;A&quot;,&quot;G&quot;), (&quot;GB&quot;,&quot;G&quot;,&quot;B&quot;), (&quot;GF&quot;,&quot;G&quot;,&quot;F&quot;))
 t.add_member((&quot;BF&quot;,&quot;B&quot;,&quot;F&quot;), (&quot;FC&quot;,&quot;F&quot;,&quot;C&quot;), (&quot;CE&quot;,&quot;C&quot;,&quot;E&quot;))
 t.add_member((&quot;FE&quot;,&quot;F&quot;,&quot;E&quot;), (&quot;DE&quot;,&quot;D&quot;,&quot;E&quot;))
 # Auflager; roller ... Loslager, pinned ... Festlager
 t.apply_support((&quot;A&quot;,&quot;roller&quot;), (&quot;D&quot;,&quot;pinned&quot;))
 # Einwirkende Kräfte
 t.apply_load((&quot;G&quot;, 5, 270), (&quot;E&quot;, 3, 90))
 
 # Berechnung 
 t.solve()
 print(&quot;Reaction Forces: &quot;, t.reaction_loads)
 print(&quot;Internal Forces: &quot;, t.internal_forces)
 
 # Fachwerk zeichnen
 p = t.draw()
 p.show()

Ausgabe auf der Konsole:

 Reaction Forces:  {'R_A_y': 4.20000000000000, 'R_D_x': 0, 'R_D_y': -2.20000000000000}
 Internal Forces:  {'AB': 2.80000000000000, 'BC': 0.333333333333333, 'CD': -1.46666666666667, 
 'AG': -5.04777178564958, 'GB': -2.05555555555556, 'GF': -1.23413387432364, 
 'BF': 0.411111111111111*sqrt(13), 'FC': -0.3*sqrt(13), 'CE': 1.50000000000000, 
 'FE': 0.284800124843917, 'DE': 2.64407093534026}

Zeichnung:

[[File:PythonIng_fachwerk1.svg|300px]]

Details zu diesem Thema siehe z.B. [https://docs.sympy.org/latest/modules/physics/continuum_mechanics/index.html Continuum Mechanics] oder [https://docs.sympy.org/latest/tutorials/physics/continuum_mechanics/index.html Continuum Mechanics Tutorials]. Auch andere mechanische Probleme werden von SymPy abgehandelt ([https://docs.sympy.org/latest/tutorials/physics/index.html Physics Tutorials]).

== Aufgabe ==
Gegeben sei ein einseitig eingespannter Kragträger. Belastet wird er durch eine Einzellast am Trägerende. Für die Daten siehe folgende ASCII-Skizze:

                            | 20 kN  
    //|---&gt; x               |
    //|                     V
    //|----------------------
    //|         10 m        |
 
 Elastizitätsmodul E = 2,1*10⁵ N/mm²
 Flächenträgheitsmoment I = 0.001 m⁴

Berechnen Sie die Auflagerreaktionen, den Querkraft- und Biegemomentenverlauf, sowie die Verformungen.
Stellen Sie dies mit Hilfe von SymPy graphisch und auch mittels Formeln dar. Verwenden Sie dazu auch pprint (pretty print) aus dem SymPy-Modul. Zwecks Lösungsansatz siehe die oben aufgeführte Seite &quot;Continuum Mechanics Tutorials&quot;. Achten Sie auch auf die Einheiten! Kontrollieren Sie das Ganze mittels händischer Rechnung. In dem genannten Tutorial ist von &quot;Singularity Functions&quot; die Rede. Gemeint ist damit in diesem Kontext die {{W|Föppl-Klammer}}.

Einige Python-Programme, vorrangig zu Maschinenelementen, finden sich auf [https://baymp.de/download_python.html BayMP für Python] (Balken, Zahnräder, Stabknickung usw.).

=Thermodynamik= 
== PYroMat ==
Für thermodynamische Aufgabenstellungen gibt es verschiedene externe Module. Eines davon ist PYroMat (siehe auch [http://pyromat.org]). Damit lassen sich thermodynamische Stoffdaten für viele Substanzen berechnen.

Beispiel (einige Stoffdaten für Wasser bei 400°C und 20 bar berechnen):

 import pyromat as pm
 
 # Wasserdaten laden:
 H2O = pm.get('mp.H2O')
 
 # Stoffdaten berechnen:
 T = 673.15  # Temperatur in Kelvin
 p = 20      # Druck in bar
 v = H2O.v(T, p)
 h = H2O.h(T, p)
 s = H2O.s(T, p)
 print(f&quot;Spezifisches Volumen: {v} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {h} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {s} kJ/(kg K)&quot;)

Ausgabe:

 Spezifisches Volumen: [0.1512163] m³/kg
 Spezifische Enthalpie: [3248.3789473] kJ/kg
 Spezifische Entropie: [7.12924142] kJ/(kg K)

&lt;small&gt;
PYroMat muss vorab installiert werden (z.B. mittels pip, in eine virtuelle Umgebung)
&lt;/small&gt;

&lt;code&gt;mp&lt;/code&gt; steht für &quot;multi phase&quot;. Für ein ideales Gas wäre &lt;code&gt;ig&lt;/code&gt; zuständig, z.B. &lt;code&gt;'ig.O2'&lt;/code&gt;.

Beispiel (T-s-Diagramm für Wasser zeichnen):
 import numpy as np
 import matplotlib.pyplot as plt
 import pyromat as pm
 
 # Konfigurieren
 pm.config[&quot;unit_pressure&quot;] = &quot;bar&quot;
 pm.config[&quot;unit_temperature&quot;] = &quot;K&quot;
 fluid = pm.get(&quot;mp.H2O&quot;)
 
 # Temperaturbereich für das Nassdampfgebiet
 T_tripel = 273.16
 T_crit = 647.096
 T = np.linspace(T_tripel, T_crit - 0.1, 200)
 
 # Sättigungslinien berechnen und zeichnen
 for x in np.linspace(0.0, 1.0, 5):
     s = fluid.s(T=T, x=x)
     if(x&lt;=0.0):
         plt.plot(s, T, label=&quot;Siedelinie x=%3.1f&quot; % x, linewidth=2.0)
     elif(x&gt;=1.0):
         plt.plot(s, T, label=&quot;Taulinie x=%3.1f&quot; % x, linewidth=2.0)
     else:
         plt.plot(s, T, label=&quot;x=%3.1f&quot; % x, linewidth=1.0)
 
 # Isobaren zeichnen
 p_values = [0.1, 1, 10, 50, 100]
 T_isobar = np.linspace(T_tripel, 1000, 200)
 t = 0.7
 
 for p in p_values:
     s_iso = fluid.s(T=T_isobar, p=p)
     plt.plot(s_iso, T_isobar, 'k-', alpha=0.8, linewidth=0.8)
 
     t += .05
     idx = int(len(s_iso) * t)
     plt.text(s_iso[idx], T_isobar[idx], f&quot;{p} bar&quot;, fontsize=9, alpha=0.8)
 
 # Diagramm zeichnen
 plt.title(&quot;T-s-Diagramm für Wasser&quot;)
 plt.xlabel(&quot;Spezifische Entropie s in kJ/kg K&quot;, fontsize=10)
 plt.ylabel(&quot;Temperatur T in K&quot;, fontsize=10)
 plt.legend(loc=&quot;best&quot;)
 plt.grid(True)
 plt.show()

Ausgabe (in etwa so):

[[Datei:T-s-Diagramm fuer Wasser.svg|400px]]

== CoolProp ==
Auch mit CoolProp können Stoffdaten berechnet werden. Siehe auch [https://coolprop.org/coolprop/wrappers/Python/index.html]

Beispiel (Wasser bei 20bar und 400°C):
 import CoolProp.CoolProp as CP
 
 fluid = 'Water'
 T = 673.15   # Temperatur in Kelvin
 P = 20e5     # Druck in Pascal
 
 dichte = CP.PropsSI('D', 'T', T, 'P', P, fluid)
 enthalpie = CP.PropsSI('H', 'T', T, 'P', P, fluid)
 entropie = CP.PropsSI('S', 'T', T, 'P', P, fluid)
 
 print(f&quot;Spez. Volumen: {1/dichte:.6f} m³/kg&quot;)
 print(f&quot;Spez. Enthalpie: {enthalpie:.2f} J/kg&quot;)
 print(f&quot;Spez. Entropie: {entropie:.2f} J/kgK&quot;)

Ausgabe:
 Spez. Volumen: 0.151215 m³/kg
 Spez. Enthalpie: 3248344.02 J/kg
 Spez. Entropie: 7129.16 J/kgK

== iapws ==
Um Werte für Wasser(dampf) zu erhalten (IAPWS; '''I'''nternational '''A'''ssociation for the '''P'''roperties of '''W'''ater and '''S'''team) gibt es die Bibliothek iapws. Siehe auch [https://iapws.org/] und [https://pypi.org/project/iapws/]

Beispiel (Wasser für 20bar und 400°C):
 from iapws import IAPWS97
 
 dampf = IAPWS97(P=2.0, T=673.15)
 
 print(f&quot;Spezifisches Volumen: {dampf.v:.6f} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {dampf.h:.2f} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {dampf.s:.4f} kJ/(kgK)&quot;)
 print(f&quot;Phase: {dampf.phase}&quot;)

Ausgabe:
 Spezifisches Volumen: 0.151208 m³/kg
 Spezifische Enthalpie: 3248.23 kJ/kg
 Spezifische Entropie: 7.1290 kJ/(kgK)
 Phase: Gas

== TESPy ==
Ein anderes Modul für einen anderen Aufgabenzweck ist TESPy ('''T'''hermal '''E'''ngineering '''S'''ystems in '''Py'''thon). Dieses Modul ist für die Anlagensimulation zuständig. Für nähere Informationen siehe [https://tespy.readthedocs.io/en/main/getting_started/introduction.html]. Als Beipiel sei hier vorerst Code, der von der Google KI generiert wurde, angeführt. Der Code wurde überarbeitet, damit keine Warnungen auftreten. Bitte aber den Code trotzdem mit Vorsicht genießen, auch KI-generierter Code kann Fehler aufweisen. Eine Pumpe wird berechnet:

 from tespy.components import Sink, Source, Pump
 from tespy.connections import Connection
 from tespy.networks import Network
 
 # 1. Netzwerk definieren (Zentrales Steuerungselement)
 # Wir wählen Wasser als Fluid und bar/Celsius als Einheiten
 nw = Network(fluids=[&quot;water&quot;])
 nw.units.set_defaults(pressure=&quot;bar&quot;, pressure_difference=&quot;bar&quot;, 
                       temperature=&quot;°C&quot;, enthalpy=&quot;kJ / kg&quot;)
 
 # 2. Komponenten erstellen
 eingang = Source(&quot;Wasserquelle&quot;)
 ausgang = Sink(&quot;Wasserspeicher&quot;)
 pumpe = Pump(&quot;Speisewasserpumpe&quot;)
 
 # 3. Verbindungen definieren (Komponenten miteinander verknüpfen)
 c1 = Connection(eingang, &quot;out1&quot;, pumpe, &quot;in1&quot;)
 c2 = Connection(pumpe, &quot;out1&quot;, ausgang, &quot;in1&quot;)
 
 # Verbindungen dem Netzwerk hinzufügen
 nw.add_conns(c1, c2)
 
 # 4. Randbedingungen und Parameter festlegen
 # Zustand am Eingang (Druck, Temperatur, Massenstrom, Fluid-Zusammensetzung)
 c1.set_attr(
     v=1,  # Massenstrom: 1 kg/s
     T=20,  # Temperatur: 20 °C
     p=1,  # Druck: 1 bar
     fluid={&quot;water&quot;: 1},  # 100% Wasser
 )
 
 # Zustand am Ausgang / Zielwerte der Pumpe
 c2.set_attr(p=10)  # Ziel-Druck nach der Pumpe: 10 bar
 
 # Pumpeneigenschaften festlegen
 pumpe.set_attr(eta_s=0.8)  # Isentroper Wirkungsgrad von 80%
 
 # 5. Simulation ausführen
 nw.solve(mode=&quot;design&quot;)
 
 # 6. Ergebnisse ausgeben
 nw.print_results()
 
 # Spezifische Werte direkt auslesen
 print(&quot;\n--- Auswertung ---&quot;)
 print(f&quot;Erforderliche Pumpenleistung: {pumpe.P.val / 1000:.2f} kW&quot;)
 print(f&quot;Temperatur nach der Pumpe: {c2.T.val:.2f} °C&quot;)

Ausgabe (gekürzt):
  iter  | residual   | progress   | massflow   | pressure   | enthalpy   | fluid      | component  
 -------+------------+------------+------------+------------+------------+------------+------------
  1     | 7.04e+04   | 12 %       | 9.96e+02   | 0.00e+00   | 8.81e+04   | 0.00e+00   | 0.00e+00   
  2     | 5.91e-12   | 100 %      | 1.11e-13   | 0.00e+00   | 7.39e-12   | 0.00e+00   | 0.00e+00   
  3     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
  4     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
 Total iterations: 4, Calculation time: 0.01 s, Iterations per second: 480.85
 
 ##### RESULTS (Pump) #####
 +-------------------+----------+----------+-----------+----------+----------+----------+
 |                   |        P |       pr |        dp |      eta |    eta_s |     head |
 |-------------------+----------+----------+-----------+----------+----------+----------|
 | Speisewasserpumpe | 1.12e+06 | 1.00e+01 | -9.00e+00 | 8.00e-01 | 8.00e-01 | 9.19e+01 |
 +-------------------+----------+----------+-----------+----------+----------+----------+
 ...
 ...
 --- Auswertung ---
 Erforderliche Pumpenleistung: 1124.77 kW
 Temperatur nach der Pumpe: 20.07 °C

= Stochastik =
Die {{W|Stochastik}} ist ein sehr weites Feld. Hier werden etliche wichtige Themen kurz angerissen. Python stellt mit den Moduln math und statistics Software zu diesem Zwecke bereit. math und statistics sind bereits im Lieferumfang von Python enthalten. Aber auch mit den externen Modulen NumPy, SciPy, stochastic und pandas kann man Stochastik in Python betreiben. Die Theorie der Wahrscheinlichkeitsrechnung und Statistik soll etwas später in Band 5 dieser Buchreihe behandelt werden.

== Lageparameter == 
 import statistics
 
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 
 m1 = statistics.mean(werte)
 m2 = statistics.mode(werte)
 m3 = statistics.median(werte)
 
 print(&quot;Arithmetischer Mittelwert = &quot;, m1)
 print(&quot;Modalwert = &quot;, m2)
 print(&quot;Median = &quot;, m3)

Ausgabe:
 Arithmetischer Mittelwert =  3.5
 Modalwert =  1
 Median =  3.0

== Streuungsparameter ==
Beispiel (Berechnung der Standardabweichung):
 import statistics
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 s = statistics.stdev(werte)
 print(&quot;Standardabweichung = &quot;, s)

Ausgabe:
 Standardabweichung =  2.6770630673681683

Beispiel (Berechnung des Variationskoeffizienten V = Standardabweichung/Mittelwert)
 import numpy as np
 from scipy import stats
 import statistics
 
 k = 50
 
 dat1 = [14, 21, 18, 25, 30, 17, 20]
 dat = np.array(dat1)
 
 # Mit SciPy
 v = stats.variation(dat)
 vddof = stats.variation(dat, ddof=1)
 print(&quot;V SciPy: &quot;, v)
 print(&quot;V DDOF SciPy: &quot;, vddof)
 print(k*&quot;-&quot;)
 
 # mit NumPy
 mittelwert1 = np.mean(dat)
 std_abw1 = np.std(dat)
 std_abw1ddof = np.std(dat, ddof=1) 
 v1= std_abw1 / mittelwert1
 v1ddof = std_abw1ddof / mittelwert1
 print(&quot;Mittelwert NumPy: &quot;, mittelwert1)
 print(&quot;Std.abw. NumPy: &quot;, std_abw1)
 print(&quot;Std.abw. DDOF NumPy: &quot;, std_abw1ddof)
 print(&quot;V NumPy: &quot;, v1)
 print(&quot;V DDOF NumPy: &quot;, v1ddof)
 print(k*&quot;-&quot;)
 
 # nur mit reinem Python
 mittelwert2 = statistics.mean(dat1)
 std_abw2 = statistics.stdev(dat1)
 v2 = std_abw2 / mittelwert2
 print(&quot;Mittelwert Python: &quot;, mittelwert2)
 print(&quot;Std.abw. Python: &quot;, std_abw2)
 print(&quot;V Python:&quot;, v2)
 print(k*&quot;-&quot;)

Ausgabe:
 V SciPy:  0.23890355966467272
 V DDOF SciPy:  0.25804533701889254
 --------------------------------------------------
 Mittelwert NumPy:  20.714285714285715
 Std.abw. NumPy:  4.948716593053935
 Std.abw. DDOF NumPy:  5.3452248382484875
 V NumPy:  0.23890355966467272
 V DDOF NumPy:  0.2580453370188925
 --------------------------------------------------
 Mittelwert Python:  20.714285714285715
 Std.abw. Python:  5.3452248382484875
 V Python: 0.2580453370188925
 --------------------------------------------------

Der Unterschied bei der Standardabweichung zwischen reinem Python und den externen Bibliotheken SciPy und NumPy entsteht dadurch, dass einmal durch (n-1) und das andere Mal nur durch n dividiert wird. Dies kann bei NumPy und SciPy dadurch entschärft werden, indem &lt;code&gt;ddof=1&lt;/code&gt; gesetzt wird. ddof steht für '''D'''elta '''D'''egrees '''o'''f '''F'''reedom. &lt;small&gt;Je größer die Anzahl der Datensätze n wird, umso weniger spielt das eine Rolle.&lt;/small&gt;

== Kombinatorik ==
Beispiel:

 import math
 
 n = 7
 k = 5
 
 print(&quot;n! = &quot;, math.factorial(n))
 print(&quot;Kombinationen (n über k) = &quot;, math.comb(n, k))

Ausgabe:
 n! =  5040
 Kombinationen (n über k) =  21

Siehe zu diesem Thema auch [[Ing Mathematik: Permutationen, Kombinationen, binomischer Lehrsatz]]. Die Anzahlen lassen sich einfach aus den dortigen Formeln ermitteln, z.B. bei Permutationen mit &lt;math&gt;n!&lt;/math&gt; oder Variationen mit Wiederholungen als &lt;math&gt;n^k&lt;/math&gt;. Will man die Kombinationen oder Variationen aber auch als Liste ausgeben, so kann das Modul &lt;code&gt;itertools&lt;/code&gt; nützlich sein.  

Beispiel (Variationen ohne Wiederholung):

 from itertools import permutations
 
 menge = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]  # n = 4
 k = 3
 
 variationen = list(permutations(menge, k))
 
 for v in variationen:
     print(&quot;&quot;.join(v))
 
 print(50*&quot;-&quot;)
 print(len(variationen))

Ausgabe (gekürzt):
 ABC
 ABD
 ACB
 ...
 DCA
 DCB
 --------------------------------------------------
 24

Siehe zum Modul &lt;code&gt;itertools&lt;/code&gt; auch die Website [https://docs.python.org/3/library/itertools.html].

* Variationen mit Wiederholung: &lt;code&gt;itertools.product()&lt;/code&gt;
* Kombinationen ohne Wiederholung: &lt;code&gt;itertools.combinations()&lt;/code&gt;
* Kombinationen mit Wiederholung: &lt;code&gt;itertools.combinations_with_replacement()&lt;/code&gt;

== Zufallszahlen ==
Beispiel:
 import random
 
 # Ganzzahlige Zufallszahl von 1 bis 10
 zufallszahl1 = random.randint(1, 10)
 
 # Gleitpunktzahlen
 # zwischen 0.0 und 1.0
 zufallszahl2 = random.random()
 # Zahl zwischen 1.5 und 9.5
 zufallszahl3 = random.uniform(1.5, 9.5)
 
 # aus Liste auswählen
 farbe = [&quot;Rot&quot;, &quot;Grün&quot;, &quot;Blau&quot;]
 zufallswert = random.choice(farbe)
 
 print(zufallszahl1)
 print(zufallszahl2)
 print(zufallszahl3)
 print(zufallswert)

Ausgabe, z.B.:
 5
 0.14147945849015753
 6.894003397570905
 Rot

Benötigt man mehrere Zufallszahlen, so ist das Modul &lt;code&gt;numpy&lt;/code&gt; zu bevorzugen, z.B.:
* Normalverteilung: &lt;code&gt;np.random.normal(...)&lt;/code&gt;
* Gleichverteilung: &lt;code&gt;np.random.uniform(...)&lt;/code&gt;

== Histogramm ==
Zum Thema Histogramm siehe {{W|Histogramm}}.

Beispiel (mit Matplotlib):

 import matplotlib.pyplot as plt
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 
 plt.hist(daten, bins=25, edgecolor='darkgray')
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm.svg|300px]]

Beispiel (mit Seaborn):

 import matplotlib.pyplot as plt
 import seaborn as sns
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 sns.set_theme(style=&quot;darkgrid&quot;)
 sns.histplot(data=daten)
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm2.svg|300px]]

Das Kürzel &lt;code&gt;sns&lt;/code&gt; ist Konvention und steht für die fiktive Figur '''S'''amuel '''N'''orman '''S'''eaborn aus der US-Fernsehserie {{W|The West Wing – Im Zentrum der Macht | The West Wing}}.

== Box-Plot ==
[[File:Elements of a boxplot.svg|400px]]

Siehe auch {{W|Box-Plot}}.

Beispiel (mit Seaborn erstellt):
 import seaborn as sns
 import matplotlib.pyplot as plt
 
 df = sns.load_dataset(&quot;tips&quot;)
 sns.boxplot(data=df, x=&quot;day&quot;, y=&quot;tip&quot;, hue=&quot;day&quot;, legend=False)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot.svg|400px]]

Beispiel (mit Matplotlib erstellt):

 import matplotlib.pyplot as plt
 
 daten = [12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25]
 
 plt.boxplot(daten, patch_artist=True)
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot2.svg|300px]]

Um mehrere Box-Plots unterschiedlicher Farbe mit Matplotlib in einem Diagramm zu zeichnen, können Sie folgendermaßen vorgehen:

 import matplotlib.pyplot as plt
 
 daten = [[12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25],
          [10, 19, 20, 21, 20, 30, 19, 40, 11, 17, 19, 21]]
 
 farben = [&quot;green&quot;, &quot;blue&quot;]
 
 boxplot = plt.boxplot(daten, patch_artist=True)
 
 for patch, farbe in zip(boxplot['boxes'], farben):
     patch.set_facecolor(farbe)
 
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

== Regressionsrechnung ==
Beispiel:
 import numpy as np
 import matplotlib.pyplot as plt
 
 # Messpunkte
 x = np.array([1, 3, 5, 6, 8, 10, 20])
 y = np.array([3, 4, 5, 5, 7, 9, 11])
 
 # Regressionskurve (Grad 1 = lineare Regression, 2 = Polynom-Regression 2. Gr.)
 # y = kx + d
 k, d = np.polyfit(x, y, deg=1)
 # y = ax**2 + bx + c
 a, b, c = np.polyfit(x, y, deg=2)
 
 x_l = np.linspace(1, 20, 100)
 y_p = a * x_l**2 + b * x_l + c
 
 # Zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.plot(x, k*x + d, color='blue', label='Regressionsgerade')
 plt.plot(x_l, y_p, color='red', label='Regressionspolynom 2. Gr.')
 plt.xlabel('x')
 plt.ylabel('y')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_regression.svg|400px]]

== Korrelationsrechnung ==
Beispiel:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 # Messdaten
 x = [1, 3, 4, 5, 6]
 y = [2, 4, 6, 8, 5]
 
 daten = {'X': x, 'Y': y}
 df = pd.DataFrame(daten)
 
 # Korrelation
 korr = df['X'].corr(df['Y'])
 print(f&quot;Korrelationskoeff.: {korr}&quot;) 
 
 # Messpunkte zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:
 Korrelationskoeff.: 0.7556096518348252

[[Datei:IngMath_korrelation.svg|300px]]

== Mengen und Venn-Diagramme ==
Beispiel: 
 import matplotlib.pyplot as plt
 from matplotlib_venn import venn2
 
 menge_a = {1, 2, 3, 4, 5, 6}
 menge_b = {4, 5, 6, 7, 8}
 
 vereinigung = menge_a | menge_b
 schnitt = menge_a &amp; menge_b
 print(&quot;Vereinigungsmenge = &quot;, vereinigung)
 print(&quot;Schnittmenge = &quot;, schnitt)
 
 venn2([menge_a, menge_b], set_labels=('Menge A', 'Menge B'))
 plt.show()

Ausgabe:
 Vereinigungsmenge =  {1, 2, 3, 4, 5, 6, 7, 8}
 Schnittmenge =  {4, 5, 6}

[[Datei:IngMath_venn.svg|300px]]

Siehe auch {{W|Mengendiagramm#Venn-Diagramme}}.

== Verteilungs- und Dichtefunktion ==
* CDF ... '''C'''umulative '''D'''istribution '''F'''unction, Verteilungsfunktion
* PDF ... '''P'''robability '''D'''ensity '''F'''unction, Dichtefunktion

Beispiel (Normalverteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 from scipy.stats import norm
 
 my, sigma = 0, 1
 x = np.linspace(-4, 4, 50)
 
 pdf = norm.pdf(x, my, sigma)
 cdf = norm.cdf(x, my, sigma)
 
 plt.plot(x, pdf, lw=2, label=&quot;Dichtefunktion&quot;)
 plt.plot(x, cdf, lw=2, label=&quot;Verteilungsfunktion&quot;)
 plt.legend()
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:IngMath_cdf_pdf.svg|300px]]

Beispiel (&lt;math&gt;\chi^2&lt;/math&gt;-Verteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 import scipy.stats as stats
 
 x = np.linspace(0, 20, 500)
 
 # df ... degree of freedom, Freiheitsgrad
 pdf = (stats.chi2.pdf(x, df=2), stats.chi2.pdf(x, df=5), stats.chi2.pdf(x, df=10))
 
 for i in range(0,3):
     if(i==0):
         lab = &quot;Freiheitsgrad 2&quot;
     elif(i==1):
         lab = &quot;Freiheitsgrad 5&quot;
     else:
         lab = &quot;Freiheitsgrad 10&quot;
 
     plt.plot(x, pdf[i], label=lab, lw=2)
 
 plt.grid()
 plt.legend()
 plt.show()

Ausgabe:

[[Datei:IngMath_chi2.svg | 300px]]

== Schätzen und Testen ==
=== Intervallschätzung ===
Als Beispiel seien Daten gegeben, die von ''Dürr, Mayer: Wahrscheinlichkeitsrechnung und Schließende Statistik; 7. Aufl., Hanser, 2014, Seite 137'' stammen. Und zwar soll das 95%-Vertrauensintervall für den Mittelwert des Kaloriengehalts (kcal/100g) von Hähnchen ermittelt werden. Wir wollen das mit Python inkl. NumPy und SciPy durchführen. Die Stichprobe ist groß (50 Hähnchen):

Python-Code:
 import numpy as np
 import scipy.stats as stats
 
 # Stichprobe
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203]
 
 # Parameter definieren
 konfidenzniveau = 0.95
 mean = np.mean(daten)
 std = np.std(daten, ddof=1)
 stdfehler = stats.sem(daten)
 
 intervall = stats.norm.interval(confidence=konfidenzniveau, loc=mean, scale=stdfehler)
 
 print(f&quot;Mittelwert: {mean}&quot;)
 print(f&quot;Standardabweichung: {std}&quot;)
 print(f&quot;Konfidenzintervall: {intervall}&quot;)

Ausgabe:
 Mittelwert: 215.48
 Standardabweichung: 33.14238915925757
 Konfidenzintervall: (np.float64(206.29356722321992), np.float64(224.66643277678006))

Diese Werte stimmen gerundet mit denen im genannten Buch überein. Zum Code selbst:
* sem steht für '''s'''tandard '''e'''rror of the '''m'''ean.
* &lt;code&gt;scipy.stats.norm&lt;/code&gt; ... Modul für die Normalverteilung.

=== Punktschätzung ===
Gleiche Daten wie oben bei der Intervallschätzung.

Python-Code:
 import numpy as np
 from scipy import stats
 
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203
         ]
 
 mu_hat, sigma_hat = stats.norm.fit(daten) 
 
 print(f&quot;Schätzer für den Erwartungswert (μ): {mu_hat:.4f}&quot;)
 print(f&quot;Schätzer für die Standardabweichung (σ): {sigma_hat:.4f}&quot;)

Ausgabe:
 Schätzer für den Erwartungswert (μ): 215.4800
 Schätzer für die Standardabweichung (σ): 32.8093

=== Hypothesentests ===
Beispiel:

 import numpy as np
 import scipy.stats as stats
 
 x_quer = 12.075      # Stichproben-Mittelwert
 var    = 0.069       # Stichproben-Varianz
 n      = 90          # Stichprobengröße
 my_0   = 12.0        # Nullhypothese
 alpha  = 0.05        # Signifikanzniveau
 
 z_stat = (x_quer - my_0) / np.sqrt(var / n)
 p_val = 2 * (1 - stats.norm.cdf(np.abs(z_stat)))
 
 print(f&quot;Z-Statistik: {z_stat:.4f}&quot;)
 
 if p_val &lt; alpha:
     print(f&quot;p-Wert: {p_val:.6f} &lt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird verworfen.&quot;)
 else:
     print(f&quot;p-Wert: {p_val:.6f} &gt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird nicht verworfen.&quot;)

Ausgabe:

 Z-Statistik: 2.7087
 p-Wert: 0.006755 &lt; alpha: 0.05
 Die Nullhypothese wird verworfen.

== Statistische Qualitätskontrolle ==
Beispiel (Mittelwertkarte):

 import numpy as np
 import matplotlib.pyplot as plt
 
 # Gegeben
 sollwert = 50.0
 varianz = 4.0
 stichproben_umfang = 1
 daten = [49.5, 50.2, 53.0, 48.1, 52.6, 53.4, 49.8]
 
 # Berechnung
 standardabweichung = np.sqrt(varianz)
 streuung = standardabweichung / np.sqrt(stichproben_umfang)
 
 cl = sollwert
 ucl = cl + 3 * streuung
 lcl = cl - 3 * streuung
 
 # Darstellung
 plt.plot(daten, marker='o', linestyle='-', color='b', label='Messdaten')
 plt.axhline(cl, color='green', linestyle='-', label=f'CL: {cl}')
 plt.axhline(ucl, color='red', linestyle='--', label=f'UCL: {ucl:.2f}')
 plt.axhline(lcl, color='red', linestyle='--', label=f'LCL: {lcl:.2f}')
 
 plt.title('Mittelwertkarte')
 plt.xlabel('Stichprobe')
 plt.ylabel('Wert')
 plt.legend(loc='lower left')
 plt.grid(True)
 plt.show()

Ausgabe:

[[Datei:IngMath_mittelwertkarte.svg|300px]]

Siehe auch {{W|Shewhart-Regelkarte}} und {{W|Qualitätsregelkarte}}.

* UCL ... '''U'''pper '''C'''ontrol '''Limit''', Obere Eingriffsgrenze
* LCL ... '''L'''ower '''C'''ontrol '''Limit''', Untere Eingriffsgrenze
* CL ... '''C'''enter '''L'''ine, Mittellinie

= Ein- und Ausgabe =
== print ==
Die Anweisung print haben wir schon oft verwendet. Hier soll anhand von Beispielen kurz beschrieben werden, was der Befehl print leisten kann.

 print(&quot;Hallo&quot;, &quot;Welt&quot;, 1, sep=&quot;-&quot;)
 print(&quot;Hallo&quot;, end=&quot; &quot;)
 print(&quot;Welt&quot;)

Ausgabe:
 Hallo-Welt-1
 Hallo Welt

== input ==
 a = int(input(&quot;Zahl 1: &quot;))
 b = int(input(&quot;Zahl 2: &quot;))
 
 print(&quot;a + b = &quot;, a+b)

Ausgabe (nach Eingabe der beiden Ganzzahlen):
 Zahl 1: 4
 Zahl 2: 5
 a + b =  9

== Aus Dateien lesen ==
Es seinen die datei.txt
 Hallo Welt.
 Wie geht es dir?
 ...

und test1.py
 dat = open(&quot;datei.txt&quot;, mode = &quot;r&quot;)
 print(dat.read())
 dat.close()

Ausgabe
 Hallo Welt.
 Wie geht es dir?
 ...

Mit dem open()-Befehl wird die Datei datei.txt im Lesemodus geöffnet (r ... read). Mit dem read()-Befehl wird die Datei eingelesen und mittels print ausgegeben.

== In Dateien schreiben ==
 dat = open(&quot;datei.txt&quot;, mode = &quot;a&quot;, encoding = &quot;utf-8&quot;)
 dat.write(&quot;Hänge Zeile an\n&quot;)
 dat.close()

Die Datei datei.txt sieht nach Abarbeitung des obigen Skripts nun so aus
 Hallo Welt.
 Wie geht es dir?
 ...
 Hänge Zeile an

Es wird die Datei im Schreibmodus geöffnet (a ... append (anhängend), w ... write (überschreibend)).
write() fügt hier also eine Zeile Text am Dateiende ein. close() schließt die Datei wieder.

Das close() kann man sich mit der with-Anweisung auch sparen.

 with open(&quot;datei.txt&quot;, mode=&quot;a&quot;, encoding=&quot;utf-8&quot;) as dat:
     dat.write(&quot;Hänge Zeile an\n&quot;)

= Benutzeroberflächen erstellen =
== tkinter ==
{{Wikipedia | Tkinter}}

Python bietet standardmäßig das Modul tkinter zur Programmierung von Benutzeroberflächen. Es müssen also bei der Verwendung von tkinter keine externen Module installiert werden. Hier wird eine (sehr) kurze Einführung in das Erstellen von grafischen Oberflächen mittels tkinter gegeben.

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 win.minsize(300, 50)
 but = tk.Button(win, text = &quot;Push the button&quot;)
 but.pack()
 win.mainloop()

Ausgabe:

[[Datei:PythonIng_gui1.jpg]]

Ein etwas komplizierteres Beispiel sei nachfolgend gezeigt. Es sollen zwei Strings miteinander verknüpft und ausgegeben werden. 

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 
 def on_button_clicked():
     str = ent1.get() + ent2.get()
     lab2[&quot;text&quot;] = str
  
 ent1 = tk.Entry(win)
 ent2 = tk.Entry(win)
 lab1 = tk.Label(win, text=&quot;verknuepfen mit&quot;)
 lab2 = tk.Label(win, text=&quot;&quot;) 
 but = tk.Button(win, text = &quot;=&quot;, command=on_button_clicked)
 
 ent1.pack(side=&quot;left&quot;)
 lab1.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 but.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 lab2.pack(side=&quot;left&quot;)
 
 win.mainloop()

Ausgabe  (vor der Eingabe der Teilstrings): 

[[Datei:PythonIng_gui2.jpg]]

Ausgabe (nach der Eingabe der Teilstrings und dem Drücken des =-Buttons): 

[[Datei:PythonIng_gui3.jpg]]

== curses ==
{{Wikipedia | curses}}

Mit dem curses-Modul lassen sich u.a. TUIs ('''T'''ext '''U'''ser '''I'''nterfaces) erstellen. Ein sehr einfaches Beispiel zur allgemeinen Funktionsweise wird nachstehend geliefert.
 
 import curses
 
 stdscr = curses.initscr()
 curses.start_color()
 curses.init_pair(1, curses.COLOR_RED, curses.COLOR_WHITE)
 stdscr.clear()
 
 stdscr.addstr(&quot;Hallo Welt&quot;, curses.color_pair(1))
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()
 
Als Ausgabe sollte &lt;span style=&quot;color:#FF0000;&quot;&gt;Hallo Welt&lt;/span&gt; (rote Schrift auf weißem Hintergrund) auf dem Terminal/der Konsole erscheinen. Getestet wurde dies mit openSUSE Tumbleweed, Python-Version 3.13.12. Das entsprechende Python-curses-Package muss installiert sein.

Allgemeine Informationen zur Terminal-/Konsolengröße und Cursorposition liefert folgendes Programm:
 
 import curses
 
 stdscr = curses.initscr()
 
 stdscr.addstr(3, 5, &quot;LINES: %d&quot; % curses.LINES)
 stdscr.addstr(4, 5, &quot;COLS:  %d&quot; % curses.COLS)
 
 (y,x) = stdscr.getyx()
 stdscr.addstr(5, 5, &quot;Momentane Cursorposition:  [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getbegyx()
 stdscr.addstr(6, 5, &quot;Koordinatenursprung:       [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getmaxyx()
 stdscr.addstr(7, 5, &quot;Fenstergröße:              [%d, %d]&quot; % (y, x))
 
 stdscr.addstr(11, 2, &quot;Taste drücken -&gt; Ende&quot;)
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()

Es sollte sich in etwa folgende Ausgabe ergeben:

     LINES: 44
     COLS:  110
     Momentane Cursorposition:  [4, 15]
     Koordinatenursprung:       [0, 0]
     Fenstergröße:              [44, 110]
 
 
 Taste drücken -&gt; Ende

Zur Funktionsweise von curses siehe auch das Wikibook [[ncurses]]. Zum Verständnis sind dort allerdings elementare Kenntnisse in der Programmiersprache C erforderlich.

== Qt ==
{{Wikipedia | Qt (Bibliothek)}}

Auch für das Qt-Framework gibt es eine Anbindung an Python. Nachfolgend ein einfaches Beispiel.

 import sys
 from PySide6.QtWidgets import QApplication, QLabel
 
 app = QApplication(sys.argv)
 label = QLabel(&quot;Hallo Welt!&quot;)
 label.show()
 sys.exit(app.exec())

Ausgabe:

[[Datei:PythonIng_gui10.png]]

== Gtk ==
{{Wikipedia | GTK (Programmbibliothek)}}

Eine idente Ausgabe, wie oben für Qt gezeigt, erzeugt z.B. folgendes Gtk-Programm:

 import gi
 gi.require_version(&quot;Gtk&quot;, &quot;4.0&quot;)
 from gi.repository import Gtk
 
 def on_activate(app):
     win = Gtk.ApplicationWindow(application=app)
     lab = Gtk.Label(label=&quot;Hallo Welt!&quot;)
     win.set_child(lab)
     win.present()
 
 app = Gtk.Application()
 app.connect('activate', on_activate)
 app.run(None)

Auch für die Benutzung von Qt und Gtk müssen die jeweiligen Packages installiert sein. Getestet wurden die entsprechenden Python-Programme nur unter openSUSE Tumbleweed. Wie das GTK-Paket unter MS Windows 11 installiert wird, siehe z.B. [https://www.gtk.org/docs/installations/windows Setting up GTK for Windows].

Damit sei aber das Thema &quot;Benutzeroberflächen erstellen&quot; hier abgeschlossen, da dies schon ein sehr spezielles Aufgabengebiet ist, das eher Informatiker und nicht so sehr Ingenieure anspricht. Bei Bedarf siehe aber ggf. die entsprechenden Links unten in diesem Tutorial. Dort sind weiterführende Informationen zu finden.

= Pandas kurz erklärt =
Hier wird kurz auf das externe Modul Pandas eingegangen. Pandas steht für '''Pan'''el '''Da'''ta und ist ein Modul für die Datenanalyse und -manipulation.

== Series ==
Vorstellbar ist eine &quot;Series&quot; wie eine einzelne Spalte in einem Tabellenkalkulationsprogramm.

Beispiel (Index implizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5]) # Temperaturwerte
 print(temp)

Ausgabe:
 0     8.5
 1    11.0
 2    12.5
 3    10.0
 4    13.0
 5    11.0
 6    14.5
 dtype: float64

Das Kürzel &lt;code&gt;pd&lt;/code&gt; ist Konvention. Es seien Temperaturwerte gegeben. Die erste Spalte bei der Ausgabe ist der Index. Die zweite Spalte enthält die Werte.

Beispiel (separater Zugriff auf den Index und auf die Werte):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5])
 print(temp.index)
 print(temp.values)

Ausgabe:
 RangeIndex(start=0, stop=7, step=1)
 [ 8.5 11.  12.5 10.  13.  11.  14.5]

Beispiel (Index explizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 print(&quot;*** Die gesamte Series ***&quot;)
 print(temp)
 
 print(&quot;*** Temperatur am Donnerstag ***&quot;)
 print(temp[&quot;Do&quot;])
 
 print(&quot;*** Tage wärmer als 12 Grad ***&quot;)
 temp_gr_12 = temp[temp &gt; 12]
 print(temp_gr_12)

Ausgabe:
 *** Die gesamte Series ***
 Mo     8.5
 Di    11.0
 Mi    12.5
 Do    10.0
 Fr    13.0
 Sa    11.0
 So    14.5
 dtype: float64
 *** Temperatur am Donnerstag ***
 10.0
 *** Tage wärmer als 12 Grad ***
 Mi    12.5
 Fr    13.0
 So    14.5
 dtype: float64

== DataFrame ==
Ein DataFrame entspricht einer Tabelle.

Beispiel (Erzeugen eines DataFrames):
 import pandas as pd
 
 tag   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 v1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=tag)
 v2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=tag)
 v3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=tag)
 
 tab = pd.concat([v1, v2, v3], axis=1)
 tab.columns = stadt
 
 print(tab)
 print(type(tab))

Ausgabe:
     Linz  Salzburg Innsbruck
 Mo     1         8     Hallo
 Di     2         9        16
 Mi     3        10        17
 Do     4        11        18
 Fr     5        12        19
 Sa     6        13        20
 So     7        14        21
 &lt;class 'pandas.core.frame.DataFrame'&gt;

Wir haben hier drei Datenspalten (v1, v2, v3) mit den Spaltennamen &quot;Linz&quot;, &quot;Salzburg&quot; und &quot;Innsbruck&quot;, sowie sieben Zeilen &quot;Mo&quot; bis &quot;So&quot;.

Beispiel (Zugriff auf eine Spalte):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab[&quot;Salzburg&quot;])

Ausgabe:
 Mo     8
 Di     9
 Mi    10
 Do    11
 Fr    12
 Sa    13
 So    14
 Name: Salzburg, dtype: int64

Beispiel (Zugriff auf eine Zeile):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab.loc[&quot;Di&quot;])

Ausgabe:
 Linz          2
 Salzburg      9
 Innsbruck    16
 Name: Di, dtype: object

== Grafiken erstellen ==
Hier sei nur ein Torten- oder Kreisdiagramm gezeichnet:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 expl = [0, 0.2, 0, 0, 0, 0, 0]
 temp.plot.pie(figsize=(5,5), explode=expl)
 plt.show()

Ausgabe:

[[Datei:IngPython_pandas1.svg|350px]]

Die &lt;code&gt;figsize&lt;/code&gt; hat nichts mit der Spaltenanzahl zu tun, sondern setzt die Fenster- oder Diagrammgröße in Inches (Breite * Höhe).
 
Mit Pandas kann man auch noch andere Diagrammarten erstellen, z.B. Linien- oder Balkendiagramme. Dies wird hier aber nicht vorgeführt.

== Arbeiten mit CSV- und LibreOffice-Dateien ==
Gegeben sei eine CSV-Datei test1.csv:
 Mai;Juni;Juli
 12;17;45
 15;65;65
 16;32;23
 4;14;7
 23;17;Keine Daten verfügbar
 67;Keine Daten verfügbar;45
 15;24;12

Lesen von dieser CSV-Datei:
 import pandas as pd
 
 tab = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 print(tab)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Schreiben in eine CSV-Datei test2.csv:
 import pandas as pd
 
 val = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 val.to_csv(&quot;test2.csv&quot;, index=False)

Ausgabedatei:
 Mai,Juni,Juli
 12,17,45
 15,65,65
 16,32,23
 4,14,7
 23,17,Keine Daten verfügbar
 67,Keine Daten verfügbar,45
 15,24,12

Die Ausgabedatei ist beinahe gleich wie die Eingabedatei. Es werden aber Kommas statt Strichpunkten verwendet. Daher kommt auch der Name CSV ('''C'''omma '''S'''eparated '''V'''alue). Will man wieder Strichpunkte, so kann man dies über den Parameter &lt;code&gt;sep=&quot;;&quot;&lt;/code&gt; in der &lt;code&gt;to_csv&lt;/code&gt;-Funktion machen.

Um direkt von einer ODS-Datei (LibreOffice Calc, '''O'''pen '''D'''ocument '''S'''preadsheet) zu lesen muss das Modul odfpy extra installiert sein (per YaST, pip etc.). Gelesen wird dann folgendermaßen:
 import pandas as pd
 
 df = pd.read_excel('test1.ods', engine='odf')
 print(df)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Die Datei &quot;test1.ods&quot; sei die Datei, aus der das obige &quot;test1.csv&quot; generiert wurde. Schreiben kann man ebenfalls in eine ODS-Datei:

 import pandas as pd
 
 daten = {
     &quot;Name&quot;: [&quot;Hugo&quot;, &quot;Richie&quot;, &quot;Wilhelmine&quot;],
     &quot;Alter&quot;: [38, 30, 29],
     &quot;Ort&quot;: [&quot;Linz&quot;, &quot;Innsbruck&quot;, &quot;Salzburg&quot;]
 }
 
 tab = pd.DataFrame(daten)
 
 with pd.ExcelWriter(&quot;test2.ods&quot;, engine=&quot;odf&quot;) as writer:
     tab.to_excel(writer, sheet_name=&quot;Daten&quot;, index=False)

Es ergibt sich eine &quot;test2.ods&quot;-Datei (Screenshot):

[[Datei:IngPython_pandas2.png|250px]]

== Sonstiges ==
Hier seien stichpunktartig einige weitere Features von Pandas angeführt:
* {{W|Pivot-Tabelle|Pivot-Tabellen}} (pivot ... Dreh-, Angelpunkt): Zweck - große Datenmengen schnell zusammenfassen, filtern und analysieren.
* NaN ('''n'''ot '''a''' '''n'''umber): In einem Datensatz fehlt ein Wert oder ist nicht definiert.
* groupby-Funktion: Daten strukturieren, aggregieren oder Zwischensummen bilden. 
* {{W|Binning#Datenverarbeitung_und_-analyse|Binning}}: Klassenbildung.
* Mehrstufige Indizierung (Hierarchical Indexing oder MultiIndex).
* Zeitreihen (Time Series).
* MS Excel-Dateien schreiben mit dem Modul openpyxl.

Für tiefergehende und weiterführende Informationen wird auf das Buch von ''Klein: Numerisches Python; Hanser, 2023'' und [https://pandas.pydata.org/ pandas] verwiesen.

= Style Guide, flake8, pylint, Black etc. =
== Style Guide ==
Wie man schönen und richtigen Python-Code schreibt, erfahren Sie in
* [https://peps.python.org/pep-0008/ PEP 8 – Style Guide for Python Code]

== Formatter und Linter ==
Ein Modul, das prüft, ob die Richtlinien im Style Guide eingehalten wurden, ist ''flake8'':
* [https://flake8.pycqa.org/en/latest/ Flake8: Your Tool For Style Guide Enforcement]

Code formatieren kann man auch mit [https://pypi.org/project/black/ Black]. Z.B. übersetzt &lt;code&gt;black test1.py&lt;/code&gt; die Datei &lt;code&gt;test1.py&lt;/code&gt;

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)),
     (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

in 

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)), (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Die Programmausgabe ist 

 reformatted test1.py
 
 All done! ✨ 🍰 ✨
 1 file reformatted.

Der Unterschied zwischen Black und Flake8:
* Black ist ein Code-Formatter. Er formatiert Ihren Code um, sodass er im Einklang mit PEP 8 steht.
* Flake8 ist ein {{W|Lint (Programmierwerkzeug) | Code-Linter}}. Flake8 verändert Ihren Code nicht, sondern durchsucht ihn nach potenziellen Fehlern etc.

Am obigen Beispiel sieht man auch, dass flake8 und Black nicht immer einer Meinung sind. Flake8 (&lt;code&gt;flake8 test1.py&lt;/code&gt;) würde standardmäßig den mit Black formatierten Code bemängeln:

 test1.py:8:80: E501 line too long (80 &gt; 79 characters)

Diese Diskrepanz kann beseitigt werden. Da 79 Zeichen auf modernen Bildschirmen meist als zu kurz empfunden werden, ist ein Limit von 88 Zeichen (Black-Standard) oder mehr empfehlenswert. Um dies zu implementieren, erstellen Sie in Ihrem Projektverzeichnis eine &lt;code&gt;.flake8&lt;/code&gt;-Datei mit dem Inhalt

 [flake8]
 max-line-length = 88

Und schon ignoriert Flake8 dieses Problem.

Ein anderer Linter ist pylint. Der würde beim Abarbeiten des obigen Beispiels, z.B. mit &lt;code&gt;pylint test1.py&lt;/code&gt; noch eine Kleinigkeit bemängeln:

 ************* Module test1
 /home/hr/tmp/test1.py:1:0: C0114: Missing module docstring (missing-module-docstring)
 
 ------------------------------------------------------------------
 Your code has been rated at 8.57/10 (previous run: 8.57/10, +0.00)

Auch pylint muss vor der ersten Verwendung installiert werden (z.B. mittels pip, virtuelle Umgebung, YaST). Die Dokumentation zu pylint findet sich auf [https://pylint.readthedocs.io/en/latest/].

&lt;u&gt;Aufgabe:&lt;/u&gt; Fügen Sie einen &quot;module docstring&quot; in die &lt;code&gt;test1.py&lt;/code&gt;-Datei ein und testen Sie erneut mit flake8, Black und pylint. &lt;small&gt;Sehen Sie zum Thema docstrings auch [https://peps.python.org/pep-0257/#what-is-a-docstring PEP 257 – Docstring Conventions].&lt;/small&gt;

Es gibt noch weitere Formatierungswerkzeuge für Python-Code. Z.B. [https://docs.astral.sh/ruff/ Ruff], ein moderner Code-Formatter und -Linter. Mittels &lt;code&gt;ruff check test1.py&lt;/code&gt; würde obiger Code geprüft (Linter). &lt;code&gt;ruff format test1.py&lt;/code&gt; formatiert den Code (Formatter).

== Type Checker ==
&quot;Type Checker&quot; sind z.B.
* mypy
* pyright
* ty

Diese prüfen die Datentypen, z.B. in folgendem Code

 def greetings(name: str) -&gt; str:
     return &quot;Hello, %s&quot; % name
 
 
 print(greetings(42))

Python selbst, flake8, ruff oder black würden diesen Code ohne zu murren akzeptieren. &quot;Type Checker&quot; würden aber sehr wohl Alarm schlagen, z.B. liefert &lt;code&gt;mypy&lt;/code&gt; folgende Ausgabe

 test1.py:5: error: Argument 1 to &quot;greetings&quot; has incompatible type &quot;int&quot;; expected &quot;str&quot;  [arg-type]
 Found 1 error in 1 file (checked 1 source file)

Das funktioniert übrigens nicht nur bei Funktionsannotationen, sondern auch mit Variablen etc.

 from typing import Final
 
 # &quot;Konstante&quot;, ab Python 3.8
 NUMBER: Final = 123
 print(NUMBER)
 NUMBER = 125
 print(NUMBER)
 
 # Variable
 a: int = 345
 print(a)
 a = &quot;Irgendwas&quot;
 print(a)
 
 # Variable (Pipe-Symbol), ab Python 3.10
 b : int|str = 567
 print(b)
 b = &quot;sonstiges&quot;
 print(b)

Ausgabe mit python:
 123
 125
 345
 Irgendwas
 567
 sonstiges

Ausgabe mit mypy:
 test3.py:6: error: Cannot assign to final name &quot;NUMBER&quot;  [misc]
 test3.py:12: error: Incompatible types in assignment (expression has type &quot;str&quot;, variable has type &quot;int&quot;)  [assignment]
 Found 2 errors in 1 file (checked 1 source file)

Python kennt übrigens keine Konstanten. Man kann diese mittels Großbuchstaben andeuten. Das ist aber nur Konvention, hat aber keine sonstigen Auswirkungen. Oder man verwendet wie oben gezeigt &lt;code&gt;Final&lt;/code&gt;. Dann werfen Typchecker Errors aus.

==pydoc==
pydoc ist ein Werkzeug, um Python-Module, -Funktionen und -Klassen zu dokumentieren.

Beispiel &lt;code&gt;test1.py&lt;/code&gt;:
 &quot;&quot;&quot;Rechen-Modul.
 
 Funktionen die von pydoc gelesen werden.
 &quot;&quot;&quot;
 
 def multiply(a, b):
     &quot;&quot;&quot;Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
     
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a * b
     
 def add(a, b):
     &quot;&quot;&quot;Addiert zwei Zahlen und gibt das Ergebnis zurück.
    
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a + b
    
 
 if __name__ == '__main__':
     print(multiply(3, 5))
     print(add(4, 6))

Ausgabe mit &lt;code&gt;python3.13 -m pydoc test1&lt;/code&gt; auf der Konsole:

 Help on module test1:
 
 NAME
     test1 - Rechen-Modul. 
 
 DESCRIPTION
     Funktionen die von pydoc gelesen werden.
 
 FUNCTIONS
     add(a, b)
         Addiert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
     multiply(a, b)
         Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
 FILE
     /home/xyz/tmp/test1.py

Siehe zu diesem Thema z.B. auch [https://docs.python.org/3/library/pydoc.html]. Mittels &lt;code&gt;python3.13 -m pydoc -w test1&lt;/code&gt; kann man auch eine HTML-Dokumentation erstellen.

Wofür &lt;code&gt;if __name__ == '__main__':&lt;/code&gt; steht, siehe z.B. etwas später im Abschnitt [[Ing_Mathematik:_Python#Doctests]].

== Sonstige Tools ==
Andere Tools für die {{W|Statische Code-Analyse|statische Codeanalyse}}, die aber für Ingenieure weniger interessant sein dürften, sind z.B.
* Radon: Liefert verschiedene {{W|Softwaremetrik|Codemetriken}} (Komplexität, Wartbarkeitsindex ...)
* Bandit: Findet Sicherheitslücken

Tools für die {{W|Dynamisches Software-Testverfahren|dynamische Codeanalyse}}, z.B.:
* DynaPyt (Framework zur dynamischen Programmanalyse)
* cProfile (Profiler)
* Memory Profiler (Speicheranalyse)
* Memray (Speicheranalyse)
* tracemalloc (Speicheranalyse)

Paket- und Projektmanagement (pip-Ersatz etc.):
* uv
* Poetry
* Conda
* pipx

Packaging-Tools (Freezer) und {{W|Compiler#Sonderformen|Transpiler}} :
* pyinstaller
** erstellt eigenständige, ausführbare Binärdatei
** kein Cross-Compiler
** kein Schutz vor Reverse-Engineering
** langsam
** packt alles in eine Datei
** sehr große Datei
** Befehl, z.B.: &lt;code&gt;pyinstaller --onefile test1.py&lt;/code&gt;
** GUI: &lt;code&gt;auto-py-to-exe&lt;/code&gt;
* cx_Freeze
* nuitka
** Übersetzt Python-Code in C/C++-Code und weiter in eine ausführbare Datei
** kein Cross-Compiler
** Schutz vor Reverse-Engineering
** Befehl, z.B.: &lt;code&gt;nuitka --standalone --onefile test1.py&lt;/code&gt;
* cython

= Einige Integrierte Entwicklungsumgebungen (IDEs)=
Werden Programmtexte größer und umfangreicher, so ist das Arbeiten mit der interaktiven Programmierumgebung bzw. das direkte Ausführen von Python-Skripten mühsam. Man wünscht sich z.B. Hilfen zum Debuggen oder die automatische Code-Vervollständigung. Zu diesem Zweck wurden IDEs (Integrated Development Environments) geschaffen. Von diesen seinen nachfolgend auszugsweise einige kurz beschrieben. Testen Sie einfach aus, welche davon für Sie bzw. für Ihr Python-Projekt geeignet sind.

== IDLE ==
IDLE ist die mit dem Python-Programmpaket mitgelieferte IDE. Der Name leitet sich einerseits ab vom Monty-Python-Mitglied Eric Idle, andererseits steht es als Abkürzung für &quot;'''I'''ntegrated '''D'''evelopment and '''L'''earning '''E'''nvironment. IDLE ist einfach zu bedienen, bietet aber schon einen beachtlichen Leistungsumfang. Nachfolgend wird ein Screenshot zu IDLE geliefert. Rechts ist das Editor-Fenster zu sehen, links die interaktive Programmierumgebung. Um das Beispiel selbst nachvollziehen zu können, starten Sie IDLE. Das geht ähnlich, wie Sie die interaktive Programmierumgebung von Python starten (nur, dass Sie eben das IDLE-Icon doppelklicken und nicht das Python-Icon. Unter Linux geben Sie einfach in einem Terminal &lt;code&gt;idle3.13&lt;/code&gt; o. Ä. ein). Weiter geht es mit &quot;File - Open - ...&quot;. Die auszuführende Datei auswählen (im konkreten Fall ein &quot;Hallo-Welt&quot;-Programm). Es erscheint das rechte Fenster. Dort &quot;Run - Run Module&quot; auswählen. Und schon wird im linken Fenster &quot;Hallo Welt!&quot; ausgegeben.

[[Datei:PythonIng_idle1.jpg | 600px]]

Siehe auch {{W|IDLE}}.

== PyCharm ==
PyCharm ist ein kommerzielles Produkt. Es gab aber auch eine kostenlose Community Edition. Seit 2025 sind beide Varianten vereint. Für die ersten 30 Tage sind die Pro-Funktionen frei verfügbar, danach nur noch die Kernfunktionalitäten (oder man bezieht kostenpflichtig  die Pro-Version). Zu beziehen ist PyCharm unter dem Weblink [https://www.jetbrains.com/pycharm/]. Nachfolgend ein etwas abgewandeltes &quot;Hallo Welt&quot;-Programm, editiert und ausgeführt mit PyCharm.

[[Datei:PyCharm_IDE_2023_screenshot.png | 600px]]

Siehe auch {{W|PyCharm}}.

== Eric ==
Auch eric ist Open Source und steht unter der  GNU General Public License Version 3 oder später. Zu beziehen ist diese Software unter [https://eric-ide.python-projects.org/].

[[Datei:Screenshot_Eric_4.png | 600px]]

Siehe auch {{W|eric (Software)}}.

&lt;small&gt;
Unter openSUSE Tumbleweed sollte sich eric auch mit YaST installieren lassen. Bei mir gibt es aber dann beim Ausführen des eric-Programms eine Fehlermeldung (Stand März 2026): 
 
 ...
 ModuleNotFoundError: No module named 'PyQt6.QtPdfWidgets'

Umgehen kann man dieses Problem aber wieder mit dem Erstellen einer virtuellen Umgebung, in etwa so

 python3.13 -m venv ~/tmp/venv1
 cd ~/tmp/venv1/bin
 ./python3.13 -m pip install --upgrade --prefer-binary eric-ide
 ./eric7_ide
&lt;/small&gt;

== PyScripter ==
Vom Funktionsumfang vergleichbar mit den vorherigen IDEs ist PyScripter. Auch PyScripter ist Open Source. Die Projekt-Homepage findet sich auf [https://sourceforge.net/projects/pyscripter/]. PyScripter ist nur für MS Windows verfügbar.

[[Datei:PythonIng_pyscripter1.jpg | 600px]]

== Spyder IDE ==
Spyder enthält bereits eine stabile Python-Version und etliche Module (z.B. matplotlib, numpy, control). Ansonsten kann dieses Softwarepaket vom Funktionsumfang her mit den anderen genannten IDEs locker mithalten. Spyder wurde unter der MIT-Lizenz veröffentlicht. Diese Software findet sich auf [https://www.spyder-ide.org].

[[Datei:Spyder-windows-screenshot.png | 600px]]

Siehe auch {{W|Spyder (Software)}}

== Eclipse IDE==
Die {{W|Eclipse_(IDE)|Eclipse-IDE}} kann für Python aufgerüstet werden. Dazu gibt es das PyDev-Plugin. Installiert wird es über 
* Help &gt; Eclipse Marketplace... 
* Find - PyDev - Install
Danach muss noch der Pfad zum Python-Interpreter festgelegt werden 
* Window &gt; Preferences &gt; PyDev &gt; Interpreters &gt; Python Interpreter &gt; New ... 
Das Ergebnis ist ähnlich wie im folgenden Bild, nur dass statt C/C++ Python Verwendung findet. 

[[Datei:Setting Up Eclipse CDT helloout.png | 600px]]

== Sonstige ==
Die genannten IDEs sind nicht die Einzigen. Es gibt, um dem Image Pythons als beliebteste Programmiersprache gerecht zu werden, noch einige andere. Sowohl Open Source-Programme als auch kommerzielle Programme sind im Web zu finden, z.B. Thonny oder {{W|Visual Studio Code}}. Unter Linux kann man auch {{W|KDevelop}}, ausgestattet mit dem Python3-Plugin, einsetzen. Braucht man den Umfang von ausgewachsenen IDEs nicht, so kann man auch normale Texteditoren verwenden (z.B. {{W|Geany}} oder {{W|Kate_(Texteditor)|Kate}}).

= Debuggen und Testen =
Das Debuggen und Testen von Programmen sind wichtige Bestandteile der Programmierung. Syntaxfehler lassen sich i.A. leicht beheben. Schwieriger ist das Eingrenzen von logischen Fehlern, die ev. nur in bestimmten Situationen auftreten und keine explizite Fehlermeldung hervorrufen. Das Programm liefert falsche Ergebnisse oder es stürzt aus heiterem Himmel ab. Um das zu verhindern gibt es verschiedene Werkzeuge, die bei der Fehlersuche behilflich sein können. Vorerst siehe aber zwecks Begriffsklärung noch folgende Links: 
 
* {{W|Debuggen}}
* {{W|Debugger}}
* {{W|Softwaretest}}

&lt;gallery&gt;
First Computer Bug, 1947.jpg
Test ganzheitlich.png
V-Modell.svg
&lt;/gallery&gt;

== Das Modul pdb ==
Python bringt schon ein Modul zum Debuggen mit. Siehe z.B. [https://docs.python.org/3/library/pdb.html pdb — The Python Debugger].
Komfortabler lässt sich das aber mittels Integrierter Entwicklungsumgebungen (IDEs) angehen.

== Debuggen mit IDEs ==
Für die IDEs IDLE und Spyder sei kurz auf die entsprechenden Webseiten verwiesen:

* [https://www.cs.uky.edu/~keen/help/debug-tutorial/debug.html Debugging under IDLE].
* [https://docs.spyder-ide.org/current/panes/debugging.html Spyder Debugger]

Dort wird die Vorgehensweise auch mittels Screenshots erläutert.

== assert ==
assert ... behaupten, zusichern ({{W|Assertion (Informatik)}})

Python-Code:
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10., 0.)

Ausgabe:

 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10., 0.)
   File &quot;/home/hr/Develop/test1.py&quot;, line 4, in print1
     assert y != 0.0
            ^^^^^^^^
 AssertionError
 
Python-Code: 
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)
 
Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(&quot;10.&quot;, &quot;5.&quot;)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError
 
Aber auch bei nachfolgendem Code gibt es eine Fehlermeldung:

 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10, 5)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError

Damit letzteres funktioniert, kann man den Programmcode so umschreiben:
 def print1(x, y):
     assert type(x) == float or type(x) == int
     assert type(y) == float or type(y) == int
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 2.0
 
Und jetzt fangen wir den &lt;code&gt;AssertionError&lt;/code&gt; auf:
 def print1(x, y):
     try:
         assert type(x) == float or type(x) == int
         assert type(y) == float or type(y) == int
         assert y != 0.0
         print(x/y)
     except(AssertionError):
         print(&quot;Hallo&quot;)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)

Ausgabe:
 2.0
 Hallo

Ich hoffe, es ist wenigstens im Ansatz klar geworden, wofür &lt;code&gt;assert&lt;/code&gt; gut sein kann. Ausschalten kann man die &lt;code&gt;assert&lt;/code&gt;-Überprüfung übrigens mit dem Python-Schalter &lt;code&gt;-O&lt;/code&gt;.

== Doctests == 
Innerhalb eines Docstrings kann die Arbeit im interaktiven Modus simuliert werden. Nach den Promptzeichen (&gt;&gt;&gt;) erfolgen dann bei unserem Beispiel innerhalb des Docstrings simulierte Aufrufe der Funktion &lt;code&gt;print1()&lt;/code&gt;. Danach folgen jeweils die Sollresultate. Wird das Modul oder die Datei als Hauptprogramm aufgerufen, so wird die Funktion &lt;code&gt;doctest.testmode()&lt;/code&gt; aufgerufen und ein Bericht auf der Konsole ausgegeben. Wird das Modul nicht als Hauptprogramm aufgerufen, sondern importiert, dann wird diese &lt;code&gt;testmod&lt;/code&gt;-Funktion nicht aufgerufen. D.h. dieser Code kann sowohl für Testzwecke als auch für den produktiven Einsatz verwendet werden. Das ist auch sinnvoll, weil wenn man Teile der Datei immer löschen bzw. einfügen müsste, so würden sich Fehlerquellen auftun. Das würde den Sinn und Zweck von Doctests konterkarieren.  

 def print1(x=0., y=1.):
     &quot;&quot;&quot; Dividiere zwei Zahlen
     Autor: Intruder
     Datum: 12.08.2025
 
     &gt;&gt;&gt; print1(2., 1.)
     2.0
     &gt;&gt;&gt; print1(5., 2.)
     2.5
     &gt;&gt;&gt; print1(5.)
     5.0
     &quot;&quot;&quot;
     print(x/y)
 
 if __name__ == &quot;__main__&quot;:
     import doctest
     doctest.testmod(verbose=True)

Ausgabe:
 Trying:
     print1(2., 1.)
 Expecting:
     2.0
 ok
 Trying:
     print1(5., 2)
 Expecting:
     2.5
 ok
 Trying:
     print1(5.)
 Expecting:
     5.0
 ok
 1 items had no tests:
     __main__
 1 items passed all tests:
    3 tests in __main__.print1
 3 tests in 2 items.
 3 passed and 0 failed.
 Test passed.

Das gezeigte Beispiel ist so ziemlich das einfachste, das es gibt. Für weiterführende Details siehe z.B.:
* [https://peps.python.org/pep-0257/ PEP 257 – Docstring Conventions]
* [https://docs.python.org/3/library/doctest.html doctest — Test interactive Python examples]

''Einschub:'' Ganz ähnlich kann man auch Klassen testen, z.B. in folgendem Code-Fragment

 class Fahrzeug:
   # siehe Abschnitt &quot;Objektorientierte Programmierung&quot;
   # ...
 
 if __name__ == &quot;__main__&quot;:
   vauweh = Fahrzeug(170, 90)
   beemweh = Fahrzeug(200, 120)
   print(vauweh.convertGeschw())
   print(beemweh.convertGeschw())

Wird das Script als Hauptprogramm ausgeführt (z.B. zu Testzwecken), so erfolgt die Ausgabe der zwei, via &lt;code&gt;convertGeschw()&lt;/code&gt;, umgerechneten Geschwindigkeiten. Wird es aber als Modul eingebunden, so wird der letzte Programmabschnitt nicht ausgeführt (&lt;code&gt;__name__ == &quot;__main__&quot;&lt;/code&gt; ergibt &lt;code&gt;False&lt;/code&gt;).

== pytest ==
Siehe zu diesem Thema auch {{W|Modultest}}.

pytest ist ein externes Modul und muss vorab installiert werden, z.B. mittels 
 pip install -U pytest
 pip install -U pytest-html 

Python-Code, Datei test1.py:
 def add(x, y):
     return x + y
 
 def test_answer():
     assert add(1, 1) == 3

Starten von pytest in der Konsole:
 pytest test1.py
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py F                                                                                                            [100%]
 
 ========================================================= FAILURES ==========================================================
 ________________________________________________________ test_answer ________________________________________________________
 
     def test_answer():
 &gt;       assert add(1, 1) == 3
 E       assert 2 == 3
 E        +  where 2 = add(1, 1)
 
 test1.py:6: AssertionError
 ================================================== short test summary info ==================================================
 FAILED test1.py::test_answer - assert 2 == 3
 ===================================================== 1 failed in 0.09s =====================================================

Hier erhalten wir einen Fehler, da 1+1 eindeutig ungleich 3 ist. Aber aus irgendeinem Grund wollte der Programmierer oder Tester in diesem Fall, dass dies so ist. Testfälle werden übrigens mit dem Präfix &lt;code&gt;test_&lt;/code&gt; eingeleitet.

Python-Code:
 def add(x, y):
     return x + y + 1
 
 def test_answer():
     assert add(1, 1) == 3 
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py .                                                                                                            [100%]
 
 ===================================================== 1 passed in 0.01s =====================================================

Jetzt ist alles in Ordnung. Weiterführendes siehe z.B.

* [https://docs.pytest.org/en/stable/ pytest: helps you write better programs]

== unittest ==
Auch unittest dient zur Durchführung von Testreihen, ist aber Bestandteil von Python. Hier wird vorerst nicht näher darauf eingegangen. Siehe z.B. 
* [https://docs.python.org/3/library/unittest.html unittest — Unit testing framework]

Lt. ''Inden: Python Challenge; dpunkt, 2021, Seite 481''  soll unittest weniger komfortabel als pytest sein.

Einen Vergleich von unittest mit pytest findet man in
* [https://knapsackpro.com/testing_frameworks/difference_between/pytest/vs/unittest pytest vs unittest]

= Python und Anwendungsprogramme =
Bisher stand immer alleine die Programmiersprache Python (ev. unter Einbeziehung von Modulen) im Mittelpunkt der Betrachtungen. Aber Python kann auch als Makrosprache für Anwendungsprogramme auftreten. Als Beispiele seien {{W|FreeCAD}} und {{W|LibreOffice}} genannt.

== FreeCAD ==
FreeCAD ist ein freies 3D-CAD-Programm. Hier soll nicht auf die Bedienung dieses CAD-Pakets eingegangen werden, sondern nur auf die Möglichkeit, mittels Python Makros zu schreiben. Als einfacher Einstieg soll ein Makro erstellt werden, welches eine Kugel (rot) und einen Quader (blau) zeichnet. Folgende Vorbereitungsschritte sind erforderlich (es sei vorausgesetzt, dass FreeCAD schon am Rechner installiert ist. Downloaden können Sie das Programm von der Website [https://www.freecad.org/downloads.php?lang=en]):

* FreeCAD starten
* Leere Datei erstellen
* Makro &gt; Makros &gt; Erstellen ...

Es öffnet sich ein leeres Editorfenster, in das Sie folgenden Code eingeben können:

 import FreeCAD
 import Part
 
 doc = FreeCAD.newDocument()
 
 # Kugel
 kugel = Part.makeSphere(10)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Kugel&quot;)
 form_element.Shape = kugel
 kug = FreeCAD.ActiveDocument.getObject(&quot;Kugel&quot;)
 kug.ViewObject.ShapeColor = (1.0, 0.0, 0.0)
 neuePosition = App.Vector(5, 2.5, 2.5)
 kug.Placement = App.Placement(neuePosition, kug.Placement.Rotation)
 
 # Quader
 quader = Part.makeBox(5, 5, 50)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Quader&quot;)
 form_element.Shape = quader
 quad = FreeCAD.ActiveDocument.getObject(&quot;Quader&quot;)
 quad.ViewObject.ShapeColor = (0.0, 0.0, 1.0)
 
 doc.recompute()

Diesen Code können Sie nun ausführen:
* Makro &gt; Makro ausführen

Es ergibt sich folgende Ausgabe (gedreht und gezoomt):

[[Datei: PythonIng_freecad1.png|500px]]

Siehe auch [https://wiki.freecad.org/Python_scripting_tutorial/de# Anleitung Skripterstellung mit Python]. Getestet wurde obiges Beispiel mit FreeCAD 1.1.3 unter Linux und 1.1.1 unter MS Windows.

== LibreOffice ==
LibreOffice ist ein freies Officepaket ([https://de.libreoffice.org/]). Hier soll nur das Tabellenkalkulationsprogramm Calc kurz betrachtet werden. Es seinen in den ersten 3 Zellen (A1 bis A3) Zahlen gegeben. Diese sollen mit einem Python-Makro addiert und das Resultat in der Zelle A5 ausgegeben werden. Auch hier sind Vorbereitungsarbeiten nötig: 
* zuerst muss unter Linux das Verzeichnis &lt;code&gt;~/.config/libreoffice/4/user/Scripts/python&lt;/code&gt; erstellt werden
* für MS Windows ist es das Verzeichnis &lt;code&gt;%APPDATA%\LibreOffice\4\user\Scripts\python&lt;/code&gt; 
** drücken Sie zuerst Win + R (es öffnet sich das Ausführen-Fenster)
** geben Sie &lt;code&gt;%appdata%&lt;/code&gt; ein, danach drücken Sie Enter (es öffnet sich der Explorer)
** navigieren Sie zu dem genannten Verzeichnis bzw. erstellen Sie das Verzeichnis 
* in diesem Verzeichnis wird dann mit einem beliebigen Texteditor das Python-Makro erstellt, in unserem Fall die Datei &lt;code&gt;summiere_zellen.py&lt;/code&gt;:

 import uno
 
 def summiere_zellen(*args):
     # Zugriff auf das aktuelle Dokument und das aktive Tabellenblatt
     ctx = uno.getComponentContext()
     smgr = ctx.getServiceManager()
     desktop = smgr.createInstanceWithContext(&quot;com.sun.star.frame.Desktop&quot;, ctx)
     doc = desktop.getCurrentComponent()
     sheet = doc.getCurrentController().getActiveSheet()
 
     # Werte aus den Zellen A1 bis A3 auslesen
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
 
     # Addition der drei Werte
     summe = w1 + w2 + w3
 
     # Ergebnis in die Zelle A5 schreiben
     sheet.getCellRangeByName(&quot;A5&quot;).Value = summe

* siehe dazu ggf. auch [https://help.libreoffice.org/latest/de/text/sbasic/python/python_locations.html?DbPAR=BASIC].

Weiter geht es in LibreOffice Calc mit dem Menü ''Extras &gt; Makros &gt; Makros verwalten &gt; Python''. Dort wird das Makro &lt;code&gt;summiere_zellen&lt;/code&gt; ausgeführt. Es ergibt sich z.B. folgendes Resultat

[[Datei:PythonIng_libreoffice1.png]]

Das Kürzel &lt;code&gt;uno&lt;/code&gt; steht für '''U'''niversal '''N'''etwork '''O'''bjects. Etwas einfacher geht's auch so:

 def summiere_zellen():
     desktop = XSCRIPTCONTEXT.getDesktop()
     model = desktop.getCurrentComponent()
     sheets = model.getSheets()
     sheet = sheets.getByIndex(0)
     
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
     
     cell = sheet.getCellRangeByName(&quot;A5&quot;)    
     cell.setValue(w1 + w2 + w3) 

Empfohlen wird auch, das Erweiterungspaket APSO ('''A'''lternative '''P'''ython '''S'''cript '''O'''rganizer, apso.oxt) zu installieren. Die Vorgehensweise wird hier nicht gezeigt, sondern nur darauf hingewiesen, dass man das einfach &quot;googeln&quot; kann. Siehe zur Python-Programmierung für LibreOffice auch [https://wiki.documentfoundation.org/Macros/Python_Guide/de Makros/Python-Handbuch]. Getestet wurden obige Beispiele mit LibreOffice 26.2.5.1 unter Linux und 26.2.1.2 unter MS Windows.

= Ausblick =
Dies war eine kurze Einführung in die Berechnungs- und Darstellungsmöglichkeiten mit Python. Es sollten etliche relevante Themen behandelt, oder zumindest kurz angesprochen worden sein. Wem dieser Text nicht ausreichend ist, der sei auf die entsprechenden weiterführenden Weblinks, Bücher und die Python-Hilfefunktion verwiesen. Python kennt noch viel mehr Befehle, als hier dargestellt wurden. Das Themenspektrum ist auch durch die Einbindung externer Module fast beliebig erweiterbar.

= Weblinks=
== Python allgemein ==
* [https://www.python.org/ Python Homepage]

== Externe mathematische Module ==
* [https://numpy.org/ NumPy]
* [https://numpy.org/doc/stable/user/numpy-for-matlab-users.html NumPy for MATLAB users]
* [https://scipy.org/ SciPy]
* [https://www.sympy.org/en/index.html SymPy]
* [https://pandas.pydata.org/ pandas]
* [https://github.com/maroba/findiff findiff]
* [https://mpmath.org/ mpmath]

== Externe Module für Grafiken ==
* [https://matplotlib.org/ Matplotlib]
* [https://vpython.org/ VPython]
* [https://build123d.readthedocs.io/en/latest/ build123d]
* [https://docs.vtk.org/en/latest/api/python.html VTK]
* [https://docs.bokeh.org/en/latest/docs/first_steps.html bokeh]
* [https://py5coding.org/ py5]

== Erstellung von User Interfaces ==
* [https://docs.python.org/3/library/tkinter.html tkinter - Python interface to Tcl/Tk]
* [https://docs.python.org/3/library/curses.html curses - Terminal handling for character-cell displays]
* [https://wiki.qt.io/Qt_for_Python Qt for Python]
* [https://www.gtk.org/docs/language-bindings/python GTK and Python]

== Erstellen virtueller Umgebungen ==
* [https://docs.python.org/3/library/venv.html venv - Creation of virtual environments]

== Sonstige ==
* [https://python-control.readthedocs.io/en/stable/ Python Control Systems Library]
* [https://pypi.org/project/regex/ regex - Regular Expressions]
* [http://pyromat.org/ PYroMat]
* [https://coolprop.org/coolprop/wrappers/Python/index.html CoolProp]
* [https://pypi.org/project/iapws/ iapws]
* [https://tespy.readthedocs.io/en/main/getting_started/introduction.html TESPy - Thermal Engineering Systems in Python]
* [https://pint.readthedocs.io/en/stable/ pint]

= Bücher =
== Gedruckte Bücher, OpenBooks, Magazine ==
* Diverse: c't Python Lernen, Verstehen, Anwenden; Heise, 2022 
* Ernesti, Kaiser: Python3 - das umfassende Handbuch; 5. Aufl., Rheinwerk, [https://openbook.rheinwerk-verlag.de/python/ OpenBook]
* Iacono et al.: Programmieren trainieren; 3. Aufl., Hanser, 2023, ISBN 978-3-446-47766-7
* Inden: Python Challenge; dpunkt, 2021, ISBN 978-3-86490-809-5
* Klein: Numerisches Python; 2. Aufl., Hanser, 2023, ISBN 978-3-446-47170-2 
* Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler; Rheinwerk, 2021, ISBN 978-3-8362-7316-9
* Weigend: Python 3 - Das umfassende Praxisbuch; 9. Aufl., mitp, 2022, ISBN 978-3-7475-0544-1
* Woyand: Python für Ingenieure und Naturwissenschaftler; 4. Aufl., Hanser, 2021, ISBN 978-3-446-46483-4

== Andere Wikibooks ==
* [[:en:Subject:Python_programming_language | Englische Wikibooks zum Thema Python]]
* [[Python|Deutschsprachiges Python-Wikibook]] [[Bild:2von10.png|20%]]
* [[Python unter Linux|Python 2.7 unter Linux]] [[Bild:10von10.png|100%]]


{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}</text>
      <sha1>5v4fy82tfigcu3c2y0nwycijrj9b0ny</sha1>
    </revision>
    <revision>
      <id>1092174</id>
      <parentid>1092173</parentid>
      <timestamp>2026-10-16T19:17:27Z</timestamp>
      <contributor>
        <username>Intruder</username>
        <id>1513</id>
      </contributor>
      <comment>/* Interpolation */</comment>
      <origin>1092174</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="189771" sha1="mndz187nvkl0x8v2xoi76y62fyplv2q" xml:space="preserve">{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}


= Hallo Welt und allgemeine Hinweise =
== Was ist Python ==
* Python ist eine universelle höhere Programmiersprache.
* Python ist objektorientiert.
* Python ist Open-Source (Python Software Foundation License).
* Python ist für viele Betriebssysteme erhältlich (z.B. für Linux, MS Windows, macOS).
* Python ist ein Interpreter.
* Python ist durch Module fast beliebig erweiterbar.
* Python als Programmiersprache ist case-sensitive - d.h. Groß- und Kleinschreibung ist relevant bei der Eingabe von Befehlen.
* Python ist in etlichen Anwendungsprogrammen (z.B. {{W|FreeCAD}}, {{W|LibreOffice}}, {{W|GIMP}}, {{W|Blender (Software) | Blender}}) als Makrosprache verwendbar.

{{Wikipedia | Python (Programmiersprache)}}

== Python installieren ==
=== MS Windows ===
Laden Sie das aktuelle Python-Paket von der Webseite [https://www.python.org/] herunter. Weiter geht es wie bei jedem anderen größeren zu installierenden Programm. Einfach das Installationsprogramm im Explorer doppelklicken und den Anweisungen des Setup-Programmes folgen.

=== Linux ===
Entweder ist Python bereits standardmäßig installiert, ansonsten ist die Installation mittels Paketmanagementsystem einfach möglich. Aber auch die Spyder-Entwicklungsumgebung ([https://www.spyder-ide.org]) bietet einen guten Einstieg mit Python (das gilt auch für MS Windows). Spyder bringt auch schon etliche wichtige Module standardmäßig mit.

== Python starten ==
=== MS Windows ===
Das Icon für das Python-Programm doppelklicken. Und schon startet das Programm.

[[Datei:PythonIng_start1.jpg]]

Python im interaktiven Modus (REPL ... '''R'''ead-'''E'''valuate-'''P'''rint-'''L'''oop) präsentiert sich dann so:

 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

Alternativ kann das Programm auch über die Eingabeaufforderung oder die PowerShell gestartet werden:

 c:\devel\Python&gt;python.exe
 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

=== Linux ===
Tippen Sie einfach das Wort „python“ (oder unter openSUSE Tumbleweed z.B. auch „python3.11“ oder „python3.13“) in einem Linux-Terminal ein, schließen den Befehl mit der RETURN-Taste ab, und schon startet Python im interaktiven Modus:
 
 Python 3.13.12 (main, Feb 09 2026, 22:37:44) [GCC] on linux
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt; 

Es gibt auch noch andere Möglichkeiten Python zwecks Programmausführung zu starten, z.&amp;nbsp;B. den {{W|Shebang}} (&lt;code&gt;#!&lt;/code&gt;) am Beginn eines Python-Scripts. Das Script sei als Script.py gespeichert. Dann kann das Script mit ./Script.py ausgeführt werden. Für openSUSE Tumbleweed sei nachfolgend ein lauffähiges &quot;Hallo Welt!&quot;-Script angegeben. Es wird in diesem Script der Python-Interpreter in der Version 3.13 verwendet :

 #!/usr/bin/python3.13
 print(&quot;Hallo Welt!&quot;)

Die Berechtigungen zum Ausführen der Datei müssen natürlich noch richtig gesetzt werden, z.B. mittels &lt;code&gt;chmod 777 Script.py&lt;/code&gt;. &lt;small&gt;&lt;code&gt;chmod&lt;/code&gt; ist die Abkürzung für&quot;'''ch'''ange file '''mod'''e bits&quot;.&lt;/small&gt; 

&lt;small&gt;Die &quot;Maske&quot; &lt;code&gt;777&lt;/code&gt; ist nur für Testzwecke sinnvoll, weil sie leicht zu merken ist und für alle Benutzer alle Zugriffsberechtigungen ('''r'''ead/'''w'''rite/e'''x'''ecute für owner/group/others) setzt. Im richtigen Einsatz wird man das aus Sicherheitsgründen nicht so handhaben, sondern nur die Berechtigungen setzen, die unbedingt erforderlich sind. Welche Zugriffsberechtigungen gesetzt sind, kann man z.B. mit dem Befehl &lt;code&gt;ls -l&lt;/code&gt; oder &lt;code&gt;ll&lt;/code&gt; ('''l'''i'''s'''t directory contents) erfragen. Aber dazu im Moment genug. Erfahrene Linux-Nutzer kennen das ohnehin und Anfänger sollen jetzt nicht mit Linux-Interna überfordert werden. Bei Bedarf siehe die Linux-Man-Pages oder dezidierte Bücher zu Linux.&lt;/code&gt;&lt;/small&gt;

&lt;small&gt;Oder das Script wird in einen Pfad verschoben, in dem sich ausführbare Programme generell befinden (welche Verzeichnisse im PATH liegen, kann bspw. mit &lt;code&gt;echo $PATH&lt;/code&gt; abgefragt werden). Das Script kann dann wie ein normales Programm ohne weitere Angaben mit Script.py gestartet werden. Alternativ wird nicht das Script an sich verschoben, sondern nur ein symbolischer Link angelegt, z.B. mit &lt;code&gt;ln -s ~/tmp/Script.py ~/.local/bin/Script.py&lt;/code&gt;. &lt;code&gt;~/.local/bin&lt;/code&gt; sei ein im PATH gelegenes Verzeichnis. Dies sind aber schon Features für fortgeschrittene Linux-Benutzer und werden am Anfang eher selten benötigt.&lt;/small&gt;

== Ein paar Worte zur Erklärung ==
=== Tests ===
Getestet wurden die Beispiele unter den Betriebssystemen 
* MS Windows 10 mit der Python-Version 3.12.0 (teilweise auch mit 3.12.2 und 3.13.1; nur die Inhalte die bis spätestens Juli 2025 erstellt wurden) 
* MS Windows 11 ab der Python-Version 3.13.4 (nur zum Teil; ab Juli 2025)
* openSUSE Leap 15.6 mit der Python-Version 3.11.12 (Spyder, nur vereinzelt) und zum Teil mit 3.12.11 (ab Juli 2025 bis November 2025).
* openSUSE Tumbleweed ab der Python-Version 3.13.9 (nur vereinzelt, ab November 2025)

=== Popularität ===
* An Beliebtheit rangiert Python mit Stand September 2026 mit einem Rating von 17,76% an 1. Stelle vor C und C++ (lt. [https://www.tiobe.com/tiobe-index/ TPCI - TIOBE Programming Community Index]). 
* Lt. [https://innovationgraph.github.com/global-metrics/programming-languages GitHub Top 50 Programming Languages Globally] lag Python im Q1/2026 auf Rang 2, vor TypeScript und hinter JavaScript. 
* [https://pypl.github.io/PYPL.html PYPL] (Popularity of Programming Language Index) ist ein anderer Popularitätsindex für Programmiersprachen. Auch hier liegt Python mit großem Vorsprung auf dem ersten Platz (52,08%), gefolgt von Java (13,34%) und C/C++ (7,99%) (Stand September 2026). 

=== Namensgebung ===
Der Name &quot;Python&quot; rührt von der Komikertruppe {{W|Monty Python}} her. Die Icons für Python (z.B. Python selbst, Eric IDE, IDLE) sind aber durch die Python-Schlangenart symbolisiert.

&lt;gallery&gt;
Python-logo-notext.svg|Python-Logo
Guido van Rossum in PyConUS24.jpg|{{W|Guido van Rossum}} (geb. 1956), der Erfinder von Python
&lt;/gallery&gt;

== Ein erstes Programm ==
Kommentare werden in Python mit der Raute (#) eingeleitet. Sie werden vom Python-Interpreter ignoriert. Text kann mit der print-Funktion ausgegeben werden. Starten Sie Python und geben sie folgende Anweisungen zeilenweise ein

 &gt;&gt;&gt; # Das ist ein Kommentar
 &gt;&gt;&gt; print(&quot;Hallo Welt!&quot;)

Als Ergebnis erhalten Sie

 Hallo Welt!

Der Prompt (&gt;&gt;&gt;) ist selbstverständlich nicht einzutippen, sondern wird vom Python-System geliefert.

Strings können in Python entweder in Anführungszeichen (&quot;) gesetzt werden oder in Hochkommatas('). In diesem Text wird die erste Variante bevorzugt eingesetzt.

Im Gegensatz zu Julia ist es hier egal, ob zwischen &lt;code&gt;print&lt;/code&gt; und der öffnenden Klammer Leerzeichen stehen.

= Python als Taschenrechner =
== Allgemeines ==
Wir wollen 3 * 5 berechnen. Dazu starten wir Python im interaktiven Modus. Geben Sie dann die Formel  

 &gt;&gt;&gt; 3 * 5

ein, drücken die Taste ENTER/RETURN ({{Taste|↵}}) und erhalten als Ergebnis

 15

Auch kompliziertere Ausdrücke sind möglich. Beispielsweise mit Winkelfunktionen, Quadratwurzeln etc. Wir wollen nun den Ausdruck &lt;math&gt;\sin\sqrt{15}&lt;/math&gt; berechnen :

 &gt;&gt;&gt; import math
 &gt;&gt;&gt; math.sin(math.sqrt(15))
 -0.6679052983383519

Als erstes wird das math-Modul importiert. Dann wird der mathematische Ausdruck berechnet.

Eine andere Variante, die dasselbe Ergebnis liefert, ist

 &gt;&gt;&gt; from math import *
 &gt;&gt;&gt; sin(sqrt(15))
 -0.6679052983383519

Es wird also aus dem Modul &lt;code&gt;math&lt;/code&gt; alles importiert (erkennbar am &lt;code&gt;*&lt;/code&gt;). Will man nicht alles importieren, so kann man das auch einschränken:

 &gt;&gt;&gt; from math import sin, sqrt

Beenden lässt sich das Python-Programm durch Eingabe von &lt;code&gt;exit()&lt;/code&gt; (und natürlich ist zur Bestätigung die RETURN-Taste zu drücken). &lt;code&gt;exit&lt;/code&gt; (ohne Klammern) oder &lt;code&gt;quit&lt;/code&gt; werden auch akzeptiert.

== Die Hilfefunktion von Python ==
Bei Eingabe der Anweisung &lt;code&gt;help&lt;/code&gt; oder &lt;code&gt;help()&lt;/code&gt; springt Python in den Hilfemodus. 

Eingabe:
 &gt;&gt;&gt; help()
 
Eingabe:
 help&gt; math.sin

Ausgabe:
 Help on built-in function sin in math:
 
 math.sin = sin(x, /)
     Return the sine of x (measured in radians).

Für die komplette Python-Dokumentation siehe [https://docs.python.org/3/]. Verlassen kann man den Hilfemodus durch das Drücken von STRG-C, bzw. der Eingabe von q, quit oder exit mit anschließendem Drücken der RETURN-Taste.

== Aufgaben ==
* Erkunden Sie die Tangensfunktion &quot;tan&quot; mittels Python-Hilfe (vergessen Sie nicht das math-Modul zu importieren und das &lt;code&gt;math.&lt;/code&gt; vor &lt;code&gt;tan&lt;/code&gt;)
* Berechnen Sie mit Python den Ausdruck &lt;math&gt;\frac{1}{2}\cdot \text{e}^2 \cdot \tan(\pi/3)&lt;/math&gt;. Siehe für die Exponentialfunktion im Python-Hilfesystem auch den Befehl &lt;code&gt;math.exp&lt;/code&gt;. Alternativ kann auch die Konstante &lt;code&gt;math.e&lt;/code&gt; eingesetzt werden. Potenzieren kann man bei Python mit dem **-Operator (z.B. 2**3 = 8). Für &lt;math&gt;\pi&lt;/math&gt; gibt es &lt;code&gt;math.pi&lt;/code&gt;.

= Python als Scriptsprache =
Häufig wird man aber kompliziertere Anweisungsfolgen verarbeiten müssen. Diese will man normalerweise nicht jedesmal neu eingeben, sondern in einer Datei speichern und diese Datei dann zur Ausführung bringen. Speichern Sie dazu folgenden Code in einer Textdatei, z.B. unter MS Windows als c:\tmp\test1.py

 # Das ist ein Kommentar
 print(&quot;Hallo Welt!&quot;)

Python-Dateien werden mit der Dateiendung .py versehen. Achten Sie darauf, dass vor dem print keine Leerzeichen vorhanden sind. Das ist eine Python-Eigenheit. Wie wir später sehen werden, nutzt Python Einrückungen als syntaktisches Mittel, z.B. um bei Schleifen den Schleifenkörper zu kennzeichnen. 

Danach bringen Sie die Skriptdatei test1.py (sozusagen das Hauptprogramm) folgendermaßen zur Ausführung:

1) Starten Sie unter MS Windows die Eingabeaufforderung (oder alternativ auch die Windows PowerShell). Das sieht dann etwa so aus:

 Microsoft Windows [Version 10.0.19045.3693]
 (c) Microsoft Corporation. Alle Rechte vorbehalten.
 
 C:\Users\xyz&gt;

: &lt;small&gt;Falls jemand nicht weiß, wie man die Eingabeaufforderung startet: Eine Möglichkeit ist, einfach in der Taskleiste von Windows das &quot;Start&quot;-Symbol &amp;nbsp;([[Image:Windows_logo_-_2021_(Black).svg|10px]])&amp;nbsp; mit der rechten Maustaste anklicken. &quot;Ausführen&quot; auswählen (oder alternativ für die PowerShell unter Windows 10 den Eintrag &quot;Windows PowerShell&quot;, unter Windows 11 den Eintrag &quot;Terminal&quot;). Im sich öffnenden Dialogfenster gibt man in die &quot;Öffnen&quot;-Zeile das Wort &lt;code&gt;cmd&lt;/code&gt; ein und mit &quot;OK&quot; wird das Ganze bestätigt.&lt;/small&gt; 
 
2) Wechseln Sie mittels &lt;code&gt;cd c:\tmp&lt;/code&gt; in das Verzeichnis c:\tmp

3) Angenommen, Sie haben Python unter dem Pfad &lt;code&gt;c:\devel\Python\&lt;/code&gt; installiert. Starten Sie das Programm so (der Prompt &lt;code&gt;c:\tmp&gt;&lt;/code&gt;ist natürlich nicht mit einzutippen): 

 c:\tmp&gt;c:\devel\Python\python.exe test1.py

4) Wie erwartet ergibt sich folgende Ausgabe am Bildschirm

 Hallo Welt!

Die Vorgehensweise unter Linux ist prinzipiell gleich. Die kleinen Unterschiede, wie z.B. der Slash statt dem Backslash in Pfadangaben, sollten für Linux-Benutzer keine Hürde darstellen.

== Variablen ==
Variablenbezeichner können aus Buchstaben (A-Za-z), Ziffern (0-9) und Underscores (_) bestehen, dürfen aber nicht mit einer Zahl beginnen. Führende Underscores haben u.a. im Kontext mit der Objektorientierten Programmierung eine spezielle Bedeutung und sollten nicht für &quot;normale&quot; Variablenbezeichner verwendet werden.

Gültige Variablenbezeichner wären also:
 xyz
 x1
 _wert
 name_anzahl

Theoretisch kann man auch Umlaute, griechische Buchstaben u.ä. in Variablenbezeichnern nutzen, z.B.

 ößÜ = 16
 α = 134 
 print(ößÜ)
 print(α)

Ausgabe:
 16
 134

Davon wird aber aus offensichtlichen Gründen ({{W|Englisch als Lingua franca}}) abgeraten. Das Eurozeichen (€) etc. darf man ohnehin nicht in Variablenbezeichnern verwenden, dies ergäbe einen Syntaxfehler. Siehe dazu auch [https://peps.python.org/pep-3131/].

Es gibt in Python etliche Schlüsselwörter (z.B. for, if oder return). Diese dürfen nicht als eigene Variablenbezeichner verwendet werden. Eine Liste aller Schlüsselwörter liefert das Script

 import keyword
 print(keyword.kwlist)

&lt;small&gt;Übung: Speichern Sie dieses Script in eine Datei, z.B. in c:\tmp\test1.py. Führen Sie diese Datei aus, um die Liste der Schlüsselwörter auszugeben.&lt;/small&gt;

Da Python case-sensitiv ist, repräsentieren folgende Bezeichner verschiedene Variablen:
 xyz
 XYZ
 xYz

Werte werden an Variablen mittels Gleich-Zeichen (=) zugewiesen. Im Folgenden wird der Code immer in der Datei c:\tmp\test1.py gespeichert.

 x = 5
 y = 10
 z = x*y
 print(z)

Bringen Sie die Datei test1.py zur Ausführung, so erhalten Sie folgende Bildschirmausgabe

 50

Sie können auch mehrere Anweisungen in einer Zeile durch Semikolon getrennt schreiben. Dies führt aber zu unübersichtlichem Code.

 x = 5; y = 10; z = x*y; print(z)

Ausgabe:
 50

Auch aus der Programmiersprache C/C++ oder Java bekannte Konstrukte können Sie verwenden, z.B.
 x = 5
 # x = x - 2
 x -= 2
 print(x)

Bildschirmausgabe:

 3
 
Beachten Sie, dass mit dem =-Zeichen eine Wertezuweisung durchgeführt wird. Dies ist nicht äquivalent zum mathematischen =-Zeichen, wie am vorigen Beispiel zu ersehen ist. Den Inkrement-/Dekrementoperator (z.B. x++ oder x--) aus C/C++ oder Java kennt Python aber nicht.

Variablen sind nicht an einen bestimmten Datentyp gebunden, folgendes ist mit Python problemlos möglich:

 import math
 wert = 10
 print(wert)
 wert = 35.5
 print(wert)
 wert = &quot;Hallo&quot;
 print(wert)
 wert = math.pi
 print(wert)

Ausgabe:
 10
 35.5
 Hallo
 3.141592653589793

== Physische und logische Zeilen ==
In Python muss eine Anweisung in einer logischen Zeile Platz finden. Wird eine Anweisung aber zu lang für eine Zeile, dann kann sie in mehrere physische Zeilen unterteilt werden. Dies kann einerseits durch einen Backslash am Ende einer Zeile geschehen, z.B.

 a = 2 + \
 5
 
Dies stellt eine logische Zeile dar, die in zwei physische Zeilen unterbrochen ist.

Geklammerte Ausdrücke werden automatisch zu einer logischen Zeile verbunden, z.B.

 a = (2 + 
 5)
 
Achtung: Im ersten Beispiel darf nach dem Backslash nichts mehr stehen, auch kein Kommentar. Dies trifft im zweiten Bespiel nicht zu, hier könnte noch ein Kommentar folgen, z.B.

 a = (2 +    # Kommentar 
 5)

Auch für Strings gibt es Möglichkeiten, diese auf mehrere Zeilen aufzuspalten.

 # Kurzer String
 str1 = &quot;ABC&quot;
 
 # Langer String
 str2 = &quot;&quot;&quot;Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle&quot;&quot;&quot;
 
 # Backslash
 str3 = &quot;UVW\
 XYZ&quot;
 
 # Mit Klammern
 str4 = (&quot;Sehr langer Text, der automatisch .............. &quot;
         &quot;in einer einzigen Variable zusammengefügt wird.&quot;
 )
 
 print(str1)
 print(str2)
 print(str3)
 print(str4)

Ausgabe:

 ABC
 Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle
 UVWXYZ
 Sehr langer Text, der automatisch .............. in einer einzigen Variable zusammengefügt wird.

==Hexadezimale, oktale, binäre und andere Zahlen==
 d = 1050         # Dezimalzahl
 h = 0xAA2        # Hexadezimalzahl
 o = 0o12         # Oktalzahl
 b = 0b100001101  # Binärzahl
 
 print(d)
 print(h)
 print(o)
 print(b)

Ausgabe:
 1050
 2722
 10
 269

Groß- und Kleinbuchstaben sind in obigen Literalen übrigens egal. So kann man z.B. statt &lt;code&gt;0b1001&lt;/code&gt; auch &lt;code&gt;0B1001&lt;/code&gt; schreiben (siehe dazu [https://docs.python.org/3/reference/lexical_analysis.html#integer-literals]).

Sie können auch dezimale in hexadezimale Zahlen umwandeln, usw.:
 h = hex(1050)    # Dezimalzahl -&gt; Hexadezimalzahl
 b = bin(1050)    # Dezimalzahl -&gt; Binärzahl
 o = oct(1050)    # Dezimalzahl -&gt; Oktalzahl
 print(h)
 print(b)
 print(o)

Ausgabe:
 0x41a
 0b10000011010
 0o2032

Gegeben sei die Zahl 121 zur Basis 3. Diese soll in eine Dezimalzahl umgewandelt werden. Das kann so geschehen:

 z = int(&quot;121&quot;, 3)
 print(z)

Ausgabe:
 16

Dass dies richtig ist, davon kann man sich folgendermaßen überzeugen:
 &lt;math&gt; 1 \cdot 3^2 + 2 \cdot 3^1 + 1 \cdot 3^0 = 9 + 6+ 1 = 16 &lt;/math&gt;

Zahlen übersichtlicher schreiben kann man auch mittels Underscore, z.B.:

 print(&quot;Eine Million (Variante 1) =&quot;, 1000000)
 print(&quot;Eine Million (Variante 2) =&quot;, 1_000_000)
 print(&quot;Eine Rechnung:&quot;, 2_000 * 400_000);

Es ergibt sich bei beiden Varianten die gleiche Ausgabe. Variante 2 ist aber im Sourcecode leichter lesbar, detto die Zahlen in der Rechnung:

 Eine Million (Variante 1) = 1000000
 Eine Million (Variante 2) = 1000000
 Eine Rechnung: 800000000

== Strings und Platzhalter==
Ein paar einfache Beispiele:

 print(&quot;Hallo {}&quot; . format(&quot;Hugo&quot;))     # new style string formatting
 print(&quot;Hallo {:s}&quot; . format(&quot;Hugo&quot;))   # new style string formatting
 print(&quot;Hallo %s&quot; % &quot;Hugo&quot;)             # %-String

Ausgabe:

 Hallo Hugo
 Hallo Hugo
 Hallo Hugo

Python-Code (formatted string literals, Beispiel 1):
 str1 = &quot;Hallo&quot;
 str2 = &quot;Hugo&quot;
 print(f&quot;{str1} {str2}&quot;)

Ausgabe:
 Hallo Hugo

f-Strings (ab Python 3.6) sind die modernere Variante gegenüber %-Strings oder das ''new style string formatting''. Sie sind in der Regel auch schneller.

Python-Code (formatted string literals, Beispiel 2):
 wert = 11.567
 print(f&quot;Ausgabe: {wert:.5f}&quot;)

Ausgabe:
 Ausgabe: 11.56700

Komplexere Beispiele:

 print(&quot;Hallo {} und {}&quot; . format(&quot;Hugo&quot;, &quot;Mike&quot;))
 print(&quot;Hallo {name1} und {name2}&quot; . format(name2=&quot;Hugo&quot;, name1=&quot;Mike&quot;))
 # Füllzeichen: *
 # Bündigkeit: &gt; (=rechts), &lt; (=links), ^ (=zentriert)
 # Feldweite: 10
 # Typ: s (=String), f (=Gleitkommazahl), d (=Dezimalzahl) etc.
 print(&quot;Hallo {:*&gt;10s}&quot; . format(&quot;Hugo&quot;))
 print(&quot;Hallo {:*&lt;10s}&quot; . format(&quot;Hugo&quot;))

Ausgabe:

 Hallo Hugo und Mike
 Hallo Mike und Hugo
 Hallo ******Hugo
 Hallo Hugo******

Python-Code:
 str = &quot;Hallo\t%s\t%7.2f\t%10.2e\t%i&quot; % (&quot;Hugo&quot;, 12.34567, 34.567, 264)
 print(str)

Ausgabe:
 Hallo	Hugo	  12.35	  3.46e+01	264

== Unicode ==
Neben den bekannten ASCII-Zeichen lassen sich Zeichen auch mittels Unicode beschreiben. Griechische Buchstaben oder komplexere mathematische Operatoren - all das sollte kein Problem sein. Siehe auch {{W|Unicode}}, {{W|Liste der Unicodeblöcke}} und {{W|Unicodeblock Mathematische Operatoren}}. Im Folgenden werden ein paar Zeichen (Allquantor, Nabla-Operator, Existenzquantor), die man aus der Mathematik kennt, erzeugt. 
 
 ch1 = &quot;\N{FOR ALL}&quot;
 ch2 = &quot;\N{NABLA}&quot;
 ch3 = &quot;\u2203&quot;
 print(ch1, ch2, ch3)

Ausgabe:
 ∀ ∇ ∃

&lt;small&gt;Diese Ausgabe ergibt sich z.B. mit der IDLE-Shell oder mit Cygwin. Beim Ausführen über die Windows-Eingabeaufforderung oder Windows PowerShell unter MS Windows 10 erfolgt keine korrekte Darstellung. IDLE ist die mit Python mitgelieferte IDE ('''I'''ntegrated '''D'''evelopment '''E'''nvironment, Integrierte Entwicklungsumgebung). Gegen Ende dieses Textes wird IDLE kurz beschrieben.
Das Problem mit der Windows Eingabeaufforderung lässt sich aber umgehen. Man muss nur eine Schriftart auswählen, die die Zeichen kennt, z.B. &quot;DejaVu Sans Mono&quot;. Dazu klicken Sie einfach bei der Eingabeaufforderung mit der rechten Maustaste oben auf die weiße Leiste und wählen im aufpoppenden Fenster den Menüpunkt &quot;Eigenschaften&quot;. Es öffnet sich ein Dialogfenster. Über den Reiter &quot;Schriftart&quot; lässt sich nun die Schriftart einstellen. Unter MS Windows 11 oder openSUSE Leap 15.6 (bash-Konsole) gibt es dieses Problem ohnehin nicht.&lt;/small&gt;

== Reguläre Ausdrücke ==
Python kennt auch {{W|Regulärer Ausdruck|reguläre Ausdrücke}}. Dazu gibt es in Python das Modul &lt;code&gt;re&lt;/code&gt;. Beipielsweise sollen alle Zahlen (&lt;math&gt;\text{zahl}\in\mathbb{N}_0&lt;/math&gt;) in einem String gesucht und ausgegeben werden. Als String sei gegeben: &lt;code&gt;3x Grüße und 100 Kekse.&lt;/code&gt; Das Muster (Pattern) ist &lt;code&gt;\d+&lt;/code&gt;. &lt;code&gt;\d&lt;/code&gt; steht für eine Dezimalziffer 0-9. Das Plus-Zeichen (+) steht symbolisch für ein oder mehrere Zeichen des vorherigen Ausdrucks. Hier also ein oder mehrere Dezimalziffern. Es wird die Funktion &lt;code&gt;findall&lt;/code&gt; aus dem Modul &lt;code&gt;re&lt;/code&gt;verwendet.

Python-Code:
 from re import findall
 
 str = &quot;3x Grüße und 100 Kekse.&quot;
 pat = &quot;\\d+&quot;  # Doppel-Backslashes müssen verwendet werden, sonst gibt Python eine Warnung aus!
               # alternativ: pat = r&quot;\d+&quot; 
               # oder: pat = &quot;[0-9]+&quot;
 
 numb = findall(pat, str)
 print(numb)

Ausgabe:
 ['3', '100']

Python kennt noch viele weitere Möglichkeiten mittels regulärer Ausdrücke zu hantieren. Dies soll hier aber nicht vertieft werden, da das Thema schon ziemlich speziell und komplex ist. Bei Bedarf siehe aber z.B. die Bücher ''Weigend, Seite 380ff'' und ''Ernesti, Kaiser'' [https://openbook.rheinwerk-verlag.de/python/28_001.html] oder die Python-Dokumentation [https://docs.python.org/3/library/re.html]. Auch [[Python unter Linux: Reguläre Ausdrücke]] liefert ein umfangreiches und brauchbares Python-2-Kapitel zu den regulären Ausdrücken. Die dort gelisteten Beispiele müssten ggf. vor Verwendung auf Python-3 umgeschrieben werden. &lt;small&gt;Wie macht  man das? Dazu siehe z.B. [https://openbook.rheinwerk-verlag.de/python/43_001.html], [https://portingguide.readthedocs.io/en/latest/] oder [https://www.digitalocean.com/community/tutorials/how-to-port-python-2-code-to-python-3]&lt;/small&gt;

&lt;small&gt;Es gibt auch ein externes Modul ''regex'', das bei Bedarf extra installiert werden muss ([https://pypi.org/project/regex/]). Es bietet zusätzliche Funktionalität und gründlicheren Unicode-Support. Dies sei hier aber nur der Vollständigkeit halber erwähnt.&lt;/small&gt;

== Verzweigungen ==
=== if ===
Die IF-Verzweigung sei aus anderen Programmiersprachen bereits bekannt. In {{W|Pseudocode}} lässt sie sich folgendermaßen darstellen:

 WENN bedingung TRUE
   führe block1 aus
 SONST
   führe block2 aus
 ENDE 

Als {{W|Aktivitätsdiagramm|UML-Aktivitätsdiagramm}} sieht das in etwa so aus:

[[File:If-Then-Else-diagram.svg|200px]]

Und als {{W|Nassi-Shneiderman-Diagramm|Nassi-Shneiderman-Struktogramm}} so:

[[File:Zweiseitige Auswahl.png|250px]]

In Python gibt es keinen expliziten ENDE-Kennzeichner. Stattdessen wird der Code durch Einrückungen strukturiert. Alles mit der gleichen Einrückungstiefe gehört zum selben Block. Dies zeichnet Python vor anderen Programmiersprachen aus.

Die test1.py-Datei laute also wie folgt:

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
   print(&quot;x ist groesser oder gleich 4&quot;)  

Ausgabe:

 Der else-Zweig wird ausgefuehrt
 x ist groesser oder gleich 4

Man achte auch auf die Doppelpunkte in der if- und else-Zeile. Darauf vergisst man gerne, wenn man von anderen Programmiersprachen kommt.

Folgendes wäre in Python ein Fehler (genauer gesagt ein IndentationError).

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
     print(&quot;x ist groesser oder gleich 4&quot;)  

Auch Nachstehendes würde nicht zum gewünschten Ergebnis führen (löst aber keine Fehlermeldung aus). Der letzte print-Befehl ist schon außerhalb der IF-ELSE-Verzweigung.

 x = 3
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
 print(&quot;x ist groesser oder gleich 4&quot;)

Ausgabe:

 x ist kleiner als 4
 x ist groesser oder gleich 4

Python kennt eine Reihe von Vergleichs- und Verknüpfungsoperatoren:

    &lt;, &lt;= ... kleiner (gleich)
    &gt;, &gt;= ... größer (gleich)
    == ... gleich
    != ... ungleich
    is ... identisch
    is not ... nicht identisch
    and ... AND
    or ... OR
    not ... NOT

Beispielsweise:

 a = 5
 b = 9
 
 if a&lt;=10 and b!=7:
   print(&quot;OK&quot;)
 else
   print(&quot;Nicht OK&quot;)

Ausgabe:

 OK

Der else-Block kann übrigens auch ersatzlos entfallen. Als Pseudocode sieht das so aus

 WENN bedingung TRUE
   führe block aus
 ENDE

Mehrfache Verzweigungen werden durch das elif-Konstrukt erstellt. In Pseudocode:

 WENN bedingung1 TRUE
   führe block1 aus
 SONST WENN bedingung2 TRUE
   führe block2 aus
 SONST WENN bedingung3 TRUE
   führe block3 aus
 SONST
   führe block4 aus
 ENDE

Ein Python-Beispiel:
 a = 14
 
 if a&lt;=10:   
   print(&quot;&lt;=10&quot;)
 elif a&gt;=11 and a&lt;=15:
   print(&quot;11 bis 15&quot;)
 elif a&gt;=16 and a&lt;=20:
   print(&quot;16 bis 20&quot;)
 else:
   print(&quot;&gt;20&quot;)

Ausgabe:

 11 bis 15

In Python gibt es auch die Schlüsselwörter &lt;code&gt;True&lt;/code&gt; (für wahr) und &lt;code&gt;False&lt;/code&gt; (für falsch). Man beachte, dass sie mit Großbuchstaben beginnen. Andere Schreibweisen wären ein Fehler. Sie gehören zum Datentyp &lt;code&gt;bool&lt;/code&gt;. Ihnen sind auch die Zahlen &lt;code&gt;1&lt;/code&gt; und &lt;code&gt;0&lt;/code&gt; zugewiesen.

Man beachte, dass {{W|Rundungsfehler}} auftreten können. D.h. man sollte  bei der Verwendung von {{W|Gleitkommazahl|Gleitpunktzahlen}} niemals auf absolute Genauigkeit prüfen, sondern eine Toleranz (einen &lt;math&gt;\varepsilon&lt;/math&gt;-Wert) vorgeben.
 
Ein klassisches Beispiel, das ein falsches Ergebnis liefert, ist:

 i = 0.1 + 0.2
 
 print(i)
 
 if i == 0.3:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 NOK

Und das, obwohl man schon in der Volksschule lernt, dass 0.1 + 0.2 gleich 0.3 ist.

Korrekt muss das obige Beispiel z.B. so umgeschrieben werden:

 ist = 0.1 + 0.2
 soll = 0.3
 epsilon = 0.000001
 
 print(ist)
 
 if abs(ist-soll) &lt; epsilon:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 OK

Alternativ kann auch die &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion verwendet werden. Das sei aber hier nur erwähnt und nicht konkret ausgeführt.

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet zum Thema &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion.

=== match ===
Ab Python 3.10 gibt es auch die match-Anweisung. Dies ist das Python-Pendant für die switch-Anweisung in anderen Programmiersprachen, geht aber bei näherer Betrachtung weit darüber hinaus. Hier nur ein einfaches Beispiel:

 x = &quot;Hello&quot;
 
 match x:
     case &quot;Servus&quot; | &quot;Ciao&quot;:         # or
         print(&quot;Servus an alle&quot;)
     case &quot;Grüetzi&quot;:
         print(&quot;Grüetzi Schwyzer&quot;)  
     case _:                         # other, default, sonstiges ...
         print(&quot;Hallo Welt&quot;)

Ausgabe: 
 Hallo Welt

Als Struktogramm sieht das in etwa so aus:

[[File:Mehrseitige Auswahl.png|250px]]

Für nähere Details siehe z.B. [https://www.geeksforgeeks.org/python-match-case-statement/], [https://learnpython.com/blog/python-match-case-statement/], [https://docs.python.org/3/tutorial/controlflow.html#match-statements] und das Python Enhancement Proposal (PEP) 636 – Structural Pattern Matching: Tutorial [https://peps.python.org/pep-0636] und dort insbesondere den Anhang A - Quick Intro.

&lt;small&gt;&lt;code&gt;match, case, _&lt;/code&gt; etc. sind sogenannte ''soft keywords''. Im Gegensatz zu den normalen Schlüsselwörtern dürfen ihnen auch Werte zugewiesen werden. Eine Liste der weichen Schlüsselwörter lässt sich durch &lt;code&gt;keyword.softkwlist&lt;/code&gt; erstellen (die Anweisung gibt es seit Python 3.9). Siehe dazu auch [https://stackoverflow.com/questions/65800344/what-are-soft-keywords] und [https://docs.python.org/3/library/keyword.html#keyword.softkwlist].&lt;/small&gt;

== Schleifen ==
Kopfgesteuerte Schleife, Endlosschleife und fußgesteuerte Schleife:

[[File:Programmingloops.svg|450px]]

=== while ===
Die WHILE-Schleife ist kopfgesteuert. Sie funktioniert wie aus anderen Programmiersprachen bekannt. 

In Pseudocode:
 SOLANGE bedingung TRUE
   führe block aus
 ENDE

In Python:
 x = 0
 
 while x &lt;= 10:
   print(x)
   x += 1

Ausgabe:
 0
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10

Eine Endlosschleife ergibt sich z.B. so:
 i = 5
 
 while True:
     print(i)
     i-=1

Beendet werden kann sie mit der Tastenkombination STRG-C.

Eine fußgesteuerte Schleife kann so simuliert werden:
 i = 5
 
 while True:
     print(i)
     i-=1
 
     if i&lt;=0:
         print(&quot;Fire&quot;)
         break

Ausgabe:
 5
 4
 3
 2
 1
 Fire

Der &lt;code&gt;break&lt;/code&gt;-Befehl wird etwas [[Ing_Mathematik:_Python#break|später]] noch einmal kurz thematisiert.

=== for ===
Struktogramm einer for-Schleife:

[[File:Zählschleife.png|200px]]

In Python bspw. so:

 for x in range(6):
   print(x*2)

Ausgabe:
 0
 2
 4
 6
 8
 10

Die Schleife läuft von 0 bis 5. Ausgegeben wird jeweils der Wert x*2. Aquivalent kann diese Schleife auch so geschrieben werden:
 for x in range(0, 11, 2):
   print(x)

Die Ausgabe ist wie oben. Der Startwert sei 0, der Endwert ist 11-1 und die Schrittweite ist 2.

Ein anderes Beispiel sei
 for x in &quot;text&quot;:
   print(x)

Ausgabe:
 t
 e
 x
 t

== Schleifen abbrechen ==
=== break ===
&lt;code&gt;break&lt;/code&gt; bricht die Schleife ab und setzt mit dem nächsten Befehl außerhalb der Schleife fort.

 for var in range(100):
   print(var) 
   if var == 5:
     break

Ausgabe:
 0
 1
 2
 3
 4
 5

=== continue ===
&lt;code&gt;continue&lt;/code&gt; bricht den aktuellen Schleifendurchlauf ab und setzt mit dem nächsten Schleifendurchlauf fort.

 for var in range (11):
   if var == 5:
     continue
   print(var)

Ausgabe:
 0
 1
 2 
 3
 4
 6
 7
 8
 9
 10

== try - except ==
 try:
     z1 = 12 / 0
     print(z1)
 except ZeroDivisionError:
     print(&quot;Das Ergebnis ist unendlich&quot;)
 except:
     print(&quot;Kann nicht berechnet werden!&quot;)
     print(&quot;Bitte die Formel korrigieren!&quot;)
 
 print(&quot;Setze Programm fort!&quot;)

Ausgabe:
 Das Ergebnis ist unendlich
 Setze Programm fort!

Es wird versucht, eine Zahl durch Null zu dividieren. Das ist nicht möglich, es wird eine Ausnahme ausgelöst. Das Programm springt daher in den except-ZeroDivisionError-Block und führt die dort gelisteten Anweisungen aus (in unserem Fall eine print-Anweisung). Danach wird das Programm fortgesetzt. Würden wir dieses Programm ohne try-except ausführen, so ergibt sich aus

 z1 = 12 / 0
 print(z1)

folgende Fehlermeldung und ein unmittelbarer Programmabbruch

 Traceback (most recent call last):
   File &quot;C:\tmp\test1.py&quot;, line 1, in &lt;module&gt;
     z1 = 12 / 0
 ZeroDivisionError: division by zero

Mit dem try-except-Mechanismus können also Ausnahmen oder Fehler aufgefangen und behandelt werden. In unserem Beispiel ist das eher trivial, aber bei größeren Programmen kann das durchaus Sinn machen.

Neu in Python 3.14 ist, dass mehrere Ausnahmen auch ohne Klammern angegeben werden können, z.B.:

bis inkl. Python 3.13 nur:
 except (ZeroDivisionError, ValueError):

ab Python 3.14 auch:
 except ZeroDivisionError, ValueError:

== pass ==
Ein leerer Block muss in Python mittels dem Schlüsselwort &lt;code&gt;pass&lt;/code&gt; dargestellt werden. Z.B.

 x = 2
 
 if x == 1:
     print(&quot;Wert ist &quot;, x)
 else:
     pass

Würde man das &lt;code&gt;pass&lt;/code&gt; im else-Block weglassen, so würde man eine Fehlermeldung erhalten:

 IndentationError: expected an indented block after 'else' statement on line 5

= Funktionen =
== Aufrufen von Funktionen ==
Funktionen sind uns im Rahmen dieses Kurses schon zuhauf begegnet. Sei es die print()-, die math.sin()- oder die hex()-Funktion. All diese Funktionen werden von Python zur Verfügung gestellt, ohne dass man sie explizit programmieren müsste. Aufgerufen werden diese Funktionen, indem man ihren Namen eintippt, gefolgt von runden Klammern. In diesen Klammern können noch Argumente übergeben werden. Auch Rückgabewerte sind möglich.

== Funktionen selber schreiben ==
Funktionen werden mit dem def-Schlüsselwort (man definiert die Funktion) eingeleitet, danach folgt der Funktionsname, danach wiederum runde Klammern, in denen formale Argumente stehen können. Abgeschlossen wird die def-Zeile mit einem Doppelpunkt. Danach folgt der Funktionskörper. Dieser Funktionskörper muss wiederum eingerückt werden (wie von den Verzweigungen und Schleifen bekannt). Aufgerufen wird diese Funktion, indem man ihren Funktionsnamen eingibt, gefolgt von runden Klammern (ggf. mit den aktuellen Parametern). Z.B.

 # Funktion definieren
 def halloWelt(i):
     # i ... beliebige Ganzzahl
     print(&quot;Hallo &quot; * i, end=&quot;&quot;)
     print(&quot;Welt!&quot;)
    
 # Funktion aufrufen
 halloWelt(3)

Ausgabe:
 Hallo Hallo Hallo Welt!

Unterschied zwischen formalen und aktuellen Parametern:

[[Datei:PythonIng_func1.jpg]]

&lt;small&gt;Aktuelle Parameter werden auch Argumente genannt.&lt;/small&gt;

Rückgabe von Funktionswerten:
 # Funktion definieren
 def mathFunc(a, b):
     r1 = a + b
     r2 = a * b
     return r1, r2
    
 # Funktion aufrufen
 c, d = mathFunc(3, 5)
 
 # Ausgabe der zurückgegebenen Werte
 print(c)
 print(d)

Ausgabe:
 8
 15

Es werden r1 und r2 zurückgegeben und den Variablen c und d zugewiesen. (r1, r2) und (c, d) sind Tupel. Was Tupel konkret sind, siehe etwas später in diesem Kapitel. 3 und 5 sind die aktuellen Parameter (die Argumente). a und b sind die formalen Parameter. Die Zuweisung der aktuellen zu den formalen Parametern erfolgt in der gegebenen Reihenfolge, also die Zahl 3 wird an a übergeben und die Zahl 5 an b.

Vorgabeparameter, z.B.:
 def mathFunc(a=10, b=20):
     r1 = a + b
     r2 = a * b
     return r1, r2
 
 c, d = mathFunc(3, 5)
 print(c)
 print(d) 
 
 e, f = mathFunc(5)
 print(e)
 print(f)
 
 g, h = mathFunc(b=6)
 print(g)
 print(h)

Ausgabe:
 8
 15
 25
 100
 16
 60

Erklärung:
* Erster &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es werden, wie weiter oben, die Argumente 3 und 5 an die formalen Parameter a und b übergeben. Die Rückgabewerte r1 und r2 werden an c und d übergeben. Somit ist c=8 und d=15.
* Zweiter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur das Argment 5 an a übergeben. b behält den Vorgabewert 20. D.h. e= 25 und f=100.
* Dritter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur die Zahl 6 an b übergeben, a behält seinen Vorgabewert 10. Somit ergibt sich g=16 und h=60.

Beispiel (Schlüsselwortargumente vs. Positionsargumente):
 def mathFunc(a, b):
     r1 = a - b
     r2 = a / b
     return r1, r2
 
 c, d = mathFunc(b=3, a=5)  # Schlüsselwortargumente
 e, f = mathFunc(3, 5)      # Positionsargumente

 print(c)
 print(d)
 print(e)
 print(f)

Ausgabe:
 2
 1.6666666666666667
 -2
 0.6

Durch die Verwendung von Schlüsselwortargumenten können die Argumente in beliebiger Reihenfolge angegeben werden. Bei den Positionsargumenten ist die Reihenfolge vorgegeben. Daraus resultiert auch der Unterschied bei den obigen Ausgaben. Werden beide Arten in einem Aufruf gemischt, so müssen die Positionsargumente zuerst angegeben werden. Den Unterschied zwischen beiden Argumentarten zu kennen ist wichtig, nicht nur bei selbst erstellten Funktionen. Auch beim Aufruf von Python-Funktionen verfolgt einen die Mischung von Schlüsselwort- und Positionsargumenten auf Schritt und Tritt, z.B. beim etwas später folgenden Abschnitt über &quot;Grafiken zeichnen&quot;:

 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)

Bei dieser &lt;code&gt;plot&lt;/code&gt;-Funktion aus dem Modul &lt;code&gt;matplotlib.pyplot&lt;/code&gt; sind &lt;code&gt;x&lt;/code&gt; und &lt;code&gt;y1&lt;/code&gt; Positionsargumente. &lt;code&gt;label, lw&lt;/code&gt; und &lt;code&gt;ls&lt;/code&gt; sind die Namen der Schlüsselwortargumente. Die Schlüsselwortargumente könnten auch in anderer Reihenfolge angeschrieben werden, nicht jedoch die Positionsargumente!
Siehe zu &lt;code&gt;matplotlib.pyplot.plot&lt;/code&gt; auch die Seite [https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html].

== Lambda-Funktionen ==
 print((lambda a, b: a*b) (3, 5))

Ausgabe:
 15

Eingeleitet wird eine Lambda-Funktion (auch Lambda-Form, Lambda-Operator oder anonyme Funktion genannt) mit dem Schlüsselwort &lt;code&gt;lambda&lt;/code&gt;. Es folgen die formalen Argumente, danach ein Doppelpunkt, die Berechnungsvorschrift und ggf. abschliessend in Klammern die aktuellen Parameter.

Man kann einer Lambda-Funktion auch einen Funktionsnamen geben und die Funktion über diesen Namen aufrufen, z.B.

 prod = lambda a, b: a*b
 print(prod(3, 5))

Als Ausgabe wird wieder die Zahl 15 geliefert.

== Rekursive Funktionen ==
Funktionen können wiederum andere Funktionen aufrufen. Von einem {{W|Rekursion|rekursiven Funktionsaufruf}} spricht man, wenn die aufgerufene Funktion gleich der aufrufenden ist. 

 def printFunc(i):
     if (i &gt;= 5):
         return 
     else:
         print(&quot;Hallo Welt&quot;)
         printFunc(i+1)
         
 printFunc(1)

Ausgabe:
 Hallo Welt
 Hallo Welt
 Hallo Welt
 Hallo Welt

Typische Beispiele für die Abarbeitung als rekursive Funktionen sind die {{W|Fibonacci-Folge}} und die {{W|Fakultät_(Mathematik)|Fakultät}}. Jedoch ist der iterative Ansatz (mit konventionellen Schleifen) meist schneller und speicherplatzschonender.

== Funktionsannotationen ==
Python ist sehr flexibel, was Typen angeht. Im Vorhergehenden haben wir generell keine Typangaben gemacht. Will man Typen angeben, so bietet Python das Konzept der Funktionsannotation.

 def calcFunc(a: int, b: int) -&gt; int:
     return a+b
 
 r1 = calcFunc(8, 9)
 r2 = calcFunc(8.0, 9.0)
 r3 = calcFunc(&quot;Hallo&quot;, &quot;Welt&quot;)
 
 print(r1)
 print(r2)
 print(r3)

Ausgabe:
 17
 17.0
 HalloWelt

Jetzt sieht man auf den ersten Blick, welche Typen der Programmierer im Sinn hatte, als er die Funktion erstellte. Das Problem dabei ist nur, dass es Python ziemlich egal ist, welche Typen man im Endeffekt eingibt. Im obigen Beispiel können statt Integer-Typen u.a. auch Float- oder String-Typen eingegeben werden.

&lt;small&gt;
Siehe zum Thema &quot;Type Checking&quot; aber auch den später folgenden Abschnitt [[Ing_Mathematik:_Python#Type_Checker]].
&lt;/small&gt;

== Variadische Funktionen ==
Python-Code:

 def test1(a, *b):
     print(a);
      
     for c in b:
         print(c);
        
 test1(&quot;Hallo&quot;, &quot;Welt&quot;, &quot;Schweizer&quot;, &quot;und alle anderen&quot;)

Ausgabe:

 Hallo
 Welt
 Schweizer
 und alle anderen

Mit dem Stern (auch als Splat-Operator bezeichnet) in der formalen Parameterliste bei der Funktion &lt;code&gt;test1&lt;/code&gt; wird angezeigt, dass eine beliebige Anzahl von Argumenten übergeben wird. &lt;small&gt; Dies entspricht in etwa dem, was in anderen Programmiersprachen (PHP etc.) mittels Ellipse (&lt;code&gt;...&lt;/code&gt;) angezeigt wird.&lt;/small&gt;

= Tupel, Listen und andere =
[[Datei:Python 3. The standard type hierarchy.png|mini|hochkant=1.7|Datentypen und Strukturen]]

== Tupel und Listen ==
Tupel, Listen und einige andere sind Datenstrukturen oder Sequenzen.

Listen (z.B. eine Einkaufsliste) sind veränderbar (mutable). Ein Tupel kann dagegen nicht verändert werden (immutable). Listen werden beim Anlegen in eckige Klammern eingeschlossen, Tupel in runde Klammern. Beim Tupel können die Klammern auch weggelassen werden. Ein Tupel mit nur einem Element muss mit einem Beistrich abgeschlossen werden. Der Grund ist, dass Python sonst nicht entscheiden kann, ob ein Tupel angelegt werden soll, oder nur ein geklammerter Wert. 

Als Gedächtnisstütze kann man sich den Unterschied zwischen Tupel und Liste ev. so leichter merken:
: T'''u'''pel ... r'''u'''nde Klammern, '''u'''nveränderlich
: L'''i'''ste ... eck'''i'''ge Klammern, veränderl'''i'''ch.

Nachfolgend werden einige Operationen mit Listen und Tupel dargestellt.

 # Liste und Tupel
 liste = [1, 2, &quot;Hallo&quot;]
 tupel = (1, 2, &quot;Hallo&quot;) 
 
 # Ausgabe von liste und tupel
 print(liste)
 print(tupel)
 
 # Ausgabe von Einzelelementen
 print(liste[1])
 print(tupel[2])
 
 # Element an Liste anhängen und einfügen 
 liste.append(55)
 liste.insert(4, &quot;Welt&quot;)
 print(liste)
 
 # Element aus Liste entfernen
 liste.remove(1)
 print(liste)
 
 # einige weitere Beispiele
 liste2 = [1,]
 tupel2 = 1, 2
 tupel3 = (1,) 
 print(liste2)
 print(tupel2)
 print(tupel3)

Ausgabe:
 [1, 2, 'Hallo']
 (1, 2, 'Hallo')
 2
 Hallo
 [1, 2, 'Hallo', 55, 'Welt']
 [2, 'Hallo', 55, 'Welt']
 [1]
 (1, 2)
 (1,)

Beispiel (eine Liste von Wörtern zu einem einzigen zusammenhängenden Text verbinden):

 woerter = [&quot;Hallo&quot;, &quot;Welt&quot;]
 satz = &quot; &quot;.join(woerter)
 print(satz)

Ausgabe:

 Hallo Welt

== Dictionaries und Mengen ==
Zu den Datenstrukturen gehören weiters auch Mengen und Dictionaries. Mengen sind von der Mathematik bekannt, sie sind ungeordnet und es kommen keine mehrfachen Elemente vor. Dictionaries sind durch Schlüssel :Wert-Paare gekennzeichnet. Mengen werden beim Anlegen wie Dictionaries in geschweifte Klammern eingeschlossen.

 dict = {&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot; }
 menge = {1, 1, 3, 4, 4, 4, &quot;Hallo&quot;}
 
 print(dict)
 print(menge)
 print(dict[&quot;vorname&quot;])

Ausgabe:
 {'vorname': 'Hugo', 'nachname': 'Meister'}
 {1, 3, 4, 'Hallo'}
 Hugo

Geschweifte Klammern ohne Inhalt stellen Dictionaries dar und keine Mengen:

 di = {}
 print(type(di))

Ausgabe:
 &lt;class 'dict'&gt;

Leere Mengen lassen sich mit &lt;code&gt;set()&lt;/code&gt; erzeugen:

 menge = set()      # leere Menge
 print(menge)
 menge.add(&quot;Hallo&quot;) # Element hinzufügen
 print(menge)

Ausgabe:
 set()
 {'Hallo'}

Beispiel (einige Mengenoperationen):
 mengeA = {&quot;Hallo&quot;, &quot;Welt&quot;}
 mengeB = {1, 2, &quot;Welt&quot;, 3}
 
 # Vereinigung
 print(mengeA | mengeB)
 print(mengeA.union(mengeB))
 
 # Durchschnitt
 print(mengeA &amp; mengeB)
 print(mengeA.intersection(mengeB))
 
 # Differenz
 print(mengeA - mengeB)
 print(mengeA.difference(mengeB))
 
 # Symmetrische Differenz
 print(mengeA ^ mengeB)
 print(mengeA.symmetric_difference(mengeB))
 
 # Teilmenge
 print(mengeA.issubset(mengeB))
 
 # Mehrere Elemente hinzu
 mengeA.update([&quot;Super&quot;, 67, 125])
 print(mengeA)
 
 # Element löschen
 mengeA.discard(&quot;Hallo&quot;)
 print(mengeA)

Ausgabe:
 {1, 2, 3, 'Welt', 'Hallo'}
 {1, 2, 3, 'Welt', 'Hallo'}
 {'Welt'}
 {'Welt'}
 {'Hallo'}
 {'Hallo'}
 {1, 2, 3, 'Hallo'}
 {1, 2, 3, 'Hallo'}
 False
 {67, 'Super', 'Welt', 'Hallo', 125}
 {67, 'Super', 'Welt', 125}

Es gibt schon seit &quot;ewigen&quot; Zeiten unveränderbare Mengen, die mittels &lt;code&gt;frozenset&lt;/code&gt; eingeleitet werden. Neu ab Python 3.15 ist dagegen das Pendant &lt;code&gt;frozendict&lt;/code&gt;, das unveränderbare Dictionaries darstellt.

 fdict = frozendict({&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot;})
 fset = frozenset({&quot;A&quot;, 1, &quot;A&quot;})
 
 print(fdict)
 print(fdict[&quot;vorname&quot;])
 print (fset) 
 
 try:
     fdict[&quot;vorname&quot;] = &quot;Max&quot;
     print(fdict[&quot;vorname&quot;])
 except TypeError as e:
     print(f&quot;Fehler: {e}&quot;)
 
 try:
     fset.add(&quot;B&quot;)
     print(fset)
 except AttributeError as e:
     print(f&quot;Fehler: {e}&quot;)

Ausgabe:
 frozendict({'vorname': 'Hugo', 'nachname': 'Meister'})
 Hugo
 frozenset({1, 'A'})
 Fehler: 'frozendict' object does not support item assignment
 Fehler: 'frozenset' object has no attribute 'add'

== List Comprehensions ==
Aus einer Eingabeliste soll eine Ausgabeliste erzeugt werden. Das kann folgendermaßen geschehen.

Mathematische Schreibweise: &lt;math&gt;lc = \{2x|x\in\ \mathbb{N}, 1\le x &lt; 11\}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11)]
 print(lc)

Ausgabe:
 [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Mathematische Schreibweise: &lt;math&gt;lc = \{2x | x \in \mathbb{N}, 1\le x &lt; 11, x \bmod 2 = 0 \}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11) if x%2 == 0]
 print(lc)

Ausgabe:
 [4, 8, 12, 16, 20]

Siehe auch {{W|List Comprehension}}.

== Set Comprehensions ==
Dies ist sehr ähnlich wie im vorigen Abschnitt beschrieben. Es wird aber keine Liste, sondern eine Menge erzeugt.

 sc = {x*2 for x in range(1,11)}
 print(sc)

Ausgabe:
 {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}

== Listen zusammenführen - zip() ==
 li1 = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]
 li2 = [1, 2, 3, 4]
 li3 = [5.5, 6.6, 7.7, 8.8]
 
 z = zip(li1, li2, li3)
 print(z)
 
 li4 = list(z)
 print(li4)

Ausgabe:
 &lt;zip object at 0x00000283B6C6AC80&gt;
 [('A', 1, 5.5), ('B', 2, 6.6), ('C', 3, 7.7), ('D', 4, 8.8)]

== Generatorausdruck ==
 g = (i*2 for i in range(1,11))
 print(g)
 t = tuple(g)
 print(t)
 print(t[1:3])

Ausgabe:
 &lt;generator object &lt;genexpr&gt; at 0x00000241D2A4A5A0&gt;
 (2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
 (4, 6)

== Slicing ==
slice ... Scheibe, Teil, in Scheiben schneiden

Beispiel: Zugriff auf Elemente eines geordneten sequentiellen Objekttyps (Liste, Tupel oder String):

 str1 = &quot;Hallo&quot;
 # Das erste Element wird mit dem Index 0 angesprochen
 # [start (inkl.) : stop (exkl.) : step (default=1)]
 str2 = str1[0:2]
 # Alternativ auch: str2 = str1[:2] 
 print(str2)
 
 tup1 = (0,1,2,3)
 # Das letzte Element hat auch den Index -1, das vorletzte den Index -2 usw.
 tup2 = tup1[-3:-1]
 print(tup2)
 
 lst1 = [[1,  5,  10, 20],
         [30, 40, 50, 60]]
 lst2 = lst1[1][1]
 print(lst2)
 
Ausgabe:
 Ha
 (1, 2)
 40

Beispiel:

 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2])
 print(x[-3]) 
 print(x)
 print(x[:])
 print(x[2:])
 print(x[:2])
 print(x[::-1])

Ausgabe:

 c
 c
 ('a', 'b', 'c', 'd', 'e')
 ('a', 'b', 'c', 'd', 'e')
 ('c', 'd', 'e')
 ('a', 'b')
 ('e', 'd', 'c', 'b', 'a')

Visualisierung:

    '''a'''     '''b'''     '''c'''     '''d'''     '''e'''
 +-----------------------------+
 |  0  |  1  |//'''2'''//|  3  |  4  |
 +-----------------------------+
 | -5  | -4  |/'''-3'''//| -2  | -1  | 
 +-----------------------------+
 |/////////////////////////////|
 +-----------------------------+
 |/////////////''':'''///////////////|
 +-----------------------------+
 |     |     |///////'''2:'''////////|
 +-----------------------------+
 |////''':2'''/////|     |     |     |
 +-----------------------------+
 |\\\\\&lt;--\\\\\'''::-1'''\\\\&lt;--\\\\\|
 +-----------------------------+

Beispiel:
 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2::2])
 print(x[2::-1])
 print(x[2:0:-1])

Ausgabe:

 ('c', 'e')
 ('c', 'b', 'a')
 ('c', 'b')

Hier sieht man sehr schön, dass beim letzen &lt;code&gt;print&lt;/code&gt;-Befehl die 0, die in diesem Fall den Buchstaben &quot;a&quot; repräsentiert, als letzer Wert nicht mehr dazugehört (wie weiter oben angedeutet ist der End- oder Stoppwert exklusiv). Will man den Buchstaben &quot;a&quot; dazunehmen, so ist die vorletzte Zeile die richtige.

Beispiel: Umdrehen von Strings

 str1 = &quot;Hallo&quot;
 str2 = str1[::-1]
 print(str2)

Ausgabe:
 ollaH

Mit zweidimensionalen Listen/Tupels wird das Ganze schon bedeutend komplexer.

Beispiel: Verkettetes Slicing

 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
     
 print(A[2::][::2])

Ausgabe:

 [['20', '21', '22', '23'], ['40', '41', '42', '43']]

Das erste Slicing erstellt folgenden Slice:

 [[&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
  [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
  [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]

Das zweite Slicing wird dann auf diesen Slice angewendet und ergibt das genannte Endergebnis. Will man Spalten statt Zeilen, so funktioniert dieser direkte Weg nicht. Man verwendet dann List Comprehensions oder die NumPy-Bibliothek. Diese Bibliothek erlaubt [[Ing_Mathematik:_Python#Zugriff_auf_Matrizenelemente|zweidimensionales Slicing]]. Sie wird erst später bei den Grafiken eingeführt. Deshalb wird hier dazu noch kein Beispiel gezeigt.

= Objektorientierte Programmierung =
{{Wikipedia|Objektorientierte Programmierung}}

* {{W|Klasse (Objektorientierung)|Klasse}} ... die Schablone oder der Bauplan, enthält Methoden und Attribute
* {{W|Objekt (Programmierung)|Objekt}} ... eine Klasseninstanz (die konkrete Ausprägung der Klasse)
* {{W|Attribut (Programmierung)|Attribute}} ... die Eigenschaften eines Objekts
* {{W|Methode (Programmierung)|Methoden}} ... die Aktionen (Operationen), die ein Objekt ausführen kann
* {{W|Vererbung (Programmierung)|Vererbung}} ... neue Klassen (Subklassen, Unterklassen, abgeleitete Klassen) aus vorhandenen Klassen (Superklassen, Oberklassen, Basisklassen, Elternklassen) ableiten. Ermöglicht den Aufbau von Klassenhierarchien. Die Subklasse &quot;erbt&quot; Attribute und Methoden von der Superklasse. Python unterstützt (so wie C++, aber im Gegensatz zu Java) Mehrfachvererbung.

== UML ==
* {{W|Unified Modeling Language|UML}} ... '''U'''nified '''M'''odeling '''L'''anguage, eine Modellierungssprache. Die UML enthält zahlreiche Diagrammarten, um Programme zu modellieren. Im Nachfolgenden wird nur das {{W|Klassendiagramm}} verwendet.

[[File:UmlCd Klasse-3.svg|300px]]

* {{W|Sichtbarkeit (Programmierung)|Sichtbarkeit}}:
** + ... public (öffentlich)
** - ... private
** # ... protected 

* {{W|Attribut_(UML)#Attribute_für_Instanzen_und_für_Klassen|Klassenattribute}} (statische Attribute): Werden nur einmal pro Klasse angelegt. Im Klassendiagramm werden sie unterstrichen.

[[File:Attribute-3.png|200px]]

* Vererbung:

&lt;gallery&gt;
InheritancePgmUML.svg | Abgeleitete Klasse erbt von Basisklasse (Einfachvererbung)
Diamond inheritance.svg | D erbt von B und C (Mehrfachvererbung). B und C erben von A (Einfachvererbung)
&lt;/gallery&gt;

Für weitergehende Betrachtungen zur UML wird auf Spezialliteratur verwiesen, z.B.:
* Seidl et al.: UML@Classroom. dpunkt, 2012, ISBN 978-3-89864-776-2
* Rupp et al.: UML 2 glasklar. Hanser, 4. Aufl., 2012, ISBN 978-3-446-43057-0

== Eine einfache Klasse ==

[[Datei:PythonIng_uml1.svg | 200px]]

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
 
 fahr = Fahrzeug(150, 90)
 
 print(fahr.convertGeschw())
 
Ausgabe:
 41.666666666666664

Die Klasse Fahrzeug wird durch das class-Schlüsselwort eingeleitet. raeder ist ein Klassenattribut und public. __init__ wird bei der Objekterzeugung automatisch aufgerufen (ist der sogenannte Konstruktor). Man achte darauf, dass diese Methode immer mit zwei Unterstrichen eingeleitet und abgeschlossen wird. Instanzattributen wird das Wort self vorangestellt. Wir sehen uns z.B. das Attribut self.__geschwind an. Auch hier werden zwei Unterstriche verwendet. Das bedeutet, dass dieses Attribut strikt/stark private ist. Wird nur ein Unterstrich verwendet, so deutet dies auf schwach/weakly private hin. Letzteres wird in Python deutlich häufiger verwendet. Bei den Methoden wird immer self als erster Parameter angegeben. Beim Aufruf der entsprechenden Funktion wird das self aber nicht berücksichtigt.

Besonderheiten bei stark und schwach private:
* '''stark private''':
** zwei führende Unterstriche
** Name Mangling: Name wird zu &lt;code&gt;_Klassenname__variablenname&lt;/code&gt;
** Schutz vor Namenskollisionen bei Vererbung
** am Ende des Namens dürfen keine zwei Unterstriche verwendet werden. Das wären dann Magic Methods oder Dunder-Methods (z.B. __init__). Diese sind public.

* '''schwach private''':
** ein führender Unterstrich
** Name bleibt gleich
** ist nur ein Hinweis an die Programmierer, kein starker Schutz
** &lt;code&gt;from modul import *&lt;/code&gt;: Objekte mit einem führenden Unterstrich werden standardmäßig nicht importiert
** Standard für die Kapselung bei Python. Schätzung: Weit mehr als 80% der nicht-öffentlichen Attribute/Methoden werden als schwach private deklariert. Weniger als 5-10% als stark private (Quelle: Google KI)

== Klassen importieren ==
Häufig ist es sinnvoll und übersichtlicher Klassen in eigenen Dateien zu speichern. Das sind dann eigene Module. Abgespeichert werden Sie mit der Endung py, wie bisher auch praktiziert. Aufgerufen werden Sie mit der import-Anweisung. Dann ist aber nur der Dateiname ohne Endung py zu verwenden. Klarer wird das mit einem Beispiel.

Datei c:\tmp\fahrzeug.py

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6

Datei c:\tmp\test1.py

 import fahrzeug
 fahr = fahrzeug.Fahrzeug(150, 90)
 print(fahr.convertGeschw())

Ausgabe:
 41.666666666666664

Die üblichen import-Anweisungen lauten wie folgt:
{| {{prettytable}}
! import-Befehl
! Instanz
|-
| import xyz      || xyz.Klasse
|-
| import xyz as x || x.Klasse
|-
| from xyz import Klasse || Klasse
|-
| from xyz import * || Klasse 
|}

Der Vorteil der ersten beiden import-Anweisungen ist, dass es kaum zu Namenskollisionen kommen kann. Dafür hat man bei den letzten beiden Varianten weniger Tipparbeit.

== Vererbung ==
=== Einfachvererbung ===

[[Datei:PythonIng_uml2.svg | 200px]]

Datei fahrzeug.py:
 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
        
     def setLeistung(self, leistung):
         self.__leistung = leistung
        
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
        
 class Luftfahrzeug(Fahrzeug):
     def __init__(self, geschwindigkeit, leistung, fluegel):
         super().__init__(geschwindigkeit, leistung)
         self.__flueg = fluegel
     
     def getFlueg(self):
         return self.__flueg

Datei test1.py:
 import fahrzeug
 fahr = fahrzeug.Luftfahrzeug(150, 90, 4)
 print(fahr.getFlueg())

Ausgabe:
 4

=== Mehrfachvererbung ===
Mit Python ist auch Mehrfachvererbung möglich, z.B.:

 class A:
     def _printA(self):
         print(&quot;Klasse A&quot;)
 
 class B:
     def _printB(self):
         print(&quot;Klasse B&quot;)
 
 class C(A,B):
     def __init__(self):
         self._printA()
         self._printB()
 
 c = C()

Ausgabe:

 Klasse A
 Klasse B

Die Klasse C erbt von A und B. In UML sieht das in etwa so aus:

 +-----------------------------+   +-------------------------+
 |            A                |   |          B              |
 +-----------------------------+   +-------------------------+
 |                             |   |                         |
 +-----------------------------+   +-------------------------+
 | # printA()                  |   | # printB()              |
 +-----------------------------+   +-------------------------+
                           .              .
                          / \            / \
                          ---            ---
                           |              |
                           |              |
                        +---------------------+
                        |          C          |
                        +---------------------+
                        |                     |
                        +---------------------+
                        |                     |
                        +---------------------+

&lt;code&gt;printA()&lt;/code&gt; und &lt;code&gt;printB()&lt;/code&gt; sind schwach private (in UML als &lt;code&gt;protected&lt;/code&gt; mit einem # dargestellt). Es ist aber zu beachten, dass schwach private nur Konvention ist. Praktisch könnte man auch von außerhalb auf diese Methoden zugreifen. Das soll man aber nicht tun, und das wird in Python durch einen Unterstrich angedeutet.

== Statische Attribute, statische Methoden und Klassenmethoden ==
Beispiel:

 class Math:
     pi = 3.14159265
     cnt = 0
     
     @staticmethod
     def expo():
         return 2.71828183
    
     @classmethod    
     def counterPlus(cls):
         cls.cnt += 1
        
 print(Math.pi)
 print(Math.expo())
 
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)

Ausgabe:

 3.14159265
 2.71828183
 1
 2
 3

Statische Attribute und Methoden, bzw. Klassenmethoden, sind direkt einer Klasse zugeordnet und nicht einem Objekt. Der Unterschied zwischen statischen Methoden und Klassenmethoden ist, dass statische Methoden nicht auf Klassenattribute (bzw. statische Attribute) zugreifen können, Klassenmethoden aber schon. &lt;code&gt;pi&lt;/code&gt; und &lt;code&gt;cnt&lt;/code&gt; sind statische Attribute. &lt;code&gt;expo()&lt;/code&gt; ist eine statische Methode. &lt;code&gt;counterPlus(cls)&lt;/code&gt; ist eine Klassenmethode. Die Bezeichnung des Parameters als &lt;code&gt;cls&lt;/code&gt; ist reine Konvention, man sollte sich aber daran halten. &lt;code&gt;@staticmethod&lt;/code&gt; und &lt;code&gt;@classmethod&lt;/code&gt; nennt man auch Dekoratoren.

= Grafiken zeichnen =
Für das Zeichnen von Grafiken wird hier das Modul &lt;code&gt;matplotlib&lt;/code&gt; verwendet. &lt;code&gt;matplotlib&lt;/code&gt; ist ein externes Modul und muss vor der ersten Verwendung installiert werden. Das geht so:

# Starten Sie ein Terminal (bei Windows die Eingabeaufforderung).
# Führen Sie darin folgenden Befehl aus &lt;code&gt;c:\devel\Python\Scripts\pip.exe install matplotlib&lt;/code&gt;

pip ist übrigens der Paketmanager von Python ({{W|Pip_(Python)}}). 

Optimalerweise installieren wir auch gleich das Modul &lt;code&gt;numpy&lt;/code&gt; (Numerical Python). Wir werden es im Folgenden oft benötigen (nicht nur bei den Grafiken). Das funktioniert vom Prinzip her genauso, wie für &lt;code&gt;matplotlib&lt;/code&gt; gezeigt.

&lt;small&gt;Verwenden Sie Spyder, so sind diese Schritte nicht nötig. Spyder inkludiert diese Pakete standardmäßig. Unter openSUSE Tumbleweed lassen sich diese Pakete mittels YaST oder zypper installieren.&lt;/small&gt;

== 2D ==
=== Graph einer Funktion ===
Es soll die cosh-Funktion im Intervall &lt;math&gt;x\in[-3,3]&lt;/math&gt; gezeichnet werden. Der Programmcode lautet in der einfachsten Form:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x)
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:PythonIng_cosh1.jpg]]

Der Code ist quasi selbsterklärend. Das Untermodul pyplot des matplotlib-Moduls und das numpy-Modul werden importiert. x läuft von -3 bis +3. y wird für jeden x-Wert per Formel ausgerechnet. &quot;plt.plot()&quot; ist der Zeichenbefehl. &quot;plt.show&quot; ist notwendig, um das Fenster mit der Grafik anzuzeigen.
Die Schrittweite 0.1 wurde so gewählt, um einen ausreichend glatten Verlauf des Graphen zu gewährleisten. Das ist immer ein Kompromiss zwischen Berechnungszeit und Ansehnlichkeit. Testen Sie einfach ein paar verschiedene Werte, um ein Gefühl dafür zu zu bekommen. &quot;plt.grid()&quot; zeichnet ein Gitter in die Grafik (kann auch weggelassen werden).
Die Bezeichnungen plt und np könnten auch anders gewählt werden. Es ist aber Konvention, diese so wie hier gezeigt zu wählen. Die &quot;arange&quot;-Funktion aus der NumPy-Bibliothek wird später ein bisschen genauer behandelt (siehe [[Ing_Mathematik:_Python#Zahlenfolgen|Zahlenfolgen]]).  

&lt;small&gt;Mit der im obigen Bild gezeigten Menüleiste kann die dargestellte Grafik nachträglich noch geändert werden (Zoom, Pan, Achsenparameter, Kurvenparameter etc.). Natürlich kann man das alles auch direkt programmieren. Wie das funktioniert wird ansatzweise etwas später gezeigt.&lt;/small&gt;

Ein etwas komplexeres Beispiel ist Folgendes:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x) + 2**x
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:
[[Datei:PythonIng_cosh4.png]]

Man beachte, dass im Gegensatz zu Octave und Julia der ominöse Punkt (.) bei 2**x mit Python nicht benötigt wird. Das macht das Programmiererleben etwas einfacher.

Die Farbe des Graphen kann man über den &lt;code&gt;color&lt;/code&gt;-Schalter einstellen, z.B. auf rot setzen:
 plt.plot(x, y, color=&quot;red&quot;)

Das ist nur eine Möglichkeit, es gibt auch andere, z.B. mittels
* hexadezimaler Zahl, z.B. &lt;code&gt;color=&quot;#ff0000&quot;&lt;/code&gt;
* Kurzform, z.B. &lt;code&gt;&quot;r&quot;&lt;/code&gt;

Statt &lt;code&gt;color&lt;/code&gt; kann auch die Kurzform &lt;code&gt;c&lt;/code&gt; verwendet werden.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie diese &quot;Farbspielereien&quot; am Computer aus.

=== Graphen mehrerer Funktionen und weiteres ===
==== Mehrere Funktionen in einen Plot zeichnen ==== 
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh2.png]]

Um die Linienstile etwas individueller zu gestalten, ist folgender Programmcode gedacht: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;, lw=3, ls=&quot;--&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh3.png]]

Einige weitere Bespiele zu &lt;code&gt;ls&lt;/code&gt;&lt;/code&gt;:
* - ... durchgezogene Linie
* -. ... Strichpunkt-Linie
* dashed ... gestrichelte Linie 

==== Marker ====
Desweiteren kann man Marker verwenden.

Beispiel:

 import matplotlib.pyplot as plt
 
 plt.plot(10, 10, &quot;ob&quot;, markersize=30)
 plt.plot(20,20, &quot;.r&quot;)
 plt.plot(30,30, &quot;Dg&quot;, ms=15)
 plt.plot(40, 40, &quot;ok&quot;, ms=20, mec=&quot;#FF5733&quot;, mew=3)
 plt.plot(50, 50, &quot;vk&quot;, ms=20, mec=&quot;yellow&quot;, mew=3)
 plt.grid()
 plt.show()


Das erste Zeichen im String nach den Koordinaten im plot-Befehl symbolisiert die Form (z.B. o für einen Kreis). Das zweite Zeichen steht für die Farbe (z.B. b für blue). &lt;code&gt;markersize&lt;/code&gt; oder &lt;code&gt;ms&lt;/code&gt; setzt die Größe des Markers.

Ausgabe:

[[Bild:PythonIng_formatpara1.svg|200px]]

Einige weitere Marker:
* * ... Stern
* + ... Plus
* h oder H ... Sechseck

Man kann mit den Parametern 
* &lt;code&gt;markeredgecolor&lt;/code&gt; oder kurz &lt;code&gt;mec&lt;/code&gt; die Farbe des Markerrandes
* &lt;code&gt;markeredgewidth&lt;/code&gt; oder kurz &lt;code&gt;mew&lt;/code&gt; die Dicke des Randes
* &lt;code&gt;markerfacecolor&lt;/code&gt; oder kurz &lt;code&gt;mfc&lt;/code&gt; die Innenfarbe des Markers
bestimmen.

=== Funktion in Parameterdarstellung ===
Es soll die archimedische Spirale &lt;math&gt;x = t \cos(t), y = t  \sin(t)&lt;/math&gt; im Intervall &lt;math&gt;[0, 6\pi[&lt;/math&gt; gezeichnet werden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
  
 plt.show()

[[Datei:PythonIng_spirale1.png]]

Diese Darstellung erscheint verzerrt. Will man gleiche Achsenskalierungen, so kann man den plt.axis()-Befehl verwenden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
 plt.axis(&quot;equal&quot;)
 
 plt.show()
 
[[Datei:PythonIng_spirale2.png]]

=== Funktion in Polardarstellung ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 fig = plt.figure()
 ax = fig.add_subplot(projection=&quot;polar&quot;)
 r = np.arange(0, 1, 0.01)
 theta = r**3
 line = ax.plot(theta, r)
 
 plt.show()

[[Datei:PythonIng_polar1.png]]

=== Logarithmische Achsenskalierung ===
==== Semilog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.semilogy()
 plt.show()

Ausgabe:

[[Datei:PythonIng_semilog1.png]]

==== LogLog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.loglog()
 plt.show()

[[Datei:PythonIng_loglog1.png]]

=== Gefüllte Fläche ===
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.arange(0, 3, 0.1)
 
 y1 = 3*x - 1
 y2 = x**2
 
 plt.plot(x, y1, x, y2, color='black')
 plt.fill_between(x, y1, y2, where=y1&gt;=y2)
 
 plt.show()

[[Datei:PythonIng_gefuellt.png]]

=== Linien, Pfeile, Rechtecke, Kreise und Texte ===
 import matplotlib as mpl
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 r = mpl.patches.Rectangle((0, 0), 3, 3, angle=30, fill=False)
 c = mpl.patches.Circle((4, 4), 2, fill=False)
 
 ax.add_patch(r)
 ax.add_patch(c)
 ax.plot([-2, 7], [-2, 0], color=&quot;black&quot;)
 ax.arrow(0, 7, 5, 0, length_includes_head=True, head_width=0.5, head_length=1.5,
          color=&quot;black&quot;)
 
 ax.set_aspect(&quot;equal&quot;)
 
 plt.axis([-3, 8, -3, 8])
 plt.show() 

[[Datei:PythonIng_linien_pfeile_etc.png]]

Text kann mit &lt;code&gt;ax.text(x, y, &quot;Text&quot;)&lt;/code&gt; hinzugefügt werden, bspw.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 ax.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

Oder einfacher auch ohne &lt;code&gt;subplots&lt;/code&gt;

 import matplotlib.pyplot as plt
 
 plt.text(0.1, 0.1, &quot;Hallo&quot;)
 plt.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

[[Datei:PythonIng_text1.png]]

Auch Sonderzeichen (griechische Buchstaben etc.) können verwendet werden (siehe dazu auch [https://matplotlib.org/stable/users/explain/text/mathtext.html]).

 import matplotlib.pyplot as plt
 
 plt.text(.3, .5,
          r'$\Omega\ \psi\ \oint\ \nabla\ \dot a\ \frac{a}{b}\ a_b$',
          size=&quot;20&quot;)
 plt.show() 

[[Datei:PythonIng_text20.svg]]

Jetzt wird noch gezeigt, wofür &lt;code&gt;subplots&lt;/code&gt; sinnvoll eingesetzt werden können.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(0.1, 0.1, &quot;Hallo&quot;)
 ax[1].text(0.1, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
            rotation=30.0)
 
 plt.show()

[[Datei:PythonIng_text2.png]]

=== Anmerkungen hinzufügen ===
Anmerkungen (engl. annotations) lassen sich mit matplotlib einfach hinzufügen. Unter Anmerkung wird hier ein Pfeil mit Text verstanden.

Beispiel:

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 ax.plot([1,10], [1,10])
 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
             arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0))
 plt.show()

Ausgabe:

[[Datei: PythonIng_ann1.svg|400px]]

&lt;code&gt;shrink&lt;/code&gt; verkürzt den Pfeil. Sinnvoll sind beim obigen Beispiel Werte irgendwo zwischen 0.0 und 0.3.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie verschiedene Pfeillängen aus. 

Die Schriftgröße verändern können Sie übrigens mit &lt;code&gt;fontsize&lt;/code&gt; oder &lt;code&gt;size&lt;/code&gt;, z.B.

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0), fontsize=25)

Eine andere Schreibweise für Dictionaries, die wir weiter oben schon kennengelernt haben, die wir aber nochmals explizit aufschreiben wollen, ist

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops={&quot;facecolor&quot;:&quot;red&quot;, &quot;shrink&quot;:0.0})

=== Figure, Axes etc.===
[[Bild:PythonIng_figure33.svg|350px]]

* fig (figure) ... das übergeordnete Fenster
* ax (axes) ... &quot;Plot&quot;, das eigentliche Zeichenfenster
* axis ... die Koordinatenachsen
* spine ... Begrenzungslinien des Zeichenfensters
* tick ... Markierung an den Achsen des Zeichenfensters

Beispiel (eine figure mit 6 axes, ax-Titel, y-axis-Titel):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=3, ncols=2)
 
 ax[0][0].text(0.1, 0.5, &quot;11&quot;)
 ax[0][1].text(0.1, 0.5, &quot;12&quot;)
 ax[1][0].text(0.1, 0.5, &quot;21&quot;)
 ax[1][1].text(0.1, 0.5, &quot;22&quot;)
 ax[2][0].text(0.1, 0.5, &quot;31&quot;)
 ax[2][1].text(0.1, 0.5, &quot;32&quot;)
 
 ax[0][0].set(ylabel=&quot;y-label&quot;, title=&quot;axes 1&quot;)
 
 plt.show()

[[Bild:PythonIng_figure34.png|350px]]

Beispiel (Achsenbereiche setzen):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 
 ax[0].axis((-1, 10, 1, 12))
 
 plt.show()

[[Bild:PythonIng_figure35.svg|350px]]

Beispiel (Gitter einschalten): 

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 ax[0].axis((-5, 10, 1, 12))
 ax[0].minorticks_on()
 ax[0].grid(which='minor')
 ax[1].grid(which='major')
 plt.show()

[[Bild:PythonIng_figure36.svg|350px]]

Beispiel (ticks setzen)

 import matplotlib.pyplot as plt
 import matplotlib.ticker as tick
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 pos = [0, .2, .5]
 lab = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
 
 ax.xaxis.set_major_locator(tick.FixedLocator(pos))
 ax.xaxis.set_major_formatter(tick.FixedFormatter(lab))
 
 plt.show()

[[Bild:PythonIng_figure37.svg|350px]]

Beispiel (Achsenkreuz beliebig setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 ax.spines['top'].set_color('none')
 ax.spines['right'].set_color('none')
 ax.spines['bottom'].set_position(('data', 0.3))
 ax.spines['left'].set_position(('data', 0.5))
 
 plt.show()

[[Bild:PythonIng_figure38.svg|350px]]

Beispiel (Inset):

 import matplotlib.pyplot as plt
 
 # Hauptplot erstellen
 fig, ax = plt.subplots()
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 
 # Inset hinzu:
 axin = ax.inset_axes([0.4, 0.4, 0.3, 0.3])
 axin.text(0, 0, &quot;Servus&quot;)
 axin.plot()
 
 plt.show()

[[Bild:PythonIng_figure40.svg|350px]]

Beispiel (Hintergrundfarben setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.set_facecolor(&quot;green&quot;)
 fig.set_facecolor(&quot;yellow&quot;)
 
 plt.plot([1, 3], [6, 8])
 plt.show()

[[Bild:PythonIng_figure39.svg|300px]]

=== GridSpec ===
Mit figures und axes lassen sich schon jede Menge an Grafikdetails einstellen. GridSpec ist dann der Turbo oder Raketenantrieb den matplotlib eingebaut hat. Naja, vielleicht ist das etwas übertrieben, aber GridSpec ist sozusagen ein flexibler Layout-Manager. Bisher haben wir immer gleich große axes gezeichnet. Mit GridSpec können wir Subplots über mehrere Zeilen und Spalten ziehen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 gs = fig.add_gridspec(3, 3)
 
 ax1 = fig.add_subplot(gs[0, :])
 ax1.set_title(&quot;Bereich 1: gs[0, :]&quot;)
 
 ax2 = fig.add_subplot(gs[1:, 0])
 ax2.set_title(&quot;Bereich 2: gs[1:, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 1:])
 ax3.set_title(&quot;Bereich 3: gs[1, 1:]&quot;)
 
 ax4 = fig.add_subplot(gs[2, 1:])
 ax4.set_title(&quot;Bereich 4: gs[2, 1:]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec1.svg|350px]]

Erklärung zu &lt;code&gt;(gs[zeile, spalte])&lt;/code&gt;: Slicing; damit legen Sie fest, welche Zellen ein Subplot belegt. Achtung! Die Indizes beginnen bei 0 und nicht bei 1 (d.h., die erste Zeile/Spalte hat den Index 0)
* : ... alle 
* 1: ... 1 bis Ende
* etc.

&lt;code&gt;constrained_layout=True&lt;/code&gt; sorgt dafür, dass sich die Subplots nicht überlappen.

Aber auch die Spaltenbreiten und Zeilenhöhen lassen sich anpassen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 
 # Verhältnis erste zu zweite Zeile = 1.5:1
 # Verhältnis erste zu zweite Spalte  = 1:4
 gs = fig.add_gridspec(2, 2, figure=fig, height_ratios=[1.5, 1], width_ratios=[1, 4])
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax1.set_title(&quot;Bereich 1: gs[0, 0]&quot;)
 
 ax2 = fig.add_subplot(gs[0, 1])
 ax2.set_title(&quot;Bereich 2: gs[0, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 0])
 ax3.set_title(&quot;Bereich 3: gs[1, 0]&quot;)
 
 ax4 = fig.add_subplot(gs[1, 1:])
 ax4.set_title(&quot;Bereich 4: gs[1, 1]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec2.svg|350px]]

Auch die Ränder lassen sich einstellen.

Beispiel 1:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.1, right=0.9, bottom=0.1,
                        top=0.9, wspace=0.2, hspace=0.2)
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec3.svg|300px]]

* hspace ... height space, vertikaler Abstand zwischen den Zeilen
* wspace ... width space, horizontaler Abstand zwischen den Spalten

Und im Vergleich dazu Beispiel 2:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.3, right=0.7, bottom=0.3, 
                        top=0.7, wspace=0.3, hspace=0.3) 
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec4.svg|300px]]

Es gibt noch einige weitere Details, die sich mit GridSpec variieren lassen (z.B. SubGridSpec ... verschachtelte Grid-Layouts). Aber wir belassen es vorerst dabei. Das bisher Gezeigte sollte für die meisten Probleme ausreichend sein.

=== Aufgaben ===
* Zeichnen Sie die Strophoide &lt;math&gt;x = \frac{a(t^2-1)}{t^2+1}, y = \frac{at(t^2-1)}{t^2+1}, a = 2, -3 \leq t \leq 3&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_strophoide.jpg|300px|center]]

* Zeichnen Sie die verschlungene Hypozykloide &lt;math&gt;x = (R-r)\cos t + c\cos\frac{R-r}{r}t, y = (R-r)\sin t - c\sin\frac{R-r}{r}t, c = 3, r = 2, R = 6, -15 \leq t \leq 15&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_hypozykloide.jpg|300px|center]]

* Testen Sie bei den obigen Übungsaufgaben verschiedene Linienstile und Farben. Farben können mit dem plt.plot()-Parameter color gewählt werden.

* Testen Sie bei den obigen Übungsaufgaben verschiedene Werte für a, c, r und R.

* Zeichnen Sie folgendes Bild (die Achsenbeschriftungen positionieren Sie z.B. mit den Befehlen &lt;code&gt;ax.set_xlabel(&quot;x&quot;, loc=&quot;right&quot;); ax.set_ylabel(&quot;y&quot;, loc=&quot;top&quot;)&lt;/code&gt;):

[[Bild:PythonIng_aufgabe24.svg|400px|center]] 

* Zeichnen Sie mit Python, matplotlib und NumPy folgendes Bild:

[[Bild:PythonIng_figure41.svg|400px|center]]

* Zeichnen Sie mit GridSpec ein Layout, das in etwa wie folgendes aussieht (&lt;code&gt;height_ratios=[1, 2], width_ratios=[2, 1]&lt;/code&gt;):

[[Bild:PythonIng_aufgabe23.svg|300px|center]]

== 3D ==
=== Räumliche Kurven ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0, 6*np.pi, 0.1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 z = t
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot(x, y, z)
 
 plt.show()

[[Datei:PythonIng_raumkurve1.png]]

=== Flächen ===
 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche1.png]]

Das Ganze in Netzdarstellung läßt sich so programmieren: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.5)
 y = np.arange(0, 10, 0.5)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_wireframe(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche2.png]]

Ein etwas komplexeres Beispiel:

 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0.1, 10, 0.1)
 y = np.arange(0.1, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z1 = np.sin(x) + 3 * np.cos(y)
 z2 = np.sin(x) + np.log(y)
 z3 = x + np.cos(y)
 z4 = x**2 - y
  
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;}, nrows=2, ncols=2)
 
 ax[0][0].plot_surface(x, y, z1)
 ax[0][1].plot_surface(x, y, z2)
 ax[1][0].plot_surface(x, y, z3)
 ax[1][1].plot_surface(x, y, z4)
 
 plt.show()

[[Datei:PythonIng_subplot1.png]]

Man beachte, dass man die Unterbilder im Bild nach dem Ausführen des Scripts z.B. mit der mittleren Maustaste einzeln drehen, oder über die Einträge in der Menüzeile einzeln bearbeiten kann. Mit ein paar Zeilen Programmtext lässt sich also eine Menge an Funktionalität generieren.

Die Farbgebung lässt sich über &lt;code&gt;colormaps&lt;/code&gt; variieren.

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm)
 
 plt.show()

[[Datei:PythonIng_colormap1.png]]

Es gibt eine Menge an Colormaps, z.B. &lt;code&gt;plasma, Greys, Dark2, ocean&lt;/code&gt;. Zwecks detaillierterer Infos siehe die matplotlib-Dokumentation. &lt;small&gt;Verwendet man die IDE namens IDLE, so gibt es dort auch die automatische Codevervollständigung. D.h. es werden alle Möglichkeiten (in unserem Fall nach dem Eintippen von &lt;code&gt;cm.&lt;/code&gt; alle verfügbaren Colormaps) angezeigt.&lt;/small&gt;

Die &quot;edgecolor&quot; und Linienbreite können auch frei gewählt werden:

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm, edgecolor=&quot;black&quot;, linewidth=1.0)
 
 plt.show()

[[Datei:PythonIng_colormap2.png]]

=== Höhenlinien ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 ax.contour(x, y, z)
 
 plt.show()

[[Datei:PythonIng_höhenlinien1.png|400px]]

Etwas abgewandelt sieht das so aus: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contour(x, y, z)
 ax.clabel(hl, inline = True)
 
 plt.show()

[[Datei:PythonIng_höhenlinien2.png|400px]]

Und noch eine Variante (mit einem Farbbalken) sei gezeigt. 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contourf(x, y, z)
 fig.colorbar(hl) 
 
 plt.show()

[[Datei:PythonIng_höhenlinien5.svg|400px]]

=== Aufgaben ===
* Zeichnen Sie die räumliche Kurve &lt;math&gt;x = 2 \cdot \cosh(t)&lt;/math&gt;, &lt;math&gt;y = 5 \cdot \sin(t)&lt;/math&gt;, &lt;math&gt; z = t^{2} - t&lt;/math&gt;, &lt;math&gt;0 \leq t \leq 3\pi&lt;/math&gt;.
* Zeichnen Sie die Fläche &lt;math&gt;z = \log(x) + \cos(y)&lt;/math&gt;.

== Animationen und fortgeschrittenes 3D ==
=== Mit matplotlib ===
Auch mit matplotlib sind Animationen möglich. Das ist ein bisschen komplizierter und wird deshalb hier nur mit einem sehr einfachen Beispiel dargestellt (bei Interesse siehe z.B. auch das [https://matplotlib.org/stable/users/explain/animations/animations.html#animations Animations using Matplotlib-Tutorial]).

 import matplotlib.pyplot as plt
 import matplotlib.animation as ani
 import matplotlib
 import numpy as np
 
 def update(frame):
     line.set_xdata(x[:frame])
     line.set_ydata(y[:frame])
     return (line)
 
 fig, ax = plt.subplots()
 
 x = np.arange(0, 10, .1)
 y = np.sin(x)
 
 line, = ax.plot(x[0], y[0])
 ax.set(xlim=[0, 10], ylim=[-1, 1])
 
 a = ani.FuncAnimation(fig=fig, func=update, frames=100, interval=20)
 plt.show()
 
 # Speichere die Animation in einem animierten GIF (optional)
 a.save(filename=&quot;c:/tmp/PythonIng_anim5.gif&quot;, writer=&quot;pillow&quot;)

[[Datei:PythonIng_anim5.gif]]

Es wird eine Sinuskurve auf den Bildschirm gezeichnet. In der letzten Zeile wird diese Animation in ein animiertes GIF gespeichert. Das ist natürlich optional und kann auch weggelassen werden.

=== Mit VPython ===
Aber auch mit dem Modul VPython lassen sich einfache 3D-Animationen erstellen. VPython ist ein externes Modul, das vorab installiert werden muss. Unter openSUSE Tumbleweed gibt es dzt. kein entsprechendes rpm-Paket. Die übliche Methode der Installation mittels YaST oder zypper ist somit nicht möglich. Auch eine direkte Verwendung von pip führt nur zu einer Fehlermeldung (&lt;code&gt;error: externally-managed-environment&lt;/code&gt;). Es empfiehlt sich dort folgende Vorgehensweise:
# Erstelle zuerst eine virtuelle Umgebung, z.B.: &lt;code&gt;python3.11 -m venv ~/tmp/venv1&lt;/code&gt;
# Wechsle das Verzeichnis: &lt;code&gt;cd ~/tmp/venv1/bin&lt;/code&gt;
# Installiere das entsprechende Paket: &lt;code&gt;./pip install vpython&lt;/code&gt;
# Führe das entsprechende Skript aus: &lt;code&gt;./python ~/tmp/test1.py&lt;/code&gt;

Aktuell (März 2026) ist dieses Programmpaket lt. der [https://vpython.org/presentation2018/install.html VPython-Homepage] nur für die Python-Versionen 3.8 bis 3.12 verfügbar.

Ein Beispiel zu einer einfachen Animation wird nachfolgend geliefert.

 from vpython import *
 
 scene.width = 1200
 scene.height = 600
 scene.center = vector(20,0,0)
 scene.background = color.white
 
 cylinder(pos=vector(0,0,0), axis=vector(20,0,0), radius=5, 
         color=color.blue)
 cone(pos=vector(0,0,0), axis=vector(-10,0,0), radius=5, 
         color=color.blue)
 helix(pos=vector(20,0,0), axis=vector(40,0,0), radius=2, 
         coils=10, thickness=0.5, color=color.blue)
 
 ball = sphere(pos=vector(20,0,0), color = color.green, radius = 1)
 ball.p = vector(0.15, 0, 0)
 
 toc = True
 
 while True:
     rate(200)
     if(ball.pos.x &lt;= 60 and toc == True):
         ball.pos += ball.p
     else:
         toc = False
         ball.pos -= ball.p
         if(ball.pos.x &lt;= 20 and toc == False):
             toc = True

[[Datei:PythonIng_vpython_anim.JPG]]

Idealerweise öffnet sich beim Ausführen des Scripts ein Browserfenster. Darin wird die programmierte Animation gezeigt (siehe auch den obigen Screenshot). Eine Größenänderung können Sie mit der mittleren Maustaste initiieren. Die Szenerie drehen können Sie mit der rechten Maustaste.

=== Mit build123d ===
Hiermit lassen sich einfach 3D-Modelle für CAD-Systeme erstellen. [https://build123d.readthedocs.io/en/latest/ build123d] ist ein externes Modul und muss vorab, wie schon für mehrere andere Module gezeigt, installiert werden (pip, venv etc.).

Beispielcode:

 from build123d import *
 
 # Bauteil
 with BuildPart() as bauteil: 
     # Zylinder erstellen
     Cylinder(100, 60)
        
     # Bohrung
     with BuildSketch(bauteil.faces().sort_by(Axis.Z)[-1]) as loch:
         Circle(radius=10)
     # negativ extrudieren
     extrude(amount=-60, mode=Mode.SUBTRACT)
     
     # Dem Bauteil z.B. die Farbe rot zuweisen
     # bauteil.part.color = Color(&quot;red&quot;, alpha=1.0)
 
     # Fertiges Modell exportieren
     export_step(bauteil.part, &quot;bauteil.step&quot;)

Ausgabe ({{W|Standard for the exchange of product model data | STEP}}-Datei, z.B. in {{W|FreeCAD}} importiert, Screenshot):

[[Datei:PythonIng_build123d.jpg | 300px]]

FreeCAD ist ein freies 3D-CAD-System. Die [[Ing_Mathematik:_Python#FreeCAD | Makroprogrammierung]] in diesem System wird später noch gezeigt. STEP steht für &quot;'''St'''andard for the '''e'''xchange of '''p'''roduct model data&quot; und ist ein Datenaustauschformat.

=== Mit VTK ===
Komplexer, aber auch mächtiger als VPython ist die Verwendung von VTK ('''V'''isualization '''T'''ool'''k'''it). Genauer gesagt des Python-Wrappers von VTK. Dieses externe Python-Modul muss vorab installiert werden (z.B. mittels YaST, pip oder in eine virtuelle Umgebung). VTK ist eine Softwarebibliothek zur 3D-Visualisierung und wurde ursprünglich in C++ geschrieben. Verbreitet eingesetzt wird diese Bibliothek in der Wissenschaft und Forschung, z.B. 
* in der medizinischen Bildgebung
* für Strömungssimulationen
* für Klimadaten

VTK funktioniert nach dem {{W|Grafikpipeline|Pipeline-Prinzip}}:

 Source (Quellen) -&gt;  Filter -&gt; Mapper (Senken) -&gt; Actor/Renderer

Daten fließen von den Quellen zu den Senken.

Als einfaches Beispiel wird die Darstellung eines Zylinders gezeigt, der mit den Maustasten gedreht oder in der Größe geändert werden kann:

 import vtk
 
 # Zylinder erzeugen
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 # Geometrie in darstellbare Daten umwandeln
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 # Objekt in der Szene
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 # Szene verwalten
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 # Render-Fenster
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 # Maus/Tastatur-Steuerung
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 # Starten
 render_window.Render()
 interactor.Start()

Ausgabe:

[[Datei:PythonIng_VTK_1.png]]

Gleiches Beispiel wie oben, aber mit einer Animationssequenz:

 import vtk
 import time
 
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     render_window.Render()
     time.sleep(0.01)

Das Grafikfenster schließt sich nach Ablauf der Schleife. Das Fenster bleibt geöffnet, wenn Sie am Programmende folgenden Befehl hinschreiben

 interactor.Start()

Um den animierten Zylinder grün einzufärben, müssen Sie Folgendes im obigen Programm ergänzen (Farbnamen):

 colors = vtk.vtkNamedColors()
 actor.GetProperty().SetColor(colors.GetColor3d(&quot;Green&quot;))

Als Namen können Sie u.a. die CSS3 Web-Farben verwenden (siehe z.B. [https://wiki.selfhtml.org/wiki/Farbe/Farbangaben] und {{W|Webfarbe#CSS_3}}).

Alternativ funktioniert auch das ({{W|RGB-Farbraum|RGB}}):

 actor.GetProperty().SetColor(0.0, 0.6, 0.0)

Wie der Zylinder mit einer Textur versehen wird, zeigt folgendes Programm:

 import vtk
 import time
 
 cylinder = vtk.vtkCylinderSource()
 cylinder.SetResolution(30)
 cylinder.SetHeight(3.0)
 cylinder.SetRadius(1.0)
 cylinder.CappingOn()
 
 texture_coords = vtk.vtkTextureMapToCylinder()
 texture_coords.SetInputConnection(cylinder.GetOutputPort())
 texture_coords.PreventSeamOn()
 
 reader = vtk.vtkJPEGReader()
 reader.SetFileName(&quot;PythonIng_textur.jpg&quot;)
 
 texture = vtk.vtkTexture()
 texture.SetInputConnection(reader.GetOutputPort()) 
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(texture_coords.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 actor.SetTexture(texture)
 
 renderer = vtk.vtkRenderer()
 renderWindow = vtk.vtkRenderWindow()
 renderWindow.AddRenderer(renderer)
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(renderWindow)
 
 renderer.AddActor(actor)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     renderWindow.Render()
     time.sleep(0.01)
 
 interactor.Start()

&lt;gallery&gt;
PythonIng_textur.jpg | Textur-Datei
PythonIng_VTK_2.png | Ausgabe (Screenshot)
&lt;/gallery&gt;

== Sonstige Grafikbibliotheken ==
=== Py5 ===
Im Buch ''Iacono et al.: Programmieren trainieren, mit über 150 Workouts in Java und Python; 3. Aufl., Hanser, 2023'' werden zahlreiche Aufgaben gestellt, die u.a. mit Processing zu lösen sind.  Processing ist eine einfache Programmiersprache und Entwicklungsumgebung. Warum ich das erwähne? Weil in älteren Processing-Versionen auch die Programmiersprache Python 2 abgedeckt war. Bei neueren Versionen gibt es keine Python-Anbindung mehr (getestet nur mit openSUSE Tumbleweed und Python 3). Somit funktioniert der Python-Teil im genannten Buch zum Teil nicht mehr. Ist das tragisch, oder kann das Buch weggeschmissen werden? Nein! Es gibt Alternativen zu Processing. Zum einen die im Buch selbst genannten Bibliotheken tkinter oder pygame. Pygame wird dort auch kurz anhand eines Beispiels thematisiert. Aber noch besser ist es, die py5-Bibliothek zu verwenden (lt. Google KI vom 30. Sept. 2026: ''Der echte, moderne „spirituelle Nachfolger“''). Damit ist die Funktionalität von Processing gewährleistet. Man kann aber beliebige Editoren oder IDEs zur Programmerstellung verwenden, ohne an Processing als IDE gebunden zu sein. Nachfolgend werden ein paar Beispiele zu dieser externen Bibliothek gegeben. Der erste Schritt ist wieder, die py5-Bibliothek zu installieren (z.B. mittels pip in eine virtuelle Umgebung; Python&gt;=3.10 und ein JDK&gt;=17 müssen auch installiert sein (Stand Okt. 2026)). Dann kann es schon mit dem Programmieren losgehen.

Beispiel (angelehnt an die ''Aufgabe W.2.3 Haus'' des genannten Buchs, jedoch etwas erweitert):

 import py5
 
 def setup():
     py5.size(600, 600)            # Fenstergröße 600px x 600px 
     py5.background(255, 255, 255) # Hintergrundfarbe ... weiss
     
 def draw():
     # Haus zeichnen
     py5.fill(255, 255, 255)       # Hintergrundfarbe ... weiss
     py5.stroke(255, 0, 0)         # Linienfarbe ... rot 
     py5.stroke_weight(3)          # Linienbreite ... 3px
     py5.rect(150, 200, 300, 300)  # Rechteck zeichnen (x, y, b, h)
     py5.triangle(150, 200, 300, 100, 450, 200) # Dreieck zeichnen
     py5.circle(250, 300, 70)      # Kreis zeichnen (x, y, d)   
     
     # Bemassung zeichnen
     py5.stroke(0, 255, 0)
     py5.stroke_weight(1)
     py5.line(300, 100, 550, 100)  # Linie zeichnen
     py5.line(450, 200, 550, 200) 
     py5.line(450, 500, 550, 500) 
     py5.line(150, 500, 150, 550)
     py5.line(450, 500, 450, 550)
     py5.text_size(20)             # Textgroesse
     py5.fill(0, 255, 0)           # Textfarbe
     py5.text(&quot;300&quot;, 280, 550)     # Text zeichnen
     py5.text(&quot;100&quot;, 500, 150)
     py5.text(&quot;300&quot;, 500, 350)  
 
     # Gedrehtes Rechteck zeichnen
     py5.stroke(255, 255, 0)
     py5.stroke_weight(3)
     py5.fill(200, 200, 200) 
     py5.translate(320, 260)  
     py5.rotate(0.3)               # Drehung (in Radiant)
     py5.rect(0, 0, 100, 50)
 
 # Startet den Sketch
 py5.run_sketch()


Ausgabe:

[[Datei:PythonIng_py5_1.png|300px]]

Das skizzierte Haus ist mit einer rudimentären Bemaßung versehen und hat zwei Fenster, ein rundes und ein gedrehtes, trübes rechteckiges. 

Beispiel (Mausoperationen):

 import py5
 
 def setup():
     py5.size(600, 600)            
     py5.background(255, 255, 255)
 
 def draw():
     pass
    
 def mouse_pressed():
     py5.text_size(15) 
     py5.fill(0, 0, 255)
     x = py5.mouse_x
     y = py5.mouse_y
     py5.text(&quot;(%d, %d)&quot; %(x, y), x, y) # Positionsdaten bei Maus-Klick schreiben
 
 py5.run_sketch()

Ausgabe:

[[Datei:PythonIng_py5_2.png|300px]]

Obiges Bild zeigt das Resultat nach einigen Mausklicks. Man erkennt, dass links-oben der Koordinatennullpunkt ist. Die x-Achse zeigt nach rechts, die y-Achse nach unten.

Beispiel (Fünfeck):

 import py5
 import random 
 
 def setup():
     py5.size(400, 400)
     py5.no_loop()       # statisches Bild (schont die Ressourcen)
 
 def draw():
     py5.translate(py5.width / 2, py5.height / 2)  # KS setzen
 
     radius = 150
     eck_anzahl = 5
 
     py5.fill(random.randint(0, 255), random.randint(0, 255), 
              random.randint(0, 255))    # Füllfarbe auf Zufallswert setzen
     py5.stroke(155, 0, 0)            
     py5.stroke_weight(5)     
     
     # Fünfeck als Polygon zeichnen
     py5.begin_shape()
     for i in range(eck_anzahl):
         winkel = i * py5.TWO_PI / eck_anzahl - py5.HALF_PI
         x = py5.cos(winkel) * radius
         y = py5.sin(winkel) * radius
         py5.vertex(x, y)
     py5.end_shape(py5.CLOSE)
 
 py5.run_sketch()

Ausgabe, bspw.:

[[Datei:PythonIng_py5_5.png|200px]]

&lt;u&gt;Kleine Aufgaben:&lt;/u&gt;
* Um die Funktionsweise von &lt;code&gt;py5.no_loop()&lt;/code&gt; zu verstehen, kommentieren Sie die Anweisung im Beispiel einfach aus, und starten Sie das Programm erneut.
* Zeichnen Sie ein Siebeneck.
* Was passiert, wenn man &lt;code&gt;py5.CLOSE&lt;/code&gt; im &lt;code&gt;py5.end_shape()&lt;/code&gt;-Befehl weglässt?

Beispiel (Grafik laden und zeichnen):

 import py5
 
 image1 = None
 
 def setup():
     global image1
     py5.size(600, 600)
     py5.no_loop()
     image1 = py5.load_image(&quot;PythonIng_py5_1.png&quot;)
 
 def draw():
     py5.image(image1, 0, 0)
 
 py5.run_sketch()

Hier wird einfach das Bild vom Haus-Beispiel (Screenshot von weiter oben) geladen und gezeichnet.

Beispiel (angelehnt an ''W.5.10 Wurfparabel'' des genannten Buches; mit OOP erstellt):

 import py5
 
 class Wurfparabel(py5.Sketch):
     def __init__(self, v0, angle):
         super().__init__()
         self.v0 = v0
         self.angle = self.radians(angle)
         self.g = 9.81
         self.t = 0.0
         self.scale = 1.5
 
     def settings(self):
         self.size(800, 600)
 
     def setup(self):        
         self.background(0, 0, 0)
         
     def draw(self):
         self.t += 0.1
 
         self.translate(50, 500)
       
         # KS Zeichnen
         self.fill(255, 255, 0)
         self.stroke(255, 255, 0)
         self.stroke_weight(1)
         self.line(0, 0, 0, -300)
         self.line(0, 0, 700, 0)
 
         # Punkt zeichnen
         cx = self.v0 * self.cos(self.angle) * self.t * self.scale
         cy = -(self.v0 * self.sin(self.angle) * self.t - \
                self.g/2 * self.t**2) * self.scale
         self.fill(255, 0, 0)
         self.stroke(255, 0, 0)
         self.circle(cx, cy, 3)
        
         # Stoppen bei Bodenkontakt
         if cy &gt;= -5:
             self.no_loop()
            
 def wurfparabel(v0=50, angle=45):
     sketch = Wurfparabel(v0, angle)
     sketch.run_sketch()
 
 v0 = float(input(&quot;v0 = &quot;))
 winkel = float(input(&quot;winkel = &quot;))
 wurfparabel(v0=v0, angle=winkel)

Eingabe auf der Konsole:

 v0 = 60
 winkel = 45

Ausgabe:

[[Datei:PythonIng_py5_13.png|200px]]

Die benötigten Formeln der Bewegungsgleichung kann man leicht herleiten, bzw. man benutzt folgende Grafik als Hilfestellung:

[[Datei:Wurfparabel_Zusammenfassung_aktualisierung.png|700px]]

&lt;u&gt;Aufgabe:&lt;/u&gt; Berechnen Sie den Scheitelpunkt und die Wurfweite bei gegebener Anfangsgeschwindigkeit und gegebenem Abwurfwinkel. Die Abwurfhöhe &lt;math&gt;y_0&lt;/math&gt; sei 0. Der Wurf soll auf der Erde stattfinden (g = 9.81 m/s²). Die dazu benötigten Formeln können aus obiger Grafik entnommen werden (oder Sie leiten sie selbst her). Geben Sie die Ergebnisse auf der Konsole aus.

Beispiel (eine einfache Animation):

 import py5
 
 i = 0
 
 def setup():
     py5.size(600, 600)
     py5.frame_rate(5)
     py5.stroke_weight(20)
 
 def draw():
     global i
     
     py5.background(255, 255, 255)
     py5.translate(py5.width/2, py5.height/2)
     py5.rotate(py5.PI/8 * i)    
 
     py5.line(-100, 0, 100, 0)
     i += 1
 
 py5.run_sketch()

Es wird eine rotierende Linie gezeichnet (z.B. wie bei einem Installationsprozess verwendet - zeigt an, dass der Installationsfortschritt nicht eingefroren ist). Hierbei ist nur aufzupassen, dass der Hintergrund in &lt;code&gt;draw()&lt;/code&gt; gesetzt wird, ansonsten würden die Linien additiv gezeichnet. Das ist zwar auch schön, aber eben nicht das gewünschte Resultat.

Hiermit belassen wir es mit der py5-Bibliothek und wenden uns wieder &quot;mathematischeren&quot; Themen zu.

= Vektoren und Matrizen =
== Zahlenfolgen ==
Für das Erstellen von Zahlenfolgen bieten sich die Funktionen &lt;code&gt;arange&lt;/code&gt; und &lt;code&gt;linspace&lt;/code&gt; aus dem &lt;code&gt;numpy&lt;/code&gt;-Modul an.

 from numpy import *
 
 start = 0
 stop = 10
 step = 2
 num = 10
 
 r = arange(start, stop, step)   # step ... Schrittweite
 l = linspace(start, stop, num)  # num ... Anzahl der Werte
 
 print(&quot;r = &quot;, r)
 print(&quot;l = &quot;, l)

Ausgabe:
 r =  [0 2 4 6 8]
 l =  [ 0.          1.11111111  2.22222222  3.33333333  4.44444444  5.55555556
   6.66666667  7.77777778  8.88888889 10.        ]

Bei &lt;code&gt;arange&lt;/code&gt; ist der &lt;code&gt;stop&lt;/code&gt;-Wert nicht im Ergebnis enthalten, bei &lt;code&gt;linspace&lt;/code&gt; standardmäßig aber sehr wohl. Jedoch kann man das bei &lt;code&gt;linspace&lt;/code&gt; auch ändern. Dann ist der Stoppwert nicht mehr enthalten: 

 linspace(start, stop, num, endpoint=False)

== Vektoren ==
Vektoren sollten jedem aus der Linearen Algebra bekannt sein. 

=== Arrays ===
In Python mit NumPy kann man Vektoren durch die Funktion array erzeugen.

 import numpy as np
 
 l1 = (-5, 3, 2)
 l2 = (1, 1, 4)
 
 a1 = np.array(l1)
 a2 = np.array(l2)
 
 a3 = a1 + a2
 a4 = 2 * a2
 
 print(a1)
 print(a2)
 print(a3)
 print(a3[2])
 print(a4)

Ausgabe:
 [-5  3  2]
 [1 1 4]
 [-4  4  6]
 6
 [2 2 8]

=== Zeilen- und Spaltenvektoren ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 print(z)
 print(s)

Ausgabe:
 [ [-5  3  2] ]
 [[1]
  [1]
  [4]]

=== Skalarprodukt ===
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4))
 
 skalarprodukt = np.dot(a1, a2)  
 
 print(skalarprodukt)

Ausgabe:
 6

=== Vektorprodukt ===
&lt;math&gt;a\ast b=\left(\begin{array}{c}
a_{1}\\
a_{2}\\
a_{3}
\end{array}\right)\ast\left(\begin{array}{c}
b_{1}\\
b_{2}\\
b_{3}
\end{array}\right)=\left(\begin{array}{c}
a_{2}b_{3}-a_{3}b_{2}\\
a_{3}b_{1}-a_{1}b_{3}\\
a_{1}b_{2}-a_{2}b_{1}
\end{array}\right)
&lt;/math&gt; 

Python-Code:
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4)) 
 
 vektorprodukt = np.cross(a1, a2) 
 
 print(vektorprodukt)

Ausgabe:
 [10 22 -8]

=== Transponierter Vektor ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 # transponierter Vektor
 z_tp = np.transpose(z)
 # transponierter Vektor
 s_tp = np.transpose(s)
 
 print(z_tp)
 print(s_tp)

Ausgabe:
 [[-5]
  [ 3]
  [ 2]]
 [ [1 1 4] ]

=== Vektorfelder visualisieren ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 # Daten generieren
 x = np.arange(0, 10, 1)
 y = np.arange(0, 10, 1)
 X, Y = np.meshgrid(x, y)
 U = X * Y
 V = Y + X
 
 # Plotten
 fig, ax = plt.subplots()
 
 ax.quiver(X, Y, U, V, angles='xy')
 
 plt.show()

Ausgabe:

[[Datei:PythonIng_quiver1.png]]

== Matrizen==
 import numpy as np
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 print(m1)

Ausgabe:
 [[1 2 3]
  [4 5 6]]

=== Zugriff auf Matrizenelemente ===
Beispiel:

 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 
 # Element aus Zeile 2 und Spalte 3 (Achtung! Index startet bei Null)
 print(m1[1,2])

Ausgabe:
 6

Visualisierung:
  
     0   1   2
   +-----------+
 0 | 1 | 2 | 3 |
   +-----------+
 1 | 4 | 5 | '''6''' |
   +-----------+


Beispiel:

 import numpy as np
 
 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
 
 B = np.matrix(A)     
 
 print(B[2::, ::2])

Ausgabe:

 [['20' '22']
  ['30' '32']
  ['40' '42']]

Mit der NumPy-Bibliothek funktioniert das zweidimensionale Slicing. Mit normalen Listen/Tupels geht das nicht, was wir schon früher thematisiert haben.

=== Addition und Subtraktion von Matrizen ===
 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 m2 = np.matrix([[0, 0, 2], [1, 3, 2]])
 
 print(m1 + m2)
 print(m1 - m2)

Ausgabe:
 [[1 2 5]
  [5 8 8]]
 [[1 2 1]
  [3 2 4]]

=== Transponierte Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 2, 3], [4, 5, 6]])
 mt = np.transpose(m) 
 
 print(m)
 print(mt)

Ausgabe:
 [[1 2 3]
  [4 5 6]]
 [[1 4]
  [2 5]
  [3 6]]

=== Rang einer Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 rg = np.linalg.matrix_rank(m)
 
 print(rg)

Ausgabe:
 2

=== Inverse Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 mi = np.linalg.inv(m)
 
 print(mi)

Ausgabe:
 [[ 1.   0.6]
  [-0.  -0.2]]

=== Multiplikation von Matrizen (falksches Schema) ===
 import numpy as np
 
 m1 = np.matrix([[1, 3, 4],  [0, -5, 1]])
 m2 = np.matrix([[1, 2], [2, 3], [0, 2]])
 
 print(m1 @ m2)

Ausgabe:
 [[  7  19]
  [-10 -13]]

=== Eigenwerte und Eigenvektoren ===
 import numpy as np
 
 m = np.matrix([[5, 8],  [1, 3]])
 D,V = np.linalg.eig(m)
 
 # Eigenwerte
 print(D)
 # Eigenvektoren
 print(V)

Ausgabe:
 [7. 1.]
 [[ 0.9701425  -0.89442719]
  [ 0.24253563  0.4472136 ]]

=== Teilmatrizen ===
 import numpy as np
 m = np.matrix([[1, 3, 4],  [0, -5, 1]])
 print(&quot;m = &quot;, m)
 
 # Erste Zeile extrahieren
 m1 = m[0,:]
 print(&quot;m1 = &quot;, m1)
 
 # Das Element aus der 1. Zeile und der 2. Spalte extrahieren
 m2 = m[0,1]
 print(&quot;m2 = &quot;, m2)
 
 # Zweite Spalte extrahieren
 m3 = m[:, 1]
 print(&quot;m3 = &quot;, m3)

Ausgabe:
 m =  [[ 1  3  4]
  [ 0 -5  1]]
 m1 =  [ [1 3 4] ]
 m2 =  3
 m3 =  [[ 3]
  [-5]]

=== Spezielle Matrizen ===
==== Nullmatrix ====
 import numpy as np
 z = np.zeros((3, 2))
 print(z)

Ausgabe:
 [[0. 0.]
  [0. 0.]
  [0. 0.]]

==== Einheitsmatrix ====
 import numpy as np
 z = np.eye(3)
 print(z)

Ausgabe:
 [[1. 0. 0.]
  [0. 1. 0.]
  [0. 0. 1.]]

==== Matrix mit lauter Einsen ====
 import numpy as np
 z = np.ones((3, 2))
 print(z)

Ausgabe:
 [[1. 1.]
  [1. 1.]
  [1. 1.]]

=== Spärlich besetzte Matrizen ===
Das Thema spärlich besetzter Matrizen wird hier nur kurz angerissen. Nähere Details siehe unter dem Weblink  [https://docs.scipy.org/doc/scipy/reference/sparse.html#module-scipy.sparse]. 

Beispiel:

 import numpy as np
 import scipy
 
 A = scipy.sparse.csr_array(np.eye(5))
 
 print(A)

Ausgabe:
 &lt;Compressed Sparse Row sparse array of dtype 'float64'
         with 5 stored elements and shape (5, 5)&gt;
   Coords        Values
   (0, 0)        1.0
   (1, 1)        1.0
   (2, 2)        1.0
   (3, 3)        1.0
   (4, 4)        1.0

csr steht für '''c'''ompressed '''s'''parse '''r'''ow.

Andere Möglichkeiten:
* coo-Format ('''coo'''rdinate Format): &lt;code&gt;scipy.sparse.coo_array()&lt;/code&gt;
* lil-Format ('''li'''st of '''l'''ists): &lt;code&gt;scipy.sparse.lil_array()&lt;/code&gt;
* csc-Format ('''c'''ompressed '''s'''parse '''c'''olumn): &lt;code&gt;scipy.sparse.csc_array()&lt;/code&gt;

Es gibt auch &lt;code&gt;scipy.sparse.csr_matrix()&lt;/code&gt; etc. Diese Befehle sind aber veraltet und es wird empfohlen, statt dessen die &lt;code&gt;..._array()&lt;/code&gt;-Funktionen zu verwenden.

&lt;u&gt;Aufgaben:&lt;/u&gt; 
Recherchieren Sie im Internet 
* generell zum Thema &quot;spärlich besetzte Matrizen mit Python&quot;.
* Was sind die Vor-/Nachteile von csr-arrays gegenüber coo- und lil-arrays?
* Wann verwendet man sinnvollerweise csr- und wann csc-arrays?
* Wie wandelt man coo-arrays in csr-arrays um?

= Lineare Gleichungssysteme =
Sei &lt;math&gt;Ax = b&lt;/math&gt; ein lineares Gleichungssystem. &lt;math&gt;A&lt;/math&gt; sei die Koeffizientenmatrix, &lt;math&gt;x&lt;/math&gt; der Lösungsvektor und &lt;math&gt;b&lt;/math&gt; ein bekannter Vektor.

Beispiel:
 import numpy as np
 
 A = np.array([[5, 1], [0, 2]])
 b = np.array([1, 2])
 
 x = np.linalg.solve(A, b)
 
 print(x)

Ausgabe:
 [0. 1.]

Siehe dazu auch das Kapitel [[Ing Mathematik: Numerisches Lösen von linearen Gleichungssystemen]]. Dort wird dieses Themengebiet u.a. mit weitergehenden Python-Skripten vertieft.

== Aufgabe ==
* Lösen Sie folgendes Gleichungssystem mittels Python (und zur Kontrolle auch händisch): 
 5x + 6y - 2z = 12
 3x - y  - 3z = 6
 2x + 2y + 4z = 5

= Polynome =
== Ein erstes einfaches Beispiel ==
Gegeben sei das Polynom &lt;math&gt;7x^3+5x^2+1&lt;/math&gt;. In Python:

 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p)

Ausgabe:
    3     2
 7 x + 5 x + 1

== Einzelne Polynomwerte berechnen ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p(1.5))

Ausgabe:
 35.875

== Polynome integrieren und differenzieren ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 
 # 1. Ableitung
 p1 = p.deriv()
 p2 = p.deriv(1)
 
 # 2. Ableitung
 p3 = p.deriv(2)
 
 # Integral
 p4 = p.integ()
 
 print(p1)
 print(p2)
 print(p3)
 print(p4)

Ausgabe:
     2
 21 x + 10 x
     2
 21 x + 10 x
 
 42 x + 10
       4         3
 1.75 x + 1.667 x + 1 x

== Nullstellen bestimmen ==
 import numpy as np
 
 p = np.poly1d([2, 5, 0, 4])
 r = np.roots(p)
 
 print(r)

Ausgabe:
 [-2.7621427 +0.j          0.13107135+0.84077099j  0.13107135-0.84077099j]

== Aufgaben ==
* Berechnen Sie den Wert für x = 3 des Polynoms &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Differenzieren und integrieren Sie das Polynom &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Berechnen Sie die Nullstellen von &lt;math&gt;y = 7x^5 - 3x^2 + 12&lt;/math&gt;.

= Nichtlineare Gleichungen und Gleichungssysteme =
== Nullstellenbestimmung ==
Löse eine beliebige Gleichung f(x) = 0, z.B. &lt;math&gt; f(x) = x^2 - 5\cos(x) - 10 = 0 &lt;/math&gt;:
 import scipy
 import numpy as np
 
 def f(x):
     return x**2 - 5*np.cos(x) - 10
    
 xstart = [-1, 1]        # Startwerte
 xn = scipy.optimize.root(f, xstart)
 
 print(xn.x)

Ausgabe:
 [-2.46813009  2.46813009]

Funktionsgraph:

[[Datei:octave_nichtlin2.jpg]]

== Gleichungssysteme ==
SymPy ist ein externes Modul, das symbolisches Rechnen ('''Sym'''bolic '''Py'''thon) ermöglicht. 

Folgende Aufgabe ist dem Buch &quot;Knorrenschild: Numerische Mathematik, Hanser, 2017, Seite 72&quot; entnommen. Zu lösen ist das nichtlineare Gleichungssystem

&lt;math&gt;f_1 = 2x_1 + 4x_2 = 0 &lt;/math&gt;

&lt;math&gt;f_2 = 4x_1 + 8x_2^3 = 0&lt;/math&gt;

Mit Python ist das so möglich:
 import sympy
 
 x1, x2 = sympy.symbols(&quot;x1 x2&quot;) 
 
 f1 = 2*x1 + 4*x2
 f2 = 4*x1 + 8*x2**3
 
 s = sympy.solve((f1, f2), x1, x2) 
 
 print(s)

Ausgabe:
 [(-2, 1), (0, 0), (2, -1)]

Plot:

[[Datei:IngPython_nl_gleichung1.svg|500px]]

= Komplexe Zahlen =
Die imaginäre Einheit wird in Python durch den Buchstaben &lt;code&gt;j&lt;/code&gt; symbolisiert. Darstellen kann man eine komplexe Zahl bekannterweise in mehreren Formen:
* Kartesische Darstellung &lt;math&gt;z = \Re(z) + j \cdot \Im(z)&lt;/math&gt;
* Polardarstellungen &lt;math&gt;z = r \cdot (\cos(\phi) + j \cdot \sin(\phi)) = r \cdot e^{j\cdot \phi}&lt;/math&gt;

Die konjugiert komplexe Zahl ist &lt;math&gt;z^* = \Re(z) - j \cdot \Im(z)&lt;/math&gt;

Nachfolgend einige mathematische Operationen mit Python und NumPy.

 import numpy as np
 
 z1 = 2 + 5j           # kartesische Darstellung
 z2 = 3 * np.exp(3j)   # Polardarstellung
  
 # Addition
 res = z1 + z2
 print(&quot;z1 + z2 = &quot;, res)
 
 # Multiplikation
 res = z1 * z2
 print(&quot;z1 * z2 = &quot;, res)
 
 # Realteil
 res = np.real(z2)
 print(&quot;Realteil von z2 = &quot;, res)
 
 # Imaginärteil
 res = np.imag(z2)
 print(&quot;Imaginaerteil von z2 = &quot;, res)
 
 # Betrag
 res = np.abs(z1)
 print(&quot;Betrag von z1 = &quot;, res)
 
 # Argument
 res = np.angle(z1)
 print(&quot;Argument von z1 = &quot;, res)
 
 # Konjugiert komplexe Zahl
 res = np.conj(z1)
 print(&quot;Konjugiert komplexe Zahl von z1 = &quot;, res)

Ausgabe:
 z1 + z2 =  (-0.9699774898013365+5.423360024179601j)
 z1 * z2 =  (-8.05675510050068-14.003167400647481j)
 Realteil von z2 =  -2.9699774898013365
 Imaginaerteil von z2 =  0.4233600241796016
 Betrag von z1 =  5.385164807134504
 Argument von z1 =  1.1902899496825317
 Konjugiert komplexe Zahl von z1 =  (2-5j)

= Interpolation =
 import numpy as np
 import scipy
 import matplotlib.pyplot as plt
 
 # Stützpunkte
 xp = np.arange(1, 6)
 yp = (0, -5, 2, 7, 6)
 
 ti = np.arange(1, 5, 0.01)
 
 i1 = scipy.interpolate.interp1d(xp, yp, kind = &quot;linear&quot;)
 i2 = scipy.interpolate.interp1d(xp, yp, kind = &quot;cubic&quot;) 
 
 plt.plot(xp, yp, &quot;rx&quot;)
 plt.plot(xp, i1(xp))
 plt.plot(ti, i2(ti))
 plt.show()

Ausgabe:

[[Datei:PythonIng_interpol1.png]]

&lt;code&gt;scipy.interpolate.interp1d()&lt;/code&gt; gilt als veraltet ([https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.interp1d.html]). Stattdessen soll man modernere Alternativen wie &lt;code&gt;scipy.interpolate.Akima1DInterpolator()&lt;/code&gt; oder &lt;code&gt;scipy.interpolate.CubicSpline()&lt;/code&gt; benutzen.

= Differenzialrechnung =
== Numerisches Differenzieren ==
Als Beispiel differenzieren wir &lt;math&gt;y = 5x\sin{x}&lt;/math&gt; und stellen das Ganze grafisch dar.

 from findiff import Diff
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.linspace(0, 10, 1000)
 f = 5 * x * np.sin(x)
 dx = x[1] - x[0]
 
 # Ableitung
 d_dx = Diff(0, dx)
 df_dx = d_dx(f)
 
 # Grafik
 plt.plot(x, f, label = &quot;y&quot;)
 plt.plot(x, df_dx, label = &quot;y'&quot;)
 plt.grid()
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

Ausgabe:

[[Datei:octave_diff1.jpg]]

&lt;small&gt;findiff ist ein externes Modul. Dieses muss installiert werden (z.B. so: ...\Python\Scripts\pip.exe install --upgrade findiff). Für die Vorgehensweise unter openSUSE Tumbleweed siehe das Kapitel [[Ing_Mathematik:_Python#Mit_VPython | VPython]], nur dass das Ganze mit einer aktuelleren Python-Version exekutiert wird, z.B. mit Python 3.13.  Das im Buch &quot;Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler, Rheinwerk&quot; verwendete Modul &quot;scipy.misc&quot; ist veraltet (deprecated ... missbilligt). Lt. [https://docs.scipy.org/doc/scipy-1.17.0/dev/roadmap-detailed.html#misc SciPy-Dokumentation für die Version 1.17.0] wurden alle entsprechenden Features schon entfernt.&lt;/small&gt;

== Symbolisches Differenzieren ==
Differenzieren Sie die Funktionen &lt;math&gt;f_1(x) = x^2&lt;/math&gt; und &lt;math&gt;f_2(x) = \sin(x)\cos\left(\frac{x}{2}\right)&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2;
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 d1 = sympy.diff(f1, x)
 d2 = sympy.diff(f2, x)
 
 print(d1)
 print(d2)

Ausgabe:
 2*x
 -0.5*sin(0.5*x)*sin(x) + cos(0.5*x)*cos(x)

== Aufgaben ==
* Differenzieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.
* Differenzieren Sie die Funktion &lt;math&gt;y = \frac{\sinh(x)}{(1+x)}&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.

= Integralrechnung =
== Numerisches Integrieren ==
Berechnen Sie das Integral &lt;math&gt;\int_{0}^{3}x^2 dx&lt;/math&gt;.

 import scipy
 
 def f(x):
     return x**2
    
 i = scipy.integrate.quad(f, 0, 3)
 print(i)

Ausgabe:
 (9.000000000000002, 9.992007221626411e-14)

Das trifft den exakten Wert 9.0 ziemlich genau.

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} dx&lt;/math&gt;.

 import scipy
 import numpy as np
 
 def f(x):
     return 2**(-x)
   
 i = scipy.integrate.quad(f, 0, np.inf)
 print(i)

Ausgabe:
 (1.4426950408889556, 4.486558477977586e-09)

== Symbolisches Integrieren ==
Berechnen Sie &lt;math&gt;\int x^2 \text{d}x&lt;/math&gt; und &lt;math&gt;\int \sin{x}\cos{\frac{x}{2}} \text{d}x&lt;/math&gt;.
 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 i1 = sympy.integrate(f1, x)
 i2 = sympy.integrate(f2, x)
 
 print(i1)
 print(i2)

Ausgabe:
 x**3/3
 -0.666666666666667*sin(0.5*x)*sin(x) - 1.33333333333333*cos(0.5*x)*cos(x)

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} \text{d}x&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f = 2**(-x)
 i = sympy.integrate(f, (x, 0, sympy.oo))
 print(i)

Ausgabe:
 1/log(2)

&lt;code&gt;sympy.oo&lt;/code&gt; steht für das {{W|Unendlichzeichen}} &lt;math&gt;\infty&lt;/math&gt; (die liegende Acht oder das Möbiusband). Mit &lt;code&gt;sympy.pprint(i)&lt;/code&gt; ließe sich letzere Ausgabe etwas schöner schreiben:

   1   
 ──────
 log(2)

Man beachtete, &lt;code&gt;log&lt;/code&gt; steht hier für den natürlichen Logarithmus &lt;code&gt;ln&lt;/code&gt;.

== Aufgaben ==
* Integrieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; von 1 bis 5.
* Integrieren Sie die Funktion &lt;math&gt;y = x^3&lt;/math&gt; von 0 bis 4.
* Integrieren Sie &lt;math&gt;\int x^x(\log (x) + 1)\mathrm dx&lt;/math&gt; symbolisch.

= Gewöhnliche Differenzialgleichungen =
== DGL numerisch lösen ==
Für die Lösung von Differenzialgleichungen steht u.a. die Funktion scipy.integrate.solve_ivp() zur Verfügung. Diese Funktion implementiert auch das Runge-Kutta-Verfahren (RK45).

{{Wikipedia | Runge-Kutta-Verfahren}}

Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import scipy
 import numpy as np
 import matplotlib.pyplot as plt
 
 def dy_dx(x, y):
     return x**2 + y**3
 
 y0 = [1]
 xi = [0, 1]
 x = np.arange(0, 1, 0.01)
 
 z = scipy.integrate.solve_ivp(dy_dx, xi, y0, method=&quot;RK45&quot;, dense_output=True)
 y = z.sol(x)
 
 plt.plot(x, y.T)
 plt.grid()
 plt.show()

[[Datei:PythonIng_dgl1.png]]

== DGL symbolisch lösen ==
Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 print(lsg)

Ausgabe:
 [Eq(f(x), (-x**2)**(1/3)), Eq(f(x), (-x**2)**(1/3)*(-1 - sqrt(3)*I)/2), Eq(f(x), (-x**2)**(1/3)*(-1 + sqrt(3)*I)/2)]

Mit &lt;code&gt;sympy.pprint&lt;/code&gt; (pretty print) lässt sich die Ausgabe etwas übersichtlicher darstellen.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 sympy.pprint(lsg)

Ausgabe:
 ⎡                           _____                        _____            ⎤
 ⎢          _____         3 ╱   2                      3 ╱   2             ⎥
 ⎢       3 ╱   2          ╲╱  -x  ⋅(-1 - √3⋅ⅈ)         ╲╱  -x  ⋅(-1 + √3⋅ⅈ)⎥
 ⎢f(x) = ╲╱  -x  , f(x) = ────────────────────, f(x) = ────────────────────⎥
 ⎣                                 2                            2          ⎦

== Aufgaben ==
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \frac{1}{x\cdot y}&lt;/math&gt; mit Python. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;m' = -k\cdot m&lt;/math&gt;. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \sqrt{|y|}&lt;/math&gt;.

=Laplace-Transformation=
Laplace-Transformation:

&lt;math&gt;F(s) =\mathcal{L} \left\{f\right\}(s) = \int_{0}^{\infty} f(t) \mathrm e^{-st} \,\mathrm{d}t, \qquad s\in\mathbb{C}
&lt;/math&gt;

Inverse Laplace-Transformation:

&lt;math&gt;\mathcal{L}^{-1} \left\{F\right\}(t)
  = \frac{1}{2 \pi \mathrm j} \int_{ \gamma - \mathrm j \infty}^{ \gamma + \mathrm j \infty} \mathrm e^{st} F(s)\,\mathrm ds 
= \begin{cases}
      f(t) &amp; \text{für } t \geq 0 \\
      0    &amp; \text{für } t &lt; 0
    \end{cases}
&lt;/math&gt;

Siehe auch [[Ing_Mathematik:_Laplace-Transformation]]

Code:
 import sympy
 from sympy.abc import t, s
 
 # Laplace-Transformation der Funktion f(t) = 1 (Heaviside-Fkt.)
 f = 1
 # alternativ: f = sympy.Heaviside(t)
 F = sympy.laplace_transform(f, t, s, noconds=True)
 print(&quot;Laplace-Transformierte F(s):&quot;, F) 
 
 # Inverse Laplace-Transformation zurück in den Zeitbereich
 f_inv = sympy.inverse_laplace_transform(F, s, t)
 print(&quot;Inverse Transformation f(t):&quot;, f_inv)

Ausgabe:
 Laplace-Transformierte F(s): 1/s
 Inverse Transformation f(t): Heaviside(t)

Die Zeile

 from sympy.abc import t, s

steht alternativ für

 t = sympy.symbols(&quot;t&quot;)
 s = sympy.symbols(&quot;s&quot;)

&lt;u&gt;Aufgaben&lt;/u&gt;: Ermitteln Sie mittels SymPy die &lt;math&gt;\mathcal{L}&lt;/math&gt;-Transformierten und dann wieder die  &lt;math&gt;\mathcal{L}^{-1}&lt;/math&gt;-Transformationen (ähnlich wie beim obigen Beispiel):
* &lt;math&gt;\sin(t) \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;t^3 \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;\text{e}^{\omega t} \circ\! -\! \bullet \ ?&lt;/math&gt;

=Fourier-Reihen=
&lt;math&gt;
f(x)\approx \frac{a_{0}}{2}+\sum_{k=1}^{\infty}\left(a_{k}\cos\left(kx\right)+b_{k}\sin\left(kx\right)\right)
&lt;/math&gt;

&lt;math&gt;
a_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\cos\left(kx\right)\mathrm dx\quad\text{für }k\geq0
&lt;/math&gt;

&lt;math&gt;
b_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\sin\left(kx\right)\mathrm dx\quad\text{für }k\geq1
&lt;/math&gt;

Für die Sägezahnfunktion &lt;math&gt;y=x;\, 0 &lt; x &lt; 2\pi&lt;/math&gt; sei die Fourierreihe mit einem Python-Programm (unter Mithilfe von sympy) hergeleitet.

Code:

 from sympy import fourier_series, pi, symbols, pprint
 
 x = symbols('x')
 f = x
 s = fourier_series(f, (x, 0, 2*pi))
 pprint(s.truncate(n=4))

Ausgabe:

                        2⋅sin(3⋅x)    
 -2⋅sin(x) - sin(2⋅x) - ────────── + π
                            3

Siehe auch [[Ing Mathematik: Fourierreihen]].

Ein komplizierteres Beispiel:

[[Datei:IngMath fourier bsp13.svg | 300px]]

&lt;math&gt;0\le t &lt; T/2\text{:}\quad f(t) = H&lt;/math&gt;

&lt;math&gt;T/2 \le t \le T\text{:}\quad f(t) = \frac{2H}{T}\left( t-\frac{T}{2}\right)&lt;/math&gt;

Code:

 import sympy as sp
 
 H = sp.Symbol('H', positive=True)
 T = sp.Symbol('T', positive=True)
 t = sp.Symbol('t')
 
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T/2)),
     (2*H/T*(t-T/2), (t &gt; T/2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Ausgabe:

      ⎛2⋅π⋅t⎞        ⎛4⋅π⋅t⎞        ⎛6⋅π⋅t⎞          ⎛2⋅π⋅t⎞          ⎛6⋅π⋅t⎞      
 H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   2⋅H⋅cos⎜─────⎟   2⋅H⋅cos⎜─────⎟      
      ⎝  T  ⎠        ⎝  T  ⎠        ⎝  T  ⎠          ⎝  T  ⎠          ⎝  T  ⎠   3⋅H
 ──────────── - ──────────── + ──────────── + ────────────── + ────────────── + ───
      π             2⋅π            3⋅π               2                 2         4 
                                                    π               9⋅π

=Rechnen mit wirklich großen Zahlen=
Bekannt ist, dass Python kaum Einschränkungen beim Wertebereich von Ganzzahlen hat, z.B.

 print(10**300)

Ausgabe (gekürzt):

 100000000000000000000...00000000000000000000000000000000000000000000000000000000000000000000000

Ähnliches geht auch mit Gleitpunktzahlen, z.B. durch die Verwendung des Moduls [https://mpmath.org/ mpmath]:

 import mpmath
 print(mpmath.mpf(1500.4)**mpmath.mpf(300))

Ausgabe:

 7.27975299218612e+952

Anderes Beispiel:

 from mpmath import mp, pi
 mp.dps = 100
 print(pi)

Ausgabe:

 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068

mpmath kann noch einiges mehr, dazu sei aber auf die entsprechende Dokumentation auf der mpmath-Homepage verwiesen. mpmath ist Bestandteil von SymPy, kann aber auch separat installiert werden.

Aber auch Python selbst besitzt eine Möglichkeit, um mit großen bzw. exakten Gleitpunktzahlen zu rechnen, nämlich das interne Modul decimal. Dieses hat einige Vorteile gegenüber mpmath, aber auch gravierende Nachteile. Diese seien hier nicht detailliert aufgezählt. Grob gesagt hat decimal im Finanzwesen seine Berechtigung. Für wissenschaftliche Anwendungen wird aber mpmath vorzuziehen sein, da es u.a. vielfältige mathematische Funktionen bereit stellt. Nachfolgend ein einfaches Beispiel mit decimal:

 import decimal
 print(&quot;Potenzierung:&quot;, decimal.Decimal(1500.4) ** decimal.Decimal(300.0))
 print(&quot;Einfache Addition:&quot;, 0.1 + 0.2)
 decimal.getcontext().prec = 50
 print(&quot;Addition mit decimal:&quot;, decimal.Decimal(&quot;0.1&quot;) + decimal.Decimal(&quot;0.2&quot;))

Ausgabe:

 Potenzierung: 7.279752992186121551039839134E+952
 Einfache Addition: 0.30000000000000004
 Addition mit decimal: 0.3

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet die genauen Vor- und Nachteile von decimal und mpmath. Verwenden Sie dazu auch KI (z.B. von Google, chatgpt).

= pint - mit physikalischen Größen rechnen = 
[[File:Pint-Glas_UK.jpg|right|100px]]
pint ist ein externes Python-Paket zur Manipulation von physikalischen Einheiten. Es muss vor der ersten Benutzung installiert werden (Vorgehensweise wie immer: pip, YaST, via venv etc.).

Beispiel:

 import pint
 import numpy as np
 
 ureg = pint.UnitRegistry()
 
 # Einfache Berechnung
 print(3 * ureg.meter + 4 * ureg.cm)
 
 # Mit NumPy
 npeinzel = [3, 4] * ureg.meter + [2, 5] * ureg.cm
 print(npeinzel)
 npsum = np.sum(npeinzel)
 print(npsum)
 
 # Konvertierung von Einheiten
 npsum_inch = npsum.to(ureg.inch)
 print(npsum_inch)
 
 print(npeinzel.magnitude)
 print(npeinzel.units)
 print(npeinzel.dimensionality)

Ausgabe:

 3.04 meter
 [3.02 4.05] meter
 7.07 meter
 278.3464566929134 inch
 [3.02 4.05]
 meter
 [length]

Die Dokumentation zu pint findet sich auf [https://pint.readthedocs.io/en/stable/].

=Regelungstechnische Aufgabenstellungen=
Für regelungstechnische Aufgaben gibt es u.a. das externe Paket &lt;code&gt;control&lt;/code&gt;. Hier soll nicht detailliert darauf eingegangen werden. Anhand eines Beispiels soll anschließend nur die Visualisierung in Form eines Bode-Diagramms und der Sprungantwort gezeigt werden. Gegeben sei ein P-Regler mit &lt;math&gt;R = \frac{5}{2}&lt;/math&gt; und eine Strecke &lt;math&gt;S= \frac{1}{30s^3+20s^2+10s+1,5}&lt;/math&gt;. Gesucht sei vorerst ein Bode-Diagramm für den offenen Regelkreis und das Führungsverhalten.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke  # oder: G0 = ct.series(regler, strecke)
 Gw = ct.feedback(G0)
 
 ct.bode_plot(G0, label='G0')
 ct.bode_plot(Gw, label='Gw')
 plt.show()

[[Datei:PythonIng_bode1.svg]]

Nun noch für obiges Beispiel die Sprungantwort. Diese zeigt einige große Überschwinger, d.h. der Regler kann sicher noch optimiert werden.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke 
 Gw = ct.feedback(G0) 
 
 t, y = ct.step_response(Gw)
 
 plt.plot(t,y)
 plt.title('Sprungantwort')
 plt.xlabel('t')
 plt.ylabel('h(t)')
 plt.grid()
 plt.show()

[[Datei:PythonIng_bode3.svg]]

Einige weitere wichtige Daten (Phasenreserve, Amplitudenreserve, Durchtrittsfrequenz) lassen sich mittels der &lt;code&gt;control&lt;/code&gt;-Funktion &lt;code&gt;margin()&lt;/code&gt; ermitteln. Die Ortskurve lässt sich mit der Funktion &lt;code&gt;nyquist_plot()&lt;/code&gt; zeichnen. Dies sei hier aber nicht weiter ausgeführt.

==Aufgaben==
* Zeichen Sie mit Python die Ortskurve für obiges Beispiel.
* Was passiert, wenn man die Reglerverstärkung weiter aufdreht (z.B. auf &lt;math&gt;R = \frac{25}{2}&lt;/math&gt;)?
* Wie sehen das Bode-Diagramm und die Sprungantwort aus, wenn ein PI-Regler verwendet wird?

= Stereostatik etc. =
Das Modul SymPy bietet einige Möglichkeiten einfache Bauwerke zu berechnen, z.B. Balken oder Fachwerke. Nachfolgend wird ein einfaches Fachwerk berechnet und gezeichnet.

Python-Code:
 from sympy.physics.continuum_mechanics.truss import Truss 
 
 t = Truss()
 # Knoten
 t.add_node((&quot;A&quot;, -3, 0), (&quot;B&quot;, 0, 0), (&quot;C&quot;, 4, 0), (&quot;D&quot;, 7, 0),
            (&quot;E&quot;, 6, 1.5), (&quot;F&quot;, 2, 3), (&quot;G&quot;, -2, 1.5))
 # Stäbe
 t.add_member((&quot;AB&quot;,&quot;A&quot;,&quot;B&quot;), (&quot;BC&quot;,&quot;B&quot;,&quot;C&quot;), (&quot;CD&quot;,&quot;C&quot;,&quot;D&quot;))
 t.add_member((&quot;AG&quot;,&quot;A&quot;,&quot;G&quot;), (&quot;GB&quot;,&quot;G&quot;,&quot;B&quot;), (&quot;GF&quot;,&quot;G&quot;,&quot;F&quot;))
 t.add_member((&quot;BF&quot;,&quot;B&quot;,&quot;F&quot;), (&quot;FC&quot;,&quot;F&quot;,&quot;C&quot;), (&quot;CE&quot;,&quot;C&quot;,&quot;E&quot;))
 t.add_member((&quot;FE&quot;,&quot;F&quot;,&quot;E&quot;), (&quot;DE&quot;,&quot;D&quot;,&quot;E&quot;))
 # Auflager; roller ... Loslager, pinned ... Festlager
 t.apply_support((&quot;A&quot;,&quot;roller&quot;), (&quot;D&quot;,&quot;pinned&quot;))
 # Einwirkende Kräfte
 t.apply_load((&quot;G&quot;, 5, 270), (&quot;E&quot;, 3, 90))
 
 # Berechnung 
 t.solve()
 print(&quot;Reaction Forces: &quot;, t.reaction_loads)
 print(&quot;Internal Forces: &quot;, t.internal_forces)
 
 # Fachwerk zeichnen
 p = t.draw()
 p.show()

Ausgabe auf der Konsole:

 Reaction Forces:  {'R_A_y': 4.20000000000000, 'R_D_x': 0, 'R_D_y': -2.20000000000000}
 Internal Forces:  {'AB': 2.80000000000000, 'BC': 0.333333333333333, 'CD': -1.46666666666667, 
 'AG': -5.04777178564958, 'GB': -2.05555555555556, 'GF': -1.23413387432364, 
 'BF': 0.411111111111111*sqrt(13), 'FC': -0.3*sqrt(13), 'CE': 1.50000000000000, 
 'FE': 0.284800124843917, 'DE': 2.64407093534026}

Zeichnung:

[[File:PythonIng_fachwerk1.svg|300px]]

Details zu diesem Thema siehe z.B. [https://docs.sympy.org/latest/modules/physics/continuum_mechanics/index.html Continuum Mechanics] oder [https://docs.sympy.org/latest/tutorials/physics/continuum_mechanics/index.html Continuum Mechanics Tutorials]. Auch andere mechanische Probleme werden von SymPy abgehandelt ([https://docs.sympy.org/latest/tutorials/physics/index.html Physics Tutorials]).

== Aufgabe ==
Gegeben sei ein einseitig eingespannter Kragträger. Belastet wird er durch eine Einzellast am Trägerende. Für die Daten siehe folgende ASCII-Skizze:

                            | 20 kN  
    //|---&gt; x               |
    //|                     V
    //|----------------------
    //|         10 m        |
 
 Elastizitätsmodul E = 2,1*10⁵ N/mm²
 Flächenträgheitsmoment I = 0.001 m⁴

Berechnen Sie die Auflagerreaktionen, den Querkraft- und Biegemomentenverlauf, sowie die Verformungen.
Stellen Sie dies mit Hilfe von SymPy graphisch und auch mittels Formeln dar. Verwenden Sie dazu auch pprint (pretty print) aus dem SymPy-Modul. Zwecks Lösungsansatz siehe die oben aufgeführte Seite &quot;Continuum Mechanics Tutorials&quot;. Achten Sie auch auf die Einheiten! Kontrollieren Sie das Ganze mittels händischer Rechnung. In dem genannten Tutorial ist von &quot;Singularity Functions&quot; die Rede. Gemeint ist damit in diesem Kontext die {{W|Föppl-Klammer}}.

Einige Python-Programme, vorrangig zu Maschinenelementen, finden sich auf [https://baymp.de/download_python.html BayMP für Python] (Balken, Zahnräder, Stabknickung usw.).

=Thermodynamik= 
== PYroMat ==
Für thermodynamische Aufgabenstellungen gibt es verschiedene externe Module. Eines davon ist PYroMat (siehe auch [http://pyromat.org]). Damit lassen sich thermodynamische Stoffdaten für viele Substanzen berechnen.

Beispiel (einige Stoffdaten für Wasser bei 400°C und 20 bar berechnen):

 import pyromat as pm
 
 # Wasserdaten laden:
 H2O = pm.get('mp.H2O')
 
 # Stoffdaten berechnen:
 T = 673.15  # Temperatur in Kelvin
 p = 20      # Druck in bar
 v = H2O.v(T, p)
 h = H2O.h(T, p)
 s = H2O.s(T, p)
 print(f&quot;Spezifisches Volumen: {v} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {h} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {s} kJ/(kg K)&quot;)

Ausgabe:

 Spezifisches Volumen: [0.1512163] m³/kg
 Spezifische Enthalpie: [3248.3789473] kJ/kg
 Spezifische Entropie: [7.12924142] kJ/(kg K)

&lt;small&gt;
PYroMat muss vorab installiert werden (z.B. mittels pip, in eine virtuelle Umgebung)
&lt;/small&gt;

&lt;code&gt;mp&lt;/code&gt; steht für &quot;multi phase&quot;. Für ein ideales Gas wäre &lt;code&gt;ig&lt;/code&gt; zuständig, z.B. &lt;code&gt;'ig.O2'&lt;/code&gt;.

Beispiel (T-s-Diagramm für Wasser zeichnen):
 import numpy as np
 import matplotlib.pyplot as plt
 import pyromat as pm
 
 # Konfigurieren
 pm.config[&quot;unit_pressure&quot;] = &quot;bar&quot;
 pm.config[&quot;unit_temperature&quot;] = &quot;K&quot;
 fluid = pm.get(&quot;mp.H2O&quot;)
 
 # Temperaturbereich für das Nassdampfgebiet
 T_tripel = 273.16
 T_crit = 647.096
 T = np.linspace(T_tripel, T_crit - 0.1, 200)
 
 # Sättigungslinien berechnen und zeichnen
 for x in np.linspace(0.0, 1.0, 5):
     s = fluid.s(T=T, x=x)
     if(x&lt;=0.0):
         plt.plot(s, T, label=&quot;Siedelinie x=%3.1f&quot; % x, linewidth=2.0)
     elif(x&gt;=1.0):
         plt.plot(s, T, label=&quot;Taulinie x=%3.1f&quot; % x, linewidth=2.0)
     else:
         plt.plot(s, T, label=&quot;x=%3.1f&quot; % x, linewidth=1.0)
 
 # Isobaren zeichnen
 p_values = [0.1, 1, 10, 50, 100]
 T_isobar = np.linspace(T_tripel, 1000, 200)
 t = 0.7
 
 for p in p_values:
     s_iso = fluid.s(T=T_isobar, p=p)
     plt.plot(s_iso, T_isobar, 'k-', alpha=0.8, linewidth=0.8)
 
     t += .05
     idx = int(len(s_iso) * t)
     plt.text(s_iso[idx], T_isobar[idx], f&quot;{p} bar&quot;, fontsize=9, alpha=0.8)
 
 # Diagramm zeichnen
 plt.title(&quot;T-s-Diagramm für Wasser&quot;)
 plt.xlabel(&quot;Spezifische Entropie s in kJ/kg K&quot;, fontsize=10)
 plt.ylabel(&quot;Temperatur T in K&quot;, fontsize=10)
 plt.legend(loc=&quot;best&quot;)
 plt.grid(True)
 plt.show()

Ausgabe (in etwa so):

[[Datei:T-s-Diagramm fuer Wasser.svg|400px]]

== CoolProp ==
Auch mit CoolProp können Stoffdaten berechnet werden. Siehe auch [https://coolprop.org/coolprop/wrappers/Python/index.html]

Beispiel (Wasser bei 20bar und 400°C):
 import CoolProp.CoolProp as CP
 
 fluid = 'Water'
 T = 673.15   # Temperatur in Kelvin
 P = 20e5     # Druck in Pascal
 
 dichte = CP.PropsSI('D', 'T', T, 'P', P, fluid)
 enthalpie = CP.PropsSI('H', 'T', T, 'P', P, fluid)
 entropie = CP.PropsSI('S', 'T', T, 'P', P, fluid)
 
 print(f&quot;Spez. Volumen: {1/dichte:.6f} m³/kg&quot;)
 print(f&quot;Spez. Enthalpie: {enthalpie:.2f} J/kg&quot;)
 print(f&quot;Spez. Entropie: {entropie:.2f} J/kgK&quot;)

Ausgabe:
 Spez. Volumen: 0.151215 m³/kg
 Spez. Enthalpie: 3248344.02 J/kg
 Spez. Entropie: 7129.16 J/kgK

== iapws ==
Um Werte für Wasser(dampf) zu erhalten (IAPWS; '''I'''nternational '''A'''ssociation for the '''P'''roperties of '''W'''ater and '''S'''team) gibt es die Bibliothek iapws. Siehe auch [https://iapws.org/] und [https://pypi.org/project/iapws/]

Beispiel (Wasser für 20bar und 400°C):
 from iapws import IAPWS97
 
 dampf = IAPWS97(P=2.0, T=673.15)
 
 print(f&quot;Spezifisches Volumen: {dampf.v:.6f} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {dampf.h:.2f} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {dampf.s:.4f} kJ/(kgK)&quot;)
 print(f&quot;Phase: {dampf.phase}&quot;)

Ausgabe:
 Spezifisches Volumen: 0.151208 m³/kg
 Spezifische Enthalpie: 3248.23 kJ/kg
 Spezifische Entropie: 7.1290 kJ/(kgK)
 Phase: Gas

== TESPy ==
Ein anderes Modul für einen anderen Aufgabenzweck ist TESPy ('''T'''hermal '''E'''ngineering '''S'''ystems in '''Py'''thon). Dieses Modul ist für die Anlagensimulation zuständig. Für nähere Informationen siehe [https://tespy.readthedocs.io/en/main/getting_started/introduction.html]. Als Beipiel sei hier vorerst Code, der von der Google KI generiert wurde, angeführt. Der Code wurde überarbeitet, damit keine Warnungen auftreten. Bitte aber den Code trotzdem mit Vorsicht genießen, auch KI-generierter Code kann Fehler aufweisen. Eine Pumpe wird berechnet:

 from tespy.components import Sink, Source, Pump
 from tespy.connections import Connection
 from tespy.networks import Network
 
 # 1. Netzwerk definieren (Zentrales Steuerungselement)
 # Wir wählen Wasser als Fluid und bar/Celsius als Einheiten
 nw = Network(fluids=[&quot;water&quot;])
 nw.units.set_defaults(pressure=&quot;bar&quot;, pressure_difference=&quot;bar&quot;, 
                       temperature=&quot;°C&quot;, enthalpy=&quot;kJ / kg&quot;)
 
 # 2. Komponenten erstellen
 eingang = Source(&quot;Wasserquelle&quot;)
 ausgang = Sink(&quot;Wasserspeicher&quot;)
 pumpe = Pump(&quot;Speisewasserpumpe&quot;)
 
 # 3. Verbindungen definieren (Komponenten miteinander verknüpfen)
 c1 = Connection(eingang, &quot;out1&quot;, pumpe, &quot;in1&quot;)
 c2 = Connection(pumpe, &quot;out1&quot;, ausgang, &quot;in1&quot;)
 
 # Verbindungen dem Netzwerk hinzufügen
 nw.add_conns(c1, c2)
 
 # 4. Randbedingungen und Parameter festlegen
 # Zustand am Eingang (Druck, Temperatur, Massenstrom, Fluid-Zusammensetzung)
 c1.set_attr(
     v=1,  # Massenstrom: 1 kg/s
     T=20,  # Temperatur: 20 °C
     p=1,  # Druck: 1 bar
     fluid={&quot;water&quot;: 1},  # 100% Wasser
 )
 
 # Zustand am Ausgang / Zielwerte der Pumpe
 c2.set_attr(p=10)  # Ziel-Druck nach der Pumpe: 10 bar
 
 # Pumpeneigenschaften festlegen
 pumpe.set_attr(eta_s=0.8)  # Isentroper Wirkungsgrad von 80%
 
 # 5. Simulation ausführen
 nw.solve(mode=&quot;design&quot;)
 
 # 6. Ergebnisse ausgeben
 nw.print_results()
 
 # Spezifische Werte direkt auslesen
 print(&quot;\n--- Auswertung ---&quot;)
 print(f&quot;Erforderliche Pumpenleistung: {pumpe.P.val / 1000:.2f} kW&quot;)
 print(f&quot;Temperatur nach der Pumpe: {c2.T.val:.2f} °C&quot;)

Ausgabe (gekürzt):
  iter  | residual   | progress   | massflow   | pressure   | enthalpy   | fluid      | component  
 -------+------------+------------+------------+------------+------------+------------+------------
  1     | 7.04e+04   | 12 %       | 9.96e+02   | 0.00e+00   | 8.81e+04   | 0.00e+00   | 0.00e+00   
  2     | 5.91e-12   | 100 %      | 1.11e-13   | 0.00e+00   | 7.39e-12   | 0.00e+00   | 0.00e+00   
  3     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
  4     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
 Total iterations: 4, Calculation time: 0.01 s, Iterations per second: 480.85
 
 ##### RESULTS (Pump) #####
 +-------------------+----------+----------+-----------+----------+----------+----------+
 |                   |        P |       pr |        dp |      eta |    eta_s |     head |
 |-------------------+----------+----------+-----------+----------+----------+----------|
 | Speisewasserpumpe | 1.12e+06 | 1.00e+01 | -9.00e+00 | 8.00e-01 | 8.00e-01 | 9.19e+01 |
 +-------------------+----------+----------+-----------+----------+----------+----------+
 ...
 ...
 --- Auswertung ---
 Erforderliche Pumpenleistung: 1124.77 kW
 Temperatur nach der Pumpe: 20.07 °C

= Stochastik =
Die {{W|Stochastik}} ist ein sehr weites Feld. Hier werden etliche wichtige Themen kurz angerissen. Python stellt mit den Moduln math und statistics Software zu diesem Zwecke bereit. math und statistics sind bereits im Lieferumfang von Python enthalten. Aber auch mit den externen Modulen NumPy, SciPy, stochastic und pandas kann man Stochastik in Python betreiben. Die Theorie der Wahrscheinlichkeitsrechnung und Statistik soll etwas später in Band 5 dieser Buchreihe behandelt werden.

== Lageparameter == 
 import statistics
 
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 
 m1 = statistics.mean(werte)
 m2 = statistics.mode(werte)
 m3 = statistics.median(werte)
 
 print(&quot;Arithmetischer Mittelwert = &quot;, m1)
 print(&quot;Modalwert = &quot;, m2)
 print(&quot;Median = &quot;, m3)

Ausgabe:
 Arithmetischer Mittelwert =  3.5
 Modalwert =  1
 Median =  3.0

== Streuungsparameter ==
Beispiel (Berechnung der Standardabweichung):
 import statistics
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 s = statistics.stdev(werte)
 print(&quot;Standardabweichung = &quot;, s)

Ausgabe:
 Standardabweichung =  2.6770630673681683

Beispiel (Berechnung des Variationskoeffizienten V = Standardabweichung/Mittelwert)
 import numpy as np
 from scipy import stats
 import statistics
 
 k = 50
 
 dat1 = [14, 21, 18, 25, 30, 17, 20]
 dat = np.array(dat1)
 
 # Mit SciPy
 v = stats.variation(dat)
 vddof = stats.variation(dat, ddof=1)
 print(&quot;V SciPy: &quot;, v)
 print(&quot;V DDOF SciPy: &quot;, vddof)
 print(k*&quot;-&quot;)
 
 # mit NumPy
 mittelwert1 = np.mean(dat)
 std_abw1 = np.std(dat)
 std_abw1ddof = np.std(dat, ddof=1) 
 v1= std_abw1 / mittelwert1
 v1ddof = std_abw1ddof / mittelwert1
 print(&quot;Mittelwert NumPy: &quot;, mittelwert1)
 print(&quot;Std.abw. NumPy: &quot;, std_abw1)
 print(&quot;Std.abw. DDOF NumPy: &quot;, std_abw1ddof)
 print(&quot;V NumPy: &quot;, v1)
 print(&quot;V DDOF NumPy: &quot;, v1ddof)
 print(k*&quot;-&quot;)
 
 # nur mit reinem Python
 mittelwert2 = statistics.mean(dat1)
 std_abw2 = statistics.stdev(dat1)
 v2 = std_abw2 / mittelwert2
 print(&quot;Mittelwert Python: &quot;, mittelwert2)
 print(&quot;Std.abw. Python: &quot;, std_abw2)
 print(&quot;V Python:&quot;, v2)
 print(k*&quot;-&quot;)

Ausgabe:
 V SciPy:  0.23890355966467272
 V DDOF SciPy:  0.25804533701889254
 --------------------------------------------------
 Mittelwert NumPy:  20.714285714285715
 Std.abw. NumPy:  4.948716593053935
 Std.abw. DDOF NumPy:  5.3452248382484875
 V NumPy:  0.23890355966467272
 V DDOF NumPy:  0.2580453370188925
 --------------------------------------------------
 Mittelwert Python:  20.714285714285715
 Std.abw. Python:  5.3452248382484875
 V Python: 0.2580453370188925
 --------------------------------------------------

Der Unterschied bei der Standardabweichung zwischen reinem Python und den externen Bibliotheken SciPy und NumPy entsteht dadurch, dass einmal durch (n-1) und das andere Mal nur durch n dividiert wird. Dies kann bei NumPy und SciPy dadurch entschärft werden, indem &lt;code&gt;ddof=1&lt;/code&gt; gesetzt wird. ddof steht für '''D'''elta '''D'''egrees '''o'''f '''F'''reedom. &lt;small&gt;Je größer die Anzahl der Datensätze n wird, umso weniger spielt das eine Rolle.&lt;/small&gt;

== Kombinatorik ==
Beispiel:

 import math
 
 n = 7
 k = 5
 
 print(&quot;n! = &quot;, math.factorial(n))
 print(&quot;Kombinationen (n über k) = &quot;, math.comb(n, k))

Ausgabe:
 n! =  5040
 Kombinationen (n über k) =  21

Siehe zu diesem Thema auch [[Ing Mathematik: Permutationen, Kombinationen, binomischer Lehrsatz]]. Die Anzahlen lassen sich einfach aus den dortigen Formeln ermitteln, z.B. bei Permutationen mit &lt;math&gt;n!&lt;/math&gt; oder Variationen mit Wiederholungen als &lt;math&gt;n^k&lt;/math&gt;. Will man die Kombinationen oder Variationen aber auch als Liste ausgeben, so kann das Modul &lt;code&gt;itertools&lt;/code&gt; nützlich sein.  

Beispiel (Variationen ohne Wiederholung):

 from itertools import permutations
 
 menge = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]  # n = 4
 k = 3
 
 variationen = list(permutations(menge, k))
 
 for v in variationen:
     print(&quot;&quot;.join(v))
 
 print(50*&quot;-&quot;)
 print(len(variationen))

Ausgabe (gekürzt):
 ABC
 ABD
 ACB
 ...
 DCA
 DCB
 --------------------------------------------------
 24

Siehe zum Modul &lt;code&gt;itertools&lt;/code&gt; auch die Website [https://docs.python.org/3/library/itertools.html].

* Variationen mit Wiederholung: &lt;code&gt;itertools.product()&lt;/code&gt;
* Kombinationen ohne Wiederholung: &lt;code&gt;itertools.combinations()&lt;/code&gt;
* Kombinationen mit Wiederholung: &lt;code&gt;itertools.combinations_with_replacement()&lt;/code&gt;

== Zufallszahlen ==
Beispiel:
 import random
 
 # Ganzzahlige Zufallszahl von 1 bis 10
 zufallszahl1 = random.randint(1, 10)
 
 # Gleitpunktzahlen
 # zwischen 0.0 und 1.0
 zufallszahl2 = random.random()
 # Zahl zwischen 1.5 und 9.5
 zufallszahl3 = random.uniform(1.5, 9.5)
 
 # aus Liste auswählen
 farbe = [&quot;Rot&quot;, &quot;Grün&quot;, &quot;Blau&quot;]
 zufallswert = random.choice(farbe)
 
 print(zufallszahl1)
 print(zufallszahl2)
 print(zufallszahl3)
 print(zufallswert)

Ausgabe, z.B.:
 5
 0.14147945849015753
 6.894003397570905
 Rot

Benötigt man mehrere Zufallszahlen, so ist das Modul &lt;code&gt;numpy&lt;/code&gt; zu bevorzugen, z.B.:
* Normalverteilung: &lt;code&gt;np.random.normal(...)&lt;/code&gt;
* Gleichverteilung: &lt;code&gt;np.random.uniform(...)&lt;/code&gt;

== Histogramm ==
Zum Thema Histogramm siehe {{W|Histogramm}}.

Beispiel (mit Matplotlib):

 import matplotlib.pyplot as plt
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 
 plt.hist(daten, bins=25, edgecolor='darkgray')
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm.svg|300px]]

Beispiel (mit Seaborn):

 import matplotlib.pyplot as plt
 import seaborn as sns
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 sns.set_theme(style=&quot;darkgrid&quot;)
 sns.histplot(data=daten)
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm2.svg|300px]]

Das Kürzel &lt;code&gt;sns&lt;/code&gt; ist Konvention und steht für die fiktive Figur '''S'''amuel '''N'''orman '''S'''eaborn aus der US-Fernsehserie {{W|The West Wing – Im Zentrum der Macht | The West Wing}}.

== Box-Plot ==
[[File:Elements of a boxplot.svg|400px]]

Siehe auch {{W|Box-Plot}}.

Beispiel (mit Seaborn erstellt):
 import seaborn as sns
 import matplotlib.pyplot as plt
 
 df = sns.load_dataset(&quot;tips&quot;)
 sns.boxplot(data=df, x=&quot;day&quot;, y=&quot;tip&quot;, hue=&quot;day&quot;, legend=False)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot.svg|400px]]

Beispiel (mit Matplotlib erstellt):

 import matplotlib.pyplot as plt
 
 daten = [12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25]
 
 plt.boxplot(daten, patch_artist=True)
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot2.svg|300px]]

Um mehrere Box-Plots unterschiedlicher Farbe mit Matplotlib in einem Diagramm zu zeichnen, können Sie folgendermaßen vorgehen:

 import matplotlib.pyplot as plt
 
 daten = [[12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25],
          [10, 19, 20, 21, 20, 30, 19, 40, 11, 17, 19, 21]]
 
 farben = [&quot;green&quot;, &quot;blue&quot;]
 
 boxplot = plt.boxplot(daten, patch_artist=True)
 
 for patch, farbe in zip(boxplot['boxes'], farben):
     patch.set_facecolor(farbe)
 
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

== Regressionsrechnung ==
Beispiel:
 import numpy as np
 import matplotlib.pyplot as plt
 
 # Messpunkte
 x = np.array([1, 3, 5, 6, 8, 10, 20])
 y = np.array([3, 4, 5, 5, 7, 9, 11])
 
 # Regressionskurve (Grad 1 = lineare Regression, 2 = Polynom-Regression 2. Gr.)
 # y = kx + d
 k, d = np.polyfit(x, y, deg=1)
 # y = ax**2 + bx + c
 a, b, c = np.polyfit(x, y, deg=2)
 
 x_l = np.linspace(1, 20, 100)
 y_p = a * x_l**2 + b * x_l + c
 
 # Zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.plot(x, k*x + d, color='blue', label='Regressionsgerade')
 plt.plot(x_l, y_p, color='red', label='Regressionspolynom 2. Gr.')
 plt.xlabel('x')
 plt.ylabel('y')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_regression.svg|400px]]

== Korrelationsrechnung ==
Beispiel:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 # Messdaten
 x = [1, 3, 4, 5, 6]
 y = [2, 4, 6, 8, 5]
 
 daten = {'X': x, 'Y': y}
 df = pd.DataFrame(daten)
 
 # Korrelation
 korr = df['X'].corr(df['Y'])
 print(f&quot;Korrelationskoeff.: {korr}&quot;) 
 
 # Messpunkte zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:
 Korrelationskoeff.: 0.7556096518348252

[[Datei:IngMath_korrelation.svg|300px]]

== Mengen und Venn-Diagramme ==
Beispiel: 
 import matplotlib.pyplot as plt
 from matplotlib_venn import venn2
 
 menge_a = {1, 2, 3, 4, 5, 6}
 menge_b = {4, 5, 6, 7, 8}
 
 vereinigung = menge_a | menge_b
 schnitt = menge_a &amp; menge_b
 print(&quot;Vereinigungsmenge = &quot;, vereinigung)
 print(&quot;Schnittmenge = &quot;, schnitt)
 
 venn2([menge_a, menge_b], set_labels=('Menge A', 'Menge B'))
 plt.show()

Ausgabe:
 Vereinigungsmenge =  {1, 2, 3, 4, 5, 6, 7, 8}
 Schnittmenge =  {4, 5, 6}

[[Datei:IngMath_venn.svg|300px]]

Siehe auch {{W|Mengendiagramm#Venn-Diagramme}}.

== Verteilungs- und Dichtefunktion ==
* CDF ... '''C'''umulative '''D'''istribution '''F'''unction, Verteilungsfunktion
* PDF ... '''P'''robability '''D'''ensity '''F'''unction, Dichtefunktion

Beispiel (Normalverteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 from scipy.stats import norm
 
 my, sigma = 0, 1
 x = np.linspace(-4, 4, 50)
 
 pdf = norm.pdf(x, my, sigma)
 cdf = norm.cdf(x, my, sigma)
 
 plt.plot(x, pdf, lw=2, label=&quot;Dichtefunktion&quot;)
 plt.plot(x, cdf, lw=2, label=&quot;Verteilungsfunktion&quot;)
 plt.legend()
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:IngMath_cdf_pdf.svg|300px]]

Beispiel (&lt;math&gt;\chi^2&lt;/math&gt;-Verteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 import scipy.stats as stats
 
 x = np.linspace(0, 20, 500)
 
 # df ... degree of freedom, Freiheitsgrad
 pdf = (stats.chi2.pdf(x, df=2), stats.chi2.pdf(x, df=5), stats.chi2.pdf(x, df=10))
 
 for i in range(0,3):
     if(i==0):
         lab = &quot;Freiheitsgrad 2&quot;
     elif(i==1):
         lab = &quot;Freiheitsgrad 5&quot;
     else:
         lab = &quot;Freiheitsgrad 10&quot;
 
     plt.plot(x, pdf[i], label=lab, lw=2)
 
 plt.grid()
 plt.legend()
 plt.show()

Ausgabe:

[[Datei:IngMath_chi2.svg | 300px]]

== Schätzen und Testen ==
=== Intervallschätzung ===
Als Beispiel seien Daten gegeben, die von ''Dürr, Mayer: Wahrscheinlichkeitsrechnung und Schließende Statistik; 7. Aufl., Hanser, 2014, Seite 137'' stammen. Und zwar soll das 95%-Vertrauensintervall für den Mittelwert des Kaloriengehalts (kcal/100g) von Hähnchen ermittelt werden. Wir wollen das mit Python inkl. NumPy und SciPy durchführen. Die Stichprobe ist groß (50 Hähnchen):

Python-Code:
 import numpy as np
 import scipy.stats as stats
 
 # Stichprobe
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203]
 
 # Parameter definieren
 konfidenzniveau = 0.95
 mean = np.mean(daten)
 std = np.std(daten, ddof=1)
 stdfehler = stats.sem(daten)
 
 intervall = stats.norm.interval(confidence=konfidenzniveau, loc=mean, scale=stdfehler)
 
 print(f&quot;Mittelwert: {mean}&quot;)
 print(f&quot;Standardabweichung: {std}&quot;)
 print(f&quot;Konfidenzintervall: {intervall}&quot;)

Ausgabe:
 Mittelwert: 215.48
 Standardabweichung: 33.14238915925757
 Konfidenzintervall: (np.float64(206.29356722321992), np.float64(224.66643277678006))

Diese Werte stimmen gerundet mit denen im genannten Buch überein. Zum Code selbst:
* sem steht für '''s'''tandard '''e'''rror of the '''m'''ean.
* &lt;code&gt;scipy.stats.norm&lt;/code&gt; ... Modul für die Normalverteilung.

=== Punktschätzung ===
Gleiche Daten wie oben bei der Intervallschätzung.

Python-Code:
 import numpy as np
 from scipy import stats
 
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203
         ]
 
 mu_hat, sigma_hat = stats.norm.fit(daten) 
 
 print(f&quot;Schätzer für den Erwartungswert (μ): {mu_hat:.4f}&quot;)
 print(f&quot;Schätzer für die Standardabweichung (σ): {sigma_hat:.4f}&quot;)

Ausgabe:
 Schätzer für den Erwartungswert (μ): 215.4800
 Schätzer für die Standardabweichung (σ): 32.8093

=== Hypothesentests ===
Beispiel:

 import numpy as np
 import scipy.stats as stats
 
 x_quer = 12.075      # Stichproben-Mittelwert
 var    = 0.069       # Stichproben-Varianz
 n      = 90          # Stichprobengröße
 my_0   = 12.0        # Nullhypothese
 alpha  = 0.05        # Signifikanzniveau
 
 z_stat = (x_quer - my_0) / np.sqrt(var / n)
 p_val = 2 * (1 - stats.norm.cdf(np.abs(z_stat)))
 
 print(f&quot;Z-Statistik: {z_stat:.4f}&quot;)
 
 if p_val &lt; alpha:
     print(f&quot;p-Wert: {p_val:.6f} &lt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird verworfen.&quot;)
 else:
     print(f&quot;p-Wert: {p_val:.6f} &gt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird nicht verworfen.&quot;)

Ausgabe:

 Z-Statistik: 2.7087
 p-Wert: 0.006755 &lt; alpha: 0.05
 Die Nullhypothese wird verworfen.

== Statistische Qualitätskontrolle ==
Beispiel (Mittelwertkarte):

 import numpy as np
 import matplotlib.pyplot as plt
 
 # Gegeben
 sollwert = 50.0
 varianz = 4.0
 stichproben_umfang = 1
 daten = [49.5, 50.2, 53.0, 48.1, 52.6, 53.4, 49.8]
 
 # Berechnung
 standardabweichung = np.sqrt(varianz)
 streuung = standardabweichung / np.sqrt(stichproben_umfang)
 
 cl = sollwert
 ucl = cl + 3 * streuung
 lcl = cl - 3 * streuung
 
 # Darstellung
 plt.plot(daten, marker='o', linestyle='-', color='b', label='Messdaten')
 plt.axhline(cl, color='green', linestyle='-', label=f'CL: {cl}')
 plt.axhline(ucl, color='red', linestyle='--', label=f'UCL: {ucl:.2f}')
 plt.axhline(lcl, color='red', linestyle='--', label=f'LCL: {lcl:.2f}')
 
 plt.title('Mittelwertkarte')
 plt.xlabel('Stichprobe')
 plt.ylabel('Wert')
 plt.legend(loc='lower left')
 plt.grid(True)
 plt.show()

Ausgabe:

[[Datei:IngMath_mittelwertkarte.svg|300px]]

Siehe auch {{W|Shewhart-Regelkarte}} und {{W|Qualitätsregelkarte}}.

* UCL ... '''U'''pper '''C'''ontrol '''Limit''', Obere Eingriffsgrenze
* LCL ... '''L'''ower '''C'''ontrol '''Limit''', Untere Eingriffsgrenze
* CL ... '''C'''enter '''L'''ine, Mittellinie

= Ein- und Ausgabe =
== print ==
Die Anweisung print haben wir schon oft verwendet. Hier soll anhand von Beispielen kurz beschrieben werden, was der Befehl print leisten kann.

 print(&quot;Hallo&quot;, &quot;Welt&quot;, 1, sep=&quot;-&quot;)
 print(&quot;Hallo&quot;, end=&quot; &quot;)
 print(&quot;Welt&quot;)

Ausgabe:
 Hallo-Welt-1
 Hallo Welt

== input ==
 a = int(input(&quot;Zahl 1: &quot;))
 b = int(input(&quot;Zahl 2: &quot;))
 
 print(&quot;a + b = &quot;, a+b)

Ausgabe (nach Eingabe der beiden Ganzzahlen):
 Zahl 1: 4
 Zahl 2: 5
 a + b =  9

== Aus Dateien lesen ==
Es seinen die datei.txt
 Hallo Welt.
 Wie geht es dir?
 ...

und test1.py
 dat = open(&quot;datei.txt&quot;, mode = &quot;r&quot;)
 print(dat.read())
 dat.close()

Ausgabe
 Hallo Welt.
 Wie geht es dir?
 ...

Mit dem open()-Befehl wird die Datei datei.txt im Lesemodus geöffnet (r ... read). Mit dem read()-Befehl wird die Datei eingelesen und mittels print ausgegeben.

== In Dateien schreiben ==
 dat = open(&quot;datei.txt&quot;, mode = &quot;a&quot;, encoding = &quot;utf-8&quot;)
 dat.write(&quot;Hänge Zeile an\n&quot;)
 dat.close()

Die Datei datei.txt sieht nach Abarbeitung des obigen Skripts nun so aus
 Hallo Welt.
 Wie geht es dir?
 ...
 Hänge Zeile an

Es wird die Datei im Schreibmodus geöffnet (a ... append (anhängend), w ... write (überschreibend)).
write() fügt hier also eine Zeile Text am Dateiende ein. close() schließt die Datei wieder.

Das close() kann man sich mit der with-Anweisung auch sparen.

 with open(&quot;datei.txt&quot;, mode=&quot;a&quot;, encoding=&quot;utf-8&quot;) as dat:
     dat.write(&quot;Hänge Zeile an\n&quot;)

= Benutzeroberflächen erstellen =
== tkinter ==
{{Wikipedia | Tkinter}}

Python bietet standardmäßig das Modul tkinter zur Programmierung von Benutzeroberflächen. Es müssen also bei der Verwendung von tkinter keine externen Module installiert werden. Hier wird eine (sehr) kurze Einführung in das Erstellen von grafischen Oberflächen mittels tkinter gegeben.

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 win.minsize(300, 50)
 but = tk.Button(win, text = &quot;Push the button&quot;)
 but.pack()
 win.mainloop()

Ausgabe:

[[Datei:PythonIng_gui1.jpg]]

Ein etwas komplizierteres Beispiel sei nachfolgend gezeigt. Es sollen zwei Strings miteinander verknüpft und ausgegeben werden. 

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 
 def on_button_clicked():
     str = ent1.get() + ent2.get()
     lab2[&quot;text&quot;] = str
  
 ent1 = tk.Entry(win)
 ent2 = tk.Entry(win)
 lab1 = tk.Label(win, text=&quot;verknuepfen mit&quot;)
 lab2 = tk.Label(win, text=&quot;&quot;) 
 but = tk.Button(win, text = &quot;=&quot;, command=on_button_clicked)
 
 ent1.pack(side=&quot;left&quot;)
 lab1.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 but.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 lab2.pack(side=&quot;left&quot;)
 
 win.mainloop()

Ausgabe  (vor der Eingabe der Teilstrings): 

[[Datei:PythonIng_gui2.jpg]]

Ausgabe (nach der Eingabe der Teilstrings und dem Drücken des =-Buttons): 

[[Datei:PythonIng_gui3.jpg]]

== curses ==
{{Wikipedia | curses}}

Mit dem curses-Modul lassen sich u.a. TUIs ('''T'''ext '''U'''ser '''I'''nterfaces) erstellen. Ein sehr einfaches Beispiel zur allgemeinen Funktionsweise wird nachstehend geliefert.
 
 import curses
 
 stdscr = curses.initscr()
 curses.start_color()
 curses.init_pair(1, curses.COLOR_RED, curses.COLOR_WHITE)
 stdscr.clear()
 
 stdscr.addstr(&quot;Hallo Welt&quot;, curses.color_pair(1))
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()
 
Als Ausgabe sollte &lt;span style=&quot;color:#FF0000;&quot;&gt;Hallo Welt&lt;/span&gt; (rote Schrift auf weißem Hintergrund) auf dem Terminal/der Konsole erscheinen. Getestet wurde dies mit openSUSE Tumbleweed, Python-Version 3.13.12. Das entsprechende Python-curses-Package muss installiert sein.

Allgemeine Informationen zur Terminal-/Konsolengröße und Cursorposition liefert folgendes Programm:
 
 import curses
 
 stdscr = curses.initscr()
 
 stdscr.addstr(3, 5, &quot;LINES: %d&quot; % curses.LINES)
 stdscr.addstr(4, 5, &quot;COLS:  %d&quot; % curses.COLS)
 
 (y,x) = stdscr.getyx()
 stdscr.addstr(5, 5, &quot;Momentane Cursorposition:  [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getbegyx()
 stdscr.addstr(6, 5, &quot;Koordinatenursprung:       [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getmaxyx()
 stdscr.addstr(7, 5, &quot;Fenstergröße:              [%d, %d]&quot; % (y, x))
 
 stdscr.addstr(11, 2, &quot;Taste drücken -&gt; Ende&quot;)
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()

Es sollte sich in etwa folgende Ausgabe ergeben:

     LINES: 44
     COLS:  110
     Momentane Cursorposition:  [4, 15]
     Koordinatenursprung:       [0, 0]
     Fenstergröße:              [44, 110]
 
 
 Taste drücken -&gt; Ende

Zur Funktionsweise von curses siehe auch das Wikibook [[ncurses]]. Zum Verständnis sind dort allerdings elementare Kenntnisse in der Programmiersprache C erforderlich.

== Qt ==
{{Wikipedia | Qt (Bibliothek)}}

Auch für das Qt-Framework gibt es eine Anbindung an Python. Nachfolgend ein einfaches Beispiel.

 import sys
 from PySide6.QtWidgets import QApplication, QLabel
 
 app = QApplication(sys.argv)
 label = QLabel(&quot;Hallo Welt!&quot;)
 label.show()
 sys.exit(app.exec())

Ausgabe:

[[Datei:PythonIng_gui10.png]]

== Gtk ==
{{Wikipedia | GTK (Programmbibliothek)}}

Eine idente Ausgabe, wie oben für Qt gezeigt, erzeugt z.B. folgendes Gtk-Programm:

 import gi
 gi.require_version(&quot;Gtk&quot;, &quot;4.0&quot;)
 from gi.repository import Gtk
 
 def on_activate(app):
     win = Gtk.ApplicationWindow(application=app)
     lab = Gtk.Label(label=&quot;Hallo Welt!&quot;)
     win.set_child(lab)
     win.present()
 
 app = Gtk.Application()
 app.connect('activate', on_activate)
 app.run(None)

Auch für die Benutzung von Qt und Gtk müssen die jeweiligen Packages installiert sein. Getestet wurden die entsprechenden Python-Programme nur unter openSUSE Tumbleweed. Wie das GTK-Paket unter MS Windows 11 installiert wird, siehe z.B. [https://www.gtk.org/docs/installations/windows Setting up GTK for Windows].

Damit sei aber das Thema &quot;Benutzeroberflächen erstellen&quot; hier abgeschlossen, da dies schon ein sehr spezielles Aufgabengebiet ist, das eher Informatiker und nicht so sehr Ingenieure anspricht. Bei Bedarf siehe aber ggf. die entsprechenden Links unten in diesem Tutorial. Dort sind weiterführende Informationen zu finden.

= Pandas kurz erklärt =
Hier wird kurz auf das externe Modul Pandas eingegangen. Pandas steht für '''Pan'''el '''Da'''ta und ist ein Modul für die Datenanalyse und -manipulation.

== Series ==
Vorstellbar ist eine &quot;Series&quot; wie eine einzelne Spalte in einem Tabellenkalkulationsprogramm.

Beispiel (Index implizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5]) # Temperaturwerte
 print(temp)

Ausgabe:
 0     8.5
 1    11.0
 2    12.5
 3    10.0
 4    13.0
 5    11.0
 6    14.5
 dtype: float64

Das Kürzel &lt;code&gt;pd&lt;/code&gt; ist Konvention. Es seien Temperaturwerte gegeben. Die erste Spalte bei der Ausgabe ist der Index. Die zweite Spalte enthält die Werte.

Beispiel (separater Zugriff auf den Index und auf die Werte):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5])
 print(temp.index)
 print(temp.values)

Ausgabe:
 RangeIndex(start=0, stop=7, step=1)
 [ 8.5 11.  12.5 10.  13.  11.  14.5]

Beispiel (Index explizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 print(&quot;*** Die gesamte Series ***&quot;)
 print(temp)
 
 print(&quot;*** Temperatur am Donnerstag ***&quot;)
 print(temp[&quot;Do&quot;])
 
 print(&quot;*** Tage wärmer als 12 Grad ***&quot;)
 temp_gr_12 = temp[temp &gt; 12]
 print(temp_gr_12)

Ausgabe:
 *** Die gesamte Series ***
 Mo     8.5
 Di    11.0
 Mi    12.5
 Do    10.0
 Fr    13.0
 Sa    11.0
 So    14.5
 dtype: float64
 *** Temperatur am Donnerstag ***
 10.0
 *** Tage wärmer als 12 Grad ***
 Mi    12.5
 Fr    13.0
 So    14.5
 dtype: float64

== DataFrame ==
Ein DataFrame entspricht einer Tabelle.

Beispiel (Erzeugen eines DataFrames):
 import pandas as pd
 
 tag   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 v1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=tag)
 v2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=tag)
 v3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=tag)
 
 tab = pd.concat([v1, v2, v3], axis=1)
 tab.columns = stadt
 
 print(tab)
 print(type(tab))

Ausgabe:
     Linz  Salzburg Innsbruck
 Mo     1         8     Hallo
 Di     2         9        16
 Mi     3        10        17
 Do     4        11        18
 Fr     5        12        19
 Sa     6        13        20
 So     7        14        21
 &lt;class 'pandas.core.frame.DataFrame'&gt;

Wir haben hier drei Datenspalten (v1, v2, v3) mit den Spaltennamen &quot;Linz&quot;, &quot;Salzburg&quot; und &quot;Innsbruck&quot;, sowie sieben Zeilen &quot;Mo&quot; bis &quot;So&quot;.

Beispiel (Zugriff auf eine Spalte):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab[&quot;Salzburg&quot;])

Ausgabe:
 Mo     8
 Di     9
 Mi    10
 Do    11
 Fr    12
 Sa    13
 So    14
 Name: Salzburg, dtype: int64

Beispiel (Zugriff auf eine Zeile):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab.loc[&quot;Di&quot;])

Ausgabe:
 Linz          2
 Salzburg      9
 Innsbruck    16
 Name: Di, dtype: object

== Grafiken erstellen ==
Hier sei nur ein Torten- oder Kreisdiagramm gezeichnet:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 expl = [0, 0.2, 0, 0, 0, 0, 0]
 temp.plot.pie(figsize=(5,5), explode=expl)
 plt.show()

Ausgabe:

[[Datei:IngPython_pandas1.svg|350px]]

Die &lt;code&gt;figsize&lt;/code&gt; hat nichts mit der Spaltenanzahl zu tun, sondern setzt die Fenster- oder Diagrammgröße in Inches (Breite * Höhe).
 
Mit Pandas kann man auch noch andere Diagrammarten erstellen, z.B. Linien- oder Balkendiagramme. Dies wird hier aber nicht vorgeführt.

== Arbeiten mit CSV- und LibreOffice-Dateien ==
Gegeben sei eine CSV-Datei test1.csv:
 Mai;Juni;Juli
 12;17;45
 15;65;65
 16;32;23
 4;14;7
 23;17;Keine Daten verfügbar
 67;Keine Daten verfügbar;45
 15;24;12

Lesen von dieser CSV-Datei:
 import pandas as pd
 
 tab = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 print(tab)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Schreiben in eine CSV-Datei test2.csv:
 import pandas as pd
 
 val = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 val.to_csv(&quot;test2.csv&quot;, index=False)

Ausgabedatei:
 Mai,Juni,Juli
 12,17,45
 15,65,65
 16,32,23
 4,14,7
 23,17,Keine Daten verfügbar
 67,Keine Daten verfügbar,45
 15,24,12

Die Ausgabedatei ist beinahe gleich wie die Eingabedatei. Es werden aber Kommas statt Strichpunkten verwendet. Daher kommt auch der Name CSV ('''C'''omma '''S'''eparated '''V'''alue). Will man wieder Strichpunkte, so kann man dies über den Parameter &lt;code&gt;sep=&quot;;&quot;&lt;/code&gt; in der &lt;code&gt;to_csv&lt;/code&gt;-Funktion machen.

Um direkt von einer ODS-Datei (LibreOffice Calc, '''O'''pen '''D'''ocument '''S'''preadsheet) zu lesen muss das Modul odfpy extra installiert sein (per YaST, pip etc.). Gelesen wird dann folgendermaßen:
 import pandas as pd
 
 df = pd.read_excel('test1.ods', engine='odf')
 print(df)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Die Datei &quot;test1.ods&quot; sei die Datei, aus der das obige &quot;test1.csv&quot; generiert wurde. Schreiben kann man ebenfalls in eine ODS-Datei:

 import pandas as pd
 
 daten = {
     &quot;Name&quot;: [&quot;Hugo&quot;, &quot;Richie&quot;, &quot;Wilhelmine&quot;],
     &quot;Alter&quot;: [38, 30, 29],
     &quot;Ort&quot;: [&quot;Linz&quot;, &quot;Innsbruck&quot;, &quot;Salzburg&quot;]
 }
 
 tab = pd.DataFrame(daten)
 
 with pd.ExcelWriter(&quot;test2.ods&quot;, engine=&quot;odf&quot;) as writer:
     tab.to_excel(writer, sheet_name=&quot;Daten&quot;, index=False)

Es ergibt sich eine &quot;test2.ods&quot;-Datei (Screenshot):

[[Datei:IngPython_pandas2.png|250px]]

== Sonstiges ==
Hier seien stichpunktartig einige weitere Features von Pandas angeführt:
* {{W|Pivot-Tabelle|Pivot-Tabellen}} (pivot ... Dreh-, Angelpunkt): Zweck - große Datenmengen schnell zusammenfassen, filtern und analysieren.
* NaN ('''n'''ot '''a''' '''n'''umber): In einem Datensatz fehlt ein Wert oder ist nicht definiert.
* groupby-Funktion: Daten strukturieren, aggregieren oder Zwischensummen bilden. 
* {{W|Binning#Datenverarbeitung_und_-analyse|Binning}}: Klassenbildung.
* Mehrstufige Indizierung (Hierarchical Indexing oder MultiIndex).
* Zeitreihen (Time Series).
* MS Excel-Dateien schreiben mit dem Modul openpyxl.

Für tiefergehende und weiterführende Informationen wird auf das Buch von ''Klein: Numerisches Python; Hanser, 2023'' und [https://pandas.pydata.org/ pandas] verwiesen.

= Style Guide, flake8, pylint, Black etc. =
== Style Guide ==
Wie man schönen und richtigen Python-Code schreibt, erfahren Sie in
* [https://peps.python.org/pep-0008/ PEP 8 – Style Guide for Python Code]

== Formatter und Linter ==
Ein Modul, das prüft, ob die Richtlinien im Style Guide eingehalten wurden, ist ''flake8'':
* [https://flake8.pycqa.org/en/latest/ Flake8: Your Tool For Style Guide Enforcement]

Code formatieren kann man auch mit [https://pypi.org/project/black/ Black]. Z.B. übersetzt &lt;code&gt;black test1.py&lt;/code&gt; die Datei &lt;code&gt;test1.py&lt;/code&gt;

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)),
     (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

in 

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)), (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Die Programmausgabe ist 

 reformatted test1.py
 
 All done! ✨ 🍰 ✨
 1 file reformatted.

Der Unterschied zwischen Black und Flake8:
* Black ist ein Code-Formatter. Er formatiert Ihren Code um, sodass er im Einklang mit PEP 8 steht.
* Flake8 ist ein {{W|Lint (Programmierwerkzeug) | Code-Linter}}. Flake8 verändert Ihren Code nicht, sondern durchsucht ihn nach potenziellen Fehlern etc.

Am obigen Beispiel sieht man auch, dass flake8 und Black nicht immer einer Meinung sind. Flake8 (&lt;code&gt;flake8 test1.py&lt;/code&gt;) würde standardmäßig den mit Black formatierten Code bemängeln:

 test1.py:8:80: E501 line too long (80 &gt; 79 characters)

Diese Diskrepanz kann beseitigt werden. Da 79 Zeichen auf modernen Bildschirmen meist als zu kurz empfunden werden, ist ein Limit von 88 Zeichen (Black-Standard) oder mehr empfehlenswert. Um dies zu implementieren, erstellen Sie in Ihrem Projektverzeichnis eine &lt;code&gt;.flake8&lt;/code&gt;-Datei mit dem Inhalt

 [flake8]
 max-line-length = 88

Und schon ignoriert Flake8 dieses Problem.

Ein anderer Linter ist pylint. Der würde beim Abarbeiten des obigen Beispiels, z.B. mit &lt;code&gt;pylint test1.py&lt;/code&gt; noch eine Kleinigkeit bemängeln:

 ************* Module test1
 /home/hr/tmp/test1.py:1:0: C0114: Missing module docstring (missing-module-docstring)
 
 ------------------------------------------------------------------
 Your code has been rated at 8.57/10 (previous run: 8.57/10, +0.00)

Auch pylint muss vor der ersten Verwendung installiert werden (z.B. mittels pip, virtuelle Umgebung, YaST). Die Dokumentation zu pylint findet sich auf [https://pylint.readthedocs.io/en/latest/].

&lt;u&gt;Aufgabe:&lt;/u&gt; Fügen Sie einen &quot;module docstring&quot; in die &lt;code&gt;test1.py&lt;/code&gt;-Datei ein und testen Sie erneut mit flake8, Black und pylint. &lt;small&gt;Sehen Sie zum Thema docstrings auch [https://peps.python.org/pep-0257/#what-is-a-docstring PEP 257 – Docstring Conventions].&lt;/small&gt;

Es gibt noch weitere Formatierungswerkzeuge für Python-Code. Z.B. [https://docs.astral.sh/ruff/ Ruff], ein moderner Code-Formatter und -Linter. Mittels &lt;code&gt;ruff check test1.py&lt;/code&gt; würde obiger Code geprüft (Linter). &lt;code&gt;ruff format test1.py&lt;/code&gt; formatiert den Code (Formatter).

== Type Checker ==
&quot;Type Checker&quot; sind z.B.
* mypy
* pyright
* ty

Diese prüfen die Datentypen, z.B. in folgendem Code

 def greetings(name: str) -&gt; str:
     return &quot;Hello, %s&quot; % name
 
 
 print(greetings(42))

Python selbst, flake8, ruff oder black würden diesen Code ohne zu murren akzeptieren. &quot;Type Checker&quot; würden aber sehr wohl Alarm schlagen, z.B. liefert &lt;code&gt;mypy&lt;/code&gt; folgende Ausgabe

 test1.py:5: error: Argument 1 to &quot;greetings&quot; has incompatible type &quot;int&quot;; expected &quot;str&quot;  [arg-type]
 Found 1 error in 1 file (checked 1 source file)

Das funktioniert übrigens nicht nur bei Funktionsannotationen, sondern auch mit Variablen etc.

 from typing import Final
 
 # &quot;Konstante&quot;, ab Python 3.8
 NUMBER: Final = 123
 print(NUMBER)
 NUMBER = 125
 print(NUMBER)
 
 # Variable
 a: int = 345
 print(a)
 a = &quot;Irgendwas&quot;
 print(a)
 
 # Variable (Pipe-Symbol), ab Python 3.10
 b : int|str = 567
 print(b)
 b = &quot;sonstiges&quot;
 print(b)

Ausgabe mit python:
 123
 125
 345
 Irgendwas
 567
 sonstiges

Ausgabe mit mypy:
 test3.py:6: error: Cannot assign to final name &quot;NUMBER&quot;  [misc]
 test3.py:12: error: Incompatible types in assignment (expression has type &quot;str&quot;, variable has type &quot;int&quot;)  [assignment]
 Found 2 errors in 1 file (checked 1 source file)

Python kennt übrigens keine Konstanten. Man kann diese mittels Großbuchstaben andeuten. Das ist aber nur Konvention, hat aber keine sonstigen Auswirkungen. Oder man verwendet wie oben gezeigt &lt;code&gt;Final&lt;/code&gt;. Dann werfen Typchecker Errors aus.

==pydoc==
pydoc ist ein Werkzeug, um Python-Module, -Funktionen und -Klassen zu dokumentieren.

Beispiel &lt;code&gt;test1.py&lt;/code&gt;:
 &quot;&quot;&quot;Rechen-Modul.
 
 Funktionen die von pydoc gelesen werden.
 &quot;&quot;&quot;
 
 def multiply(a, b):
     &quot;&quot;&quot;Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
     
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a * b
     
 def add(a, b):
     &quot;&quot;&quot;Addiert zwei Zahlen und gibt das Ergebnis zurück.
    
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a + b
    
 
 if __name__ == '__main__':
     print(multiply(3, 5))
     print(add(4, 6))

Ausgabe mit &lt;code&gt;python3.13 -m pydoc test1&lt;/code&gt; auf der Konsole:

 Help on module test1:
 
 NAME
     test1 - Rechen-Modul. 
 
 DESCRIPTION
     Funktionen die von pydoc gelesen werden.
 
 FUNCTIONS
     add(a, b)
         Addiert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
     multiply(a, b)
         Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
 FILE
     /home/xyz/tmp/test1.py

Siehe zu diesem Thema z.B. auch [https://docs.python.org/3/library/pydoc.html]. Mittels &lt;code&gt;python3.13 -m pydoc -w test1&lt;/code&gt; kann man auch eine HTML-Dokumentation erstellen.

Wofür &lt;code&gt;if __name__ == '__main__':&lt;/code&gt; steht, siehe z.B. etwas später im Abschnitt [[Ing_Mathematik:_Python#Doctests]].

== Sonstige Tools ==
Andere Tools für die {{W|Statische Code-Analyse|statische Codeanalyse}}, die aber für Ingenieure weniger interessant sein dürften, sind z.B.
* Radon: Liefert verschiedene {{W|Softwaremetrik|Codemetriken}} (Komplexität, Wartbarkeitsindex ...)
* Bandit: Findet Sicherheitslücken

Tools für die {{W|Dynamisches Software-Testverfahren|dynamische Codeanalyse}}, z.B.:
* DynaPyt (Framework zur dynamischen Programmanalyse)
* cProfile (Profiler)
* Memory Profiler (Speicheranalyse)
* Memray (Speicheranalyse)
* tracemalloc (Speicheranalyse)

Paket- und Projektmanagement (pip-Ersatz etc.):
* uv
* Poetry
* Conda
* pipx

Packaging-Tools (Freezer) und {{W|Compiler#Sonderformen|Transpiler}} :
* pyinstaller
** erstellt eigenständige, ausführbare Binärdatei
** kein Cross-Compiler
** kein Schutz vor Reverse-Engineering
** langsam
** packt alles in eine Datei
** sehr große Datei
** Befehl, z.B.: &lt;code&gt;pyinstaller --onefile test1.py&lt;/code&gt;
** GUI: &lt;code&gt;auto-py-to-exe&lt;/code&gt;
* cx_Freeze
* nuitka
** Übersetzt Python-Code in C/C++-Code und weiter in eine ausführbare Datei
** kein Cross-Compiler
** Schutz vor Reverse-Engineering
** Befehl, z.B.: &lt;code&gt;nuitka --standalone --onefile test1.py&lt;/code&gt;
* cython

= Einige Integrierte Entwicklungsumgebungen (IDEs)=
Werden Programmtexte größer und umfangreicher, so ist das Arbeiten mit der interaktiven Programmierumgebung bzw. das direkte Ausführen von Python-Skripten mühsam. Man wünscht sich z.B. Hilfen zum Debuggen oder die automatische Code-Vervollständigung. Zu diesem Zweck wurden IDEs (Integrated Development Environments) geschaffen. Von diesen seinen nachfolgend auszugsweise einige kurz beschrieben. Testen Sie einfach aus, welche davon für Sie bzw. für Ihr Python-Projekt geeignet sind.

== IDLE ==
IDLE ist die mit dem Python-Programmpaket mitgelieferte IDE. Der Name leitet sich einerseits ab vom Monty-Python-Mitglied Eric Idle, andererseits steht es als Abkürzung für &quot;'''I'''ntegrated '''D'''evelopment and '''L'''earning '''E'''nvironment. IDLE ist einfach zu bedienen, bietet aber schon einen beachtlichen Leistungsumfang. Nachfolgend wird ein Screenshot zu IDLE geliefert. Rechts ist das Editor-Fenster zu sehen, links die interaktive Programmierumgebung. Um das Beispiel selbst nachvollziehen zu können, starten Sie IDLE. Das geht ähnlich, wie Sie die interaktive Programmierumgebung von Python starten (nur, dass Sie eben das IDLE-Icon doppelklicken und nicht das Python-Icon. Unter Linux geben Sie einfach in einem Terminal &lt;code&gt;idle3.13&lt;/code&gt; o. Ä. ein). Weiter geht es mit &quot;File - Open - ...&quot;. Die auszuführende Datei auswählen (im konkreten Fall ein &quot;Hallo-Welt&quot;-Programm). Es erscheint das rechte Fenster. Dort &quot;Run - Run Module&quot; auswählen. Und schon wird im linken Fenster &quot;Hallo Welt!&quot; ausgegeben.

[[Datei:PythonIng_idle1.jpg | 600px]]

Siehe auch {{W|IDLE}}.

== PyCharm ==
PyCharm ist ein kommerzielles Produkt. Es gab aber auch eine kostenlose Community Edition. Seit 2025 sind beide Varianten vereint. Für die ersten 30 Tage sind die Pro-Funktionen frei verfügbar, danach nur noch die Kernfunktionalitäten (oder man bezieht kostenpflichtig  die Pro-Version). Zu beziehen ist PyCharm unter dem Weblink [https://www.jetbrains.com/pycharm/]. Nachfolgend ein etwas abgewandeltes &quot;Hallo Welt&quot;-Programm, editiert und ausgeführt mit PyCharm.

[[Datei:PyCharm_IDE_2023_screenshot.png | 600px]]

Siehe auch {{W|PyCharm}}.

== Eric ==
Auch eric ist Open Source und steht unter der  GNU General Public License Version 3 oder später. Zu beziehen ist diese Software unter [https://eric-ide.python-projects.org/].

[[Datei:Screenshot_Eric_4.png | 600px]]

Siehe auch {{W|eric (Software)}}.

&lt;small&gt;
Unter openSUSE Tumbleweed sollte sich eric auch mit YaST installieren lassen. Bei mir gibt es aber dann beim Ausführen des eric-Programms eine Fehlermeldung (Stand März 2026): 
 
 ...
 ModuleNotFoundError: No module named 'PyQt6.QtPdfWidgets'

Umgehen kann man dieses Problem aber wieder mit dem Erstellen einer virtuellen Umgebung, in etwa so

 python3.13 -m venv ~/tmp/venv1
 cd ~/tmp/venv1/bin
 ./python3.13 -m pip install --upgrade --prefer-binary eric-ide
 ./eric7_ide
&lt;/small&gt;

== PyScripter ==
Vom Funktionsumfang vergleichbar mit den vorherigen IDEs ist PyScripter. Auch PyScripter ist Open Source. Die Projekt-Homepage findet sich auf [https://sourceforge.net/projects/pyscripter/]. PyScripter ist nur für MS Windows verfügbar.

[[Datei:PythonIng_pyscripter1.jpg | 600px]]

== Spyder IDE ==
Spyder enthält bereits eine stabile Python-Version und etliche Module (z.B. matplotlib, numpy, control). Ansonsten kann dieses Softwarepaket vom Funktionsumfang her mit den anderen genannten IDEs locker mithalten. Spyder wurde unter der MIT-Lizenz veröffentlicht. Diese Software findet sich auf [https://www.spyder-ide.org].

[[Datei:Spyder-windows-screenshot.png | 600px]]

Siehe auch {{W|Spyder (Software)}}

== Eclipse IDE==
Die {{W|Eclipse_(IDE)|Eclipse-IDE}} kann für Python aufgerüstet werden. Dazu gibt es das PyDev-Plugin. Installiert wird es über 
* Help &gt; Eclipse Marketplace... 
* Find - PyDev - Install
Danach muss noch der Pfad zum Python-Interpreter festgelegt werden 
* Window &gt; Preferences &gt; PyDev &gt; Interpreters &gt; Python Interpreter &gt; New ... 
Das Ergebnis ist ähnlich wie im folgenden Bild, nur dass statt C/C++ Python Verwendung findet. 

[[Datei:Setting Up Eclipse CDT helloout.png | 600px]]

== Sonstige ==
Die genannten IDEs sind nicht die Einzigen. Es gibt, um dem Image Pythons als beliebteste Programmiersprache gerecht zu werden, noch einige andere. Sowohl Open Source-Programme als auch kommerzielle Programme sind im Web zu finden, z.B. Thonny oder {{W|Visual Studio Code}}. Unter Linux kann man auch {{W|KDevelop}}, ausgestattet mit dem Python3-Plugin, einsetzen. Braucht man den Umfang von ausgewachsenen IDEs nicht, so kann man auch normale Texteditoren verwenden (z.B. {{W|Geany}} oder {{W|Kate_(Texteditor)|Kate}}).

= Debuggen und Testen =
Das Debuggen und Testen von Programmen sind wichtige Bestandteile der Programmierung. Syntaxfehler lassen sich i.A. leicht beheben. Schwieriger ist das Eingrenzen von logischen Fehlern, die ev. nur in bestimmten Situationen auftreten und keine explizite Fehlermeldung hervorrufen. Das Programm liefert falsche Ergebnisse oder es stürzt aus heiterem Himmel ab. Um das zu verhindern gibt es verschiedene Werkzeuge, die bei der Fehlersuche behilflich sein können. Vorerst siehe aber zwecks Begriffsklärung noch folgende Links: 
 
* {{W|Debuggen}}
* {{W|Debugger}}
* {{W|Softwaretest}}

&lt;gallery&gt;
First Computer Bug, 1947.jpg
Test ganzheitlich.png
V-Modell.svg
&lt;/gallery&gt;

== Das Modul pdb ==
Python bringt schon ein Modul zum Debuggen mit. Siehe z.B. [https://docs.python.org/3/library/pdb.html pdb — The Python Debugger].
Komfortabler lässt sich das aber mittels Integrierter Entwicklungsumgebungen (IDEs) angehen.

== Debuggen mit IDEs ==
Für die IDEs IDLE und Spyder sei kurz auf die entsprechenden Webseiten verwiesen:

* [https://www.cs.uky.edu/~keen/help/debug-tutorial/debug.html Debugging under IDLE].
* [https://docs.spyder-ide.org/current/panes/debugging.html Spyder Debugger]

Dort wird die Vorgehensweise auch mittels Screenshots erläutert.

== assert ==
assert ... behaupten, zusichern ({{W|Assertion (Informatik)}})

Python-Code:
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10., 0.)

Ausgabe:

 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10., 0.)
   File &quot;/home/hr/Develop/test1.py&quot;, line 4, in print1
     assert y != 0.0
            ^^^^^^^^
 AssertionError
 
Python-Code: 
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)
 
Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(&quot;10.&quot;, &quot;5.&quot;)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError
 
Aber auch bei nachfolgendem Code gibt es eine Fehlermeldung:

 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10, 5)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError

Damit letzteres funktioniert, kann man den Programmcode so umschreiben:
 def print1(x, y):
     assert type(x) == float or type(x) == int
     assert type(y) == float or type(y) == int
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 2.0
 
Und jetzt fangen wir den &lt;code&gt;AssertionError&lt;/code&gt; auf:
 def print1(x, y):
     try:
         assert type(x) == float or type(x) == int
         assert type(y) == float or type(y) == int
         assert y != 0.0
         print(x/y)
     except(AssertionError):
         print(&quot;Hallo&quot;)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)

Ausgabe:
 2.0
 Hallo

Ich hoffe, es ist wenigstens im Ansatz klar geworden, wofür &lt;code&gt;assert&lt;/code&gt; gut sein kann. Ausschalten kann man die &lt;code&gt;assert&lt;/code&gt;-Überprüfung übrigens mit dem Python-Schalter &lt;code&gt;-O&lt;/code&gt;.

== Doctests == 
Innerhalb eines Docstrings kann die Arbeit im interaktiven Modus simuliert werden. Nach den Promptzeichen (&gt;&gt;&gt;) erfolgen dann bei unserem Beispiel innerhalb des Docstrings simulierte Aufrufe der Funktion &lt;code&gt;print1()&lt;/code&gt;. Danach folgen jeweils die Sollresultate. Wird das Modul oder die Datei als Hauptprogramm aufgerufen, so wird die Funktion &lt;code&gt;doctest.testmode()&lt;/code&gt; aufgerufen und ein Bericht auf der Konsole ausgegeben. Wird das Modul nicht als Hauptprogramm aufgerufen, sondern importiert, dann wird diese &lt;code&gt;testmod&lt;/code&gt;-Funktion nicht aufgerufen. D.h. dieser Code kann sowohl für Testzwecke als auch für den produktiven Einsatz verwendet werden. Das ist auch sinnvoll, weil wenn man Teile der Datei immer löschen bzw. einfügen müsste, so würden sich Fehlerquellen auftun. Das würde den Sinn und Zweck von Doctests konterkarieren.  

 def print1(x=0., y=1.):
     &quot;&quot;&quot; Dividiere zwei Zahlen
     Autor: Intruder
     Datum: 12.08.2025
 
     &gt;&gt;&gt; print1(2., 1.)
     2.0
     &gt;&gt;&gt; print1(5., 2.)
     2.5
     &gt;&gt;&gt; print1(5.)
     5.0
     &quot;&quot;&quot;
     print(x/y)
 
 if __name__ == &quot;__main__&quot;:
     import doctest
     doctest.testmod(verbose=True)

Ausgabe:
 Trying:
     print1(2., 1.)
 Expecting:
     2.0
 ok
 Trying:
     print1(5., 2)
 Expecting:
     2.5
 ok
 Trying:
     print1(5.)
 Expecting:
     5.0
 ok
 1 items had no tests:
     __main__
 1 items passed all tests:
    3 tests in __main__.print1
 3 tests in 2 items.
 3 passed and 0 failed.
 Test passed.

Das gezeigte Beispiel ist so ziemlich das einfachste, das es gibt. Für weiterführende Details siehe z.B.:
* [https://peps.python.org/pep-0257/ PEP 257 – Docstring Conventions]
* [https://docs.python.org/3/library/doctest.html doctest — Test interactive Python examples]

''Einschub:'' Ganz ähnlich kann man auch Klassen testen, z.B. in folgendem Code-Fragment

 class Fahrzeug:
   # siehe Abschnitt &quot;Objektorientierte Programmierung&quot;
   # ...
 
 if __name__ == &quot;__main__&quot;:
   vauweh = Fahrzeug(170, 90)
   beemweh = Fahrzeug(200, 120)
   print(vauweh.convertGeschw())
   print(beemweh.convertGeschw())

Wird das Script als Hauptprogramm ausgeführt (z.B. zu Testzwecken), so erfolgt die Ausgabe der zwei, via &lt;code&gt;convertGeschw()&lt;/code&gt;, umgerechneten Geschwindigkeiten. Wird es aber als Modul eingebunden, so wird der letzte Programmabschnitt nicht ausgeführt (&lt;code&gt;__name__ == &quot;__main__&quot;&lt;/code&gt; ergibt &lt;code&gt;False&lt;/code&gt;).

== pytest ==
Siehe zu diesem Thema auch {{W|Modultest}}.

pytest ist ein externes Modul und muss vorab installiert werden, z.B. mittels 
 pip install -U pytest
 pip install -U pytest-html 

Python-Code, Datei test1.py:
 def add(x, y):
     return x + y
 
 def test_answer():
     assert add(1, 1) == 3

Starten von pytest in der Konsole:
 pytest test1.py
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py F                                                                                                            [100%]
 
 ========================================================= FAILURES ==========================================================
 ________________________________________________________ test_answer ________________________________________________________
 
     def test_answer():
 &gt;       assert add(1, 1) == 3
 E       assert 2 == 3
 E        +  where 2 = add(1, 1)
 
 test1.py:6: AssertionError
 ================================================== short test summary info ==================================================
 FAILED test1.py::test_answer - assert 2 == 3
 ===================================================== 1 failed in 0.09s =====================================================

Hier erhalten wir einen Fehler, da 1+1 eindeutig ungleich 3 ist. Aber aus irgendeinem Grund wollte der Programmierer oder Tester in diesem Fall, dass dies so ist. Testfälle werden übrigens mit dem Präfix &lt;code&gt;test_&lt;/code&gt; eingeleitet.

Python-Code:
 def add(x, y):
     return x + y + 1
 
 def test_answer():
     assert add(1, 1) == 3 
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py .                                                                                                            [100%]
 
 ===================================================== 1 passed in 0.01s =====================================================

Jetzt ist alles in Ordnung. Weiterführendes siehe z.B.

* [https://docs.pytest.org/en/stable/ pytest: helps you write better programs]

== unittest ==
Auch unittest dient zur Durchführung von Testreihen, ist aber Bestandteil von Python. Hier wird vorerst nicht näher darauf eingegangen. Siehe z.B. 
* [https://docs.python.org/3/library/unittest.html unittest — Unit testing framework]

Lt. ''Inden: Python Challenge; dpunkt, 2021, Seite 481''  soll unittest weniger komfortabel als pytest sein.

Einen Vergleich von unittest mit pytest findet man in
* [https://knapsackpro.com/testing_frameworks/difference_between/pytest/vs/unittest pytest vs unittest]

= Python und Anwendungsprogramme =
Bisher stand immer alleine die Programmiersprache Python (ev. unter Einbeziehung von Modulen) im Mittelpunkt der Betrachtungen. Aber Python kann auch als Makrosprache für Anwendungsprogramme auftreten. Als Beispiele seien {{W|FreeCAD}} und {{W|LibreOffice}} genannt.

== FreeCAD ==
FreeCAD ist ein freies 3D-CAD-Programm. Hier soll nicht auf die Bedienung dieses CAD-Pakets eingegangen werden, sondern nur auf die Möglichkeit, mittels Python Makros zu schreiben. Als einfacher Einstieg soll ein Makro erstellt werden, welches eine Kugel (rot) und einen Quader (blau) zeichnet. Folgende Vorbereitungsschritte sind erforderlich (es sei vorausgesetzt, dass FreeCAD schon am Rechner installiert ist. Downloaden können Sie das Programm von der Website [https://www.freecad.org/downloads.php?lang=en]):

* FreeCAD starten
* Leere Datei erstellen
* Makro &gt; Makros &gt; Erstellen ...

Es öffnet sich ein leeres Editorfenster, in das Sie folgenden Code eingeben können:

 import FreeCAD
 import Part
 
 doc = FreeCAD.newDocument()
 
 # Kugel
 kugel = Part.makeSphere(10)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Kugel&quot;)
 form_element.Shape = kugel
 kug = FreeCAD.ActiveDocument.getObject(&quot;Kugel&quot;)
 kug.ViewObject.ShapeColor = (1.0, 0.0, 0.0)
 neuePosition = App.Vector(5, 2.5, 2.5)
 kug.Placement = App.Placement(neuePosition, kug.Placement.Rotation)
 
 # Quader
 quader = Part.makeBox(5, 5, 50)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Quader&quot;)
 form_element.Shape = quader
 quad = FreeCAD.ActiveDocument.getObject(&quot;Quader&quot;)
 quad.ViewObject.ShapeColor = (0.0, 0.0, 1.0)
 
 doc.recompute()

Diesen Code können Sie nun ausführen:
* Makro &gt; Makro ausführen

Es ergibt sich folgende Ausgabe (gedreht und gezoomt):

[[Datei: PythonIng_freecad1.png|500px]]

Siehe auch [https://wiki.freecad.org/Python_scripting_tutorial/de# Anleitung Skripterstellung mit Python]. Getestet wurde obiges Beispiel mit FreeCAD 1.1.3 unter Linux und 1.1.1 unter MS Windows.

== LibreOffice ==
LibreOffice ist ein freies Officepaket ([https://de.libreoffice.org/]). Hier soll nur das Tabellenkalkulationsprogramm Calc kurz betrachtet werden. Es seinen in den ersten 3 Zellen (A1 bis A3) Zahlen gegeben. Diese sollen mit einem Python-Makro addiert und das Resultat in der Zelle A5 ausgegeben werden. Auch hier sind Vorbereitungsarbeiten nötig: 
* zuerst muss unter Linux das Verzeichnis &lt;code&gt;~/.config/libreoffice/4/user/Scripts/python&lt;/code&gt; erstellt werden
* für MS Windows ist es das Verzeichnis &lt;code&gt;%APPDATA%\LibreOffice\4\user\Scripts\python&lt;/code&gt; 
** drücken Sie zuerst Win + R (es öffnet sich das Ausführen-Fenster)
** geben Sie &lt;code&gt;%appdata%&lt;/code&gt; ein, danach drücken Sie Enter (es öffnet sich der Explorer)
** navigieren Sie zu dem genannten Verzeichnis bzw. erstellen Sie das Verzeichnis 
* in diesem Verzeichnis wird dann mit einem beliebigen Texteditor das Python-Makro erstellt, in unserem Fall die Datei &lt;code&gt;summiere_zellen.py&lt;/code&gt;:

 import uno
 
 def summiere_zellen(*args):
     # Zugriff auf das aktuelle Dokument und das aktive Tabellenblatt
     ctx = uno.getComponentContext()
     smgr = ctx.getServiceManager()
     desktop = smgr.createInstanceWithContext(&quot;com.sun.star.frame.Desktop&quot;, ctx)
     doc = desktop.getCurrentComponent()
     sheet = doc.getCurrentController().getActiveSheet()
 
     # Werte aus den Zellen A1 bis A3 auslesen
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
 
     # Addition der drei Werte
     summe = w1 + w2 + w3
 
     # Ergebnis in die Zelle A5 schreiben
     sheet.getCellRangeByName(&quot;A5&quot;).Value = summe

* siehe dazu ggf. auch [https://help.libreoffice.org/latest/de/text/sbasic/python/python_locations.html?DbPAR=BASIC].

Weiter geht es in LibreOffice Calc mit dem Menü ''Extras &gt; Makros &gt; Makros verwalten &gt; Python''. Dort wird das Makro &lt;code&gt;summiere_zellen&lt;/code&gt; ausgeführt. Es ergibt sich z.B. folgendes Resultat

[[Datei:PythonIng_libreoffice1.png]]

Das Kürzel &lt;code&gt;uno&lt;/code&gt; steht für '''U'''niversal '''N'''etwork '''O'''bjects. Etwas einfacher geht's auch so:

 def summiere_zellen():
     desktop = XSCRIPTCONTEXT.getDesktop()
     model = desktop.getCurrentComponent()
     sheets = model.getSheets()
     sheet = sheets.getByIndex(0)
     
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
     
     cell = sheet.getCellRangeByName(&quot;A5&quot;)    
     cell.setValue(w1 + w2 + w3) 

Empfohlen wird auch, das Erweiterungspaket APSO ('''A'''lternative '''P'''ython '''S'''cript '''O'''rganizer, apso.oxt) zu installieren. Die Vorgehensweise wird hier nicht gezeigt, sondern nur darauf hingewiesen, dass man das einfach &quot;googeln&quot; kann. Siehe zur Python-Programmierung für LibreOffice auch [https://wiki.documentfoundation.org/Macros/Python_Guide/de Makros/Python-Handbuch]. Getestet wurden obige Beispiele mit LibreOffice 26.2.5.1 unter Linux und 26.2.1.2 unter MS Windows.

= Ausblick =
Dies war eine kurze Einführung in die Berechnungs- und Darstellungsmöglichkeiten mit Python. Es sollten etliche relevante Themen behandelt, oder zumindest kurz angesprochen worden sein. Wem dieser Text nicht ausreichend ist, der sei auf die entsprechenden weiterführenden Weblinks, Bücher und die Python-Hilfefunktion verwiesen. Python kennt noch viel mehr Befehle, als hier dargestellt wurden. Das Themenspektrum ist auch durch die Einbindung externer Module fast beliebig erweiterbar.

= Weblinks=
== Python allgemein ==
* [https://www.python.org/ Python Homepage]

== Externe mathematische Module ==
* [https://numpy.org/ NumPy]
* [https://numpy.org/doc/stable/user/numpy-for-matlab-users.html NumPy for MATLAB users]
* [https://scipy.org/ SciPy]
* [https://www.sympy.org/en/index.html SymPy]
* [https://pandas.pydata.org/ pandas]
* [https://github.com/maroba/findiff findiff]
* [https://mpmath.org/ mpmath]

== Externe Module für Grafiken ==
* [https://matplotlib.org/ Matplotlib]
* [https://vpython.org/ VPython]
* [https://build123d.readthedocs.io/en/latest/ build123d]
* [https://docs.vtk.org/en/latest/api/python.html VTK]
* [https://docs.bokeh.org/en/latest/docs/first_steps.html bokeh]
* [https://py5coding.org/ py5]

== Erstellung von User Interfaces ==
* [https://docs.python.org/3/library/tkinter.html tkinter - Python interface to Tcl/Tk]
* [https://docs.python.org/3/library/curses.html curses - Terminal handling for character-cell displays]
* [https://wiki.qt.io/Qt_for_Python Qt for Python]
* [https://www.gtk.org/docs/language-bindings/python GTK and Python]

== Erstellen virtueller Umgebungen ==
* [https://docs.python.org/3/library/venv.html venv - Creation of virtual environments]

== Sonstige ==
* [https://python-control.readthedocs.io/en/stable/ Python Control Systems Library]
* [https://pypi.org/project/regex/ regex - Regular Expressions]
* [http://pyromat.org/ PYroMat]
* [https://coolprop.org/coolprop/wrappers/Python/index.html CoolProp]
* [https://pypi.org/project/iapws/ iapws]
* [https://tespy.readthedocs.io/en/main/getting_started/introduction.html TESPy - Thermal Engineering Systems in Python]
* [https://pint.readthedocs.io/en/stable/ pint]

= Bücher =
== Gedruckte Bücher, OpenBooks, Magazine ==
* Diverse: c't Python Lernen, Verstehen, Anwenden; Heise, 2022 
* Ernesti, Kaiser: Python3 - das umfassende Handbuch; 5. Aufl., Rheinwerk, [https://openbook.rheinwerk-verlag.de/python/ OpenBook]
* Iacono et al.: Programmieren trainieren; 3. Aufl., Hanser, 2023, ISBN 978-3-446-47766-7
* Inden: Python Challenge; dpunkt, 2021, ISBN 978-3-86490-809-5
* Klein: Numerisches Python; 2. Aufl., Hanser, 2023, ISBN 978-3-446-47170-2 
* Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler; Rheinwerk, 2021, ISBN 978-3-8362-7316-9
* Weigend: Python 3 - Das umfassende Praxisbuch; 9. Aufl., mitp, 2022, ISBN 978-3-7475-0544-1
* Woyand: Python für Ingenieure und Naturwissenschaftler; 4. Aufl., Hanser, 2021, ISBN 978-3-446-46483-4

== Andere Wikibooks ==
* [[:en:Subject:Python_programming_language | Englische Wikibooks zum Thema Python]]
* [[Python|Deutschsprachiges Python-Wikibook]] [[Bild:2von10.png|20%]]
* [[Python unter Linux|Python 2.7 unter Linux]] [[Bild:10von10.png|100%]]


{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}</text>
      <sha1>mndz187nvkl0x8v2xoi76y62fyplv2q</sha1>
    </revision>
    <revision>
      <id>1092176</id>
      <parentid>1092174</parentid>
      <timestamp>2026-10-16T19:34:00Z</timestamp>
      <contributor>
        <username>Intruder</username>
        <id>1513</id>
      </contributor>
      <comment>/* Interpolation */</comment>
      <origin>1092176</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="189835" sha1="5ibaj4l84ogkmz2citb5pcetb4ucmt5" xml:space="preserve">{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}


= Hallo Welt und allgemeine Hinweise =
== Was ist Python ==
* Python ist eine universelle höhere Programmiersprache.
* Python ist objektorientiert.
* Python ist Open-Source (Python Software Foundation License).
* Python ist für viele Betriebssysteme erhältlich (z.B. für Linux, MS Windows, macOS).
* Python ist ein Interpreter.
* Python ist durch Module fast beliebig erweiterbar.
* Python als Programmiersprache ist case-sensitive - d.h. Groß- und Kleinschreibung ist relevant bei der Eingabe von Befehlen.
* Python ist in etlichen Anwendungsprogrammen (z.B. {{W|FreeCAD}}, {{W|LibreOffice}}, {{W|GIMP}}, {{W|Blender (Software) | Blender}}) als Makrosprache verwendbar.

{{Wikipedia | Python (Programmiersprache)}}

== Python installieren ==
=== MS Windows ===
Laden Sie das aktuelle Python-Paket von der Webseite [https://www.python.org/] herunter. Weiter geht es wie bei jedem anderen größeren zu installierenden Programm. Einfach das Installationsprogramm im Explorer doppelklicken und den Anweisungen des Setup-Programmes folgen.

=== Linux ===
Entweder ist Python bereits standardmäßig installiert, ansonsten ist die Installation mittels Paketmanagementsystem einfach möglich. Aber auch die Spyder-Entwicklungsumgebung ([https://www.spyder-ide.org]) bietet einen guten Einstieg mit Python (das gilt auch für MS Windows). Spyder bringt auch schon etliche wichtige Module standardmäßig mit.

== Python starten ==
=== MS Windows ===
Das Icon für das Python-Programm doppelklicken. Und schon startet das Programm.

[[Datei:PythonIng_start1.jpg]]

Python im interaktiven Modus (REPL ... '''R'''ead-'''E'''valuate-'''P'''rint-'''L'''oop) präsentiert sich dann so:

 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

Alternativ kann das Programm auch über die Eingabeaufforderung oder die PowerShell gestartet werden:

 c:\devel\Python&gt;python.exe
 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

=== Linux ===
Tippen Sie einfach das Wort „python“ (oder unter openSUSE Tumbleweed z.B. auch „python3.11“ oder „python3.13“) in einem Linux-Terminal ein, schließen den Befehl mit der RETURN-Taste ab, und schon startet Python im interaktiven Modus:
 
 Python 3.13.12 (main, Feb 09 2026, 22:37:44) [GCC] on linux
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt; 

Es gibt auch noch andere Möglichkeiten Python zwecks Programmausführung zu starten, z.&amp;nbsp;B. den {{W|Shebang}} (&lt;code&gt;#!&lt;/code&gt;) am Beginn eines Python-Scripts. Das Script sei als Script.py gespeichert. Dann kann das Script mit ./Script.py ausgeführt werden. Für openSUSE Tumbleweed sei nachfolgend ein lauffähiges &quot;Hallo Welt!&quot;-Script angegeben. Es wird in diesem Script der Python-Interpreter in der Version 3.13 verwendet :

 #!/usr/bin/python3.13
 print(&quot;Hallo Welt!&quot;)

Die Berechtigungen zum Ausführen der Datei müssen natürlich noch richtig gesetzt werden, z.B. mittels &lt;code&gt;chmod 777 Script.py&lt;/code&gt;. &lt;small&gt;&lt;code&gt;chmod&lt;/code&gt; ist die Abkürzung für&quot;'''ch'''ange file '''mod'''e bits&quot;.&lt;/small&gt; 

&lt;small&gt;Die &quot;Maske&quot; &lt;code&gt;777&lt;/code&gt; ist nur für Testzwecke sinnvoll, weil sie leicht zu merken ist und für alle Benutzer alle Zugriffsberechtigungen ('''r'''ead/'''w'''rite/e'''x'''ecute für owner/group/others) setzt. Im richtigen Einsatz wird man das aus Sicherheitsgründen nicht so handhaben, sondern nur die Berechtigungen setzen, die unbedingt erforderlich sind. Welche Zugriffsberechtigungen gesetzt sind, kann man z.B. mit dem Befehl &lt;code&gt;ls -l&lt;/code&gt; oder &lt;code&gt;ll&lt;/code&gt; ('''l'''i'''s'''t directory contents) erfragen. Aber dazu im Moment genug. Erfahrene Linux-Nutzer kennen das ohnehin und Anfänger sollen jetzt nicht mit Linux-Interna überfordert werden. Bei Bedarf siehe die Linux-Man-Pages oder dezidierte Bücher zu Linux.&lt;/code&gt;&lt;/small&gt;

&lt;small&gt;Oder das Script wird in einen Pfad verschoben, in dem sich ausführbare Programme generell befinden (welche Verzeichnisse im PATH liegen, kann bspw. mit &lt;code&gt;echo $PATH&lt;/code&gt; abgefragt werden). Das Script kann dann wie ein normales Programm ohne weitere Angaben mit Script.py gestartet werden. Alternativ wird nicht das Script an sich verschoben, sondern nur ein symbolischer Link angelegt, z.B. mit &lt;code&gt;ln -s ~/tmp/Script.py ~/.local/bin/Script.py&lt;/code&gt;. &lt;code&gt;~/.local/bin&lt;/code&gt; sei ein im PATH gelegenes Verzeichnis. Dies sind aber schon Features für fortgeschrittene Linux-Benutzer und werden am Anfang eher selten benötigt.&lt;/small&gt;

== Ein paar Worte zur Erklärung ==
=== Tests ===
Getestet wurden die Beispiele unter den Betriebssystemen 
* MS Windows 10 mit der Python-Version 3.12.0 (teilweise auch mit 3.12.2 und 3.13.1; nur die Inhalte die bis spätestens Juli 2025 erstellt wurden) 
* MS Windows 11 ab der Python-Version 3.13.4 (nur zum Teil; ab Juli 2025)
* openSUSE Leap 15.6 mit der Python-Version 3.11.12 (Spyder, nur vereinzelt) und zum Teil mit 3.12.11 (ab Juli 2025 bis November 2025).
* openSUSE Tumbleweed ab der Python-Version 3.13.9 (nur vereinzelt, ab November 2025)

=== Popularität ===
* An Beliebtheit rangiert Python mit Stand September 2026 mit einem Rating von 17,76% an 1. Stelle vor C und C++ (lt. [https://www.tiobe.com/tiobe-index/ TPCI - TIOBE Programming Community Index]). 
* Lt. [https://innovationgraph.github.com/global-metrics/programming-languages GitHub Top 50 Programming Languages Globally] lag Python im Q1/2026 auf Rang 2, vor TypeScript und hinter JavaScript. 
* [https://pypl.github.io/PYPL.html PYPL] (Popularity of Programming Language Index) ist ein anderer Popularitätsindex für Programmiersprachen. Auch hier liegt Python mit großem Vorsprung auf dem ersten Platz (52,08%), gefolgt von Java (13,34%) und C/C++ (7,99%) (Stand September 2026). 

=== Namensgebung ===
Der Name &quot;Python&quot; rührt von der Komikertruppe {{W|Monty Python}} her. Die Icons für Python (z.B. Python selbst, Eric IDE, IDLE) sind aber durch die Python-Schlangenart symbolisiert.

&lt;gallery&gt;
Python-logo-notext.svg|Python-Logo
Guido van Rossum in PyConUS24.jpg|{{W|Guido van Rossum}} (geb. 1956), der Erfinder von Python
&lt;/gallery&gt;

== Ein erstes Programm ==
Kommentare werden in Python mit der Raute (#) eingeleitet. Sie werden vom Python-Interpreter ignoriert. Text kann mit der print-Funktion ausgegeben werden. Starten Sie Python und geben sie folgende Anweisungen zeilenweise ein

 &gt;&gt;&gt; # Das ist ein Kommentar
 &gt;&gt;&gt; print(&quot;Hallo Welt!&quot;)

Als Ergebnis erhalten Sie

 Hallo Welt!

Der Prompt (&gt;&gt;&gt;) ist selbstverständlich nicht einzutippen, sondern wird vom Python-System geliefert.

Strings können in Python entweder in Anführungszeichen (&quot;) gesetzt werden oder in Hochkommatas('). In diesem Text wird die erste Variante bevorzugt eingesetzt.

Im Gegensatz zu Julia ist es hier egal, ob zwischen &lt;code&gt;print&lt;/code&gt; und der öffnenden Klammer Leerzeichen stehen.

= Python als Taschenrechner =
== Allgemeines ==
Wir wollen 3 * 5 berechnen. Dazu starten wir Python im interaktiven Modus. Geben Sie dann die Formel  

 &gt;&gt;&gt; 3 * 5

ein, drücken die Taste ENTER/RETURN ({{Taste|↵}}) und erhalten als Ergebnis

 15

Auch kompliziertere Ausdrücke sind möglich. Beispielsweise mit Winkelfunktionen, Quadratwurzeln etc. Wir wollen nun den Ausdruck &lt;math&gt;\sin\sqrt{15}&lt;/math&gt; berechnen :

 &gt;&gt;&gt; import math
 &gt;&gt;&gt; math.sin(math.sqrt(15))
 -0.6679052983383519

Als erstes wird das math-Modul importiert. Dann wird der mathematische Ausdruck berechnet.

Eine andere Variante, die dasselbe Ergebnis liefert, ist

 &gt;&gt;&gt; from math import *
 &gt;&gt;&gt; sin(sqrt(15))
 -0.6679052983383519

Es wird also aus dem Modul &lt;code&gt;math&lt;/code&gt; alles importiert (erkennbar am &lt;code&gt;*&lt;/code&gt;). Will man nicht alles importieren, so kann man das auch einschränken:

 &gt;&gt;&gt; from math import sin, sqrt

Beenden lässt sich das Python-Programm durch Eingabe von &lt;code&gt;exit()&lt;/code&gt; (und natürlich ist zur Bestätigung die RETURN-Taste zu drücken). &lt;code&gt;exit&lt;/code&gt; (ohne Klammern) oder &lt;code&gt;quit&lt;/code&gt; werden auch akzeptiert.

== Die Hilfefunktion von Python ==
Bei Eingabe der Anweisung &lt;code&gt;help&lt;/code&gt; oder &lt;code&gt;help()&lt;/code&gt; springt Python in den Hilfemodus. 

Eingabe:
 &gt;&gt;&gt; help()
 
Eingabe:
 help&gt; math.sin

Ausgabe:
 Help on built-in function sin in math:
 
 math.sin = sin(x, /)
     Return the sine of x (measured in radians).

Für die komplette Python-Dokumentation siehe [https://docs.python.org/3/]. Verlassen kann man den Hilfemodus durch das Drücken von STRG-C, bzw. der Eingabe von q, quit oder exit mit anschließendem Drücken der RETURN-Taste.

== Aufgaben ==
* Erkunden Sie die Tangensfunktion &quot;tan&quot; mittels Python-Hilfe (vergessen Sie nicht das math-Modul zu importieren und das &lt;code&gt;math.&lt;/code&gt; vor &lt;code&gt;tan&lt;/code&gt;)
* Berechnen Sie mit Python den Ausdruck &lt;math&gt;\frac{1}{2}\cdot \text{e}^2 \cdot \tan(\pi/3)&lt;/math&gt;. Siehe für die Exponentialfunktion im Python-Hilfesystem auch den Befehl &lt;code&gt;math.exp&lt;/code&gt;. Alternativ kann auch die Konstante &lt;code&gt;math.e&lt;/code&gt; eingesetzt werden. Potenzieren kann man bei Python mit dem **-Operator (z.B. 2**3 = 8). Für &lt;math&gt;\pi&lt;/math&gt; gibt es &lt;code&gt;math.pi&lt;/code&gt;.

= Python als Scriptsprache =
Häufig wird man aber kompliziertere Anweisungsfolgen verarbeiten müssen. Diese will man normalerweise nicht jedesmal neu eingeben, sondern in einer Datei speichern und diese Datei dann zur Ausführung bringen. Speichern Sie dazu folgenden Code in einer Textdatei, z.B. unter MS Windows als c:\tmp\test1.py

 # Das ist ein Kommentar
 print(&quot;Hallo Welt!&quot;)

Python-Dateien werden mit der Dateiendung .py versehen. Achten Sie darauf, dass vor dem print keine Leerzeichen vorhanden sind. Das ist eine Python-Eigenheit. Wie wir später sehen werden, nutzt Python Einrückungen als syntaktisches Mittel, z.B. um bei Schleifen den Schleifenkörper zu kennzeichnen. 

Danach bringen Sie die Skriptdatei test1.py (sozusagen das Hauptprogramm) folgendermaßen zur Ausführung:

1) Starten Sie unter MS Windows die Eingabeaufforderung (oder alternativ auch die Windows PowerShell). Das sieht dann etwa so aus:

 Microsoft Windows [Version 10.0.19045.3693]
 (c) Microsoft Corporation. Alle Rechte vorbehalten.
 
 C:\Users\xyz&gt;

: &lt;small&gt;Falls jemand nicht weiß, wie man die Eingabeaufforderung startet: Eine Möglichkeit ist, einfach in der Taskleiste von Windows das &quot;Start&quot;-Symbol &amp;nbsp;([[Image:Windows_logo_-_2021_(Black).svg|10px]])&amp;nbsp; mit der rechten Maustaste anklicken. &quot;Ausführen&quot; auswählen (oder alternativ für die PowerShell unter Windows 10 den Eintrag &quot;Windows PowerShell&quot;, unter Windows 11 den Eintrag &quot;Terminal&quot;). Im sich öffnenden Dialogfenster gibt man in die &quot;Öffnen&quot;-Zeile das Wort &lt;code&gt;cmd&lt;/code&gt; ein und mit &quot;OK&quot; wird das Ganze bestätigt.&lt;/small&gt; 
 
2) Wechseln Sie mittels &lt;code&gt;cd c:\tmp&lt;/code&gt; in das Verzeichnis c:\tmp

3) Angenommen, Sie haben Python unter dem Pfad &lt;code&gt;c:\devel\Python\&lt;/code&gt; installiert. Starten Sie das Programm so (der Prompt &lt;code&gt;c:\tmp&gt;&lt;/code&gt;ist natürlich nicht mit einzutippen): 

 c:\tmp&gt;c:\devel\Python\python.exe test1.py

4) Wie erwartet ergibt sich folgende Ausgabe am Bildschirm

 Hallo Welt!

Die Vorgehensweise unter Linux ist prinzipiell gleich. Die kleinen Unterschiede, wie z.B. der Slash statt dem Backslash in Pfadangaben, sollten für Linux-Benutzer keine Hürde darstellen.

== Variablen ==
Variablenbezeichner können aus Buchstaben (A-Za-z), Ziffern (0-9) und Underscores (_) bestehen, dürfen aber nicht mit einer Zahl beginnen. Führende Underscores haben u.a. im Kontext mit der Objektorientierten Programmierung eine spezielle Bedeutung und sollten nicht für &quot;normale&quot; Variablenbezeichner verwendet werden.

Gültige Variablenbezeichner wären also:
 xyz
 x1
 _wert
 name_anzahl

Theoretisch kann man auch Umlaute, griechische Buchstaben u.ä. in Variablenbezeichnern nutzen, z.B.

 ößÜ = 16
 α = 134 
 print(ößÜ)
 print(α)

Ausgabe:
 16
 134

Davon wird aber aus offensichtlichen Gründen ({{W|Englisch als Lingua franca}}) abgeraten. Das Eurozeichen (€) etc. darf man ohnehin nicht in Variablenbezeichnern verwenden, dies ergäbe einen Syntaxfehler. Siehe dazu auch [https://peps.python.org/pep-3131/].

Es gibt in Python etliche Schlüsselwörter (z.B. for, if oder return). Diese dürfen nicht als eigene Variablenbezeichner verwendet werden. Eine Liste aller Schlüsselwörter liefert das Script

 import keyword
 print(keyword.kwlist)

&lt;small&gt;Übung: Speichern Sie dieses Script in eine Datei, z.B. in c:\tmp\test1.py. Führen Sie diese Datei aus, um die Liste der Schlüsselwörter auszugeben.&lt;/small&gt;

Da Python case-sensitiv ist, repräsentieren folgende Bezeichner verschiedene Variablen:
 xyz
 XYZ
 xYz

Werte werden an Variablen mittels Gleich-Zeichen (=) zugewiesen. Im Folgenden wird der Code immer in der Datei c:\tmp\test1.py gespeichert.

 x = 5
 y = 10
 z = x*y
 print(z)

Bringen Sie die Datei test1.py zur Ausführung, so erhalten Sie folgende Bildschirmausgabe

 50

Sie können auch mehrere Anweisungen in einer Zeile durch Semikolon getrennt schreiben. Dies führt aber zu unübersichtlichem Code.

 x = 5; y = 10; z = x*y; print(z)

Ausgabe:
 50

Auch aus der Programmiersprache C/C++ oder Java bekannte Konstrukte können Sie verwenden, z.B.
 x = 5
 # x = x - 2
 x -= 2
 print(x)

Bildschirmausgabe:

 3
 
Beachten Sie, dass mit dem =-Zeichen eine Wertezuweisung durchgeführt wird. Dies ist nicht äquivalent zum mathematischen =-Zeichen, wie am vorigen Beispiel zu ersehen ist. Den Inkrement-/Dekrementoperator (z.B. x++ oder x--) aus C/C++ oder Java kennt Python aber nicht.

Variablen sind nicht an einen bestimmten Datentyp gebunden, folgendes ist mit Python problemlos möglich:

 import math
 wert = 10
 print(wert)
 wert = 35.5
 print(wert)
 wert = &quot;Hallo&quot;
 print(wert)
 wert = math.pi
 print(wert)

Ausgabe:
 10
 35.5
 Hallo
 3.141592653589793

== Physische und logische Zeilen ==
In Python muss eine Anweisung in einer logischen Zeile Platz finden. Wird eine Anweisung aber zu lang für eine Zeile, dann kann sie in mehrere physische Zeilen unterteilt werden. Dies kann einerseits durch einen Backslash am Ende einer Zeile geschehen, z.B.

 a = 2 + \
 5
 
Dies stellt eine logische Zeile dar, die in zwei physische Zeilen unterbrochen ist.

Geklammerte Ausdrücke werden automatisch zu einer logischen Zeile verbunden, z.B.

 a = (2 + 
 5)
 
Achtung: Im ersten Beispiel darf nach dem Backslash nichts mehr stehen, auch kein Kommentar. Dies trifft im zweiten Bespiel nicht zu, hier könnte noch ein Kommentar folgen, z.B.

 a = (2 +    # Kommentar 
 5)

Auch für Strings gibt es Möglichkeiten, diese auf mehrere Zeilen aufzuspalten.

 # Kurzer String
 str1 = &quot;ABC&quot;
 
 # Langer String
 str2 = &quot;&quot;&quot;Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle&quot;&quot;&quot;
 
 # Backslash
 str3 = &quot;UVW\
 XYZ&quot;
 
 # Mit Klammern
 str4 = (&quot;Sehr langer Text, der automatisch .............. &quot;
         &quot;in einer einzigen Variable zusammengefügt wird.&quot;
 )
 
 print(str1)
 print(str2)
 print(str3)
 print(str4)

Ausgabe:

 ABC
 Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle
 UVWXYZ
 Sehr langer Text, der automatisch .............. in einer einzigen Variable zusammengefügt wird.

==Hexadezimale, oktale, binäre und andere Zahlen==
 d = 1050         # Dezimalzahl
 h = 0xAA2        # Hexadezimalzahl
 o = 0o12         # Oktalzahl
 b = 0b100001101  # Binärzahl
 
 print(d)
 print(h)
 print(o)
 print(b)

Ausgabe:
 1050
 2722
 10
 269

Groß- und Kleinbuchstaben sind in obigen Literalen übrigens egal. So kann man z.B. statt &lt;code&gt;0b1001&lt;/code&gt; auch &lt;code&gt;0B1001&lt;/code&gt; schreiben (siehe dazu [https://docs.python.org/3/reference/lexical_analysis.html#integer-literals]).

Sie können auch dezimale in hexadezimale Zahlen umwandeln, usw.:
 h = hex(1050)    # Dezimalzahl -&gt; Hexadezimalzahl
 b = bin(1050)    # Dezimalzahl -&gt; Binärzahl
 o = oct(1050)    # Dezimalzahl -&gt; Oktalzahl
 print(h)
 print(b)
 print(o)

Ausgabe:
 0x41a
 0b10000011010
 0o2032

Gegeben sei die Zahl 121 zur Basis 3. Diese soll in eine Dezimalzahl umgewandelt werden. Das kann so geschehen:

 z = int(&quot;121&quot;, 3)
 print(z)

Ausgabe:
 16

Dass dies richtig ist, davon kann man sich folgendermaßen überzeugen:
 &lt;math&gt; 1 \cdot 3^2 + 2 \cdot 3^1 + 1 \cdot 3^0 = 9 + 6+ 1 = 16 &lt;/math&gt;

Zahlen übersichtlicher schreiben kann man auch mittels Underscore, z.B.:

 print(&quot;Eine Million (Variante 1) =&quot;, 1000000)
 print(&quot;Eine Million (Variante 2) =&quot;, 1_000_000)
 print(&quot;Eine Rechnung:&quot;, 2_000 * 400_000);

Es ergibt sich bei beiden Varianten die gleiche Ausgabe. Variante 2 ist aber im Sourcecode leichter lesbar, detto die Zahlen in der Rechnung:

 Eine Million (Variante 1) = 1000000
 Eine Million (Variante 2) = 1000000
 Eine Rechnung: 800000000

== Strings und Platzhalter==
Ein paar einfache Beispiele:

 print(&quot;Hallo {}&quot; . format(&quot;Hugo&quot;))     # new style string formatting
 print(&quot;Hallo {:s}&quot; . format(&quot;Hugo&quot;))   # new style string formatting
 print(&quot;Hallo %s&quot; % &quot;Hugo&quot;)             # %-String

Ausgabe:

 Hallo Hugo
 Hallo Hugo
 Hallo Hugo

Python-Code (formatted string literals, Beispiel 1):
 str1 = &quot;Hallo&quot;
 str2 = &quot;Hugo&quot;
 print(f&quot;{str1} {str2}&quot;)

Ausgabe:
 Hallo Hugo

f-Strings (ab Python 3.6) sind die modernere Variante gegenüber %-Strings oder das ''new style string formatting''. Sie sind in der Regel auch schneller.

Python-Code (formatted string literals, Beispiel 2):
 wert = 11.567
 print(f&quot;Ausgabe: {wert:.5f}&quot;)

Ausgabe:
 Ausgabe: 11.56700

Komplexere Beispiele:

 print(&quot;Hallo {} und {}&quot; . format(&quot;Hugo&quot;, &quot;Mike&quot;))
 print(&quot;Hallo {name1} und {name2}&quot; . format(name2=&quot;Hugo&quot;, name1=&quot;Mike&quot;))
 # Füllzeichen: *
 # Bündigkeit: &gt; (=rechts), &lt; (=links), ^ (=zentriert)
 # Feldweite: 10
 # Typ: s (=String), f (=Gleitkommazahl), d (=Dezimalzahl) etc.
 print(&quot;Hallo {:*&gt;10s}&quot; . format(&quot;Hugo&quot;))
 print(&quot;Hallo {:*&lt;10s}&quot; . format(&quot;Hugo&quot;))

Ausgabe:

 Hallo Hugo und Mike
 Hallo Mike und Hugo
 Hallo ******Hugo
 Hallo Hugo******

Python-Code:
 str = &quot;Hallo\t%s\t%7.2f\t%10.2e\t%i&quot; % (&quot;Hugo&quot;, 12.34567, 34.567, 264)
 print(str)

Ausgabe:
 Hallo	Hugo	  12.35	  3.46e+01	264

== Unicode ==
Neben den bekannten ASCII-Zeichen lassen sich Zeichen auch mittels Unicode beschreiben. Griechische Buchstaben oder komplexere mathematische Operatoren - all das sollte kein Problem sein. Siehe auch {{W|Unicode}}, {{W|Liste der Unicodeblöcke}} und {{W|Unicodeblock Mathematische Operatoren}}. Im Folgenden werden ein paar Zeichen (Allquantor, Nabla-Operator, Existenzquantor), die man aus der Mathematik kennt, erzeugt. 
 
 ch1 = &quot;\N{FOR ALL}&quot;
 ch2 = &quot;\N{NABLA}&quot;
 ch3 = &quot;\u2203&quot;
 print(ch1, ch2, ch3)

Ausgabe:
 ∀ ∇ ∃

&lt;small&gt;Diese Ausgabe ergibt sich z.B. mit der IDLE-Shell oder mit Cygwin. Beim Ausführen über die Windows-Eingabeaufforderung oder Windows PowerShell unter MS Windows 10 erfolgt keine korrekte Darstellung. IDLE ist die mit Python mitgelieferte IDE ('''I'''ntegrated '''D'''evelopment '''E'''nvironment, Integrierte Entwicklungsumgebung). Gegen Ende dieses Textes wird IDLE kurz beschrieben.
Das Problem mit der Windows Eingabeaufforderung lässt sich aber umgehen. Man muss nur eine Schriftart auswählen, die die Zeichen kennt, z.B. &quot;DejaVu Sans Mono&quot;. Dazu klicken Sie einfach bei der Eingabeaufforderung mit der rechten Maustaste oben auf die weiße Leiste und wählen im aufpoppenden Fenster den Menüpunkt &quot;Eigenschaften&quot;. Es öffnet sich ein Dialogfenster. Über den Reiter &quot;Schriftart&quot; lässt sich nun die Schriftart einstellen. Unter MS Windows 11 oder openSUSE Leap 15.6 (bash-Konsole) gibt es dieses Problem ohnehin nicht.&lt;/small&gt;

== Reguläre Ausdrücke ==
Python kennt auch {{W|Regulärer Ausdruck|reguläre Ausdrücke}}. Dazu gibt es in Python das Modul &lt;code&gt;re&lt;/code&gt;. Beipielsweise sollen alle Zahlen (&lt;math&gt;\text{zahl}\in\mathbb{N}_0&lt;/math&gt;) in einem String gesucht und ausgegeben werden. Als String sei gegeben: &lt;code&gt;3x Grüße und 100 Kekse.&lt;/code&gt; Das Muster (Pattern) ist &lt;code&gt;\d+&lt;/code&gt;. &lt;code&gt;\d&lt;/code&gt; steht für eine Dezimalziffer 0-9. Das Plus-Zeichen (+) steht symbolisch für ein oder mehrere Zeichen des vorherigen Ausdrucks. Hier also ein oder mehrere Dezimalziffern. Es wird die Funktion &lt;code&gt;findall&lt;/code&gt; aus dem Modul &lt;code&gt;re&lt;/code&gt;verwendet.

Python-Code:
 from re import findall
 
 str = &quot;3x Grüße und 100 Kekse.&quot;
 pat = &quot;\\d+&quot;  # Doppel-Backslashes müssen verwendet werden, sonst gibt Python eine Warnung aus!
               # alternativ: pat = r&quot;\d+&quot; 
               # oder: pat = &quot;[0-9]+&quot;
 
 numb = findall(pat, str)
 print(numb)

Ausgabe:
 ['3', '100']

Python kennt noch viele weitere Möglichkeiten mittels regulärer Ausdrücke zu hantieren. Dies soll hier aber nicht vertieft werden, da das Thema schon ziemlich speziell und komplex ist. Bei Bedarf siehe aber z.B. die Bücher ''Weigend, Seite 380ff'' und ''Ernesti, Kaiser'' [https://openbook.rheinwerk-verlag.de/python/28_001.html] oder die Python-Dokumentation [https://docs.python.org/3/library/re.html]. Auch [[Python unter Linux: Reguläre Ausdrücke]] liefert ein umfangreiches und brauchbares Python-2-Kapitel zu den regulären Ausdrücken. Die dort gelisteten Beispiele müssten ggf. vor Verwendung auf Python-3 umgeschrieben werden. &lt;small&gt;Wie macht  man das? Dazu siehe z.B. [https://openbook.rheinwerk-verlag.de/python/43_001.html], [https://portingguide.readthedocs.io/en/latest/] oder [https://www.digitalocean.com/community/tutorials/how-to-port-python-2-code-to-python-3]&lt;/small&gt;

&lt;small&gt;Es gibt auch ein externes Modul ''regex'', das bei Bedarf extra installiert werden muss ([https://pypi.org/project/regex/]). Es bietet zusätzliche Funktionalität und gründlicheren Unicode-Support. Dies sei hier aber nur der Vollständigkeit halber erwähnt.&lt;/small&gt;

== Verzweigungen ==
=== if ===
Die IF-Verzweigung sei aus anderen Programmiersprachen bereits bekannt. In {{W|Pseudocode}} lässt sie sich folgendermaßen darstellen:

 WENN bedingung TRUE
   führe block1 aus
 SONST
   führe block2 aus
 ENDE 

Als {{W|Aktivitätsdiagramm|UML-Aktivitätsdiagramm}} sieht das in etwa so aus:

[[File:If-Then-Else-diagram.svg|200px]]

Und als {{W|Nassi-Shneiderman-Diagramm|Nassi-Shneiderman-Struktogramm}} so:

[[File:Zweiseitige Auswahl.png|250px]]

In Python gibt es keinen expliziten ENDE-Kennzeichner. Stattdessen wird der Code durch Einrückungen strukturiert. Alles mit der gleichen Einrückungstiefe gehört zum selben Block. Dies zeichnet Python vor anderen Programmiersprachen aus.

Die test1.py-Datei laute also wie folgt:

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
   print(&quot;x ist groesser oder gleich 4&quot;)  

Ausgabe:

 Der else-Zweig wird ausgefuehrt
 x ist groesser oder gleich 4

Man achte auch auf die Doppelpunkte in der if- und else-Zeile. Darauf vergisst man gerne, wenn man von anderen Programmiersprachen kommt.

Folgendes wäre in Python ein Fehler (genauer gesagt ein IndentationError).

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
     print(&quot;x ist groesser oder gleich 4&quot;)  

Auch Nachstehendes würde nicht zum gewünschten Ergebnis führen (löst aber keine Fehlermeldung aus). Der letzte print-Befehl ist schon außerhalb der IF-ELSE-Verzweigung.

 x = 3
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
 print(&quot;x ist groesser oder gleich 4&quot;)

Ausgabe:

 x ist kleiner als 4
 x ist groesser oder gleich 4

Python kennt eine Reihe von Vergleichs- und Verknüpfungsoperatoren:

    &lt;, &lt;= ... kleiner (gleich)
    &gt;, &gt;= ... größer (gleich)
    == ... gleich
    != ... ungleich
    is ... identisch
    is not ... nicht identisch
    and ... AND
    or ... OR
    not ... NOT

Beispielsweise:

 a = 5
 b = 9
 
 if a&lt;=10 and b!=7:
   print(&quot;OK&quot;)
 else
   print(&quot;Nicht OK&quot;)

Ausgabe:

 OK

Der else-Block kann übrigens auch ersatzlos entfallen. Als Pseudocode sieht das so aus

 WENN bedingung TRUE
   führe block aus
 ENDE

Mehrfache Verzweigungen werden durch das elif-Konstrukt erstellt. In Pseudocode:

 WENN bedingung1 TRUE
   führe block1 aus
 SONST WENN bedingung2 TRUE
   führe block2 aus
 SONST WENN bedingung3 TRUE
   führe block3 aus
 SONST
   führe block4 aus
 ENDE

Ein Python-Beispiel:
 a = 14
 
 if a&lt;=10:   
   print(&quot;&lt;=10&quot;)
 elif a&gt;=11 and a&lt;=15:
   print(&quot;11 bis 15&quot;)
 elif a&gt;=16 and a&lt;=20:
   print(&quot;16 bis 20&quot;)
 else:
   print(&quot;&gt;20&quot;)

Ausgabe:

 11 bis 15

In Python gibt es auch die Schlüsselwörter &lt;code&gt;True&lt;/code&gt; (für wahr) und &lt;code&gt;False&lt;/code&gt; (für falsch). Man beachte, dass sie mit Großbuchstaben beginnen. Andere Schreibweisen wären ein Fehler. Sie gehören zum Datentyp &lt;code&gt;bool&lt;/code&gt;. Ihnen sind auch die Zahlen &lt;code&gt;1&lt;/code&gt; und &lt;code&gt;0&lt;/code&gt; zugewiesen.

Man beachte, dass {{W|Rundungsfehler}} auftreten können. D.h. man sollte  bei der Verwendung von {{W|Gleitkommazahl|Gleitpunktzahlen}} niemals auf absolute Genauigkeit prüfen, sondern eine Toleranz (einen &lt;math&gt;\varepsilon&lt;/math&gt;-Wert) vorgeben.
 
Ein klassisches Beispiel, das ein falsches Ergebnis liefert, ist:

 i = 0.1 + 0.2
 
 print(i)
 
 if i == 0.3:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 NOK

Und das, obwohl man schon in der Volksschule lernt, dass 0.1 + 0.2 gleich 0.3 ist.

Korrekt muss das obige Beispiel z.B. so umgeschrieben werden:

 ist = 0.1 + 0.2
 soll = 0.3
 epsilon = 0.000001
 
 print(ist)
 
 if abs(ist-soll) &lt; epsilon:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 OK

Alternativ kann auch die &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion verwendet werden. Das sei aber hier nur erwähnt und nicht konkret ausgeführt.

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet zum Thema &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion.

=== match ===
Ab Python 3.10 gibt es auch die match-Anweisung. Dies ist das Python-Pendant für die switch-Anweisung in anderen Programmiersprachen, geht aber bei näherer Betrachtung weit darüber hinaus. Hier nur ein einfaches Beispiel:

 x = &quot;Hello&quot;
 
 match x:
     case &quot;Servus&quot; | &quot;Ciao&quot;:         # or
         print(&quot;Servus an alle&quot;)
     case &quot;Grüetzi&quot;:
         print(&quot;Grüetzi Schwyzer&quot;)  
     case _:                         # other, default, sonstiges ...
         print(&quot;Hallo Welt&quot;)

Ausgabe: 
 Hallo Welt

Als Struktogramm sieht das in etwa so aus:

[[File:Mehrseitige Auswahl.png|250px]]

Für nähere Details siehe z.B. [https://www.geeksforgeeks.org/python-match-case-statement/], [https://learnpython.com/blog/python-match-case-statement/], [https://docs.python.org/3/tutorial/controlflow.html#match-statements] und das Python Enhancement Proposal (PEP) 636 – Structural Pattern Matching: Tutorial [https://peps.python.org/pep-0636] und dort insbesondere den Anhang A - Quick Intro.

&lt;small&gt;&lt;code&gt;match, case, _&lt;/code&gt; etc. sind sogenannte ''soft keywords''. Im Gegensatz zu den normalen Schlüsselwörtern dürfen ihnen auch Werte zugewiesen werden. Eine Liste der weichen Schlüsselwörter lässt sich durch &lt;code&gt;keyword.softkwlist&lt;/code&gt; erstellen (die Anweisung gibt es seit Python 3.9). Siehe dazu auch [https://stackoverflow.com/questions/65800344/what-are-soft-keywords] und [https://docs.python.org/3/library/keyword.html#keyword.softkwlist].&lt;/small&gt;

== Schleifen ==
Kopfgesteuerte Schleife, Endlosschleife und fußgesteuerte Schleife:

[[File:Programmingloops.svg|450px]]

=== while ===
Die WHILE-Schleife ist kopfgesteuert. Sie funktioniert wie aus anderen Programmiersprachen bekannt. 

In Pseudocode:
 SOLANGE bedingung TRUE
   führe block aus
 ENDE

In Python:
 x = 0
 
 while x &lt;= 10:
   print(x)
   x += 1

Ausgabe:
 0
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10

Eine Endlosschleife ergibt sich z.B. so:
 i = 5
 
 while True:
     print(i)
     i-=1

Beendet werden kann sie mit der Tastenkombination STRG-C.

Eine fußgesteuerte Schleife kann so simuliert werden:
 i = 5
 
 while True:
     print(i)
     i-=1
 
     if i&lt;=0:
         print(&quot;Fire&quot;)
         break

Ausgabe:
 5
 4
 3
 2
 1
 Fire

Der &lt;code&gt;break&lt;/code&gt;-Befehl wird etwas [[Ing_Mathematik:_Python#break|später]] noch einmal kurz thematisiert.

=== for ===
Struktogramm einer for-Schleife:

[[File:Zählschleife.png|200px]]

In Python bspw. so:

 for x in range(6):
   print(x*2)

Ausgabe:
 0
 2
 4
 6
 8
 10

Die Schleife läuft von 0 bis 5. Ausgegeben wird jeweils der Wert x*2. Aquivalent kann diese Schleife auch so geschrieben werden:
 for x in range(0, 11, 2):
   print(x)

Die Ausgabe ist wie oben. Der Startwert sei 0, der Endwert ist 11-1 und die Schrittweite ist 2.

Ein anderes Beispiel sei
 for x in &quot;text&quot;:
   print(x)

Ausgabe:
 t
 e
 x
 t

== Schleifen abbrechen ==
=== break ===
&lt;code&gt;break&lt;/code&gt; bricht die Schleife ab und setzt mit dem nächsten Befehl außerhalb der Schleife fort.

 for var in range(100):
   print(var) 
   if var == 5:
     break

Ausgabe:
 0
 1
 2
 3
 4
 5

=== continue ===
&lt;code&gt;continue&lt;/code&gt; bricht den aktuellen Schleifendurchlauf ab und setzt mit dem nächsten Schleifendurchlauf fort.

 for var in range (11):
   if var == 5:
     continue
   print(var)

Ausgabe:
 0
 1
 2 
 3
 4
 6
 7
 8
 9
 10

== try - except ==
 try:
     z1 = 12 / 0
     print(z1)
 except ZeroDivisionError:
     print(&quot;Das Ergebnis ist unendlich&quot;)
 except:
     print(&quot;Kann nicht berechnet werden!&quot;)
     print(&quot;Bitte die Formel korrigieren!&quot;)
 
 print(&quot;Setze Programm fort!&quot;)

Ausgabe:
 Das Ergebnis ist unendlich
 Setze Programm fort!

Es wird versucht, eine Zahl durch Null zu dividieren. Das ist nicht möglich, es wird eine Ausnahme ausgelöst. Das Programm springt daher in den except-ZeroDivisionError-Block und führt die dort gelisteten Anweisungen aus (in unserem Fall eine print-Anweisung). Danach wird das Programm fortgesetzt. Würden wir dieses Programm ohne try-except ausführen, so ergibt sich aus

 z1 = 12 / 0
 print(z1)

folgende Fehlermeldung und ein unmittelbarer Programmabbruch

 Traceback (most recent call last):
   File &quot;C:\tmp\test1.py&quot;, line 1, in &lt;module&gt;
     z1 = 12 / 0
 ZeroDivisionError: division by zero

Mit dem try-except-Mechanismus können also Ausnahmen oder Fehler aufgefangen und behandelt werden. In unserem Beispiel ist das eher trivial, aber bei größeren Programmen kann das durchaus Sinn machen.

Neu in Python 3.14 ist, dass mehrere Ausnahmen auch ohne Klammern angegeben werden können, z.B.:

bis inkl. Python 3.13 nur:
 except (ZeroDivisionError, ValueError):

ab Python 3.14 auch:
 except ZeroDivisionError, ValueError:

== pass ==
Ein leerer Block muss in Python mittels dem Schlüsselwort &lt;code&gt;pass&lt;/code&gt; dargestellt werden. Z.B.

 x = 2
 
 if x == 1:
     print(&quot;Wert ist &quot;, x)
 else:
     pass

Würde man das &lt;code&gt;pass&lt;/code&gt; im else-Block weglassen, so würde man eine Fehlermeldung erhalten:

 IndentationError: expected an indented block after 'else' statement on line 5

= Funktionen =
== Aufrufen von Funktionen ==
Funktionen sind uns im Rahmen dieses Kurses schon zuhauf begegnet. Sei es die print()-, die math.sin()- oder die hex()-Funktion. All diese Funktionen werden von Python zur Verfügung gestellt, ohne dass man sie explizit programmieren müsste. Aufgerufen werden diese Funktionen, indem man ihren Namen eintippt, gefolgt von runden Klammern. In diesen Klammern können noch Argumente übergeben werden. Auch Rückgabewerte sind möglich.

== Funktionen selber schreiben ==
Funktionen werden mit dem def-Schlüsselwort (man definiert die Funktion) eingeleitet, danach folgt der Funktionsname, danach wiederum runde Klammern, in denen formale Argumente stehen können. Abgeschlossen wird die def-Zeile mit einem Doppelpunkt. Danach folgt der Funktionskörper. Dieser Funktionskörper muss wiederum eingerückt werden (wie von den Verzweigungen und Schleifen bekannt). Aufgerufen wird diese Funktion, indem man ihren Funktionsnamen eingibt, gefolgt von runden Klammern (ggf. mit den aktuellen Parametern). Z.B.

 # Funktion definieren
 def halloWelt(i):
     # i ... beliebige Ganzzahl
     print(&quot;Hallo &quot; * i, end=&quot;&quot;)
     print(&quot;Welt!&quot;)
    
 # Funktion aufrufen
 halloWelt(3)

Ausgabe:
 Hallo Hallo Hallo Welt!

Unterschied zwischen formalen und aktuellen Parametern:

[[Datei:PythonIng_func1.jpg]]

&lt;small&gt;Aktuelle Parameter werden auch Argumente genannt.&lt;/small&gt;

Rückgabe von Funktionswerten:
 # Funktion definieren
 def mathFunc(a, b):
     r1 = a + b
     r2 = a * b
     return r1, r2
    
 # Funktion aufrufen
 c, d = mathFunc(3, 5)
 
 # Ausgabe der zurückgegebenen Werte
 print(c)
 print(d)

Ausgabe:
 8
 15

Es werden r1 und r2 zurückgegeben und den Variablen c und d zugewiesen. (r1, r2) und (c, d) sind Tupel. Was Tupel konkret sind, siehe etwas später in diesem Kapitel. 3 und 5 sind die aktuellen Parameter (die Argumente). a und b sind die formalen Parameter. Die Zuweisung der aktuellen zu den formalen Parametern erfolgt in der gegebenen Reihenfolge, also die Zahl 3 wird an a übergeben und die Zahl 5 an b.

Vorgabeparameter, z.B.:
 def mathFunc(a=10, b=20):
     r1 = a + b
     r2 = a * b
     return r1, r2
 
 c, d = mathFunc(3, 5)
 print(c)
 print(d) 
 
 e, f = mathFunc(5)
 print(e)
 print(f)
 
 g, h = mathFunc(b=6)
 print(g)
 print(h)

Ausgabe:
 8
 15
 25
 100
 16
 60

Erklärung:
* Erster &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es werden, wie weiter oben, die Argumente 3 und 5 an die formalen Parameter a und b übergeben. Die Rückgabewerte r1 und r2 werden an c und d übergeben. Somit ist c=8 und d=15.
* Zweiter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur das Argment 5 an a übergeben. b behält den Vorgabewert 20. D.h. e= 25 und f=100.
* Dritter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur die Zahl 6 an b übergeben, a behält seinen Vorgabewert 10. Somit ergibt sich g=16 und h=60.

Beispiel (Schlüsselwortargumente vs. Positionsargumente):
 def mathFunc(a, b):
     r1 = a - b
     r2 = a / b
     return r1, r2
 
 c, d = mathFunc(b=3, a=5)  # Schlüsselwortargumente
 e, f = mathFunc(3, 5)      # Positionsargumente

 print(c)
 print(d)
 print(e)
 print(f)

Ausgabe:
 2
 1.6666666666666667
 -2
 0.6

Durch die Verwendung von Schlüsselwortargumenten können die Argumente in beliebiger Reihenfolge angegeben werden. Bei den Positionsargumenten ist die Reihenfolge vorgegeben. Daraus resultiert auch der Unterschied bei den obigen Ausgaben. Werden beide Arten in einem Aufruf gemischt, so müssen die Positionsargumente zuerst angegeben werden. Den Unterschied zwischen beiden Argumentarten zu kennen ist wichtig, nicht nur bei selbst erstellten Funktionen. Auch beim Aufruf von Python-Funktionen verfolgt einen die Mischung von Schlüsselwort- und Positionsargumenten auf Schritt und Tritt, z.B. beim etwas später folgenden Abschnitt über &quot;Grafiken zeichnen&quot;:

 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)

Bei dieser &lt;code&gt;plot&lt;/code&gt;-Funktion aus dem Modul &lt;code&gt;matplotlib.pyplot&lt;/code&gt; sind &lt;code&gt;x&lt;/code&gt; und &lt;code&gt;y1&lt;/code&gt; Positionsargumente. &lt;code&gt;label, lw&lt;/code&gt; und &lt;code&gt;ls&lt;/code&gt; sind die Namen der Schlüsselwortargumente. Die Schlüsselwortargumente könnten auch in anderer Reihenfolge angeschrieben werden, nicht jedoch die Positionsargumente!
Siehe zu &lt;code&gt;matplotlib.pyplot.plot&lt;/code&gt; auch die Seite [https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html].

== Lambda-Funktionen ==
 print((lambda a, b: a*b) (3, 5))

Ausgabe:
 15

Eingeleitet wird eine Lambda-Funktion (auch Lambda-Form, Lambda-Operator oder anonyme Funktion genannt) mit dem Schlüsselwort &lt;code&gt;lambda&lt;/code&gt;. Es folgen die formalen Argumente, danach ein Doppelpunkt, die Berechnungsvorschrift und ggf. abschliessend in Klammern die aktuellen Parameter.

Man kann einer Lambda-Funktion auch einen Funktionsnamen geben und die Funktion über diesen Namen aufrufen, z.B.

 prod = lambda a, b: a*b
 print(prod(3, 5))

Als Ausgabe wird wieder die Zahl 15 geliefert.

== Rekursive Funktionen ==
Funktionen können wiederum andere Funktionen aufrufen. Von einem {{W|Rekursion|rekursiven Funktionsaufruf}} spricht man, wenn die aufgerufene Funktion gleich der aufrufenden ist. 

 def printFunc(i):
     if (i &gt;= 5):
         return 
     else:
         print(&quot;Hallo Welt&quot;)
         printFunc(i+1)
         
 printFunc(1)

Ausgabe:
 Hallo Welt
 Hallo Welt
 Hallo Welt
 Hallo Welt

Typische Beispiele für die Abarbeitung als rekursive Funktionen sind die {{W|Fibonacci-Folge}} und die {{W|Fakultät_(Mathematik)|Fakultät}}. Jedoch ist der iterative Ansatz (mit konventionellen Schleifen) meist schneller und speicherplatzschonender.

== Funktionsannotationen ==
Python ist sehr flexibel, was Typen angeht. Im Vorhergehenden haben wir generell keine Typangaben gemacht. Will man Typen angeben, so bietet Python das Konzept der Funktionsannotation.

 def calcFunc(a: int, b: int) -&gt; int:
     return a+b
 
 r1 = calcFunc(8, 9)
 r2 = calcFunc(8.0, 9.0)
 r3 = calcFunc(&quot;Hallo&quot;, &quot;Welt&quot;)
 
 print(r1)
 print(r2)
 print(r3)

Ausgabe:
 17
 17.0
 HalloWelt

Jetzt sieht man auf den ersten Blick, welche Typen der Programmierer im Sinn hatte, als er die Funktion erstellte. Das Problem dabei ist nur, dass es Python ziemlich egal ist, welche Typen man im Endeffekt eingibt. Im obigen Beispiel können statt Integer-Typen u.a. auch Float- oder String-Typen eingegeben werden.

&lt;small&gt;
Siehe zum Thema &quot;Type Checking&quot; aber auch den später folgenden Abschnitt [[Ing_Mathematik:_Python#Type_Checker]].
&lt;/small&gt;

== Variadische Funktionen ==
Python-Code:

 def test1(a, *b):
     print(a);
      
     for c in b:
         print(c);
        
 test1(&quot;Hallo&quot;, &quot;Welt&quot;, &quot;Schweizer&quot;, &quot;und alle anderen&quot;)

Ausgabe:

 Hallo
 Welt
 Schweizer
 und alle anderen

Mit dem Stern (auch als Splat-Operator bezeichnet) in der formalen Parameterliste bei der Funktion &lt;code&gt;test1&lt;/code&gt; wird angezeigt, dass eine beliebige Anzahl von Argumenten übergeben wird. &lt;small&gt; Dies entspricht in etwa dem, was in anderen Programmiersprachen (PHP etc.) mittels Ellipse (&lt;code&gt;...&lt;/code&gt;) angezeigt wird.&lt;/small&gt;

= Tupel, Listen und andere =
[[Datei:Python 3. The standard type hierarchy.png|mini|hochkant=1.7|Datentypen und Strukturen]]

== Tupel und Listen ==
Tupel, Listen und einige andere sind Datenstrukturen oder Sequenzen.

Listen (z.B. eine Einkaufsliste) sind veränderbar (mutable). Ein Tupel kann dagegen nicht verändert werden (immutable). Listen werden beim Anlegen in eckige Klammern eingeschlossen, Tupel in runde Klammern. Beim Tupel können die Klammern auch weggelassen werden. Ein Tupel mit nur einem Element muss mit einem Beistrich abgeschlossen werden. Der Grund ist, dass Python sonst nicht entscheiden kann, ob ein Tupel angelegt werden soll, oder nur ein geklammerter Wert. 

Als Gedächtnisstütze kann man sich den Unterschied zwischen Tupel und Liste ev. so leichter merken:
: T'''u'''pel ... r'''u'''nde Klammern, '''u'''nveränderlich
: L'''i'''ste ... eck'''i'''ge Klammern, veränderl'''i'''ch.

Nachfolgend werden einige Operationen mit Listen und Tupel dargestellt.

 # Liste und Tupel
 liste = [1, 2, &quot;Hallo&quot;]
 tupel = (1, 2, &quot;Hallo&quot;) 
 
 # Ausgabe von liste und tupel
 print(liste)
 print(tupel)
 
 # Ausgabe von Einzelelementen
 print(liste[1])
 print(tupel[2])
 
 # Element an Liste anhängen und einfügen 
 liste.append(55)
 liste.insert(4, &quot;Welt&quot;)
 print(liste)
 
 # Element aus Liste entfernen
 liste.remove(1)
 print(liste)
 
 # einige weitere Beispiele
 liste2 = [1,]
 tupel2 = 1, 2
 tupel3 = (1,) 
 print(liste2)
 print(tupel2)
 print(tupel3)

Ausgabe:
 [1, 2, 'Hallo']
 (1, 2, 'Hallo')
 2
 Hallo
 [1, 2, 'Hallo', 55, 'Welt']
 [2, 'Hallo', 55, 'Welt']
 [1]
 (1, 2)
 (1,)

Beispiel (eine Liste von Wörtern zu einem einzigen zusammenhängenden Text verbinden):

 woerter = [&quot;Hallo&quot;, &quot;Welt&quot;]
 satz = &quot; &quot;.join(woerter)
 print(satz)

Ausgabe:

 Hallo Welt

== Dictionaries und Mengen ==
Zu den Datenstrukturen gehören weiters auch Mengen und Dictionaries. Mengen sind von der Mathematik bekannt, sie sind ungeordnet und es kommen keine mehrfachen Elemente vor. Dictionaries sind durch Schlüssel :Wert-Paare gekennzeichnet. Mengen werden beim Anlegen wie Dictionaries in geschweifte Klammern eingeschlossen.

 dict = {&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot; }
 menge = {1, 1, 3, 4, 4, 4, &quot;Hallo&quot;}
 
 print(dict)
 print(menge)
 print(dict[&quot;vorname&quot;])

Ausgabe:
 {'vorname': 'Hugo', 'nachname': 'Meister'}
 {1, 3, 4, 'Hallo'}
 Hugo

Geschweifte Klammern ohne Inhalt stellen Dictionaries dar und keine Mengen:

 di = {}
 print(type(di))

Ausgabe:
 &lt;class 'dict'&gt;

Leere Mengen lassen sich mit &lt;code&gt;set()&lt;/code&gt; erzeugen:

 menge = set()      # leere Menge
 print(menge)
 menge.add(&quot;Hallo&quot;) # Element hinzufügen
 print(menge)

Ausgabe:
 set()
 {'Hallo'}

Beispiel (einige Mengenoperationen):
 mengeA = {&quot;Hallo&quot;, &quot;Welt&quot;}
 mengeB = {1, 2, &quot;Welt&quot;, 3}
 
 # Vereinigung
 print(mengeA | mengeB)
 print(mengeA.union(mengeB))
 
 # Durchschnitt
 print(mengeA &amp; mengeB)
 print(mengeA.intersection(mengeB))
 
 # Differenz
 print(mengeA - mengeB)
 print(mengeA.difference(mengeB))
 
 # Symmetrische Differenz
 print(mengeA ^ mengeB)
 print(mengeA.symmetric_difference(mengeB))
 
 # Teilmenge
 print(mengeA.issubset(mengeB))
 
 # Mehrere Elemente hinzu
 mengeA.update([&quot;Super&quot;, 67, 125])
 print(mengeA)
 
 # Element löschen
 mengeA.discard(&quot;Hallo&quot;)
 print(mengeA)

Ausgabe:
 {1, 2, 3, 'Welt', 'Hallo'}
 {1, 2, 3, 'Welt', 'Hallo'}
 {'Welt'}
 {'Welt'}
 {'Hallo'}
 {'Hallo'}
 {1, 2, 3, 'Hallo'}
 {1, 2, 3, 'Hallo'}
 False
 {67, 'Super', 'Welt', 'Hallo', 125}
 {67, 'Super', 'Welt', 125}

Es gibt schon seit &quot;ewigen&quot; Zeiten unveränderbare Mengen, die mittels &lt;code&gt;frozenset&lt;/code&gt; eingeleitet werden. Neu ab Python 3.15 ist dagegen das Pendant &lt;code&gt;frozendict&lt;/code&gt;, das unveränderbare Dictionaries darstellt.

 fdict = frozendict({&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot;})
 fset = frozenset({&quot;A&quot;, 1, &quot;A&quot;})
 
 print(fdict)
 print(fdict[&quot;vorname&quot;])
 print (fset) 
 
 try:
     fdict[&quot;vorname&quot;] = &quot;Max&quot;
     print(fdict[&quot;vorname&quot;])
 except TypeError as e:
     print(f&quot;Fehler: {e}&quot;)
 
 try:
     fset.add(&quot;B&quot;)
     print(fset)
 except AttributeError as e:
     print(f&quot;Fehler: {e}&quot;)

Ausgabe:
 frozendict({'vorname': 'Hugo', 'nachname': 'Meister'})
 Hugo
 frozenset({1, 'A'})
 Fehler: 'frozendict' object does not support item assignment
 Fehler: 'frozenset' object has no attribute 'add'

== List Comprehensions ==
Aus einer Eingabeliste soll eine Ausgabeliste erzeugt werden. Das kann folgendermaßen geschehen.

Mathematische Schreibweise: &lt;math&gt;lc = \{2x|x\in\ \mathbb{N}, 1\le x &lt; 11\}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11)]
 print(lc)

Ausgabe:
 [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Mathematische Schreibweise: &lt;math&gt;lc = \{2x | x \in \mathbb{N}, 1\le x &lt; 11, x \bmod 2 = 0 \}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11) if x%2 == 0]
 print(lc)

Ausgabe:
 [4, 8, 12, 16, 20]

Siehe auch {{W|List Comprehension}}.

== Set Comprehensions ==
Dies ist sehr ähnlich wie im vorigen Abschnitt beschrieben. Es wird aber keine Liste, sondern eine Menge erzeugt.

 sc = {x*2 for x in range(1,11)}
 print(sc)

Ausgabe:
 {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}

== Listen zusammenführen - zip() ==
 li1 = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]
 li2 = [1, 2, 3, 4]
 li3 = [5.5, 6.6, 7.7, 8.8]
 
 z = zip(li1, li2, li3)
 print(z)
 
 li4 = list(z)
 print(li4)

Ausgabe:
 &lt;zip object at 0x00000283B6C6AC80&gt;
 [('A', 1, 5.5), ('B', 2, 6.6), ('C', 3, 7.7), ('D', 4, 8.8)]

== Generatorausdruck ==
 g = (i*2 for i in range(1,11))
 print(g)
 t = tuple(g)
 print(t)
 print(t[1:3])

Ausgabe:
 &lt;generator object &lt;genexpr&gt; at 0x00000241D2A4A5A0&gt;
 (2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
 (4, 6)

== Slicing ==
slice ... Scheibe, Teil, in Scheiben schneiden

Beispiel: Zugriff auf Elemente eines geordneten sequentiellen Objekttyps (Liste, Tupel oder String):

 str1 = &quot;Hallo&quot;
 # Das erste Element wird mit dem Index 0 angesprochen
 # [start (inkl.) : stop (exkl.) : step (default=1)]
 str2 = str1[0:2]
 # Alternativ auch: str2 = str1[:2] 
 print(str2)
 
 tup1 = (0,1,2,3)
 # Das letzte Element hat auch den Index -1, das vorletzte den Index -2 usw.
 tup2 = tup1[-3:-1]
 print(tup2)
 
 lst1 = [[1,  5,  10, 20],
         [30, 40, 50, 60]]
 lst2 = lst1[1][1]
 print(lst2)
 
Ausgabe:
 Ha
 (1, 2)
 40

Beispiel:

 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2])
 print(x[-3]) 
 print(x)
 print(x[:])
 print(x[2:])
 print(x[:2])
 print(x[::-1])

Ausgabe:

 c
 c
 ('a', 'b', 'c', 'd', 'e')
 ('a', 'b', 'c', 'd', 'e')
 ('c', 'd', 'e')
 ('a', 'b')
 ('e', 'd', 'c', 'b', 'a')

Visualisierung:

    '''a'''     '''b'''     '''c'''     '''d'''     '''e'''
 +-----------------------------+
 |  0  |  1  |//'''2'''//|  3  |  4  |
 +-----------------------------+
 | -5  | -4  |/'''-3'''//| -2  | -1  | 
 +-----------------------------+
 |/////////////////////////////|
 +-----------------------------+
 |/////////////''':'''///////////////|
 +-----------------------------+
 |     |     |///////'''2:'''////////|
 +-----------------------------+
 |////''':2'''/////|     |     |     |
 +-----------------------------+
 |\\\\\&lt;--\\\\\'''::-1'''\\\\&lt;--\\\\\|
 +-----------------------------+

Beispiel:
 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2::2])
 print(x[2::-1])
 print(x[2:0:-1])

Ausgabe:

 ('c', 'e')
 ('c', 'b', 'a')
 ('c', 'b')

Hier sieht man sehr schön, dass beim letzen &lt;code&gt;print&lt;/code&gt;-Befehl die 0, die in diesem Fall den Buchstaben &quot;a&quot; repräsentiert, als letzer Wert nicht mehr dazugehört (wie weiter oben angedeutet ist der End- oder Stoppwert exklusiv). Will man den Buchstaben &quot;a&quot; dazunehmen, so ist die vorletzte Zeile die richtige.

Beispiel: Umdrehen von Strings

 str1 = &quot;Hallo&quot;
 str2 = str1[::-1]
 print(str2)

Ausgabe:
 ollaH

Mit zweidimensionalen Listen/Tupels wird das Ganze schon bedeutend komplexer.

Beispiel: Verkettetes Slicing

 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
     
 print(A[2::][::2])

Ausgabe:

 [['20', '21', '22', '23'], ['40', '41', '42', '43']]

Das erste Slicing erstellt folgenden Slice:

 [[&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
  [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
  [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]

Das zweite Slicing wird dann auf diesen Slice angewendet und ergibt das genannte Endergebnis. Will man Spalten statt Zeilen, so funktioniert dieser direkte Weg nicht. Man verwendet dann List Comprehensions oder die NumPy-Bibliothek. Diese Bibliothek erlaubt [[Ing_Mathematik:_Python#Zugriff_auf_Matrizenelemente|zweidimensionales Slicing]]. Sie wird erst später bei den Grafiken eingeführt. Deshalb wird hier dazu noch kein Beispiel gezeigt.

= Objektorientierte Programmierung =
{{Wikipedia|Objektorientierte Programmierung}}

* {{W|Klasse (Objektorientierung)|Klasse}} ... die Schablone oder der Bauplan, enthält Methoden und Attribute
* {{W|Objekt (Programmierung)|Objekt}} ... eine Klasseninstanz (die konkrete Ausprägung der Klasse)
* {{W|Attribut (Programmierung)|Attribute}} ... die Eigenschaften eines Objekts
* {{W|Methode (Programmierung)|Methoden}} ... die Aktionen (Operationen), die ein Objekt ausführen kann
* {{W|Vererbung (Programmierung)|Vererbung}} ... neue Klassen (Subklassen, Unterklassen, abgeleitete Klassen) aus vorhandenen Klassen (Superklassen, Oberklassen, Basisklassen, Elternklassen) ableiten. Ermöglicht den Aufbau von Klassenhierarchien. Die Subklasse &quot;erbt&quot; Attribute und Methoden von der Superklasse. Python unterstützt (so wie C++, aber im Gegensatz zu Java) Mehrfachvererbung.

== UML ==
* {{W|Unified Modeling Language|UML}} ... '''U'''nified '''M'''odeling '''L'''anguage, eine Modellierungssprache. Die UML enthält zahlreiche Diagrammarten, um Programme zu modellieren. Im Nachfolgenden wird nur das {{W|Klassendiagramm}} verwendet.

[[File:UmlCd Klasse-3.svg|300px]]

* {{W|Sichtbarkeit (Programmierung)|Sichtbarkeit}}:
** + ... public (öffentlich)
** - ... private
** # ... protected 

* {{W|Attribut_(UML)#Attribute_für_Instanzen_und_für_Klassen|Klassenattribute}} (statische Attribute): Werden nur einmal pro Klasse angelegt. Im Klassendiagramm werden sie unterstrichen.

[[File:Attribute-3.png|200px]]

* Vererbung:

&lt;gallery&gt;
InheritancePgmUML.svg | Abgeleitete Klasse erbt von Basisklasse (Einfachvererbung)
Diamond inheritance.svg | D erbt von B und C (Mehrfachvererbung). B und C erben von A (Einfachvererbung)
&lt;/gallery&gt;

Für weitergehende Betrachtungen zur UML wird auf Spezialliteratur verwiesen, z.B.:
* Seidl et al.: UML@Classroom. dpunkt, 2012, ISBN 978-3-89864-776-2
* Rupp et al.: UML 2 glasklar. Hanser, 4. Aufl., 2012, ISBN 978-3-446-43057-0

== Eine einfache Klasse ==

[[Datei:PythonIng_uml1.svg | 200px]]

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
 
 fahr = Fahrzeug(150, 90)
 
 print(fahr.convertGeschw())
 
Ausgabe:
 41.666666666666664

Die Klasse Fahrzeug wird durch das class-Schlüsselwort eingeleitet. raeder ist ein Klassenattribut und public. __init__ wird bei der Objekterzeugung automatisch aufgerufen (ist der sogenannte Konstruktor). Man achte darauf, dass diese Methode immer mit zwei Unterstrichen eingeleitet und abgeschlossen wird. Instanzattributen wird das Wort self vorangestellt. Wir sehen uns z.B. das Attribut self.__geschwind an. Auch hier werden zwei Unterstriche verwendet. Das bedeutet, dass dieses Attribut strikt/stark private ist. Wird nur ein Unterstrich verwendet, so deutet dies auf schwach/weakly private hin. Letzteres wird in Python deutlich häufiger verwendet. Bei den Methoden wird immer self als erster Parameter angegeben. Beim Aufruf der entsprechenden Funktion wird das self aber nicht berücksichtigt.

Besonderheiten bei stark und schwach private:
* '''stark private''':
** zwei führende Unterstriche
** Name Mangling: Name wird zu &lt;code&gt;_Klassenname__variablenname&lt;/code&gt;
** Schutz vor Namenskollisionen bei Vererbung
** am Ende des Namens dürfen keine zwei Unterstriche verwendet werden. Das wären dann Magic Methods oder Dunder-Methods (z.B. __init__). Diese sind public.

* '''schwach private''':
** ein führender Unterstrich
** Name bleibt gleich
** ist nur ein Hinweis an die Programmierer, kein starker Schutz
** &lt;code&gt;from modul import *&lt;/code&gt;: Objekte mit einem führenden Unterstrich werden standardmäßig nicht importiert
** Standard für die Kapselung bei Python. Schätzung: Weit mehr als 80% der nicht-öffentlichen Attribute/Methoden werden als schwach private deklariert. Weniger als 5-10% als stark private (Quelle: Google KI)

== Klassen importieren ==
Häufig ist es sinnvoll und übersichtlicher Klassen in eigenen Dateien zu speichern. Das sind dann eigene Module. Abgespeichert werden Sie mit der Endung py, wie bisher auch praktiziert. Aufgerufen werden Sie mit der import-Anweisung. Dann ist aber nur der Dateiname ohne Endung py zu verwenden. Klarer wird das mit einem Beispiel.

Datei c:\tmp\fahrzeug.py

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6

Datei c:\tmp\test1.py

 import fahrzeug
 fahr = fahrzeug.Fahrzeug(150, 90)
 print(fahr.convertGeschw())

Ausgabe:
 41.666666666666664

Die üblichen import-Anweisungen lauten wie folgt:
{| {{prettytable}}
! import-Befehl
! Instanz
|-
| import xyz      || xyz.Klasse
|-
| import xyz as x || x.Klasse
|-
| from xyz import Klasse || Klasse
|-
| from xyz import * || Klasse 
|}

Der Vorteil der ersten beiden import-Anweisungen ist, dass es kaum zu Namenskollisionen kommen kann. Dafür hat man bei den letzten beiden Varianten weniger Tipparbeit.

== Vererbung ==
=== Einfachvererbung ===

[[Datei:PythonIng_uml2.svg | 200px]]

Datei fahrzeug.py:
 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
        
     def setLeistung(self, leistung):
         self.__leistung = leistung
        
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
        
 class Luftfahrzeug(Fahrzeug):
     def __init__(self, geschwindigkeit, leistung, fluegel):
         super().__init__(geschwindigkeit, leistung)
         self.__flueg = fluegel
     
     def getFlueg(self):
         return self.__flueg

Datei test1.py:
 import fahrzeug
 fahr = fahrzeug.Luftfahrzeug(150, 90, 4)
 print(fahr.getFlueg())

Ausgabe:
 4

=== Mehrfachvererbung ===
Mit Python ist auch Mehrfachvererbung möglich, z.B.:

 class A:
     def _printA(self):
         print(&quot;Klasse A&quot;)
 
 class B:
     def _printB(self):
         print(&quot;Klasse B&quot;)
 
 class C(A,B):
     def __init__(self):
         self._printA()
         self._printB()
 
 c = C()

Ausgabe:

 Klasse A
 Klasse B

Die Klasse C erbt von A und B. In UML sieht das in etwa so aus:

 +-----------------------------+   +-------------------------+
 |            A                |   |          B              |
 +-----------------------------+   +-------------------------+
 |                             |   |                         |
 +-----------------------------+   +-------------------------+
 | # printA()                  |   | # printB()              |
 +-----------------------------+   +-------------------------+
                           .              .
                          / \            / \
                          ---            ---
                           |              |
                           |              |
                        +---------------------+
                        |          C          |
                        +---------------------+
                        |                     |
                        +---------------------+
                        |                     |
                        +---------------------+

&lt;code&gt;printA()&lt;/code&gt; und &lt;code&gt;printB()&lt;/code&gt; sind schwach private (in UML als &lt;code&gt;protected&lt;/code&gt; mit einem # dargestellt). Es ist aber zu beachten, dass schwach private nur Konvention ist. Praktisch könnte man auch von außerhalb auf diese Methoden zugreifen. Das soll man aber nicht tun, und das wird in Python durch einen Unterstrich angedeutet.

== Statische Attribute, statische Methoden und Klassenmethoden ==
Beispiel:

 class Math:
     pi = 3.14159265
     cnt = 0
     
     @staticmethod
     def expo():
         return 2.71828183
    
     @classmethod    
     def counterPlus(cls):
         cls.cnt += 1
        
 print(Math.pi)
 print(Math.expo())
 
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)

Ausgabe:

 3.14159265
 2.71828183
 1
 2
 3

Statische Attribute und Methoden, bzw. Klassenmethoden, sind direkt einer Klasse zugeordnet und nicht einem Objekt. Der Unterschied zwischen statischen Methoden und Klassenmethoden ist, dass statische Methoden nicht auf Klassenattribute (bzw. statische Attribute) zugreifen können, Klassenmethoden aber schon. &lt;code&gt;pi&lt;/code&gt; und &lt;code&gt;cnt&lt;/code&gt; sind statische Attribute. &lt;code&gt;expo()&lt;/code&gt; ist eine statische Methode. &lt;code&gt;counterPlus(cls)&lt;/code&gt; ist eine Klassenmethode. Die Bezeichnung des Parameters als &lt;code&gt;cls&lt;/code&gt; ist reine Konvention, man sollte sich aber daran halten. &lt;code&gt;@staticmethod&lt;/code&gt; und &lt;code&gt;@classmethod&lt;/code&gt; nennt man auch Dekoratoren.

= Grafiken zeichnen =
Für das Zeichnen von Grafiken wird hier das Modul &lt;code&gt;matplotlib&lt;/code&gt; verwendet. &lt;code&gt;matplotlib&lt;/code&gt; ist ein externes Modul und muss vor der ersten Verwendung installiert werden. Das geht so:

# Starten Sie ein Terminal (bei Windows die Eingabeaufforderung).
# Führen Sie darin folgenden Befehl aus &lt;code&gt;c:\devel\Python\Scripts\pip.exe install matplotlib&lt;/code&gt;

pip ist übrigens der Paketmanager von Python ({{W|Pip_(Python)}}). 

Optimalerweise installieren wir auch gleich das Modul &lt;code&gt;numpy&lt;/code&gt; (Numerical Python). Wir werden es im Folgenden oft benötigen (nicht nur bei den Grafiken). Das funktioniert vom Prinzip her genauso, wie für &lt;code&gt;matplotlib&lt;/code&gt; gezeigt.

&lt;small&gt;Verwenden Sie Spyder, so sind diese Schritte nicht nötig. Spyder inkludiert diese Pakete standardmäßig. Unter openSUSE Tumbleweed lassen sich diese Pakete mittels YaST oder zypper installieren.&lt;/small&gt;

== 2D ==
=== Graph einer Funktion ===
Es soll die cosh-Funktion im Intervall &lt;math&gt;x\in[-3,3]&lt;/math&gt; gezeichnet werden. Der Programmcode lautet in der einfachsten Form:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x)
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:PythonIng_cosh1.jpg]]

Der Code ist quasi selbsterklärend. Das Untermodul pyplot des matplotlib-Moduls und das numpy-Modul werden importiert. x läuft von -3 bis +3. y wird für jeden x-Wert per Formel ausgerechnet. &quot;plt.plot()&quot; ist der Zeichenbefehl. &quot;plt.show&quot; ist notwendig, um das Fenster mit der Grafik anzuzeigen.
Die Schrittweite 0.1 wurde so gewählt, um einen ausreichend glatten Verlauf des Graphen zu gewährleisten. Das ist immer ein Kompromiss zwischen Berechnungszeit und Ansehnlichkeit. Testen Sie einfach ein paar verschiedene Werte, um ein Gefühl dafür zu zu bekommen. &quot;plt.grid()&quot; zeichnet ein Gitter in die Grafik (kann auch weggelassen werden).
Die Bezeichnungen plt und np könnten auch anders gewählt werden. Es ist aber Konvention, diese so wie hier gezeigt zu wählen. Die &quot;arange&quot;-Funktion aus der NumPy-Bibliothek wird später ein bisschen genauer behandelt (siehe [[Ing_Mathematik:_Python#Zahlenfolgen|Zahlenfolgen]]).  

&lt;small&gt;Mit der im obigen Bild gezeigten Menüleiste kann die dargestellte Grafik nachträglich noch geändert werden (Zoom, Pan, Achsenparameter, Kurvenparameter etc.). Natürlich kann man das alles auch direkt programmieren. Wie das funktioniert wird ansatzweise etwas später gezeigt.&lt;/small&gt;

Ein etwas komplexeres Beispiel ist Folgendes:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x) + 2**x
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:
[[Datei:PythonIng_cosh4.png]]

Man beachte, dass im Gegensatz zu Octave und Julia der ominöse Punkt (.) bei 2**x mit Python nicht benötigt wird. Das macht das Programmiererleben etwas einfacher.

Die Farbe des Graphen kann man über den &lt;code&gt;color&lt;/code&gt;-Schalter einstellen, z.B. auf rot setzen:
 plt.plot(x, y, color=&quot;red&quot;)

Das ist nur eine Möglichkeit, es gibt auch andere, z.B. mittels
* hexadezimaler Zahl, z.B. &lt;code&gt;color=&quot;#ff0000&quot;&lt;/code&gt;
* Kurzform, z.B. &lt;code&gt;&quot;r&quot;&lt;/code&gt;

Statt &lt;code&gt;color&lt;/code&gt; kann auch die Kurzform &lt;code&gt;c&lt;/code&gt; verwendet werden.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie diese &quot;Farbspielereien&quot; am Computer aus.

=== Graphen mehrerer Funktionen und weiteres ===
==== Mehrere Funktionen in einen Plot zeichnen ==== 
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh2.png]]

Um die Linienstile etwas individueller zu gestalten, ist folgender Programmcode gedacht: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;, lw=3, ls=&quot;--&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh3.png]]

Einige weitere Bespiele zu &lt;code&gt;ls&lt;/code&gt;&lt;/code&gt;:
* - ... durchgezogene Linie
* -. ... Strichpunkt-Linie
* dashed ... gestrichelte Linie 

==== Marker ====
Desweiteren kann man Marker verwenden.

Beispiel:

 import matplotlib.pyplot as plt
 
 plt.plot(10, 10, &quot;ob&quot;, markersize=30)
 plt.plot(20,20, &quot;.r&quot;)
 plt.plot(30,30, &quot;Dg&quot;, ms=15)
 plt.plot(40, 40, &quot;ok&quot;, ms=20, mec=&quot;#FF5733&quot;, mew=3)
 plt.plot(50, 50, &quot;vk&quot;, ms=20, mec=&quot;yellow&quot;, mew=3)
 plt.grid()
 plt.show()


Das erste Zeichen im String nach den Koordinaten im plot-Befehl symbolisiert die Form (z.B. o für einen Kreis). Das zweite Zeichen steht für die Farbe (z.B. b für blue). &lt;code&gt;markersize&lt;/code&gt; oder &lt;code&gt;ms&lt;/code&gt; setzt die Größe des Markers.

Ausgabe:

[[Bild:PythonIng_formatpara1.svg|200px]]

Einige weitere Marker:
* * ... Stern
* + ... Plus
* h oder H ... Sechseck

Man kann mit den Parametern 
* &lt;code&gt;markeredgecolor&lt;/code&gt; oder kurz &lt;code&gt;mec&lt;/code&gt; die Farbe des Markerrandes
* &lt;code&gt;markeredgewidth&lt;/code&gt; oder kurz &lt;code&gt;mew&lt;/code&gt; die Dicke des Randes
* &lt;code&gt;markerfacecolor&lt;/code&gt; oder kurz &lt;code&gt;mfc&lt;/code&gt; die Innenfarbe des Markers
bestimmen.

=== Funktion in Parameterdarstellung ===
Es soll die archimedische Spirale &lt;math&gt;x = t \cos(t), y = t  \sin(t)&lt;/math&gt; im Intervall &lt;math&gt;[0, 6\pi[&lt;/math&gt; gezeichnet werden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
  
 plt.show()

[[Datei:PythonIng_spirale1.png]]

Diese Darstellung erscheint verzerrt. Will man gleiche Achsenskalierungen, so kann man den plt.axis()-Befehl verwenden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
 plt.axis(&quot;equal&quot;)
 
 plt.show()
 
[[Datei:PythonIng_spirale2.png]]

=== Funktion in Polardarstellung ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 fig = plt.figure()
 ax = fig.add_subplot(projection=&quot;polar&quot;)
 r = np.arange(0, 1, 0.01)
 theta = r**3
 line = ax.plot(theta, r)
 
 plt.show()

[[Datei:PythonIng_polar1.png]]

=== Logarithmische Achsenskalierung ===
==== Semilog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.semilogy()
 plt.show()

Ausgabe:

[[Datei:PythonIng_semilog1.png]]

==== LogLog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.loglog()
 plt.show()

[[Datei:PythonIng_loglog1.png]]

=== Gefüllte Fläche ===
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.arange(0, 3, 0.1)
 
 y1 = 3*x - 1
 y2 = x**2
 
 plt.plot(x, y1, x, y2, color='black')
 plt.fill_between(x, y1, y2, where=y1&gt;=y2)
 
 plt.show()

[[Datei:PythonIng_gefuellt.png]]

=== Linien, Pfeile, Rechtecke, Kreise und Texte ===
 import matplotlib as mpl
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 r = mpl.patches.Rectangle((0, 0), 3, 3, angle=30, fill=False)
 c = mpl.patches.Circle((4, 4), 2, fill=False)
 
 ax.add_patch(r)
 ax.add_patch(c)
 ax.plot([-2, 7], [-2, 0], color=&quot;black&quot;)
 ax.arrow(0, 7, 5, 0, length_includes_head=True, head_width=0.5, head_length=1.5,
          color=&quot;black&quot;)
 
 ax.set_aspect(&quot;equal&quot;)
 
 plt.axis([-3, 8, -3, 8])
 plt.show() 

[[Datei:PythonIng_linien_pfeile_etc.png]]

Text kann mit &lt;code&gt;ax.text(x, y, &quot;Text&quot;)&lt;/code&gt; hinzugefügt werden, bspw.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 ax.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

Oder einfacher auch ohne &lt;code&gt;subplots&lt;/code&gt;

 import matplotlib.pyplot as plt
 
 plt.text(0.1, 0.1, &quot;Hallo&quot;)
 plt.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

[[Datei:PythonIng_text1.png]]

Auch Sonderzeichen (griechische Buchstaben etc.) können verwendet werden (siehe dazu auch [https://matplotlib.org/stable/users/explain/text/mathtext.html]).

 import matplotlib.pyplot as plt
 
 plt.text(.3, .5,
          r'$\Omega\ \psi\ \oint\ \nabla\ \dot a\ \frac{a}{b}\ a_b$',
          size=&quot;20&quot;)
 plt.show() 

[[Datei:PythonIng_text20.svg]]

Jetzt wird noch gezeigt, wofür &lt;code&gt;subplots&lt;/code&gt; sinnvoll eingesetzt werden können.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(0.1, 0.1, &quot;Hallo&quot;)
 ax[1].text(0.1, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
            rotation=30.0)
 
 plt.show()

[[Datei:PythonIng_text2.png]]

=== Anmerkungen hinzufügen ===
Anmerkungen (engl. annotations) lassen sich mit matplotlib einfach hinzufügen. Unter Anmerkung wird hier ein Pfeil mit Text verstanden.

Beispiel:

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 ax.plot([1,10], [1,10])
 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
             arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0))
 plt.show()

Ausgabe:

[[Datei: PythonIng_ann1.svg|400px]]

&lt;code&gt;shrink&lt;/code&gt; verkürzt den Pfeil. Sinnvoll sind beim obigen Beispiel Werte irgendwo zwischen 0.0 und 0.3.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie verschiedene Pfeillängen aus. 

Die Schriftgröße verändern können Sie übrigens mit &lt;code&gt;fontsize&lt;/code&gt; oder &lt;code&gt;size&lt;/code&gt;, z.B.

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0), fontsize=25)

Eine andere Schreibweise für Dictionaries, die wir weiter oben schon kennengelernt haben, die wir aber nochmals explizit aufschreiben wollen, ist

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops={&quot;facecolor&quot;:&quot;red&quot;, &quot;shrink&quot;:0.0})

=== Figure, Axes etc.===
[[Bild:PythonIng_figure33.svg|350px]]

* fig (figure) ... das übergeordnete Fenster
* ax (axes) ... &quot;Plot&quot;, das eigentliche Zeichenfenster
* axis ... die Koordinatenachsen
* spine ... Begrenzungslinien des Zeichenfensters
* tick ... Markierung an den Achsen des Zeichenfensters

Beispiel (eine figure mit 6 axes, ax-Titel, y-axis-Titel):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=3, ncols=2)
 
 ax[0][0].text(0.1, 0.5, &quot;11&quot;)
 ax[0][1].text(0.1, 0.5, &quot;12&quot;)
 ax[1][0].text(0.1, 0.5, &quot;21&quot;)
 ax[1][1].text(0.1, 0.5, &quot;22&quot;)
 ax[2][0].text(0.1, 0.5, &quot;31&quot;)
 ax[2][1].text(0.1, 0.5, &quot;32&quot;)
 
 ax[0][0].set(ylabel=&quot;y-label&quot;, title=&quot;axes 1&quot;)
 
 plt.show()

[[Bild:PythonIng_figure34.png|350px]]

Beispiel (Achsenbereiche setzen):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 
 ax[0].axis((-1, 10, 1, 12))
 
 plt.show()

[[Bild:PythonIng_figure35.svg|350px]]

Beispiel (Gitter einschalten): 

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 ax[0].axis((-5, 10, 1, 12))
 ax[0].minorticks_on()
 ax[0].grid(which='minor')
 ax[1].grid(which='major')
 plt.show()

[[Bild:PythonIng_figure36.svg|350px]]

Beispiel (ticks setzen)

 import matplotlib.pyplot as plt
 import matplotlib.ticker as tick
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 pos = [0, .2, .5]
 lab = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
 
 ax.xaxis.set_major_locator(tick.FixedLocator(pos))
 ax.xaxis.set_major_formatter(tick.FixedFormatter(lab))
 
 plt.show()

[[Bild:PythonIng_figure37.svg|350px]]

Beispiel (Achsenkreuz beliebig setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 ax.spines['top'].set_color('none')
 ax.spines['right'].set_color('none')
 ax.spines['bottom'].set_position(('data', 0.3))
 ax.spines['left'].set_position(('data', 0.5))
 
 plt.show()

[[Bild:PythonIng_figure38.svg|350px]]

Beispiel (Inset):

 import matplotlib.pyplot as plt
 
 # Hauptplot erstellen
 fig, ax = plt.subplots()
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 
 # Inset hinzu:
 axin = ax.inset_axes([0.4, 0.4, 0.3, 0.3])
 axin.text(0, 0, &quot;Servus&quot;)
 axin.plot()
 
 plt.show()

[[Bild:PythonIng_figure40.svg|350px]]

Beispiel (Hintergrundfarben setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.set_facecolor(&quot;green&quot;)
 fig.set_facecolor(&quot;yellow&quot;)
 
 plt.plot([1, 3], [6, 8])
 plt.show()

[[Bild:PythonIng_figure39.svg|300px]]

=== GridSpec ===
Mit figures und axes lassen sich schon jede Menge an Grafikdetails einstellen. GridSpec ist dann der Turbo oder Raketenantrieb den matplotlib eingebaut hat. Naja, vielleicht ist das etwas übertrieben, aber GridSpec ist sozusagen ein flexibler Layout-Manager. Bisher haben wir immer gleich große axes gezeichnet. Mit GridSpec können wir Subplots über mehrere Zeilen und Spalten ziehen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 gs = fig.add_gridspec(3, 3)
 
 ax1 = fig.add_subplot(gs[0, :])
 ax1.set_title(&quot;Bereich 1: gs[0, :]&quot;)
 
 ax2 = fig.add_subplot(gs[1:, 0])
 ax2.set_title(&quot;Bereich 2: gs[1:, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 1:])
 ax3.set_title(&quot;Bereich 3: gs[1, 1:]&quot;)
 
 ax4 = fig.add_subplot(gs[2, 1:])
 ax4.set_title(&quot;Bereich 4: gs[2, 1:]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec1.svg|350px]]

Erklärung zu &lt;code&gt;(gs[zeile, spalte])&lt;/code&gt;: Slicing; damit legen Sie fest, welche Zellen ein Subplot belegt. Achtung! Die Indizes beginnen bei 0 und nicht bei 1 (d.h., die erste Zeile/Spalte hat den Index 0)
* : ... alle 
* 1: ... 1 bis Ende
* etc.

&lt;code&gt;constrained_layout=True&lt;/code&gt; sorgt dafür, dass sich die Subplots nicht überlappen.

Aber auch die Spaltenbreiten und Zeilenhöhen lassen sich anpassen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 
 # Verhältnis erste zu zweite Zeile = 1.5:1
 # Verhältnis erste zu zweite Spalte  = 1:4
 gs = fig.add_gridspec(2, 2, figure=fig, height_ratios=[1.5, 1], width_ratios=[1, 4])
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax1.set_title(&quot;Bereich 1: gs[0, 0]&quot;)
 
 ax2 = fig.add_subplot(gs[0, 1])
 ax2.set_title(&quot;Bereich 2: gs[0, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 0])
 ax3.set_title(&quot;Bereich 3: gs[1, 0]&quot;)
 
 ax4 = fig.add_subplot(gs[1, 1:])
 ax4.set_title(&quot;Bereich 4: gs[1, 1]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec2.svg|350px]]

Auch die Ränder lassen sich einstellen.

Beispiel 1:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.1, right=0.9, bottom=0.1,
                        top=0.9, wspace=0.2, hspace=0.2)
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec3.svg|300px]]

* hspace ... height space, vertikaler Abstand zwischen den Zeilen
* wspace ... width space, horizontaler Abstand zwischen den Spalten

Und im Vergleich dazu Beispiel 2:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.3, right=0.7, bottom=0.3, 
                        top=0.7, wspace=0.3, hspace=0.3) 
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec4.svg|300px]]

Es gibt noch einige weitere Details, die sich mit GridSpec variieren lassen (z.B. SubGridSpec ... verschachtelte Grid-Layouts). Aber wir belassen es vorerst dabei. Das bisher Gezeigte sollte für die meisten Probleme ausreichend sein.

=== Aufgaben ===
* Zeichnen Sie die Strophoide &lt;math&gt;x = \frac{a(t^2-1)}{t^2+1}, y = \frac{at(t^2-1)}{t^2+1}, a = 2, -3 \leq t \leq 3&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_strophoide.jpg|300px|center]]

* Zeichnen Sie die verschlungene Hypozykloide &lt;math&gt;x = (R-r)\cos t + c\cos\frac{R-r}{r}t, y = (R-r)\sin t - c\sin\frac{R-r}{r}t, c = 3, r = 2, R = 6, -15 \leq t \leq 15&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_hypozykloide.jpg|300px|center]]

* Testen Sie bei den obigen Übungsaufgaben verschiedene Linienstile und Farben. Farben können mit dem plt.plot()-Parameter color gewählt werden.

* Testen Sie bei den obigen Übungsaufgaben verschiedene Werte für a, c, r und R.

* Zeichnen Sie folgendes Bild (die Achsenbeschriftungen positionieren Sie z.B. mit den Befehlen &lt;code&gt;ax.set_xlabel(&quot;x&quot;, loc=&quot;right&quot;); ax.set_ylabel(&quot;y&quot;, loc=&quot;top&quot;)&lt;/code&gt;):

[[Bild:PythonIng_aufgabe24.svg|400px|center]] 

* Zeichnen Sie mit Python, matplotlib und NumPy folgendes Bild:

[[Bild:PythonIng_figure41.svg|400px|center]]

* Zeichnen Sie mit GridSpec ein Layout, das in etwa wie folgendes aussieht (&lt;code&gt;height_ratios=[1, 2], width_ratios=[2, 1]&lt;/code&gt;):

[[Bild:PythonIng_aufgabe23.svg|300px|center]]

== 3D ==
=== Räumliche Kurven ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0, 6*np.pi, 0.1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 z = t
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot(x, y, z)
 
 plt.show()

[[Datei:PythonIng_raumkurve1.png]]

=== Flächen ===
 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche1.png]]

Das Ganze in Netzdarstellung läßt sich so programmieren: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.5)
 y = np.arange(0, 10, 0.5)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_wireframe(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche2.png]]

Ein etwas komplexeres Beispiel:

 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0.1, 10, 0.1)
 y = np.arange(0.1, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z1 = np.sin(x) + 3 * np.cos(y)
 z2 = np.sin(x) + np.log(y)
 z3 = x + np.cos(y)
 z4 = x**2 - y
  
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;}, nrows=2, ncols=2)
 
 ax[0][0].plot_surface(x, y, z1)
 ax[0][1].plot_surface(x, y, z2)
 ax[1][0].plot_surface(x, y, z3)
 ax[1][1].plot_surface(x, y, z4)
 
 plt.show()

[[Datei:PythonIng_subplot1.png]]

Man beachte, dass man die Unterbilder im Bild nach dem Ausführen des Scripts z.B. mit der mittleren Maustaste einzeln drehen, oder über die Einträge in der Menüzeile einzeln bearbeiten kann. Mit ein paar Zeilen Programmtext lässt sich also eine Menge an Funktionalität generieren.

Die Farbgebung lässt sich über &lt;code&gt;colormaps&lt;/code&gt; variieren.

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm)
 
 plt.show()

[[Datei:PythonIng_colormap1.png]]

Es gibt eine Menge an Colormaps, z.B. &lt;code&gt;plasma, Greys, Dark2, ocean&lt;/code&gt;. Zwecks detaillierterer Infos siehe die matplotlib-Dokumentation. &lt;small&gt;Verwendet man die IDE namens IDLE, so gibt es dort auch die automatische Codevervollständigung. D.h. es werden alle Möglichkeiten (in unserem Fall nach dem Eintippen von &lt;code&gt;cm.&lt;/code&gt; alle verfügbaren Colormaps) angezeigt.&lt;/small&gt;

Die &quot;edgecolor&quot; und Linienbreite können auch frei gewählt werden:

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm, edgecolor=&quot;black&quot;, linewidth=1.0)
 
 plt.show()

[[Datei:PythonIng_colormap2.png]]

=== Höhenlinien ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 ax.contour(x, y, z)
 
 plt.show()

[[Datei:PythonIng_höhenlinien1.png|400px]]

Etwas abgewandelt sieht das so aus: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contour(x, y, z)
 ax.clabel(hl, inline = True)
 
 plt.show()

[[Datei:PythonIng_höhenlinien2.png|400px]]

Und noch eine Variante (mit einem Farbbalken) sei gezeigt. 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contourf(x, y, z)
 fig.colorbar(hl) 
 
 plt.show()

[[Datei:PythonIng_höhenlinien5.svg|400px]]

=== Aufgaben ===
* Zeichnen Sie die räumliche Kurve &lt;math&gt;x = 2 \cdot \cosh(t)&lt;/math&gt;, &lt;math&gt;y = 5 \cdot \sin(t)&lt;/math&gt;, &lt;math&gt; z = t^{2} - t&lt;/math&gt;, &lt;math&gt;0 \leq t \leq 3\pi&lt;/math&gt;.
* Zeichnen Sie die Fläche &lt;math&gt;z = \log(x) + \cos(y)&lt;/math&gt;.

== Animationen und fortgeschrittenes 3D ==
=== Mit matplotlib ===
Auch mit matplotlib sind Animationen möglich. Das ist ein bisschen komplizierter und wird deshalb hier nur mit einem sehr einfachen Beispiel dargestellt (bei Interesse siehe z.B. auch das [https://matplotlib.org/stable/users/explain/animations/animations.html#animations Animations using Matplotlib-Tutorial]).

 import matplotlib.pyplot as plt
 import matplotlib.animation as ani
 import matplotlib
 import numpy as np
 
 def update(frame):
     line.set_xdata(x[:frame])
     line.set_ydata(y[:frame])
     return (line)
 
 fig, ax = plt.subplots()
 
 x = np.arange(0, 10, .1)
 y = np.sin(x)
 
 line, = ax.plot(x[0], y[0])
 ax.set(xlim=[0, 10], ylim=[-1, 1])
 
 a = ani.FuncAnimation(fig=fig, func=update, frames=100, interval=20)
 plt.show()
 
 # Speichere die Animation in einem animierten GIF (optional)
 a.save(filename=&quot;c:/tmp/PythonIng_anim5.gif&quot;, writer=&quot;pillow&quot;)

[[Datei:PythonIng_anim5.gif]]

Es wird eine Sinuskurve auf den Bildschirm gezeichnet. In der letzten Zeile wird diese Animation in ein animiertes GIF gespeichert. Das ist natürlich optional und kann auch weggelassen werden.

=== Mit VPython ===
Aber auch mit dem Modul VPython lassen sich einfache 3D-Animationen erstellen. VPython ist ein externes Modul, das vorab installiert werden muss. Unter openSUSE Tumbleweed gibt es dzt. kein entsprechendes rpm-Paket. Die übliche Methode der Installation mittels YaST oder zypper ist somit nicht möglich. Auch eine direkte Verwendung von pip führt nur zu einer Fehlermeldung (&lt;code&gt;error: externally-managed-environment&lt;/code&gt;). Es empfiehlt sich dort folgende Vorgehensweise:
# Erstelle zuerst eine virtuelle Umgebung, z.B.: &lt;code&gt;python3.11 -m venv ~/tmp/venv1&lt;/code&gt;
# Wechsle das Verzeichnis: &lt;code&gt;cd ~/tmp/venv1/bin&lt;/code&gt;
# Installiere das entsprechende Paket: &lt;code&gt;./pip install vpython&lt;/code&gt;
# Führe das entsprechende Skript aus: &lt;code&gt;./python ~/tmp/test1.py&lt;/code&gt;

Aktuell (März 2026) ist dieses Programmpaket lt. der [https://vpython.org/presentation2018/install.html VPython-Homepage] nur für die Python-Versionen 3.8 bis 3.12 verfügbar.

Ein Beispiel zu einer einfachen Animation wird nachfolgend geliefert.

 from vpython import *
 
 scene.width = 1200
 scene.height = 600
 scene.center = vector(20,0,0)
 scene.background = color.white
 
 cylinder(pos=vector(0,0,0), axis=vector(20,0,0), radius=5, 
         color=color.blue)
 cone(pos=vector(0,0,0), axis=vector(-10,0,0), radius=5, 
         color=color.blue)
 helix(pos=vector(20,0,0), axis=vector(40,0,0), radius=2, 
         coils=10, thickness=0.5, color=color.blue)
 
 ball = sphere(pos=vector(20,0,0), color = color.green, radius = 1)
 ball.p = vector(0.15, 0, 0)
 
 toc = True
 
 while True:
     rate(200)
     if(ball.pos.x &lt;= 60 and toc == True):
         ball.pos += ball.p
     else:
         toc = False
         ball.pos -= ball.p
         if(ball.pos.x &lt;= 20 and toc == False):
             toc = True

[[Datei:PythonIng_vpython_anim.JPG]]

Idealerweise öffnet sich beim Ausführen des Scripts ein Browserfenster. Darin wird die programmierte Animation gezeigt (siehe auch den obigen Screenshot). Eine Größenänderung können Sie mit der mittleren Maustaste initiieren. Die Szenerie drehen können Sie mit der rechten Maustaste.

=== Mit build123d ===
Hiermit lassen sich einfach 3D-Modelle für CAD-Systeme erstellen. [https://build123d.readthedocs.io/en/latest/ build123d] ist ein externes Modul und muss vorab, wie schon für mehrere andere Module gezeigt, installiert werden (pip, venv etc.).

Beispielcode:

 from build123d import *
 
 # Bauteil
 with BuildPart() as bauteil: 
     # Zylinder erstellen
     Cylinder(100, 60)
        
     # Bohrung
     with BuildSketch(bauteil.faces().sort_by(Axis.Z)[-1]) as loch:
         Circle(radius=10)
     # negativ extrudieren
     extrude(amount=-60, mode=Mode.SUBTRACT)
     
     # Dem Bauteil z.B. die Farbe rot zuweisen
     # bauteil.part.color = Color(&quot;red&quot;, alpha=1.0)
 
     # Fertiges Modell exportieren
     export_step(bauteil.part, &quot;bauteil.step&quot;)

Ausgabe ({{W|Standard for the exchange of product model data | STEP}}-Datei, z.B. in {{W|FreeCAD}} importiert, Screenshot):

[[Datei:PythonIng_build123d.jpg | 300px]]

FreeCAD ist ein freies 3D-CAD-System. Die [[Ing_Mathematik:_Python#FreeCAD | Makroprogrammierung]] in diesem System wird später noch gezeigt. STEP steht für &quot;'''St'''andard for the '''e'''xchange of '''p'''roduct model data&quot; und ist ein Datenaustauschformat.

=== Mit VTK ===
Komplexer, aber auch mächtiger als VPython ist die Verwendung von VTK ('''V'''isualization '''T'''ool'''k'''it). Genauer gesagt des Python-Wrappers von VTK. Dieses externe Python-Modul muss vorab installiert werden (z.B. mittels YaST, pip oder in eine virtuelle Umgebung). VTK ist eine Softwarebibliothek zur 3D-Visualisierung und wurde ursprünglich in C++ geschrieben. Verbreitet eingesetzt wird diese Bibliothek in der Wissenschaft und Forschung, z.B. 
* in der medizinischen Bildgebung
* für Strömungssimulationen
* für Klimadaten

VTK funktioniert nach dem {{W|Grafikpipeline|Pipeline-Prinzip}}:

 Source (Quellen) -&gt;  Filter -&gt; Mapper (Senken) -&gt; Actor/Renderer

Daten fließen von den Quellen zu den Senken.

Als einfaches Beispiel wird die Darstellung eines Zylinders gezeigt, der mit den Maustasten gedreht oder in der Größe geändert werden kann:

 import vtk
 
 # Zylinder erzeugen
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 # Geometrie in darstellbare Daten umwandeln
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 # Objekt in der Szene
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 # Szene verwalten
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 # Render-Fenster
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 # Maus/Tastatur-Steuerung
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 # Starten
 render_window.Render()
 interactor.Start()

Ausgabe:

[[Datei:PythonIng_VTK_1.png]]

Gleiches Beispiel wie oben, aber mit einer Animationssequenz:

 import vtk
 import time
 
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     render_window.Render()
     time.sleep(0.01)

Das Grafikfenster schließt sich nach Ablauf der Schleife. Das Fenster bleibt geöffnet, wenn Sie am Programmende folgenden Befehl hinschreiben

 interactor.Start()

Um den animierten Zylinder grün einzufärben, müssen Sie Folgendes im obigen Programm ergänzen (Farbnamen):

 colors = vtk.vtkNamedColors()
 actor.GetProperty().SetColor(colors.GetColor3d(&quot;Green&quot;))

Als Namen können Sie u.a. die CSS3 Web-Farben verwenden (siehe z.B. [https://wiki.selfhtml.org/wiki/Farbe/Farbangaben] und {{W|Webfarbe#CSS_3}}).

Alternativ funktioniert auch das ({{W|RGB-Farbraum|RGB}}):

 actor.GetProperty().SetColor(0.0, 0.6, 0.0)

Wie der Zylinder mit einer Textur versehen wird, zeigt folgendes Programm:

 import vtk
 import time
 
 cylinder = vtk.vtkCylinderSource()
 cylinder.SetResolution(30)
 cylinder.SetHeight(3.0)
 cylinder.SetRadius(1.0)
 cylinder.CappingOn()
 
 texture_coords = vtk.vtkTextureMapToCylinder()
 texture_coords.SetInputConnection(cylinder.GetOutputPort())
 texture_coords.PreventSeamOn()
 
 reader = vtk.vtkJPEGReader()
 reader.SetFileName(&quot;PythonIng_textur.jpg&quot;)
 
 texture = vtk.vtkTexture()
 texture.SetInputConnection(reader.GetOutputPort()) 
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(texture_coords.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 actor.SetTexture(texture)
 
 renderer = vtk.vtkRenderer()
 renderWindow = vtk.vtkRenderWindow()
 renderWindow.AddRenderer(renderer)
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(renderWindow)
 
 renderer.AddActor(actor)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     renderWindow.Render()
     time.sleep(0.01)
 
 interactor.Start()

&lt;gallery&gt;
PythonIng_textur.jpg | Textur-Datei
PythonIng_VTK_2.png | Ausgabe (Screenshot)
&lt;/gallery&gt;

== Sonstige Grafikbibliotheken ==
=== Py5 ===
Im Buch ''Iacono et al.: Programmieren trainieren, mit über 150 Workouts in Java und Python; 3. Aufl., Hanser, 2023'' werden zahlreiche Aufgaben gestellt, die u.a. mit Processing zu lösen sind.  Processing ist eine einfache Programmiersprache und Entwicklungsumgebung. Warum ich das erwähne? Weil in älteren Processing-Versionen auch die Programmiersprache Python 2 abgedeckt war. Bei neueren Versionen gibt es keine Python-Anbindung mehr (getestet nur mit openSUSE Tumbleweed und Python 3). Somit funktioniert der Python-Teil im genannten Buch zum Teil nicht mehr. Ist das tragisch, oder kann das Buch weggeschmissen werden? Nein! Es gibt Alternativen zu Processing. Zum einen die im Buch selbst genannten Bibliotheken tkinter oder pygame. Pygame wird dort auch kurz anhand eines Beispiels thematisiert. Aber noch besser ist es, die py5-Bibliothek zu verwenden (lt. Google KI vom 30. Sept. 2026: ''Der echte, moderne „spirituelle Nachfolger“''). Damit ist die Funktionalität von Processing gewährleistet. Man kann aber beliebige Editoren oder IDEs zur Programmerstellung verwenden, ohne an Processing als IDE gebunden zu sein. Nachfolgend werden ein paar Beispiele zu dieser externen Bibliothek gegeben. Der erste Schritt ist wieder, die py5-Bibliothek zu installieren (z.B. mittels pip in eine virtuelle Umgebung; Python&gt;=3.10 und ein JDK&gt;=17 müssen auch installiert sein (Stand Okt. 2026)). Dann kann es schon mit dem Programmieren losgehen.

Beispiel (angelehnt an die ''Aufgabe W.2.3 Haus'' des genannten Buchs, jedoch etwas erweitert):

 import py5
 
 def setup():
     py5.size(600, 600)            # Fenstergröße 600px x 600px 
     py5.background(255, 255, 255) # Hintergrundfarbe ... weiss
     
 def draw():
     # Haus zeichnen
     py5.fill(255, 255, 255)       # Hintergrundfarbe ... weiss
     py5.stroke(255, 0, 0)         # Linienfarbe ... rot 
     py5.stroke_weight(3)          # Linienbreite ... 3px
     py5.rect(150, 200, 300, 300)  # Rechteck zeichnen (x, y, b, h)
     py5.triangle(150, 200, 300, 100, 450, 200) # Dreieck zeichnen
     py5.circle(250, 300, 70)      # Kreis zeichnen (x, y, d)   
     
     # Bemassung zeichnen
     py5.stroke(0, 255, 0)
     py5.stroke_weight(1)
     py5.line(300, 100, 550, 100)  # Linie zeichnen
     py5.line(450, 200, 550, 200) 
     py5.line(450, 500, 550, 500) 
     py5.line(150, 500, 150, 550)
     py5.line(450, 500, 450, 550)
     py5.text_size(20)             # Textgroesse
     py5.fill(0, 255, 0)           # Textfarbe
     py5.text(&quot;300&quot;, 280, 550)     # Text zeichnen
     py5.text(&quot;100&quot;, 500, 150)
     py5.text(&quot;300&quot;, 500, 350)  
 
     # Gedrehtes Rechteck zeichnen
     py5.stroke(255, 255, 0)
     py5.stroke_weight(3)
     py5.fill(200, 200, 200) 
     py5.translate(320, 260)  
     py5.rotate(0.3)               # Drehung (in Radiant)
     py5.rect(0, 0, 100, 50)
 
 # Startet den Sketch
 py5.run_sketch()


Ausgabe:

[[Datei:PythonIng_py5_1.png|300px]]

Das skizzierte Haus ist mit einer rudimentären Bemaßung versehen und hat zwei Fenster, ein rundes und ein gedrehtes, trübes rechteckiges. 

Beispiel (Mausoperationen):

 import py5
 
 def setup():
     py5.size(600, 600)            
     py5.background(255, 255, 255)
 
 def draw():
     pass
    
 def mouse_pressed():
     py5.text_size(15) 
     py5.fill(0, 0, 255)
     x = py5.mouse_x
     y = py5.mouse_y
     py5.text(&quot;(%d, %d)&quot; %(x, y), x, y) # Positionsdaten bei Maus-Klick schreiben
 
 py5.run_sketch()

Ausgabe:

[[Datei:PythonIng_py5_2.png|300px]]

Obiges Bild zeigt das Resultat nach einigen Mausklicks. Man erkennt, dass links-oben der Koordinatennullpunkt ist. Die x-Achse zeigt nach rechts, die y-Achse nach unten.

Beispiel (Fünfeck):

 import py5
 import random 
 
 def setup():
     py5.size(400, 400)
     py5.no_loop()       # statisches Bild (schont die Ressourcen)
 
 def draw():
     py5.translate(py5.width / 2, py5.height / 2)  # KS setzen
 
     radius = 150
     eck_anzahl = 5
 
     py5.fill(random.randint(0, 255), random.randint(0, 255), 
              random.randint(0, 255))    # Füllfarbe auf Zufallswert setzen
     py5.stroke(155, 0, 0)            
     py5.stroke_weight(5)     
     
     # Fünfeck als Polygon zeichnen
     py5.begin_shape()
     for i in range(eck_anzahl):
         winkel = i * py5.TWO_PI / eck_anzahl - py5.HALF_PI
         x = py5.cos(winkel) * radius
         y = py5.sin(winkel) * radius
         py5.vertex(x, y)
     py5.end_shape(py5.CLOSE)
 
 py5.run_sketch()

Ausgabe, bspw.:

[[Datei:PythonIng_py5_5.png|200px]]

&lt;u&gt;Kleine Aufgaben:&lt;/u&gt;
* Um die Funktionsweise von &lt;code&gt;py5.no_loop()&lt;/code&gt; zu verstehen, kommentieren Sie die Anweisung im Beispiel einfach aus, und starten Sie das Programm erneut.
* Zeichnen Sie ein Siebeneck.
* Was passiert, wenn man &lt;code&gt;py5.CLOSE&lt;/code&gt; im &lt;code&gt;py5.end_shape()&lt;/code&gt;-Befehl weglässt?

Beispiel (Grafik laden und zeichnen):

 import py5
 
 image1 = None
 
 def setup():
     global image1
     py5.size(600, 600)
     py5.no_loop()
     image1 = py5.load_image(&quot;PythonIng_py5_1.png&quot;)
 
 def draw():
     py5.image(image1, 0, 0)
 
 py5.run_sketch()

Hier wird einfach das Bild vom Haus-Beispiel (Screenshot von weiter oben) geladen und gezeichnet.

Beispiel (angelehnt an ''W.5.10 Wurfparabel'' des genannten Buches; mit OOP erstellt):

 import py5
 
 class Wurfparabel(py5.Sketch):
     def __init__(self, v0, angle):
         super().__init__()
         self.v0 = v0
         self.angle = self.radians(angle)
         self.g = 9.81
         self.t = 0.0
         self.scale = 1.5
 
     def settings(self):
         self.size(800, 600)
 
     def setup(self):        
         self.background(0, 0, 0)
         
     def draw(self):
         self.t += 0.1
 
         self.translate(50, 500)
       
         # KS Zeichnen
         self.fill(255, 255, 0)
         self.stroke(255, 255, 0)
         self.stroke_weight(1)
         self.line(0, 0, 0, -300)
         self.line(0, 0, 700, 0)
 
         # Punkt zeichnen
         cx = self.v0 * self.cos(self.angle) * self.t * self.scale
         cy = -(self.v0 * self.sin(self.angle) * self.t - \
                self.g/2 * self.t**2) * self.scale
         self.fill(255, 0, 0)
         self.stroke(255, 0, 0)
         self.circle(cx, cy, 3)
        
         # Stoppen bei Bodenkontakt
         if cy &gt;= -5:
             self.no_loop()
            
 def wurfparabel(v0=50, angle=45):
     sketch = Wurfparabel(v0, angle)
     sketch.run_sketch()
 
 v0 = float(input(&quot;v0 = &quot;))
 winkel = float(input(&quot;winkel = &quot;))
 wurfparabel(v0=v0, angle=winkel)

Eingabe auf der Konsole:

 v0 = 60
 winkel = 45

Ausgabe:

[[Datei:PythonIng_py5_13.png|200px]]

Die benötigten Formeln der Bewegungsgleichung kann man leicht herleiten, bzw. man benutzt folgende Grafik als Hilfestellung:

[[Datei:Wurfparabel_Zusammenfassung_aktualisierung.png|700px]]

&lt;u&gt;Aufgabe:&lt;/u&gt; Berechnen Sie den Scheitelpunkt und die Wurfweite bei gegebener Anfangsgeschwindigkeit und gegebenem Abwurfwinkel. Die Abwurfhöhe &lt;math&gt;y_0&lt;/math&gt; sei 0. Der Wurf soll auf der Erde stattfinden (g = 9.81 m/s²). Die dazu benötigten Formeln können aus obiger Grafik entnommen werden (oder Sie leiten sie selbst her). Geben Sie die Ergebnisse auf der Konsole aus.

Beispiel (eine einfache Animation):

 import py5
 
 i = 0
 
 def setup():
     py5.size(600, 600)
     py5.frame_rate(5)
     py5.stroke_weight(20)
 
 def draw():
     global i
     
     py5.background(255, 255, 255)
     py5.translate(py5.width/2, py5.height/2)
     py5.rotate(py5.PI/8 * i)    
 
     py5.line(-100, 0, 100, 0)
     i += 1
 
 py5.run_sketch()

Es wird eine rotierende Linie gezeichnet (z.B. wie bei einem Installationsprozess verwendet - zeigt an, dass der Installationsfortschritt nicht eingefroren ist). Hierbei ist nur aufzupassen, dass der Hintergrund in &lt;code&gt;draw()&lt;/code&gt; gesetzt wird, ansonsten würden die Linien additiv gezeichnet. Das ist zwar auch schön, aber eben nicht das gewünschte Resultat.

Hiermit belassen wir es mit der py5-Bibliothek und wenden uns wieder &quot;mathematischeren&quot; Themen zu.

= Vektoren und Matrizen =
== Zahlenfolgen ==
Für das Erstellen von Zahlenfolgen bieten sich die Funktionen &lt;code&gt;arange&lt;/code&gt; und &lt;code&gt;linspace&lt;/code&gt; aus dem &lt;code&gt;numpy&lt;/code&gt;-Modul an.

 from numpy import *
 
 start = 0
 stop = 10
 step = 2
 num = 10
 
 r = arange(start, stop, step)   # step ... Schrittweite
 l = linspace(start, stop, num)  # num ... Anzahl der Werte
 
 print(&quot;r = &quot;, r)
 print(&quot;l = &quot;, l)

Ausgabe:
 r =  [0 2 4 6 8]
 l =  [ 0.          1.11111111  2.22222222  3.33333333  4.44444444  5.55555556
   6.66666667  7.77777778  8.88888889 10.        ]

Bei &lt;code&gt;arange&lt;/code&gt; ist der &lt;code&gt;stop&lt;/code&gt;-Wert nicht im Ergebnis enthalten, bei &lt;code&gt;linspace&lt;/code&gt; standardmäßig aber sehr wohl. Jedoch kann man das bei &lt;code&gt;linspace&lt;/code&gt; auch ändern. Dann ist der Stoppwert nicht mehr enthalten: 

 linspace(start, stop, num, endpoint=False)

== Vektoren ==
Vektoren sollten jedem aus der Linearen Algebra bekannt sein. 

=== Arrays ===
In Python mit NumPy kann man Vektoren durch die Funktion array erzeugen.

 import numpy as np
 
 l1 = (-5, 3, 2)
 l2 = (1, 1, 4)
 
 a1 = np.array(l1)
 a2 = np.array(l2)
 
 a3 = a1 + a2
 a4 = 2 * a2
 
 print(a1)
 print(a2)
 print(a3)
 print(a3[2])
 print(a4)

Ausgabe:
 [-5  3  2]
 [1 1 4]
 [-4  4  6]
 6
 [2 2 8]

=== Zeilen- und Spaltenvektoren ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 print(z)
 print(s)

Ausgabe:
 [ [-5  3  2] ]
 [[1]
  [1]
  [4]]

=== Skalarprodukt ===
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4))
 
 skalarprodukt = np.dot(a1, a2)  
 
 print(skalarprodukt)

Ausgabe:
 6

=== Vektorprodukt ===
&lt;math&gt;a\ast b=\left(\begin{array}{c}
a_{1}\\
a_{2}\\
a_{3}
\end{array}\right)\ast\left(\begin{array}{c}
b_{1}\\
b_{2}\\
b_{3}
\end{array}\right)=\left(\begin{array}{c}
a_{2}b_{3}-a_{3}b_{2}\\
a_{3}b_{1}-a_{1}b_{3}\\
a_{1}b_{2}-a_{2}b_{1}
\end{array}\right)
&lt;/math&gt; 

Python-Code:
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4)) 
 
 vektorprodukt = np.cross(a1, a2) 
 
 print(vektorprodukt)

Ausgabe:
 [10 22 -8]

=== Transponierter Vektor ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 # transponierter Vektor
 z_tp = np.transpose(z)
 # transponierter Vektor
 s_tp = np.transpose(s)
 
 print(z_tp)
 print(s_tp)

Ausgabe:
 [[-5]
  [ 3]
  [ 2]]
 [ [1 1 4] ]

=== Vektorfelder visualisieren ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 # Daten generieren
 x = np.arange(0, 10, 1)
 y = np.arange(0, 10, 1)
 X, Y = np.meshgrid(x, y)
 U = X * Y
 V = Y + X
 
 # Plotten
 fig, ax = plt.subplots()
 
 ax.quiver(X, Y, U, V, angles='xy')
 
 plt.show()

Ausgabe:

[[Datei:PythonIng_quiver1.png]]

== Matrizen==
 import numpy as np
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 print(m1)

Ausgabe:
 [[1 2 3]
  [4 5 6]]

=== Zugriff auf Matrizenelemente ===
Beispiel:

 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 
 # Element aus Zeile 2 und Spalte 3 (Achtung! Index startet bei Null)
 print(m1[1,2])

Ausgabe:
 6

Visualisierung:
  
     0   1   2
   +-----------+
 0 | 1 | 2 | 3 |
   +-----------+
 1 | 4 | 5 | '''6''' |
   +-----------+


Beispiel:

 import numpy as np
 
 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
 
 B = np.matrix(A)     
 
 print(B[2::, ::2])

Ausgabe:

 [['20' '22']
  ['30' '32']
  ['40' '42']]

Mit der NumPy-Bibliothek funktioniert das zweidimensionale Slicing. Mit normalen Listen/Tupels geht das nicht, was wir schon früher thematisiert haben.

=== Addition und Subtraktion von Matrizen ===
 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 m2 = np.matrix([[0, 0, 2], [1, 3, 2]])
 
 print(m1 + m2)
 print(m1 - m2)

Ausgabe:
 [[1 2 5]
  [5 8 8]]
 [[1 2 1]
  [3 2 4]]

=== Transponierte Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 2, 3], [4, 5, 6]])
 mt = np.transpose(m) 
 
 print(m)
 print(mt)

Ausgabe:
 [[1 2 3]
  [4 5 6]]
 [[1 4]
  [2 5]
  [3 6]]

=== Rang einer Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 rg = np.linalg.matrix_rank(m)
 
 print(rg)

Ausgabe:
 2

=== Inverse Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 mi = np.linalg.inv(m)
 
 print(mi)

Ausgabe:
 [[ 1.   0.6]
  [-0.  -0.2]]

=== Multiplikation von Matrizen (falksches Schema) ===
 import numpy as np
 
 m1 = np.matrix([[1, 3, 4],  [0, -5, 1]])
 m2 = np.matrix([[1, 2], [2, 3], [0, 2]])
 
 print(m1 @ m2)

Ausgabe:
 [[  7  19]
  [-10 -13]]

=== Eigenwerte und Eigenvektoren ===
 import numpy as np
 
 m = np.matrix([[5, 8],  [1, 3]])
 D,V = np.linalg.eig(m)
 
 # Eigenwerte
 print(D)
 # Eigenvektoren
 print(V)

Ausgabe:
 [7. 1.]
 [[ 0.9701425  -0.89442719]
  [ 0.24253563  0.4472136 ]]

=== Teilmatrizen ===
 import numpy as np
 m = np.matrix([[1, 3, 4],  [0, -5, 1]])
 print(&quot;m = &quot;, m)
 
 # Erste Zeile extrahieren
 m1 = m[0,:]
 print(&quot;m1 = &quot;, m1)
 
 # Das Element aus der 1. Zeile und der 2. Spalte extrahieren
 m2 = m[0,1]
 print(&quot;m2 = &quot;, m2)
 
 # Zweite Spalte extrahieren
 m3 = m[:, 1]
 print(&quot;m3 = &quot;, m3)

Ausgabe:
 m =  [[ 1  3  4]
  [ 0 -5  1]]
 m1 =  [ [1 3 4] ]
 m2 =  3
 m3 =  [[ 3]
  [-5]]

=== Spezielle Matrizen ===
==== Nullmatrix ====
 import numpy as np
 z = np.zeros((3, 2))
 print(z)

Ausgabe:
 [[0. 0.]
  [0. 0.]
  [0. 0.]]

==== Einheitsmatrix ====
 import numpy as np
 z = np.eye(3)
 print(z)

Ausgabe:
 [[1. 0. 0.]
  [0. 1. 0.]
  [0. 0. 1.]]

==== Matrix mit lauter Einsen ====
 import numpy as np
 z = np.ones((3, 2))
 print(z)

Ausgabe:
 [[1. 1.]
  [1. 1.]
  [1. 1.]]

=== Spärlich besetzte Matrizen ===
Das Thema spärlich besetzter Matrizen wird hier nur kurz angerissen. Nähere Details siehe unter dem Weblink  [https://docs.scipy.org/doc/scipy/reference/sparse.html#module-scipy.sparse]. 

Beispiel:

 import numpy as np
 import scipy
 
 A = scipy.sparse.csr_array(np.eye(5))
 
 print(A)

Ausgabe:
 &lt;Compressed Sparse Row sparse array of dtype 'float64'
         with 5 stored elements and shape (5, 5)&gt;
   Coords        Values
   (0, 0)        1.0
   (1, 1)        1.0
   (2, 2)        1.0
   (3, 3)        1.0
   (4, 4)        1.0

csr steht für '''c'''ompressed '''s'''parse '''r'''ow.

Andere Möglichkeiten:
* coo-Format ('''coo'''rdinate Format): &lt;code&gt;scipy.sparse.coo_array()&lt;/code&gt;
* lil-Format ('''li'''st of '''l'''ists): &lt;code&gt;scipy.sparse.lil_array()&lt;/code&gt;
* csc-Format ('''c'''ompressed '''s'''parse '''c'''olumn): &lt;code&gt;scipy.sparse.csc_array()&lt;/code&gt;

Es gibt auch &lt;code&gt;scipy.sparse.csr_matrix()&lt;/code&gt; etc. Diese Befehle sind aber veraltet und es wird empfohlen, statt dessen die &lt;code&gt;..._array()&lt;/code&gt;-Funktionen zu verwenden.

&lt;u&gt;Aufgaben:&lt;/u&gt; 
Recherchieren Sie im Internet 
* generell zum Thema &quot;spärlich besetzte Matrizen mit Python&quot;.
* Was sind die Vor-/Nachteile von csr-arrays gegenüber coo- und lil-arrays?
* Wann verwendet man sinnvollerweise csr- und wann csc-arrays?
* Wie wandelt man coo-arrays in csr-arrays um?

= Lineare Gleichungssysteme =
Sei &lt;math&gt;Ax = b&lt;/math&gt; ein lineares Gleichungssystem. &lt;math&gt;A&lt;/math&gt; sei die Koeffizientenmatrix, &lt;math&gt;x&lt;/math&gt; der Lösungsvektor und &lt;math&gt;b&lt;/math&gt; ein bekannter Vektor.

Beispiel:
 import numpy as np
 
 A = np.array([[5, 1], [0, 2]])
 b = np.array([1, 2])
 
 x = np.linalg.solve(A, b)
 
 print(x)

Ausgabe:
 [0. 1.]

Siehe dazu auch das Kapitel [[Ing Mathematik: Numerisches Lösen von linearen Gleichungssystemen]]. Dort wird dieses Themengebiet u.a. mit weitergehenden Python-Skripten vertieft.

== Aufgabe ==
* Lösen Sie folgendes Gleichungssystem mittels Python (und zur Kontrolle auch händisch): 
 5x + 6y - 2z = 12
 3x - y  - 3z = 6
 2x + 2y + 4z = 5

= Polynome =
== Ein erstes einfaches Beispiel ==
Gegeben sei das Polynom &lt;math&gt;7x^3+5x^2+1&lt;/math&gt;. In Python:

 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p)

Ausgabe:
    3     2
 7 x + 5 x + 1

== Einzelne Polynomwerte berechnen ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p(1.5))

Ausgabe:
 35.875

== Polynome integrieren und differenzieren ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 
 # 1. Ableitung
 p1 = p.deriv()
 p2 = p.deriv(1)
 
 # 2. Ableitung
 p3 = p.deriv(2)
 
 # Integral
 p4 = p.integ()
 
 print(p1)
 print(p2)
 print(p3)
 print(p4)

Ausgabe:
     2
 21 x + 10 x
     2
 21 x + 10 x
 
 42 x + 10
       4         3
 1.75 x + 1.667 x + 1 x

== Nullstellen bestimmen ==
 import numpy as np
 
 p = np.poly1d([2, 5, 0, 4])
 r = np.roots(p)
 
 print(r)

Ausgabe:
 [-2.7621427 +0.j          0.13107135+0.84077099j  0.13107135-0.84077099j]

== Aufgaben ==
* Berechnen Sie den Wert für x = 3 des Polynoms &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Differenzieren und integrieren Sie das Polynom &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Berechnen Sie die Nullstellen von &lt;math&gt;y = 7x^5 - 3x^2 + 12&lt;/math&gt;.

= Nichtlineare Gleichungen und Gleichungssysteme =
== Nullstellenbestimmung ==
Löse eine beliebige Gleichung f(x) = 0, z.B. &lt;math&gt; f(x) = x^2 - 5\cos(x) - 10 = 0 &lt;/math&gt;:
 import scipy
 import numpy as np
 
 def f(x):
     return x**2 - 5*np.cos(x) - 10
    
 xstart = [-1, 1]        # Startwerte
 xn = scipy.optimize.root(f, xstart)
 
 print(xn.x)

Ausgabe:
 [-2.46813009  2.46813009]

Funktionsgraph:

[[Datei:octave_nichtlin2.jpg]]

== Gleichungssysteme ==
SymPy ist ein externes Modul, das symbolisches Rechnen ('''Sym'''bolic '''Py'''thon) ermöglicht. 

Folgende Aufgabe ist dem Buch &quot;Knorrenschild: Numerische Mathematik, Hanser, 2017, Seite 72&quot; entnommen. Zu lösen ist das nichtlineare Gleichungssystem

&lt;math&gt;f_1 = 2x_1 + 4x_2 = 0 &lt;/math&gt;

&lt;math&gt;f_2 = 4x_1 + 8x_2^3 = 0&lt;/math&gt;

Mit Python ist das so möglich:
 import sympy
 
 x1, x2 = sympy.symbols(&quot;x1 x2&quot;) 
 
 f1 = 2*x1 + 4*x2
 f2 = 4*x1 + 8*x2**3
 
 s = sympy.solve((f1, f2), x1, x2) 
 
 print(s)

Ausgabe:
 [(-2, 1), (0, 0), (2, -1)]

Plot:

[[Datei:IngPython_nl_gleichung1.svg|500px]]

= Komplexe Zahlen =
Die imaginäre Einheit wird in Python durch den Buchstaben &lt;code&gt;j&lt;/code&gt; symbolisiert. Darstellen kann man eine komplexe Zahl bekannterweise in mehreren Formen:
* Kartesische Darstellung &lt;math&gt;z = \Re(z) + j \cdot \Im(z)&lt;/math&gt;
* Polardarstellungen &lt;math&gt;z = r \cdot (\cos(\phi) + j \cdot \sin(\phi)) = r \cdot e^{j\cdot \phi}&lt;/math&gt;

Die konjugiert komplexe Zahl ist &lt;math&gt;z^* = \Re(z) - j \cdot \Im(z)&lt;/math&gt;

Nachfolgend einige mathematische Operationen mit Python und NumPy.

 import numpy as np
 
 z1 = 2 + 5j           # kartesische Darstellung
 z2 = 3 * np.exp(3j)   # Polardarstellung
  
 # Addition
 res = z1 + z2
 print(&quot;z1 + z2 = &quot;, res)
 
 # Multiplikation
 res = z1 * z2
 print(&quot;z1 * z2 = &quot;, res)
 
 # Realteil
 res = np.real(z2)
 print(&quot;Realteil von z2 = &quot;, res)
 
 # Imaginärteil
 res = np.imag(z2)
 print(&quot;Imaginaerteil von z2 = &quot;, res)
 
 # Betrag
 res = np.abs(z1)
 print(&quot;Betrag von z1 = &quot;, res)
 
 # Argument
 res = np.angle(z1)
 print(&quot;Argument von z1 = &quot;, res)
 
 # Konjugiert komplexe Zahl
 res = np.conj(z1)
 print(&quot;Konjugiert komplexe Zahl von z1 = &quot;, res)

Ausgabe:
 z1 + z2 =  (-0.9699774898013365+5.423360024179601j)
 z1 * z2 =  (-8.05675510050068-14.003167400647481j)
 Realteil von z2 =  -2.9699774898013365
 Imaginaerteil von z2 =  0.4233600241796016
 Betrag von z1 =  5.385164807134504
 Argument von z1 =  1.1902899496825317
 Konjugiert komplexe Zahl von z1 =  (2-5j)

= Interpolation =
 import numpy as np
 import scipy
 import matplotlib.pyplot as plt
 
 # Stützpunkte
 xp = np.arange(1, 6)
 yp = (0, -5, 2, 7, 6)
 
 ti = np.arange(1, 5, 0.01)
 
 i1 = scipy.interpolate.interp1d(xp, yp, kind = &quot;linear&quot;)
 i2 = scipy.interpolate.interp1d(xp, yp, kind = &quot;cubic&quot;) 
 
 plt.plot(xp, yp, &quot;rx&quot;)
 plt.plot(xp, i1(xp))
 plt.plot(ti, i2(ti))
 plt.show()

Ausgabe:

[[Datei:PythonIng_interpol1.png]]

&lt;code&gt;scipy.interpolate.interp1d()&lt;/code&gt; gilt als veraltet ([https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.interp1d.html]). Stattdessen soll man modernere Alternativen wie &lt;code&gt;scipy.interpolate.Akima1DInterpolator()&lt;/code&gt; oder &lt;code&gt;scipy.interpolate.CubicSpline()&lt;/code&gt; benutzen. Für die lineare Interpolation tut es &lt;code&gt;np.interp()&lt;/code&gt;.

= Differenzialrechnung =
== Numerisches Differenzieren ==
Als Beispiel differenzieren wir &lt;math&gt;y = 5x\sin{x}&lt;/math&gt; und stellen das Ganze grafisch dar.

 from findiff import Diff
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.linspace(0, 10, 1000)
 f = 5 * x * np.sin(x)
 dx = x[1] - x[0]
 
 # Ableitung
 d_dx = Diff(0, dx)
 df_dx = d_dx(f)
 
 # Grafik
 plt.plot(x, f, label = &quot;y&quot;)
 plt.plot(x, df_dx, label = &quot;y'&quot;)
 plt.grid()
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

Ausgabe:

[[Datei:octave_diff1.jpg]]

&lt;small&gt;findiff ist ein externes Modul. Dieses muss installiert werden (z.B. so: ...\Python\Scripts\pip.exe install --upgrade findiff). Für die Vorgehensweise unter openSUSE Tumbleweed siehe das Kapitel [[Ing_Mathematik:_Python#Mit_VPython | VPython]], nur dass das Ganze mit einer aktuelleren Python-Version exekutiert wird, z.B. mit Python 3.13.  Das im Buch &quot;Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler, Rheinwerk&quot; verwendete Modul &quot;scipy.misc&quot; ist veraltet (deprecated ... missbilligt). Lt. [https://docs.scipy.org/doc/scipy-1.17.0/dev/roadmap-detailed.html#misc SciPy-Dokumentation für die Version 1.17.0] wurden alle entsprechenden Features schon entfernt.&lt;/small&gt;

== Symbolisches Differenzieren ==
Differenzieren Sie die Funktionen &lt;math&gt;f_1(x) = x^2&lt;/math&gt; und &lt;math&gt;f_2(x) = \sin(x)\cos\left(\frac{x}{2}\right)&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2;
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 d1 = sympy.diff(f1, x)
 d2 = sympy.diff(f2, x)
 
 print(d1)
 print(d2)

Ausgabe:
 2*x
 -0.5*sin(0.5*x)*sin(x) + cos(0.5*x)*cos(x)

== Aufgaben ==
* Differenzieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.
* Differenzieren Sie die Funktion &lt;math&gt;y = \frac{\sinh(x)}{(1+x)}&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.

= Integralrechnung =
== Numerisches Integrieren ==
Berechnen Sie das Integral &lt;math&gt;\int_{0}^{3}x^2 dx&lt;/math&gt;.

 import scipy
 
 def f(x):
     return x**2
    
 i = scipy.integrate.quad(f, 0, 3)
 print(i)

Ausgabe:
 (9.000000000000002, 9.992007221626411e-14)

Das trifft den exakten Wert 9.0 ziemlich genau.

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} dx&lt;/math&gt;.

 import scipy
 import numpy as np
 
 def f(x):
     return 2**(-x)
   
 i = scipy.integrate.quad(f, 0, np.inf)
 print(i)

Ausgabe:
 (1.4426950408889556, 4.486558477977586e-09)

== Symbolisches Integrieren ==
Berechnen Sie &lt;math&gt;\int x^2 \text{d}x&lt;/math&gt; und &lt;math&gt;\int \sin{x}\cos{\frac{x}{2}} \text{d}x&lt;/math&gt;.
 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 i1 = sympy.integrate(f1, x)
 i2 = sympy.integrate(f2, x)
 
 print(i1)
 print(i2)

Ausgabe:
 x**3/3
 -0.666666666666667*sin(0.5*x)*sin(x) - 1.33333333333333*cos(0.5*x)*cos(x)

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} \text{d}x&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f = 2**(-x)
 i = sympy.integrate(f, (x, 0, sympy.oo))
 print(i)

Ausgabe:
 1/log(2)

&lt;code&gt;sympy.oo&lt;/code&gt; steht für das {{W|Unendlichzeichen}} &lt;math&gt;\infty&lt;/math&gt; (die liegende Acht oder das Möbiusband). Mit &lt;code&gt;sympy.pprint(i)&lt;/code&gt; ließe sich letzere Ausgabe etwas schöner schreiben:

   1   
 ──────
 log(2)

Man beachtete, &lt;code&gt;log&lt;/code&gt; steht hier für den natürlichen Logarithmus &lt;code&gt;ln&lt;/code&gt;.

== Aufgaben ==
* Integrieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; von 1 bis 5.
* Integrieren Sie die Funktion &lt;math&gt;y = x^3&lt;/math&gt; von 0 bis 4.
* Integrieren Sie &lt;math&gt;\int x^x(\log (x) + 1)\mathrm dx&lt;/math&gt; symbolisch.

= Gewöhnliche Differenzialgleichungen =
== DGL numerisch lösen ==
Für die Lösung von Differenzialgleichungen steht u.a. die Funktion scipy.integrate.solve_ivp() zur Verfügung. Diese Funktion implementiert auch das Runge-Kutta-Verfahren (RK45).

{{Wikipedia | Runge-Kutta-Verfahren}}

Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import scipy
 import numpy as np
 import matplotlib.pyplot as plt
 
 def dy_dx(x, y):
     return x**2 + y**3
 
 y0 = [1]
 xi = [0, 1]
 x = np.arange(0, 1, 0.01)
 
 z = scipy.integrate.solve_ivp(dy_dx, xi, y0, method=&quot;RK45&quot;, dense_output=True)
 y = z.sol(x)
 
 plt.plot(x, y.T)
 plt.grid()
 plt.show()

[[Datei:PythonIng_dgl1.png]]

== DGL symbolisch lösen ==
Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 print(lsg)

Ausgabe:
 [Eq(f(x), (-x**2)**(1/3)), Eq(f(x), (-x**2)**(1/3)*(-1 - sqrt(3)*I)/2), Eq(f(x), (-x**2)**(1/3)*(-1 + sqrt(3)*I)/2)]

Mit &lt;code&gt;sympy.pprint&lt;/code&gt; (pretty print) lässt sich die Ausgabe etwas übersichtlicher darstellen.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 sympy.pprint(lsg)

Ausgabe:
 ⎡                           _____                        _____            ⎤
 ⎢          _____         3 ╱   2                      3 ╱   2             ⎥
 ⎢       3 ╱   2          ╲╱  -x  ⋅(-1 - √3⋅ⅈ)         ╲╱  -x  ⋅(-1 + √3⋅ⅈ)⎥
 ⎢f(x) = ╲╱  -x  , f(x) = ────────────────────, f(x) = ────────────────────⎥
 ⎣                                 2                            2          ⎦

== Aufgaben ==
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \frac{1}{x\cdot y}&lt;/math&gt; mit Python. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;m' = -k\cdot m&lt;/math&gt;. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \sqrt{|y|}&lt;/math&gt;.

=Laplace-Transformation=
Laplace-Transformation:

&lt;math&gt;F(s) =\mathcal{L} \left\{f\right\}(s) = \int_{0}^{\infty} f(t) \mathrm e^{-st} \,\mathrm{d}t, \qquad s\in\mathbb{C}
&lt;/math&gt;

Inverse Laplace-Transformation:

&lt;math&gt;\mathcal{L}^{-1} \left\{F\right\}(t)
  = \frac{1}{2 \pi \mathrm j} \int_{ \gamma - \mathrm j \infty}^{ \gamma + \mathrm j \infty} \mathrm e^{st} F(s)\,\mathrm ds 
= \begin{cases}
      f(t) &amp; \text{für } t \geq 0 \\
      0    &amp; \text{für } t &lt; 0
    \end{cases}
&lt;/math&gt;

Siehe auch [[Ing_Mathematik:_Laplace-Transformation]]

Code:
 import sympy
 from sympy.abc import t, s
 
 # Laplace-Transformation der Funktion f(t) = 1 (Heaviside-Fkt.)
 f = 1
 # alternativ: f = sympy.Heaviside(t)
 F = sympy.laplace_transform(f, t, s, noconds=True)
 print(&quot;Laplace-Transformierte F(s):&quot;, F) 
 
 # Inverse Laplace-Transformation zurück in den Zeitbereich
 f_inv = sympy.inverse_laplace_transform(F, s, t)
 print(&quot;Inverse Transformation f(t):&quot;, f_inv)

Ausgabe:
 Laplace-Transformierte F(s): 1/s
 Inverse Transformation f(t): Heaviside(t)

Die Zeile

 from sympy.abc import t, s

steht alternativ für

 t = sympy.symbols(&quot;t&quot;)
 s = sympy.symbols(&quot;s&quot;)

&lt;u&gt;Aufgaben&lt;/u&gt;: Ermitteln Sie mittels SymPy die &lt;math&gt;\mathcal{L}&lt;/math&gt;-Transformierten und dann wieder die  &lt;math&gt;\mathcal{L}^{-1}&lt;/math&gt;-Transformationen (ähnlich wie beim obigen Beispiel):
* &lt;math&gt;\sin(t) \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;t^3 \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;\text{e}^{\omega t} \circ\! -\! \bullet \ ?&lt;/math&gt;

=Fourier-Reihen=
&lt;math&gt;
f(x)\approx \frac{a_{0}}{2}+\sum_{k=1}^{\infty}\left(a_{k}\cos\left(kx\right)+b_{k}\sin\left(kx\right)\right)
&lt;/math&gt;

&lt;math&gt;
a_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\cos\left(kx\right)\mathrm dx\quad\text{für }k\geq0
&lt;/math&gt;

&lt;math&gt;
b_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\sin\left(kx\right)\mathrm dx\quad\text{für }k\geq1
&lt;/math&gt;

Für die Sägezahnfunktion &lt;math&gt;y=x;\, 0 &lt; x &lt; 2\pi&lt;/math&gt; sei die Fourierreihe mit einem Python-Programm (unter Mithilfe von sympy) hergeleitet.

Code:

 from sympy import fourier_series, pi, symbols, pprint
 
 x = symbols('x')
 f = x
 s = fourier_series(f, (x, 0, 2*pi))
 pprint(s.truncate(n=4))

Ausgabe:

                        2⋅sin(3⋅x)    
 -2⋅sin(x) - sin(2⋅x) - ────────── + π
                            3

Siehe auch [[Ing Mathematik: Fourierreihen]].

Ein komplizierteres Beispiel:

[[Datei:IngMath fourier bsp13.svg | 300px]]

&lt;math&gt;0\le t &lt; T/2\text{:}\quad f(t) = H&lt;/math&gt;

&lt;math&gt;T/2 \le t \le T\text{:}\quad f(t) = \frac{2H}{T}\left( t-\frac{T}{2}\right)&lt;/math&gt;

Code:

 import sympy as sp
 
 H = sp.Symbol('H', positive=True)
 T = sp.Symbol('T', positive=True)
 t = sp.Symbol('t')
 
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T/2)),
     (2*H/T*(t-T/2), (t &gt; T/2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Ausgabe:

      ⎛2⋅π⋅t⎞        ⎛4⋅π⋅t⎞        ⎛6⋅π⋅t⎞          ⎛2⋅π⋅t⎞          ⎛6⋅π⋅t⎞      
 H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   2⋅H⋅cos⎜─────⎟   2⋅H⋅cos⎜─────⎟      
      ⎝  T  ⎠        ⎝  T  ⎠        ⎝  T  ⎠          ⎝  T  ⎠          ⎝  T  ⎠   3⋅H
 ──────────── - ──────────── + ──────────── + ────────────── + ────────────── + ───
      π             2⋅π            3⋅π               2                 2         4 
                                                    π               9⋅π

=Rechnen mit wirklich großen Zahlen=
Bekannt ist, dass Python kaum Einschränkungen beim Wertebereich von Ganzzahlen hat, z.B.

 print(10**300)

Ausgabe (gekürzt):

 100000000000000000000...00000000000000000000000000000000000000000000000000000000000000000000000

Ähnliches geht auch mit Gleitpunktzahlen, z.B. durch die Verwendung des Moduls [https://mpmath.org/ mpmath]:

 import mpmath
 print(mpmath.mpf(1500.4)**mpmath.mpf(300))

Ausgabe:

 7.27975299218612e+952

Anderes Beispiel:

 from mpmath import mp, pi
 mp.dps = 100
 print(pi)

Ausgabe:

 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068

mpmath kann noch einiges mehr, dazu sei aber auf die entsprechende Dokumentation auf der mpmath-Homepage verwiesen. mpmath ist Bestandteil von SymPy, kann aber auch separat installiert werden.

Aber auch Python selbst besitzt eine Möglichkeit, um mit großen bzw. exakten Gleitpunktzahlen zu rechnen, nämlich das interne Modul decimal. Dieses hat einige Vorteile gegenüber mpmath, aber auch gravierende Nachteile. Diese seien hier nicht detailliert aufgezählt. Grob gesagt hat decimal im Finanzwesen seine Berechtigung. Für wissenschaftliche Anwendungen wird aber mpmath vorzuziehen sein, da es u.a. vielfältige mathematische Funktionen bereit stellt. Nachfolgend ein einfaches Beispiel mit decimal:

 import decimal
 print(&quot;Potenzierung:&quot;, decimal.Decimal(1500.4) ** decimal.Decimal(300.0))
 print(&quot;Einfache Addition:&quot;, 0.1 + 0.2)
 decimal.getcontext().prec = 50
 print(&quot;Addition mit decimal:&quot;, decimal.Decimal(&quot;0.1&quot;) + decimal.Decimal(&quot;0.2&quot;))

Ausgabe:

 Potenzierung: 7.279752992186121551039839134E+952
 Einfache Addition: 0.30000000000000004
 Addition mit decimal: 0.3

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet die genauen Vor- und Nachteile von decimal und mpmath. Verwenden Sie dazu auch KI (z.B. von Google, chatgpt).

= pint - mit physikalischen Größen rechnen = 
[[File:Pint-Glas_UK.jpg|right|100px]]
pint ist ein externes Python-Paket zur Manipulation von physikalischen Einheiten. Es muss vor der ersten Benutzung installiert werden (Vorgehensweise wie immer: pip, YaST, via venv etc.).

Beispiel:

 import pint
 import numpy as np
 
 ureg = pint.UnitRegistry()
 
 # Einfache Berechnung
 print(3 * ureg.meter + 4 * ureg.cm)
 
 # Mit NumPy
 npeinzel = [3, 4] * ureg.meter + [2, 5] * ureg.cm
 print(npeinzel)
 npsum = np.sum(npeinzel)
 print(npsum)
 
 # Konvertierung von Einheiten
 npsum_inch = npsum.to(ureg.inch)
 print(npsum_inch)
 
 print(npeinzel.magnitude)
 print(npeinzel.units)
 print(npeinzel.dimensionality)

Ausgabe:

 3.04 meter
 [3.02 4.05] meter
 7.07 meter
 278.3464566929134 inch
 [3.02 4.05]
 meter
 [length]

Die Dokumentation zu pint findet sich auf [https://pint.readthedocs.io/en/stable/].

=Regelungstechnische Aufgabenstellungen=
Für regelungstechnische Aufgaben gibt es u.a. das externe Paket &lt;code&gt;control&lt;/code&gt;. Hier soll nicht detailliert darauf eingegangen werden. Anhand eines Beispiels soll anschließend nur die Visualisierung in Form eines Bode-Diagramms und der Sprungantwort gezeigt werden. Gegeben sei ein P-Regler mit &lt;math&gt;R = \frac{5}{2}&lt;/math&gt; und eine Strecke &lt;math&gt;S= \frac{1}{30s^3+20s^2+10s+1,5}&lt;/math&gt;. Gesucht sei vorerst ein Bode-Diagramm für den offenen Regelkreis und das Führungsverhalten.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke  # oder: G0 = ct.series(regler, strecke)
 Gw = ct.feedback(G0)
 
 ct.bode_plot(G0, label='G0')
 ct.bode_plot(Gw, label='Gw')
 plt.show()

[[Datei:PythonIng_bode1.svg]]

Nun noch für obiges Beispiel die Sprungantwort. Diese zeigt einige große Überschwinger, d.h. der Regler kann sicher noch optimiert werden.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke 
 Gw = ct.feedback(G0) 
 
 t, y = ct.step_response(Gw)
 
 plt.plot(t,y)
 plt.title('Sprungantwort')
 plt.xlabel('t')
 plt.ylabel('h(t)')
 plt.grid()
 plt.show()

[[Datei:PythonIng_bode3.svg]]

Einige weitere wichtige Daten (Phasenreserve, Amplitudenreserve, Durchtrittsfrequenz) lassen sich mittels der &lt;code&gt;control&lt;/code&gt;-Funktion &lt;code&gt;margin()&lt;/code&gt; ermitteln. Die Ortskurve lässt sich mit der Funktion &lt;code&gt;nyquist_plot()&lt;/code&gt; zeichnen. Dies sei hier aber nicht weiter ausgeführt.

==Aufgaben==
* Zeichen Sie mit Python die Ortskurve für obiges Beispiel.
* Was passiert, wenn man die Reglerverstärkung weiter aufdreht (z.B. auf &lt;math&gt;R = \frac{25}{2}&lt;/math&gt;)?
* Wie sehen das Bode-Diagramm und die Sprungantwort aus, wenn ein PI-Regler verwendet wird?

= Stereostatik etc. =
Das Modul SymPy bietet einige Möglichkeiten einfache Bauwerke zu berechnen, z.B. Balken oder Fachwerke. Nachfolgend wird ein einfaches Fachwerk berechnet und gezeichnet.

Python-Code:
 from sympy.physics.continuum_mechanics.truss import Truss 
 
 t = Truss()
 # Knoten
 t.add_node((&quot;A&quot;, -3, 0), (&quot;B&quot;, 0, 0), (&quot;C&quot;, 4, 0), (&quot;D&quot;, 7, 0),
            (&quot;E&quot;, 6, 1.5), (&quot;F&quot;, 2, 3), (&quot;G&quot;, -2, 1.5))
 # Stäbe
 t.add_member((&quot;AB&quot;,&quot;A&quot;,&quot;B&quot;), (&quot;BC&quot;,&quot;B&quot;,&quot;C&quot;), (&quot;CD&quot;,&quot;C&quot;,&quot;D&quot;))
 t.add_member((&quot;AG&quot;,&quot;A&quot;,&quot;G&quot;), (&quot;GB&quot;,&quot;G&quot;,&quot;B&quot;), (&quot;GF&quot;,&quot;G&quot;,&quot;F&quot;))
 t.add_member((&quot;BF&quot;,&quot;B&quot;,&quot;F&quot;), (&quot;FC&quot;,&quot;F&quot;,&quot;C&quot;), (&quot;CE&quot;,&quot;C&quot;,&quot;E&quot;))
 t.add_member((&quot;FE&quot;,&quot;F&quot;,&quot;E&quot;), (&quot;DE&quot;,&quot;D&quot;,&quot;E&quot;))
 # Auflager; roller ... Loslager, pinned ... Festlager
 t.apply_support((&quot;A&quot;,&quot;roller&quot;), (&quot;D&quot;,&quot;pinned&quot;))
 # Einwirkende Kräfte
 t.apply_load((&quot;G&quot;, 5, 270), (&quot;E&quot;, 3, 90))
 
 # Berechnung 
 t.solve()
 print(&quot;Reaction Forces: &quot;, t.reaction_loads)
 print(&quot;Internal Forces: &quot;, t.internal_forces)
 
 # Fachwerk zeichnen
 p = t.draw()
 p.show()

Ausgabe auf der Konsole:

 Reaction Forces:  {'R_A_y': 4.20000000000000, 'R_D_x': 0, 'R_D_y': -2.20000000000000}
 Internal Forces:  {'AB': 2.80000000000000, 'BC': 0.333333333333333, 'CD': -1.46666666666667, 
 'AG': -5.04777178564958, 'GB': -2.05555555555556, 'GF': -1.23413387432364, 
 'BF': 0.411111111111111*sqrt(13), 'FC': -0.3*sqrt(13), 'CE': 1.50000000000000, 
 'FE': 0.284800124843917, 'DE': 2.64407093534026}

Zeichnung:

[[File:PythonIng_fachwerk1.svg|300px]]

Details zu diesem Thema siehe z.B. [https://docs.sympy.org/latest/modules/physics/continuum_mechanics/index.html Continuum Mechanics] oder [https://docs.sympy.org/latest/tutorials/physics/continuum_mechanics/index.html Continuum Mechanics Tutorials]. Auch andere mechanische Probleme werden von SymPy abgehandelt ([https://docs.sympy.org/latest/tutorials/physics/index.html Physics Tutorials]).

== Aufgabe ==
Gegeben sei ein einseitig eingespannter Kragträger. Belastet wird er durch eine Einzellast am Trägerende. Für die Daten siehe folgende ASCII-Skizze:

                            | 20 kN  
    //|---&gt; x               |
    //|                     V
    //|----------------------
    //|         10 m        |
 
 Elastizitätsmodul E = 2,1*10⁵ N/mm²
 Flächenträgheitsmoment I = 0.001 m⁴

Berechnen Sie die Auflagerreaktionen, den Querkraft- und Biegemomentenverlauf, sowie die Verformungen.
Stellen Sie dies mit Hilfe von SymPy graphisch und auch mittels Formeln dar. Verwenden Sie dazu auch pprint (pretty print) aus dem SymPy-Modul. Zwecks Lösungsansatz siehe die oben aufgeführte Seite &quot;Continuum Mechanics Tutorials&quot;. Achten Sie auch auf die Einheiten! Kontrollieren Sie das Ganze mittels händischer Rechnung. In dem genannten Tutorial ist von &quot;Singularity Functions&quot; die Rede. Gemeint ist damit in diesem Kontext die {{W|Föppl-Klammer}}.

Einige Python-Programme, vorrangig zu Maschinenelementen, finden sich auf [https://baymp.de/download_python.html BayMP für Python] (Balken, Zahnräder, Stabknickung usw.).

=Thermodynamik= 
== PYroMat ==
Für thermodynamische Aufgabenstellungen gibt es verschiedene externe Module. Eines davon ist PYroMat (siehe auch [http://pyromat.org]). Damit lassen sich thermodynamische Stoffdaten für viele Substanzen berechnen.

Beispiel (einige Stoffdaten für Wasser bei 400°C und 20 bar berechnen):

 import pyromat as pm
 
 # Wasserdaten laden:
 H2O = pm.get('mp.H2O')
 
 # Stoffdaten berechnen:
 T = 673.15  # Temperatur in Kelvin
 p = 20      # Druck in bar
 v = H2O.v(T, p)
 h = H2O.h(T, p)
 s = H2O.s(T, p)
 print(f&quot;Spezifisches Volumen: {v} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {h} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {s} kJ/(kg K)&quot;)

Ausgabe:

 Spezifisches Volumen: [0.1512163] m³/kg
 Spezifische Enthalpie: [3248.3789473] kJ/kg
 Spezifische Entropie: [7.12924142] kJ/(kg K)

&lt;small&gt;
PYroMat muss vorab installiert werden (z.B. mittels pip, in eine virtuelle Umgebung)
&lt;/small&gt;

&lt;code&gt;mp&lt;/code&gt; steht für &quot;multi phase&quot;. Für ein ideales Gas wäre &lt;code&gt;ig&lt;/code&gt; zuständig, z.B. &lt;code&gt;'ig.O2'&lt;/code&gt;.

Beispiel (T-s-Diagramm für Wasser zeichnen):
 import numpy as np
 import matplotlib.pyplot as plt
 import pyromat as pm
 
 # Konfigurieren
 pm.config[&quot;unit_pressure&quot;] = &quot;bar&quot;
 pm.config[&quot;unit_temperature&quot;] = &quot;K&quot;
 fluid = pm.get(&quot;mp.H2O&quot;)
 
 # Temperaturbereich für das Nassdampfgebiet
 T_tripel = 273.16
 T_crit = 647.096
 T = np.linspace(T_tripel, T_crit - 0.1, 200)
 
 # Sättigungslinien berechnen und zeichnen
 for x in np.linspace(0.0, 1.0, 5):
     s = fluid.s(T=T, x=x)
     if(x&lt;=0.0):
         plt.plot(s, T, label=&quot;Siedelinie x=%3.1f&quot; % x, linewidth=2.0)
     elif(x&gt;=1.0):
         plt.plot(s, T, label=&quot;Taulinie x=%3.1f&quot; % x, linewidth=2.0)
     else:
         plt.plot(s, T, label=&quot;x=%3.1f&quot; % x, linewidth=1.0)
 
 # Isobaren zeichnen
 p_values = [0.1, 1, 10, 50, 100]
 T_isobar = np.linspace(T_tripel, 1000, 200)
 t = 0.7
 
 for p in p_values:
     s_iso = fluid.s(T=T_isobar, p=p)
     plt.plot(s_iso, T_isobar, 'k-', alpha=0.8, linewidth=0.8)
 
     t += .05
     idx = int(len(s_iso) * t)
     plt.text(s_iso[idx], T_isobar[idx], f&quot;{p} bar&quot;, fontsize=9, alpha=0.8)
 
 # Diagramm zeichnen
 plt.title(&quot;T-s-Diagramm für Wasser&quot;)
 plt.xlabel(&quot;Spezifische Entropie s in kJ/kg K&quot;, fontsize=10)
 plt.ylabel(&quot;Temperatur T in K&quot;, fontsize=10)
 plt.legend(loc=&quot;best&quot;)
 plt.grid(True)
 plt.show()

Ausgabe (in etwa so):

[[Datei:T-s-Diagramm fuer Wasser.svg|400px]]

== CoolProp ==
Auch mit CoolProp können Stoffdaten berechnet werden. Siehe auch [https://coolprop.org/coolprop/wrappers/Python/index.html]

Beispiel (Wasser bei 20bar und 400°C):
 import CoolProp.CoolProp as CP
 
 fluid = 'Water'
 T = 673.15   # Temperatur in Kelvin
 P = 20e5     # Druck in Pascal
 
 dichte = CP.PropsSI('D', 'T', T, 'P', P, fluid)
 enthalpie = CP.PropsSI('H', 'T', T, 'P', P, fluid)
 entropie = CP.PropsSI('S', 'T', T, 'P', P, fluid)
 
 print(f&quot;Spez. Volumen: {1/dichte:.6f} m³/kg&quot;)
 print(f&quot;Spez. Enthalpie: {enthalpie:.2f} J/kg&quot;)
 print(f&quot;Spez. Entropie: {entropie:.2f} J/kgK&quot;)

Ausgabe:
 Spez. Volumen: 0.151215 m³/kg
 Spez. Enthalpie: 3248344.02 J/kg
 Spez. Entropie: 7129.16 J/kgK

== iapws ==
Um Werte für Wasser(dampf) zu erhalten (IAPWS; '''I'''nternational '''A'''ssociation for the '''P'''roperties of '''W'''ater and '''S'''team) gibt es die Bibliothek iapws. Siehe auch [https://iapws.org/] und [https://pypi.org/project/iapws/]

Beispiel (Wasser für 20bar und 400°C):
 from iapws import IAPWS97
 
 dampf = IAPWS97(P=2.0, T=673.15)
 
 print(f&quot;Spezifisches Volumen: {dampf.v:.6f} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {dampf.h:.2f} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {dampf.s:.4f} kJ/(kgK)&quot;)
 print(f&quot;Phase: {dampf.phase}&quot;)

Ausgabe:
 Spezifisches Volumen: 0.151208 m³/kg
 Spezifische Enthalpie: 3248.23 kJ/kg
 Spezifische Entropie: 7.1290 kJ/(kgK)
 Phase: Gas

== TESPy ==
Ein anderes Modul für einen anderen Aufgabenzweck ist TESPy ('''T'''hermal '''E'''ngineering '''S'''ystems in '''Py'''thon). Dieses Modul ist für die Anlagensimulation zuständig. Für nähere Informationen siehe [https://tespy.readthedocs.io/en/main/getting_started/introduction.html]. Als Beipiel sei hier vorerst Code, der von der Google KI generiert wurde, angeführt. Der Code wurde überarbeitet, damit keine Warnungen auftreten. Bitte aber den Code trotzdem mit Vorsicht genießen, auch KI-generierter Code kann Fehler aufweisen. Eine Pumpe wird berechnet:

 from tespy.components import Sink, Source, Pump
 from tespy.connections import Connection
 from tespy.networks import Network
 
 # 1. Netzwerk definieren (Zentrales Steuerungselement)
 # Wir wählen Wasser als Fluid und bar/Celsius als Einheiten
 nw = Network(fluids=[&quot;water&quot;])
 nw.units.set_defaults(pressure=&quot;bar&quot;, pressure_difference=&quot;bar&quot;, 
                       temperature=&quot;°C&quot;, enthalpy=&quot;kJ / kg&quot;)
 
 # 2. Komponenten erstellen
 eingang = Source(&quot;Wasserquelle&quot;)
 ausgang = Sink(&quot;Wasserspeicher&quot;)
 pumpe = Pump(&quot;Speisewasserpumpe&quot;)
 
 # 3. Verbindungen definieren (Komponenten miteinander verknüpfen)
 c1 = Connection(eingang, &quot;out1&quot;, pumpe, &quot;in1&quot;)
 c2 = Connection(pumpe, &quot;out1&quot;, ausgang, &quot;in1&quot;)
 
 # Verbindungen dem Netzwerk hinzufügen
 nw.add_conns(c1, c2)
 
 # 4. Randbedingungen und Parameter festlegen
 # Zustand am Eingang (Druck, Temperatur, Massenstrom, Fluid-Zusammensetzung)
 c1.set_attr(
     v=1,  # Massenstrom: 1 kg/s
     T=20,  # Temperatur: 20 °C
     p=1,  # Druck: 1 bar
     fluid={&quot;water&quot;: 1},  # 100% Wasser
 )
 
 # Zustand am Ausgang / Zielwerte der Pumpe
 c2.set_attr(p=10)  # Ziel-Druck nach der Pumpe: 10 bar
 
 # Pumpeneigenschaften festlegen
 pumpe.set_attr(eta_s=0.8)  # Isentroper Wirkungsgrad von 80%
 
 # 5. Simulation ausführen
 nw.solve(mode=&quot;design&quot;)
 
 # 6. Ergebnisse ausgeben
 nw.print_results()
 
 # Spezifische Werte direkt auslesen
 print(&quot;\n--- Auswertung ---&quot;)
 print(f&quot;Erforderliche Pumpenleistung: {pumpe.P.val / 1000:.2f} kW&quot;)
 print(f&quot;Temperatur nach der Pumpe: {c2.T.val:.2f} °C&quot;)

Ausgabe (gekürzt):
  iter  | residual   | progress   | massflow   | pressure   | enthalpy   | fluid      | component  
 -------+------------+------------+------------+------------+------------+------------+------------
  1     | 7.04e+04   | 12 %       | 9.96e+02   | 0.00e+00   | 8.81e+04   | 0.00e+00   | 0.00e+00   
  2     | 5.91e-12   | 100 %      | 1.11e-13   | 0.00e+00   | 7.39e-12   | 0.00e+00   | 0.00e+00   
  3     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
  4     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
 Total iterations: 4, Calculation time: 0.01 s, Iterations per second: 480.85
 
 ##### RESULTS (Pump) #####
 +-------------------+----------+----------+-----------+----------+----------+----------+
 |                   |        P |       pr |        dp |      eta |    eta_s |     head |
 |-------------------+----------+----------+-----------+----------+----------+----------|
 | Speisewasserpumpe | 1.12e+06 | 1.00e+01 | -9.00e+00 | 8.00e-01 | 8.00e-01 | 9.19e+01 |
 +-------------------+----------+----------+-----------+----------+----------+----------+
 ...
 ...
 --- Auswertung ---
 Erforderliche Pumpenleistung: 1124.77 kW
 Temperatur nach der Pumpe: 20.07 °C

= Stochastik =
Die {{W|Stochastik}} ist ein sehr weites Feld. Hier werden etliche wichtige Themen kurz angerissen. Python stellt mit den Moduln math und statistics Software zu diesem Zwecke bereit. math und statistics sind bereits im Lieferumfang von Python enthalten. Aber auch mit den externen Modulen NumPy, SciPy, stochastic und pandas kann man Stochastik in Python betreiben. Die Theorie der Wahrscheinlichkeitsrechnung und Statistik soll etwas später in Band 5 dieser Buchreihe behandelt werden.

== Lageparameter == 
 import statistics
 
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 
 m1 = statistics.mean(werte)
 m2 = statistics.mode(werte)
 m3 = statistics.median(werte)
 
 print(&quot;Arithmetischer Mittelwert = &quot;, m1)
 print(&quot;Modalwert = &quot;, m2)
 print(&quot;Median = &quot;, m3)

Ausgabe:
 Arithmetischer Mittelwert =  3.5
 Modalwert =  1
 Median =  3.0

== Streuungsparameter ==
Beispiel (Berechnung der Standardabweichung):
 import statistics
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 s = statistics.stdev(werte)
 print(&quot;Standardabweichung = &quot;, s)

Ausgabe:
 Standardabweichung =  2.6770630673681683

Beispiel (Berechnung des Variationskoeffizienten V = Standardabweichung/Mittelwert)
 import numpy as np
 from scipy import stats
 import statistics
 
 k = 50
 
 dat1 = [14, 21, 18, 25, 30, 17, 20]
 dat = np.array(dat1)
 
 # Mit SciPy
 v = stats.variation(dat)
 vddof = stats.variation(dat, ddof=1)
 print(&quot;V SciPy: &quot;, v)
 print(&quot;V DDOF SciPy: &quot;, vddof)
 print(k*&quot;-&quot;)
 
 # mit NumPy
 mittelwert1 = np.mean(dat)
 std_abw1 = np.std(dat)
 std_abw1ddof = np.std(dat, ddof=1) 
 v1= std_abw1 / mittelwert1
 v1ddof = std_abw1ddof / mittelwert1
 print(&quot;Mittelwert NumPy: &quot;, mittelwert1)
 print(&quot;Std.abw. NumPy: &quot;, std_abw1)
 print(&quot;Std.abw. DDOF NumPy: &quot;, std_abw1ddof)
 print(&quot;V NumPy: &quot;, v1)
 print(&quot;V DDOF NumPy: &quot;, v1ddof)
 print(k*&quot;-&quot;)
 
 # nur mit reinem Python
 mittelwert2 = statistics.mean(dat1)
 std_abw2 = statistics.stdev(dat1)
 v2 = std_abw2 / mittelwert2
 print(&quot;Mittelwert Python: &quot;, mittelwert2)
 print(&quot;Std.abw. Python: &quot;, std_abw2)
 print(&quot;V Python:&quot;, v2)
 print(k*&quot;-&quot;)

Ausgabe:
 V SciPy:  0.23890355966467272
 V DDOF SciPy:  0.25804533701889254
 --------------------------------------------------
 Mittelwert NumPy:  20.714285714285715
 Std.abw. NumPy:  4.948716593053935
 Std.abw. DDOF NumPy:  5.3452248382484875
 V NumPy:  0.23890355966467272
 V DDOF NumPy:  0.2580453370188925
 --------------------------------------------------
 Mittelwert Python:  20.714285714285715
 Std.abw. Python:  5.3452248382484875
 V Python: 0.2580453370188925
 --------------------------------------------------

Der Unterschied bei der Standardabweichung zwischen reinem Python und den externen Bibliotheken SciPy und NumPy entsteht dadurch, dass einmal durch (n-1) und das andere Mal nur durch n dividiert wird. Dies kann bei NumPy und SciPy dadurch entschärft werden, indem &lt;code&gt;ddof=1&lt;/code&gt; gesetzt wird. ddof steht für '''D'''elta '''D'''egrees '''o'''f '''F'''reedom. &lt;small&gt;Je größer die Anzahl der Datensätze n wird, umso weniger spielt das eine Rolle.&lt;/small&gt;

== Kombinatorik ==
Beispiel:

 import math
 
 n = 7
 k = 5
 
 print(&quot;n! = &quot;, math.factorial(n))
 print(&quot;Kombinationen (n über k) = &quot;, math.comb(n, k))

Ausgabe:
 n! =  5040
 Kombinationen (n über k) =  21

Siehe zu diesem Thema auch [[Ing Mathematik: Permutationen, Kombinationen, binomischer Lehrsatz]]. Die Anzahlen lassen sich einfach aus den dortigen Formeln ermitteln, z.B. bei Permutationen mit &lt;math&gt;n!&lt;/math&gt; oder Variationen mit Wiederholungen als &lt;math&gt;n^k&lt;/math&gt;. Will man die Kombinationen oder Variationen aber auch als Liste ausgeben, so kann das Modul &lt;code&gt;itertools&lt;/code&gt; nützlich sein.  

Beispiel (Variationen ohne Wiederholung):

 from itertools import permutations
 
 menge = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]  # n = 4
 k = 3
 
 variationen = list(permutations(menge, k))
 
 for v in variationen:
     print(&quot;&quot;.join(v))
 
 print(50*&quot;-&quot;)
 print(len(variationen))

Ausgabe (gekürzt):
 ABC
 ABD
 ACB
 ...
 DCA
 DCB
 --------------------------------------------------
 24

Siehe zum Modul &lt;code&gt;itertools&lt;/code&gt; auch die Website [https://docs.python.org/3/library/itertools.html].

* Variationen mit Wiederholung: &lt;code&gt;itertools.product()&lt;/code&gt;
* Kombinationen ohne Wiederholung: &lt;code&gt;itertools.combinations()&lt;/code&gt;
* Kombinationen mit Wiederholung: &lt;code&gt;itertools.combinations_with_replacement()&lt;/code&gt;

== Zufallszahlen ==
Beispiel:
 import random
 
 # Ganzzahlige Zufallszahl von 1 bis 10
 zufallszahl1 = random.randint(1, 10)
 
 # Gleitpunktzahlen
 # zwischen 0.0 und 1.0
 zufallszahl2 = random.random()
 # Zahl zwischen 1.5 und 9.5
 zufallszahl3 = random.uniform(1.5, 9.5)
 
 # aus Liste auswählen
 farbe = [&quot;Rot&quot;, &quot;Grün&quot;, &quot;Blau&quot;]
 zufallswert = random.choice(farbe)
 
 print(zufallszahl1)
 print(zufallszahl2)
 print(zufallszahl3)
 print(zufallswert)

Ausgabe, z.B.:
 5
 0.14147945849015753
 6.894003397570905
 Rot

Benötigt man mehrere Zufallszahlen, so ist das Modul &lt;code&gt;numpy&lt;/code&gt; zu bevorzugen, z.B.:
* Normalverteilung: &lt;code&gt;np.random.normal(...)&lt;/code&gt;
* Gleichverteilung: &lt;code&gt;np.random.uniform(...)&lt;/code&gt;

== Histogramm ==
Zum Thema Histogramm siehe {{W|Histogramm}}.

Beispiel (mit Matplotlib):

 import matplotlib.pyplot as plt
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 
 plt.hist(daten, bins=25, edgecolor='darkgray')
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm.svg|300px]]

Beispiel (mit Seaborn):

 import matplotlib.pyplot as plt
 import seaborn as sns
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 sns.set_theme(style=&quot;darkgrid&quot;)
 sns.histplot(data=daten)
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm2.svg|300px]]

Das Kürzel &lt;code&gt;sns&lt;/code&gt; ist Konvention und steht für die fiktive Figur '''S'''amuel '''N'''orman '''S'''eaborn aus der US-Fernsehserie {{W|The West Wing – Im Zentrum der Macht | The West Wing}}.

== Box-Plot ==
[[File:Elements of a boxplot.svg|400px]]

Siehe auch {{W|Box-Plot}}.

Beispiel (mit Seaborn erstellt):
 import seaborn as sns
 import matplotlib.pyplot as plt
 
 df = sns.load_dataset(&quot;tips&quot;)
 sns.boxplot(data=df, x=&quot;day&quot;, y=&quot;tip&quot;, hue=&quot;day&quot;, legend=False)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot.svg|400px]]

Beispiel (mit Matplotlib erstellt):

 import matplotlib.pyplot as plt
 
 daten = [12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25]
 
 plt.boxplot(daten, patch_artist=True)
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot2.svg|300px]]

Um mehrere Box-Plots unterschiedlicher Farbe mit Matplotlib in einem Diagramm zu zeichnen, können Sie folgendermaßen vorgehen:

 import matplotlib.pyplot as plt
 
 daten = [[12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25],
          [10, 19, 20, 21, 20, 30, 19, 40, 11, 17, 19, 21]]
 
 farben = [&quot;green&quot;, &quot;blue&quot;]
 
 boxplot = plt.boxplot(daten, patch_artist=True)
 
 for patch, farbe in zip(boxplot['boxes'], farben):
     patch.set_facecolor(farbe)
 
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

== Regressionsrechnung ==
Beispiel:
 import numpy as np
 import matplotlib.pyplot as plt
 
 # Messpunkte
 x = np.array([1, 3, 5, 6, 8, 10, 20])
 y = np.array([3, 4, 5, 5, 7, 9, 11])
 
 # Regressionskurve (Grad 1 = lineare Regression, 2 = Polynom-Regression 2. Gr.)
 # y = kx + d
 k, d = np.polyfit(x, y, deg=1)
 # y = ax**2 + bx + c
 a, b, c = np.polyfit(x, y, deg=2)
 
 x_l = np.linspace(1, 20, 100)
 y_p = a * x_l**2 + b * x_l + c
 
 # Zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.plot(x, k*x + d, color='blue', label='Regressionsgerade')
 plt.plot(x_l, y_p, color='red', label='Regressionspolynom 2. Gr.')
 plt.xlabel('x')
 plt.ylabel('y')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_regression.svg|400px]]

== Korrelationsrechnung ==
Beispiel:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 # Messdaten
 x = [1, 3, 4, 5, 6]
 y = [2, 4, 6, 8, 5]
 
 daten = {'X': x, 'Y': y}
 df = pd.DataFrame(daten)
 
 # Korrelation
 korr = df['X'].corr(df['Y'])
 print(f&quot;Korrelationskoeff.: {korr}&quot;) 
 
 # Messpunkte zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:
 Korrelationskoeff.: 0.7556096518348252

[[Datei:IngMath_korrelation.svg|300px]]

== Mengen und Venn-Diagramme ==
Beispiel: 
 import matplotlib.pyplot as plt
 from matplotlib_venn import venn2
 
 menge_a = {1, 2, 3, 4, 5, 6}
 menge_b = {4, 5, 6, 7, 8}
 
 vereinigung = menge_a | menge_b
 schnitt = menge_a &amp; menge_b
 print(&quot;Vereinigungsmenge = &quot;, vereinigung)
 print(&quot;Schnittmenge = &quot;, schnitt)
 
 venn2([menge_a, menge_b], set_labels=('Menge A', 'Menge B'))
 plt.show()

Ausgabe:
 Vereinigungsmenge =  {1, 2, 3, 4, 5, 6, 7, 8}
 Schnittmenge =  {4, 5, 6}

[[Datei:IngMath_venn.svg|300px]]

Siehe auch {{W|Mengendiagramm#Venn-Diagramme}}.

== Verteilungs- und Dichtefunktion ==
* CDF ... '''C'''umulative '''D'''istribution '''F'''unction, Verteilungsfunktion
* PDF ... '''P'''robability '''D'''ensity '''F'''unction, Dichtefunktion

Beispiel (Normalverteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 from scipy.stats import norm
 
 my, sigma = 0, 1
 x = np.linspace(-4, 4, 50)
 
 pdf = norm.pdf(x, my, sigma)
 cdf = norm.cdf(x, my, sigma)
 
 plt.plot(x, pdf, lw=2, label=&quot;Dichtefunktion&quot;)
 plt.plot(x, cdf, lw=2, label=&quot;Verteilungsfunktion&quot;)
 plt.legend()
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:IngMath_cdf_pdf.svg|300px]]

Beispiel (&lt;math&gt;\chi^2&lt;/math&gt;-Verteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 import scipy.stats as stats
 
 x = np.linspace(0, 20, 500)
 
 # df ... degree of freedom, Freiheitsgrad
 pdf = (stats.chi2.pdf(x, df=2), stats.chi2.pdf(x, df=5), stats.chi2.pdf(x, df=10))
 
 for i in range(0,3):
     if(i==0):
         lab = &quot;Freiheitsgrad 2&quot;
     elif(i==1):
         lab = &quot;Freiheitsgrad 5&quot;
     else:
         lab = &quot;Freiheitsgrad 10&quot;
 
     plt.plot(x, pdf[i], label=lab, lw=2)
 
 plt.grid()
 plt.legend()
 plt.show()

Ausgabe:

[[Datei:IngMath_chi2.svg | 300px]]

== Schätzen und Testen ==
=== Intervallschätzung ===
Als Beispiel seien Daten gegeben, die von ''Dürr, Mayer: Wahrscheinlichkeitsrechnung und Schließende Statistik; 7. Aufl., Hanser, 2014, Seite 137'' stammen. Und zwar soll das 95%-Vertrauensintervall für den Mittelwert des Kaloriengehalts (kcal/100g) von Hähnchen ermittelt werden. Wir wollen das mit Python inkl. NumPy und SciPy durchführen. Die Stichprobe ist groß (50 Hähnchen):

Python-Code:
 import numpy as np
 import scipy.stats as stats
 
 # Stichprobe
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203]
 
 # Parameter definieren
 konfidenzniveau = 0.95
 mean = np.mean(daten)
 std = np.std(daten, ddof=1)
 stdfehler = stats.sem(daten)
 
 intervall = stats.norm.interval(confidence=konfidenzniveau, loc=mean, scale=stdfehler)
 
 print(f&quot;Mittelwert: {mean}&quot;)
 print(f&quot;Standardabweichung: {std}&quot;)
 print(f&quot;Konfidenzintervall: {intervall}&quot;)

Ausgabe:
 Mittelwert: 215.48
 Standardabweichung: 33.14238915925757
 Konfidenzintervall: (np.float64(206.29356722321992), np.float64(224.66643277678006))

Diese Werte stimmen gerundet mit denen im genannten Buch überein. Zum Code selbst:
* sem steht für '''s'''tandard '''e'''rror of the '''m'''ean.
* &lt;code&gt;scipy.stats.norm&lt;/code&gt; ... Modul für die Normalverteilung.

=== Punktschätzung ===
Gleiche Daten wie oben bei der Intervallschätzung.

Python-Code:
 import numpy as np
 from scipy import stats
 
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203
         ]
 
 mu_hat, sigma_hat = stats.norm.fit(daten) 
 
 print(f&quot;Schätzer für den Erwartungswert (μ): {mu_hat:.4f}&quot;)
 print(f&quot;Schätzer für die Standardabweichung (σ): {sigma_hat:.4f}&quot;)

Ausgabe:
 Schätzer für den Erwartungswert (μ): 215.4800
 Schätzer für die Standardabweichung (σ): 32.8093

=== Hypothesentests ===
Beispiel:

 import numpy as np
 import scipy.stats as stats
 
 x_quer = 12.075      # Stichproben-Mittelwert
 var    = 0.069       # Stichproben-Varianz
 n      = 90          # Stichprobengröße
 my_0   = 12.0        # Nullhypothese
 alpha  = 0.05        # Signifikanzniveau
 
 z_stat = (x_quer - my_0) / np.sqrt(var / n)
 p_val = 2 * (1 - stats.norm.cdf(np.abs(z_stat)))
 
 print(f&quot;Z-Statistik: {z_stat:.4f}&quot;)
 
 if p_val &lt; alpha:
     print(f&quot;p-Wert: {p_val:.6f} &lt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird verworfen.&quot;)
 else:
     print(f&quot;p-Wert: {p_val:.6f} &gt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird nicht verworfen.&quot;)

Ausgabe:

 Z-Statistik: 2.7087
 p-Wert: 0.006755 &lt; alpha: 0.05
 Die Nullhypothese wird verworfen.

== Statistische Qualitätskontrolle ==
Beispiel (Mittelwertkarte):

 import numpy as np
 import matplotlib.pyplot as plt
 
 # Gegeben
 sollwert = 50.0
 varianz = 4.0
 stichproben_umfang = 1
 daten = [49.5, 50.2, 53.0, 48.1, 52.6, 53.4, 49.8]
 
 # Berechnung
 standardabweichung = np.sqrt(varianz)
 streuung = standardabweichung / np.sqrt(stichproben_umfang)
 
 cl = sollwert
 ucl = cl + 3 * streuung
 lcl = cl - 3 * streuung
 
 # Darstellung
 plt.plot(daten, marker='o', linestyle='-', color='b', label='Messdaten')
 plt.axhline(cl, color='green', linestyle='-', label=f'CL: {cl}')
 plt.axhline(ucl, color='red', linestyle='--', label=f'UCL: {ucl:.2f}')
 plt.axhline(lcl, color='red', linestyle='--', label=f'LCL: {lcl:.2f}')
 
 plt.title('Mittelwertkarte')
 plt.xlabel('Stichprobe')
 plt.ylabel('Wert')
 plt.legend(loc='lower left')
 plt.grid(True)
 plt.show()

Ausgabe:

[[Datei:IngMath_mittelwertkarte.svg|300px]]

Siehe auch {{W|Shewhart-Regelkarte}} und {{W|Qualitätsregelkarte}}.

* UCL ... '''U'''pper '''C'''ontrol '''Limit''', Obere Eingriffsgrenze
* LCL ... '''L'''ower '''C'''ontrol '''Limit''', Untere Eingriffsgrenze
* CL ... '''C'''enter '''L'''ine, Mittellinie

= Ein- und Ausgabe =
== print ==
Die Anweisung print haben wir schon oft verwendet. Hier soll anhand von Beispielen kurz beschrieben werden, was der Befehl print leisten kann.

 print(&quot;Hallo&quot;, &quot;Welt&quot;, 1, sep=&quot;-&quot;)
 print(&quot;Hallo&quot;, end=&quot; &quot;)
 print(&quot;Welt&quot;)

Ausgabe:
 Hallo-Welt-1
 Hallo Welt

== input ==
 a = int(input(&quot;Zahl 1: &quot;))
 b = int(input(&quot;Zahl 2: &quot;))
 
 print(&quot;a + b = &quot;, a+b)

Ausgabe (nach Eingabe der beiden Ganzzahlen):
 Zahl 1: 4
 Zahl 2: 5
 a + b =  9

== Aus Dateien lesen ==
Es seinen die datei.txt
 Hallo Welt.
 Wie geht es dir?
 ...

und test1.py
 dat = open(&quot;datei.txt&quot;, mode = &quot;r&quot;)
 print(dat.read())
 dat.close()

Ausgabe
 Hallo Welt.
 Wie geht es dir?
 ...

Mit dem open()-Befehl wird die Datei datei.txt im Lesemodus geöffnet (r ... read). Mit dem read()-Befehl wird die Datei eingelesen und mittels print ausgegeben.

== In Dateien schreiben ==
 dat = open(&quot;datei.txt&quot;, mode = &quot;a&quot;, encoding = &quot;utf-8&quot;)
 dat.write(&quot;Hänge Zeile an\n&quot;)
 dat.close()

Die Datei datei.txt sieht nach Abarbeitung des obigen Skripts nun so aus
 Hallo Welt.
 Wie geht es dir?
 ...
 Hänge Zeile an

Es wird die Datei im Schreibmodus geöffnet (a ... append (anhängend), w ... write (überschreibend)).
write() fügt hier also eine Zeile Text am Dateiende ein. close() schließt die Datei wieder.

Das close() kann man sich mit der with-Anweisung auch sparen.

 with open(&quot;datei.txt&quot;, mode=&quot;a&quot;, encoding=&quot;utf-8&quot;) as dat:
     dat.write(&quot;Hänge Zeile an\n&quot;)

= Benutzeroberflächen erstellen =
== tkinter ==
{{Wikipedia | Tkinter}}

Python bietet standardmäßig das Modul tkinter zur Programmierung von Benutzeroberflächen. Es müssen also bei der Verwendung von tkinter keine externen Module installiert werden. Hier wird eine (sehr) kurze Einführung in das Erstellen von grafischen Oberflächen mittels tkinter gegeben.

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 win.minsize(300, 50)
 but = tk.Button(win, text = &quot;Push the button&quot;)
 but.pack()
 win.mainloop()

Ausgabe:

[[Datei:PythonIng_gui1.jpg]]

Ein etwas komplizierteres Beispiel sei nachfolgend gezeigt. Es sollen zwei Strings miteinander verknüpft und ausgegeben werden. 

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 
 def on_button_clicked():
     str = ent1.get() + ent2.get()
     lab2[&quot;text&quot;] = str
  
 ent1 = tk.Entry(win)
 ent2 = tk.Entry(win)
 lab1 = tk.Label(win, text=&quot;verknuepfen mit&quot;)
 lab2 = tk.Label(win, text=&quot;&quot;) 
 but = tk.Button(win, text = &quot;=&quot;, command=on_button_clicked)
 
 ent1.pack(side=&quot;left&quot;)
 lab1.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 but.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 lab2.pack(side=&quot;left&quot;)
 
 win.mainloop()

Ausgabe  (vor der Eingabe der Teilstrings): 

[[Datei:PythonIng_gui2.jpg]]

Ausgabe (nach der Eingabe der Teilstrings und dem Drücken des =-Buttons): 

[[Datei:PythonIng_gui3.jpg]]

== curses ==
{{Wikipedia | curses}}

Mit dem curses-Modul lassen sich u.a. TUIs ('''T'''ext '''U'''ser '''I'''nterfaces) erstellen. Ein sehr einfaches Beispiel zur allgemeinen Funktionsweise wird nachstehend geliefert.
 
 import curses
 
 stdscr = curses.initscr()
 curses.start_color()
 curses.init_pair(1, curses.COLOR_RED, curses.COLOR_WHITE)
 stdscr.clear()
 
 stdscr.addstr(&quot;Hallo Welt&quot;, curses.color_pair(1))
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()
 
Als Ausgabe sollte &lt;span style=&quot;color:#FF0000;&quot;&gt;Hallo Welt&lt;/span&gt; (rote Schrift auf weißem Hintergrund) auf dem Terminal/der Konsole erscheinen. Getestet wurde dies mit openSUSE Tumbleweed, Python-Version 3.13.12. Das entsprechende Python-curses-Package muss installiert sein.

Allgemeine Informationen zur Terminal-/Konsolengröße und Cursorposition liefert folgendes Programm:
 
 import curses
 
 stdscr = curses.initscr()
 
 stdscr.addstr(3, 5, &quot;LINES: %d&quot; % curses.LINES)
 stdscr.addstr(4, 5, &quot;COLS:  %d&quot; % curses.COLS)
 
 (y,x) = stdscr.getyx()
 stdscr.addstr(5, 5, &quot;Momentane Cursorposition:  [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getbegyx()
 stdscr.addstr(6, 5, &quot;Koordinatenursprung:       [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getmaxyx()
 stdscr.addstr(7, 5, &quot;Fenstergröße:              [%d, %d]&quot; % (y, x))
 
 stdscr.addstr(11, 2, &quot;Taste drücken -&gt; Ende&quot;)
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()

Es sollte sich in etwa folgende Ausgabe ergeben:

     LINES: 44
     COLS:  110
     Momentane Cursorposition:  [4, 15]
     Koordinatenursprung:       [0, 0]
     Fenstergröße:              [44, 110]
 
 
 Taste drücken -&gt; Ende

Zur Funktionsweise von curses siehe auch das Wikibook [[ncurses]]. Zum Verständnis sind dort allerdings elementare Kenntnisse in der Programmiersprache C erforderlich.

== Qt ==
{{Wikipedia | Qt (Bibliothek)}}

Auch für das Qt-Framework gibt es eine Anbindung an Python. Nachfolgend ein einfaches Beispiel.

 import sys
 from PySide6.QtWidgets import QApplication, QLabel
 
 app = QApplication(sys.argv)
 label = QLabel(&quot;Hallo Welt!&quot;)
 label.show()
 sys.exit(app.exec())

Ausgabe:

[[Datei:PythonIng_gui10.png]]

== Gtk ==
{{Wikipedia | GTK (Programmbibliothek)}}

Eine idente Ausgabe, wie oben für Qt gezeigt, erzeugt z.B. folgendes Gtk-Programm:

 import gi
 gi.require_version(&quot;Gtk&quot;, &quot;4.0&quot;)
 from gi.repository import Gtk
 
 def on_activate(app):
     win = Gtk.ApplicationWindow(application=app)
     lab = Gtk.Label(label=&quot;Hallo Welt!&quot;)
     win.set_child(lab)
     win.present()
 
 app = Gtk.Application()
 app.connect('activate', on_activate)
 app.run(None)

Auch für die Benutzung von Qt und Gtk müssen die jeweiligen Packages installiert sein. Getestet wurden die entsprechenden Python-Programme nur unter openSUSE Tumbleweed. Wie das GTK-Paket unter MS Windows 11 installiert wird, siehe z.B. [https://www.gtk.org/docs/installations/windows Setting up GTK for Windows].

Damit sei aber das Thema &quot;Benutzeroberflächen erstellen&quot; hier abgeschlossen, da dies schon ein sehr spezielles Aufgabengebiet ist, das eher Informatiker und nicht so sehr Ingenieure anspricht. Bei Bedarf siehe aber ggf. die entsprechenden Links unten in diesem Tutorial. Dort sind weiterführende Informationen zu finden.

= Pandas kurz erklärt =
Hier wird kurz auf das externe Modul Pandas eingegangen. Pandas steht für '''Pan'''el '''Da'''ta und ist ein Modul für die Datenanalyse und -manipulation.

== Series ==
Vorstellbar ist eine &quot;Series&quot; wie eine einzelne Spalte in einem Tabellenkalkulationsprogramm.

Beispiel (Index implizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5]) # Temperaturwerte
 print(temp)

Ausgabe:
 0     8.5
 1    11.0
 2    12.5
 3    10.0
 4    13.0
 5    11.0
 6    14.5
 dtype: float64

Das Kürzel &lt;code&gt;pd&lt;/code&gt; ist Konvention. Es seien Temperaturwerte gegeben. Die erste Spalte bei der Ausgabe ist der Index. Die zweite Spalte enthält die Werte.

Beispiel (separater Zugriff auf den Index und auf die Werte):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5])
 print(temp.index)
 print(temp.values)

Ausgabe:
 RangeIndex(start=0, stop=7, step=1)
 [ 8.5 11.  12.5 10.  13.  11.  14.5]

Beispiel (Index explizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 print(&quot;*** Die gesamte Series ***&quot;)
 print(temp)
 
 print(&quot;*** Temperatur am Donnerstag ***&quot;)
 print(temp[&quot;Do&quot;])
 
 print(&quot;*** Tage wärmer als 12 Grad ***&quot;)
 temp_gr_12 = temp[temp &gt; 12]
 print(temp_gr_12)

Ausgabe:
 *** Die gesamte Series ***
 Mo     8.5
 Di    11.0
 Mi    12.5
 Do    10.0
 Fr    13.0
 Sa    11.0
 So    14.5
 dtype: float64
 *** Temperatur am Donnerstag ***
 10.0
 *** Tage wärmer als 12 Grad ***
 Mi    12.5
 Fr    13.0
 So    14.5
 dtype: float64

== DataFrame ==
Ein DataFrame entspricht einer Tabelle.

Beispiel (Erzeugen eines DataFrames):
 import pandas as pd
 
 tag   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 v1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=tag)
 v2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=tag)
 v3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=tag)
 
 tab = pd.concat([v1, v2, v3], axis=1)
 tab.columns = stadt
 
 print(tab)
 print(type(tab))

Ausgabe:
     Linz  Salzburg Innsbruck
 Mo     1         8     Hallo
 Di     2         9        16
 Mi     3        10        17
 Do     4        11        18
 Fr     5        12        19
 Sa     6        13        20
 So     7        14        21
 &lt;class 'pandas.core.frame.DataFrame'&gt;

Wir haben hier drei Datenspalten (v1, v2, v3) mit den Spaltennamen &quot;Linz&quot;, &quot;Salzburg&quot; und &quot;Innsbruck&quot;, sowie sieben Zeilen &quot;Mo&quot; bis &quot;So&quot;.

Beispiel (Zugriff auf eine Spalte):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab[&quot;Salzburg&quot;])

Ausgabe:
 Mo     8
 Di     9
 Mi    10
 Do    11
 Fr    12
 Sa    13
 So    14
 Name: Salzburg, dtype: int64

Beispiel (Zugriff auf eine Zeile):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab.loc[&quot;Di&quot;])

Ausgabe:
 Linz          2
 Salzburg      9
 Innsbruck    16
 Name: Di, dtype: object

== Grafiken erstellen ==
Hier sei nur ein Torten- oder Kreisdiagramm gezeichnet:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 expl = [0, 0.2, 0, 0, 0, 0, 0]
 temp.plot.pie(figsize=(5,5), explode=expl)
 plt.show()

Ausgabe:

[[Datei:IngPython_pandas1.svg|350px]]

Die &lt;code&gt;figsize&lt;/code&gt; hat nichts mit der Spaltenanzahl zu tun, sondern setzt die Fenster- oder Diagrammgröße in Inches (Breite * Höhe).
 
Mit Pandas kann man auch noch andere Diagrammarten erstellen, z.B. Linien- oder Balkendiagramme. Dies wird hier aber nicht vorgeführt.

== Arbeiten mit CSV- und LibreOffice-Dateien ==
Gegeben sei eine CSV-Datei test1.csv:
 Mai;Juni;Juli
 12;17;45
 15;65;65
 16;32;23
 4;14;7
 23;17;Keine Daten verfügbar
 67;Keine Daten verfügbar;45
 15;24;12

Lesen von dieser CSV-Datei:
 import pandas as pd
 
 tab = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 print(tab)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Schreiben in eine CSV-Datei test2.csv:
 import pandas as pd
 
 val = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 val.to_csv(&quot;test2.csv&quot;, index=False)

Ausgabedatei:
 Mai,Juni,Juli
 12,17,45
 15,65,65
 16,32,23
 4,14,7
 23,17,Keine Daten verfügbar
 67,Keine Daten verfügbar,45
 15,24,12

Die Ausgabedatei ist beinahe gleich wie die Eingabedatei. Es werden aber Kommas statt Strichpunkten verwendet. Daher kommt auch der Name CSV ('''C'''omma '''S'''eparated '''V'''alue). Will man wieder Strichpunkte, so kann man dies über den Parameter &lt;code&gt;sep=&quot;;&quot;&lt;/code&gt; in der &lt;code&gt;to_csv&lt;/code&gt;-Funktion machen.

Um direkt von einer ODS-Datei (LibreOffice Calc, '''O'''pen '''D'''ocument '''S'''preadsheet) zu lesen muss das Modul odfpy extra installiert sein (per YaST, pip etc.). Gelesen wird dann folgendermaßen:
 import pandas as pd
 
 df = pd.read_excel('test1.ods', engine='odf')
 print(df)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Die Datei &quot;test1.ods&quot; sei die Datei, aus der das obige &quot;test1.csv&quot; generiert wurde. Schreiben kann man ebenfalls in eine ODS-Datei:

 import pandas as pd
 
 daten = {
     &quot;Name&quot;: [&quot;Hugo&quot;, &quot;Richie&quot;, &quot;Wilhelmine&quot;],
     &quot;Alter&quot;: [38, 30, 29],
     &quot;Ort&quot;: [&quot;Linz&quot;, &quot;Innsbruck&quot;, &quot;Salzburg&quot;]
 }
 
 tab = pd.DataFrame(daten)
 
 with pd.ExcelWriter(&quot;test2.ods&quot;, engine=&quot;odf&quot;) as writer:
     tab.to_excel(writer, sheet_name=&quot;Daten&quot;, index=False)

Es ergibt sich eine &quot;test2.ods&quot;-Datei (Screenshot):

[[Datei:IngPython_pandas2.png|250px]]

== Sonstiges ==
Hier seien stichpunktartig einige weitere Features von Pandas angeführt:
* {{W|Pivot-Tabelle|Pivot-Tabellen}} (pivot ... Dreh-, Angelpunkt): Zweck - große Datenmengen schnell zusammenfassen, filtern und analysieren.
* NaN ('''n'''ot '''a''' '''n'''umber): In einem Datensatz fehlt ein Wert oder ist nicht definiert.
* groupby-Funktion: Daten strukturieren, aggregieren oder Zwischensummen bilden. 
* {{W|Binning#Datenverarbeitung_und_-analyse|Binning}}: Klassenbildung.
* Mehrstufige Indizierung (Hierarchical Indexing oder MultiIndex).
* Zeitreihen (Time Series).
* MS Excel-Dateien schreiben mit dem Modul openpyxl.

Für tiefergehende und weiterführende Informationen wird auf das Buch von ''Klein: Numerisches Python; Hanser, 2023'' und [https://pandas.pydata.org/ pandas] verwiesen.

= Style Guide, flake8, pylint, Black etc. =
== Style Guide ==
Wie man schönen und richtigen Python-Code schreibt, erfahren Sie in
* [https://peps.python.org/pep-0008/ PEP 8 – Style Guide for Python Code]

== Formatter und Linter ==
Ein Modul, das prüft, ob die Richtlinien im Style Guide eingehalten wurden, ist ''flake8'':
* [https://flake8.pycqa.org/en/latest/ Flake8: Your Tool For Style Guide Enforcement]

Code formatieren kann man auch mit [https://pypi.org/project/black/ Black]. Z.B. übersetzt &lt;code&gt;black test1.py&lt;/code&gt; die Datei &lt;code&gt;test1.py&lt;/code&gt;

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)),
     (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

in 

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)), (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Die Programmausgabe ist 

 reformatted test1.py
 
 All done! ✨ 🍰 ✨
 1 file reformatted.

Der Unterschied zwischen Black und Flake8:
* Black ist ein Code-Formatter. Er formatiert Ihren Code um, sodass er im Einklang mit PEP 8 steht.
* Flake8 ist ein {{W|Lint (Programmierwerkzeug) | Code-Linter}}. Flake8 verändert Ihren Code nicht, sondern durchsucht ihn nach potenziellen Fehlern etc.

Am obigen Beispiel sieht man auch, dass flake8 und Black nicht immer einer Meinung sind. Flake8 (&lt;code&gt;flake8 test1.py&lt;/code&gt;) würde standardmäßig den mit Black formatierten Code bemängeln:

 test1.py:8:80: E501 line too long (80 &gt; 79 characters)

Diese Diskrepanz kann beseitigt werden. Da 79 Zeichen auf modernen Bildschirmen meist als zu kurz empfunden werden, ist ein Limit von 88 Zeichen (Black-Standard) oder mehr empfehlenswert. Um dies zu implementieren, erstellen Sie in Ihrem Projektverzeichnis eine &lt;code&gt;.flake8&lt;/code&gt;-Datei mit dem Inhalt

 [flake8]
 max-line-length = 88

Und schon ignoriert Flake8 dieses Problem.

Ein anderer Linter ist pylint. Der würde beim Abarbeiten des obigen Beispiels, z.B. mit &lt;code&gt;pylint test1.py&lt;/code&gt; noch eine Kleinigkeit bemängeln:

 ************* Module test1
 /home/hr/tmp/test1.py:1:0: C0114: Missing module docstring (missing-module-docstring)
 
 ------------------------------------------------------------------
 Your code has been rated at 8.57/10 (previous run: 8.57/10, +0.00)

Auch pylint muss vor der ersten Verwendung installiert werden (z.B. mittels pip, virtuelle Umgebung, YaST). Die Dokumentation zu pylint findet sich auf [https://pylint.readthedocs.io/en/latest/].

&lt;u&gt;Aufgabe:&lt;/u&gt; Fügen Sie einen &quot;module docstring&quot; in die &lt;code&gt;test1.py&lt;/code&gt;-Datei ein und testen Sie erneut mit flake8, Black und pylint. &lt;small&gt;Sehen Sie zum Thema docstrings auch [https://peps.python.org/pep-0257/#what-is-a-docstring PEP 257 – Docstring Conventions].&lt;/small&gt;

Es gibt noch weitere Formatierungswerkzeuge für Python-Code. Z.B. [https://docs.astral.sh/ruff/ Ruff], ein moderner Code-Formatter und -Linter. Mittels &lt;code&gt;ruff check test1.py&lt;/code&gt; würde obiger Code geprüft (Linter). &lt;code&gt;ruff format test1.py&lt;/code&gt; formatiert den Code (Formatter).

== Type Checker ==
&quot;Type Checker&quot; sind z.B.
* mypy
* pyright
* ty

Diese prüfen die Datentypen, z.B. in folgendem Code

 def greetings(name: str) -&gt; str:
     return &quot;Hello, %s&quot; % name
 
 
 print(greetings(42))

Python selbst, flake8, ruff oder black würden diesen Code ohne zu murren akzeptieren. &quot;Type Checker&quot; würden aber sehr wohl Alarm schlagen, z.B. liefert &lt;code&gt;mypy&lt;/code&gt; folgende Ausgabe

 test1.py:5: error: Argument 1 to &quot;greetings&quot; has incompatible type &quot;int&quot;; expected &quot;str&quot;  [arg-type]
 Found 1 error in 1 file (checked 1 source file)

Das funktioniert übrigens nicht nur bei Funktionsannotationen, sondern auch mit Variablen etc.

 from typing import Final
 
 # &quot;Konstante&quot;, ab Python 3.8
 NUMBER: Final = 123
 print(NUMBER)
 NUMBER = 125
 print(NUMBER)
 
 # Variable
 a: int = 345
 print(a)
 a = &quot;Irgendwas&quot;
 print(a)
 
 # Variable (Pipe-Symbol), ab Python 3.10
 b : int|str = 567
 print(b)
 b = &quot;sonstiges&quot;
 print(b)

Ausgabe mit python:
 123
 125
 345
 Irgendwas
 567
 sonstiges

Ausgabe mit mypy:
 test3.py:6: error: Cannot assign to final name &quot;NUMBER&quot;  [misc]
 test3.py:12: error: Incompatible types in assignment (expression has type &quot;str&quot;, variable has type &quot;int&quot;)  [assignment]
 Found 2 errors in 1 file (checked 1 source file)

Python kennt übrigens keine Konstanten. Man kann diese mittels Großbuchstaben andeuten. Das ist aber nur Konvention, hat aber keine sonstigen Auswirkungen. Oder man verwendet wie oben gezeigt &lt;code&gt;Final&lt;/code&gt;. Dann werfen Typchecker Errors aus.

==pydoc==
pydoc ist ein Werkzeug, um Python-Module, -Funktionen und -Klassen zu dokumentieren.

Beispiel &lt;code&gt;test1.py&lt;/code&gt;:
 &quot;&quot;&quot;Rechen-Modul.
 
 Funktionen die von pydoc gelesen werden.
 &quot;&quot;&quot;
 
 def multiply(a, b):
     &quot;&quot;&quot;Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
     
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a * b
     
 def add(a, b):
     &quot;&quot;&quot;Addiert zwei Zahlen und gibt das Ergebnis zurück.
    
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a + b
    
 
 if __name__ == '__main__':
     print(multiply(3, 5))
     print(add(4, 6))

Ausgabe mit &lt;code&gt;python3.13 -m pydoc test1&lt;/code&gt; auf der Konsole:

 Help on module test1:
 
 NAME
     test1 - Rechen-Modul. 
 
 DESCRIPTION
     Funktionen die von pydoc gelesen werden.
 
 FUNCTIONS
     add(a, b)
         Addiert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
     multiply(a, b)
         Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
 FILE
     /home/xyz/tmp/test1.py

Siehe zu diesem Thema z.B. auch [https://docs.python.org/3/library/pydoc.html]. Mittels &lt;code&gt;python3.13 -m pydoc -w test1&lt;/code&gt; kann man auch eine HTML-Dokumentation erstellen.

Wofür &lt;code&gt;if __name__ == '__main__':&lt;/code&gt; steht, siehe z.B. etwas später im Abschnitt [[Ing_Mathematik:_Python#Doctests]].

== Sonstige Tools ==
Andere Tools für die {{W|Statische Code-Analyse|statische Codeanalyse}}, die aber für Ingenieure weniger interessant sein dürften, sind z.B.
* Radon: Liefert verschiedene {{W|Softwaremetrik|Codemetriken}} (Komplexität, Wartbarkeitsindex ...)
* Bandit: Findet Sicherheitslücken

Tools für die {{W|Dynamisches Software-Testverfahren|dynamische Codeanalyse}}, z.B.:
* DynaPyt (Framework zur dynamischen Programmanalyse)
* cProfile (Profiler)
* Memory Profiler (Speicheranalyse)
* Memray (Speicheranalyse)
* tracemalloc (Speicheranalyse)

Paket- und Projektmanagement (pip-Ersatz etc.):
* uv
* Poetry
* Conda
* pipx

Packaging-Tools (Freezer) und {{W|Compiler#Sonderformen|Transpiler}} :
* pyinstaller
** erstellt eigenständige, ausführbare Binärdatei
** kein Cross-Compiler
** kein Schutz vor Reverse-Engineering
** langsam
** packt alles in eine Datei
** sehr große Datei
** Befehl, z.B.: &lt;code&gt;pyinstaller --onefile test1.py&lt;/code&gt;
** GUI: &lt;code&gt;auto-py-to-exe&lt;/code&gt;
* cx_Freeze
* nuitka
** Übersetzt Python-Code in C/C++-Code und weiter in eine ausführbare Datei
** kein Cross-Compiler
** Schutz vor Reverse-Engineering
** Befehl, z.B.: &lt;code&gt;nuitka --standalone --onefile test1.py&lt;/code&gt;
* cython

= Einige Integrierte Entwicklungsumgebungen (IDEs)=
Werden Programmtexte größer und umfangreicher, so ist das Arbeiten mit der interaktiven Programmierumgebung bzw. das direkte Ausführen von Python-Skripten mühsam. Man wünscht sich z.B. Hilfen zum Debuggen oder die automatische Code-Vervollständigung. Zu diesem Zweck wurden IDEs (Integrated Development Environments) geschaffen. Von diesen seinen nachfolgend auszugsweise einige kurz beschrieben. Testen Sie einfach aus, welche davon für Sie bzw. für Ihr Python-Projekt geeignet sind.

== IDLE ==
IDLE ist die mit dem Python-Programmpaket mitgelieferte IDE. Der Name leitet sich einerseits ab vom Monty-Python-Mitglied Eric Idle, andererseits steht es als Abkürzung für &quot;'''I'''ntegrated '''D'''evelopment and '''L'''earning '''E'''nvironment. IDLE ist einfach zu bedienen, bietet aber schon einen beachtlichen Leistungsumfang. Nachfolgend wird ein Screenshot zu IDLE geliefert. Rechts ist das Editor-Fenster zu sehen, links die interaktive Programmierumgebung. Um das Beispiel selbst nachvollziehen zu können, starten Sie IDLE. Das geht ähnlich, wie Sie die interaktive Programmierumgebung von Python starten (nur, dass Sie eben das IDLE-Icon doppelklicken und nicht das Python-Icon. Unter Linux geben Sie einfach in einem Terminal &lt;code&gt;idle3.13&lt;/code&gt; o. Ä. ein). Weiter geht es mit &quot;File - Open - ...&quot;. Die auszuführende Datei auswählen (im konkreten Fall ein &quot;Hallo-Welt&quot;-Programm). Es erscheint das rechte Fenster. Dort &quot;Run - Run Module&quot; auswählen. Und schon wird im linken Fenster &quot;Hallo Welt!&quot; ausgegeben.

[[Datei:PythonIng_idle1.jpg | 600px]]

Siehe auch {{W|IDLE}}.

== PyCharm ==
PyCharm ist ein kommerzielles Produkt. Es gab aber auch eine kostenlose Community Edition. Seit 2025 sind beide Varianten vereint. Für die ersten 30 Tage sind die Pro-Funktionen frei verfügbar, danach nur noch die Kernfunktionalitäten (oder man bezieht kostenpflichtig  die Pro-Version). Zu beziehen ist PyCharm unter dem Weblink [https://www.jetbrains.com/pycharm/]. Nachfolgend ein etwas abgewandeltes &quot;Hallo Welt&quot;-Programm, editiert und ausgeführt mit PyCharm.

[[Datei:PyCharm_IDE_2023_screenshot.png | 600px]]

Siehe auch {{W|PyCharm}}.

== Eric ==
Auch eric ist Open Source und steht unter der  GNU General Public License Version 3 oder später. Zu beziehen ist diese Software unter [https://eric-ide.python-projects.org/].

[[Datei:Screenshot_Eric_4.png | 600px]]

Siehe auch {{W|eric (Software)}}.

&lt;small&gt;
Unter openSUSE Tumbleweed sollte sich eric auch mit YaST installieren lassen. Bei mir gibt es aber dann beim Ausführen des eric-Programms eine Fehlermeldung (Stand März 2026): 
 
 ...
 ModuleNotFoundError: No module named 'PyQt6.QtPdfWidgets'

Umgehen kann man dieses Problem aber wieder mit dem Erstellen einer virtuellen Umgebung, in etwa so

 python3.13 -m venv ~/tmp/venv1
 cd ~/tmp/venv1/bin
 ./python3.13 -m pip install --upgrade --prefer-binary eric-ide
 ./eric7_ide
&lt;/small&gt;

== PyScripter ==
Vom Funktionsumfang vergleichbar mit den vorherigen IDEs ist PyScripter. Auch PyScripter ist Open Source. Die Projekt-Homepage findet sich auf [https://sourceforge.net/projects/pyscripter/]. PyScripter ist nur für MS Windows verfügbar.

[[Datei:PythonIng_pyscripter1.jpg | 600px]]

== Spyder IDE ==
Spyder enthält bereits eine stabile Python-Version und etliche Module (z.B. matplotlib, numpy, control). Ansonsten kann dieses Softwarepaket vom Funktionsumfang her mit den anderen genannten IDEs locker mithalten. Spyder wurde unter der MIT-Lizenz veröffentlicht. Diese Software findet sich auf [https://www.spyder-ide.org].

[[Datei:Spyder-windows-screenshot.png | 600px]]

Siehe auch {{W|Spyder (Software)}}

== Eclipse IDE==
Die {{W|Eclipse_(IDE)|Eclipse-IDE}} kann für Python aufgerüstet werden. Dazu gibt es das PyDev-Plugin. Installiert wird es über 
* Help &gt; Eclipse Marketplace... 
* Find - PyDev - Install
Danach muss noch der Pfad zum Python-Interpreter festgelegt werden 
* Window &gt; Preferences &gt; PyDev &gt; Interpreters &gt; Python Interpreter &gt; New ... 
Das Ergebnis ist ähnlich wie im folgenden Bild, nur dass statt C/C++ Python Verwendung findet. 

[[Datei:Setting Up Eclipse CDT helloout.png | 600px]]

== Sonstige ==
Die genannten IDEs sind nicht die Einzigen. Es gibt, um dem Image Pythons als beliebteste Programmiersprache gerecht zu werden, noch einige andere. Sowohl Open Source-Programme als auch kommerzielle Programme sind im Web zu finden, z.B. Thonny oder {{W|Visual Studio Code}}. Unter Linux kann man auch {{W|KDevelop}}, ausgestattet mit dem Python3-Plugin, einsetzen. Braucht man den Umfang von ausgewachsenen IDEs nicht, so kann man auch normale Texteditoren verwenden (z.B. {{W|Geany}} oder {{W|Kate_(Texteditor)|Kate}}).

= Debuggen und Testen =
Das Debuggen und Testen von Programmen sind wichtige Bestandteile der Programmierung. Syntaxfehler lassen sich i.A. leicht beheben. Schwieriger ist das Eingrenzen von logischen Fehlern, die ev. nur in bestimmten Situationen auftreten und keine explizite Fehlermeldung hervorrufen. Das Programm liefert falsche Ergebnisse oder es stürzt aus heiterem Himmel ab. Um das zu verhindern gibt es verschiedene Werkzeuge, die bei der Fehlersuche behilflich sein können. Vorerst siehe aber zwecks Begriffsklärung noch folgende Links: 
 
* {{W|Debuggen}}
* {{W|Debugger}}
* {{W|Softwaretest}}

&lt;gallery&gt;
First Computer Bug, 1947.jpg
Test ganzheitlich.png
V-Modell.svg
&lt;/gallery&gt;

== Das Modul pdb ==
Python bringt schon ein Modul zum Debuggen mit. Siehe z.B. [https://docs.python.org/3/library/pdb.html pdb — The Python Debugger].
Komfortabler lässt sich das aber mittels Integrierter Entwicklungsumgebungen (IDEs) angehen.

== Debuggen mit IDEs ==
Für die IDEs IDLE und Spyder sei kurz auf die entsprechenden Webseiten verwiesen:

* [https://www.cs.uky.edu/~keen/help/debug-tutorial/debug.html Debugging under IDLE].
* [https://docs.spyder-ide.org/current/panes/debugging.html Spyder Debugger]

Dort wird die Vorgehensweise auch mittels Screenshots erläutert.

== assert ==
assert ... behaupten, zusichern ({{W|Assertion (Informatik)}})

Python-Code:
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10., 0.)

Ausgabe:

 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10., 0.)
   File &quot;/home/hr/Develop/test1.py&quot;, line 4, in print1
     assert y != 0.0
            ^^^^^^^^
 AssertionError
 
Python-Code: 
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)
 
Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(&quot;10.&quot;, &quot;5.&quot;)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError
 
Aber auch bei nachfolgendem Code gibt es eine Fehlermeldung:

 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10, 5)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError

Damit letzteres funktioniert, kann man den Programmcode so umschreiben:
 def print1(x, y):
     assert type(x) == float or type(x) == int
     assert type(y) == float or type(y) == int
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 2.0
 
Und jetzt fangen wir den &lt;code&gt;AssertionError&lt;/code&gt; auf:
 def print1(x, y):
     try:
         assert type(x) == float or type(x) == int
         assert type(y) == float or type(y) == int
         assert y != 0.0
         print(x/y)
     except(AssertionError):
         print(&quot;Hallo&quot;)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)

Ausgabe:
 2.0
 Hallo

Ich hoffe, es ist wenigstens im Ansatz klar geworden, wofür &lt;code&gt;assert&lt;/code&gt; gut sein kann. Ausschalten kann man die &lt;code&gt;assert&lt;/code&gt;-Überprüfung übrigens mit dem Python-Schalter &lt;code&gt;-O&lt;/code&gt;.

== Doctests == 
Innerhalb eines Docstrings kann die Arbeit im interaktiven Modus simuliert werden. Nach den Promptzeichen (&gt;&gt;&gt;) erfolgen dann bei unserem Beispiel innerhalb des Docstrings simulierte Aufrufe der Funktion &lt;code&gt;print1()&lt;/code&gt;. Danach folgen jeweils die Sollresultate. Wird das Modul oder die Datei als Hauptprogramm aufgerufen, so wird die Funktion &lt;code&gt;doctest.testmode()&lt;/code&gt; aufgerufen und ein Bericht auf der Konsole ausgegeben. Wird das Modul nicht als Hauptprogramm aufgerufen, sondern importiert, dann wird diese &lt;code&gt;testmod&lt;/code&gt;-Funktion nicht aufgerufen. D.h. dieser Code kann sowohl für Testzwecke als auch für den produktiven Einsatz verwendet werden. Das ist auch sinnvoll, weil wenn man Teile der Datei immer löschen bzw. einfügen müsste, so würden sich Fehlerquellen auftun. Das würde den Sinn und Zweck von Doctests konterkarieren.  

 def print1(x=0., y=1.):
     &quot;&quot;&quot; Dividiere zwei Zahlen
     Autor: Intruder
     Datum: 12.08.2025
 
     &gt;&gt;&gt; print1(2., 1.)
     2.0
     &gt;&gt;&gt; print1(5., 2.)
     2.5
     &gt;&gt;&gt; print1(5.)
     5.0
     &quot;&quot;&quot;
     print(x/y)
 
 if __name__ == &quot;__main__&quot;:
     import doctest
     doctest.testmod(verbose=True)

Ausgabe:
 Trying:
     print1(2., 1.)
 Expecting:
     2.0
 ok
 Trying:
     print1(5., 2)
 Expecting:
     2.5
 ok
 Trying:
     print1(5.)
 Expecting:
     5.0
 ok
 1 items had no tests:
     __main__
 1 items passed all tests:
    3 tests in __main__.print1
 3 tests in 2 items.
 3 passed and 0 failed.
 Test passed.

Das gezeigte Beispiel ist so ziemlich das einfachste, das es gibt. Für weiterführende Details siehe z.B.:
* [https://peps.python.org/pep-0257/ PEP 257 – Docstring Conventions]
* [https://docs.python.org/3/library/doctest.html doctest — Test interactive Python examples]

''Einschub:'' Ganz ähnlich kann man auch Klassen testen, z.B. in folgendem Code-Fragment

 class Fahrzeug:
   # siehe Abschnitt &quot;Objektorientierte Programmierung&quot;
   # ...
 
 if __name__ == &quot;__main__&quot;:
   vauweh = Fahrzeug(170, 90)
   beemweh = Fahrzeug(200, 120)
   print(vauweh.convertGeschw())
   print(beemweh.convertGeschw())

Wird das Script als Hauptprogramm ausgeführt (z.B. zu Testzwecken), so erfolgt die Ausgabe der zwei, via &lt;code&gt;convertGeschw()&lt;/code&gt;, umgerechneten Geschwindigkeiten. Wird es aber als Modul eingebunden, so wird der letzte Programmabschnitt nicht ausgeführt (&lt;code&gt;__name__ == &quot;__main__&quot;&lt;/code&gt; ergibt &lt;code&gt;False&lt;/code&gt;).

== pytest ==
Siehe zu diesem Thema auch {{W|Modultest}}.

pytest ist ein externes Modul und muss vorab installiert werden, z.B. mittels 
 pip install -U pytest
 pip install -U pytest-html 

Python-Code, Datei test1.py:
 def add(x, y):
     return x + y
 
 def test_answer():
     assert add(1, 1) == 3

Starten von pytest in der Konsole:
 pytest test1.py
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py F                                                                                                            [100%]
 
 ========================================================= FAILURES ==========================================================
 ________________________________________________________ test_answer ________________________________________________________
 
     def test_answer():
 &gt;       assert add(1, 1) == 3
 E       assert 2 == 3
 E        +  where 2 = add(1, 1)
 
 test1.py:6: AssertionError
 ================================================== short test summary info ==================================================
 FAILED test1.py::test_answer - assert 2 == 3
 ===================================================== 1 failed in 0.09s =====================================================

Hier erhalten wir einen Fehler, da 1+1 eindeutig ungleich 3 ist. Aber aus irgendeinem Grund wollte der Programmierer oder Tester in diesem Fall, dass dies so ist. Testfälle werden übrigens mit dem Präfix &lt;code&gt;test_&lt;/code&gt; eingeleitet.

Python-Code:
 def add(x, y):
     return x + y + 1
 
 def test_answer():
     assert add(1, 1) == 3 
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py .                                                                                                            [100%]
 
 ===================================================== 1 passed in 0.01s =====================================================

Jetzt ist alles in Ordnung. Weiterführendes siehe z.B.

* [https://docs.pytest.org/en/stable/ pytest: helps you write better programs]

== unittest ==
Auch unittest dient zur Durchführung von Testreihen, ist aber Bestandteil von Python. Hier wird vorerst nicht näher darauf eingegangen. Siehe z.B. 
* [https://docs.python.org/3/library/unittest.html unittest — Unit testing framework]

Lt. ''Inden: Python Challenge; dpunkt, 2021, Seite 481''  soll unittest weniger komfortabel als pytest sein.

Einen Vergleich von unittest mit pytest findet man in
* [https://knapsackpro.com/testing_frameworks/difference_between/pytest/vs/unittest pytest vs unittest]

= Python und Anwendungsprogramme =
Bisher stand immer alleine die Programmiersprache Python (ev. unter Einbeziehung von Modulen) im Mittelpunkt der Betrachtungen. Aber Python kann auch als Makrosprache für Anwendungsprogramme auftreten. Als Beispiele seien {{W|FreeCAD}} und {{W|LibreOffice}} genannt.

== FreeCAD ==
FreeCAD ist ein freies 3D-CAD-Programm. Hier soll nicht auf die Bedienung dieses CAD-Pakets eingegangen werden, sondern nur auf die Möglichkeit, mittels Python Makros zu schreiben. Als einfacher Einstieg soll ein Makro erstellt werden, welches eine Kugel (rot) und einen Quader (blau) zeichnet. Folgende Vorbereitungsschritte sind erforderlich (es sei vorausgesetzt, dass FreeCAD schon am Rechner installiert ist. Downloaden können Sie das Programm von der Website [https://www.freecad.org/downloads.php?lang=en]):

* FreeCAD starten
* Leere Datei erstellen
* Makro &gt; Makros &gt; Erstellen ...

Es öffnet sich ein leeres Editorfenster, in das Sie folgenden Code eingeben können:

 import FreeCAD
 import Part
 
 doc = FreeCAD.newDocument()
 
 # Kugel
 kugel = Part.makeSphere(10)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Kugel&quot;)
 form_element.Shape = kugel
 kug = FreeCAD.ActiveDocument.getObject(&quot;Kugel&quot;)
 kug.ViewObject.ShapeColor = (1.0, 0.0, 0.0)
 neuePosition = App.Vector(5, 2.5, 2.5)
 kug.Placement = App.Placement(neuePosition, kug.Placement.Rotation)
 
 # Quader
 quader = Part.makeBox(5, 5, 50)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Quader&quot;)
 form_element.Shape = quader
 quad = FreeCAD.ActiveDocument.getObject(&quot;Quader&quot;)
 quad.ViewObject.ShapeColor = (0.0, 0.0, 1.0)
 
 doc.recompute()

Diesen Code können Sie nun ausführen:
* Makro &gt; Makro ausführen

Es ergibt sich folgende Ausgabe (gedreht und gezoomt):

[[Datei: PythonIng_freecad1.png|500px]]

Siehe auch [https://wiki.freecad.org/Python_scripting_tutorial/de# Anleitung Skripterstellung mit Python]. Getestet wurde obiges Beispiel mit FreeCAD 1.1.3 unter Linux und 1.1.1 unter MS Windows.

== LibreOffice ==
LibreOffice ist ein freies Officepaket ([https://de.libreoffice.org/]). Hier soll nur das Tabellenkalkulationsprogramm Calc kurz betrachtet werden. Es seinen in den ersten 3 Zellen (A1 bis A3) Zahlen gegeben. Diese sollen mit einem Python-Makro addiert und das Resultat in der Zelle A5 ausgegeben werden. Auch hier sind Vorbereitungsarbeiten nötig: 
* zuerst muss unter Linux das Verzeichnis &lt;code&gt;~/.config/libreoffice/4/user/Scripts/python&lt;/code&gt; erstellt werden
* für MS Windows ist es das Verzeichnis &lt;code&gt;%APPDATA%\LibreOffice\4\user\Scripts\python&lt;/code&gt; 
** drücken Sie zuerst Win + R (es öffnet sich das Ausführen-Fenster)
** geben Sie &lt;code&gt;%appdata%&lt;/code&gt; ein, danach drücken Sie Enter (es öffnet sich der Explorer)
** navigieren Sie zu dem genannten Verzeichnis bzw. erstellen Sie das Verzeichnis 
* in diesem Verzeichnis wird dann mit einem beliebigen Texteditor das Python-Makro erstellt, in unserem Fall die Datei &lt;code&gt;summiere_zellen.py&lt;/code&gt;:

 import uno
 
 def summiere_zellen(*args):
     # Zugriff auf das aktuelle Dokument und das aktive Tabellenblatt
     ctx = uno.getComponentContext()
     smgr = ctx.getServiceManager()
     desktop = smgr.createInstanceWithContext(&quot;com.sun.star.frame.Desktop&quot;, ctx)
     doc = desktop.getCurrentComponent()
     sheet = doc.getCurrentController().getActiveSheet()
 
     # Werte aus den Zellen A1 bis A3 auslesen
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
 
     # Addition der drei Werte
     summe = w1 + w2 + w3
 
     # Ergebnis in die Zelle A5 schreiben
     sheet.getCellRangeByName(&quot;A5&quot;).Value = summe

* siehe dazu ggf. auch [https://help.libreoffice.org/latest/de/text/sbasic/python/python_locations.html?DbPAR=BASIC].

Weiter geht es in LibreOffice Calc mit dem Menü ''Extras &gt; Makros &gt; Makros verwalten &gt; Python''. Dort wird das Makro &lt;code&gt;summiere_zellen&lt;/code&gt; ausgeführt. Es ergibt sich z.B. folgendes Resultat

[[Datei:PythonIng_libreoffice1.png]]

Das Kürzel &lt;code&gt;uno&lt;/code&gt; steht für '''U'''niversal '''N'''etwork '''O'''bjects. Etwas einfacher geht's auch so:

 def summiere_zellen():
     desktop = XSCRIPTCONTEXT.getDesktop()
     model = desktop.getCurrentComponent()
     sheets = model.getSheets()
     sheet = sheets.getByIndex(0)
     
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
     
     cell = sheet.getCellRangeByName(&quot;A5&quot;)    
     cell.setValue(w1 + w2 + w3) 

Empfohlen wird auch, das Erweiterungspaket APSO ('''A'''lternative '''P'''ython '''S'''cript '''O'''rganizer, apso.oxt) zu installieren. Die Vorgehensweise wird hier nicht gezeigt, sondern nur darauf hingewiesen, dass man das einfach &quot;googeln&quot; kann. Siehe zur Python-Programmierung für LibreOffice auch [https://wiki.documentfoundation.org/Macros/Python_Guide/de Makros/Python-Handbuch]. Getestet wurden obige Beispiele mit LibreOffice 26.2.5.1 unter Linux und 26.2.1.2 unter MS Windows.

= Ausblick =
Dies war eine kurze Einführung in die Berechnungs- und Darstellungsmöglichkeiten mit Python. Es sollten etliche relevante Themen behandelt, oder zumindest kurz angesprochen worden sein. Wem dieser Text nicht ausreichend ist, der sei auf die entsprechenden weiterführenden Weblinks, Bücher und die Python-Hilfefunktion verwiesen. Python kennt noch viel mehr Befehle, als hier dargestellt wurden. Das Themenspektrum ist auch durch die Einbindung externer Module fast beliebig erweiterbar.

= Weblinks=
== Python allgemein ==
* [https://www.python.org/ Python Homepage]

== Externe mathematische Module ==
* [https://numpy.org/ NumPy]
* [https://numpy.org/doc/stable/user/numpy-for-matlab-users.html NumPy for MATLAB users]
* [https://scipy.org/ SciPy]
* [https://www.sympy.org/en/index.html SymPy]
* [https://pandas.pydata.org/ pandas]
* [https://github.com/maroba/findiff findiff]
* [https://mpmath.org/ mpmath]

== Externe Module für Grafiken ==
* [https://matplotlib.org/ Matplotlib]
* [https://vpython.org/ VPython]
* [https://build123d.readthedocs.io/en/latest/ build123d]
* [https://docs.vtk.org/en/latest/api/python.html VTK]
* [https://docs.bokeh.org/en/latest/docs/first_steps.html bokeh]
* [https://py5coding.org/ py5]

== Erstellung von User Interfaces ==
* [https://docs.python.org/3/library/tkinter.html tkinter - Python interface to Tcl/Tk]
* [https://docs.python.org/3/library/curses.html curses - Terminal handling for character-cell displays]
* [https://wiki.qt.io/Qt_for_Python Qt for Python]
* [https://www.gtk.org/docs/language-bindings/python GTK and Python]

== Erstellen virtueller Umgebungen ==
* [https://docs.python.org/3/library/venv.html venv - Creation of virtual environments]

== Sonstige ==
* [https://python-control.readthedocs.io/en/stable/ Python Control Systems Library]
* [https://pypi.org/project/regex/ regex - Regular Expressions]
* [http://pyromat.org/ PYroMat]
* [https://coolprop.org/coolprop/wrappers/Python/index.html CoolProp]
* [https://pypi.org/project/iapws/ iapws]
* [https://tespy.readthedocs.io/en/main/getting_started/introduction.html TESPy - Thermal Engineering Systems in Python]
* [https://pint.readthedocs.io/en/stable/ pint]

= Bücher =
== Gedruckte Bücher, OpenBooks, Magazine ==
* Diverse: c't Python Lernen, Verstehen, Anwenden; Heise, 2022 
* Ernesti, Kaiser: Python3 - das umfassende Handbuch; 5. Aufl., Rheinwerk, [https://openbook.rheinwerk-verlag.de/python/ OpenBook]
* Iacono et al.: Programmieren trainieren; 3. Aufl., Hanser, 2023, ISBN 978-3-446-47766-7
* Inden: Python Challenge; dpunkt, 2021, ISBN 978-3-86490-809-5
* Klein: Numerisches Python; 2. Aufl., Hanser, 2023, ISBN 978-3-446-47170-2 
* Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler; Rheinwerk, 2021, ISBN 978-3-8362-7316-9
* Weigend: Python 3 - Das umfassende Praxisbuch; 9. Aufl., mitp, 2022, ISBN 978-3-7475-0544-1
* Woyand: Python für Ingenieure und Naturwissenschaftler; 4. Aufl., Hanser, 2021, ISBN 978-3-446-46483-4

== Andere Wikibooks ==
* [[:en:Subject:Python_programming_language | Englische Wikibooks zum Thema Python]]
* [[Python|Deutschsprachiges Python-Wikibook]] [[Bild:2von10.png|20%]]
* [[Python unter Linux|Python 2.7 unter Linux]] [[Bild:10von10.png|100%]]


{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}</text>
      <sha1>5ibaj4l84ogkmz2citb5pcetb4ucmt5</sha1>
    </revision>
    <revision>
      <id>1092178</id>
      <parentid>1092176</parentid>
      <timestamp>2026-10-16T19:59:03Z</timestamp>
      <contributor>
        <username>Intruder</username>
        <id>1513</id>
      </contributor>
      <comment>/* Interpolation */ Aufgaben hinzu</comment>
      <origin>1092178</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="190008" sha1="0h80c5p2guoqgpzewvvkdjpwdy64qdf" xml:space="preserve">{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}


= Hallo Welt und allgemeine Hinweise =
== Was ist Python ==
* Python ist eine universelle höhere Programmiersprache.
* Python ist objektorientiert.
* Python ist Open-Source (Python Software Foundation License).
* Python ist für viele Betriebssysteme erhältlich (z.B. für Linux, MS Windows, macOS).
* Python ist ein Interpreter.
* Python ist durch Module fast beliebig erweiterbar.
* Python als Programmiersprache ist case-sensitive - d.h. Groß- und Kleinschreibung ist relevant bei der Eingabe von Befehlen.
* Python ist in etlichen Anwendungsprogrammen (z.B. {{W|FreeCAD}}, {{W|LibreOffice}}, {{W|GIMP}}, {{W|Blender (Software) | Blender}}) als Makrosprache verwendbar.

{{Wikipedia | Python (Programmiersprache)}}

== Python installieren ==
=== MS Windows ===
Laden Sie das aktuelle Python-Paket von der Webseite [https://www.python.org/] herunter. Weiter geht es wie bei jedem anderen größeren zu installierenden Programm. Einfach das Installationsprogramm im Explorer doppelklicken und den Anweisungen des Setup-Programmes folgen.

=== Linux ===
Entweder ist Python bereits standardmäßig installiert, ansonsten ist die Installation mittels Paketmanagementsystem einfach möglich. Aber auch die Spyder-Entwicklungsumgebung ([https://www.spyder-ide.org]) bietet einen guten Einstieg mit Python (das gilt auch für MS Windows). Spyder bringt auch schon etliche wichtige Module standardmäßig mit.

== Python starten ==
=== MS Windows ===
Das Icon für das Python-Programm doppelklicken. Und schon startet das Programm.

[[Datei:PythonIng_start1.jpg]]

Python im interaktiven Modus (REPL ... '''R'''ead-'''E'''valuate-'''P'''rint-'''L'''oop) präsentiert sich dann so:

 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

Alternativ kann das Programm auch über die Eingabeaufforderung oder die PowerShell gestartet werden:

 c:\devel\Python&gt;python.exe
 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

=== Linux ===
Tippen Sie einfach das Wort „python“ (oder unter openSUSE Tumbleweed z.B. auch „python3.11“ oder „python3.13“) in einem Linux-Terminal ein, schließen den Befehl mit der RETURN-Taste ab, und schon startet Python im interaktiven Modus:
 
 Python 3.13.12 (main, Feb 09 2026, 22:37:44) [GCC] on linux
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt; 

Es gibt auch noch andere Möglichkeiten Python zwecks Programmausführung zu starten, z.&amp;nbsp;B. den {{W|Shebang}} (&lt;code&gt;#!&lt;/code&gt;) am Beginn eines Python-Scripts. Das Script sei als Script.py gespeichert. Dann kann das Script mit ./Script.py ausgeführt werden. Für openSUSE Tumbleweed sei nachfolgend ein lauffähiges &quot;Hallo Welt!&quot;-Script angegeben. Es wird in diesem Script der Python-Interpreter in der Version 3.13 verwendet :

 #!/usr/bin/python3.13
 print(&quot;Hallo Welt!&quot;)

Die Berechtigungen zum Ausführen der Datei müssen natürlich noch richtig gesetzt werden, z.B. mittels &lt;code&gt;chmod 777 Script.py&lt;/code&gt;. &lt;small&gt;&lt;code&gt;chmod&lt;/code&gt; ist die Abkürzung für&quot;'''ch'''ange file '''mod'''e bits&quot;.&lt;/small&gt; 

&lt;small&gt;Die &quot;Maske&quot; &lt;code&gt;777&lt;/code&gt; ist nur für Testzwecke sinnvoll, weil sie leicht zu merken ist und für alle Benutzer alle Zugriffsberechtigungen ('''r'''ead/'''w'''rite/e'''x'''ecute für owner/group/others) setzt. Im richtigen Einsatz wird man das aus Sicherheitsgründen nicht so handhaben, sondern nur die Berechtigungen setzen, die unbedingt erforderlich sind. Welche Zugriffsberechtigungen gesetzt sind, kann man z.B. mit dem Befehl &lt;code&gt;ls -l&lt;/code&gt; oder &lt;code&gt;ll&lt;/code&gt; ('''l'''i'''s'''t directory contents) erfragen. Aber dazu im Moment genug. Erfahrene Linux-Nutzer kennen das ohnehin und Anfänger sollen jetzt nicht mit Linux-Interna überfordert werden. Bei Bedarf siehe die Linux-Man-Pages oder dezidierte Bücher zu Linux.&lt;/code&gt;&lt;/small&gt;

&lt;small&gt;Oder das Script wird in einen Pfad verschoben, in dem sich ausführbare Programme generell befinden (welche Verzeichnisse im PATH liegen, kann bspw. mit &lt;code&gt;echo $PATH&lt;/code&gt; abgefragt werden). Das Script kann dann wie ein normales Programm ohne weitere Angaben mit Script.py gestartet werden. Alternativ wird nicht das Script an sich verschoben, sondern nur ein symbolischer Link angelegt, z.B. mit &lt;code&gt;ln -s ~/tmp/Script.py ~/.local/bin/Script.py&lt;/code&gt;. &lt;code&gt;~/.local/bin&lt;/code&gt; sei ein im PATH gelegenes Verzeichnis. Dies sind aber schon Features für fortgeschrittene Linux-Benutzer und werden am Anfang eher selten benötigt.&lt;/small&gt;

== Ein paar Worte zur Erklärung ==
=== Tests ===
Getestet wurden die Beispiele unter den Betriebssystemen 
* MS Windows 10 mit der Python-Version 3.12.0 (teilweise auch mit 3.12.2 und 3.13.1; nur die Inhalte die bis spätestens Juli 2025 erstellt wurden) 
* MS Windows 11 ab der Python-Version 3.13.4 (nur zum Teil; ab Juli 2025)
* openSUSE Leap 15.6 mit der Python-Version 3.11.12 (Spyder, nur vereinzelt) und zum Teil mit 3.12.11 (ab Juli 2025 bis November 2025).
* openSUSE Tumbleweed ab der Python-Version 3.13.9 (nur vereinzelt, ab November 2025)

=== Popularität ===
* An Beliebtheit rangiert Python mit Stand September 2026 mit einem Rating von 17,76% an 1. Stelle vor C und C++ (lt. [https://www.tiobe.com/tiobe-index/ TPCI - TIOBE Programming Community Index]). 
* Lt. [https://innovationgraph.github.com/global-metrics/programming-languages GitHub Top 50 Programming Languages Globally] lag Python im Q1/2026 auf Rang 2, vor TypeScript und hinter JavaScript. 
* [https://pypl.github.io/PYPL.html PYPL] (Popularity of Programming Language Index) ist ein anderer Popularitätsindex für Programmiersprachen. Auch hier liegt Python mit großem Vorsprung auf dem ersten Platz (52,08%), gefolgt von Java (13,34%) und C/C++ (7,99%) (Stand September 2026). 

=== Namensgebung ===
Der Name &quot;Python&quot; rührt von der Komikertruppe {{W|Monty Python}} her. Die Icons für Python (z.B. Python selbst, Eric IDE, IDLE) sind aber durch die Python-Schlangenart symbolisiert.

&lt;gallery&gt;
Python-logo-notext.svg|Python-Logo
Guido van Rossum in PyConUS24.jpg|{{W|Guido van Rossum}} (geb. 1956), der Erfinder von Python
&lt;/gallery&gt;

== Ein erstes Programm ==
Kommentare werden in Python mit der Raute (#) eingeleitet. Sie werden vom Python-Interpreter ignoriert. Text kann mit der print-Funktion ausgegeben werden. Starten Sie Python und geben sie folgende Anweisungen zeilenweise ein

 &gt;&gt;&gt; # Das ist ein Kommentar
 &gt;&gt;&gt; print(&quot;Hallo Welt!&quot;)

Als Ergebnis erhalten Sie

 Hallo Welt!

Der Prompt (&gt;&gt;&gt;) ist selbstverständlich nicht einzutippen, sondern wird vom Python-System geliefert.

Strings können in Python entweder in Anführungszeichen (&quot;) gesetzt werden oder in Hochkommatas('). In diesem Text wird die erste Variante bevorzugt eingesetzt.

Im Gegensatz zu Julia ist es hier egal, ob zwischen &lt;code&gt;print&lt;/code&gt; und der öffnenden Klammer Leerzeichen stehen.

= Python als Taschenrechner =
== Allgemeines ==
Wir wollen 3 * 5 berechnen. Dazu starten wir Python im interaktiven Modus. Geben Sie dann die Formel  

 &gt;&gt;&gt; 3 * 5

ein, drücken die Taste ENTER/RETURN ({{Taste|↵}}) und erhalten als Ergebnis

 15

Auch kompliziertere Ausdrücke sind möglich. Beispielsweise mit Winkelfunktionen, Quadratwurzeln etc. Wir wollen nun den Ausdruck &lt;math&gt;\sin\sqrt{15}&lt;/math&gt; berechnen :

 &gt;&gt;&gt; import math
 &gt;&gt;&gt; math.sin(math.sqrt(15))
 -0.6679052983383519

Als erstes wird das math-Modul importiert. Dann wird der mathematische Ausdruck berechnet.

Eine andere Variante, die dasselbe Ergebnis liefert, ist

 &gt;&gt;&gt; from math import *
 &gt;&gt;&gt; sin(sqrt(15))
 -0.6679052983383519

Es wird also aus dem Modul &lt;code&gt;math&lt;/code&gt; alles importiert (erkennbar am &lt;code&gt;*&lt;/code&gt;). Will man nicht alles importieren, so kann man das auch einschränken:

 &gt;&gt;&gt; from math import sin, sqrt

Beenden lässt sich das Python-Programm durch Eingabe von &lt;code&gt;exit()&lt;/code&gt; (und natürlich ist zur Bestätigung die RETURN-Taste zu drücken). &lt;code&gt;exit&lt;/code&gt; (ohne Klammern) oder &lt;code&gt;quit&lt;/code&gt; werden auch akzeptiert.

== Die Hilfefunktion von Python ==
Bei Eingabe der Anweisung &lt;code&gt;help&lt;/code&gt; oder &lt;code&gt;help()&lt;/code&gt; springt Python in den Hilfemodus. 

Eingabe:
 &gt;&gt;&gt; help()
 
Eingabe:
 help&gt; math.sin

Ausgabe:
 Help on built-in function sin in math:
 
 math.sin = sin(x, /)
     Return the sine of x (measured in radians).

Für die komplette Python-Dokumentation siehe [https://docs.python.org/3/]. Verlassen kann man den Hilfemodus durch das Drücken von STRG-C, bzw. der Eingabe von q, quit oder exit mit anschließendem Drücken der RETURN-Taste.

== Aufgaben ==
* Erkunden Sie die Tangensfunktion &quot;tan&quot; mittels Python-Hilfe (vergessen Sie nicht das math-Modul zu importieren und das &lt;code&gt;math.&lt;/code&gt; vor &lt;code&gt;tan&lt;/code&gt;)
* Berechnen Sie mit Python den Ausdruck &lt;math&gt;\frac{1}{2}\cdot \text{e}^2 \cdot \tan(\pi/3)&lt;/math&gt;. Siehe für die Exponentialfunktion im Python-Hilfesystem auch den Befehl &lt;code&gt;math.exp&lt;/code&gt;. Alternativ kann auch die Konstante &lt;code&gt;math.e&lt;/code&gt; eingesetzt werden. Potenzieren kann man bei Python mit dem **-Operator (z.B. 2**3 = 8). Für &lt;math&gt;\pi&lt;/math&gt; gibt es &lt;code&gt;math.pi&lt;/code&gt;.

= Python als Scriptsprache =
Häufig wird man aber kompliziertere Anweisungsfolgen verarbeiten müssen. Diese will man normalerweise nicht jedesmal neu eingeben, sondern in einer Datei speichern und diese Datei dann zur Ausführung bringen. Speichern Sie dazu folgenden Code in einer Textdatei, z.B. unter MS Windows als c:\tmp\test1.py

 # Das ist ein Kommentar
 print(&quot;Hallo Welt!&quot;)

Python-Dateien werden mit der Dateiendung .py versehen. Achten Sie darauf, dass vor dem print keine Leerzeichen vorhanden sind. Das ist eine Python-Eigenheit. Wie wir später sehen werden, nutzt Python Einrückungen als syntaktisches Mittel, z.B. um bei Schleifen den Schleifenkörper zu kennzeichnen. 

Danach bringen Sie die Skriptdatei test1.py (sozusagen das Hauptprogramm) folgendermaßen zur Ausführung:

1) Starten Sie unter MS Windows die Eingabeaufforderung (oder alternativ auch die Windows PowerShell). Das sieht dann etwa so aus:

 Microsoft Windows [Version 10.0.19045.3693]
 (c) Microsoft Corporation. Alle Rechte vorbehalten.
 
 C:\Users\xyz&gt;

: &lt;small&gt;Falls jemand nicht weiß, wie man die Eingabeaufforderung startet: Eine Möglichkeit ist, einfach in der Taskleiste von Windows das &quot;Start&quot;-Symbol &amp;nbsp;([[Image:Windows_logo_-_2021_(Black).svg|10px]])&amp;nbsp; mit der rechten Maustaste anklicken. &quot;Ausführen&quot; auswählen (oder alternativ für die PowerShell unter Windows 10 den Eintrag &quot;Windows PowerShell&quot;, unter Windows 11 den Eintrag &quot;Terminal&quot;). Im sich öffnenden Dialogfenster gibt man in die &quot;Öffnen&quot;-Zeile das Wort &lt;code&gt;cmd&lt;/code&gt; ein und mit &quot;OK&quot; wird das Ganze bestätigt.&lt;/small&gt; 
 
2) Wechseln Sie mittels &lt;code&gt;cd c:\tmp&lt;/code&gt; in das Verzeichnis c:\tmp

3) Angenommen, Sie haben Python unter dem Pfad &lt;code&gt;c:\devel\Python\&lt;/code&gt; installiert. Starten Sie das Programm so (der Prompt &lt;code&gt;c:\tmp&gt;&lt;/code&gt;ist natürlich nicht mit einzutippen): 

 c:\tmp&gt;c:\devel\Python\python.exe test1.py

4) Wie erwartet ergibt sich folgende Ausgabe am Bildschirm

 Hallo Welt!

Die Vorgehensweise unter Linux ist prinzipiell gleich. Die kleinen Unterschiede, wie z.B. der Slash statt dem Backslash in Pfadangaben, sollten für Linux-Benutzer keine Hürde darstellen.

== Variablen ==
Variablenbezeichner können aus Buchstaben (A-Za-z), Ziffern (0-9) und Underscores (_) bestehen, dürfen aber nicht mit einer Zahl beginnen. Führende Underscores haben u.a. im Kontext mit der Objektorientierten Programmierung eine spezielle Bedeutung und sollten nicht für &quot;normale&quot; Variablenbezeichner verwendet werden.

Gültige Variablenbezeichner wären also:
 xyz
 x1
 _wert
 name_anzahl

Theoretisch kann man auch Umlaute, griechische Buchstaben u.ä. in Variablenbezeichnern nutzen, z.B.

 ößÜ = 16
 α = 134 
 print(ößÜ)
 print(α)

Ausgabe:
 16
 134

Davon wird aber aus offensichtlichen Gründen ({{W|Englisch als Lingua franca}}) abgeraten. Das Eurozeichen (€) etc. darf man ohnehin nicht in Variablenbezeichnern verwenden, dies ergäbe einen Syntaxfehler. Siehe dazu auch [https://peps.python.org/pep-3131/].

Es gibt in Python etliche Schlüsselwörter (z.B. for, if oder return). Diese dürfen nicht als eigene Variablenbezeichner verwendet werden. Eine Liste aller Schlüsselwörter liefert das Script

 import keyword
 print(keyword.kwlist)

&lt;small&gt;Übung: Speichern Sie dieses Script in eine Datei, z.B. in c:\tmp\test1.py. Führen Sie diese Datei aus, um die Liste der Schlüsselwörter auszugeben.&lt;/small&gt;

Da Python case-sensitiv ist, repräsentieren folgende Bezeichner verschiedene Variablen:
 xyz
 XYZ
 xYz

Werte werden an Variablen mittels Gleich-Zeichen (=) zugewiesen. Im Folgenden wird der Code immer in der Datei c:\tmp\test1.py gespeichert.

 x = 5
 y = 10
 z = x*y
 print(z)

Bringen Sie die Datei test1.py zur Ausführung, so erhalten Sie folgende Bildschirmausgabe

 50

Sie können auch mehrere Anweisungen in einer Zeile durch Semikolon getrennt schreiben. Dies führt aber zu unübersichtlichem Code.

 x = 5; y = 10; z = x*y; print(z)

Ausgabe:
 50

Auch aus der Programmiersprache C/C++ oder Java bekannte Konstrukte können Sie verwenden, z.B.
 x = 5
 # x = x - 2
 x -= 2
 print(x)

Bildschirmausgabe:

 3
 
Beachten Sie, dass mit dem =-Zeichen eine Wertezuweisung durchgeführt wird. Dies ist nicht äquivalent zum mathematischen =-Zeichen, wie am vorigen Beispiel zu ersehen ist. Den Inkrement-/Dekrementoperator (z.B. x++ oder x--) aus C/C++ oder Java kennt Python aber nicht.

Variablen sind nicht an einen bestimmten Datentyp gebunden, folgendes ist mit Python problemlos möglich:

 import math
 wert = 10
 print(wert)
 wert = 35.5
 print(wert)
 wert = &quot;Hallo&quot;
 print(wert)
 wert = math.pi
 print(wert)

Ausgabe:
 10
 35.5
 Hallo
 3.141592653589793

== Physische und logische Zeilen ==
In Python muss eine Anweisung in einer logischen Zeile Platz finden. Wird eine Anweisung aber zu lang für eine Zeile, dann kann sie in mehrere physische Zeilen unterteilt werden. Dies kann einerseits durch einen Backslash am Ende einer Zeile geschehen, z.B.

 a = 2 + \
 5
 
Dies stellt eine logische Zeile dar, die in zwei physische Zeilen unterbrochen ist.

Geklammerte Ausdrücke werden automatisch zu einer logischen Zeile verbunden, z.B.

 a = (2 + 
 5)
 
Achtung: Im ersten Beispiel darf nach dem Backslash nichts mehr stehen, auch kein Kommentar. Dies trifft im zweiten Bespiel nicht zu, hier könnte noch ein Kommentar folgen, z.B.

 a = (2 +    # Kommentar 
 5)

Auch für Strings gibt es Möglichkeiten, diese auf mehrere Zeilen aufzuspalten.

 # Kurzer String
 str1 = &quot;ABC&quot;
 
 # Langer String
 str2 = &quot;&quot;&quot;Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle&quot;&quot;&quot;
 
 # Backslash
 str3 = &quot;UVW\
 XYZ&quot;
 
 # Mit Klammern
 str4 = (&quot;Sehr langer Text, der automatisch .............. &quot;
         &quot;in einer einzigen Variable zusammengefügt wird.&quot;
 )
 
 print(str1)
 print(str2)
 print(str3)
 print(str4)

Ausgabe:

 ABC
 Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle
 UVWXYZ
 Sehr langer Text, der automatisch .............. in einer einzigen Variable zusammengefügt wird.

==Hexadezimale, oktale, binäre und andere Zahlen==
 d = 1050         # Dezimalzahl
 h = 0xAA2        # Hexadezimalzahl
 o = 0o12         # Oktalzahl
 b = 0b100001101  # Binärzahl
 
 print(d)
 print(h)
 print(o)
 print(b)

Ausgabe:
 1050
 2722
 10
 269

Groß- und Kleinbuchstaben sind in obigen Literalen übrigens egal. So kann man z.B. statt &lt;code&gt;0b1001&lt;/code&gt; auch &lt;code&gt;0B1001&lt;/code&gt; schreiben (siehe dazu [https://docs.python.org/3/reference/lexical_analysis.html#integer-literals]).

Sie können auch dezimale in hexadezimale Zahlen umwandeln, usw.:
 h = hex(1050)    # Dezimalzahl -&gt; Hexadezimalzahl
 b = bin(1050)    # Dezimalzahl -&gt; Binärzahl
 o = oct(1050)    # Dezimalzahl -&gt; Oktalzahl
 print(h)
 print(b)
 print(o)

Ausgabe:
 0x41a
 0b10000011010
 0o2032

Gegeben sei die Zahl 121 zur Basis 3. Diese soll in eine Dezimalzahl umgewandelt werden. Das kann so geschehen:

 z = int(&quot;121&quot;, 3)
 print(z)

Ausgabe:
 16

Dass dies richtig ist, davon kann man sich folgendermaßen überzeugen:
 &lt;math&gt; 1 \cdot 3^2 + 2 \cdot 3^1 + 1 \cdot 3^0 = 9 + 6+ 1 = 16 &lt;/math&gt;

Zahlen übersichtlicher schreiben kann man auch mittels Underscore, z.B.:

 print(&quot;Eine Million (Variante 1) =&quot;, 1000000)
 print(&quot;Eine Million (Variante 2) =&quot;, 1_000_000)
 print(&quot;Eine Rechnung:&quot;, 2_000 * 400_000);

Es ergibt sich bei beiden Varianten die gleiche Ausgabe. Variante 2 ist aber im Sourcecode leichter lesbar, detto die Zahlen in der Rechnung:

 Eine Million (Variante 1) = 1000000
 Eine Million (Variante 2) = 1000000
 Eine Rechnung: 800000000

== Strings und Platzhalter==
Ein paar einfache Beispiele:

 print(&quot;Hallo {}&quot; . format(&quot;Hugo&quot;))     # new style string formatting
 print(&quot;Hallo {:s}&quot; . format(&quot;Hugo&quot;))   # new style string formatting
 print(&quot;Hallo %s&quot; % &quot;Hugo&quot;)             # %-String

Ausgabe:

 Hallo Hugo
 Hallo Hugo
 Hallo Hugo

Python-Code (formatted string literals, Beispiel 1):
 str1 = &quot;Hallo&quot;
 str2 = &quot;Hugo&quot;
 print(f&quot;{str1} {str2}&quot;)

Ausgabe:
 Hallo Hugo

f-Strings (ab Python 3.6) sind die modernere Variante gegenüber %-Strings oder das ''new style string formatting''. Sie sind in der Regel auch schneller.

Python-Code (formatted string literals, Beispiel 2):
 wert = 11.567
 print(f&quot;Ausgabe: {wert:.5f}&quot;)

Ausgabe:
 Ausgabe: 11.56700

Komplexere Beispiele:

 print(&quot;Hallo {} und {}&quot; . format(&quot;Hugo&quot;, &quot;Mike&quot;))
 print(&quot;Hallo {name1} und {name2}&quot; . format(name2=&quot;Hugo&quot;, name1=&quot;Mike&quot;))
 # Füllzeichen: *
 # Bündigkeit: &gt; (=rechts), &lt; (=links), ^ (=zentriert)
 # Feldweite: 10
 # Typ: s (=String), f (=Gleitkommazahl), d (=Dezimalzahl) etc.
 print(&quot;Hallo {:*&gt;10s}&quot; . format(&quot;Hugo&quot;))
 print(&quot;Hallo {:*&lt;10s}&quot; . format(&quot;Hugo&quot;))

Ausgabe:

 Hallo Hugo und Mike
 Hallo Mike und Hugo
 Hallo ******Hugo
 Hallo Hugo******

Python-Code:
 str = &quot;Hallo\t%s\t%7.2f\t%10.2e\t%i&quot; % (&quot;Hugo&quot;, 12.34567, 34.567, 264)
 print(str)

Ausgabe:
 Hallo	Hugo	  12.35	  3.46e+01	264

== Unicode ==
Neben den bekannten ASCII-Zeichen lassen sich Zeichen auch mittels Unicode beschreiben. Griechische Buchstaben oder komplexere mathematische Operatoren - all das sollte kein Problem sein. Siehe auch {{W|Unicode}}, {{W|Liste der Unicodeblöcke}} und {{W|Unicodeblock Mathematische Operatoren}}. Im Folgenden werden ein paar Zeichen (Allquantor, Nabla-Operator, Existenzquantor), die man aus der Mathematik kennt, erzeugt. 
 
 ch1 = &quot;\N{FOR ALL}&quot;
 ch2 = &quot;\N{NABLA}&quot;
 ch3 = &quot;\u2203&quot;
 print(ch1, ch2, ch3)

Ausgabe:
 ∀ ∇ ∃

&lt;small&gt;Diese Ausgabe ergibt sich z.B. mit der IDLE-Shell oder mit Cygwin. Beim Ausführen über die Windows-Eingabeaufforderung oder Windows PowerShell unter MS Windows 10 erfolgt keine korrekte Darstellung. IDLE ist die mit Python mitgelieferte IDE ('''I'''ntegrated '''D'''evelopment '''E'''nvironment, Integrierte Entwicklungsumgebung). Gegen Ende dieses Textes wird IDLE kurz beschrieben.
Das Problem mit der Windows Eingabeaufforderung lässt sich aber umgehen. Man muss nur eine Schriftart auswählen, die die Zeichen kennt, z.B. &quot;DejaVu Sans Mono&quot;. Dazu klicken Sie einfach bei der Eingabeaufforderung mit der rechten Maustaste oben auf die weiße Leiste und wählen im aufpoppenden Fenster den Menüpunkt &quot;Eigenschaften&quot;. Es öffnet sich ein Dialogfenster. Über den Reiter &quot;Schriftart&quot; lässt sich nun die Schriftart einstellen. Unter MS Windows 11 oder openSUSE Leap 15.6 (bash-Konsole) gibt es dieses Problem ohnehin nicht.&lt;/small&gt;

== Reguläre Ausdrücke ==
Python kennt auch {{W|Regulärer Ausdruck|reguläre Ausdrücke}}. Dazu gibt es in Python das Modul &lt;code&gt;re&lt;/code&gt;. Beipielsweise sollen alle Zahlen (&lt;math&gt;\text{zahl}\in\mathbb{N}_0&lt;/math&gt;) in einem String gesucht und ausgegeben werden. Als String sei gegeben: &lt;code&gt;3x Grüße und 100 Kekse.&lt;/code&gt; Das Muster (Pattern) ist &lt;code&gt;\d+&lt;/code&gt;. &lt;code&gt;\d&lt;/code&gt; steht für eine Dezimalziffer 0-9. Das Plus-Zeichen (+) steht symbolisch für ein oder mehrere Zeichen des vorherigen Ausdrucks. Hier also ein oder mehrere Dezimalziffern. Es wird die Funktion &lt;code&gt;findall&lt;/code&gt; aus dem Modul &lt;code&gt;re&lt;/code&gt;verwendet.

Python-Code:
 from re import findall
 
 str = &quot;3x Grüße und 100 Kekse.&quot;
 pat = &quot;\\d+&quot;  # Doppel-Backslashes müssen verwendet werden, sonst gibt Python eine Warnung aus!
               # alternativ: pat = r&quot;\d+&quot; 
               # oder: pat = &quot;[0-9]+&quot;
 
 numb = findall(pat, str)
 print(numb)

Ausgabe:
 ['3', '100']

Python kennt noch viele weitere Möglichkeiten mittels regulärer Ausdrücke zu hantieren. Dies soll hier aber nicht vertieft werden, da das Thema schon ziemlich speziell und komplex ist. Bei Bedarf siehe aber z.B. die Bücher ''Weigend, Seite 380ff'' und ''Ernesti, Kaiser'' [https://openbook.rheinwerk-verlag.de/python/28_001.html] oder die Python-Dokumentation [https://docs.python.org/3/library/re.html]. Auch [[Python unter Linux: Reguläre Ausdrücke]] liefert ein umfangreiches und brauchbares Python-2-Kapitel zu den regulären Ausdrücken. Die dort gelisteten Beispiele müssten ggf. vor Verwendung auf Python-3 umgeschrieben werden. &lt;small&gt;Wie macht  man das? Dazu siehe z.B. [https://openbook.rheinwerk-verlag.de/python/43_001.html], [https://portingguide.readthedocs.io/en/latest/] oder [https://www.digitalocean.com/community/tutorials/how-to-port-python-2-code-to-python-3]&lt;/small&gt;

&lt;small&gt;Es gibt auch ein externes Modul ''regex'', das bei Bedarf extra installiert werden muss ([https://pypi.org/project/regex/]). Es bietet zusätzliche Funktionalität und gründlicheren Unicode-Support. Dies sei hier aber nur der Vollständigkeit halber erwähnt.&lt;/small&gt;

== Verzweigungen ==
=== if ===
Die IF-Verzweigung sei aus anderen Programmiersprachen bereits bekannt. In {{W|Pseudocode}} lässt sie sich folgendermaßen darstellen:

 WENN bedingung TRUE
   führe block1 aus
 SONST
   führe block2 aus
 ENDE 

Als {{W|Aktivitätsdiagramm|UML-Aktivitätsdiagramm}} sieht das in etwa so aus:

[[File:If-Then-Else-diagram.svg|200px]]

Und als {{W|Nassi-Shneiderman-Diagramm|Nassi-Shneiderman-Struktogramm}} so:

[[File:Zweiseitige Auswahl.png|250px]]

In Python gibt es keinen expliziten ENDE-Kennzeichner. Stattdessen wird der Code durch Einrückungen strukturiert. Alles mit der gleichen Einrückungstiefe gehört zum selben Block. Dies zeichnet Python vor anderen Programmiersprachen aus.

Die test1.py-Datei laute also wie folgt:

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
   print(&quot;x ist groesser oder gleich 4&quot;)  

Ausgabe:

 Der else-Zweig wird ausgefuehrt
 x ist groesser oder gleich 4

Man achte auch auf die Doppelpunkte in der if- und else-Zeile. Darauf vergisst man gerne, wenn man von anderen Programmiersprachen kommt.

Folgendes wäre in Python ein Fehler (genauer gesagt ein IndentationError).

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
     print(&quot;x ist groesser oder gleich 4&quot;)  

Auch Nachstehendes würde nicht zum gewünschten Ergebnis führen (löst aber keine Fehlermeldung aus). Der letzte print-Befehl ist schon außerhalb der IF-ELSE-Verzweigung.

 x = 3
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
 print(&quot;x ist groesser oder gleich 4&quot;)

Ausgabe:

 x ist kleiner als 4
 x ist groesser oder gleich 4

Python kennt eine Reihe von Vergleichs- und Verknüpfungsoperatoren:

    &lt;, &lt;= ... kleiner (gleich)
    &gt;, &gt;= ... größer (gleich)
    == ... gleich
    != ... ungleich
    is ... identisch
    is not ... nicht identisch
    and ... AND
    or ... OR
    not ... NOT

Beispielsweise:

 a = 5
 b = 9
 
 if a&lt;=10 and b!=7:
   print(&quot;OK&quot;)
 else
   print(&quot;Nicht OK&quot;)

Ausgabe:

 OK

Der else-Block kann übrigens auch ersatzlos entfallen. Als Pseudocode sieht das so aus

 WENN bedingung TRUE
   führe block aus
 ENDE

Mehrfache Verzweigungen werden durch das elif-Konstrukt erstellt. In Pseudocode:

 WENN bedingung1 TRUE
   führe block1 aus
 SONST WENN bedingung2 TRUE
   führe block2 aus
 SONST WENN bedingung3 TRUE
   führe block3 aus
 SONST
   führe block4 aus
 ENDE

Ein Python-Beispiel:
 a = 14
 
 if a&lt;=10:   
   print(&quot;&lt;=10&quot;)
 elif a&gt;=11 and a&lt;=15:
   print(&quot;11 bis 15&quot;)
 elif a&gt;=16 and a&lt;=20:
   print(&quot;16 bis 20&quot;)
 else:
   print(&quot;&gt;20&quot;)

Ausgabe:

 11 bis 15

In Python gibt es auch die Schlüsselwörter &lt;code&gt;True&lt;/code&gt; (für wahr) und &lt;code&gt;False&lt;/code&gt; (für falsch). Man beachte, dass sie mit Großbuchstaben beginnen. Andere Schreibweisen wären ein Fehler. Sie gehören zum Datentyp &lt;code&gt;bool&lt;/code&gt;. Ihnen sind auch die Zahlen &lt;code&gt;1&lt;/code&gt; und &lt;code&gt;0&lt;/code&gt; zugewiesen.

Man beachte, dass {{W|Rundungsfehler}} auftreten können. D.h. man sollte  bei der Verwendung von {{W|Gleitkommazahl|Gleitpunktzahlen}} niemals auf absolute Genauigkeit prüfen, sondern eine Toleranz (einen &lt;math&gt;\varepsilon&lt;/math&gt;-Wert) vorgeben.
 
Ein klassisches Beispiel, das ein falsches Ergebnis liefert, ist:

 i = 0.1 + 0.2
 
 print(i)
 
 if i == 0.3:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 NOK

Und das, obwohl man schon in der Volksschule lernt, dass 0.1 + 0.2 gleich 0.3 ist.

Korrekt muss das obige Beispiel z.B. so umgeschrieben werden:

 ist = 0.1 + 0.2
 soll = 0.3
 epsilon = 0.000001
 
 print(ist)
 
 if abs(ist-soll) &lt; epsilon:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 OK

Alternativ kann auch die &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion verwendet werden. Das sei aber hier nur erwähnt und nicht konkret ausgeführt.

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet zum Thema &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion.

=== match ===
Ab Python 3.10 gibt es auch die match-Anweisung. Dies ist das Python-Pendant für die switch-Anweisung in anderen Programmiersprachen, geht aber bei näherer Betrachtung weit darüber hinaus. Hier nur ein einfaches Beispiel:

 x = &quot;Hello&quot;
 
 match x:
     case &quot;Servus&quot; | &quot;Ciao&quot;:         # or
         print(&quot;Servus an alle&quot;)
     case &quot;Grüetzi&quot;:
         print(&quot;Grüetzi Schwyzer&quot;)  
     case _:                         # other, default, sonstiges ...
         print(&quot;Hallo Welt&quot;)

Ausgabe: 
 Hallo Welt

Als Struktogramm sieht das in etwa so aus:

[[File:Mehrseitige Auswahl.png|250px]]

Für nähere Details siehe z.B. [https://www.geeksforgeeks.org/python-match-case-statement/], [https://learnpython.com/blog/python-match-case-statement/], [https://docs.python.org/3/tutorial/controlflow.html#match-statements] und das Python Enhancement Proposal (PEP) 636 – Structural Pattern Matching: Tutorial [https://peps.python.org/pep-0636] und dort insbesondere den Anhang A - Quick Intro.

&lt;small&gt;&lt;code&gt;match, case, _&lt;/code&gt; etc. sind sogenannte ''soft keywords''. Im Gegensatz zu den normalen Schlüsselwörtern dürfen ihnen auch Werte zugewiesen werden. Eine Liste der weichen Schlüsselwörter lässt sich durch &lt;code&gt;keyword.softkwlist&lt;/code&gt; erstellen (die Anweisung gibt es seit Python 3.9). Siehe dazu auch [https://stackoverflow.com/questions/65800344/what-are-soft-keywords] und [https://docs.python.org/3/library/keyword.html#keyword.softkwlist].&lt;/small&gt;

== Schleifen ==
Kopfgesteuerte Schleife, Endlosschleife und fußgesteuerte Schleife:

[[File:Programmingloops.svg|450px]]

=== while ===
Die WHILE-Schleife ist kopfgesteuert. Sie funktioniert wie aus anderen Programmiersprachen bekannt. 

In Pseudocode:
 SOLANGE bedingung TRUE
   führe block aus
 ENDE

In Python:
 x = 0
 
 while x &lt;= 10:
   print(x)
   x += 1

Ausgabe:
 0
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10

Eine Endlosschleife ergibt sich z.B. so:
 i = 5
 
 while True:
     print(i)
     i-=1

Beendet werden kann sie mit der Tastenkombination STRG-C.

Eine fußgesteuerte Schleife kann so simuliert werden:
 i = 5
 
 while True:
     print(i)
     i-=1
 
     if i&lt;=0:
         print(&quot;Fire&quot;)
         break

Ausgabe:
 5
 4
 3
 2
 1
 Fire

Der &lt;code&gt;break&lt;/code&gt;-Befehl wird etwas [[Ing_Mathematik:_Python#break|später]] noch einmal kurz thematisiert.

=== for ===
Struktogramm einer for-Schleife:

[[File:Zählschleife.png|200px]]

In Python bspw. so:

 for x in range(6):
   print(x*2)

Ausgabe:
 0
 2
 4
 6
 8
 10

Die Schleife läuft von 0 bis 5. Ausgegeben wird jeweils der Wert x*2. Aquivalent kann diese Schleife auch so geschrieben werden:
 for x in range(0, 11, 2):
   print(x)

Die Ausgabe ist wie oben. Der Startwert sei 0, der Endwert ist 11-1 und die Schrittweite ist 2.

Ein anderes Beispiel sei
 for x in &quot;text&quot;:
   print(x)

Ausgabe:
 t
 e
 x
 t

== Schleifen abbrechen ==
=== break ===
&lt;code&gt;break&lt;/code&gt; bricht die Schleife ab und setzt mit dem nächsten Befehl außerhalb der Schleife fort.

 for var in range(100):
   print(var) 
   if var == 5:
     break

Ausgabe:
 0
 1
 2
 3
 4
 5

=== continue ===
&lt;code&gt;continue&lt;/code&gt; bricht den aktuellen Schleifendurchlauf ab und setzt mit dem nächsten Schleifendurchlauf fort.

 for var in range (11):
   if var == 5:
     continue
   print(var)

Ausgabe:
 0
 1
 2 
 3
 4
 6
 7
 8
 9
 10

== try - except ==
 try:
     z1 = 12 / 0
     print(z1)
 except ZeroDivisionError:
     print(&quot;Das Ergebnis ist unendlich&quot;)
 except:
     print(&quot;Kann nicht berechnet werden!&quot;)
     print(&quot;Bitte die Formel korrigieren!&quot;)
 
 print(&quot;Setze Programm fort!&quot;)

Ausgabe:
 Das Ergebnis ist unendlich
 Setze Programm fort!

Es wird versucht, eine Zahl durch Null zu dividieren. Das ist nicht möglich, es wird eine Ausnahme ausgelöst. Das Programm springt daher in den except-ZeroDivisionError-Block und führt die dort gelisteten Anweisungen aus (in unserem Fall eine print-Anweisung). Danach wird das Programm fortgesetzt. Würden wir dieses Programm ohne try-except ausführen, so ergibt sich aus

 z1 = 12 / 0
 print(z1)

folgende Fehlermeldung und ein unmittelbarer Programmabbruch

 Traceback (most recent call last):
   File &quot;C:\tmp\test1.py&quot;, line 1, in &lt;module&gt;
     z1 = 12 / 0
 ZeroDivisionError: division by zero

Mit dem try-except-Mechanismus können also Ausnahmen oder Fehler aufgefangen und behandelt werden. In unserem Beispiel ist das eher trivial, aber bei größeren Programmen kann das durchaus Sinn machen.

Neu in Python 3.14 ist, dass mehrere Ausnahmen auch ohne Klammern angegeben werden können, z.B.:

bis inkl. Python 3.13 nur:
 except (ZeroDivisionError, ValueError):

ab Python 3.14 auch:
 except ZeroDivisionError, ValueError:

== pass ==
Ein leerer Block muss in Python mittels dem Schlüsselwort &lt;code&gt;pass&lt;/code&gt; dargestellt werden. Z.B.

 x = 2
 
 if x == 1:
     print(&quot;Wert ist &quot;, x)
 else:
     pass

Würde man das &lt;code&gt;pass&lt;/code&gt; im else-Block weglassen, so würde man eine Fehlermeldung erhalten:

 IndentationError: expected an indented block after 'else' statement on line 5

= Funktionen =
== Aufrufen von Funktionen ==
Funktionen sind uns im Rahmen dieses Kurses schon zuhauf begegnet. Sei es die print()-, die math.sin()- oder die hex()-Funktion. All diese Funktionen werden von Python zur Verfügung gestellt, ohne dass man sie explizit programmieren müsste. Aufgerufen werden diese Funktionen, indem man ihren Namen eintippt, gefolgt von runden Klammern. In diesen Klammern können noch Argumente übergeben werden. Auch Rückgabewerte sind möglich.

== Funktionen selber schreiben ==
Funktionen werden mit dem def-Schlüsselwort (man definiert die Funktion) eingeleitet, danach folgt der Funktionsname, danach wiederum runde Klammern, in denen formale Argumente stehen können. Abgeschlossen wird die def-Zeile mit einem Doppelpunkt. Danach folgt der Funktionskörper. Dieser Funktionskörper muss wiederum eingerückt werden (wie von den Verzweigungen und Schleifen bekannt). Aufgerufen wird diese Funktion, indem man ihren Funktionsnamen eingibt, gefolgt von runden Klammern (ggf. mit den aktuellen Parametern). Z.B.

 # Funktion definieren
 def halloWelt(i):
     # i ... beliebige Ganzzahl
     print(&quot;Hallo &quot; * i, end=&quot;&quot;)
     print(&quot;Welt!&quot;)
    
 # Funktion aufrufen
 halloWelt(3)

Ausgabe:
 Hallo Hallo Hallo Welt!

Unterschied zwischen formalen und aktuellen Parametern:

[[Datei:PythonIng_func1.jpg]]

&lt;small&gt;Aktuelle Parameter werden auch Argumente genannt.&lt;/small&gt;

Rückgabe von Funktionswerten:
 # Funktion definieren
 def mathFunc(a, b):
     r1 = a + b
     r2 = a * b
     return r1, r2
    
 # Funktion aufrufen
 c, d = mathFunc(3, 5)
 
 # Ausgabe der zurückgegebenen Werte
 print(c)
 print(d)

Ausgabe:
 8
 15

Es werden r1 und r2 zurückgegeben und den Variablen c und d zugewiesen. (r1, r2) und (c, d) sind Tupel. Was Tupel konkret sind, siehe etwas später in diesem Kapitel. 3 und 5 sind die aktuellen Parameter (die Argumente). a und b sind die formalen Parameter. Die Zuweisung der aktuellen zu den formalen Parametern erfolgt in der gegebenen Reihenfolge, also die Zahl 3 wird an a übergeben und die Zahl 5 an b.

Vorgabeparameter, z.B.:
 def mathFunc(a=10, b=20):
     r1 = a + b
     r2 = a * b
     return r1, r2
 
 c, d = mathFunc(3, 5)
 print(c)
 print(d) 
 
 e, f = mathFunc(5)
 print(e)
 print(f)
 
 g, h = mathFunc(b=6)
 print(g)
 print(h)

Ausgabe:
 8
 15
 25
 100
 16
 60

Erklärung:
* Erster &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es werden, wie weiter oben, die Argumente 3 und 5 an die formalen Parameter a und b übergeben. Die Rückgabewerte r1 und r2 werden an c und d übergeben. Somit ist c=8 und d=15.
* Zweiter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur das Argment 5 an a übergeben. b behält den Vorgabewert 20. D.h. e= 25 und f=100.
* Dritter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur die Zahl 6 an b übergeben, a behält seinen Vorgabewert 10. Somit ergibt sich g=16 und h=60.

Beispiel (Schlüsselwortargumente vs. Positionsargumente):
 def mathFunc(a, b):
     r1 = a - b
     r2 = a / b
     return r1, r2
 
 c, d = mathFunc(b=3, a=5)  # Schlüsselwortargumente
 e, f = mathFunc(3, 5)      # Positionsargumente

 print(c)
 print(d)
 print(e)
 print(f)

Ausgabe:
 2
 1.6666666666666667
 -2
 0.6

Durch die Verwendung von Schlüsselwortargumenten können die Argumente in beliebiger Reihenfolge angegeben werden. Bei den Positionsargumenten ist die Reihenfolge vorgegeben. Daraus resultiert auch der Unterschied bei den obigen Ausgaben. Werden beide Arten in einem Aufruf gemischt, so müssen die Positionsargumente zuerst angegeben werden. Den Unterschied zwischen beiden Argumentarten zu kennen ist wichtig, nicht nur bei selbst erstellten Funktionen. Auch beim Aufruf von Python-Funktionen verfolgt einen die Mischung von Schlüsselwort- und Positionsargumenten auf Schritt und Tritt, z.B. beim etwas später folgenden Abschnitt über &quot;Grafiken zeichnen&quot;:

 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)

Bei dieser &lt;code&gt;plot&lt;/code&gt;-Funktion aus dem Modul &lt;code&gt;matplotlib.pyplot&lt;/code&gt; sind &lt;code&gt;x&lt;/code&gt; und &lt;code&gt;y1&lt;/code&gt; Positionsargumente. &lt;code&gt;label, lw&lt;/code&gt; und &lt;code&gt;ls&lt;/code&gt; sind die Namen der Schlüsselwortargumente. Die Schlüsselwortargumente könnten auch in anderer Reihenfolge angeschrieben werden, nicht jedoch die Positionsargumente!
Siehe zu &lt;code&gt;matplotlib.pyplot.plot&lt;/code&gt; auch die Seite [https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html].

== Lambda-Funktionen ==
 print((lambda a, b: a*b) (3, 5))

Ausgabe:
 15

Eingeleitet wird eine Lambda-Funktion (auch Lambda-Form, Lambda-Operator oder anonyme Funktion genannt) mit dem Schlüsselwort &lt;code&gt;lambda&lt;/code&gt;. Es folgen die formalen Argumente, danach ein Doppelpunkt, die Berechnungsvorschrift und ggf. abschliessend in Klammern die aktuellen Parameter.

Man kann einer Lambda-Funktion auch einen Funktionsnamen geben und die Funktion über diesen Namen aufrufen, z.B.

 prod = lambda a, b: a*b
 print(prod(3, 5))

Als Ausgabe wird wieder die Zahl 15 geliefert.

== Rekursive Funktionen ==
Funktionen können wiederum andere Funktionen aufrufen. Von einem {{W|Rekursion|rekursiven Funktionsaufruf}} spricht man, wenn die aufgerufene Funktion gleich der aufrufenden ist. 

 def printFunc(i):
     if (i &gt;= 5):
         return 
     else:
         print(&quot;Hallo Welt&quot;)
         printFunc(i+1)
         
 printFunc(1)

Ausgabe:
 Hallo Welt
 Hallo Welt
 Hallo Welt
 Hallo Welt

Typische Beispiele für die Abarbeitung als rekursive Funktionen sind die {{W|Fibonacci-Folge}} und die {{W|Fakultät_(Mathematik)|Fakultät}}. Jedoch ist der iterative Ansatz (mit konventionellen Schleifen) meist schneller und speicherplatzschonender.

== Funktionsannotationen ==
Python ist sehr flexibel, was Typen angeht. Im Vorhergehenden haben wir generell keine Typangaben gemacht. Will man Typen angeben, so bietet Python das Konzept der Funktionsannotation.

 def calcFunc(a: int, b: int) -&gt; int:
     return a+b
 
 r1 = calcFunc(8, 9)
 r2 = calcFunc(8.0, 9.0)
 r3 = calcFunc(&quot;Hallo&quot;, &quot;Welt&quot;)
 
 print(r1)
 print(r2)
 print(r3)

Ausgabe:
 17
 17.0
 HalloWelt

Jetzt sieht man auf den ersten Blick, welche Typen der Programmierer im Sinn hatte, als er die Funktion erstellte. Das Problem dabei ist nur, dass es Python ziemlich egal ist, welche Typen man im Endeffekt eingibt. Im obigen Beispiel können statt Integer-Typen u.a. auch Float- oder String-Typen eingegeben werden.

&lt;small&gt;
Siehe zum Thema &quot;Type Checking&quot; aber auch den später folgenden Abschnitt [[Ing_Mathematik:_Python#Type_Checker]].
&lt;/small&gt;

== Variadische Funktionen ==
Python-Code:

 def test1(a, *b):
     print(a);
      
     for c in b:
         print(c);
        
 test1(&quot;Hallo&quot;, &quot;Welt&quot;, &quot;Schweizer&quot;, &quot;und alle anderen&quot;)

Ausgabe:

 Hallo
 Welt
 Schweizer
 und alle anderen

Mit dem Stern (auch als Splat-Operator bezeichnet) in der formalen Parameterliste bei der Funktion &lt;code&gt;test1&lt;/code&gt; wird angezeigt, dass eine beliebige Anzahl von Argumenten übergeben wird. &lt;small&gt; Dies entspricht in etwa dem, was in anderen Programmiersprachen (PHP etc.) mittels Ellipse (&lt;code&gt;...&lt;/code&gt;) angezeigt wird.&lt;/small&gt;

= Tupel, Listen und andere =
[[Datei:Python 3. The standard type hierarchy.png|mini|hochkant=1.7|Datentypen und Strukturen]]

== Tupel und Listen ==
Tupel, Listen und einige andere sind Datenstrukturen oder Sequenzen.

Listen (z.B. eine Einkaufsliste) sind veränderbar (mutable). Ein Tupel kann dagegen nicht verändert werden (immutable). Listen werden beim Anlegen in eckige Klammern eingeschlossen, Tupel in runde Klammern. Beim Tupel können die Klammern auch weggelassen werden. Ein Tupel mit nur einem Element muss mit einem Beistrich abgeschlossen werden. Der Grund ist, dass Python sonst nicht entscheiden kann, ob ein Tupel angelegt werden soll, oder nur ein geklammerter Wert. 

Als Gedächtnisstütze kann man sich den Unterschied zwischen Tupel und Liste ev. so leichter merken:
: T'''u'''pel ... r'''u'''nde Klammern, '''u'''nveränderlich
: L'''i'''ste ... eck'''i'''ge Klammern, veränderl'''i'''ch.

Nachfolgend werden einige Operationen mit Listen und Tupel dargestellt.

 # Liste und Tupel
 liste = [1, 2, &quot;Hallo&quot;]
 tupel = (1, 2, &quot;Hallo&quot;) 
 
 # Ausgabe von liste und tupel
 print(liste)
 print(tupel)
 
 # Ausgabe von Einzelelementen
 print(liste[1])
 print(tupel[2])
 
 # Element an Liste anhängen und einfügen 
 liste.append(55)
 liste.insert(4, &quot;Welt&quot;)
 print(liste)
 
 # Element aus Liste entfernen
 liste.remove(1)
 print(liste)
 
 # einige weitere Beispiele
 liste2 = [1,]
 tupel2 = 1, 2
 tupel3 = (1,) 
 print(liste2)
 print(tupel2)
 print(tupel3)

Ausgabe:
 [1, 2, 'Hallo']
 (1, 2, 'Hallo')
 2
 Hallo
 [1, 2, 'Hallo', 55, 'Welt']
 [2, 'Hallo', 55, 'Welt']
 [1]
 (1, 2)
 (1,)

Beispiel (eine Liste von Wörtern zu einem einzigen zusammenhängenden Text verbinden):

 woerter = [&quot;Hallo&quot;, &quot;Welt&quot;]
 satz = &quot; &quot;.join(woerter)
 print(satz)

Ausgabe:

 Hallo Welt

== Dictionaries und Mengen ==
Zu den Datenstrukturen gehören weiters auch Mengen und Dictionaries. Mengen sind von der Mathematik bekannt, sie sind ungeordnet und es kommen keine mehrfachen Elemente vor. Dictionaries sind durch Schlüssel :Wert-Paare gekennzeichnet. Mengen werden beim Anlegen wie Dictionaries in geschweifte Klammern eingeschlossen.

 dict = {&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot; }
 menge = {1, 1, 3, 4, 4, 4, &quot;Hallo&quot;}
 
 print(dict)
 print(menge)
 print(dict[&quot;vorname&quot;])

Ausgabe:
 {'vorname': 'Hugo', 'nachname': 'Meister'}
 {1, 3, 4, 'Hallo'}
 Hugo

Geschweifte Klammern ohne Inhalt stellen Dictionaries dar und keine Mengen:

 di = {}
 print(type(di))

Ausgabe:
 &lt;class 'dict'&gt;

Leere Mengen lassen sich mit &lt;code&gt;set()&lt;/code&gt; erzeugen:

 menge = set()      # leere Menge
 print(menge)
 menge.add(&quot;Hallo&quot;) # Element hinzufügen
 print(menge)

Ausgabe:
 set()
 {'Hallo'}

Beispiel (einige Mengenoperationen):
 mengeA = {&quot;Hallo&quot;, &quot;Welt&quot;}
 mengeB = {1, 2, &quot;Welt&quot;, 3}
 
 # Vereinigung
 print(mengeA | mengeB)
 print(mengeA.union(mengeB))
 
 # Durchschnitt
 print(mengeA &amp; mengeB)
 print(mengeA.intersection(mengeB))
 
 # Differenz
 print(mengeA - mengeB)
 print(mengeA.difference(mengeB))
 
 # Symmetrische Differenz
 print(mengeA ^ mengeB)
 print(mengeA.symmetric_difference(mengeB))
 
 # Teilmenge
 print(mengeA.issubset(mengeB))
 
 # Mehrere Elemente hinzu
 mengeA.update([&quot;Super&quot;, 67, 125])
 print(mengeA)
 
 # Element löschen
 mengeA.discard(&quot;Hallo&quot;)
 print(mengeA)

Ausgabe:
 {1, 2, 3, 'Welt', 'Hallo'}
 {1, 2, 3, 'Welt', 'Hallo'}
 {'Welt'}
 {'Welt'}
 {'Hallo'}
 {'Hallo'}
 {1, 2, 3, 'Hallo'}
 {1, 2, 3, 'Hallo'}
 False
 {67, 'Super', 'Welt', 'Hallo', 125}
 {67, 'Super', 'Welt', 125}

Es gibt schon seit &quot;ewigen&quot; Zeiten unveränderbare Mengen, die mittels &lt;code&gt;frozenset&lt;/code&gt; eingeleitet werden. Neu ab Python 3.15 ist dagegen das Pendant &lt;code&gt;frozendict&lt;/code&gt;, das unveränderbare Dictionaries darstellt.

 fdict = frozendict({&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot;})
 fset = frozenset({&quot;A&quot;, 1, &quot;A&quot;})
 
 print(fdict)
 print(fdict[&quot;vorname&quot;])
 print (fset) 
 
 try:
     fdict[&quot;vorname&quot;] = &quot;Max&quot;
     print(fdict[&quot;vorname&quot;])
 except TypeError as e:
     print(f&quot;Fehler: {e}&quot;)
 
 try:
     fset.add(&quot;B&quot;)
     print(fset)
 except AttributeError as e:
     print(f&quot;Fehler: {e}&quot;)

Ausgabe:
 frozendict({'vorname': 'Hugo', 'nachname': 'Meister'})
 Hugo
 frozenset({1, 'A'})
 Fehler: 'frozendict' object does not support item assignment
 Fehler: 'frozenset' object has no attribute 'add'

== List Comprehensions ==
Aus einer Eingabeliste soll eine Ausgabeliste erzeugt werden. Das kann folgendermaßen geschehen.

Mathematische Schreibweise: &lt;math&gt;lc = \{2x|x\in\ \mathbb{N}, 1\le x &lt; 11\}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11)]
 print(lc)

Ausgabe:
 [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Mathematische Schreibweise: &lt;math&gt;lc = \{2x | x \in \mathbb{N}, 1\le x &lt; 11, x \bmod 2 = 0 \}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11) if x%2 == 0]
 print(lc)

Ausgabe:
 [4, 8, 12, 16, 20]

Siehe auch {{W|List Comprehension}}.

== Set Comprehensions ==
Dies ist sehr ähnlich wie im vorigen Abschnitt beschrieben. Es wird aber keine Liste, sondern eine Menge erzeugt.

 sc = {x*2 for x in range(1,11)}
 print(sc)

Ausgabe:
 {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}

== Listen zusammenführen - zip() ==
 li1 = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]
 li2 = [1, 2, 3, 4]
 li3 = [5.5, 6.6, 7.7, 8.8]
 
 z = zip(li1, li2, li3)
 print(z)
 
 li4 = list(z)
 print(li4)

Ausgabe:
 &lt;zip object at 0x00000283B6C6AC80&gt;
 [('A', 1, 5.5), ('B', 2, 6.6), ('C', 3, 7.7), ('D', 4, 8.8)]

== Generatorausdruck ==
 g = (i*2 for i in range(1,11))
 print(g)
 t = tuple(g)
 print(t)
 print(t[1:3])

Ausgabe:
 &lt;generator object &lt;genexpr&gt; at 0x00000241D2A4A5A0&gt;
 (2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
 (4, 6)

== Slicing ==
slice ... Scheibe, Teil, in Scheiben schneiden

Beispiel: Zugriff auf Elemente eines geordneten sequentiellen Objekttyps (Liste, Tupel oder String):

 str1 = &quot;Hallo&quot;
 # Das erste Element wird mit dem Index 0 angesprochen
 # [start (inkl.) : stop (exkl.) : step (default=1)]
 str2 = str1[0:2]
 # Alternativ auch: str2 = str1[:2] 
 print(str2)
 
 tup1 = (0,1,2,3)
 # Das letzte Element hat auch den Index -1, das vorletzte den Index -2 usw.
 tup2 = tup1[-3:-1]
 print(tup2)
 
 lst1 = [[1,  5,  10, 20],
         [30, 40, 50, 60]]
 lst2 = lst1[1][1]
 print(lst2)
 
Ausgabe:
 Ha
 (1, 2)
 40

Beispiel:

 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2])
 print(x[-3]) 
 print(x)
 print(x[:])
 print(x[2:])
 print(x[:2])
 print(x[::-1])

Ausgabe:

 c
 c
 ('a', 'b', 'c', 'd', 'e')
 ('a', 'b', 'c', 'd', 'e')
 ('c', 'd', 'e')
 ('a', 'b')
 ('e', 'd', 'c', 'b', 'a')

Visualisierung:

    '''a'''     '''b'''     '''c'''     '''d'''     '''e'''
 +-----------------------------+
 |  0  |  1  |//'''2'''//|  3  |  4  |
 +-----------------------------+
 | -5  | -4  |/'''-3'''//| -2  | -1  | 
 +-----------------------------+
 |/////////////////////////////|
 +-----------------------------+
 |/////////////''':'''///////////////|
 +-----------------------------+
 |     |     |///////'''2:'''////////|
 +-----------------------------+
 |////''':2'''/////|     |     |     |
 +-----------------------------+
 |\\\\\&lt;--\\\\\'''::-1'''\\\\&lt;--\\\\\|
 +-----------------------------+

Beispiel:
 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2::2])
 print(x[2::-1])
 print(x[2:0:-1])

Ausgabe:

 ('c', 'e')
 ('c', 'b', 'a')
 ('c', 'b')

Hier sieht man sehr schön, dass beim letzen &lt;code&gt;print&lt;/code&gt;-Befehl die 0, die in diesem Fall den Buchstaben &quot;a&quot; repräsentiert, als letzer Wert nicht mehr dazugehört (wie weiter oben angedeutet ist der End- oder Stoppwert exklusiv). Will man den Buchstaben &quot;a&quot; dazunehmen, so ist die vorletzte Zeile die richtige.

Beispiel: Umdrehen von Strings

 str1 = &quot;Hallo&quot;
 str2 = str1[::-1]
 print(str2)

Ausgabe:
 ollaH

Mit zweidimensionalen Listen/Tupels wird das Ganze schon bedeutend komplexer.

Beispiel: Verkettetes Slicing

 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
     
 print(A[2::][::2])

Ausgabe:

 [['20', '21', '22', '23'], ['40', '41', '42', '43']]

Das erste Slicing erstellt folgenden Slice:

 [[&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
  [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
  [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]

Das zweite Slicing wird dann auf diesen Slice angewendet und ergibt das genannte Endergebnis. Will man Spalten statt Zeilen, so funktioniert dieser direkte Weg nicht. Man verwendet dann List Comprehensions oder die NumPy-Bibliothek. Diese Bibliothek erlaubt [[Ing_Mathematik:_Python#Zugriff_auf_Matrizenelemente|zweidimensionales Slicing]]. Sie wird erst später bei den Grafiken eingeführt. Deshalb wird hier dazu noch kein Beispiel gezeigt.

= Objektorientierte Programmierung =
{{Wikipedia|Objektorientierte Programmierung}}

* {{W|Klasse (Objektorientierung)|Klasse}} ... die Schablone oder der Bauplan, enthält Methoden und Attribute
* {{W|Objekt (Programmierung)|Objekt}} ... eine Klasseninstanz (die konkrete Ausprägung der Klasse)
* {{W|Attribut (Programmierung)|Attribute}} ... die Eigenschaften eines Objekts
* {{W|Methode (Programmierung)|Methoden}} ... die Aktionen (Operationen), die ein Objekt ausführen kann
* {{W|Vererbung (Programmierung)|Vererbung}} ... neue Klassen (Subklassen, Unterklassen, abgeleitete Klassen) aus vorhandenen Klassen (Superklassen, Oberklassen, Basisklassen, Elternklassen) ableiten. Ermöglicht den Aufbau von Klassenhierarchien. Die Subklasse &quot;erbt&quot; Attribute und Methoden von der Superklasse. Python unterstützt (so wie C++, aber im Gegensatz zu Java) Mehrfachvererbung.

== UML ==
* {{W|Unified Modeling Language|UML}} ... '''U'''nified '''M'''odeling '''L'''anguage, eine Modellierungssprache. Die UML enthält zahlreiche Diagrammarten, um Programme zu modellieren. Im Nachfolgenden wird nur das {{W|Klassendiagramm}} verwendet.

[[File:UmlCd Klasse-3.svg|300px]]

* {{W|Sichtbarkeit (Programmierung)|Sichtbarkeit}}:
** + ... public (öffentlich)
** - ... private
** # ... protected 

* {{W|Attribut_(UML)#Attribute_für_Instanzen_und_für_Klassen|Klassenattribute}} (statische Attribute): Werden nur einmal pro Klasse angelegt. Im Klassendiagramm werden sie unterstrichen.

[[File:Attribute-3.png|200px]]

* Vererbung:

&lt;gallery&gt;
InheritancePgmUML.svg | Abgeleitete Klasse erbt von Basisklasse (Einfachvererbung)
Diamond inheritance.svg | D erbt von B und C (Mehrfachvererbung). B und C erben von A (Einfachvererbung)
&lt;/gallery&gt;

Für weitergehende Betrachtungen zur UML wird auf Spezialliteratur verwiesen, z.B.:
* Seidl et al.: UML@Classroom. dpunkt, 2012, ISBN 978-3-89864-776-2
* Rupp et al.: UML 2 glasklar. Hanser, 4. Aufl., 2012, ISBN 978-3-446-43057-0

== Eine einfache Klasse ==

[[Datei:PythonIng_uml1.svg | 200px]]

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
 
 fahr = Fahrzeug(150, 90)
 
 print(fahr.convertGeschw())
 
Ausgabe:
 41.666666666666664

Die Klasse Fahrzeug wird durch das class-Schlüsselwort eingeleitet. raeder ist ein Klassenattribut und public. __init__ wird bei der Objekterzeugung automatisch aufgerufen (ist der sogenannte Konstruktor). Man achte darauf, dass diese Methode immer mit zwei Unterstrichen eingeleitet und abgeschlossen wird. Instanzattributen wird das Wort self vorangestellt. Wir sehen uns z.B. das Attribut self.__geschwind an. Auch hier werden zwei Unterstriche verwendet. Das bedeutet, dass dieses Attribut strikt/stark private ist. Wird nur ein Unterstrich verwendet, so deutet dies auf schwach/weakly private hin. Letzteres wird in Python deutlich häufiger verwendet. Bei den Methoden wird immer self als erster Parameter angegeben. Beim Aufruf der entsprechenden Funktion wird das self aber nicht berücksichtigt.

Besonderheiten bei stark und schwach private:
* '''stark private''':
** zwei führende Unterstriche
** Name Mangling: Name wird zu &lt;code&gt;_Klassenname__variablenname&lt;/code&gt;
** Schutz vor Namenskollisionen bei Vererbung
** am Ende des Namens dürfen keine zwei Unterstriche verwendet werden. Das wären dann Magic Methods oder Dunder-Methods (z.B. __init__). Diese sind public.

* '''schwach private''':
** ein führender Unterstrich
** Name bleibt gleich
** ist nur ein Hinweis an die Programmierer, kein starker Schutz
** &lt;code&gt;from modul import *&lt;/code&gt;: Objekte mit einem führenden Unterstrich werden standardmäßig nicht importiert
** Standard für die Kapselung bei Python. Schätzung: Weit mehr als 80% der nicht-öffentlichen Attribute/Methoden werden als schwach private deklariert. Weniger als 5-10% als stark private (Quelle: Google KI)

== Klassen importieren ==
Häufig ist es sinnvoll und übersichtlicher Klassen in eigenen Dateien zu speichern. Das sind dann eigene Module. Abgespeichert werden Sie mit der Endung py, wie bisher auch praktiziert. Aufgerufen werden Sie mit der import-Anweisung. Dann ist aber nur der Dateiname ohne Endung py zu verwenden. Klarer wird das mit einem Beispiel.

Datei c:\tmp\fahrzeug.py

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6

Datei c:\tmp\test1.py

 import fahrzeug
 fahr = fahrzeug.Fahrzeug(150, 90)
 print(fahr.convertGeschw())

Ausgabe:
 41.666666666666664

Die üblichen import-Anweisungen lauten wie folgt:
{| {{prettytable}}
! import-Befehl
! Instanz
|-
| import xyz      || xyz.Klasse
|-
| import xyz as x || x.Klasse
|-
| from xyz import Klasse || Klasse
|-
| from xyz import * || Klasse 
|}

Der Vorteil der ersten beiden import-Anweisungen ist, dass es kaum zu Namenskollisionen kommen kann. Dafür hat man bei den letzten beiden Varianten weniger Tipparbeit.

== Vererbung ==
=== Einfachvererbung ===

[[Datei:PythonIng_uml2.svg | 200px]]

Datei fahrzeug.py:
 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
        
     def setLeistung(self, leistung):
         self.__leistung = leistung
        
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
        
 class Luftfahrzeug(Fahrzeug):
     def __init__(self, geschwindigkeit, leistung, fluegel):
         super().__init__(geschwindigkeit, leistung)
         self.__flueg = fluegel
     
     def getFlueg(self):
         return self.__flueg

Datei test1.py:
 import fahrzeug
 fahr = fahrzeug.Luftfahrzeug(150, 90, 4)
 print(fahr.getFlueg())

Ausgabe:
 4

=== Mehrfachvererbung ===
Mit Python ist auch Mehrfachvererbung möglich, z.B.:

 class A:
     def _printA(self):
         print(&quot;Klasse A&quot;)
 
 class B:
     def _printB(self):
         print(&quot;Klasse B&quot;)
 
 class C(A,B):
     def __init__(self):
         self._printA()
         self._printB()
 
 c = C()

Ausgabe:

 Klasse A
 Klasse B

Die Klasse C erbt von A und B. In UML sieht das in etwa so aus:

 +-----------------------------+   +-------------------------+
 |            A                |   |          B              |
 +-----------------------------+   +-------------------------+
 |                             |   |                         |
 +-----------------------------+   +-------------------------+
 | # printA()                  |   | # printB()              |
 +-----------------------------+   +-------------------------+
                           .              .
                          / \            / \
                          ---            ---
                           |              |
                           |              |
                        +---------------------+
                        |          C          |
                        +---------------------+
                        |                     |
                        +---------------------+
                        |                     |
                        +---------------------+

&lt;code&gt;printA()&lt;/code&gt; und &lt;code&gt;printB()&lt;/code&gt; sind schwach private (in UML als &lt;code&gt;protected&lt;/code&gt; mit einem # dargestellt). Es ist aber zu beachten, dass schwach private nur Konvention ist. Praktisch könnte man auch von außerhalb auf diese Methoden zugreifen. Das soll man aber nicht tun, und das wird in Python durch einen Unterstrich angedeutet.

== Statische Attribute, statische Methoden und Klassenmethoden ==
Beispiel:

 class Math:
     pi = 3.14159265
     cnt = 0
     
     @staticmethod
     def expo():
         return 2.71828183
    
     @classmethod    
     def counterPlus(cls):
         cls.cnt += 1
        
 print(Math.pi)
 print(Math.expo())
 
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)

Ausgabe:

 3.14159265
 2.71828183
 1
 2
 3

Statische Attribute und Methoden, bzw. Klassenmethoden, sind direkt einer Klasse zugeordnet und nicht einem Objekt. Der Unterschied zwischen statischen Methoden und Klassenmethoden ist, dass statische Methoden nicht auf Klassenattribute (bzw. statische Attribute) zugreifen können, Klassenmethoden aber schon. &lt;code&gt;pi&lt;/code&gt; und &lt;code&gt;cnt&lt;/code&gt; sind statische Attribute. &lt;code&gt;expo()&lt;/code&gt; ist eine statische Methode. &lt;code&gt;counterPlus(cls)&lt;/code&gt; ist eine Klassenmethode. Die Bezeichnung des Parameters als &lt;code&gt;cls&lt;/code&gt; ist reine Konvention, man sollte sich aber daran halten. &lt;code&gt;@staticmethod&lt;/code&gt; und &lt;code&gt;@classmethod&lt;/code&gt; nennt man auch Dekoratoren.

= Grafiken zeichnen =
Für das Zeichnen von Grafiken wird hier das Modul &lt;code&gt;matplotlib&lt;/code&gt; verwendet. &lt;code&gt;matplotlib&lt;/code&gt; ist ein externes Modul und muss vor der ersten Verwendung installiert werden. Das geht so:

# Starten Sie ein Terminal (bei Windows die Eingabeaufforderung).
# Führen Sie darin folgenden Befehl aus &lt;code&gt;c:\devel\Python\Scripts\pip.exe install matplotlib&lt;/code&gt;

pip ist übrigens der Paketmanager von Python ({{W|Pip_(Python)}}). 

Optimalerweise installieren wir auch gleich das Modul &lt;code&gt;numpy&lt;/code&gt; (Numerical Python). Wir werden es im Folgenden oft benötigen (nicht nur bei den Grafiken). Das funktioniert vom Prinzip her genauso, wie für &lt;code&gt;matplotlib&lt;/code&gt; gezeigt.

&lt;small&gt;Verwenden Sie Spyder, so sind diese Schritte nicht nötig. Spyder inkludiert diese Pakete standardmäßig. Unter openSUSE Tumbleweed lassen sich diese Pakete mittels YaST oder zypper installieren.&lt;/small&gt;

== 2D ==
=== Graph einer Funktion ===
Es soll die cosh-Funktion im Intervall &lt;math&gt;x\in[-3,3]&lt;/math&gt; gezeichnet werden. Der Programmcode lautet in der einfachsten Form:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x)
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:PythonIng_cosh1.jpg]]

Der Code ist quasi selbsterklärend. Das Untermodul pyplot des matplotlib-Moduls und das numpy-Modul werden importiert. x läuft von -3 bis +3. y wird für jeden x-Wert per Formel ausgerechnet. &quot;plt.plot()&quot; ist der Zeichenbefehl. &quot;plt.show&quot; ist notwendig, um das Fenster mit der Grafik anzuzeigen.
Die Schrittweite 0.1 wurde so gewählt, um einen ausreichend glatten Verlauf des Graphen zu gewährleisten. Das ist immer ein Kompromiss zwischen Berechnungszeit und Ansehnlichkeit. Testen Sie einfach ein paar verschiedene Werte, um ein Gefühl dafür zu zu bekommen. &quot;plt.grid()&quot; zeichnet ein Gitter in die Grafik (kann auch weggelassen werden).
Die Bezeichnungen plt und np könnten auch anders gewählt werden. Es ist aber Konvention, diese so wie hier gezeigt zu wählen. Die &quot;arange&quot;-Funktion aus der NumPy-Bibliothek wird später ein bisschen genauer behandelt (siehe [[Ing_Mathematik:_Python#Zahlenfolgen|Zahlenfolgen]]).  

&lt;small&gt;Mit der im obigen Bild gezeigten Menüleiste kann die dargestellte Grafik nachträglich noch geändert werden (Zoom, Pan, Achsenparameter, Kurvenparameter etc.). Natürlich kann man das alles auch direkt programmieren. Wie das funktioniert wird ansatzweise etwas später gezeigt.&lt;/small&gt;

Ein etwas komplexeres Beispiel ist Folgendes:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x) + 2**x
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:
[[Datei:PythonIng_cosh4.png]]

Man beachte, dass im Gegensatz zu Octave und Julia der ominöse Punkt (.) bei 2**x mit Python nicht benötigt wird. Das macht das Programmiererleben etwas einfacher.

Die Farbe des Graphen kann man über den &lt;code&gt;color&lt;/code&gt;-Schalter einstellen, z.B. auf rot setzen:
 plt.plot(x, y, color=&quot;red&quot;)

Das ist nur eine Möglichkeit, es gibt auch andere, z.B. mittels
* hexadezimaler Zahl, z.B. &lt;code&gt;color=&quot;#ff0000&quot;&lt;/code&gt;
* Kurzform, z.B. &lt;code&gt;&quot;r&quot;&lt;/code&gt;

Statt &lt;code&gt;color&lt;/code&gt; kann auch die Kurzform &lt;code&gt;c&lt;/code&gt; verwendet werden.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie diese &quot;Farbspielereien&quot; am Computer aus.

=== Graphen mehrerer Funktionen und weiteres ===
==== Mehrere Funktionen in einen Plot zeichnen ==== 
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh2.png]]

Um die Linienstile etwas individueller zu gestalten, ist folgender Programmcode gedacht: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;, lw=3, ls=&quot;--&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh3.png]]

Einige weitere Bespiele zu &lt;code&gt;ls&lt;/code&gt;&lt;/code&gt;:
* - ... durchgezogene Linie
* -. ... Strichpunkt-Linie
* dashed ... gestrichelte Linie 

==== Marker ====
Desweiteren kann man Marker verwenden.

Beispiel:

 import matplotlib.pyplot as plt
 
 plt.plot(10, 10, &quot;ob&quot;, markersize=30)
 plt.plot(20,20, &quot;.r&quot;)
 plt.plot(30,30, &quot;Dg&quot;, ms=15)
 plt.plot(40, 40, &quot;ok&quot;, ms=20, mec=&quot;#FF5733&quot;, mew=3)
 plt.plot(50, 50, &quot;vk&quot;, ms=20, mec=&quot;yellow&quot;, mew=3)
 plt.grid()
 plt.show()


Das erste Zeichen im String nach den Koordinaten im plot-Befehl symbolisiert die Form (z.B. o für einen Kreis). Das zweite Zeichen steht für die Farbe (z.B. b für blue). &lt;code&gt;markersize&lt;/code&gt; oder &lt;code&gt;ms&lt;/code&gt; setzt die Größe des Markers.

Ausgabe:

[[Bild:PythonIng_formatpara1.svg|200px]]

Einige weitere Marker:
* * ... Stern
* + ... Plus
* h oder H ... Sechseck

Man kann mit den Parametern 
* &lt;code&gt;markeredgecolor&lt;/code&gt; oder kurz &lt;code&gt;mec&lt;/code&gt; die Farbe des Markerrandes
* &lt;code&gt;markeredgewidth&lt;/code&gt; oder kurz &lt;code&gt;mew&lt;/code&gt; die Dicke des Randes
* &lt;code&gt;markerfacecolor&lt;/code&gt; oder kurz &lt;code&gt;mfc&lt;/code&gt; die Innenfarbe des Markers
bestimmen.

=== Funktion in Parameterdarstellung ===
Es soll die archimedische Spirale &lt;math&gt;x = t \cos(t), y = t  \sin(t)&lt;/math&gt; im Intervall &lt;math&gt;[0, 6\pi[&lt;/math&gt; gezeichnet werden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
  
 plt.show()

[[Datei:PythonIng_spirale1.png]]

Diese Darstellung erscheint verzerrt. Will man gleiche Achsenskalierungen, so kann man den plt.axis()-Befehl verwenden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
 plt.axis(&quot;equal&quot;)
 
 plt.show()
 
[[Datei:PythonIng_spirale2.png]]

=== Funktion in Polardarstellung ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 fig = plt.figure()
 ax = fig.add_subplot(projection=&quot;polar&quot;)
 r = np.arange(0, 1, 0.01)
 theta = r**3
 line = ax.plot(theta, r)
 
 plt.show()

[[Datei:PythonIng_polar1.png]]

=== Logarithmische Achsenskalierung ===
==== Semilog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.semilogy()
 plt.show()

Ausgabe:

[[Datei:PythonIng_semilog1.png]]

==== LogLog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.loglog()
 plt.show()

[[Datei:PythonIng_loglog1.png]]

=== Gefüllte Fläche ===
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.arange(0, 3, 0.1)
 
 y1 = 3*x - 1
 y2 = x**2
 
 plt.plot(x, y1, x, y2, color='black')
 plt.fill_between(x, y1, y2, where=y1&gt;=y2)
 
 plt.show()

[[Datei:PythonIng_gefuellt.png]]

=== Linien, Pfeile, Rechtecke, Kreise und Texte ===
 import matplotlib as mpl
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 r = mpl.patches.Rectangle((0, 0), 3, 3, angle=30, fill=False)
 c = mpl.patches.Circle((4, 4), 2, fill=False)
 
 ax.add_patch(r)
 ax.add_patch(c)
 ax.plot([-2, 7], [-2, 0], color=&quot;black&quot;)
 ax.arrow(0, 7, 5, 0, length_includes_head=True, head_width=0.5, head_length=1.5,
          color=&quot;black&quot;)
 
 ax.set_aspect(&quot;equal&quot;)
 
 plt.axis([-3, 8, -3, 8])
 plt.show() 

[[Datei:PythonIng_linien_pfeile_etc.png]]

Text kann mit &lt;code&gt;ax.text(x, y, &quot;Text&quot;)&lt;/code&gt; hinzugefügt werden, bspw.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 ax.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

Oder einfacher auch ohne &lt;code&gt;subplots&lt;/code&gt;

 import matplotlib.pyplot as plt
 
 plt.text(0.1, 0.1, &quot;Hallo&quot;)
 plt.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

[[Datei:PythonIng_text1.png]]

Auch Sonderzeichen (griechische Buchstaben etc.) können verwendet werden (siehe dazu auch [https://matplotlib.org/stable/users/explain/text/mathtext.html]).

 import matplotlib.pyplot as plt
 
 plt.text(.3, .5,
          r'$\Omega\ \psi\ \oint\ \nabla\ \dot a\ \frac{a}{b}\ a_b$',
          size=&quot;20&quot;)
 plt.show() 

[[Datei:PythonIng_text20.svg]]

Jetzt wird noch gezeigt, wofür &lt;code&gt;subplots&lt;/code&gt; sinnvoll eingesetzt werden können.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(0.1, 0.1, &quot;Hallo&quot;)
 ax[1].text(0.1, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
            rotation=30.0)
 
 plt.show()

[[Datei:PythonIng_text2.png]]

=== Anmerkungen hinzufügen ===
Anmerkungen (engl. annotations) lassen sich mit matplotlib einfach hinzufügen. Unter Anmerkung wird hier ein Pfeil mit Text verstanden.

Beispiel:

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 ax.plot([1,10], [1,10])
 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
             arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0))
 plt.show()

Ausgabe:

[[Datei: PythonIng_ann1.svg|400px]]

&lt;code&gt;shrink&lt;/code&gt; verkürzt den Pfeil. Sinnvoll sind beim obigen Beispiel Werte irgendwo zwischen 0.0 und 0.3.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie verschiedene Pfeillängen aus. 

Die Schriftgröße verändern können Sie übrigens mit &lt;code&gt;fontsize&lt;/code&gt; oder &lt;code&gt;size&lt;/code&gt;, z.B.

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0), fontsize=25)

Eine andere Schreibweise für Dictionaries, die wir weiter oben schon kennengelernt haben, die wir aber nochmals explizit aufschreiben wollen, ist

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops={&quot;facecolor&quot;:&quot;red&quot;, &quot;shrink&quot;:0.0})

=== Figure, Axes etc.===
[[Bild:PythonIng_figure33.svg|350px]]

* fig (figure) ... das übergeordnete Fenster
* ax (axes) ... &quot;Plot&quot;, das eigentliche Zeichenfenster
* axis ... die Koordinatenachsen
* spine ... Begrenzungslinien des Zeichenfensters
* tick ... Markierung an den Achsen des Zeichenfensters

Beispiel (eine figure mit 6 axes, ax-Titel, y-axis-Titel):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=3, ncols=2)
 
 ax[0][0].text(0.1, 0.5, &quot;11&quot;)
 ax[0][1].text(0.1, 0.5, &quot;12&quot;)
 ax[1][0].text(0.1, 0.5, &quot;21&quot;)
 ax[1][1].text(0.1, 0.5, &quot;22&quot;)
 ax[2][0].text(0.1, 0.5, &quot;31&quot;)
 ax[2][1].text(0.1, 0.5, &quot;32&quot;)
 
 ax[0][0].set(ylabel=&quot;y-label&quot;, title=&quot;axes 1&quot;)
 
 plt.show()

[[Bild:PythonIng_figure34.png|350px]]

Beispiel (Achsenbereiche setzen):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 
 ax[0].axis((-1, 10, 1, 12))
 
 plt.show()

[[Bild:PythonIng_figure35.svg|350px]]

Beispiel (Gitter einschalten): 

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 ax[0].axis((-5, 10, 1, 12))
 ax[0].minorticks_on()
 ax[0].grid(which='minor')
 ax[1].grid(which='major')
 plt.show()

[[Bild:PythonIng_figure36.svg|350px]]

Beispiel (ticks setzen)

 import matplotlib.pyplot as plt
 import matplotlib.ticker as tick
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 pos = [0, .2, .5]
 lab = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
 
 ax.xaxis.set_major_locator(tick.FixedLocator(pos))
 ax.xaxis.set_major_formatter(tick.FixedFormatter(lab))
 
 plt.show()

[[Bild:PythonIng_figure37.svg|350px]]

Beispiel (Achsenkreuz beliebig setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 ax.spines['top'].set_color('none')
 ax.spines['right'].set_color('none')
 ax.spines['bottom'].set_position(('data', 0.3))
 ax.spines['left'].set_position(('data', 0.5))
 
 plt.show()

[[Bild:PythonIng_figure38.svg|350px]]

Beispiel (Inset):

 import matplotlib.pyplot as plt
 
 # Hauptplot erstellen
 fig, ax = plt.subplots()
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 
 # Inset hinzu:
 axin = ax.inset_axes([0.4, 0.4, 0.3, 0.3])
 axin.text(0, 0, &quot;Servus&quot;)
 axin.plot()
 
 plt.show()

[[Bild:PythonIng_figure40.svg|350px]]

Beispiel (Hintergrundfarben setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.set_facecolor(&quot;green&quot;)
 fig.set_facecolor(&quot;yellow&quot;)
 
 plt.plot([1, 3], [6, 8])
 plt.show()

[[Bild:PythonIng_figure39.svg|300px]]

=== GridSpec ===
Mit figures und axes lassen sich schon jede Menge an Grafikdetails einstellen. GridSpec ist dann der Turbo oder Raketenantrieb den matplotlib eingebaut hat. Naja, vielleicht ist das etwas übertrieben, aber GridSpec ist sozusagen ein flexibler Layout-Manager. Bisher haben wir immer gleich große axes gezeichnet. Mit GridSpec können wir Subplots über mehrere Zeilen und Spalten ziehen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 gs = fig.add_gridspec(3, 3)
 
 ax1 = fig.add_subplot(gs[0, :])
 ax1.set_title(&quot;Bereich 1: gs[0, :]&quot;)
 
 ax2 = fig.add_subplot(gs[1:, 0])
 ax2.set_title(&quot;Bereich 2: gs[1:, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 1:])
 ax3.set_title(&quot;Bereich 3: gs[1, 1:]&quot;)
 
 ax4 = fig.add_subplot(gs[2, 1:])
 ax4.set_title(&quot;Bereich 4: gs[2, 1:]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec1.svg|350px]]

Erklärung zu &lt;code&gt;(gs[zeile, spalte])&lt;/code&gt;: Slicing; damit legen Sie fest, welche Zellen ein Subplot belegt. Achtung! Die Indizes beginnen bei 0 und nicht bei 1 (d.h., die erste Zeile/Spalte hat den Index 0)
* : ... alle 
* 1: ... 1 bis Ende
* etc.

&lt;code&gt;constrained_layout=True&lt;/code&gt; sorgt dafür, dass sich die Subplots nicht überlappen.

Aber auch die Spaltenbreiten und Zeilenhöhen lassen sich anpassen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 
 # Verhältnis erste zu zweite Zeile = 1.5:1
 # Verhältnis erste zu zweite Spalte  = 1:4
 gs = fig.add_gridspec(2, 2, figure=fig, height_ratios=[1.5, 1], width_ratios=[1, 4])
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax1.set_title(&quot;Bereich 1: gs[0, 0]&quot;)
 
 ax2 = fig.add_subplot(gs[0, 1])
 ax2.set_title(&quot;Bereich 2: gs[0, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 0])
 ax3.set_title(&quot;Bereich 3: gs[1, 0]&quot;)
 
 ax4 = fig.add_subplot(gs[1, 1:])
 ax4.set_title(&quot;Bereich 4: gs[1, 1]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec2.svg|350px]]

Auch die Ränder lassen sich einstellen.

Beispiel 1:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.1, right=0.9, bottom=0.1,
                        top=0.9, wspace=0.2, hspace=0.2)
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec3.svg|300px]]

* hspace ... height space, vertikaler Abstand zwischen den Zeilen
* wspace ... width space, horizontaler Abstand zwischen den Spalten

Und im Vergleich dazu Beispiel 2:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.3, right=0.7, bottom=0.3, 
                        top=0.7, wspace=0.3, hspace=0.3) 
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec4.svg|300px]]

Es gibt noch einige weitere Details, die sich mit GridSpec variieren lassen (z.B. SubGridSpec ... verschachtelte Grid-Layouts). Aber wir belassen es vorerst dabei. Das bisher Gezeigte sollte für die meisten Probleme ausreichend sein.

=== Aufgaben ===
* Zeichnen Sie die Strophoide &lt;math&gt;x = \frac{a(t^2-1)}{t^2+1}, y = \frac{at(t^2-1)}{t^2+1}, a = 2, -3 \leq t \leq 3&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_strophoide.jpg|300px|center]]

* Zeichnen Sie die verschlungene Hypozykloide &lt;math&gt;x = (R-r)\cos t + c\cos\frac{R-r}{r}t, y = (R-r)\sin t - c\sin\frac{R-r}{r}t, c = 3, r = 2, R = 6, -15 \leq t \leq 15&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_hypozykloide.jpg|300px|center]]

* Testen Sie bei den obigen Übungsaufgaben verschiedene Linienstile und Farben. Farben können mit dem plt.plot()-Parameter color gewählt werden.

* Testen Sie bei den obigen Übungsaufgaben verschiedene Werte für a, c, r und R.

* Zeichnen Sie folgendes Bild (die Achsenbeschriftungen positionieren Sie z.B. mit den Befehlen &lt;code&gt;ax.set_xlabel(&quot;x&quot;, loc=&quot;right&quot;); ax.set_ylabel(&quot;y&quot;, loc=&quot;top&quot;)&lt;/code&gt;):

[[Bild:PythonIng_aufgabe24.svg|400px|center]] 

* Zeichnen Sie mit Python, matplotlib und NumPy folgendes Bild:

[[Bild:PythonIng_figure41.svg|400px|center]]

* Zeichnen Sie mit GridSpec ein Layout, das in etwa wie folgendes aussieht (&lt;code&gt;height_ratios=[1, 2], width_ratios=[2, 1]&lt;/code&gt;):

[[Bild:PythonIng_aufgabe23.svg|300px|center]]

== 3D ==
=== Räumliche Kurven ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0, 6*np.pi, 0.1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 z = t
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot(x, y, z)
 
 plt.show()

[[Datei:PythonIng_raumkurve1.png]]

=== Flächen ===
 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche1.png]]

Das Ganze in Netzdarstellung läßt sich so programmieren: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.5)
 y = np.arange(0, 10, 0.5)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_wireframe(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche2.png]]

Ein etwas komplexeres Beispiel:

 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0.1, 10, 0.1)
 y = np.arange(0.1, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z1 = np.sin(x) + 3 * np.cos(y)
 z2 = np.sin(x) + np.log(y)
 z3 = x + np.cos(y)
 z4 = x**2 - y
  
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;}, nrows=2, ncols=2)
 
 ax[0][0].plot_surface(x, y, z1)
 ax[0][1].plot_surface(x, y, z2)
 ax[1][0].plot_surface(x, y, z3)
 ax[1][1].plot_surface(x, y, z4)
 
 plt.show()

[[Datei:PythonIng_subplot1.png]]

Man beachte, dass man die Unterbilder im Bild nach dem Ausführen des Scripts z.B. mit der mittleren Maustaste einzeln drehen, oder über die Einträge in der Menüzeile einzeln bearbeiten kann. Mit ein paar Zeilen Programmtext lässt sich also eine Menge an Funktionalität generieren.

Die Farbgebung lässt sich über &lt;code&gt;colormaps&lt;/code&gt; variieren.

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm)
 
 plt.show()

[[Datei:PythonIng_colormap1.png]]

Es gibt eine Menge an Colormaps, z.B. &lt;code&gt;plasma, Greys, Dark2, ocean&lt;/code&gt;. Zwecks detaillierterer Infos siehe die matplotlib-Dokumentation. &lt;small&gt;Verwendet man die IDE namens IDLE, so gibt es dort auch die automatische Codevervollständigung. D.h. es werden alle Möglichkeiten (in unserem Fall nach dem Eintippen von &lt;code&gt;cm.&lt;/code&gt; alle verfügbaren Colormaps) angezeigt.&lt;/small&gt;

Die &quot;edgecolor&quot; und Linienbreite können auch frei gewählt werden:

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm, edgecolor=&quot;black&quot;, linewidth=1.0)
 
 plt.show()

[[Datei:PythonIng_colormap2.png]]

=== Höhenlinien ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 ax.contour(x, y, z)
 
 plt.show()

[[Datei:PythonIng_höhenlinien1.png|400px]]

Etwas abgewandelt sieht das so aus: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contour(x, y, z)
 ax.clabel(hl, inline = True)
 
 plt.show()

[[Datei:PythonIng_höhenlinien2.png|400px]]

Und noch eine Variante (mit einem Farbbalken) sei gezeigt. 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contourf(x, y, z)
 fig.colorbar(hl) 
 
 plt.show()

[[Datei:PythonIng_höhenlinien5.svg|400px]]

=== Aufgaben ===
* Zeichnen Sie die räumliche Kurve &lt;math&gt;x = 2 \cdot \cosh(t)&lt;/math&gt;, &lt;math&gt;y = 5 \cdot \sin(t)&lt;/math&gt;, &lt;math&gt; z = t^{2} - t&lt;/math&gt;, &lt;math&gt;0 \leq t \leq 3\pi&lt;/math&gt;.
* Zeichnen Sie die Fläche &lt;math&gt;z = \log(x) + \cos(y)&lt;/math&gt;.

== Animationen und fortgeschrittenes 3D ==
=== Mit matplotlib ===
Auch mit matplotlib sind Animationen möglich. Das ist ein bisschen komplizierter und wird deshalb hier nur mit einem sehr einfachen Beispiel dargestellt (bei Interesse siehe z.B. auch das [https://matplotlib.org/stable/users/explain/animations/animations.html#animations Animations using Matplotlib-Tutorial]).

 import matplotlib.pyplot as plt
 import matplotlib.animation as ani
 import matplotlib
 import numpy as np
 
 def update(frame):
     line.set_xdata(x[:frame])
     line.set_ydata(y[:frame])
     return (line)
 
 fig, ax = plt.subplots()
 
 x = np.arange(0, 10, .1)
 y = np.sin(x)
 
 line, = ax.plot(x[0], y[0])
 ax.set(xlim=[0, 10], ylim=[-1, 1])
 
 a = ani.FuncAnimation(fig=fig, func=update, frames=100, interval=20)
 plt.show()
 
 # Speichere die Animation in einem animierten GIF (optional)
 a.save(filename=&quot;c:/tmp/PythonIng_anim5.gif&quot;, writer=&quot;pillow&quot;)

[[Datei:PythonIng_anim5.gif]]

Es wird eine Sinuskurve auf den Bildschirm gezeichnet. In der letzten Zeile wird diese Animation in ein animiertes GIF gespeichert. Das ist natürlich optional und kann auch weggelassen werden.

=== Mit VPython ===
Aber auch mit dem Modul VPython lassen sich einfache 3D-Animationen erstellen. VPython ist ein externes Modul, das vorab installiert werden muss. Unter openSUSE Tumbleweed gibt es dzt. kein entsprechendes rpm-Paket. Die übliche Methode der Installation mittels YaST oder zypper ist somit nicht möglich. Auch eine direkte Verwendung von pip führt nur zu einer Fehlermeldung (&lt;code&gt;error: externally-managed-environment&lt;/code&gt;). Es empfiehlt sich dort folgende Vorgehensweise:
# Erstelle zuerst eine virtuelle Umgebung, z.B.: &lt;code&gt;python3.11 -m venv ~/tmp/venv1&lt;/code&gt;
# Wechsle das Verzeichnis: &lt;code&gt;cd ~/tmp/venv1/bin&lt;/code&gt;
# Installiere das entsprechende Paket: &lt;code&gt;./pip install vpython&lt;/code&gt;
# Führe das entsprechende Skript aus: &lt;code&gt;./python ~/tmp/test1.py&lt;/code&gt;

Aktuell (März 2026) ist dieses Programmpaket lt. der [https://vpython.org/presentation2018/install.html VPython-Homepage] nur für die Python-Versionen 3.8 bis 3.12 verfügbar.

Ein Beispiel zu einer einfachen Animation wird nachfolgend geliefert.

 from vpython import *
 
 scene.width = 1200
 scene.height = 600
 scene.center = vector(20,0,0)
 scene.background = color.white
 
 cylinder(pos=vector(0,0,0), axis=vector(20,0,0), radius=5, 
         color=color.blue)
 cone(pos=vector(0,0,0), axis=vector(-10,0,0), radius=5, 
         color=color.blue)
 helix(pos=vector(20,0,0), axis=vector(40,0,0), radius=2, 
         coils=10, thickness=0.5, color=color.blue)
 
 ball = sphere(pos=vector(20,0,0), color = color.green, radius = 1)
 ball.p = vector(0.15, 0, 0)
 
 toc = True
 
 while True:
     rate(200)
     if(ball.pos.x &lt;= 60 and toc == True):
         ball.pos += ball.p
     else:
         toc = False
         ball.pos -= ball.p
         if(ball.pos.x &lt;= 20 and toc == False):
             toc = True

[[Datei:PythonIng_vpython_anim.JPG]]

Idealerweise öffnet sich beim Ausführen des Scripts ein Browserfenster. Darin wird die programmierte Animation gezeigt (siehe auch den obigen Screenshot). Eine Größenänderung können Sie mit der mittleren Maustaste initiieren. Die Szenerie drehen können Sie mit der rechten Maustaste.

=== Mit build123d ===
Hiermit lassen sich einfach 3D-Modelle für CAD-Systeme erstellen. [https://build123d.readthedocs.io/en/latest/ build123d] ist ein externes Modul und muss vorab, wie schon für mehrere andere Module gezeigt, installiert werden (pip, venv etc.).

Beispielcode:

 from build123d import *
 
 # Bauteil
 with BuildPart() as bauteil: 
     # Zylinder erstellen
     Cylinder(100, 60)
        
     # Bohrung
     with BuildSketch(bauteil.faces().sort_by(Axis.Z)[-1]) as loch:
         Circle(radius=10)
     # negativ extrudieren
     extrude(amount=-60, mode=Mode.SUBTRACT)
     
     # Dem Bauteil z.B. die Farbe rot zuweisen
     # bauteil.part.color = Color(&quot;red&quot;, alpha=1.0)
 
     # Fertiges Modell exportieren
     export_step(bauteil.part, &quot;bauteil.step&quot;)

Ausgabe ({{W|Standard for the exchange of product model data | STEP}}-Datei, z.B. in {{W|FreeCAD}} importiert, Screenshot):

[[Datei:PythonIng_build123d.jpg | 300px]]

FreeCAD ist ein freies 3D-CAD-System. Die [[Ing_Mathematik:_Python#FreeCAD | Makroprogrammierung]] in diesem System wird später noch gezeigt. STEP steht für &quot;'''St'''andard for the '''e'''xchange of '''p'''roduct model data&quot; und ist ein Datenaustauschformat.

=== Mit VTK ===
Komplexer, aber auch mächtiger als VPython ist die Verwendung von VTK ('''V'''isualization '''T'''ool'''k'''it). Genauer gesagt des Python-Wrappers von VTK. Dieses externe Python-Modul muss vorab installiert werden (z.B. mittels YaST, pip oder in eine virtuelle Umgebung). VTK ist eine Softwarebibliothek zur 3D-Visualisierung und wurde ursprünglich in C++ geschrieben. Verbreitet eingesetzt wird diese Bibliothek in der Wissenschaft und Forschung, z.B. 
* in der medizinischen Bildgebung
* für Strömungssimulationen
* für Klimadaten

VTK funktioniert nach dem {{W|Grafikpipeline|Pipeline-Prinzip}}:

 Source (Quellen) -&gt;  Filter -&gt; Mapper (Senken) -&gt; Actor/Renderer

Daten fließen von den Quellen zu den Senken.

Als einfaches Beispiel wird die Darstellung eines Zylinders gezeigt, der mit den Maustasten gedreht oder in der Größe geändert werden kann:

 import vtk
 
 # Zylinder erzeugen
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 # Geometrie in darstellbare Daten umwandeln
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 # Objekt in der Szene
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 # Szene verwalten
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 # Render-Fenster
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 # Maus/Tastatur-Steuerung
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 # Starten
 render_window.Render()
 interactor.Start()

Ausgabe:

[[Datei:PythonIng_VTK_1.png]]

Gleiches Beispiel wie oben, aber mit einer Animationssequenz:

 import vtk
 import time
 
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     render_window.Render()
     time.sleep(0.01)

Das Grafikfenster schließt sich nach Ablauf der Schleife. Das Fenster bleibt geöffnet, wenn Sie am Programmende folgenden Befehl hinschreiben

 interactor.Start()

Um den animierten Zylinder grün einzufärben, müssen Sie Folgendes im obigen Programm ergänzen (Farbnamen):

 colors = vtk.vtkNamedColors()
 actor.GetProperty().SetColor(colors.GetColor3d(&quot;Green&quot;))

Als Namen können Sie u.a. die CSS3 Web-Farben verwenden (siehe z.B. [https://wiki.selfhtml.org/wiki/Farbe/Farbangaben] und {{W|Webfarbe#CSS_3}}).

Alternativ funktioniert auch das ({{W|RGB-Farbraum|RGB}}):

 actor.GetProperty().SetColor(0.0, 0.6, 0.0)

Wie der Zylinder mit einer Textur versehen wird, zeigt folgendes Programm:

 import vtk
 import time
 
 cylinder = vtk.vtkCylinderSource()
 cylinder.SetResolution(30)
 cylinder.SetHeight(3.0)
 cylinder.SetRadius(1.0)
 cylinder.CappingOn()
 
 texture_coords = vtk.vtkTextureMapToCylinder()
 texture_coords.SetInputConnection(cylinder.GetOutputPort())
 texture_coords.PreventSeamOn()
 
 reader = vtk.vtkJPEGReader()
 reader.SetFileName(&quot;PythonIng_textur.jpg&quot;)
 
 texture = vtk.vtkTexture()
 texture.SetInputConnection(reader.GetOutputPort()) 
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(texture_coords.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 actor.SetTexture(texture)
 
 renderer = vtk.vtkRenderer()
 renderWindow = vtk.vtkRenderWindow()
 renderWindow.AddRenderer(renderer)
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(renderWindow)
 
 renderer.AddActor(actor)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     renderWindow.Render()
     time.sleep(0.01)
 
 interactor.Start()

&lt;gallery&gt;
PythonIng_textur.jpg | Textur-Datei
PythonIng_VTK_2.png | Ausgabe (Screenshot)
&lt;/gallery&gt;

== Sonstige Grafikbibliotheken ==
=== Py5 ===
Im Buch ''Iacono et al.: Programmieren trainieren, mit über 150 Workouts in Java und Python; 3. Aufl., Hanser, 2023'' werden zahlreiche Aufgaben gestellt, die u.a. mit Processing zu lösen sind.  Processing ist eine einfache Programmiersprache und Entwicklungsumgebung. Warum ich das erwähne? Weil in älteren Processing-Versionen auch die Programmiersprache Python 2 abgedeckt war. Bei neueren Versionen gibt es keine Python-Anbindung mehr (getestet nur mit openSUSE Tumbleweed und Python 3). Somit funktioniert der Python-Teil im genannten Buch zum Teil nicht mehr. Ist das tragisch, oder kann das Buch weggeschmissen werden? Nein! Es gibt Alternativen zu Processing. Zum einen die im Buch selbst genannten Bibliotheken tkinter oder pygame. Pygame wird dort auch kurz anhand eines Beispiels thematisiert. Aber noch besser ist es, die py5-Bibliothek zu verwenden (lt. Google KI vom 30. Sept. 2026: ''Der echte, moderne „spirituelle Nachfolger“''). Damit ist die Funktionalität von Processing gewährleistet. Man kann aber beliebige Editoren oder IDEs zur Programmerstellung verwenden, ohne an Processing als IDE gebunden zu sein. Nachfolgend werden ein paar Beispiele zu dieser externen Bibliothek gegeben. Der erste Schritt ist wieder, die py5-Bibliothek zu installieren (z.B. mittels pip in eine virtuelle Umgebung; Python&gt;=3.10 und ein JDK&gt;=17 müssen auch installiert sein (Stand Okt. 2026)). Dann kann es schon mit dem Programmieren losgehen.

Beispiel (angelehnt an die ''Aufgabe W.2.3 Haus'' des genannten Buchs, jedoch etwas erweitert):

 import py5
 
 def setup():
     py5.size(600, 600)            # Fenstergröße 600px x 600px 
     py5.background(255, 255, 255) # Hintergrundfarbe ... weiss
     
 def draw():
     # Haus zeichnen
     py5.fill(255, 255, 255)       # Hintergrundfarbe ... weiss
     py5.stroke(255, 0, 0)         # Linienfarbe ... rot 
     py5.stroke_weight(3)          # Linienbreite ... 3px
     py5.rect(150, 200, 300, 300)  # Rechteck zeichnen (x, y, b, h)
     py5.triangle(150, 200, 300, 100, 450, 200) # Dreieck zeichnen
     py5.circle(250, 300, 70)      # Kreis zeichnen (x, y, d)   
     
     # Bemassung zeichnen
     py5.stroke(0, 255, 0)
     py5.stroke_weight(1)
     py5.line(300, 100, 550, 100)  # Linie zeichnen
     py5.line(450, 200, 550, 200) 
     py5.line(450, 500, 550, 500) 
     py5.line(150, 500, 150, 550)
     py5.line(450, 500, 450, 550)
     py5.text_size(20)             # Textgroesse
     py5.fill(0, 255, 0)           # Textfarbe
     py5.text(&quot;300&quot;, 280, 550)     # Text zeichnen
     py5.text(&quot;100&quot;, 500, 150)
     py5.text(&quot;300&quot;, 500, 350)  
 
     # Gedrehtes Rechteck zeichnen
     py5.stroke(255, 255, 0)
     py5.stroke_weight(3)
     py5.fill(200, 200, 200) 
     py5.translate(320, 260)  
     py5.rotate(0.3)               # Drehung (in Radiant)
     py5.rect(0, 0, 100, 50)
 
 # Startet den Sketch
 py5.run_sketch()


Ausgabe:

[[Datei:PythonIng_py5_1.png|300px]]

Das skizzierte Haus ist mit einer rudimentären Bemaßung versehen und hat zwei Fenster, ein rundes und ein gedrehtes, trübes rechteckiges. 

Beispiel (Mausoperationen):

 import py5
 
 def setup():
     py5.size(600, 600)            
     py5.background(255, 255, 255)
 
 def draw():
     pass
    
 def mouse_pressed():
     py5.text_size(15) 
     py5.fill(0, 0, 255)
     x = py5.mouse_x
     y = py5.mouse_y
     py5.text(&quot;(%d, %d)&quot; %(x, y), x, y) # Positionsdaten bei Maus-Klick schreiben
 
 py5.run_sketch()

Ausgabe:

[[Datei:PythonIng_py5_2.png|300px]]

Obiges Bild zeigt das Resultat nach einigen Mausklicks. Man erkennt, dass links-oben der Koordinatennullpunkt ist. Die x-Achse zeigt nach rechts, die y-Achse nach unten.

Beispiel (Fünfeck):

 import py5
 import random 
 
 def setup():
     py5.size(400, 400)
     py5.no_loop()       # statisches Bild (schont die Ressourcen)
 
 def draw():
     py5.translate(py5.width / 2, py5.height / 2)  # KS setzen
 
     radius = 150
     eck_anzahl = 5
 
     py5.fill(random.randint(0, 255), random.randint(0, 255), 
              random.randint(0, 255))    # Füllfarbe auf Zufallswert setzen
     py5.stroke(155, 0, 0)            
     py5.stroke_weight(5)     
     
     # Fünfeck als Polygon zeichnen
     py5.begin_shape()
     for i in range(eck_anzahl):
         winkel = i * py5.TWO_PI / eck_anzahl - py5.HALF_PI
         x = py5.cos(winkel) * radius
         y = py5.sin(winkel) * radius
         py5.vertex(x, y)
     py5.end_shape(py5.CLOSE)
 
 py5.run_sketch()

Ausgabe, bspw.:

[[Datei:PythonIng_py5_5.png|200px]]

&lt;u&gt;Kleine Aufgaben:&lt;/u&gt;
* Um die Funktionsweise von &lt;code&gt;py5.no_loop()&lt;/code&gt; zu verstehen, kommentieren Sie die Anweisung im Beispiel einfach aus, und starten Sie das Programm erneut.
* Zeichnen Sie ein Siebeneck.
* Was passiert, wenn man &lt;code&gt;py5.CLOSE&lt;/code&gt; im &lt;code&gt;py5.end_shape()&lt;/code&gt;-Befehl weglässt?

Beispiel (Grafik laden und zeichnen):

 import py5
 
 image1 = None
 
 def setup():
     global image1
     py5.size(600, 600)
     py5.no_loop()
     image1 = py5.load_image(&quot;PythonIng_py5_1.png&quot;)
 
 def draw():
     py5.image(image1, 0, 0)
 
 py5.run_sketch()

Hier wird einfach das Bild vom Haus-Beispiel (Screenshot von weiter oben) geladen und gezeichnet.

Beispiel (angelehnt an ''W.5.10 Wurfparabel'' des genannten Buches; mit OOP erstellt):

 import py5
 
 class Wurfparabel(py5.Sketch):
     def __init__(self, v0, angle):
         super().__init__()
         self.v0 = v0
         self.angle = self.radians(angle)
         self.g = 9.81
         self.t = 0.0
         self.scale = 1.5
 
     def settings(self):
         self.size(800, 600)
 
     def setup(self):        
         self.background(0, 0, 0)
         
     def draw(self):
         self.t += 0.1
 
         self.translate(50, 500)
       
         # KS Zeichnen
         self.fill(255, 255, 0)
         self.stroke(255, 255, 0)
         self.stroke_weight(1)
         self.line(0, 0, 0, -300)
         self.line(0, 0, 700, 0)
 
         # Punkt zeichnen
         cx = self.v0 * self.cos(self.angle) * self.t * self.scale
         cy = -(self.v0 * self.sin(self.angle) * self.t - \
                self.g/2 * self.t**2) * self.scale
         self.fill(255, 0, 0)
         self.stroke(255, 0, 0)
         self.circle(cx, cy, 3)
        
         # Stoppen bei Bodenkontakt
         if cy &gt;= -5:
             self.no_loop()
            
 def wurfparabel(v0=50, angle=45):
     sketch = Wurfparabel(v0, angle)
     sketch.run_sketch()
 
 v0 = float(input(&quot;v0 = &quot;))
 winkel = float(input(&quot;winkel = &quot;))
 wurfparabel(v0=v0, angle=winkel)

Eingabe auf der Konsole:

 v0 = 60
 winkel = 45

Ausgabe:

[[Datei:PythonIng_py5_13.png|200px]]

Die benötigten Formeln der Bewegungsgleichung kann man leicht herleiten, bzw. man benutzt folgende Grafik als Hilfestellung:

[[Datei:Wurfparabel_Zusammenfassung_aktualisierung.png|700px]]

&lt;u&gt;Aufgabe:&lt;/u&gt; Berechnen Sie den Scheitelpunkt und die Wurfweite bei gegebener Anfangsgeschwindigkeit und gegebenem Abwurfwinkel. Die Abwurfhöhe &lt;math&gt;y_0&lt;/math&gt; sei 0. Der Wurf soll auf der Erde stattfinden (g = 9.81 m/s²). Die dazu benötigten Formeln können aus obiger Grafik entnommen werden (oder Sie leiten sie selbst her). Geben Sie die Ergebnisse auf der Konsole aus.

Beispiel (eine einfache Animation):

 import py5
 
 i = 0
 
 def setup():
     py5.size(600, 600)
     py5.frame_rate(5)
     py5.stroke_weight(20)
 
 def draw():
     global i
     
     py5.background(255, 255, 255)
     py5.translate(py5.width/2, py5.height/2)
     py5.rotate(py5.PI/8 * i)    
 
     py5.line(-100, 0, 100, 0)
     i += 1
 
 py5.run_sketch()

Es wird eine rotierende Linie gezeichnet (z.B. wie bei einem Installationsprozess verwendet - zeigt an, dass der Installationsfortschritt nicht eingefroren ist). Hierbei ist nur aufzupassen, dass der Hintergrund in &lt;code&gt;draw()&lt;/code&gt; gesetzt wird, ansonsten würden die Linien additiv gezeichnet. Das ist zwar auch schön, aber eben nicht das gewünschte Resultat.

Hiermit belassen wir es mit der py5-Bibliothek und wenden uns wieder &quot;mathematischeren&quot; Themen zu.

= Vektoren und Matrizen =
== Zahlenfolgen ==
Für das Erstellen von Zahlenfolgen bieten sich die Funktionen &lt;code&gt;arange&lt;/code&gt; und &lt;code&gt;linspace&lt;/code&gt; aus dem &lt;code&gt;numpy&lt;/code&gt;-Modul an.

 from numpy import *
 
 start = 0
 stop = 10
 step = 2
 num = 10
 
 r = arange(start, stop, step)   # step ... Schrittweite
 l = linspace(start, stop, num)  # num ... Anzahl der Werte
 
 print(&quot;r = &quot;, r)
 print(&quot;l = &quot;, l)

Ausgabe:
 r =  [0 2 4 6 8]
 l =  [ 0.          1.11111111  2.22222222  3.33333333  4.44444444  5.55555556
   6.66666667  7.77777778  8.88888889 10.        ]

Bei &lt;code&gt;arange&lt;/code&gt; ist der &lt;code&gt;stop&lt;/code&gt;-Wert nicht im Ergebnis enthalten, bei &lt;code&gt;linspace&lt;/code&gt; standardmäßig aber sehr wohl. Jedoch kann man das bei &lt;code&gt;linspace&lt;/code&gt; auch ändern. Dann ist der Stoppwert nicht mehr enthalten: 

 linspace(start, stop, num, endpoint=False)

== Vektoren ==
Vektoren sollten jedem aus der Linearen Algebra bekannt sein. 

=== Arrays ===
In Python mit NumPy kann man Vektoren durch die Funktion array erzeugen.

 import numpy as np
 
 l1 = (-5, 3, 2)
 l2 = (1, 1, 4)
 
 a1 = np.array(l1)
 a2 = np.array(l2)
 
 a3 = a1 + a2
 a4 = 2 * a2
 
 print(a1)
 print(a2)
 print(a3)
 print(a3[2])
 print(a4)

Ausgabe:
 [-5  3  2]
 [1 1 4]
 [-4  4  6]
 6
 [2 2 8]

=== Zeilen- und Spaltenvektoren ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 print(z)
 print(s)

Ausgabe:
 [ [-5  3  2] ]
 [[1]
  [1]
  [4]]

=== Skalarprodukt ===
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4))
 
 skalarprodukt = np.dot(a1, a2)  
 
 print(skalarprodukt)

Ausgabe:
 6

=== Vektorprodukt ===
&lt;math&gt;a\ast b=\left(\begin{array}{c}
a_{1}\\
a_{2}\\
a_{3}
\end{array}\right)\ast\left(\begin{array}{c}
b_{1}\\
b_{2}\\
b_{3}
\end{array}\right)=\left(\begin{array}{c}
a_{2}b_{3}-a_{3}b_{2}\\
a_{3}b_{1}-a_{1}b_{3}\\
a_{1}b_{2}-a_{2}b_{1}
\end{array}\right)
&lt;/math&gt; 

Python-Code:
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4)) 
 
 vektorprodukt = np.cross(a1, a2) 
 
 print(vektorprodukt)

Ausgabe:
 [10 22 -8]

=== Transponierter Vektor ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 # transponierter Vektor
 z_tp = np.transpose(z)
 # transponierter Vektor
 s_tp = np.transpose(s)
 
 print(z_tp)
 print(s_tp)

Ausgabe:
 [[-5]
  [ 3]
  [ 2]]
 [ [1 1 4] ]

=== Vektorfelder visualisieren ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 # Daten generieren
 x = np.arange(0, 10, 1)
 y = np.arange(0, 10, 1)
 X, Y = np.meshgrid(x, y)
 U = X * Y
 V = Y + X
 
 # Plotten
 fig, ax = plt.subplots()
 
 ax.quiver(X, Y, U, V, angles='xy')
 
 plt.show()

Ausgabe:

[[Datei:PythonIng_quiver1.png]]

== Matrizen==
 import numpy as np
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 print(m1)

Ausgabe:
 [[1 2 3]
  [4 5 6]]

=== Zugriff auf Matrizenelemente ===
Beispiel:

 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 
 # Element aus Zeile 2 und Spalte 3 (Achtung! Index startet bei Null)
 print(m1[1,2])

Ausgabe:
 6

Visualisierung:
  
     0   1   2
   +-----------+
 0 | 1 | 2 | 3 |
   +-----------+
 1 | 4 | 5 | '''6''' |
   +-----------+


Beispiel:

 import numpy as np
 
 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
 
 B = np.matrix(A)     
 
 print(B[2::, ::2])

Ausgabe:

 [['20' '22']
  ['30' '32']
  ['40' '42']]

Mit der NumPy-Bibliothek funktioniert das zweidimensionale Slicing. Mit normalen Listen/Tupels geht das nicht, was wir schon früher thematisiert haben.

=== Addition und Subtraktion von Matrizen ===
 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 m2 = np.matrix([[0, 0, 2], [1, 3, 2]])
 
 print(m1 + m2)
 print(m1 - m2)

Ausgabe:
 [[1 2 5]
  [5 8 8]]
 [[1 2 1]
  [3 2 4]]

=== Transponierte Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 2, 3], [4, 5, 6]])
 mt = np.transpose(m) 
 
 print(m)
 print(mt)

Ausgabe:
 [[1 2 3]
  [4 5 6]]
 [[1 4]
  [2 5]
  [3 6]]

=== Rang einer Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 rg = np.linalg.matrix_rank(m)
 
 print(rg)

Ausgabe:
 2

=== Inverse Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 mi = np.linalg.inv(m)
 
 print(mi)

Ausgabe:
 [[ 1.   0.6]
  [-0.  -0.2]]

=== Multiplikation von Matrizen (falksches Schema) ===
 import numpy as np
 
 m1 = np.matrix([[1, 3, 4],  [0, -5, 1]])
 m2 = np.matrix([[1, 2], [2, 3], [0, 2]])
 
 print(m1 @ m2)

Ausgabe:
 [[  7  19]
  [-10 -13]]

=== Eigenwerte und Eigenvektoren ===
 import numpy as np
 
 m = np.matrix([[5, 8],  [1, 3]])
 D,V = np.linalg.eig(m)
 
 # Eigenwerte
 print(D)
 # Eigenvektoren
 print(V)

Ausgabe:
 [7. 1.]
 [[ 0.9701425  -0.89442719]
  [ 0.24253563  0.4472136 ]]

=== Teilmatrizen ===
 import numpy as np
 m = np.matrix([[1, 3, 4],  [0, -5, 1]])
 print(&quot;m = &quot;, m)
 
 # Erste Zeile extrahieren
 m1 = m[0,:]
 print(&quot;m1 = &quot;, m1)
 
 # Das Element aus der 1. Zeile und der 2. Spalte extrahieren
 m2 = m[0,1]
 print(&quot;m2 = &quot;, m2)
 
 # Zweite Spalte extrahieren
 m3 = m[:, 1]
 print(&quot;m3 = &quot;, m3)

Ausgabe:
 m =  [[ 1  3  4]
  [ 0 -5  1]]
 m1 =  [ [1 3 4] ]
 m2 =  3
 m3 =  [[ 3]
  [-5]]

=== Spezielle Matrizen ===
==== Nullmatrix ====
 import numpy as np
 z = np.zeros((3, 2))
 print(z)

Ausgabe:
 [[0. 0.]
  [0. 0.]
  [0. 0.]]

==== Einheitsmatrix ====
 import numpy as np
 z = np.eye(3)
 print(z)

Ausgabe:
 [[1. 0. 0.]
  [0. 1. 0.]
  [0. 0. 1.]]

==== Matrix mit lauter Einsen ====
 import numpy as np
 z = np.ones((3, 2))
 print(z)

Ausgabe:
 [[1. 1.]
  [1. 1.]
  [1. 1.]]

=== Spärlich besetzte Matrizen ===
Das Thema spärlich besetzter Matrizen wird hier nur kurz angerissen. Nähere Details siehe unter dem Weblink  [https://docs.scipy.org/doc/scipy/reference/sparse.html#module-scipy.sparse]. 

Beispiel:

 import numpy as np
 import scipy
 
 A = scipy.sparse.csr_array(np.eye(5))
 
 print(A)

Ausgabe:
 &lt;Compressed Sparse Row sparse array of dtype 'float64'
         with 5 stored elements and shape (5, 5)&gt;
   Coords        Values
   (0, 0)        1.0
   (1, 1)        1.0
   (2, 2)        1.0
   (3, 3)        1.0
   (4, 4)        1.0

csr steht für '''c'''ompressed '''s'''parse '''r'''ow.

Andere Möglichkeiten:
* coo-Format ('''coo'''rdinate Format): &lt;code&gt;scipy.sparse.coo_array()&lt;/code&gt;
* lil-Format ('''li'''st of '''l'''ists): &lt;code&gt;scipy.sparse.lil_array()&lt;/code&gt;
* csc-Format ('''c'''ompressed '''s'''parse '''c'''olumn): &lt;code&gt;scipy.sparse.csc_array()&lt;/code&gt;

Es gibt auch &lt;code&gt;scipy.sparse.csr_matrix()&lt;/code&gt; etc. Diese Befehle sind aber veraltet und es wird empfohlen, statt dessen die &lt;code&gt;..._array()&lt;/code&gt;-Funktionen zu verwenden.

&lt;u&gt;Aufgaben:&lt;/u&gt; 
Recherchieren Sie im Internet 
* generell zum Thema &quot;spärlich besetzte Matrizen mit Python&quot;.
* Was sind die Vor-/Nachteile von csr-arrays gegenüber coo- und lil-arrays?
* Wann verwendet man sinnvollerweise csr- und wann csc-arrays?
* Wie wandelt man coo-arrays in csr-arrays um?

= Lineare Gleichungssysteme =
Sei &lt;math&gt;Ax = b&lt;/math&gt; ein lineares Gleichungssystem. &lt;math&gt;A&lt;/math&gt; sei die Koeffizientenmatrix, &lt;math&gt;x&lt;/math&gt; der Lösungsvektor und &lt;math&gt;b&lt;/math&gt; ein bekannter Vektor.

Beispiel:
 import numpy as np
 
 A = np.array([[5, 1], [0, 2]])
 b = np.array([1, 2])
 
 x = np.linalg.solve(A, b)
 
 print(x)

Ausgabe:
 [0. 1.]

Siehe dazu auch das Kapitel [[Ing Mathematik: Numerisches Lösen von linearen Gleichungssystemen]]. Dort wird dieses Themengebiet u.a. mit weitergehenden Python-Skripten vertieft.

== Aufgabe ==
* Lösen Sie folgendes Gleichungssystem mittels Python (und zur Kontrolle auch händisch): 
 5x + 6y - 2z = 12
 3x - y  - 3z = 6
 2x + 2y + 4z = 5

= Polynome =
== Ein erstes einfaches Beispiel ==
Gegeben sei das Polynom &lt;math&gt;7x^3+5x^2+1&lt;/math&gt;. In Python:

 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p)

Ausgabe:
    3     2
 7 x + 5 x + 1

== Einzelne Polynomwerte berechnen ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p(1.5))

Ausgabe:
 35.875

== Polynome integrieren und differenzieren ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 
 # 1. Ableitung
 p1 = p.deriv()
 p2 = p.deriv(1)
 
 # 2. Ableitung
 p3 = p.deriv(2)
 
 # Integral
 p4 = p.integ()
 
 print(p1)
 print(p2)
 print(p3)
 print(p4)

Ausgabe:
     2
 21 x + 10 x
     2
 21 x + 10 x
 
 42 x + 10
       4         3
 1.75 x + 1.667 x + 1 x

== Nullstellen bestimmen ==
 import numpy as np
 
 p = np.poly1d([2, 5, 0, 4])
 r = np.roots(p)
 
 print(r)

Ausgabe:
 [-2.7621427 +0.j          0.13107135+0.84077099j  0.13107135-0.84077099j]

== Aufgaben ==
* Berechnen Sie den Wert für x = 3 des Polynoms &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Differenzieren und integrieren Sie das Polynom &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Berechnen Sie die Nullstellen von &lt;math&gt;y = 7x^5 - 3x^2 + 12&lt;/math&gt;.

= Nichtlineare Gleichungen und Gleichungssysteme =
== Nullstellenbestimmung ==
Löse eine beliebige Gleichung f(x) = 0, z.B. &lt;math&gt; f(x) = x^2 - 5\cos(x) - 10 = 0 &lt;/math&gt;:
 import scipy
 import numpy as np
 
 def f(x):
     return x**2 - 5*np.cos(x) - 10
    
 xstart = [-1, 1]        # Startwerte
 xn = scipy.optimize.root(f, xstart)
 
 print(xn.x)

Ausgabe:
 [-2.46813009  2.46813009]

Funktionsgraph:

[[Datei:octave_nichtlin2.jpg]]

== Gleichungssysteme ==
SymPy ist ein externes Modul, das symbolisches Rechnen ('''Sym'''bolic '''Py'''thon) ermöglicht. 

Folgende Aufgabe ist dem Buch &quot;Knorrenschild: Numerische Mathematik, Hanser, 2017, Seite 72&quot; entnommen. Zu lösen ist das nichtlineare Gleichungssystem

&lt;math&gt;f_1 = 2x_1 + 4x_2 = 0 &lt;/math&gt;

&lt;math&gt;f_2 = 4x_1 + 8x_2^3 = 0&lt;/math&gt;

Mit Python ist das so möglich:
 import sympy
 
 x1, x2 = sympy.symbols(&quot;x1 x2&quot;) 
 
 f1 = 2*x1 + 4*x2
 f2 = 4*x1 + 8*x2**3
 
 s = sympy.solve((f1, f2), x1, x2) 
 
 print(s)

Ausgabe:
 [(-2, 1), (0, 0), (2, -1)]

Plot:

[[Datei:IngPython_nl_gleichung1.svg|500px]]

= Komplexe Zahlen =
Die imaginäre Einheit wird in Python durch den Buchstaben &lt;code&gt;j&lt;/code&gt; symbolisiert. Darstellen kann man eine komplexe Zahl bekannterweise in mehreren Formen:
* Kartesische Darstellung &lt;math&gt;z = \Re(z) + j \cdot \Im(z)&lt;/math&gt;
* Polardarstellungen &lt;math&gt;z = r \cdot (\cos(\phi) + j \cdot \sin(\phi)) = r \cdot e^{j\cdot \phi}&lt;/math&gt;

Die konjugiert komplexe Zahl ist &lt;math&gt;z^* = \Re(z) - j \cdot \Im(z)&lt;/math&gt;

Nachfolgend einige mathematische Operationen mit Python und NumPy.

 import numpy as np
 
 z1 = 2 + 5j           # kartesische Darstellung
 z2 = 3 * np.exp(3j)   # Polardarstellung
  
 # Addition
 res = z1 + z2
 print(&quot;z1 + z2 = &quot;, res)
 
 # Multiplikation
 res = z1 * z2
 print(&quot;z1 * z2 = &quot;, res)
 
 # Realteil
 res = np.real(z2)
 print(&quot;Realteil von z2 = &quot;, res)
 
 # Imaginärteil
 res = np.imag(z2)
 print(&quot;Imaginaerteil von z2 = &quot;, res)
 
 # Betrag
 res = np.abs(z1)
 print(&quot;Betrag von z1 = &quot;, res)
 
 # Argument
 res = np.angle(z1)
 print(&quot;Argument von z1 = &quot;, res)
 
 # Konjugiert komplexe Zahl
 res = np.conj(z1)
 print(&quot;Konjugiert komplexe Zahl von z1 = &quot;, res)

Ausgabe:
 z1 + z2 =  (-0.9699774898013365+5.423360024179601j)
 z1 * z2 =  (-8.05675510050068-14.003167400647481j)
 Realteil von z2 =  -2.9699774898013365
 Imaginaerteil von z2 =  0.4233600241796016
 Betrag von z1 =  5.385164807134504
 Argument von z1 =  1.1902899496825317
 Konjugiert komplexe Zahl von z1 =  (2-5j)

= Interpolation =
 import numpy as np
 import scipy
 import matplotlib.pyplot as plt
 
 # Stützpunkte
 xp = np.arange(1, 6)
 yp = (0, -5, 2, 7, 6)
 
 ti = np.arange(1, 5, 0.01)
 
 i1 = scipy.interpolate.interp1d(xp, yp, kind = &quot;linear&quot;)
 i2 = scipy.interpolate.interp1d(xp, yp, kind = &quot;cubic&quot;) 
 
 plt.plot(xp, yp, &quot;rx&quot;)
 plt.plot(xp, i1(xp))
 plt.plot(ti, i2(ti))
 plt.show()

Ausgabe:

[[Datei:PythonIng_interpol1.png]]

&lt;code&gt;scipy.interpolate.interp1d()&lt;/code&gt; gilt als veraltet ([https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.interp1d.html]). Stattdessen soll man modernere Alternativen wie &lt;code&gt;scipy.interpolate.Akima1DInterpolator()&lt;/code&gt; oder &lt;code&gt;scipy.interpolate.CubicSpline()&lt;/code&gt; benutzen. Für die lineare Interpolation tut es &lt;code&gt;np.interp()&lt;/code&gt;.

&lt;u&gt;Aufgaben:&lt;/u&gt;
* Recherchieren Sie im Internet zu den oben genannten modernen Alternativen.
* Schreiben Sie obiges Programm auf die genannten moderneren Alternativen um.

= Differenzialrechnung =
== Numerisches Differenzieren ==
Als Beispiel differenzieren wir &lt;math&gt;y = 5x\sin{x}&lt;/math&gt; und stellen das Ganze grafisch dar.

 from findiff import Diff
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.linspace(0, 10, 1000)
 f = 5 * x * np.sin(x)
 dx = x[1] - x[0]
 
 # Ableitung
 d_dx = Diff(0, dx)
 df_dx = d_dx(f)
 
 # Grafik
 plt.plot(x, f, label = &quot;y&quot;)
 plt.plot(x, df_dx, label = &quot;y'&quot;)
 plt.grid()
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

Ausgabe:

[[Datei:octave_diff1.jpg]]

&lt;small&gt;findiff ist ein externes Modul. Dieses muss installiert werden (z.B. so: ...\Python\Scripts\pip.exe install --upgrade findiff). Für die Vorgehensweise unter openSUSE Tumbleweed siehe das Kapitel [[Ing_Mathematik:_Python#Mit_VPython | VPython]], nur dass das Ganze mit einer aktuelleren Python-Version exekutiert wird, z.B. mit Python 3.13.  Das im Buch &quot;Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler, Rheinwerk&quot; verwendete Modul &quot;scipy.misc&quot; ist veraltet (deprecated ... missbilligt). Lt. [https://docs.scipy.org/doc/scipy-1.17.0/dev/roadmap-detailed.html#misc SciPy-Dokumentation für die Version 1.17.0] wurden alle entsprechenden Features schon entfernt.&lt;/small&gt;

== Symbolisches Differenzieren ==
Differenzieren Sie die Funktionen &lt;math&gt;f_1(x) = x^2&lt;/math&gt; und &lt;math&gt;f_2(x) = \sin(x)\cos\left(\frac{x}{2}\right)&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2;
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 d1 = sympy.diff(f1, x)
 d2 = sympy.diff(f2, x)
 
 print(d1)
 print(d2)

Ausgabe:
 2*x
 -0.5*sin(0.5*x)*sin(x) + cos(0.5*x)*cos(x)

== Aufgaben ==
* Differenzieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.
* Differenzieren Sie die Funktion &lt;math&gt;y = \frac{\sinh(x)}{(1+x)}&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.

= Integralrechnung =
== Numerisches Integrieren ==
Berechnen Sie das Integral &lt;math&gt;\int_{0}^{3}x^2 dx&lt;/math&gt;.

 import scipy
 
 def f(x):
     return x**2
    
 i = scipy.integrate.quad(f, 0, 3)
 print(i)

Ausgabe:
 (9.000000000000002, 9.992007221626411e-14)

Das trifft den exakten Wert 9.0 ziemlich genau.

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} dx&lt;/math&gt;.

 import scipy
 import numpy as np
 
 def f(x):
     return 2**(-x)
   
 i = scipy.integrate.quad(f, 0, np.inf)
 print(i)

Ausgabe:
 (1.4426950408889556, 4.486558477977586e-09)

== Symbolisches Integrieren ==
Berechnen Sie &lt;math&gt;\int x^2 \text{d}x&lt;/math&gt; und &lt;math&gt;\int \sin{x}\cos{\frac{x}{2}} \text{d}x&lt;/math&gt;.
 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 i1 = sympy.integrate(f1, x)
 i2 = sympy.integrate(f2, x)
 
 print(i1)
 print(i2)

Ausgabe:
 x**3/3
 -0.666666666666667*sin(0.5*x)*sin(x) - 1.33333333333333*cos(0.5*x)*cos(x)

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} \text{d}x&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f = 2**(-x)
 i = sympy.integrate(f, (x, 0, sympy.oo))
 print(i)

Ausgabe:
 1/log(2)

&lt;code&gt;sympy.oo&lt;/code&gt; steht für das {{W|Unendlichzeichen}} &lt;math&gt;\infty&lt;/math&gt; (die liegende Acht oder das Möbiusband). Mit &lt;code&gt;sympy.pprint(i)&lt;/code&gt; ließe sich letzere Ausgabe etwas schöner schreiben:

   1   
 ──────
 log(2)

Man beachtete, &lt;code&gt;log&lt;/code&gt; steht hier für den natürlichen Logarithmus &lt;code&gt;ln&lt;/code&gt;.

== Aufgaben ==
* Integrieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; von 1 bis 5.
* Integrieren Sie die Funktion &lt;math&gt;y = x^3&lt;/math&gt; von 0 bis 4.
* Integrieren Sie &lt;math&gt;\int x^x(\log (x) + 1)\mathrm dx&lt;/math&gt; symbolisch.

= Gewöhnliche Differenzialgleichungen =
== DGL numerisch lösen ==
Für die Lösung von Differenzialgleichungen steht u.a. die Funktion scipy.integrate.solve_ivp() zur Verfügung. Diese Funktion implementiert auch das Runge-Kutta-Verfahren (RK45).

{{Wikipedia | Runge-Kutta-Verfahren}}

Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import scipy
 import numpy as np
 import matplotlib.pyplot as plt
 
 def dy_dx(x, y):
     return x**2 + y**3
 
 y0 = [1]
 xi = [0, 1]
 x = np.arange(0, 1, 0.01)
 
 z = scipy.integrate.solve_ivp(dy_dx, xi, y0, method=&quot;RK45&quot;, dense_output=True)
 y = z.sol(x)
 
 plt.plot(x, y.T)
 plt.grid()
 plt.show()

[[Datei:PythonIng_dgl1.png]]

== DGL symbolisch lösen ==
Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 print(lsg)

Ausgabe:
 [Eq(f(x), (-x**2)**(1/3)), Eq(f(x), (-x**2)**(1/3)*(-1 - sqrt(3)*I)/2), Eq(f(x), (-x**2)**(1/3)*(-1 + sqrt(3)*I)/2)]

Mit &lt;code&gt;sympy.pprint&lt;/code&gt; (pretty print) lässt sich die Ausgabe etwas übersichtlicher darstellen.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 sympy.pprint(lsg)

Ausgabe:
 ⎡                           _____                        _____            ⎤
 ⎢          _____         3 ╱   2                      3 ╱   2             ⎥
 ⎢       3 ╱   2          ╲╱  -x  ⋅(-1 - √3⋅ⅈ)         ╲╱  -x  ⋅(-1 + √3⋅ⅈ)⎥
 ⎢f(x) = ╲╱  -x  , f(x) = ────────────────────, f(x) = ────────────────────⎥
 ⎣                                 2                            2          ⎦

== Aufgaben ==
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \frac{1}{x\cdot y}&lt;/math&gt; mit Python. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;m' = -k\cdot m&lt;/math&gt;. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \sqrt{|y|}&lt;/math&gt;.

=Laplace-Transformation=
Laplace-Transformation:

&lt;math&gt;F(s) =\mathcal{L} \left\{f\right\}(s) = \int_{0}^{\infty} f(t) \mathrm e^{-st} \,\mathrm{d}t, \qquad s\in\mathbb{C}
&lt;/math&gt;

Inverse Laplace-Transformation:

&lt;math&gt;\mathcal{L}^{-1} \left\{F\right\}(t)
  = \frac{1}{2 \pi \mathrm j} \int_{ \gamma - \mathrm j \infty}^{ \gamma + \mathrm j \infty} \mathrm e^{st} F(s)\,\mathrm ds 
= \begin{cases}
      f(t) &amp; \text{für } t \geq 0 \\
      0    &amp; \text{für } t &lt; 0
    \end{cases}
&lt;/math&gt;

Siehe auch [[Ing_Mathematik:_Laplace-Transformation]]

Code:
 import sympy
 from sympy.abc import t, s
 
 # Laplace-Transformation der Funktion f(t) = 1 (Heaviside-Fkt.)
 f = 1
 # alternativ: f = sympy.Heaviside(t)
 F = sympy.laplace_transform(f, t, s, noconds=True)
 print(&quot;Laplace-Transformierte F(s):&quot;, F) 
 
 # Inverse Laplace-Transformation zurück in den Zeitbereich
 f_inv = sympy.inverse_laplace_transform(F, s, t)
 print(&quot;Inverse Transformation f(t):&quot;, f_inv)

Ausgabe:
 Laplace-Transformierte F(s): 1/s
 Inverse Transformation f(t): Heaviside(t)

Die Zeile

 from sympy.abc import t, s

steht alternativ für

 t = sympy.symbols(&quot;t&quot;)
 s = sympy.symbols(&quot;s&quot;)

&lt;u&gt;Aufgaben&lt;/u&gt;: Ermitteln Sie mittels SymPy die &lt;math&gt;\mathcal{L}&lt;/math&gt;-Transformierten und dann wieder die  &lt;math&gt;\mathcal{L}^{-1}&lt;/math&gt;-Transformationen (ähnlich wie beim obigen Beispiel):
* &lt;math&gt;\sin(t) \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;t^3 \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;\text{e}^{\omega t} \circ\! -\! \bullet \ ?&lt;/math&gt;

=Fourier-Reihen=
&lt;math&gt;
f(x)\approx \frac{a_{0}}{2}+\sum_{k=1}^{\infty}\left(a_{k}\cos\left(kx\right)+b_{k}\sin\left(kx\right)\right)
&lt;/math&gt;

&lt;math&gt;
a_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\cos\left(kx\right)\mathrm dx\quad\text{für }k\geq0
&lt;/math&gt;

&lt;math&gt;
b_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\sin\left(kx\right)\mathrm dx\quad\text{für }k\geq1
&lt;/math&gt;

Für die Sägezahnfunktion &lt;math&gt;y=x;\, 0 &lt; x &lt; 2\pi&lt;/math&gt; sei die Fourierreihe mit einem Python-Programm (unter Mithilfe von sympy) hergeleitet.

Code:

 from sympy import fourier_series, pi, symbols, pprint
 
 x = symbols('x')
 f = x
 s = fourier_series(f, (x, 0, 2*pi))
 pprint(s.truncate(n=4))

Ausgabe:

                        2⋅sin(3⋅x)    
 -2⋅sin(x) - sin(2⋅x) - ────────── + π
                            3

Siehe auch [[Ing Mathematik: Fourierreihen]].

Ein komplizierteres Beispiel:

[[Datei:IngMath fourier bsp13.svg | 300px]]

&lt;math&gt;0\le t &lt; T/2\text{:}\quad f(t) = H&lt;/math&gt;

&lt;math&gt;T/2 \le t \le T\text{:}\quad f(t) = \frac{2H}{T}\left( t-\frac{T}{2}\right)&lt;/math&gt;

Code:

 import sympy as sp
 
 H = sp.Symbol('H', positive=True)
 T = sp.Symbol('T', positive=True)
 t = sp.Symbol('t')
 
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T/2)),
     (2*H/T*(t-T/2), (t &gt; T/2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Ausgabe:

      ⎛2⋅π⋅t⎞        ⎛4⋅π⋅t⎞        ⎛6⋅π⋅t⎞          ⎛2⋅π⋅t⎞          ⎛6⋅π⋅t⎞      
 H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   2⋅H⋅cos⎜─────⎟   2⋅H⋅cos⎜─────⎟      
      ⎝  T  ⎠        ⎝  T  ⎠        ⎝  T  ⎠          ⎝  T  ⎠          ⎝  T  ⎠   3⋅H
 ──────────── - ──────────── + ──────────── + ────────────── + ────────────── + ───
      π             2⋅π            3⋅π               2                 2         4 
                                                    π               9⋅π

=Rechnen mit wirklich großen Zahlen=
Bekannt ist, dass Python kaum Einschränkungen beim Wertebereich von Ganzzahlen hat, z.B.

 print(10**300)

Ausgabe (gekürzt):

 100000000000000000000...00000000000000000000000000000000000000000000000000000000000000000000000

Ähnliches geht auch mit Gleitpunktzahlen, z.B. durch die Verwendung des Moduls [https://mpmath.org/ mpmath]:

 import mpmath
 print(mpmath.mpf(1500.4)**mpmath.mpf(300))

Ausgabe:

 7.27975299218612e+952

Anderes Beispiel:

 from mpmath import mp, pi
 mp.dps = 100
 print(pi)

Ausgabe:

 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068

mpmath kann noch einiges mehr, dazu sei aber auf die entsprechende Dokumentation auf der mpmath-Homepage verwiesen. mpmath ist Bestandteil von SymPy, kann aber auch separat installiert werden.

Aber auch Python selbst besitzt eine Möglichkeit, um mit großen bzw. exakten Gleitpunktzahlen zu rechnen, nämlich das interne Modul decimal. Dieses hat einige Vorteile gegenüber mpmath, aber auch gravierende Nachteile. Diese seien hier nicht detailliert aufgezählt. Grob gesagt hat decimal im Finanzwesen seine Berechtigung. Für wissenschaftliche Anwendungen wird aber mpmath vorzuziehen sein, da es u.a. vielfältige mathematische Funktionen bereit stellt. Nachfolgend ein einfaches Beispiel mit decimal:

 import decimal
 print(&quot;Potenzierung:&quot;, decimal.Decimal(1500.4) ** decimal.Decimal(300.0))
 print(&quot;Einfache Addition:&quot;, 0.1 + 0.2)
 decimal.getcontext().prec = 50
 print(&quot;Addition mit decimal:&quot;, decimal.Decimal(&quot;0.1&quot;) + decimal.Decimal(&quot;0.2&quot;))

Ausgabe:

 Potenzierung: 7.279752992186121551039839134E+952
 Einfache Addition: 0.30000000000000004
 Addition mit decimal: 0.3

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet die genauen Vor- und Nachteile von decimal und mpmath. Verwenden Sie dazu auch KI (z.B. von Google, chatgpt).

= pint - mit physikalischen Größen rechnen = 
[[File:Pint-Glas_UK.jpg|right|100px]]
pint ist ein externes Python-Paket zur Manipulation von physikalischen Einheiten. Es muss vor der ersten Benutzung installiert werden (Vorgehensweise wie immer: pip, YaST, via venv etc.).

Beispiel:

 import pint
 import numpy as np
 
 ureg = pint.UnitRegistry()
 
 # Einfache Berechnung
 print(3 * ureg.meter + 4 * ureg.cm)
 
 # Mit NumPy
 npeinzel = [3, 4] * ureg.meter + [2, 5] * ureg.cm
 print(npeinzel)
 npsum = np.sum(npeinzel)
 print(npsum)
 
 # Konvertierung von Einheiten
 npsum_inch = npsum.to(ureg.inch)
 print(npsum_inch)
 
 print(npeinzel.magnitude)
 print(npeinzel.units)
 print(npeinzel.dimensionality)

Ausgabe:

 3.04 meter
 [3.02 4.05] meter
 7.07 meter
 278.3464566929134 inch
 [3.02 4.05]
 meter
 [length]

Die Dokumentation zu pint findet sich auf [https://pint.readthedocs.io/en/stable/].

=Regelungstechnische Aufgabenstellungen=
Für regelungstechnische Aufgaben gibt es u.a. das externe Paket &lt;code&gt;control&lt;/code&gt;. Hier soll nicht detailliert darauf eingegangen werden. Anhand eines Beispiels soll anschließend nur die Visualisierung in Form eines Bode-Diagramms und der Sprungantwort gezeigt werden. Gegeben sei ein P-Regler mit &lt;math&gt;R = \frac{5}{2}&lt;/math&gt; und eine Strecke &lt;math&gt;S= \frac{1}{30s^3+20s^2+10s+1,5}&lt;/math&gt;. Gesucht sei vorerst ein Bode-Diagramm für den offenen Regelkreis und das Führungsverhalten.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke  # oder: G0 = ct.series(regler, strecke)
 Gw = ct.feedback(G0)
 
 ct.bode_plot(G0, label='G0')
 ct.bode_plot(Gw, label='Gw')
 plt.show()

[[Datei:PythonIng_bode1.svg]]

Nun noch für obiges Beispiel die Sprungantwort. Diese zeigt einige große Überschwinger, d.h. der Regler kann sicher noch optimiert werden.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke 
 Gw = ct.feedback(G0) 
 
 t, y = ct.step_response(Gw)
 
 plt.plot(t,y)
 plt.title('Sprungantwort')
 plt.xlabel('t')
 plt.ylabel('h(t)')
 plt.grid()
 plt.show()

[[Datei:PythonIng_bode3.svg]]

Einige weitere wichtige Daten (Phasenreserve, Amplitudenreserve, Durchtrittsfrequenz) lassen sich mittels der &lt;code&gt;control&lt;/code&gt;-Funktion &lt;code&gt;margin()&lt;/code&gt; ermitteln. Die Ortskurve lässt sich mit der Funktion &lt;code&gt;nyquist_plot()&lt;/code&gt; zeichnen. Dies sei hier aber nicht weiter ausgeführt.

==Aufgaben==
* Zeichen Sie mit Python die Ortskurve für obiges Beispiel.
* Was passiert, wenn man die Reglerverstärkung weiter aufdreht (z.B. auf &lt;math&gt;R = \frac{25}{2}&lt;/math&gt;)?
* Wie sehen das Bode-Diagramm und die Sprungantwort aus, wenn ein PI-Regler verwendet wird?

= Stereostatik etc. =
Das Modul SymPy bietet einige Möglichkeiten einfache Bauwerke zu berechnen, z.B. Balken oder Fachwerke. Nachfolgend wird ein einfaches Fachwerk berechnet und gezeichnet.

Python-Code:
 from sympy.physics.continuum_mechanics.truss import Truss 
 
 t = Truss()
 # Knoten
 t.add_node((&quot;A&quot;, -3, 0), (&quot;B&quot;, 0, 0), (&quot;C&quot;, 4, 0), (&quot;D&quot;, 7, 0),
            (&quot;E&quot;, 6, 1.5), (&quot;F&quot;, 2, 3), (&quot;G&quot;, -2, 1.5))
 # Stäbe
 t.add_member((&quot;AB&quot;,&quot;A&quot;,&quot;B&quot;), (&quot;BC&quot;,&quot;B&quot;,&quot;C&quot;), (&quot;CD&quot;,&quot;C&quot;,&quot;D&quot;))
 t.add_member((&quot;AG&quot;,&quot;A&quot;,&quot;G&quot;), (&quot;GB&quot;,&quot;G&quot;,&quot;B&quot;), (&quot;GF&quot;,&quot;G&quot;,&quot;F&quot;))
 t.add_member((&quot;BF&quot;,&quot;B&quot;,&quot;F&quot;), (&quot;FC&quot;,&quot;F&quot;,&quot;C&quot;), (&quot;CE&quot;,&quot;C&quot;,&quot;E&quot;))
 t.add_member((&quot;FE&quot;,&quot;F&quot;,&quot;E&quot;), (&quot;DE&quot;,&quot;D&quot;,&quot;E&quot;))
 # Auflager; roller ... Loslager, pinned ... Festlager
 t.apply_support((&quot;A&quot;,&quot;roller&quot;), (&quot;D&quot;,&quot;pinned&quot;))
 # Einwirkende Kräfte
 t.apply_load((&quot;G&quot;, 5, 270), (&quot;E&quot;, 3, 90))
 
 # Berechnung 
 t.solve()
 print(&quot;Reaction Forces: &quot;, t.reaction_loads)
 print(&quot;Internal Forces: &quot;, t.internal_forces)
 
 # Fachwerk zeichnen
 p = t.draw()
 p.show()

Ausgabe auf der Konsole:

 Reaction Forces:  {'R_A_y': 4.20000000000000, 'R_D_x': 0, 'R_D_y': -2.20000000000000}
 Internal Forces:  {'AB': 2.80000000000000, 'BC': 0.333333333333333, 'CD': -1.46666666666667, 
 'AG': -5.04777178564958, 'GB': -2.05555555555556, 'GF': -1.23413387432364, 
 'BF': 0.411111111111111*sqrt(13), 'FC': -0.3*sqrt(13), 'CE': 1.50000000000000, 
 'FE': 0.284800124843917, 'DE': 2.64407093534026}

Zeichnung:

[[File:PythonIng_fachwerk1.svg|300px]]

Details zu diesem Thema siehe z.B. [https://docs.sympy.org/latest/modules/physics/continuum_mechanics/index.html Continuum Mechanics] oder [https://docs.sympy.org/latest/tutorials/physics/continuum_mechanics/index.html Continuum Mechanics Tutorials]. Auch andere mechanische Probleme werden von SymPy abgehandelt ([https://docs.sympy.org/latest/tutorials/physics/index.html Physics Tutorials]).

== Aufgabe ==
Gegeben sei ein einseitig eingespannter Kragträger. Belastet wird er durch eine Einzellast am Trägerende. Für die Daten siehe folgende ASCII-Skizze:

                            | 20 kN  
    //|---&gt; x               |
    //|                     V
    //|----------------------
    //|         10 m        |
 
 Elastizitätsmodul E = 2,1*10⁵ N/mm²
 Flächenträgheitsmoment I = 0.001 m⁴

Berechnen Sie die Auflagerreaktionen, den Querkraft- und Biegemomentenverlauf, sowie die Verformungen.
Stellen Sie dies mit Hilfe von SymPy graphisch und auch mittels Formeln dar. Verwenden Sie dazu auch pprint (pretty print) aus dem SymPy-Modul. Zwecks Lösungsansatz siehe die oben aufgeführte Seite &quot;Continuum Mechanics Tutorials&quot;. Achten Sie auch auf die Einheiten! Kontrollieren Sie das Ganze mittels händischer Rechnung. In dem genannten Tutorial ist von &quot;Singularity Functions&quot; die Rede. Gemeint ist damit in diesem Kontext die {{W|Föppl-Klammer}}.

Einige Python-Programme, vorrangig zu Maschinenelementen, finden sich auf [https://baymp.de/download_python.html BayMP für Python] (Balken, Zahnräder, Stabknickung usw.).

=Thermodynamik= 
== PYroMat ==
Für thermodynamische Aufgabenstellungen gibt es verschiedene externe Module. Eines davon ist PYroMat (siehe auch [http://pyromat.org]). Damit lassen sich thermodynamische Stoffdaten für viele Substanzen berechnen.

Beispiel (einige Stoffdaten für Wasser bei 400°C und 20 bar berechnen):

 import pyromat as pm
 
 # Wasserdaten laden:
 H2O = pm.get('mp.H2O')
 
 # Stoffdaten berechnen:
 T = 673.15  # Temperatur in Kelvin
 p = 20      # Druck in bar
 v = H2O.v(T, p)
 h = H2O.h(T, p)
 s = H2O.s(T, p)
 print(f&quot;Spezifisches Volumen: {v} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {h} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {s} kJ/(kg K)&quot;)

Ausgabe:

 Spezifisches Volumen: [0.1512163] m³/kg
 Spezifische Enthalpie: [3248.3789473] kJ/kg
 Spezifische Entropie: [7.12924142] kJ/(kg K)

&lt;small&gt;
PYroMat muss vorab installiert werden (z.B. mittels pip, in eine virtuelle Umgebung)
&lt;/small&gt;

&lt;code&gt;mp&lt;/code&gt; steht für &quot;multi phase&quot;. Für ein ideales Gas wäre &lt;code&gt;ig&lt;/code&gt; zuständig, z.B. &lt;code&gt;'ig.O2'&lt;/code&gt;.

Beispiel (T-s-Diagramm für Wasser zeichnen):
 import numpy as np
 import matplotlib.pyplot as plt
 import pyromat as pm
 
 # Konfigurieren
 pm.config[&quot;unit_pressure&quot;] = &quot;bar&quot;
 pm.config[&quot;unit_temperature&quot;] = &quot;K&quot;
 fluid = pm.get(&quot;mp.H2O&quot;)
 
 # Temperaturbereich für das Nassdampfgebiet
 T_tripel = 273.16
 T_crit = 647.096
 T = np.linspace(T_tripel, T_crit - 0.1, 200)
 
 # Sättigungslinien berechnen und zeichnen
 for x in np.linspace(0.0, 1.0, 5):
     s = fluid.s(T=T, x=x)
     if(x&lt;=0.0):
         plt.plot(s, T, label=&quot;Siedelinie x=%3.1f&quot; % x, linewidth=2.0)
     elif(x&gt;=1.0):
         plt.plot(s, T, label=&quot;Taulinie x=%3.1f&quot; % x, linewidth=2.0)
     else:
         plt.plot(s, T, label=&quot;x=%3.1f&quot; % x, linewidth=1.0)
 
 # Isobaren zeichnen
 p_values = [0.1, 1, 10, 50, 100]
 T_isobar = np.linspace(T_tripel, 1000, 200)
 t = 0.7
 
 for p in p_values:
     s_iso = fluid.s(T=T_isobar, p=p)
     plt.plot(s_iso, T_isobar, 'k-', alpha=0.8, linewidth=0.8)
 
     t += .05
     idx = int(len(s_iso) * t)
     plt.text(s_iso[idx], T_isobar[idx], f&quot;{p} bar&quot;, fontsize=9, alpha=0.8)
 
 # Diagramm zeichnen
 plt.title(&quot;T-s-Diagramm für Wasser&quot;)
 plt.xlabel(&quot;Spezifische Entropie s in kJ/kg K&quot;, fontsize=10)
 plt.ylabel(&quot;Temperatur T in K&quot;, fontsize=10)
 plt.legend(loc=&quot;best&quot;)
 plt.grid(True)
 plt.show()

Ausgabe (in etwa so):

[[Datei:T-s-Diagramm fuer Wasser.svg|400px]]

== CoolProp ==
Auch mit CoolProp können Stoffdaten berechnet werden. Siehe auch [https://coolprop.org/coolprop/wrappers/Python/index.html]

Beispiel (Wasser bei 20bar und 400°C):
 import CoolProp.CoolProp as CP
 
 fluid = 'Water'
 T = 673.15   # Temperatur in Kelvin
 P = 20e5     # Druck in Pascal
 
 dichte = CP.PropsSI('D', 'T', T, 'P', P, fluid)
 enthalpie = CP.PropsSI('H', 'T', T, 'P', P, fluid)
 entropie = CP.PropsSI('S', 'T', T, 'P', P, fluid)
 
 print(f&quot;Spez. Volumen: {1/dichte:.6f} m³/kg&quot;)
 print(f&quot;Spez. Enthalpie: {enthalpie:.2f} J/kg&quot;)
 print(f&quot;Spez. Entropie: {entropie:.2f} J/kgK&quot;)

Ausgabe:
 Spez. Volumen: 0.151215 m³/kg
 Spez. Enthalpie: 3248344.02 J/kg
 Spez. Entropie: 7129.16 J/kgK

== iapws ==
Um Werte für Wasser(dampf) zu erhalten (IAPWS; '''I'''nternational '''A'''ssociation for the '''P'''roperties of '''W'''ater and '''S'''team) gibt es die Bibliothek iapws. Siehe auch [https://iapws.org/] und [https://pypi.org/project/iapws/]

Beispiel (Wasser für 20bar und 400°C):
 from iapws import IAPWS97
 
 dampf = IAPWS97(P=2.0, T=673.15)
 
 print(f&quot;Spezifisches Volumen: {dampf.v:.6f} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {dampf.h:.2f} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {dampf.s:.4f} kJ/(kgK)&quot;)
 print(f&quot;Phase: {dampf.phase}&quot;)

Ausgabe:
 Spezifisches Volumen: 0.151208 m³/kg
 Spezifische Enthalpie: 3248.23 kJ/kg
 Spezifische Entropie: 7.1290 kJ/(kgK)
 Phase: Gas

== TESPy ==
Ein anderes Modul für einen anderen Aufgabenzweck ist TESPy ('''T'''hermal '''E'''ngineering '''S'''ystems in '''Py'''thon). Dieses Modul ist für die Anlagensimulation zuständig. Für nähere Informationen siehe [https://tespy.readthedocs.io/en/main/getting_started/introduction.html]. Als Beipiel sei hier vorerst Code, der von der Google KI generiert wurde, angeführt. Der Code wurde überarbeitet, damit keine Warnungen auftreten. Bitte aber den Code trotzdem mit Vorsicht genießen, auch KI-generierter Code kann Fehler aufweisen. Eine Pumpe wird berechnet:

 from tespy.components import Sink, Source, Pump
 from tespy.connections import Connection
 from tespy.networks import Network
 
 # 1. Netzwerk definieren (Zentrales Steuerungselement)
 # Wir wählen Wasser als Fluid und bar/Celsius als Einheiten
 nw = Network(fluids=[&quot;water&quot;])
 nw.units.set_defaults(pressure=&quot;bar&quot;, pressure_difference=&quot;bar&quot;, 
                       temperature=&quot;°C&quot;, enthalpy=&quot;kJ / kg&quot;)
 
 # 2. Komponenten erstellen
 eingang = Source(&quot;Wasserquelle&quot;)
 ausgang = Sink(&quot;Wasserspeicher&quot;)
 pumpe = Pump(&quot;Speisewasserpumpe&quot;)
 
 # 3. Verbindungen definieren (Komponenten miteinander verknüpfen)
 c1 = Connection(eingang, &quot;out1&quot;, pumpe, &quot;in1&quot;)
 c2 = Connection(pumpe, &quot;out1&quot;, ausgang, &quot;in1&quot;)
 
 # Verbindungen dem Netzwerk hinzufügen
 nw.add_conns(c1, c2)
 
 # 4. Randbedingungen und Parameter festlegen
 # Zustand am Eingang (Druck, Temperatur, Massenstrom, Fluid-Zusammensetzung)
 c1.set_attr(
     v=1,  # Massenstrom: 1 kg/s
     T=20,  # Temperatur: 20 °C
     p=1,  # Druck: 1 bar
     fluid={&quot;water&quot;: 1},  # 100% Wasser
 )
 
 # Zustand am Ausgang / Zielwerte der Pumpe
 c2.set_attr(p=10)  # Ziel-Druck nach der Pumpe: 10 bar
 
 # Pumpeneigenschaften festlegen
 pumpe.set_attr(eta_s=0.8)  # Isentroper Wirkungsgrad von 80%
 
 # 5. Simulation ausführen
 nw.solve(mode=&quot;design&quot;)
 
 # 6. Ergebnisse ausgeben
 nw.print_results()
 
 # Spezifische Werte direkt auslesen
 print(&quot;\n--- Auswertung ---&quot;)
 print(f&quot;Erforderliche Pumpenleistung: {pumpe.P.val / 1000:.2f} kW&quot;)
 print(f&quot;Temperatur nach der Pumpe: {c2.T.val:.2f} °C&quot;)

Ausgabe (gekürzt):
  iter  | residual   | progress   | massflow   | pressure   | enthalpy   | fluid      | component  
 -------+------------+------------+------------+------------+------------+------------+------------
  1     | 7.04e+04   | 12 %       | 9.96e+02   | 0.00e+00   | 8.81e+04   | 0.00e+00   | 0.00e+00   
  2     | 5.91e-12   | 100 %      | 1.11e-13   | 0.00e+00   | 7.39e-12   | 0.00e+00   | 0.00e+00   
  3     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
  4     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
 Total iterations: 4, Calculation time: 0.01 s, Iterations per second: 480.85
 
 ##### RESULTS (Pump) #####
 +-------------------+----------+----------+-----------+----------+----------+----------+
 |                   |        P |       pr |        dp |      eta |    eta_s |     head |
 |-------------------+----------+----------+-----------+----------+----------+----------|
 | Speisewasserpumpe | 1.12e+06 | 1.00e+01 | -9.00e+00 | 8.00e-01 | 8.00e-01 | 9.19e+01 |
 +-------------------+----------+----------+-----------+----------+----------+----------+
 ...
 ...
 --- Auswertung ---
 Erforderliche Pumpenleistung: 1124.77 kW
 Temperatur nach der Pumpe: 20.07 °C

= Stochastik =
Die {{W|Stochastik}} ist ein sehr weites Feld. Hier werden etliche wichtige Themen kurz angerissen. Python stellt mit den Moduln math und statistics Software zu diesem Zwecke bereit. math und statistics sind bereits im Lieferumfang von Python enthalten. Aber auch mit den externen Modulen NumPy, SciPy, stochastic und pandas kann man Stochastik in Python betreiben. Die Theorie der Wahrscheinlichkeitsrechnung und Statistik soll etwas später in Band 5 dieser Buchreihe behandelt werden.

== Lageparameter == 
 import statistics
 
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 
 m1 = statistics.mean(werte)
 m2 = statistics.mode(werte)
 m3 = statistics.median(werte)
 
 print(&quot;Arithmetischer Mittelwert = &quot;, m1)
 print(&quot;Modalwert = &quot;, m2)
 print(&quot;Median = &quot;, m3)

Ausgabe:
 Arithmetischer Mittelwert =  3.5
 Modalwert =  1
 Median =  3.0

== Streuungsparameter ==
Beispiel (Berechnung der Standardabweichung):
 import statistics
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 s = statistics.stdev(werte)
 print(&quot;Standardabweichung = &quot;, s)

Ausgabe:
 Standardabweichung =  2.6770630673681683

Beispiel (Berechnung des Variationskoeffizienten V = Standardabweichung/Mittelwert)
 import numpy as np
 from scipy import stats
 import statistics
 
 k = 50
 
 dat1 = [14, 21, 18, 25, 30, 17, 20]
 dat = np.array(dat1)
 
 # Mit SciPy
 v = stats.variation(dat)
 vddof = stats.variation(dat, ddof=1)
 print(&quot;V SciPy: &quot;, v)
 print(&quot;V DDOF SciPy: &quot;, vddof)
 print(k*&quot;-&quot;)
 
 # mit NumPy
 mittelwert1 = np.mean(dat)
 std_abw1 = np.std(dat)
 std_abw1ddof = np.std(dat, ddof=1) 
 v1= std_abw1 / mittelwert1
 v1ddof = std_abw1ddof / mittelwert1
 print(&quot;Mittelwert NumPy: &quot;, mittelwert1)
 print(&quot;Std.abw. NumPy: &quot;, std_abw1)
 print(&quot;Std.abw. DDOF NumPy: &quot;, std_abw1ddof)
 print(&quot;V NumPy: &quot;, v1)
 print(&quot;V DDOF NumPy: &quot;, v1ddof)
 print(k*&quot;-&quot;)
 
 # nur mit reinem Python
 mittelwert2 = statistics.mean(dat1)
 std_abw2 = statistics.stdev(dat1)
 v2 = std_abw2 / mittelwert2
 print(&quot;Mittelwert Python: &quot;, mittelwert2)
 print(&quot;Std.abw. Python: &quot;, std_abw2)
 print(&quot;V Python:&quot;, v2)
 print(k*&quot;-&quot;)

Ausgabe:
 V SciPy:  0.23890355966467272
 V DDOF SciPy:  0.25804533701889254
 --------------------------------------------------
 Mittelwert NumPy:  20.714285714285715
 Std.abw. NumPy:  4.948716593053935
 Std.abw. DDOF NumPy:  5.3452248382484875
 V NumPy:  0.23890355966467272
 V DDOF NumPy:  0.2580453370188925
 --------------------------------------------------
 Mittelwert Python:  20.714285714285715
 Std.abw. Python:  5.3452248382484875
 V Python: 0.2580453370188925
 --------------------------------------------------

Der Unterschied bei der Standardabweichung zwischen reinem Python und den externen Bibliotheken SciPy und NumPy entsteht dadurch, dass einmal durch (n-1) und das andere Mal nur durch n dividiert wird. Dies kann bei NumPy und SciPy dadurch entschärft werden, indem &lt;code&gt;ddof=1&lt;/code&gt; gesetzt wird. ddof steht für '''D'''elta '''D'''egrees '''o'''f '''F'''reedom. &lt;small&gt;Je größer die Anzahl der Datensätze n wird, umso weniger spielt das eine Rolle.&lt;/small&gt;

== Kombinatorik ==
Beispiel:

 import math
 
 n = 7
 k = 5
 
 print(&quot;n! = &quot;, math.factorial(n))
 print(&quot;Kombinationen (n über k) = &quot;, math.comb(n, k))

Ausgabe:
 n! =  5040
 Kombinationen (n über k) =  21

Siehe zu diesem Thema auch [[Ing Mathematik: Permutationen, Kombinationen, binomischer Lehrsatz]]. Die Anzahlen lassen sich einfach aus den dortigen Formeln ermitteln, z.B. bei Permutationen mit &lt;math&gt;n!&lt;/math&gt; oder Variationen mit Wiederholungen als &lt;math&gt;n^k&lt;/math&gt;. Will man die Kombinationen oder Variationen aber auch als Liste ausgeben, so kann das Modul &lt;code&gt;itertools&lt;/code&gt; nützlich sein.  

Beispiel (Variationen ohne Wiederholung):

 from itertools import permutations
 
 menge = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]  # n = 4
 k = 3
 
 variationen = list(permutations(menge, k))
 
 for v in variationen:
     print(&quot;&quot;.join(v))
 
 print(50*&quot;-&quot;)
 print(len(variationen))

Ausgabe (gekürzt):
 ABC
 ABD
 ACB
 ...
 DCA
 DCB
 --------------------------------------------------
 24

Siehe zum Modul &lt;code&gt;itertools&lt;/code&gt; auch die Website [https://docs.python.org/3/library/itertools.html].

* Variationen mit Wiederholung: &lt;code&gt;itertools.product()&lt;/code&gt;
* Kombinationen ohne Wiederholung: &lt;code&gt;itertools.combinations()&lt;/code&gt;
* Kombinationen mit Wiederholung: &lt;code&gt;itertools.combinations_with_replacement()&lt;/code&gt;

== Zufallszahlen ==
Beispiel:
 import random
 
 # Ganzzahlige Zufallszahl von 1 bis 10
 zufallszahl1 = random.randint(1, 10)
 
 # Gleitpunktzahlen
 # zwischen 0.0 und 1.0
 zufallszahl2 = random.random()
 # Zahl zwischen 1.5 und 9.5
 zufallszahl3 = random.uniform(1.5, 9.5)
 
 # aus Liste auswählen
 farbe = [&quot;Rot&quot;, &quot;Grün&quot;, &quot;Blau&quot;]
 zufallswert = random.choice(farbe)
 
 print(zufallszahl1)
 print(zufallszahl2)
 print(zufallszahl3)
 print(zufallswert)

Ausgabe, z.B.:
 5
 0.14147945849015753
 6.894003397570905
 Rot

Benötigt man mehrere Zufallszahlen, so ist das Modul &lt;code&gt;numpy&lt;/code&gt; zu bevorzugen, z.B.:
* Normalverteilung: &lt;code&gt;np.random.normal(...)&lt;/code&gt;
* Gleichverteilung: &lt;code&gt;np.random.uniform(...)&lt;/code&gt;

== Histogramm ==
Zum Thema Histogramm siehe {{W|Histogramm}}.

Beispiel (mit Matplotlib):

 import matplotlib.pyplot as plt
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 
 plt.hist(daten, bins=25, edgecolor='darkgray')
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm.svg|300px]]

Beispiel (mit Seaborn):

 import matplotlib.pyplot as plt
 import seaborn as sns
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 sns.set_theme(style=&quot;darkgrid&quot;)
 sns.histplot(data=daten)
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm2.svg|300px]]

Das Kürzel &lt;code&gt;sns&lt;/code&gt; ist Konvention und steht für die fiktive Figur '''S'''amuel '''N'''orman '''S'''eaborn aus der US-Fernsehserie {{W|The West Wing – Im Zentrum der Macht | The West Wing}}.

== Box-Plot ==
[[File:Elements of a boxplot.svg|400px]]

Siehe auch {{W|Box-Plot}}.

Beispiel (mit Seaborn erstellt):
 import seaborn as sns
 import matplotlib.pyplot as plt
 
 df = sns.load_dataset(&quot;tips&quot;)
 sns.boxplot(data=df, x=&quot;day&quot;, y=&quot;tip&quot;, hue=&quot;day&quot;, legend=False)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot.svg|400px]]

Beispiel (mit Matplotlib erstellt):

 import matplotlib.pyplot as plt
 
 daten = [12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25]
 
 plt.boxplot(daten, patch_artist=True)
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot2.svg|300px]]

Um mehrere Box-Plots unterschiedlicher Farbe mit Matplotlib in einem Diagramm zu zeichnen, können Sie folgendermaßen vorgehen:

 import matplotlib.pyplot as plt
 
 daten = [[12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25],
          [10, 19, 20, 21, 20, 30, 19, 40, 11, 17, 19, 21]]
 
 farben = [&quot;green&quot;, &quot;blue&quot;]
 
 boxplot = plt.boxplot(daten, patch_artist=True)
 
 for patch, farbe in zip(boxplot['boxes'], farben):
     patch.set_facecolor(farbe)
 
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

== Regressionsrechnung ==
Beispiel:
 import numpy as np
 import matplotlib.pyplot as plt
 
 # Messpunkte
 x = np.array([1, 3, 5, 6, 8, 10, 20])
 y = np.array([3, 4, 5, 5, 7, 9, 11])
 
 # Regressionskurve (Grad 1 = lineare Regression, 2 = Polynom-Regression 2. Gr.)
 # y = kx + d
 k, d = np.polyfit(x, y, deg=1)
 # y = ax**2 + bx + c
 a, b, c = np.polyfit(x, y, deg=2)
 
 x_l = np.linspace(1, 20, 100)
 y_p = a * x_l**2 + b * x_l + c
 
 # Zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.plot(x, k*x + d, color='blue', label='Regressionsgerade')
 plt.plot(x_l, y_p, color='red', label='Regressionspolynom 2. Gr.')
 plt.xlabel('x')
 plt.ylabel('y')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_regression.svg|400px]]

== Korrelationsrechnung ==
Beispiel:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 # Messdaten
 x = [1, 3, 4, 5, 6]
 y = [2, 4, 6, 8, 5]
 
 daten = {'X': x, 'Y': y}
 df = pd.DataFrame(daten)
 
 # Korrelation
 korr = df['X'].corr(df['Y'])
 print(f&quot;Korrelationskoeff.: {korr}&quot;) 
 
 # Messpunkte zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:
 Korrelationskoeff.: 0.7556096518348252

[[Datei:IngMath_korrelation.svg|300px]]

== Mengen und Venn-Diagramme ==
Beispiel: 
 import matplotlib.pyplot as plt
 from matplotlib_venn import venn2
 
 menge_a = {1, 2, 3, 4, 5, 6}
 menge_b = {4, 5, 6, 7, 8}
 
 vereinigung = menge_a | menge_b
 schnitt = menge_a &amp; menge_b
 print(&quot;Vereinigungsmenge = &quot;, vereinigung)
 print(&quot;Schnittmenge = &quot;, schnitt)
 
 venn2([menge_a, menge_b], set_labels=('Menge A', 'Menge B'))
 plt.show()

Ausgabe:
 Vereinigungsmenge =  {1, 2, 3, 4, 5, 6, 7, 8}
 Schnittmenge =  {4, 5, 6}

[[Datei:IngMath_venn.svg|300px]]

Siehe auch {{W|Mengendiagramm#Venn-Diagramme}}.

== Verteilungs- und Dichtefunktion ==
* CDF ... '''C'''umulative '''D'''istribution '''F'''unction, Verteilungsfunktion
* PDF ... '''P'''robability '''D'''ensity '''F'''unction, Dichtefunktion

Beispiel (Normalverteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 from scipy.stats import norm
 
 my, sigma = 0, 1
 x = np.linspace(-4, 4, 50)
 
 pdf = norm.pdf(x, my, sigma)
 cdf = norm.cdf(x, my, sigma)
 
 plt.plot(x, pdf, lw=2, label=&quot;Dichtefunktion&quot;)
 plt.plot(x, cdf, lw=2, label=&quot;Verteilungsfunktion&quot;)
 plt.legend()
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:IngMath_cdf_pdf.svg|300px]]

Beispiel (&lt;math&gt;\chi^2&lt;/math&gt;-Verteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 import scipy.stats as stats
 
 x = np.linspace(0, 20, 500)
 
 # df ... degree of freedom, Freiheitsgrad
 pdf = (stats.chi2.pdf(x, df=2), stats.chi2.pdf(x, df=5), stats.chi2.pdf(x, df=10))
 
 for i in range(0,3):
     if(i==0):
         lab = &quot;Freiheitsgrad 2&quot;
     elif(i==1):
         lab = &quot;Freiheitsgrad 5&quot;
     else:
         lab = &quot;Freiheitsgrad 10&quot;
 
     plt.plot(x, pdf[i], label=lab, lw=2)
 
 plt.grid()
 plt.legend()
 plt.show()

Ausgabe:

[[Datei:IngMath_chi2.svg | 300px]]

== Schätzen und Testen ==
=== Intervallschätzung ===
Als Beispiel seien Daten gegeben, die von ''Dürr, Mayer: Wahrscheinlichkeitsrechnung und Schließende Statistik; 7. Aufl., Hanser, 2014, Seite 137'' stammen. Und zwar soll das 95%-Vertrauensintervall für den Mittelwert des Kaloriengehalts (kcal/100g) von Hähnchen ermittelt werden. Wir wollen das mit Python inkl. NumPy und SciPy durchführen. Die Stichprobe ist groß (50 Hähnchen):

Python-Code:
 import numpy as np
 import scipy.stats as stats
 
 # Stichprobe
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203]
 
 # Parameter definieren
 konfidenzniveau = 0.95
 mean = np.mean(daten)
 std = np.std(daten, ddof=1)
 stdfehler = stats.sem(daten)
 
 intervall = stats.norm.interval(confidence=konfidenzniveau, loc=mean, scale=stdfehler)
 
 print(f&quot;Mittelwert: {mean}&quot;)
 print(f&quot;Standardabweichung: {std}&quot;)
 print(f&quot;Konfidenzintervall: {intervall}&quot;)

Ausgabe:
 Mittelwert: 215.48
 Standardabweichung: 33.14238915925757
 Konfidenzintervall: (np.float64(206.29356722321992), np.float64(224.66643277678006))

Diese Werte stimmen gerundet mit denen im genannten Buch überein. Zum Code selbst:
* sem steht für '''s'''tandard '''e'''rror of the '''m'''ean.
* &lt;code&gt;scipy.stats.norm&lt;/code&gt; ... Modul für die Normalverteilung.

=== Punktschätzung ===
Gleiche Daten wie oben bei der Intervallschätzung.

Python-Code:
 import numpy as np
 from scipy import stats
 
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203
         ]
 
 mu_hat, sigma_hat = stats.norm.fit(daten) 
 
 print(f&quot;Schätzer für den Erwartungswert (μ): {mu_hat:.4f}&quot;)
 print(f&quot;Schätzer für die Standardabweichung (σ): {sigma_hat:.4f}&quot;)

Ausgabe:
 Schätzer für den Erwartungswert (μ): 215.4800
 Schätzer für die Standardabweichung (σ): 32.8093

=== Hypothesentests ===
Beispiel:

 import numpy as np
 import scipy.stats as stats
 
 x_quer = 12.075      # Stichproben-Mittelwert
 var    = 0.069       # Stichproben-Varianz
 n      = 90          # Stichprobengröße
 my_0   = 12.0        # Nullhypothese
 alpha  = 0.05        # Signifikanzniveau
 
 z_stat = (x_quer - my_0) / np.sqrt(var / n)
 p_val = 2 * (1 - stats.norm.cdf(np.abs(z_stat)))
 
 print(f&quot;Z-Statistik: {z_stat:.4f}&quot;)
 
 if p_val &lt; alpha:
     print(f&quot;p-Wert: {p_val:.6f} &lt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird verworfen.&quot;)
 else:
     print(f&quot;p-Wert: {p_val:.6f} &gt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird nicht verworfen.&quot;)

Ausgabe:

 Z-Statistik: 2.7087
 p-Wert: 0.006755 &lt; alpha: 0.05
 Die Nullhypothese wird verworfen.

== Statistische Qualitätskontrolle ==
Beispiel (Mittelwertkarte):

 import numpy as np
 import matplotlib.pyplot as plt
 
 # Gegeben
 sollwert = 50.0
 varianz = 4.0
 stichproben_umfang = 1
 daten = [49.5, 50.2, 53.0, 48.1, 52.6, 53.4, 49.8]
 
 # Berechnung
 standardabweichung = np.sqrt(varianz)
 streuung = standardabweichung / np.sqrt(stichproben_umfang)
 
 cl = sollwert
 ucl = cl + 3 * streuung
 lcl = cl - 3 * streuung
 
 # Darstellung
 plt.plot(daten, marker='o', linestyle='-', color='b', label='Messdaten')
 plt.axhline(cl, color='green', linestyle='-', label=f'CL: {cl}')
 plt.axhline(ucl, color='red', linestyle='--', label=f'UCL: {ucl:.2f}')
 plt.axhline(lcl, color='red', linestyle='--', label=f'LCL: {lcl:.2f}')
 
 plt.title('Mittelwertkarte')
 plt.xlabel('Stichprobe')
 plt.ylabel('Wert')
 plt.legend(loc='lower left')
 plt.grid(True)
 plt.show()

Ausgabe:

[[Datei:IngMath_mittelwertkarte.svg|300px]]

Siehe auch {{W|Shewhart-Regelkarte}} und {{W|Qualitätsregelkarte}}.

* UCL ... '''U'''pper '''C'''ontrol '''Limit''', Obere Eingriffsgrenze
* LCL ... '''L'''ower '''C'''ontrol '''Limit''', Untere Eingriffsgrenze
* CL ... '''C'''enter '''L'''ine, Mittellinie

= Ein- und Ausgabe =
== print ==
Die Anweisung print haben wir schon oft verwendet. Hier soll anhand von Beispielen kurz beschrieben werden, was der Befehl print leisten kann.

 print(&quot;Hallo&quot;, &quot;Welt&quot;, 1, sep=&quot;-&quot;)
 print(&quot;Hallo&quot;, end=&quot; &quot;)
 print(&quot;Welt&quot;)

Ausgabe:
 Hallo-Welt-1
 Hallo Welt

== input ==
 a = int(input(&quot;Zahl 1: &quot;))
 b = int(input(&quot;Zahl 2: &quot;))
 
 print(&quot;a + b = &quot;, a+b)

Ausgabe (nach Eingabe der beiden Ganzzahlen):
 Zahl 1: 4
 Zahl 2: 5
 a + b =  9

== Aus Dateien lesen ==
Es seinen die datei.txt
 Hallo Welt.
 Wie geht es dir?
 ...

und test1.py
 dat = open(&quot;datei.txt&quot;, mode = &quot;r&quot;)
 print(dat.read())
 dat.close()

Ausgabe
 Hallo Welt.
 Wie geht es dir?
 ...

Mit dem open()-Befehl wird die Datei datei.txt im Lesemodus geöffnet (r ... read). Mit dem read()-Befehl wird die Datei eingelesen und mittels print ausgegeben.

== In Dateien schreiben ==
 dat = open(&quot;datei.txt&quot;, mode = &quot;a&quot;, encoding = &quot;utf-8&quot;)
 dat.write(&quot;Hänge Zeile an\n&quot;)
 dat.close()

Die Datei datei.txt sieht nach Abarbeitung des obigen Skripts nun so aus
 Hallo Welt.
 Wie geht es dir?
 ...
 Hänge Zeile an

Es wird die Datei im Schreibmodus geöffnet (a ... append (anhängend), w ... write (überschreibend)).
write() fügt hier also eine Zeile Text am Dateiende ein. close() schließt die Datei wieder.

Das close() kann man sich mit der with-Anweisung auch sparen.

 with open(&quot;datei.txt&quot;, mode=&quot;a&quot;, encoding=&quot;utf-8&quot;) as dat:
     dat.write(&quot;Hänge Zeile an\n&quot;)

= Benutzeroberflächen erstellen =
== tkinter ==
{{Wikipedia | Tkinter}}

Python bietet standardmäßig das Modul tkinter zur Programmierung von Benutzeroberflächen. Es müssen also bei der Verwendung von tkinter keine externen Module installiert werden. Hier wird eine (sehr) kurze Einführung in das Erstellen von grafischen Oberflächen mittels tkinter gegeben.

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 win.minsize(300, 50)
 but = tk.Button(win, text = &quot;Push the button&quot;)
 but.pack()
 win.mainloop()

Ausgabe:

[[Datei:PythonIng_gui1.jpg]]

Ein etwas komplizierteres Beispiel sei nachfolgend gezeigt. Es sollen zwei Strings miteinander verknüpft und ausgegeben werden. 

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 
 def on_button_clicked():
     str = ent1.get() + ent2.get()
     lab2[&quot;text&quot;] = str
  
 ent1 = tk.Entry(win)
 ent2 = tk.Entry(win)
 lab1 = tk.Label(win, text=&quot;verknuepfen mit&quot;)
 lab2 = tk.Label(win, text=&quot;&quot;) 
 but = tk.Button(win, text = &quot;=&quot;, command=on_button_clicked)
 
 ent1.pack(side=&quot;left&quot;)
 lab1.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 but.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 lab2.pack(side=&quot;left&quot;)
 
 win.mainloop()

Ausgabe  (vor der Eingabe der Teilstrings): 

[[Datei:PythonIng_gui2.jpg]]

Ausgabe (nach der Eingabe der Teilstrings und dem Drücken des =-Buttons): 

[[Datei:PythonIng_gui3.jpg]]

== curses ==
{{Wikipedia | curses}}

Mit dem curses-Modul lassen sich u.a. TUIs ('''T'''ext '''U'''ser '''I'''nterfaces) erstellen. Ein sehr einfaches Beispiel zur allgemeinen Funktionsweise wird nachstehend geliefert.
 
 import curses
 
 stdscr = curses.initscr()
 curses.start_color()
 curses.init_pair(1, curses.COLOR_RED, curses.COLOR_WHITE)
 stdscr.clear()
 
 stdscr.addstr(&quot;Hallo Welt&quot;, curses.color_pair(1))
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()
 
Als Ausgabe sollte &lt;span style=&quot;color:#FF0000;&quot;&gt;Hallo Welt&lt;/span&gt; (rote Schrift auf weißem Hintergrund) auf dem Terminal/der Konsole erscheinen. Getestet wurde dies mit openSUSE Tumbleweed, Python-Version 3.13.12. Das entsprechende Python-curses-Package muss installiert sein.

Allgemeine Informationen zur Terminal-/Konsolengröße und Cursorposition liefert folgendes Programm:
 
 import curses
 
 stdscr = curses.initscr()
 
 stdscr.addstr(3, 5, &quot;LINES: %d&quot; % curses.LINES)
 stdscr.addstr(4, 5, &quot;COLS:  %d&quot; % curses.COLS)
 
 (y,x) = stdscr.getyx()
 stdscr.addstr(5, 5, &quot;Momentane Cursorposition:  [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getbegyx()
 stdscr.addstr(6, 5, &quot;Koordinatenursprung:       [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getmaxyx()
 stdscr.addstr(7, 5, &quot;Fenstergröße:              [%d, %d]&quot; % (y, x))
 
 stdscr.addstr(11, 2, &quot;Taste drücken -&gt; Ende&quot;)
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()

Es sollte sich in etwa folgende Ausgabe ergeben:

     LINES: 44
     COLS:  110
     Momentane Cursorposition:  [4, 15]
     Koordinatenursprung:       [0, 0]
     Fenstergröße:              [44, 110]
 
 
 Taste drücken -&gt; Ende

Zur Funktionsweise von curses siehe auch das Wikibook [[ncurses]]. Zum Verständnis sind dort allerdings elementare Kenntnisse in der Programmiersprache C erforderlich.

== Qt ==
{{Wikipedia | Qt (Bibliothek)}}

Auch für das Qt-Framework gibt es eine Anbindung an Python. Nachfolgend ein einfaches Beispiel.

 import sys
 from PySide6.QtWidgets import QApplication, QLabel
 
 app = QApplication(sys.argv)
 label = QLabel(&quot;Hallo Welt!&quot;)
 label.show()
 sys.exit(app.exec())

Ausgabe:

[[Datei:PythonIng_gui10.png]]

== Gtk ==
{{Wikipedia | GTK (Programmbibliothek)}}

Eine idente Ausgabe, wie oben für Qt gezeigt, erzeugt z.B. folgendes Gtk-Programm:

 import gi
 gi.require_version(&quot;Gtk&quot;, &quot;4.0&quot;)
 from gi.repository import Gtk
 
 def on_activate(app):
     win = Gtk.ApplicationWindow(application=app)
     lab = Gtk.Label(label=&quot;Hallo Welt!&quot;)
     win.set_child(lab)
     win.present()
 
 app = Gtk.Application()
 app.connect('activate', on_activate)
 app.run(None)

Auch für die Benutzung von Qt und Gtk müssen die jeweiligen Packages installiert sein. Getestet wurden die entsprechenden Python-Programme nur unter openSUSE Tumbleweed. Wie das GTK-Paket unter MS Windows 11 installiert wird, siehe z.B. [https://www.gtk.org/docs/installations/windows Setting up GTK for Windows].

Damit sei aber das Thema &quot;Benutzeroberflächen erstellen&quot; hier abgeschlossen, da dies schon ein sehr spezielles Aufgabengebiet ist, das eher Informatiker und nicht so sehr Ingenieure anspricht. Bei Bedarf siehe aber ggf. die entsprechenden Links unten in diesem Tutorial. Dort sind weiterführende Informationen zu finden.

= Pandas kurz erklärt =
Hier wird kurz auf das externe Modul Pandas eingegangen. Pandas steht für '''Pan'''el '''Da'''ta und ist ein Modul für die Datenanalyse und -manipulation.

== Series ==
Vorstellbar ist eine &quot;Series&quot; wie eine einzelne Spalte in einem Tabellenkalkulationsprogramm.

Beispiel (Index implizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5]) # Temperaturwerte
 print(temp)

Ausgabe:
 0     8.5
 1    11.0
 2    12.5
 3    10.0
 4    13.0
 5    11.0
 6    14.5
 dtype: float64

Das Kürzel &lt;code&gt;pd&lt;/code&gt; ist Konvention. Es seien Temperaturwerte gegeben. Die erste Spalte bei der Ausgabe ist der Index. Die zweite Spalte enthält die Werte.

Beispiel (separater Zugriff auf den Index und auf die Werte):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5])
 print(temp.index)
 print(temp.values)

Ausgabe:
 RangeIndex(start=0, stop=7, step=1)
 [ 8.5 11.  12.5 10.  13.  11.  14.5]

Beispiel (Index explizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 print(&quot;*** Die gesamte Series ***&quot;)
 print(temp)
 
 print(&quot;*** Temperatur am Donnerstag ***&quot;)
 print(temp[&quot;Do&quot;])
 
 print(&quot;*** Tage wärmer als 12 Grad ***&quot;)
 temp_gr_12 = temp[temp &gt; 12]
 print(temp_gr_12)

Ausgabe:
 *** Die gesamte Series ***
 Mo     8.5
 Di    11.0
 Mi    12.5
 Do    10.0
 Fr    13.0
 Sa    11.0
 So    14.5
 dtype: float64
 *** Temperatur am Donnerstag ***
 10.0
 *** Tage wärmer als 12 Grad ***
 Mi    12.5
 Fr    13.0
 So    14.5
 dtype: float64

== DataFrame ==
Ein DataFrame entspricht einer Tabelle.

Beispiel (Erzeugen eines DataFrames):
 import pandas as pd
 
 tag   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 v1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=tag)
 v2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=tag)
 v3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=tag)
 
 tab = pd.concat([v1, v2, v3], axis=1)
 tab.columns = stadt
 
 print(tab)
 print(type(tab))

Ausgabe:
     Linz  Salzburg Innsbruck
 Mo     1         8     Hallo
 Di     2         9        16
 Mi     3        10        17
 Do     4        11        18
 Fr     5        12        19
 Sa     6        13        20
 So     7        14        21
 &lt;class 'pandas.core.frame.DataFrame'&gt;

Wir haben hier drei Datenspalten (v1, v2, v3) mit den Spaltennamen &quot;Linz&quot;, &quot;Salzburg&quot; und &quot;Innsbruck&quot;, sowie sieben Zeilen &quot;Mo&quot; bis &quot;So&quot;.

Beispiel (Zugriff auf eine Spalte):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab[&quot;Salzburg&quot;])

Ausgabe:
 Mo     8
 Di     9
 Mi    10
 Do    11
 Fr    12
 Sa    13
 So    14
 Name: Salzburg, dtype: int64

Beispiel (Zugriff auf eine Zeile):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab.loc[&quot;Di&quot;])

Ausgabe:
 Linz          2
 Salzburg      9
 Innsbruck    16
 Name: Di, dtype: object

== Grafiken erstellen ==
Hier sei nur ein Torten- oder Kreisdiagramm gezeichnet:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 expl = [0, 0.2, 0, 0, 0, 0, 0]
 temp.plot.pie(figsize=(5,5), explode=expl)
 plt.show()

Ausgabe:

[[Datei:IngPython_pandas1.svg|350px]]

Die &lt;code&gt;figsize&lt;/code&gt; hat nichts mit der Spaltenanzahl zu tun, sondern setzt die Fenster- oder Diagrammgröße in Inches (Breite * Höhe).
 
Mit Pandas kann man auch noch andere Diagrammarten erstellen, z.B. Linien- oder Balkendiagramme. Dies wird hier aber nicht vorgeführt.

== Arbeiten mit CSV- und LibreOffice-Dateien ==
Gegeben sei eine CSV-Datei test1.csv:
 Mai;Juni;Juli
 12;17;45
 15;65;65
 16;32;23
 4;14;7
 23;17;Keine Daten verfügbar
 67;Keine Daten verfügbar;45
 15;24;12

Lesen von dieser CSV-Datei:
 import pandas as pd
 
 tab = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 print(tab)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Schreiben in eine CSV-Datei test2.csv:
 import pandas as pd
 
 val = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 val.to_csv(&quot;test2.csv&quot;, index=False)

Ausgabedatei:
 Mai,Juni,Juli
 12,17,45
 15,65,65
 16,32,23
 4,14,7
 23,17,Keine Daten verfügbar
 67,Keine Daten verfügbar,45
 15,24,12

Die Ausgabedatei ist beinahe gleich wie die Eingabedatei. Es werden aber Kommas statt Strichpunkten verwendet. Daher kommt auch der Name CSV ('''C'''omma '''S'''eparated '''V'''alue). Will man wieder Strichpunkte, so kann man dies über den Parameter &lt;code&gt;sep=&quot;;&quot;&lt;/code&gt; in der &lt;code&gt;to_csv&lt;/code&gt;-Funktion machen.

Um direkt von einer ODS-Datei (LibreOffice Calc, '''O'''pen '''D'''ocument '''S'''preadsheet) zu lesen muss das Modul odfpy extra installiert sein (per YaST, pip etc.). Gelesen wird dann folgendermaßen:
 import pandas as pd
 
 df = pd.read_excel('test1.ods', engine='odf')
 print(df)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Die Datei &quot;test1.ods&quot; sei die Datei, aus der das obige &quot;test1.csv&quot; generiert wurde. Schreiben kann man ebenfalls in eine ODS-Datei:

 import pandas as pd
 
 daten = {
     &quot;Name&quot;: [&quot;Hugo&quot;, &quot;Richie&quot;, &quot;Wilhelmine&quot;],
     &quot;Alter&quot;: [38, 30, 29],
     &quot;Ort&quot;: [&quot;Linz&quot;, &quot;Innsbruck&quot;, &quot;Salzburg&quot;]
 }
 
 tab = pd.DataFrame(daten)
 
 with pd.ExcelWriter(&quot;test2.ods&quot;, engine=&quot;odf&quot;) as writer:
     tab.to_excel(writer, sheet_name=&quot;Daten&quot;, index=False)

Es ergibt sich eine &quot;test2.ods&quot;-Datei (Screenshot):

[[Datei:IngPython_pandas2.png|250px]]

== Sonstiges ==
Hier seien stichpunktartig einige weitere Features von Pandas angeführt:
* {{W|Pivot-Tabelle|Pivot-Tabellen}} (pivot ... Dreh-, Angelpunkt): Zweck - große Datenmengen schnell zusammenfassen, filtern und analysieren.
* NaN ('''n'''ot '''a''' '''n'''umber): In einem Datensatz fehlt ein Wert oder ist nicht definiert.
* groupby-Funktion: Daten strukturieren, aggregieren oder Zwischensummen bilden. 
* {{W|Binning#Datenverarbeitung_und_-analyse|Binning}}: Klassenbildung.
* Mehrstufige Indizierung (Hierarchical Indexing oder MultiIndex).
* Zeitreihen (Time Series).
* MS Excel-Dateien schreiben mit dem Modul openpyxl.

Für tiefergehende und weiterführende Informationen wird auf das Buch von ''Klein: Numerisches Python; Hanser, 2023'' und [https://pandas.pydata.org/ pandas] verwiesen.

= Style Guide, flake8, pylint, Black etc. =
== Style Guide ==
Wie man schönen und richtigen Python-Code schreibt, erfahren Sie in
* [https://peps.python.org/pep-0008/ PEP 8 – Style Guide for Python Code]

== Formatter und Linter ==
Ein Modul, das prüft, ob die Richtlinien im Style Guide eingehalten wurden, ist ''flake8'':
* [https://flake8.pycqa.org/en/latest/ Flake8: Your Tool For Style Guide Enforcement]

Code formatieren kann man auch mit [https://pypi.org/project/black/ Black]. Z.B. übersetzt &lt;code&gt;black test1.py&lt;/code&gt; die Datei &lt;code&gt;test1.py&lt;/code&gt;

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)),
     (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

in 

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)), (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Die Programmausgabe ist 

 reformatted test1.py
 
 All done! ✨ 🍰 ✨
 1 file reformatted.

Der Unterschied zwischen Black und Flake8:
* Black ist ein Code-Formatter. Er formatiert Ihren Code um, sodass er im Einklang mit PEP 8 steht.
* Flake8 ist ein {{W|Lint (Programmierwerkzeug) | Code-Linter}}. Flake8 verändert Ihren Code nicht, sondern durchsucht ihn nach potenziellen Fehlern etc.

Am obigen Beispiel sieht man auch, dass flake8 und Black nicht immer einer Meinung sind. Flake8 (&lt;code&gt;flake8 test1.py&lt;/code&gt;) würde standardmäßig den mit Black formatierten Code bemängeln:

 test1.py:8:80: E501 line too long (80 &gt; 79 characters)

Diese Diskrepanz kann beseitigt werden. Da 79 Zeichen auf modernen Bildschirmen meist als zu kurz empfunden werden, ist ein Limit von 88 Zeichen (Black-Standard) oder mehr empfehlenswert. Um dies zu implementieren, erstellen Sie in Ihrem Projektverzeichnis eine &lt;code&gt;.flake8&lt;/code&gt;-Datei mit dem Inhalt

 [flake8]
 max-line-length = 88

Und schon ignoriert Flake8 dieses Problem.

Ein anderer Linter ist pylint. Der würde beim Abarbeiten des obigen Beispiels, z.B. mit &lt;code&gt;pylint test1.py&lt;/code&gt; noch eine Kleinigkeit bemängeln:

 ************* Module test1
 /home/hr/tmp/test1.py:1:0: C0114: Missing module docstring (missing-module-docstring)
 
 ------------------------------------------------------------------
 Your code has been rated at 8.57/10 (previous run: 8.57/10, +0.00)

Auch pylint muss vor der ersten Verwendung installiert werden (z.B. mittels pip, virtuelle Umgebung, YaST). Die Dokumentation zu pylint findet sich auf [https://pylint.readthedocs.io/en/latest/].

&lt;u&gt;Aufgabe:&lt;/u&gt; Fügen Sie einen &quot;module docstring&quot; in die &lt;code&gt;test1.py&lt;/code&gt;-Datei ein und testen Sie erneut mit flake8, Black und pylint. &lt;small&gt;Sehen Sie zum Thema docstrings auch [https://peps.python.org/pep-0257/#what-is-a-docstring PEP 257 – Docstring Conventions].&lt;/small&gt;

Es gibt noch weitere Formatierungswerkzeuge für Python-Code. Z.B. [https://docs.astral.sh/ruff/ Ruff], ein moderner Code-Formatter und -Linter. Mittels &lt;code&gt;ruff check test1.py&lt;/code&gt; würde obiger Code geprüft (Linter). &lt;code&gt;ruff format test1.py&lt;/code&gt; formatiert den Code (Formatter).

== Type Checker ==
&quot;Type Checker&quot; sind z.B.
* mypy
* pyright
* ty

Diese prüfen die Datentypen, z.B. in folgendem Code

 def greetings(name: str) -&gt; str:
     return &quot;Hello, %s&quot; % name
 
 
 print(greetings(42))

Python selbst, flake8, ruff oder black würden diesen Code ohne zu murren akzeptieren. &quot;Type Checker&quot; würden aber sehr wohl Alarm schlagen, z.B. liefert &lt;code&gt;mypy&lt;/code&gt; folgende Ausgabe

 test1.py:5: error: Argument 1 to &quot;greetings&quot; has incompatible type &quot;int&quot;; expected &quot;str&quot;  [arg-type]
 Found 1 error in 1 file (checked 1 source file)

Das funktioniert übrigens nicht nur bei Funktionsannotationen, sondern auch mit Variablen etc.

 from typing import Final
 
 # &quot;Konstante&quot;, ab Python 3.8
 NUMBER: Final = 123
 print(NUMBER)
 NUMBER = 125
 print(NUMBER)
 
 # Variable
 a: int = 345
 print(a)
 a = &quot;Irgendwas&quot;
 print(a)
 
 # Variable (Pipe-Symbol), ab Python 3.10
 b : int|str = 567
 print(b)
 b = &quot;sonstiges&quot;
 print(b)

Ausgabe mit python:
 123
 125
 345
 Irgendwas
 567
 sonstiges

Ausgabe mit mypy:
 test3.py:6: error: Cannot assign to final name &quot;NUMBER&quot;  [misc]
 test3.py:12: error: Incompatible types in assignment (expression has type &quot;str&quot;, variable has type &quot;int&quot;)  [assignment]
 Found 2 errors in 1 file (checked 1 source file)

Python kennt übrigens keine Konstanten. Man kann diese mittels Großbuchstaben andeuten. Das ist aber nur Konvention, hat aber keine sonstigen Auswirkungen. Oder man verwendet wie oben gezeigt &lt;code&gt;Final&lt;/code&gt;. Dann werfen Typchecker Errors aus.

==pydoc==
pydoc ist ein Werkzeug, um Python-Module, -Funktionen und -Klassen zu dokumentieren.

Beispiel &lt;code&gt;test1.py&lt;/code&gt;:
 &quot;&quot;&quot;Rechen-Modul.
 
 Funktionen die von pydoc gelesen werden.
 &quot;&quot;&quot;
 
 def multiply(a, b):
     &quot;&quot;&quot;Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
     
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a * b
     
 def add(a, b):
     &quot;&quot;&quot;Addiert zwei Zahlen und gibt das Ergebnis zurück.
    
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a + b
    
 
 if __name__ == '__main__':
     print(multiply(3, 5))
     print(add(4, 6))

Ausgabe mit &lt;code&gt;python3.13 -m pydoc test1&lt;/code&gt; auf der Konsole:

 Help on module test1:
 
 NAME
     test1 - Rechen-Modul. 
 
 DESCRIPTION
     Funktionen die von pydoc gelesen werden.
 
 FUNCTIONS
     add(a, b)
         Addiert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
     multiply(a, b)
         Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
 FILE
     /home/xyz/tmp/test1.py

Siehe zu diesem Thema z.B. auch [https://docs.python.org/3/library/pydoc.html]. Mittels &lt;code&gt;python3.13 -m pydoc -w test1&lt;/code&gt; kann man auch eine HTML-Dokumentation erstellen.

Wofür &lt;code&gt;if __name__ == '__main__':&lt;/code&gt; steht, siehe z.B. etwas später im Abschnitt [[Ing_Mathematik:_Python#Doctests]].

== Sonstige Tools ==
Andere Tools für die {{W|Statische Code-Analyse|statische Codeanalyse}}, die aber für Ingenieure weniger interessant sein dürften, sind z.B.
* Radon: Liefert verschiedene {{W|Softwaremetrik|Codemetriken}} (Komplexität, Wartbarkeitsindex ...)
* Bandit: Findet Sicherheitslücken

Tools für die {{W|Dynamisches Software-Testverfahren|dynamische Codeanalyse}}, z.B.:
* DynaPyt (Framework zur dynamischen Programmanalyse)
* cProfile (Profiler)
* Memory Profiler (Speicheranalyse)
* Memray (Speicheranalyse)
* tracemalloc (Speicheranalyse)

Paket- und Projektmanagement (pip-Ersatz etc.):
* uv
* Poetry
* Conda
* pipx

Packaging-Tools (Freezer) und {{W|Compiler#Sonderformen|Transpiler}} :
* pyinstaller
** erstellt eigenständige, ausführbare Binärdatei
** kein Cross-Compiler
** kein Schutz vor Reverse-Engineering
** langsam
** packt alles in eine Datei
** sehr große Datei
** Befehl, z.B.: &lt;code&gt;pyinstaller --onefile test1.py&lt;/code&gt;
** GUI: &lt;code&gt;auto-py-to-exe&lt;/code&gt;
* cx_Freeze
* nuitka
** Übersetzt Python-Code in C/C++-Code und weiter in eine ausführbare Datei
** kein Cross-Compiler
** Schutz vor Reverse-Engineering
** Befehl, z.B.: &lt;code&gt;nuitka --standalone --onefile test1.py&lt;/code&gt;
* cython

= Einige Integrierte Entwicklungsumgebungen (IDEs)=
Werden Programmtexte größer und umfangreicher, so ist das Arbeiten mit der interaktiven Programmierumgebung bzw. das direkte Ausführen von Python-Skripten mühsam. Man wünscht sich z.B. Hilfen zum Debuggen oder die automatische Code-Vervollständigung. Zu diesem Zweck wurden IDEs (Integrated Development Environments) geschaffen. Von diesen seinen nachfolgend auszugsweise einige kurz beschrieben. Testen Sie einfach aus, welche davon für Sie bzw. für Ihr Python-Projekt geeignet sind.

== IDLE ==
IDLE ist die mit dem Python-Programmpaket mitgelieferte IDE. Der Name leitet sich einerseits ab vom Monty-Python-Mitglied Eric Idle, andererseits steht es als Abkürzung für &quot;'''I'''ntegrated '''D'''evelopment and '''L'''earning '''E'''nvironment. IDLE ist einfach zu bedienen, bietet aber schon einen beachtlichen Leistungsumfang. Nachfolgend wird ein Screenshot zu IDLE geliefert. Rechts ist das Editor-Fenster zu sehen, links die interaktive Programmierumgebung. Um das Beispiel selbst nachvollziehen zu können, starten Sie IDLE. Das geht ähnlich, wie Sie die interaktive Programmierumgebung von Python starten (nur, dass Sie eben das IDLE-Icon doppelklicken und nicht das Python-Icon. Unter Linux geben Sie einfach in einem Terminal &lt;code&gt;idle3.13&lt;/code&gt; o. Ä. ein). Weiter geht es mit &quot;File - Open - ...&quot;. Die auszuführende Datei auswählen (im konkreten Fall ein &quot;Hallo-Welt&quot;-Programm). Es erscheint das rechte Fenster. Dort &quot;Run - Run Module&quot; auswählen. Und schon wird im linken Fenster &quot;Hallo Welt!&quot; ausgegeben.

[[Datei:PythonIng_idle1.jpg | 600px]]

Siehe auch {{W|IDLE}}.

== PyCharm ==
PyCharm ist ein kommerzielles Produkt. Es gab aber auch eine kostenlose Community Edition. Seit 2025 sind beide Varianten vereint. Für die ersten 30 Tage sind die Pro-Funktionen frei verfügbar, danach nur noch die Kernfunktionalitäten (oder man bezieht kostenpflichtig  die Pro-Version). Zu beziehen ist PyCharm unter dem Weblink [https://www.jetbrains.com/pycharm/]. Nachfolgend ein etwas abgewandeltes &quot;Hallo Welt&quot;-Programm, editiert und ausgeführt mit PyCharm.

[[Datei:PyCharm_IDE_2023_screenshot.png | 600px]]

Siehe auch {{W|PyCharm}}.

== Eric ==
Auch eric ist Open Source und steht unter der  GNU General Public License Version 3 oder später. Zu beziehen ist diese Software unter [https://eric-ide.python-projects.org/].

[[Datei:Screenshot_Eric_4.png | 600px]]

Siehe auch {{W|eric (Software)}}.

&lt;small&gt;
Unter openSUSE Tumbleweed sollte sich eric auch mit YaST installieren lassen. Bei mir gibt es aber dann beim Ausführen des eric-Programms eine Fehlermeldung (Stand März 2026): 
 
 ...
 ModuleNotFoundError: No module named 'PyQt6.QtPdfWidgets'

Umgehen kann man dieses Problem aber wieder mit dem Erstellen einer virtuellen Umgebung, in etwa so

 python3.13 -m venv ~/tmp/venv1
 cd ~/tmp/venv1/bin
 ./python3.13 -m pip install --upgrade --prefer-binary eric-ide
 ./eric7_ide
&lt;/small&gt;

== PyScripter ==
Vom Funktionsumfang vergleichbar mit den vorherigen IDEs ist PyScripter. Auch PyScripter ist Open Source. Die Projekt-Homepage findet sich auf [https://sourceforge.net/projects/pyscripter/]. PyScripter ist nur für MS Windows verfügbar.

[[Datei:PythonIng_pyscripter1.jpg | 600px]]

== Spyder IDE ==
Spyder enthält bereits eine stabile Python-Version und etliche Module (z.B. matplotlib, numpy, control). Ansonsten kann dieses Softwarepaket vom Funktionsumfang her mit den anderen genannten IDEs locker mithalten. Spyder wurde unter der MIT-Lizenz veröffentlicht. Diese Software findet sich auf [https://www.spyder-ide.org].

[[Datei:Spyder-windows-screenshot.png | 600px]]

Siehe auch {{W|Spyder (Software)}}

== Eclipse IDE==
Die {{W|Eclipse_(IDE)|Eclipse-IDE}} kann für Python aufgerüstet werden. Dazu gibt es das PyDev-Plugin. Installiert wird es über 
* Help &gt; Eclipse Marketplace... 
* Find - PyDev - Install
Danach muss noch der Pfad zum Python-Interpreter festgelegt werden 
* Window &gt; Preferences &gt; PyDev &gt; Interpreters &gt; Python Interpreter &gt; New ... 
Das Ergebnis ist ähnlich wie im folgenden Bild, nur dass statt C/C++ Python Verwendung findet. 

[[Datei:Setting Up Eclipse CDT helloout.png | 600px]]

== Sonstige ==
Die genannten IDEs sind nicht die Einzigen. Es gibt, um dem Image Pythons als beliebteste Programmiersprache gerecht zu werden, noch einige andere. Sowohl Open Source-Programme als auch kommerzielle Programme sind im Web zu finden, z.B. Thonny oder {{W|Visual Studio Code}}. Unter Linux kann man auch {{W|KDevelop}}, ausgestattet mit dem Python3-Plugin, einsetzen. Braucht man den Umfang von ausgewachsenen IDEs nicht, so kann man auch normale Texteditoren verwenden (z.B. {{W|Geany}} oder {{W|Kate_(Texteditor)|Kate}}).

= Debuggen und Testen =
Das Debuggen und Testen von Programmen sind wichtige Bestandteile der Programmierung. Syntaxfehler lassen sich i.A. leicht beheben. Schwieriger ist das Eingrenzen von logischen Fehlern, die ev. nur in bestimmten Situationen auftreten und keine explizite Fehlermeldung hervorrufen. Das Programm liefert falsche Ergebnisse oder es stürzt aus heiterem Himmel ab. Um das zu verhindern gibt es verschiedene Werkzeuge, die bei der Fehlersuche behilflich sein können. Vorerst siehe aber zwecks Begriffsklärung noch folgende Links: 
 
* {{W|Debuggen}}
* {{W|Debugger}}
* {{W|Softwaretest}}

&lt;gallery&gt;
First Computer Bug, 1947.jpg
Test ganzheitlich.png
V-Modell.svg
&lt;/gallery&gt;

== Das Modul pdb ==
Python bringt schon ein Modul zum Debuggen mit. Siehe z.B. [https://docs.python.org/3/library/pdb.html pdb — The Python Debugger].
Komfortabler lässt sich das aber mittels Integrierter Entwicklungsumgebungen (IDEs) angehen.

== Debuggen mit IDEs ==
Für die IDEs IDLE und Spyder sei kurz auf die entsprechenden Webseiten verwiesen:

* [https://www.cs.uky.edu/~keen/help/debug-tutorial/debug.html Debugging under IDLE].
* [https://docs.spyder-ide.org/current/panes/debugging.html Spyder Debugger]

Dort wird die Vorgehensweise auch mittels Screenshots erläutert.

== assert ==
assert ... behaupten, zusichern ({{W|Assertion (Informatik)}})

Python-Code:
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10., 0.)

Ausgabe:

 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10., 0.)
   File &quot;/home/hr/Develop/test1.py&quot;, line 4, in print1
     assert y != 0.0
            ^^^^^^^^
 AssertionError
 
Python-Code: 
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)
 
Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(&quot;10.&quot;, &quot;5.&quot;)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError
 
Aber auch bei nachfolgendem Code gibt es eine Fehlermeldung:

 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10, 5)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError

Damit letzteres funktioniert, kann man den Programmcode so umschreiben:
 def print1(x, y):
     assert type(x) == float or type(x) == int
     assert type(y) == float or type(y) == int
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 2.0
 
Und jetzt fangen wir den &lt;code&gt;AssertionError&lt;/code&gt; auf:
 def print1(x, y):
     try:
         assert type(x) == float or type(x) == int
         assert type(y) == float or type(y) == int
         assert y != 0.0
         print(x/y)
     except(AssertionError):
         print(&quot;Hallo&quot;)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)

Ausgabe:
 2.0
 Hallo

Ich hoffe, es ist wenigstens im Ansatz klar geworden, wofür &lt;code&gt;assert&lt;/code&gt; gut sein kann. Ausschalten kann man die &lt;code&gt;assert&lt;/code&gt;-Überprüfung übrigens mit dem Python-Schalter &lt;code&gt;-O&lt;/code&gt;.

== Doctests == 
Innerhalb eines Docstrings kann die Arbeit im interaktiven Modus simuliert werden. Nach den Promptzeichen (&gt;&gt;&gt;) erfolgen dann bei unserem Beispiel innerhalb des Docstrings simulierte Aufrufe der Funktion &lt;code&gt;print1()&lt;/code&gt;. Danach folgen jeweils die Sollresultate. Wird das Modul oder die Datei als Hauptprogramm aufgerufen, so wird die Funktion &lt;code&gt;doctest.testmode()&lt;/code&gt; aufgerufen und ein Bericht auf der Konsole ausgegeben. Wird das Modul nicht als Hauptprogramm aufgerufen, sondern importiert, dann wird diese &lt;code&gt;testmod&lt;/code&gt;-Funktion nicht aufgerufen. D.h. dieser Code kann sowohl für Testzwecke als auch für den produktiven Einsatz verwendet werden. Das ist auch sinnvoll, weil wenn man Teile der Datei immer löschen bzw. einfügen müsste, so würden sich Fehlerquellen auftun. Das würde den Sinn und Zweck von Doctests konterkarieren.  

 def print1(x=0., y=1.):
     &quot;&quot;&quot; Dividiere zwei Zahlen
     Autor: Intruder
     Datum: 12.08.2025
 
     &gt;&gt;&gt; print1(2., 1.)
     2.0
     &gt;&gt;&gt; print1(5., 2.)
     2.5
     &gt;&gt;&gt; print1(5.)
     5.0
     &quot;&quot;&quot;
     print(x/y)
 
 if __name__ == &quot;__main__&quot;:
     import doctest
     doctest.testmod(verbose=True)

Ausgabe:
 Trying:
     print1(2., 1.)
 Expecting:
     2.0
 ok
 Trying:
     print1(5., 2)
 Expecting:
     2.5
 ok
 Trying:
     print1(5.)
 Expecting:
     5.0
 ok
 1 items had no tests:
     __main__
 1 items passed all tests:
    3 tests in __main__.print1
 3 tests in 2 items.
 3 passed and 0 failed.
 Test passed.

Das gezeigte Beispiel ist so ziemlich das einfachste, das es gibt. Für weiterführende Details siehe z.B.:
* [https://peps.python.org/pep-0257/ PEP 257 – Docstring Conventions]
* [https://docs.python.org/3/library/doctest.html doctest — Test interactive Python examples]

''Einschub:'' Ganz ähnlich kann man auch Klassen testen, z.B. in folgendem Code-Fragment

 class Fahrzeug:
   # siehe Abschnitt &quot;Objektorientierte Programmierung&quot;
   # ...
 
 if __name__ == &quot;__main__&quot;:
   vauweh = Fahrzeug(170, 90)
   beemweh = Fahrzeug(200, 120)
   print(vauweh.convertGeschw())
   print(beemweh.convertGeschw())

Wird das Script als Hauptprogramm ausgeführt (z.B. zu Testzwecken), so erfolgt die Ausgabe der zwei, via &lt;code&gt;convertGeschw()&lt;/code&gt;, umgerechneten Geschwindigkeiten. Wird es aber als Modul eingebunden, so wird der letzte Programmabschnitt nicht ausgeführt (&lt;code&gt;__name__ == &quot;__main__&quot;&lt;/code&gt; ergibt &lt;code&gt;False&lt;/code&gt;).

== pytest ==
Siehe zu diesem Thema auch {{W|Modultest}}.

pytest ist ein externes Modul und muss vorab installiert werden, z.B. mittels 
 pip install -U pytest
 pip install -U pytest-html 

Python-Code, Datei test1.py:
 def add(x, y):
     return x + y
 
 def test_answer():
     assert add(1, 1) == 3

Starten von pytest in der Konsole:
 pytest test1.py
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py F                                                                                                            [100%]
 
 ========================================================= FAILURES ==========================================================
 ________________________________________________________ test_answer ________________________________________________________
 
     def test_answer():
 &gt;       assert add(1, 1) == 3
 E       assert 2 == 3
 E        +  where 2 = add(1, 1)
 
 test1.py:6: AssertionError
 ================================================== short test summary info ==================================================
 FAILED test1.py::test_answer - assert 2 == 3
 ===================================================== 1 failed in 0.09s =====================================================

Hier erhalten wir einen Fehler, da 1+1 eindeutig ungleich 3 ist. Aber aus irgendeinem Grund wollte der Programmierer oder Tester in diesem Fall, dass dies so ist. Testfälle werden übrigens mit dem Präfix &lt;code&gt;test_&lt;/code&gt; eingeleitet.

Python-Code:
 def add(x, y):
     return x + y + 1
 
 def test_answer():
     assert add(1, 1) == 3 
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py .                                                                                                            [100%]
 
 ===================================================== 1 passed in 0.01s =====================================================

Jetzt ist alles in Ordnung. Weiterführendes siehe z.B.

* [https://docs.pytest.org/en/stable/ pytest: helps you write better programs]

== unittest ==
Auch unittest dient zur Durchführung von Testreihen, ist aber Bestandteil von Python. Hier wird vorerst nicht näher darauf eingegangen. Siehe z.B. 
* [https://docs.python.org/3/library/unittest.html unittest — Unit testing framework]

Lt. ''Inden: Python Challenge; dpunkt, 2021, Seite 481''  soll unittest weniger komfortabel als pytest sein.

Einen Vergleich von unittest mit pytest findet man in
* [https://knapsackpro.com/testing_frameworks/difference_between/pytest/vs/unittest pytest vs unittest]

= Python und Anwendungsprogramme =
Bisher stand immer alleine die Programmiersprache Python (ev. unter Einbeziehung von Modulen) im Mittelpunkt der Betrachtungen. Aber Python kann auch als Makrosprache für Anwendungsprogramme auftreten. Als Beispiele seien {{W|FreeCAD}} und {{W|LibreOffice}} genannt.

== FreeCAD ==
FreeCAD ist ein freies 3D-CAD-Programm. Hier soll nicht auf die Bedienung dieses CAD-Pakets eingegangen werden, sondern nur auf die Möglichkeit, mittels Python Makros zu schreiben. Als einfacher Einstieg soll ein Makro erstellt werden, welches eine Kugel (rot) und einen Quader (blau) zeichnet. Folgende Vorbereitungsschritte sind erforderlich (es sei vorausgesetzt, dass FreeCAD schon am Rechner installiert ist. Downloaden können Sie das Programm von der Website [https://www.freecad.org/downloads.php?lang=en]):

* FreeCAD starten
* Leere Datei erstellen
* Makro &gt; Makros &gt; Erstellen ...

Es öffnet sich ein leeres Editorfenster, in das Sie folgenden Code eingeben können:

 import FreeCAD
 import Part
 
 doc = FreeCAD.newDocument()
 
 # Kugel
 kugel = Part.makeSphere(10)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Kugel&quot;)
 form_element.Shape = kugel
 kug = FreeCAD.ActiveDocument.getObject(&quot;Kugel&quot;)
 kug.ViewObject.ShapeColor = (1.0, 0.0, 0.0)
 neuePosition = App.Vector(5, 2.5, 2.5)
 kug.Placement = App.Placement(neuePosition, kug.Placement.Rotation)
 
 # Quader
 quader = Part.makeBox(5, 5, 50)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Quader&quot;)
 form_element.Shape = quader
 quad = FreeCAD.ActiveDocument.getObject(&quot;Quader&quot;)
 quad.ViewObject.ShapeColor = (0.0, 0.0, 1.0)
 
 doc.recompute()

Diesen Code können Sie nun ausführen:
* Makro &gt; Makro ausführen

Es ergibt sich folgende Ausgabe (gedreht und gezoomt):

[[Datei: PythonIng_freecad1.png|500px]]

Siehe auch [https://wiki.freecad.org/Python_scripting_tutorial/de# Anleitung Skripterstellung mit Python]. Getestet wurde obiges Beispiel mit FreeCAD 1.1.3 unter Linux und 1.1.1 unter MS Windows.

== LibreOffice ==
LibreOffice ist ein freies Officepaket ([https://de.libreoffice.org/]). Hier soll nur das Tabellenkalkulationsprogramm Calc kurz betrachtet werden. Es seinen in den ersten 3 Zellen (A1 bis A3) Zahlen gegeben. Diese sollen mit einem Python-Makro addiert und das Resultat in der Zelle A5 ausgegeben werden. Auch hier sind Vorbereitungsarbeiten nötig: 
* zuerst muss unter Linux das Verzeichnis &lt;code&gt;~/.config/libreoffice/4/user/Scripts/python&lt;/code&gt; erstellt werden
* für MS Windows ist es das Verzeichnis &lt;code&gt;%APPDATA%\LibreOffice\4\user\Scripts\python&lt;/code&gt; 
** drücken Sie zuerst Win + R (es öffnet sich das Ausführen-Fenster)
** geben Sie &lt;code&gt;%appdata%&lt;/code&gt; ein, danach drücken Sie Enter (es öffnet sich der Explorer)
** navigieren Sie zu dem genannten Verzeichnis bzw. erstellen Sie das Verzeichnis 
* in diesem Verzeichnis wird dann mit einem beliebigen Texteditor das Python-Makro erstellt, in unserem Fall die Datei &lt;code&gt;summiere_zellen.py&lt;/code&gt;:

 import uno
 
 def summiere_zellen(*args):
     # Zugriff auf das aktuelle Dokument und das aktive Tabellenblatt
     ctx = uno.getComponentContext()
     smgr = ctx.getServiceManager()
     desktop = smgr.createInstanceWithContext(&quot;com.sun.star.frame.Desktop&quot;, ctx)
     doc = desktop.getCurrentComponent()
     sheet = doc.getCurrentController().getActiveSheet()
 
     # Werte aus den Zellen A1 bis A3 auslesen
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
 
     # Addition der drei Werte
     summe = w1 + w2 + w3
 
     # Ergebnis in die Zelle A5 schreiben
     sheet.getCellRangeByName(&quot;A5&quot;).Value = summe

* siehe dazu ggf. auch [https://help.libreoffice.org/latest/de/text/sbasic/python/python_locations.html?DbPAR=BASIC].

Weiter geht es in LibreOffice Calc mit dem Menü ''Extras &gt; Makros &gt; Makros verwalten &gt; Python''. Dort wird das Makro &lt;code&gt;summiere_zellen&lt;/code&gt; ausgeführt. Es ergibt sich z.B. folgendes Resultat

[[Datei:PythonIng_libreoffice1.png]]

Das Kürzel &lt;code&gt;uno&lt;/code&gt; steht für '''U'''niversal '''N'''etwork '''O'''bjects. Etwas einfacher geht's auch so:

 def summiere_zellen():
     desktop = XSCRIPTCONTEXT.getDesktop()
     model = desktop.getCurrentComponent()
     sheets = model.getSheets()
     sheet = sheets.getByIndex(0)
     
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
     
     cell = sheet.getCellRangeByName(&quot;A5&quot;)    
     cell.setValue(w1 + w2 + w3) 

Empfohlen wird auch, das Erweiterungspaket APSO ('''A'''lternative '''P'''ython '''S'''cript '''O'''rganizer, apso.oxt) zu installieren. Die Vorgehensweise wird hier nicht gezeigt, sondern nur darauf hingewiesen, dass man das einfach &quot;googeln&quot; kann. Siehe zur Python-Programmierung für LibreOffice auch [https://wiki.documentfoundation.org/Macros/Python_Guide/de Makros/Python-Handbuch]. Getestet wurden obige Beispiele mit LibreOffice 26.2.5.1 unter Linux und 26.2.1.2 unter MS Windows.

= Ausblick =
Dies war eine kurze Einführung in die Berechnungs- und Darstellungsmöglichkeiten mit Python. Es sollten etliche relevante Themen behandelt, oder zumindest kurz angesprochen worden sein. Wem dieser Text nicht ausreichend ist, der sei auf die entsprechenden weiterführenden Weblinks, Bücher und die Python-Hilfefunktion verwiesen. Python kennt noch viel mehr Befehle, als hier dargestellt wurden. Das Themenspektrum ist auch durch die Einbindung externer Module fast beliebig erweiterbar.

= Weblinks=
== Python allgemein ==
* [https://www.python.org/ Python Homepage]

== Externe mathematische Module ==
* [https://numpy.org/ NumPy]
* [https://numpy.org/doc/stable/user/numpy-for-matlab-users.html NumPy for MATLAB users]
* [https://scipy.org/ SciPy]
* [https://www.sympy.org/en/index.html SymPy]
* [https://pandas.pydata.org/ pandas]
* [https://github.com/maroba/findiff findiff]
* [https://mpmath.org/ mpmath]

== Externe Module für Grafiken ==
* [https://matplotlib.org/ Matplotlib]
* [https://vpython.org/ VPython]
* [https://build123d.readthedocs.io/en/latest/ build123d]
* [https://docs.vtk.org/en/latest/api/python.html VTK]
* [https://docs.bokeh.org/en/latest/docs/first_steps.html bokeh]
* [https://py5coding.org/ py5]

== Erstellung von User Interfaces ==
* [https://docs.python.org/3/library/tkinter.html tkinter - Python interface to Tcl/Tk]
* [https://docs.python.org/3/library/curses.html curses - Terminal handling for character-cell displays]
* [https://wiki.qt.io/Qt_for_Python Qt for Python]
* [https://www.gtk.org/docs/language-bindings/python GTK and Python]

== Erstellen virtueller Umgebungen ==
* [https://docs.python.org/3/library/venv.html venv - Creation of virtual environments]

== Sonstige ==
* [https://python-control.readthedocs.io/en/stable/ Python Control Systems Library]
* [https://pypi.org/project/regex/ regex - Regular Expressions]
* [http://pyromat.org/ PYroMat]
* [https://coolprop.org/coolprop/wrappers/Python/index.html CoolProp]
* [https://pypi.org/project/iapws/ iapws]
* [https://tespy.readthedocs.io/en/main/getting_started/introduction.html TESPy - Thermal Engineering Systems in Python]
* [https://pint.readthedocs.io/en/stable/ pint]

= Bücher =
== Gedruckte Bücher, OpenBooks, Magazine ==
* Diverse: c't Python Lernen, Verstehen, Anwenden; Heise, 2022 
* Ernesti, Kaiser: Python3 - das umfassende Handbuch; 5. Aufl., Rheinwerk, [https://openbook.rheinwerk-verlag.de/python/ OpenBook]
* Iacono et al.: Programmieren trainieren; 3. Aufl., Hanser, 2023, ISBN 978-3-446-47766-7
* Inden: Python Challenge; dpunkt, 2021, ISBN 978-3-86490-809-5
* Klein: Numerisches Python; 2. Aufl., Hanser, 2023, ISBN 978-3-446-47170-2 
* Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler; Rheinwerk, 2021, ISBN 978-3-8362-7316-9
* Weigend: Python 3 - Das umfassende Praxisbuch; 9. Aufl., mitp, 2022, ISBN 978-3-7475-0544-1
* Woyand: Python für Ingenieure und Naturwissenschaftler; 4. Aufl., Hanser, 2021, ISBN 978-3-446-46483-4

== Andere Wikibooks ==
* [[:en:Subject:Python_programming_language | Englische Wikibooks zum Thema Python]]
* [[Python|Deutschsprachiges Python-Wikibook]] [[Bild:2von10.png|20%]]
* [[Python unter Linux|Python 2.7 unter Linux]] [[Bild:10von10.png|100%]]


{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}</text>
      <sha1>0h80c5p2guoqgpzewvvkdjpwdy64qdf</sha1>
    </revision>
    <revision>
      <id>1092182</id>
      <parentid>1092178</parentid>
      <timestamp>2026-10-17T10:15:51Z</timestamp>
      <contributor>
        <username>Intruder</username>
        <id>1513</id>
      </contributor>
      <origin>1092182</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="191475" sha1="1e4y52pi2rtveys3ow33qw8oiztzf2o" xml:space="preserve">{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}


= Hallo Welt und allgemeine Hinweise =
== Was ist Python ==
* Python ist eine universelle höhere Programmiersprache.
* Python ist objektorientiert.
* Python ist Open-Source (Python Software Foundation License).
* Python ist für viele Betriebssysteme erhältlich (z.B. für Linux, MS Windows, macOS).
* Python ist ein Interpreter.
* Python ist durch Module fast beliebig erweiterbar.
* Python als Programmiersprache ist case-sensitive - d.h. Groß- und Kleinschreibung ist relevant bei der Eingabe von Befehlen.
* Python ist in etlichen Anwendungsprogrammen (z.B. {{W|FreeCAD}}, {{W|LibreOffice}}, {{W|GIMP}}, {{W|Blender (Software) | Blender}}) als Makrosprache verwendbar.

{{Wikipedia | Python (Programmiersprache)}}

== Python installieren ==
=== MS Windows ===
Laden Sie das aktuelle Python-Paket von der Webseite [https://www.python.org/] herunter. Weiter geht es wie bei jedem anderen größeren zu installierenden Programm. Einfach das Installationsprogramm im Explorer doppelklicken und den Anweisungen des Setup-Programmes folgen.

=== Linux ===
Entweder ist Python bereits standardmäßig installiert, ansonsten ist die Installation mittels Paketmanagementsystem einfach möglich. Aber auch die Spyder-Entwicklungsumgebung ([https://www.spyder-ide.org]) bietet einen guten Einstieg mit Python (das gilt auch für MS Windows). Spyder bringt auch schon etliche wichtige Module standardmäßig mit.

== Python starten ==
=== MS Windows ===
Das Icon für das Python-Programm doppelklicken. Und schon startet das Programm.

[[Datei:PythonIng_start1.jpg]]

Python im interaktiven Modus (REPL ... '''R'''ead-'''E'''valuate-'''P'''rint-'''L'''oop) präsentiert sich dann so:

 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

Alternativ kann das Programm auch über die Eingabeaufforderung oder die PowerShell gestartet werden:

 c:\devel\Python&gt;python.exe
 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

=== Linux ===
Tippen Sie einfach das Wort „python“ (oder unter openSUSE Tumbleweed z.B. auch „python3.11“ oder „python3.13“) in einem Linux-Terminal ein, schließen den Befehl mit der RETURN-Taste ab, und schon startet Python im interaktiven Modus:
 
 Python 3.13.12 (main, Feb 09 2026, 22:37:44) [GCC] on linux
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt; 

Es gibt auch noch andere Möglichkeiten Python zwecks Programmausführung zu starten, z.&amp;nbsp;B. den {{W|Shebang}} (&lt;code&gt;#!&lt;/code&gt;) am Beginn eines Python-Scripts. Das Script sei als Script.py gespeichert. Dann kann das Script mit ./Script.py ausgeführt werden. Für openSUSE Tumbleweed sei nachfolgend ein lauffähiges &quot;Hallo Welt!&quot;-Script angegeben. Es wird in diesem Script der Python-Interpreter in der Version 3.13 verwendet :

 #!/usr/bin/python3.13
 print(&quot;Hallo Welt!&quot;)

Die Berechtigungen zum Ausführen der Datei müssen natürlich noch richtig gesetzt werden, z.B. mittels &lt;code&gt;chmod 777 Script.py&lt;/code&gt;. &lt;small&gt;&lt;code&gt;chmod&lt;/code&gt; ist die Abkürzung für&quot;'''ch'''ange file '''mod'''e bits&quot;.&lt;/small&gt; 

&lt;small&gt;Die &quot;Maske&quot; &lt;code&gt;777&lt;/code&gt; ist nur für Testzwecke sinnvoll, weil sie leicht zu merken ist und für alle Benutzer alle Zugriffsberechtigungen ('''r'''ead/'''w'''rite/e'''x'''ecute für owner/group/others) setzt. Im richtigen Einsatz wird man das aus Sicherheitsgründen nicht so handhaben, sondern nur die Berechtigungen setzen, die unbedingt erforderlich sind. Welche Zugriffsberechtigungen gesetzt sind, kann man z.B. mit dem Befehl &lt;code&gt;ls -l&lt;/code&gt; oder &lt;code&gt;ll&lt;/code&gt; ('''l'''i'''s'''t directory contents) erfragen. Aber dazu im Moment genug. Erfahrene Linux-Nutzer kennen das ohnehin und Anfänger sollen jetzt nicht mit Linux-Interna überfordert werden. Bei Bedarf siehe die Linux-Man-Pages oder dezidierte Bücher zu Linux.&lt;/code&gt;&lt;/small&gt;

&lt;small&gt;Oder das Script wird in einen Pfad verschoben, in dem sich ausführbare Programme generell befinden (welche Verzeichnisse im PATH liegen, kann bspw. mit &lt;code&gt;echo $PATH&lt;/code&gt; abgefragt werden). Das Script kann dann wie ein normales Programm ohne weitere Angaben mit Script.py gestartet werden. Alternativ wird nicht das Script an sich verschoben, sondern nur ein symbolischer Link angelegt, z.B. mit &lt;code&gt;ln -s ~/tmp/Script.py ~/.local/bin/Script.py&lt;/code&gt;. &lt;code&gt;~/.local/bin&lt;/code&gt; sei ein im PATH gelegenes Verzeichnis. Dies sind aber schon Features für fortgeschrittene Linux-Benutzer und werden am Anfang eher selten benötigt.&lt;/small&gt;

== Ein paar Worte zur Erklärung ==
=== Tests ===
Getestet wurden die Beispiele unter den Betriebssystemen 
* MS Windows 10 mit der Python-Version 3.12.0 (teilweise auch mit 3.12.2 und 3.13.1; nur die Inhalte die bis spätestens Juli 2025 erstellt wurden) 
* MS Windows 11 ab der Python-Version 3.13.4 (nur zum Teil; ab Juli 2025)
* openSUSE Leap 15.6 mit der Python-Version 3.11.12 (Spyder, nur vereinzelt) und zum Teil mit 3.12.11 (ab Juli 2025 bis November 2025).
* openSUSE Tumbleweed ab der Python-Version 3.13.9 (nur vereinzelt, ab November 2025)

=== Popularität ===
* An Beliebtheit rangiert Python mit Stand September 2026 mit einem Rating von 17,76% an 1. Stelle vor C und C++ (lt. [https://www.tiobe.com/tiobe-index/ TPCI - TIOBE Programming Community Index]). 
* Lt. [https://innovationgraph.github.com/global-metrics/programming-languages GitHub Top 50 Programming Languages Globally] lag Python im Q1/2026 auf Rang 2, vor TypeScript und hinter JavaScript. 
* [https://pypl.github.io/PYPL.html PYPL] (Popularity of Programming Language Index) ist ein anderer Popularitätsindex für Programmiersprachen. Auch hier liegt Python mit großem Vorsprung auf dem ersten Platz (52,08%), gefolgt von Java (13,34%) und C/C++ (7,99%) (Stand September 2026). 

=== Namensgebung ===
Der Name &quot;Python&quot; rührt von der Komikertruppe {{W|Monty Python}} her. Die Icons für Python (z.B. Python selbst, Eric IDE, IDLE) sind aber durch die Python-Schlangenart symbolisiert.

&lt;gallery&gt;
Python-logo-notext.svg|Python-Logo
Guido van Rossum in PyConUS24.jpg|{{W|Guido van Rossum}} (geb. 1956), der Erfinder von Python
&lt;/gallery&gt;

== Ein erstes Programm ==
Kommentare werden in Python mit der Raute (#) eingeleitet. Sie werden vom Python-Interpreter ignoriert. Text kann mit der print-Funktion ausgegeben werden. Starten Sie Python und geben sie folgende Anweisungen zeilenweise ein

 &gt;&gt;&gt; # Das ist ein Kommentar
 &gt;&gt;&gt; print(&quot;Hallo Welt!&quot;)

Als Ergebnis erhalten Sie

 Hallo Welt!

Der Prompt (&gt;&gt;&gt;) ist selbstverständlich nicht einzutippen, sondern wird vom Python-System geliefert.

Strings können in Python entweder in Anführungszeichen (&quot;) gesetzt werden oder in Hochkommatas('). In diesem Text wird die erste Variante bevorzugt eingesetzt.

Im Gegensatz zu Julia ist es hier egal, ob zwischen &lt;code&gt;print&lt;/code&gt; und der öffnenden Klammer Leerzeichen stehen.

= Python als Taschenrechner =
== Allgemeines ==
Wir wollen 3 * 5 berechnen. Dazu starten wir Python im interaktiven Modus. Geben Sie dann die Formel  

 &gt;&gt;&gt; 3 * 5

ein, drücken die Taste ENTER/RETURN ({{Taste|↵}}) und erhalten als Ergebnis

 15

Auch kompliziertere Ausdrücke sind möglich. Beispielsweise mit Winkelfunktionen, Quadratwurzeln etc. Wir wollen nun den Ausdruck &lt;math&gt;\sin\sqrt{15}&lt;/math&gt; berechnen :

 &gt;&gt;&gt; import math
 &gt;&gt;&gt; math.sin(math.sqrt(15))
 -0.6679052983383519

Als erstes wird das math-Modul importiert. Dann wird der mathematische Ausdruck berechnet.

Eine andere Variante, die dasselbe Ergebnis liefert, ist

 &gt;&gt;&gt; from math import *
 &gt;&gt;&gt; sin(sqrt(15))
 -0.6679052983383519

Es wird also aus dem Modul &lt;code&gt;math&lt;/code&gt; alles importiert (erkennbar am &lt;code&gt;*&lt;/code&gt;). Will man nicht alles importieren, so kann man das auch einschränken:

 &gt;&gt;&gt; from math import sin, sqrt

Beenden lässt sich das Python-Programm durch Eingabe von &lt;code&gt;exit()&lt;/code&gt; (und natürlich ist zur Bestätigung die RETURN-Taste zu drücken). &lt;code&gt;exit&lt;/code&gt; (ohne Klammern) oder &lt;code&gt;quit&lt;/code&gt; werden auch akzeptiert.

== Die Hilfefunktion von Python ==
Bei Eingabe der Anweisung &lt;code&gt;help&lt;/code&gt; oder &lt;code&gt;help()&lt;/code&gt; springt Python in den Hilfemodus. 

Eingabe:
 &gt;&gt;&gt; help()
 
Eingabe:
 help&gt; math.sin

Ausgabe:
 Help on built-in function sin in math:
 
 math.sin = sin(x, /)
     Return the sine of x (measured in radians).

Für die komplette Python-Dokumentation siehe [https://docs.python.org/3/]. Verlassen kann man den Hilfemodus durch das Drücken von STRG-C, bzw. der Eingabe von q, quit oder exit mit anschließendem Drücken der RETURN-Taste.

== Aufgaben ==
* Erkunden Sie die Tangensfunktion &quot;tan&quot; mittels Python-Hilfe (vergessen Sie nicht das math-Modul zu importieren und das &lt;code&gt;math.&lt;/code&gt; vor &lt;code&gt;tan&lt;/code&gt;)
* Berechnen Sie mit Python den Ausdruck &lt;math&gt;\frac{1}{2}\cdot \text{e}^2 \cdot \tan(\pi/3)&lt;/math&gt;. Siehe für die Exponentialfunktion im Python-Hilfesystem auch den Befehl &lt;code&gt;math.exp&lt;/code&gt;. Alternativ kann auch die Konstante &lt;code&gt;math.e&lt;/code&gt; eingesetzt werden. Potenzieren kann man bei Python mit dem **-Operator (z.B. 2**3 = 8). Für &lt;math&gt;\pi&lt;/math&gt; gibt es &lt;code&gt;math.pi&lt;/code&gt;.

= Python als Scriptsprache =
Häufig wird man aber kompliziertere Anweisungsfolgen verarbeiten müssen. Diese will man normalerweise nicht jedesmal neu eingeben, sondern in einer Datei speichern und diese Datei dann zur Ausführung bringen. Speichern Sie dazu folgenden Code in einer Textdatei, z.B. unter MS Windows als c:\tmp\test1.py

 # Das ist ein Kommentar
 print(&quot;Hallo Welt!&quot;)

Python-Dateien werden mit der Dateiendung .py versehen. Achten Sie darauf, dass vor dem print keine Leerzeichen vorhanden sind. Das ist eine Python-Eigenheit. Wie wir später sehen werden, nutzt Python Einrückungen als syntaktisches Mittel, z.B. um bei Schleifen den Schleifenkörper zu kennzeichnen. 

Danach bringen Sie die Skriptdatei test1.py (sozusagen das Hauptprogramm) folgendermaßen zur Ausführung:

1) Starten Sie unter MS Windows die Eingabeaufforderung (oder alternativ auch die Windows PowerShell). Das sieht dann etwa so aus:

 Microsoft Windows [Version 10.0.19045.3693]
 (c) Microsoft Corporation. Alle Rechte vorbehalten.
 
 C:\Users\xyz&gt;

: &lt;small&gt;Falls jemand nicht weiß, wie man die Eingabeaufforderung startet: Eine Möglichkeit ist, einfach in der Taskleiste von Windows das &quot;Start&quot;-Symbol &amp;nbsp;([[Image:Windows_logo_-_2021_(Black).svg|10px]])&amp;nbsp; mit der rechten Maustaste anklicken. &quot;Ausführen&quot; auswählen (oder alternativ für die PowerShell unter Windows 10 den Eintrag &quot;Windows PowerShell&quot;, unter Windows 11 den Eintrag &quot;Terminal&quot;). Im sich öffnenden Dialogfenster gibt man in die &quot;Öffnen&quot;-Zeile das Wort &lt;code&gt;cmd&lt;/code&gt; ein und mit &quot;OK&quot; wird das Ganze bestätigt.&lt;/small&gt; 
 
2) Wechseln Sie mittels &lt;code&gt;cd c:\tmp&lt;/code&gt; in das Verzeichnis c:\tmp

3) Angenommen, Sie haben Python unter dem Pfad &lt;code&gt;c:\devel\Python\&lt;/code&gt; installiert. Starten Sie das Programm so (der Prompt &lt;code&gt;c:\tmp&gt;&lt;/code&gt;ist natürlich nicht mit einzutippen): 

 c:\tmp&gt;c:\devel\Python\python.exe test1.py

4) Wie erwartet ergibt sich folgende Ausgabe am Bildschirm

 Hallo Welt!

Die Vorgehensweise unter Linux ist prinzipiell gleich. Die kleinen Unterschiede, wie z.B. der Slash statt dem Backslash in Pfadangaben, sollten für Linux-Benutzer keine Hürde darstellen.

== Variablen ==
Variablenbezeichner können aus Buchstaben (A-Za-z), Ziffern (0-9) und Underscores (_) bestehen, dürfen aber nicht mit einer Zahl beginnen. Führende Underscores haben u.a. im Kontext mit der Objektorientierten Programmierung eine spezielle Bedeutung und sollten nicht für &quot;normale&quot; Variablenbezeichner verwendet werden.

Gültige Variablenbezeichner wären also:
 xyz
 x1
 _wert
 name_anzahl

Theoretisch kann man auch Umlaute, griechische Buchstaben u.ä. in Variablenbezeichnern nutzen, z.B.

 ößÜ = 16
 α = 134 
 print(ößÜ)
 print(α)

Ausgabe:
 16
 134

Davon wird aber aus offensichtlichen Gründen ({{W|Englisch als Lingua franca}}) abgeraten. Das Eurozeichen (€) etc. darf man ohnehin nicht in Variablenbezeichnern verwenden, dies ergäbe einen Syntaxfehler. Siehe dazu auch [https://peps.python.org/pep-3131/].

Es gibt in Python etliche Schlüsselwörter (z.B. for, if oder return). Diese dürfen nicht als eigene Variablenbezeichner verwendet werden. Eine Liste aller Schlüsselwörter liefert das Script

 import keyword
 print(keyword.kwlist)

&lt;small&gt;Übung: Speichern Sie dieses Script in eine Datei, z.B. in c:\tmp\test1.py. Führen Sie diese Datei aus, um die Liste der Schlüsselwörter auszugeben.&lt;/small&gt;

Da Python case-sensitiv ist, repräsentieren folgende Bezeichner verschiedene Variablen:
 xyz
 XYZ
 xYz

Werte werden an Variablen mittels Gleich-Zeichen (=) zugewiesen. Im Folgenden wird der Code immer in der Datei c:\tmp\test1.py gespeichert.

 x = 5
 y = 10
 z = x*y
 print(z)

Bringen Sie die Datei test1.py zur Ausführung, so erhalten Sie folgende Bildschirmausgabe

 50

Sie können auch mehrere Anweisungen in einer Zeile durch Semikolon getrennt schreiben. Dies führt aber zu unübersichtlichem Code.

 x = 5; y = 10; z = x*y; print(z)

Ausgabe:
 50

Auch aus der Programmiersprache C/C++ oder Java bekannte Konstrukte können Sie verwenden, z.B.
 x = 5
 # x = x - 2
 x -= 2
 print(x)

Bildschirmausgabe:

 3
 
Beachten Sie, dass mit dem =-Zeichen eine Wertezuweisung durchgeführt wird. Dies ist nicht äquivalent zum mathematischen =-Zeichen, wie am vorigen Beispiel zu ersehen ist. Den Inkrement-/Dekrementoperator (z.B. x++ oder x--) aus C/C++ oder Java kennt Python aber nicht.

Variablen sind nicht an einen bestimmten Datentyp gebunden, folgendes ist mit Python problemlos möglich:

 import math
 wert = 10
 print(wert)
 wert = 35.5
 print(wert)
 wert = &quot;Hallo&quot;
 print(wert)
 wert = math.pi
 print(wert)

Ausgabe:
 10
 35.5
 Hallo
 3.141592653589793

== Physische und logische Zeilen ==
In Python muss eine Anweisung in einer logischen Zeile Platz finden. Wird eine Anweisung aber zu lang für eine Zeile, dann kann sie in mehrere physische Zeilen unterteilt werden. Dies kann einerseits durch einen Backslash am Ende einer Zeile geschehen, z.B.

 a = 2 + \
 5
 
Dies stellt eine logische Zeile dar, die in zwei physische Zeilen unterbrochen ist.

Geklammerte Ausdrücke werden automatisch zu einer logischen Zeile verbunden, z.B.

 a = (2 + 
 5)
 
Achtung: Im ersten Beispiel darf nach dem Backslash nichts mehr stehen, auch kein Kommentar. Dies trifft im zweiten Bespiel nicht zu, hier könnte noch ein Kommentar folgen, z.B.

 a = (2 +    # Kommentar 
 5)

Auch für Strings gibt es Möglichkeiten, diese auf mehrere Zeilen aufzuspalten.

 # Kurzer String
 str1 = &quot;ABC&quot;
 
 # Langer String
 str2 = &quot;&quot;&quot;Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle&quot;&quot;&quot;
 
 # Backslash
 str3 = &quot;UVW\
 XYZ&quot;
 
 # Mit Klammern
 str4 = (&quot;Sehr langer Text, der automatisch .............. &quot;
         &quot;in einer einzigen Variable zusammengefügt wird.&quot;
 )
 
 print(str1)
 print(str2)
 print(str3)
 print(str4)

Ausgabe:

 ABC
 Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle
 UVWXYZ
 Sehr langer Text, der automatisch .............. in einer einzigen Variable zusammengefügt wird.

==Hexadezimale, oktale, binäre und andere Zahlen==
 d = 1050         # Dezimalzahl
 h = 0xAA2        # Hexadezimalzahl
 o = 0o12         # Oktalzahl
 b = 0b100001101  # Binärzahl
 
 print(d)
 print(h)
 print(o)
 print(b)

Ausgabe:
 1050
 2722
 10
 269

Groß- und Kleinbuchstaben sind in obigen Literalen übrigens egal. So kann man z.B. statt &lt;code&gt;0b1001&lt;/code&gt; auch &lt;code&gt;0B1001&lt;/code&gt; schreiben (siehe dazu [https://docs.python.org/3/reference/lexical_analysis.html#integer-literals]).

Sie können auch dezimale in hexadezimale Zahlen umwandeln, usw.:
 h = hex(1050)    # Dezimalzahl -&gt; Hexadezimalzahl
 b = bin(1050)    # Dezimalzahl -&gt; Binärzahl
 o = oct(1050)    # Dezimalzahl -&gt; Oktalzahl
 print(h)
 print(b)
 print(o)

Ausgabe:
 0x41a
 0b10000011010
 0o2032

Gegeben sei die Zahl 121 zur Basis 3. Diese soll in eine Dezimalzahl umgewandelt werden. Das kann so geschehen:

 z = int(&quot;121&quot;, 3)
 print(z)

Ausgabe:
 16

Dass dies richtig ist, davon kann man sich folgendermaßen überzeugen:
 &lt;math&gt; 1 \cdot 3^2 + 2 \cdot 3^1 + 1 \cdot 3^0 = 9 + 6+ 1 = 16 &lt;/math&gt;

Zahlen übersichtlicher schreiben kann man auch mittels Underscore, z.B.:

 print(&quot;Eine Million (Variante 1) =&quot;, 1000000)
 print(&quot;Eine Million (Variante 2) =&quot;, 1_000_000)
 print(&quot;Eine Rechnung:&quot;, 2_000 * 400_000);

Es ergibt sich bei beiden Varianten die gleiche Ausgabe. Variante 2 ist aber im Sourcecode leichter lesbar, detto die Zahlen in der Rechnung:

 Eine Million (Variante 1) = 1000000
 Eine Million (Variante 2) = 1000000
 Eine Rechnung: 800000000

== Strings und Platzhalter==
Ein paar einfache Beispiele:

 print(&quot;Hallo {}&quot; . format(&quot;Hugo&quot;))     # new style string formatting
 print(&quot;Hallo {:s}&quot; . format(&quot;Hugo&quot;))   # new style string formatting
 print(&quot;Hallo %s&quot; % &quot;Hugo&quot;)             # %-String

Ausgabe:

 Hallo Hugo
 Hallo Hugo
 Hallo Hugo

Python-Code (formatted string literals, Beispiel 1):
 str1 = &quot;Hallo&quot;
 str2 = &quot;Hugo&quot;
 print(f&quot;{str1} {str2}&quot;)

Ausgabe:
 Hallo Hugo

f-Strings (ab Python 3.6) sind die modernere Variante gegenüber %-Strings oder das ''new style string formatting''. Sie sind in der Regel auch schneller.

Python-Code (formatted string literals, Beispiel 2):
 wert = 11.567
 print(f&quot;Ausgabe: {wert:.5f}&quot;)

Ausgabe:
 Ausgabe: 11.56700

Komplexere Beispiele:

 print(&quot;Hallo {} und {}&quot; . format(&quot;Hugo&quot;, &quot;Mike&quot;))
 print(&quot;Hallo {name1} und {name2}&quot; . format(name2=&quot;Hugo&quot;, name1=&quot;Mike&quot;))
 # Füllzeichen: *
 # Bündigkeit: &gt; (=rechts), &lt; (=links), ^ (=zentriert)
 # Feldweite: 10
 # Typ: s (=String), f (=Gleitkommazahl), d (=Dezimalzahl) etc.
 print(&quot;Hallo {:*&gt;10s}&quot; . format(&quot;Hugo&quot;))
 print(&quot;Hallo {:*&lt;10s}&quot; . format(&quot;Hugo&quot;))

Ausgabe:

 Hallo Hugo und Mike
 Hallo Mike und Hugo
 Hallo ******Hugo
 Hallo Hugo******

Python-Code:
 str = &quot;Hallo\t%s\t%7.2f\t%10.2e\t%i&quot; % (&quot;Hugo&quot;, 12.34567, 34.567, 264)
 print(str)

Ausgabe:
 Hallo	Hugo	  12.35	  3.46e+01	264

== Unicode ==
Neben den bekannten ASCII-Zeichen lassen sich Zeichen auch mittels Unicode beschreiben. Griechische Buchstaben oder komplexere mathematische Operatoren - all das sollte kein Problem sein. Siehe auch {{W|Unicode}}, {{W|Liste der Unicodeblöcke}} und {{W|Unicodeblock Mathematische Operatoren}}. Im Folgenden werden ein paar Zeichen (Allquantor, Nabla-Operator, Existenzquantor), die man aus der Mathematik kennt, erzeugt. 
 
 ch1 = &quot;\N{FOR ALL}&quot;
 ch2 = &quot;\N{NABLA}&quot;
 ch3 = &quot;\u2203&quot;
 print(ch1, ch2, ch3)

Ausgabe:
 ∀ ∇ ∃

&lt;small&gt;Diese Ausgabe ergibt sich z.B. mit der IDLE-Shell oder mit Cygwin. Beim Ausführen über die Windows-Eingabeaufforderung oder Windows PowerShell unter MS Windows 10 erfolgt keine korrekte Darstellung. IDLE ist die mit Python mitgelieferte IDE ('''I'''ntegrated '''D'''evelopment '''E'''nvironment, Integrierte Entwicklungsumgebung). Gegen Ende dieses Textes wird IDLE kurz beschrieben.
Das Problem mit der Windows Eingabeaufforderung lässt sich aber umgehen. Man muss nur eine Schriftart auswählen, die die Zeichen kennt, z.B. &quot;DejaVu Sans Mono&quot;. Dazu klicken Sie einfach bei der Eingabeaufforderung mit der rechten Maustaste oben auf die weiße Leiste und wählen im aufpoppenden Fenster den Menüpunkt &quot;Eigenschaften&quot;. Es öffnet sich ein Dialogfenster. Über den Reiter &quot;Schriftart&quot; lässt sich nun die Schriftart einstellen. Unter MS Windows 11 oder openSUSE Leap 15.6 (bash-Konsole) gibt es dieses Problem ohnehin nicht.&lt;/small&gt;

== Reguläre Ausdrücke ==
Python kennt auch {{W|Regulärer Ausdruck|reguläre Ausdrücke}}. Dazu gibt es in Python das Modul &lt;code&gt;re&lt;/code&gt;. Beipielsweise sollen alle Zahlen (&lt;math&gt;\text{zahl}\in\mathbb{N}_0&lt;/math&gt;) in einem String gesucht und ausgegeben werden. Als String sei gegeben: &lt;code&gt;3x Grüße und 100 Kekse.&lt;/code&gt; Das Muster (Pattern) ist &lt;code&gt;\d+&lt;/code&gt;. &lt;code&gt;\d&lt;/code&gt; steht für eine Dezimalziffer 0-9. Das Plus-Zeichen (+) steht symbolisch für ein oder mehrere Zeichen des vorherigen Ausdrucks. Hier also ein oder mehrere Dezimalziffern. Es wird die Funktion &lt;code&gt;findall&lt;/code&gt; aus dem Modul &lt;code&gt;re&lt;/code&gt;verwendet.

Python-Code:
 from re import findall
 
 str = &quot;3x Grüße und 100 Kekse.&quot;
 pat = &quot;\\d+&quot;  # Doppel-Backslashes müssen verwendet werden, sonst gibt Python eine Warnung aus!
               # alternativ: pat = r&quot;\d+&quot; 
               # oder: pat = &quot;[0-9]+&quot;
 
 numb = findall(pat, str)
 print(numb)

Ausgabe:
 ['3', '100']

Python kennt noch viele weitere Möglichkeiten mittels regulärer Ausdrücke zu hantieren. Dies soll hier aber nicht vertieft werden, da das Thema schon ziemlich speziell und komplex ist. Bei Bedarf siehe aber z.B. die Bücher ''Weigend, Seite 380ff'' und ''Ernesti, Kaiser'' [https://openbook.rheinwerk-verlag.de/python/28_001.html] oder die Python-Dokumentation [https://docs.python.org/3/library/re.html]. Auch [[Python unter Linux: Reguläre Ausdrücke]] liefert ein umfangreiches und brauchbares Python-2-Kapitel zu den regulären Ausdrücken. Die dort gelisteten Beispiele müssten ggf. vor Verwendung auf Python-3 umgeschrieben werden. &lt;small&gt;Wie macht  man das? Dazu siehe z.B. [https://openbook.rheinwerk-verlag.de/python/43_001.html], [https://portingguide.readthedocs.io/en/latest/] oder [https://www.digitalocean.com/community/tutorials/how-to-port-python-2-code-to-python-3]&lt;/small&gt;

&lt;small&gt;Es gibt auch ein externes Modul ''regex'', das bei Bedarf extra installiert werden muss ([https://pypi.org/project/regex/]). Es bietet zusätzliche Funktionalität und gründlicheren Unicode-Support. Dies sei hier aber nur der Vollständigkeit halber erwähnt.&lt;/small&gt;

== Verzweigungen ==
=== if ===
Die IF-Verzweigung sei aus anderen Programmiersprachen bereits bekannt. In {{W|Pseudocode}} lässt sie sich folgendermaßen darstellen:

 WENN bedingung TRUE
   führe block1 aus
 SONST
   führe block2 aus
 ENDE 

Als {{W|Aktivitätsdiagramm|UML-Aktivitätsdiagramm}} sieht das in etwa so aus:

[[File:If-Then-Else-diagram.svg|200px]]

Und als {{W|Nassi-Shneiderman-Diagramm|Nassi-Shneiderman-Struktogramm}} so:

[[File:Zweiseitige Auswahl.png|250px]]

In Python gibt es keinen expliziten ENDE-Kennzeichner. Stattdessen wird der Code durch Einrückungen strukturiert. Alles mit der gleichen Einrückungstiefe gehört zum selben Block. Dies zeichnet Python vor anderen Programmiersprachen aus.

Die test1.py-Datei laute also wie folgt:

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
   print(&quot;x ist groesser oder gleich 4&quot;)  

Ausgabe:

 Der else-Zweig wird ausgefuehrt
 x ist groesser oder gleich 4

Man achte auch auf die Doppelpunkte in der if- und else-Zeile. Darauf vergisst man gerne, wenn man von anderen Programmiersprachen kommt.

Folgendes wäre in Python ein Fehler (genauer gesagt ein IndentationError).

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
     print(&quot;x ist groesser oder gleich 4&quot;)  

Auch Nachstehendes würde nicht zum gewünschten Ergebnis führen (löst aber keine Fehlermeldung aus). Der letzte print-Befehl ist schon außerhalb der IF-ELSE-Verzweigung.

 x = 3
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
 print(&quot;x ist groesser oder gleich 4&quot;)

Ausgabe:

 x ist kleiner als 4
 x ist groesser oder gleich 4

Python kennt eine Reihe von Vergleichs- und Verknüpfungsoperatoren:

    &lt;, &lt;= ... kleiner (gleich)
    &gt;, &gt;= ... größer (gleich)
    == ... gleich
    != ... ungleich
    is ... identisch
    is not ... nicht identisch
    and ... AND
    or ... OR
    not ... NOT

Beispielsweise:

 a = 5
 b = 9
 
 if a&lt;=10 and b!=7:
   print(&quot;OK&quot;)
 else
   print(&quot;Nicht OK&quot;)

Ausgabe:

 OK

Der else-Block kann übrigens auch ersatzlos entfallen. Als Pseudocode sieht das so aus

 WENN bedingung TRUE
   führe block aus
 ENDE

Mehrfache Verzweigungen werden durch das elif-Konstrukt erstellt. In Pseudocode:

 WENN bedingung1 TRUE
   führe block1 aus
 SONST WENN bedingung2 TRUE
   führe block2 aus
 SONST WENN bedingung3 TRUE
   führe block3 aus
 SONST
   führe block4 aus
 ENDE

Ein Python-Beispiel:
 a = 14
 
 if a&lt;=10:   
   print(&quot;&lt;=10&quot;)
 elif a&gt;=11 and a&lt;=15:
   print(&quot;11 bis 15&quot;)
 elif a&gt;=16 and a&lt;=20:
   print(&quot;16 bis 20&quot;)
 else:
   print(&quot;&gt;20&quot;)

Ausgabe:

 11 bis 15

In Python gibt es auch die Schlüsselwörter &lt;code&gt;True&lt;/code&gt; (für wahr) und &lt;code&gt;False&lt;/code&gt; (für falsch). Man beachte, dass sie mit Großbuchstaben beginnen. Andere Schreibweisen wären ein Fehler. Sie gehören zum Datentyp &lt;code&gt;bool&lt;/code&gt;. Ihnen sind auch die Zahlen &lt;code&gt;1&lt;/code&gt; und &lt;code&gt;0&lt;/code&gt; zugewiesen.

Man beachte, dass {{W|Rundungsfehler}} auftreten können. D.h. man sollte  bei der Verwendung von {{W|Gleitkommazahl|Gleitpunktzahlen}} niemals auf absolute Genauigkeit prüfen, sondern eine Toleranz (einen &lt;math&gt;\varepsilon&lt;/math&gt;-Wert) vorgeben.
 
Ein klassisches Beispiel, das ein falsches Ergebnis liefert, ist:

 i = 0.1 + 0.2
 
 print(i)
 
 if i == 0.3:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 NOK

Und das, obwohl man schon in der Volksschule lernt, dass 0.1 + 0.2 gleich 0.3 ist.

Korrekt muss das obige Beispiel z.B. so umgeschrieben werden:

 ist = 0.1 + 0.2
 soll = 0.3
 epsilon = 0.000001
 
 print(ist)
 
 if abs(ist-soll) &lt; epsilon:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 OK

Alternativ kann auch die &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion verwendet werden. Das sei aber hier nur erwähnt und nicht konkret ausgeführt.

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet zum Thema &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion.

=== match ===
Ab Python 3.10 gibt es auch die match-Anweisung. Dies ist das Python-Pendant für die switch-Anweisung in anderen Programmiersprachen, geht aber bei näherer Betrachtung weit darüber hinaus. Hier nur ein einfaches Beispiel:

 x = &quot;Hello&quot;
 
 match x:
     case &quot;Servus&quot; | &quot;Ciao&quot;:         # or
         print(&quot;Servus an alle&quot;)
     case &quot;Grüetzi&quot;:
         print(&quot;Grüetzi Schwyzer&quot;)  
     case _:                         # other, default, sonstiges ...
         print(&quot;Hallo Welt&quot;)

Ausgabe: 
 Hallo Welt

Als Struktogramm sieht das in etwa so aus:

[[File:Mehrseitige Auswahl.png|250px]]

Für nähere Details siehe z.B. [https://www.geeksforgeeks.org/python-match-case-statement/], [https://learnpython.com/blog/python-match-case-statement/], [https://docs.python.org/3/tutorial/controlflow.html#match-statements] und das Python Enhancement Proposal (PEP) 636 – Structural Pattern Matching: Tutorial [https://peps.python.org/pep-0636] und dort insbesondere den Anhang A - Quick Intro.

&lt;small&gt;&lt;code&gt;match, case, _&lt;/code&gt; etc. sind sogenannte ''soft keywords''. Im Gegensatz zu den normalen Schlüsselwörtern dürfen ihnen auch Werte zugewiesen werden. Eine Liste der weichen Schlüsselwörter lässt sich durch &lt;code&gt;keyword.softkwlist&lt;/code&gt; erstellen (die Anweisung gibt es seit Python 3.9). Siehe dazu auch [https://stackoverflow.com/questions/65800344/what-are-soft-keywords] und [https://docs.python.org/3/library/keyword.html#keyword.softkwlist].&lt;/small&gt;

== Schleifen ==
Kopfgesteuerte Schleife, Endlosschleife und fußgesteuerte Schleife:

[[File:Programmingloops.svg|450px]]

=== while ===
Die WHILE-Schleife ist kopfgesteuert. Sie funktioniert wie aus anderen Programmiersprachen bekannt. 

In Pseudocode:
 SOLANGE bedingung TRUE
   führe block aus
 ENDE

In Python:
 x = 0
 
 while x &lt;= 10:
   print(x)
   x += 1

Ausgabe:
 0
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10

Eine Endlosschleife ergibt sich z.B. so:
 i = 5
 
 while True:
     print(i)
     i-=1

Beendet werden kann sie mit der Tastenkombination STRG-C.

Eine fußgesteuerte Schleife kann so simuliert werden:
 i = 5
 
 while True:
     print(i)
     i-=1
 
     if i&lt;=0:
         print(&quot;Fire&quot;)
         break

Ausgabe:
 5
 4
 3
 2
 1
 Fire

Der &lt;code&gt;break&lt;/code&gt;-Befehl wird etwas [[Ing_Mathematik:_Python#break|später]] noch einmal kurz thematisiert.

=== for ===
Struktogramm einer for-Schleife:

[[File:Zählschleife.png|200px]]

In Python bspw. so:

 for x in range(6):
   print(x*2)

Ausgabe:
 0
 2
 4
 6
 8
 10

Die Schleife läuft von 0 bis 5. Ausgegeben wird jeweils der Wert x*2. Aquivalent kann diese Schleife auch so geschrieben werden:
 for x in range(0, 11, 2):
   print(x)

Die Ausgabe ist wie oben. Der Startwert sei 0, der Endwert ist 11-1 und die Schrittweite ist 2.

Ein anderes Beispiel sei
 for x in &quot;text&quot;:
   print(x)

Ausgabe:
 t
 e
 x
 t

== Schleifen abbrechen ==
=== break ===
&lt;code&gt;break&lt;/code&gt; bricht die Schleife ab und setzt mit dem nächsten Befehl außerhalb der Schleife fort.

 for var in range(100):
   print(var) 
   if var == 5:
     break

Ausgabe:
 0
 1
 2
 3
 4
 5

=== continue ===
&lt;code&gt;continue&lt;/code&gt; bricht den aktuellen Schleifendurchlauf ab und setzt mit dem nächsten Schleifendurchlauf fort.

 for var in range (11):
   if var == 5:
     continue
   print(var)

Ausgabe:
 0
 1
 2 
 3
 4
 6
 7
 8
 9
 10

== try - except ==
 try:
     z1 = 12 / 0
     print(z1)
 except ZeroDivisionError:
     print(&quot;Das Ergebnis ist unendlich&quot;)
 except:
     print(&quot;Kann nicht berechnet werden!&quot;)
     print(&quot;Bitte die Formel korrigieren!&quot;)
 
 print(&quot;Setze Programm fort!&quot;)

Ausgabe:
 Das Ergebnis ist unendlich
 Setze Programm fort!

Es wird versucht, eine Zahl durch Null zu dividieren. Das ist nicht möglich, es wird eine Ausnahme ausgelöst. Das Programm springt daher in den except-ZeroDivisionError-Block und führt die dort gelisteten Anweisungen aus (in unserem Fall eine print-Anweisung). Danach wird das Programm fortgesetzt. Würden wir dieses Programm ohne try-except ausführen, so ergibt sich aus

 z1 = 12 / 0
 print(z1)

folgende Fehlermeldung und ein unmittelbarer Programmabbruch

 Traceback (most recent call last):
   File &quot;C:\tmp\test1.py&quot;, line 1, in &lt;module&gt;
     z1 = 12 / 0
 ZeroDivisionError: division by zero

Mit dem try-except-Mechanismus können also Ausnahmen oder Fehler aufgefangen und behandelt werden. In unserem Beispiel ist das eher trivial, aber bei größeren Programmen kann das durchaus Sinn machen.

Neu in Python 3.14 ist, dass mehrere Ausnahmen auch ohne Klammern angegeben werden können, z.B.:

bis inkl. Python 3.13 nur:
 except (ZeroDivisionError, ValueError):

ab Python 3.14 auch:
 except ZeroDivisionError, ValueError:

== pass ==
Ein leerer Block muss in Python mittels dem Schlüsselwort &lt;code&gt;pass&lt;/code&gt; dargestellt werden. Z.B.

 x = 2
 
 if x == 1:
     print(&quot;Wert ist &quot;, x)
 else:
     pass

Würde man das &lt;code&gt;pass&lt;/code&gt; im else-Block weglassen, so würde man eine Fehlermeldung erhalten:

 IndentationError: expected an indented block after 'else' statement on line 5

= Funktionen =
== Aufrufen von Funktionen ==
Funktionen sind uns im Rahmen dieses Kurses schon zuhauf begegnet. Sei es die print()-, die math.sin()- oder die hex()-Funktion. All diese Funktionen werden von Python zur Verfügung gestellt, ohne dass man sie explizit programmieren müsste. Aufgerufen werden diese Funktionen, indem man ihren Namen eintippt, gefolgt von runden Klammern. In diesen Klammern können noch Argumente übergeben werden. Auch Rückgabewerte sind möglich.

== Funktionen selber schreiben ==
Funktionen werden mit dem def-Schlüsselwort (man definiert die Funktion) eingeleitet, danach folgt der Funktionsname, danach wiederum runde Klammern, in denen formale Argumente stehen können. Abgeschlossen wird die def-Zeile mit einem Doppelpunkt. Danach folgt der Funktionskörper. Dieser Funktionskörper muss wiederum eingerückt werden (wie von den Verzweigungen und Schleifen bekannt). Aufgerufen wird diese Funktion, indem man ihren Funktionsnamen eingibt, gefolgt von runden Klammern (ggf. mit den aktuellen Parametern). Z.B.

 # Funktion definieren
 def halloWelt(i):
     # i ... beliebige Ganzzahl
     print(&quot;Hallo &quot; * i, end=&quot;&quot;)
     print(&quot;Welt!&quot;)
    
 # Funktion aufrufen
 halloWelt(3)

Ausgabe:
 Hallo Hallo Hallo Welt!

Unterschied zwischen formalen und aktuellen Parametern:

[[Datei:PythonIng_func1.jpg]]

&lt;small&gt;Aktuelle Parameter werden auch Argumente genannt.&lt;/small&gt;

Rückgabe von Funktionswerten:
 # Funktion definieren
 def mathFunc(a, b):
     r1 = a + b
     r2 = a * b
     return r1, r2
    
 # Funktion aufrufen
 c, d = mathFunc(3, 5)
 
 # Ausgabe der zurückgegebenen Werte
 print(c)
 print(d)

Ausgabe:
 8
 15

Es werden r1 und r2 zurückgegeben und den Variablen c und d zugewiesen. (r1, r2) und (c, d) sind Tupel. Was Tupel konkret sind, siehe etwas später in diesem Kapitel. 3 und 5 sind die aktuellen Parameter (die Argumente). a und b sind die formalen Parameter. Die Zuweisung der aktuellen zu den formalen Parametern erfolgt in der gegebenen Reihenfolge, also die Zahl 3 wird an a übergeben und die Zahl 5 an b.

Vorgabeparameter, z.B.:
 def mathFunc(a=10, b=20):
     r1 = a + b
     r2 = a * b
     return r1, r2
 
 c, d = mathFunc(3, 5)
 print(c)
 print(d) 
 
 e, f = mathFunc(5)
 print(e)
 print(f)
 
 g, h = mathFunc(b=6)
 print(g)
 print(h)

Ausgabe:
 8
 15
 25
 100
 16
 60

Erklärung:
* Erster &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es werden, wie weiter oben, die Argumente 3 und 5 an die formalen Parameter a und b übergeben. Die Rückgabewerte r1 und r2 werden an c und d übergeben. Somit ist c=8 und d=15.
* Zweiter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur das Argment 5 an a übergeben. b behält den Vorgabewert 20. D.h. e= 25 und f=100.
* Dritter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur die Zahl 6 an b übergeben, a behält seinen Vorgabewert 10. Somit ergibt sich g=16 und h=60.

Beispiel (Schlüsselwortargumente vs. Positionsargumente):
 def mathFunc(a, b):
     r1 = a - b
     r2 = a / b
     return r1, r2
 
 c, d = mathFunc(b=3, a=5)  # Schlüsselwortargumente
 e, f = mathFunc(3, 5)      # Positionsargumente

 print(c)
 print(d)
 print(e)
 print(f)

Ausgabe:
 2
 1.6666666666666667
 -2
 0.6

Durch die Verwendung von Schlüsselwortargumenten können die Argumente in beliebiger Reihenfolge angegeben werden. Bei den Positionsargumenten ist die Reihenfolge vorgegeben. Daraus resultiert auch der Unterschied bei den obigen Ausgaben. Werden beide Arten in einem Aufruf gemischt, so müssen die Positionsargumente zuerst angegeben werden. Den Unterschied zwischen beiden Argumentarten zu kennen ist wichtig, nicht nur bei selbst erstellten Funktionen. Auch beim Aufruf von Python-Funktionen verfolgt einen die Mischung von Schlüsselwort- und Positionsargumenten auf Schritt und Tritt, z.B. beim etwas später folgenden Abschnitt über &quot;Grafiken zeichnen&quot;:

 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)

Bei dieser &lt;code&gt;plot&lt;/code&gt;-Funktion aus dem Modul &lt;code&gt;matplotlib.pyplot&lt;/code&gt; sind &lt;code&gt;x&lt;/code&gt; und &lt;code&gt;y1&lt;/code&gt; Positionsargumente. &lt;code&gt;label, lw&lt;/code&gt; und &lt;code&gt;ls&lt;/code&gt; sind die Namen der Schlüsselwortargumente. Die Schlüsselwortargumente könnten auch in anderer Reihenfolge angeschrieben werden, nicht jedoch die Positionsargumente!
Siehe zu &lt;code&gt;matplotlib.pyplot.plot&lt;/code&gt; auch die Seite [https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html].

== Lambda-Funktionen ==
 print((lambda a, b: a*b) (3, 5))

Ausgabe:
 15

Eingeleitet wird eine Lambda-Funktion (auch Lambda-Form, Lambda-Operator oder anonyme Funktion genannt) mit dem Schlüsselwort &lt;code&gt;lambda&lt;/code&gt;. Es folgen die formalen Argumente, danach ein Doppelpunkt, die Berechnungsvorschrift und ggf. abschliessend in Klammern die aktuellen Parameter.

Man kann einer Lambda-Funktion auch einen Funktionsnamen geben und die Funktion über diesen Namen aufrufen, z.B.

 prod = lambda a, b: a*b
 print(prod(3, 5))

Als Ausgabe wird wieder die Zahl 15 geliefert.

== Rekursive Funktionen ==
Funktionen können wiederum andere Funktionen aufrufen. Von einem {{W|Rekursion|rekursiven Funktionsaufruf}} spricht man, wenn die aufgerufene Funktion gleich der aufrufenden ist. 

 def printFunc(i):
     if (i &gt;= 5):
         return 
     else:
         print(&quot;Hallo Welt&quot;)
         printFunc(i+1)
         
 printFunc(1)

Ausgabe:
 Hallo Welt
 Hallo Welt
 Hallo Welt
 Hallo Welt

Typische Beispiele für die Abarbeitung als rekursive Funktionen sind die {{W|Fibonacci-Folge}} und die {{W|Fakultät_(Mathematik)|Fakultät}}. Jedoch ist der iterative Ansatz (mit konventionellen Schleifen) meist schneller und speicherplatzschonender.

== Funktionsannotationen ==
Python ist sehr flexibel, was Typen angeht. Im Vorhergehenden haben wir generell keine Typangaben gemacht. Will man Typen angeben, so bietet Python das Konzept der Funktionsannotation.

 def calcFunc(a: int, b: int) -&gt; int:
     return a+b
 
 r1 = calcFunc(8, 9)
 r2 = calcFunc(8.0, 9.0)
 r3 = calcFunc(&quot;Hallo&quot;, &quot;Welt&quot;)
 
 print(r1)
 print(r2)
 print(r3)

Ausgabe:
 17
 17.0
 HalloWelt

Jetzt sieht man auf den ersten Blick, welche Typen der Programmierer im Sinn hatte, als er die Funktion erstellte. Das Problem dabei ist nur, dass es Python ziemlich egal ist, welche Typen man im Endeffekt eingibt. Im obigen Beispiel können statt Integer-Typen u.a. auch Float- oder String-Typen eingegeben werden.

&lt;small&gt;
Siehe zum Thema &quot;Type Checking&quot; aber auch den später folgenden Abschnitt [[Ing_Mathematik:_Python#Type_Checker]].
&lt;/small&gt;

== Variadische Funktionen ==
Python-Code:

 def test1(a, *b):
     print(a);
      
     for c in b:
         print(c);
        
 test1(&quot;Hallo&quot;, &quot;Welt&quot;, &quot;Schweizer&quot;, &quot;und alle anderen&quot;)

Ausgabe:

 Hallo
 Welt
 Schweizer
 und alle anderen

Mit dem Stern (auch als Splat-Operator bezeichnet) in der formalen Parameterliste bei der Funktion &lt;code&gt;test1&lt;/code&gt; wird angezeigt, dass eine beliebige Anzahl von Argumenten übergeben wird. &lt;small&gt; Dies entspricht in etwa dem, was in anderen Programmiersprachen (PHP etc.) mittels Ellipse (&lt;code&gt;...&lt;/code&gt;) angezeigt wird.&lt;/small&gt;

= Tupel, Listen und andere =
[[Datei:Python 3. The standard type hierarchy.png|mini|hochkant=1.7|Datentypen und Strukturen]]

== Tupel und Listen ==
Tupel, Listen und einige andere sind Datenstrukturen oder Sequenzen.

Listen (z.B. eine Einkaufsliste) sind veränderbar (mutable). Ein Tupel kann dagegen nicht verändert werden (immutable). Listen werden beim Anlegen in eckige Klammern eingeschlossen, Tupel in runde Klammern. Beim Tupel können die Klammern auch weggelassen werden. Ein Tupel mit nur einem Element muss mit einem Beistrich abgeschlossen werden. Der Grund ist, dass Python sonst nicht entscheiden kann, ob ein Tupel angelegt werden soll, oder nur ein geklammerter Wert. 

Als Gedächtnisstütze kann man sich den Unterschied zwischen Tupel und Liste ev. so leichter merken:
: T'''u'''pel ... r'''u'''nde Klammern, '''u'''nveränderlich
: L'''i'''ste ... eck'''i'''ge Klammern, veränderl'''i'''ch.

Nachfolgend werden einige Operationen mit Listen und Tupel dargestellt.

 # Liste und Tupel
 liste = [1, 2, &quot;Hallo&quot;]
 tupel = (1, 2, &quot;Hallo&quot;) 
 
 # Ausgabe von liste und tupel
 print(liste)
 print(tupel)
 
 # Ausgabe von Einzelelementen
 print(liste[1])
 print(tupel[2])
 
 # Element an Liste anhängen und einfügen 
 liste.append(55)
 liste.insert(4, &quot;Welt&quot;)
 print(liste)
 
 # Element aus Liste entfernen
 liste.remove(1)
 print(liste)
 
 # einige weitere Beispiele
 liste2 = [1,]
 tupel2 = 1, 2
 tupel3 = (1,) 
 print(liste2)
 print(tupel2)
 print(tupel3)

Ausgabe:
 [1, 2, 'Hallo']
 (1, 2, 'Hallo')
 2
 Hallo
 [1, 2, 'Hallo', 55, 'Welt']
 [2, 'Hallo', 55, 'Welt']
 [1]
 (1, 2)
 (1,)

Beispiel (eine Liste von Wörtern zu einem einzigen zusammenhängenden Text verbinden):

 woerter = [&quot;Hallo&quot;, &quot;Welt&quot;]
 satz = &quot; &quot;.join(woerter)
 print(satz)

Ausgabe:

 Hallo Welt

== Dictionaries und Mengen ==
Zu den Datenstrukturen gehören weiters auch Mengen und Dictionaries. Mengen sind von der Mathematik bekannt, sie sind ungeordnet und es kommen keine mehrfachen Elemente vor. Dictionaries sind durch Schlüssel :Wert-Paare gekennzeichnet. Mengen werden beim Anlegen wie Dictionaries in geschweifte Klammern eingeschlossen.

 dict = {&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot; }
 menge = {1, 1, 3, 4, 4, 4, &quot;Hallo&quot;}
 
 print(dict)
 print(menge)
 print(dict[&quot;vorname&quot;])

Ausgabe:
 {'vorname': 'Hugo', 'nachname': 'Meister'}
 {1, 3, 4, 'Hallo'}
 Hugo

Geschweifte Klammern ohne Inhalt stellen Dictionaries dar und keine Mengen:

 di = {}
 print(type(di))

Ausgabe:
 &lt;class 'dict'&gt;

Leere Mengen lassen sich mit &lt;code&gt;set()&lt;/code&gt; erzeugen:

 menge = set()      # leere Menge
 print(menge)
 menge.add(&quot;Hallo&quot;) # Element hinzufügen
 print(menge)

Ausgabe:
 set()
 {'Hallo'}

Beispiel (einige Mengenoperationen):
 mengeA = {&quot;Hallo&quot;, &quot;Welt&quot;}
 mengeB = {1, 2, &quot;Welt&quot;, 3}
 
 # Vereinigung
 print(mengeA | mengeB)
 print(mengeA.union(mengeB))
 
 # Durchschnitt
 print(mengeA &amp; mengeB)
 print(mengeA.intersection(mengeB))
 
 # Differenz
 print(mengeA - mengeB)
 print(mengeA.difference(mengeB))
 
 # Symmetrische Differenz
 print(mengeA ^ mengeB)
 print(mengeA.symmetric_difference(mengeB))
 
 # Teilmenge
 print(mengeA.issubset(mengeB))
 
 # Mehrere Elemente hinzu
 mengeA.update([&quot;Super&quot;, 67, 125])
 print(mengeA)
 
 # Element löschen
 mengeA.discard(&quot;Hallo&quot;)
 print(mengeA)

Ausgabe:
 {1, 2, 3, 'Welt', 'Hallo'}
 {1, 2, 3, 'Welt', 'Hallo'}
 {'Welt'}
 {'Welt'}
 {'Hallo'}
 {'Hallo'}
 {1, 2, 3, 'Hallo'}
 {1, 2, 3, 'Hallo'}
 False
 {67, 'Super', 'Welt', 'Hallo', 125}
 {67, 'Super', 'Welt', 125}

Es gibt schon seit &quot;ewigen&quot; Zeiten unveränderbare Mengen, die mittels &lt;code&gt;frozenset&lt;/code&gt; eingeleitet werden. Neu ab Python 3.15 ist dagegen das Pendant &lt;code&gt;frozendict&lt;/code&gt;, das unveränderbare Dictionaries darstellt.

 fdict = frozendict({&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot;})
 fset = frozenset({&quot;A&quot;, 1, &quot;A&quot;})
 
 print(fdict)
 print(fdict[&quot;vorname&quot;])
 print (fset) 
 
 try:
     fdict[&quot;vorname&quot;] = &quot;Max&quot;
     print(fdict[&quot;vorname&quot;])
 except TypeError as e:
     print(f&quot;Fehler: {e}&quot;)
 
 try:
     fset.add(&quot;B&quot;)
     print(fset)
 except AttributeError as e:
     print(f&quot;Fehler: {e}&quot;)

Ausgabe:
 frozendict({'vorname': 'Hugo', 'nachname': 'Meister'})
 Hugo
 frozenset({1, 'A'})
 Fehler: 'frozendict' object does not support item assignment
 Fehler: 'frozenset' object has no attribute 'add'

== List Comprehensions ==
Aus einer Eingabeliste soll eine Ausgabeliste erzeugt werden. Das kann folgendermaßen geschehen.

Mathematische Schreibweise: &lt;math&gt;lc = \{2x|x\in\ \mathbb{N}, 1\le x &lt; 11\}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11)]
 print(lc)

Ausgabe:
 [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Mathematische Schreibweise: &lt;math&gt;lc = \{2x | x \in \mathbb{N}, 1\le x &lt; 11, x \bmod 2 = 0 \}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11) if x%2 == 0]
 print(lc)

Ausgabe:
 [4, 8, 12, 16, 20]

Siehe auch {{W|List Comprehension}}.

== Set Comprehensions ==
Dies ist sehr ähnlich wie im vorigen Abschnitt beschrieben. Es wird aber keine Liste, sondern eine Menge erzeugt.

 sc = {x*2 for x in range(1,11)}
 print(sc)

Ausgabe:
 {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}

== Listen zusammenführen - zip() ==
 li1 = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]
 li2 = [1, 2, 3, 4]
 li3 = [5.5, 6.6, 7.7, 8.8]
 
 z = zip(li1, li2, li3)
 print(z)
 
 li4 = list(z)
 print(li4)

Ausgabe:
 &lt;zip object at 0x00000283B6C6AC80&gt;
 [('A', 1, 5.5), ('B', 2, 6.6), ('C', 3, 7.7), ('D', 4, 8.8)]

== Generatorausdruck ==
 g = (i*2 for i in range(1,11))
 print(g)
 t = tuple(g)
 print(t)
 print(t[1:3])

Ausgabe:
 &lt;generator object &lt;genexpr&gt; at 0x00000241D2A4A5A0&gt;
 (2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
 (4, 6)

== Slicing ==
slice ... Scheibe, Teil, in Scheiben schneiden

Beispiel: Zugriff auf Elemente eines geordneten sequentiellen Objekttyps (Liste, Tupel oder String):

 str1 = &quot;Hallo&quot;
 # Das erste Element wird mit dem Index 0 angesprochen
 # [start (inkl.) : stop (exkl.) : step (default=1)]
 str2 = str1[0:2]
 # Alternativ auch: str2 = str1[:2] 
 print(str2)
 
 tup1 = (0,1,2,3)
 # Das letzte Element hat auch den Index -1, das vorletzte den Index -2 usw.
 tup2 = tup1[-3:-1]
 print(tup2)
 
 lst1 = [[1,  5,  10, 20],
         [30, 40, 50, 60]]
 lst2 = lst1[1][1]
 print(lst2)
 
Ausgabe:
 Ha
 (1, 2)
 40

Beispiel:

 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2])
 print(x[-3]) 
 print(x)
 print(x[:])
 print(x[2:])
 print(x[:2])
 print(x[::-1])

Ausgabe:

 c
 c
 ('a', 'b', 'c', 'd', 'e')
 ('a', 'b', 'c', 'd', 'e')
 ('c', 'd', 'e')
 ('a', 'b')
 ('e', 'd', 'c', 'b', 'a')

Visualisierung:

    '''a'''     '''b'''     '''c'''     '''d'''     '''e'''
 +-----------------------------+
 |  0  |  1  |//'''2'''//|  3  |  4  |
 +-----------------------------+
 | -5  | -4  |/'''-3'''//| -2  | -1  | 
 +-----------------------------+
 |/////////////////////////////|
 +-----------------------------+
 |/////////////''':'''///////////////|
 +-----------------------------+
 |     |     |///////'''2:'''////////|
 +-----------------------------+
 |////''':2'''/////|     |     |     |
 +-----------------------------+
 |\\\\\&lt;--\\\\\'''::-1'''\\\\&lt;--\\\\\|
 +-----------------------------+

Beispiel:
 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2::2])
 print(x[2::-1])
 print(x[2:0:-1])

Ausgabe:

 ('c', 'e')
 ('c', 'b', 'a')
 ('c', 'b')

Hier sieht man sehr schön, dass beim letzen &lt;code&gt;print&lt;/code&gt;-Befehl die 0, die in diesem Fall den Buchstaben &quot;a&quot; repräsentiert, als letzer Wert nicht mehr dazugehört (wie weiter oben angedeutet ist der End- oder Stoppwert exklusiv). Will man den Buchstaben &quot;a&quot; dazunehmen, so ist die vorletzte Zeile die richtige.

Beispiel: Umdrehen von Strings

 str1 = &quot;Hallo&quot;
 str2 = str1[::-1]
 print(str2)

Ausgabe:
 ollaH

Mit zweidimensionalen Listen/Tupels wird das Ganze schon bedeutend komplexer.

Beispiel: Verkettetes Slicing

 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
     
 print(A[2::][::2])

Ausgabe:

 [['20', '21', '22', '23'], ['40', '41', '42', '43']]

Das erste Slicing erstellt folgenden Slice:

 [[&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
  [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
  [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]

Das zweite Slicing wird dann auf diesen Slice angewendet und ergibt das genannte Endergebnis. Will man Spalten statt Zeilen, so funktioniert dieser direkte Weg nicht. Man verwendet dann List Comprehensions oder die NumPy-Bibliothek. Diese Bibliothek erlaubt [[Ing_Mathematik:_Python#Zugriff_auf_Matrizenelemente|zweidimensionales Slicing]]. Sie wird erst später bei den Grafiken eingeführt. Deshalb wird hier dazu noch kein Beispiel gezeigt.

= Objektorientierte Programmierung =
{{Wikipedia|Objektorientierte Programmierung}}

* {{W|Klasse (Objektorientierung)|Klasse}} ... die Schablone oder der Bauplan, enthält Methoden und Attribute
* {{W|Objekt (Programmierung)|Objekt}} ... eine Klasseninstanz (die konkrete Ausprägung der Klasse)
* {{W|Attribut (Programmierung)|Attribute}} ... die Eigenschaften eines Objekts
* {{W|Methode (Programmierung)|Methoden}} ... die Aktionen (Operationen), die ein Objekt ausführen kann
* {{W|Vererbung (Programmierung)|Vererbung}} ... neue Klassen (Subklassen, Unterklassen, abgeleitete Klassen) aus vorhandenen Klassen (Superklassen, Oberklassen, Basisklassen, Elternklassen) ableiten. Ermöglicht den Aufbau von Klassenhierarchien. Die Subklasse &quot;erbt&quot; Attribute und Methoden von der Superklasse. Python unterstützt (so wie C++, aber im Gegensatz zu Java) Mehrfachvererbung.

== UML ==
* {{W|Unified Modeling Language|UML}} ... '''U'''nified '''M'''odeling '''L'''anguage, eine Modellierungssprache. Die UML enthält zahlreiche Diagrammarten, um Programme zu modellieren. Im Nachfolgenden wird nur das {{W|Klassendiagramm}} verwendet.

[[File:UmlCd Klasse-3.svg|300px]]

* {{W|Sichtbarkeit (Programmierung)|Sichtbarkeit}}:
** + ... public (öffentlich)
** - ... private
** # ... protected 

* {{W|Attribut_(UML)#Attribute_für_Instanzen_und_für_Klassen|Klassenattribute}} (statische Attribute): Werden nur einmal pro Klasse angelegt. Im Klassendiagramm werden sie unterstrichen.

[[File:Attribute-3.png|200px]]

* Vererbung:

&lt;gallery&gt;
InheritancePgmUML.svg | Abgeleitete Klasse erbt von Basisklasse (Einfachvererbung)
Diamond inheritance.svg | D erbt von B und C (Mehrfachvererbung). B und C erben von A (Einfachvererbung)
&lt;/gallery&gt;

Für weitergehende Betrachtungen zur UML wird auf Spezialliteratur verwiesen, z.B.:
* Seidl et al.: UML@Classroom. dpunkt, 2012, ISBN 978-3-89864-776-2
* Rupp et al.: UML 2 glasklar. Hanser, 4. Aufl., 2012, ISBN 978-3-446-43057-0

== Eine einfache Klasse ==

[[Datei:PythonIng_uml1.svg | 200px]]

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
 
 fahr = Fahrzeug(150, 90)
 
 print(fahr.convertGeschw())
 
Ausgabe:
 41.666666666666664

Die Klasse Fahrzeug wird durch das class-Schlüsselwort eingeleitet. raeder ist ein Klassenattribut und public. __init__ wird bei der Objekterzeugung automatisch aufgerufen (ist der sogenannte Konstruktor). Man achte darauf, dass diese Methode immer mit zwei Unterstrichen eingeleitet und abgeschlossen wird. Instanzattributen wird das Wort self vorangestellt. Wir sehen uns z.B. das Attribut self.__geschwind an. Auch hier werden zwei Unterstriche verwendet. Das bedeutet, dass dieses Attribut strikt/stark private ist. Wird nur ein Unterstrich verwendet, so deutet dies auf schwach/weakly private hin. Letzteres wird in Python deutlich häufiger verwendet. Bei den Methoden wird immer self als erster Parameter angegeben. Beim Aufruf der entsprechenden Funktion wird das self aber nicht berücksichtigt.

Besonderheiten bei stark und schwach private:
* '''stark private''':
** zwei führende Unterstriche
** Name Mangling: Name wird zu &lt;code&gt;_Klassenname__variablenname&lt;/code&gt;
** Schutz vor Namenskollisionen bei Vererbung
** am Ende des Namens dürfen keine zwei Unterstriche verwendet werden. Das wären dann Magic Methods oder Dunder-Methods (z.B. __init__). Diese sind public.

* '''schwach private''':
** ein führender Unterstrich
** Name bleibt gleich
** ist nur ein Hinweis an die Programmierer, kein starker Schutz
** &lt;code&gt;from modul import *&lt;/code&gt;: Objekte mit einem führenden Unterstrich werden standardmäßig nicht importiert
** Standard für die Kapselung bei Python. Schätzung: Weit mehr als 80% der nicht-öffentlichen Attribute/Methoden werden als schwach private deklariert. Weniger als 5-10% als stark private (Quelle: Google KI)

== Klassen importieren ==
Häufig ist es sinnvoll und übersichtlicher Klassen in eigenen Dateien zu speichern. Das sind dann eigene Module. Abgespeichert werden Sie mit der Endung py, wie bisher auch praktiziert. Aufgerufen werden Sie mit der import-Anweisung. Dann ist aber nur der Dateiname ohne Endung py zu verwenden. Klarer wird das mit einem Beispiel.

Datei c:\tmp\fahrzeug.py

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6

Datei c:\tmp\test1.py

 import fahrzeug
 fahr = fahrzeug.Fahrzeug(150, 90)
 print(fahr.convertGeschw())

Ausgabe:
 41.666666666666664

Die üblichen import-Anweisungen lauten wie folgt:
{| {{prettytable}}
! import-Befehl
! Instanz
|-
| import xyz      || xyz.Klasse
|-
| import xyz as x || x.Klasse
|-
| from xyz import Klasse || Klasse
|-
| from xyz import * || Klasse 
|}

Der Vorteil der ersten beiden import-Anweisungen ist, dass es kaum zu Namenskollisionen kommen kann. Dafür hat man bei den letzten beiden Varianten weniger Tipparbeit.

== Vererbung ==
=== Einfachvererbung ===

[[Datei:PythonIng_uml2.svg | 200px]]

Datei fahrzeug.py:
 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
        
     def setLeistung(self, leistung):
         self.__leistung = leistung
        
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
        
 class Luftfahrzeug(Fahrzeug):
     def __init__(self, geschwindigkeit, leistung, fluegel):
         super().__init__(geschwindigkeit, leistung)
         self.__flueg = fluegel
     
     def getFlueg(self):
         return self.__flueg

Datei test1.py:
 import fahrzeug
 fahr = fahrzeug.Luftfahrzeug(150, 90, 4)
 print(fahr.getFlueg())

Ausgabe:
 4

=== Mehrfachvererbung ===
Mit Python ist auch Mehrfachvererbung möglich, z.B.:

 class A:
     def _printA(self):
         print(&quot;Klasse A&quot;)
 
 class B:
     def _printB(self):
         print(&quot;Klasse B&quot;)
 
 class C(A,B):
     def __init__(self):
         self._printA()
         self._printB()
 
 c = C()

Ausgabe:

 Klasse A
 Klasse B

Die Klasse C erbt von A und B. In UML sieht das in etwa so aus:

 +-----------------------------+   +-------------------------+
 |            A                |   |          B              |
 +-----------------------------+   +-------------------------+
 |                             |   |                         |
 +-----------------------------+   +-------------------------+
 | # printA()                  |   | # printB()              |
 +-----------------------------+   +-------------------------+
                           .              .
                          / \            / \
                          ---            ---
                           |              |
                           |              |
                        +---------------------+
                        |          C          |
                        +---------------------+
                        |                     |
                        +---------------------+
                        |                     |
                        +---------------------+

&lt;code&gt;printA()&lt;/code&gt; und &lt;code&gt;printB()&lt;/code&gt; sind schwach private (in UML als &lt;code&gt;protected&lt;/code&gt; mit einem # dargestellt). Es ist aber zu beachten, dass schwach private nur Konvention ist. Praktisch könnte man auch von außerhalb auf diese Methoden zugreifen. Das soll man aber nicht tun, und das wird in Python durch einen Unterstrich angedeutet.

== Statische Attribute, statische Methoden und Klassenmethoden ==
Beispiel:

 class Math:
     pi = 3.14159265
     cnt = 0
     
     @staticmethod
     def expo():
         return 2.71828183
    
     @classmethod    
     def counterPlus(cls):
         cls.cnt += 1
        
 print(Math.pi)
 print(Math.expo())
 
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)

Ausgabe:

 3.14159265
 2.71828183
 1
 2
 3

Statische Attribute und Methoden, bzw. Klassenmethoden, sind direkt einer Klasse zugeordnet und nicht einem Objekt. Der Unterschied zwischen statischen Methoden und Klassenmethoden ist, dass statische Methoden nicht auf Klassenattribute (bzw. statische Attribute) zugreifen können, Klassenmethoden aber schon. &lt;code&gt;pi&lt;/code&gt; und &lt;code&gt;cnt&lt;/code&gt; sind statische Attribute. &lt;code&gt;expo()&lt;/code&gt; ist eine statische Methode. &lt;code&gt;counterPlus(cls)&lt;/code&gt; ist eine Klassenmethode. Die Bezeichnung des Parameters als &lt;code&gt;cls&lt;/code&gt; ist reine Konvention, man sollte sich aber daran halten. &lt;code&gt;@staticmethod&lt;/code&gt; und &lt;code&gt;@classmethod&lt;/code&gt; nennt man auch Dekoratoren.

= Grafiken zeichnen =
Für das Zeichnen von Grafiken wird hier das Modul &lt;code&gt;matplotlib&lt;/code&gt; verwendet. &lt;code&gt;matplotlib&lt;/code&gt; ist ein externes Modul und muss vor der ersten Verwendung installiert werden. Das geht so:

# Starten Sie ein Terminal (bei Windows die Eingabeaufforderung).
# Führen Sie darin folgenden Befehl aus &lt;code&gt;c:\devel\Python\Scripts\pip.exe install matplotlib&lt;/code&gt;

pip ist übrigens der Paketmanager von Python ({{W|Pip_(Python)}}). 

Optimalerweise installieren wir auch gleich das Modul &lt;code&gt;numpy&lt;/code&gt; (Numerical Python). Wir werden es im Folgenden oft benötigen (nicht nur bei den Grafiken). Das funktioniert vom Prinzip her genauso, wie für &lt;code&gt;matplotlib&lt;/code&gt; gezeigt.

&lt;small&gt;Verwenden Sie Spyder, so sind diese Schritte nicht nötig. Spyder inkludiert diese Pakete standardmäßig. Unter openSUSE Tumbleweed lassen sich diese Pakete mittels YaST oder zypper installieren.&lt;/small&gt;

== 2D ==
=== Graph einer Funktion ===
Es soll die cosh-Funktion im Intervall &lt;math&gt;x\in[-3,3]&lt;/math&gt; gezeichnet werden. Der Programmcode lautet in der einfachsten Form:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x)
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:PythonIng_cosh1.jpg]]

Der Code ist quasi selbsterklärend. Das Untermodul pyplot des matplotlib-Moduls und das numpy-Modul werden importiert. x läuft von -3 bis +3. y wird für jeden x-Wert per Formel ausgerechnet. &quot;plt.plot()&quot; ist der Zeichenbefehl. &quot;plt.show&quot; ist notwendig, um das Fenster mit der Grafik anzuzeigen.
Die Schrittweite 0.1 wurde so gewählt, um einen ausreichend glatten Verlauf des Graphen zu gewährleisten. Das ist immer ein Kompromiss zwischen Berechnungszeit und Ansehnlichkeit. Testen Sie einfach ein paar verschiedene Werte, um ein Gefühl dafür zu zu bekommen. &quot;plt.grid()&quot; zeichnet ein Gitter in die Grafik (kann auch weggelassen werden).
Die Bezeichnungen plt und np könnten auch anders gewählt werden. Es ist aber Konvention, diese so wie hier gezeigt zu wählen. Die &quot;arange&quot;-Funktion aus der NumPy-Bibliothek wird später ein bisschen genauer behandelt (siehe [[Ing_Mathematik:_Python#Zahlenfolgen|Zahlenfolgen]]).  

&lt;small&gt;Mit der im obigen Bild gezeigten Menüleiste kann die dargestellte Grafik nachträglich noch geändert werden (Zoom, Pan, Achsenparameter, Kurvenparameter etc.). Natürlich kann man das alles auch direkt programmieren. Wie das funktioniert wird ansatzweise etwas später gezeigt.&lt;/small&gt;

Ein etwas komplexeres Beispiel ist Folgendes:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x) + 2**x
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:
[[Datei:PythonIng_cosh4.png]]

Man beachte, dass im Gegensatz zu Octave und Julia der ominöse Punkt (.) bei 2**x mit Python nicht benötigt wird. Das macht das Programmiererleben etwas einfacher.

Die Farbe des Graphen kann man über den &lt;code&gt;color&lt;/code&gt;-Schalter einstellen, z.B. auf rot setzen:
 plt.plot(x, y, color=&quot;red&quot;)

Das ist nur eine Möglichkeit, es gibt auch andere, z.B. mittels
* hexadezimaler Zahl, z.B. &lt;code&gt;color=&quot;#ff0000&quot;&lt;/code&gt;
* Kurzform, z.B. &lt;code&gt;&quot;r&quot;&lt;/code&gt;

Statt &lt;code&gt;color&lt;/code&gt; kann auch die Kurzform &lt;code&gt;c&lt;/code&gt; verwendet werden.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie diese &quot;Farbspielereien&quot; am Computer aus.

=== Graphen mehrerer Funktionen und weiteres ===
==== Mehrere Funktionen in einen Plot zeichnen ==== 
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh2.png]]

Um die Linienstile etwas individueller zu gestalten, ist folgender Programmcode gedacht: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;, lw=3, ls=&quot;--&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh3.png]]

Einige weitere Bespiele zu &lt;code&gt;ls&lt;/code&gt;&lt;/code&gt;:
* - ... durchgezogene Linie
* -. ... Strichpunkt-Linie
* dashed ... gestrichelte Linie 

==== Marker ====
Desweiteren kann man Marker verwenden.

Beispiel:

 import matplotlib.pyplot as plt
 
 plt.plot(10, 10, &quot;ob&quot;, markersize=30)
 plt.plot(20,20, &quot;.r&quot;)
 plt.plot(30,30, &quot;Dg&quot;, ms=15)
 plt.plot(40, 40, &quot;ok&quot;, ms=20, mec=&quot;#FF5733&quot;, mew=3)
 plt.plot(50, 50, &quot;vk&quot;, ms=20, mec=&quot;yellow&quot;, mew=3)
 plt.grid()
 plt.show()


Das erste Zeichen im String nach den Koordinaten im plot-Befehl symbolisiert die Form (z.B. o für einen Kreis). Das zweite Zeichen steht für die Farbe (z.B. b für blue). &lt;code&gt;markersize&lt;/code&gt; oder &lt;code&gt;ms&lt;/code&gt; setzt die Größe des Markers.

Ausgabe:

[[Bild:PythonIng_formatpara1.svg|200px]]

Einige weitere Marker:
* * ... Stern
* + ... Plus
* h oder H ... Sechseck

Man kann mit den Parametern 
* &lt;code&gt;markeredgecolor&lt;/code&gt; oder kurz &lt;code&gt;mec&lt;/code&gt; die Farbe des Markerrandes
* &lt;code&gt;markeredgewidth&lt;/code&gt; oder kurz &lt;code&gt;mew&lt;/code&gt; die Dicke des Randes
* &lt;code&gt;markerfacecolor&lt;/code&gt; oder kurz &lt;code&gt;mfc&lt;/code&gt; die Innenfarbe des Markers
bestimmen.

=== Funktion in Parameterdarstellung ===
Es soll die archimedische Spirale &lt;math&gt;x = t \cos(t), y = t  \sin(t)&lt;/math&gt; im Intervall &lt;math&gt;[0, 6\pi[&lt;/math&gt; gezeichnet werden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
  
 plt.show()

[[Datei:PythonIng_spirale1.png]]

Diese Darstellung erscheint verzerrt. Will man gleiche Achsenskalierungen, so kann man den plt.axis()-Befehl verwenden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
 plt.axis(&quot;equal&quot;)
 
 plt.show()
 
[[Datei:PythonIng_spirale2.png]]

=== Funktion in Polardarstellung ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 fig = plt.figure()
 ax = fig.add_subplot(projection=&quot;polar&quot;)
 r = np.arange(0, 1, 0.01)
 theta = r**3
 line = ax.plot(theta, r)
 
 plt.show()

[[Datei:PythonIng_polar1.png]]

=== Logarithmische Achsenskalierung ===
==== Semilog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.semilogy()
 plt.show()

Ausgabe:

[[Datei:PythonIng_semilog1.png]]

==== LogLog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.loglog()
 plt.show()

[[Datei:PythonIng_loglog1.png]]

=== Gefüllte Fläche ===
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.arange(0, 3, 0.1)
 
 y1 = 3*x - 1
 y2 = x**2
 
 plt.plot(x, y1, x, y2, color='black')
 plt.fill_between(x, y1, y2, where=y1&gt;=y2)
 
 plt.show()

[[Datei:PythonIng_gefuellt.png]]

=== Linien, Pfeile, Rechtecke, Kreise und Texte ===
 import matplotlib as mpl
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 r = mpl.patches.Rectangle((0, 0), 3, 3, angle=30, fill=False)
 c = mpl.patches.Circle((4, 4), 2, fill=False)
 
 ax.add_patch(r)
 ax.add_patch(c)
 ax.plot([-2, 7], [-2, 0], color=&quot;black&quot;)
 ax.arrow(0, 7, 5, 0, length_includes_head=True, head_width=0.5, head_length=1.5,
          color=&quot;black&quot;)
 
 ax.set_aspect(&quot;equal&quot;)
 
 plt.axis([-3, 8, -3, 8])
 plt.show() 

[[Datei:PythonIng_linien_pfeile_etc.png]]

Text kann mit &lt;code&gt;ax.text(x, y, &quot;Text&quot;)&lt;/code&gt; hinzugefügt werden, bspw.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 ax.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

Oder einfacher auch ohne &lt;code&gt;subplots&lt;/code&gt;

 import matplotlib.pyplot as plt
 
 plt.text(0.1, 0.1, &quot;Hallo&quot;)
 plt.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

[[Datei:PythonIng_text1.png]]

Auch Sonderzeichen (griechische Buchstaben etc.) können verwendet werden (siehe dazu auch [https://matplotlib.org/stable/users/explain/text/mathtext.html]).

 import matplotlib.pyplot as plt
 
 plt.text(.3, .5,
          r'$\Omega\ \psi\ \oint\ \nabla\ \dot a\ \frac{a}{b}\ a_b$',
          size=&quot;20&quot;)
 plt.show() 

[[Datei:PythonIng_text20.svg]]

Jetzt wird noch gezeigt, wofür &lt;code&gt;subplots&lt;/code&gt; sinnvoll eingesetzt werden können.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(0.1, 0.1, &quot;Hallo&quot;)
 ax[1].text(0.1, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
            rotation=30.0)
 
 plt.show()

[[Datei:PythonIng_text2.png]]

=== Anmerkungen hinzufügen ===
Anmerkungen (engl. annotations) lassen sich mit matplotlib einfach hinzufügen. Unter Anmerkung wird hier ein Pfeil mit Text verstanden.

Beispiel:

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 ax.plot([1,10], [1,10])
 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
             arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0))
 plt.show()

Ausgabe:

[[Datei: PythonIng_ann1.svg|400px]]

&lt;code&gt;shrink&lt;/code&gt; verkürzt den Pfeil. Sinnvoll sind beim obigen Beispiel Werte irgendwo zwischen 0.0 und 0.3.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie verschiedene Pfeillängen aus. 

Die Schriftgröße verändern können Sie übrigens mit &lt;code&gt;fontsize&lt;/code&gt; oder &lt;code&gt;size&lt;/code&gt;, z.B.

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0), fontsize=25)

Eine andere Schreibweise für Dictionaries, die wir weiter oben schon kennengelernt haben, die wir aber nochmals explizit aufschreiben wollen, ist

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops={&quot;facecolor&quot;:&quot;red&quot;, &quot;shrink&quot;:0.0})

=== Figure, Axes etc.===
[[Bild:PythonIng_figure33.svg|350px]]

* fig (figure) ... das übergeordnete Fenster
* ax (axes) ... &quot;Plot&quot;, das eigentliche Zeichenfenster
* axis ... die Koordinatenachsen
* spine ... Begrenzungslinien des Zeichenfensters
* tick ... Markierung an den Achsen des Zeichenfensters

Beispiel (eine figure mit 6 axes, ax-Titel, y-axis-Titel):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=3, ncols=2)
 
 ax[0][0].text(0.1, 0.5, &quot;11&quot;)
 ax[0][1].text(0.1, 0.5, &quot;12&quot;)
 ax[1][0].text(0.1, 0.5, &quot;21&quot;)
 ax[1][1].text(0.1, 0.5, &quot;22&quot;)
 ax[2][0].text(0.1, 0.5, &quot;31&quot;)
 ax[2][1].text(0.1, 0.5, &quot;32&quot;)
 
 ax[0][0].set(ylabel=&quot;y-label&quot;, title=&quot;axes 1&quot;)
 
 plt.show()

[[Bild:PythonIng_figure34.png|350px]]

Beispiel (Achsenbereiche setzen):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 
 ax[0].axis((-1, 10, 1, 12))
 
 plt.show()

[[Bild:PythonIng_figure35.svg|350px]]

Beispiel (Gitter einschalten): 

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 ax[0].axis((-5, 10, 1, 12))
 ax[0].minorticks_on()
 ax[0].grid(which='minor')
 ax[1].grid(which='major')
 plt.show()

[[Bild:PythonIng_figure36.svg|350px]]

Beispiel (ticks setzen)

 import matplotlib.pyplot as plt
 import matplotlib.ticker as tick
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 pos = [0, .2, .5]
 lab = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
 
 ax.xaxis.set_major_locator(tick.FixedLocator(pos))
 ax.xaxis.set_major_formatter(tick.FixedFormatter(lab))
 
 plt.show()

[[Bild:PythonIng_figure37.svg|350px]]

Beispiel (Achsenkreuz beliebig setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 ax.spines['top'].set_color('none')
 ax.spines['right'].set_color('none')
 ax.spines['bottom'].set_position(('data', 0.3))
 ax.spines['left'].set_position(('data', 0.5))
 
 plt.show()

[[Bild:PythonIng_figure38.svg|350px]]

Beispiel (Inset):

 import matplotlib.pyplot as plt
 
 # Hauptplot erstellen
 fig, ax = plt.subplots()
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 
 # Inset hinzu:
 axin = ax.inset_axes([0.4, 0.4, 0.3, 0.3])
 axin.text(0, 0, &quot;Servus&quot;)
 axin.plot()
 
 plt.show()

[[Bild:PythonIng_figure40.svg|350px]]

Beispiel (Hintergrundfarben setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.set_facecolor(&quot;green&quot;)
 fig.set_facecolor(&quot;yellow&quot;)
 
 plt.plot([1, 3], [6, 8])
 plt.show()

[[Bild:PythonIng_figure39.svg|300px]]

=== GridSpec ===
Mit figures und axes lassen sich schon jede Menge an Grafikdetails einstellen. GridSpec ist dann der Turbo oder Raketenantrieb den matplotlib eingebaut hat. Naja, vielleicht ist das etwas übertrieben, aber GridSpec ist sozusagen ein flexibler Layout-Manager. Bisher haben wir immer gleich große axes gezeichnet. Mit GridSpec können wir Subplots über mehrere Zeilen und Spalten ziehen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 gs = fig.add_gridspec(3, 3)
 
 ax1 = fig.add_subplot(gs[0, :])
 ax1.set_title(&quot;Bereich 1: gs[0, :]&quot;)
 
 ax2 = fig.add_subplot(gs[1:, 0])
 ax2.set_title(&quot;Bereich 2: gs[1:, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 1:])
 ax3.set_title(&quot;Bereich 3: gs[1, 1:]&quot;)
 
 ax4 = fig.add_subplot(gs[2, 1:])
 ax4.set_title(&quot;Bereich 4: gs[2, 1:]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec1.svg|350px]]

Erklärung zu &lt;code&gt;(gs[zeile, spalte])&lt;/code&gt;: Slicing; damit legen Sie fest, welche Zellen ein Subplot belegt. Achtung! Die Indizes beginnen bei 0 und nicht bei 1 (d.h., die erste Zeile/Spalte hat den Index 0)
* : ... alle 
* 1: ... 1 bis Ende
* etc.

&lt;code&gt;constrained_layout=True&lt;/code&gt; sorgt dafür, dass sich die Subplots nicht überlappen.

Aber auch die Spaltenbreiten und Zeilenhöhen lassen sich anpassen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 
 # Verhältnis erste zu zweite Zeile = 1.5:1
 # Verhältnis erste zu zweite Spalte  = 1:4
 gs = fig.add_gridspec(2, 2, figure=fig, height_ratios=[1.5, 1], width_ratios=[1, 4])
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax1.set_title(&quot;Bereich 1: gs[0, 0]&quot;)
 
 ax2 = fig.add_subplot(gs[0, 1])
 ax2.set_title(&quot;Bereich 2: gs[0, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 0])
 ax3.set_title(&quot;Bereich 3: gs[1, 0]&quot;)
 
 ax4 = fig.add_subplot(gs[1, 1:])
 ax4.set_title(&quot;Bereich 4: gs[1, 1]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec2.svg|350px]]

Auch die Ränder lassen sich einstellen.

Beispiel 1:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.1, right=0.9, bottom=0.1,
                        top=0.9, wspace=0.2, hspace=0.2)
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec3.svg|300px]]

* hspace ... height space, vertikaler Abstand zwischen den Zeilen
* wspace ... width space, horizontaler Abstand zwischen den Spalten

Und im Vergleich dazu Beispiel 2:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.3, right=0.7, bottom=0.3, 
                        top=0.7, wspace=0.3, hspace=0.3) 
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec4.svg|300px]]

Es gibt noch einige weitere Details, die sich mit GridSpec variieren lassen (z.B. SubGridSpec ... verschachtelte Grid-Layouts). Aber wir belassen es vorerst dabei. Das bisher Gezeigte sollte für die meisten Probleme ausreichend sein.

=== Aufgaben ===
* Zeichnen Sie die Strophoide &lt;math&gt;x = \frac{a(t^2-1)}{t^2+1}, y = \frac{at(t^2-1)}{t^2+1}, a = 2, -3 \leq t \leq 3&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_strophoide.jpg|300px|center]]

* Zeichnen Sie die verschlungene Hypozykloide &lt;math&gt;x = (R-r)\cos t + c\cos\frac{R-r}{r}t, y = (R-r)\sin t - c\sin\frac{R-r}{r}t, c = 3, r = 2, R = 6, -15 \leq t \leq 15&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_hypozykloide.jpg|300px|center]]

* Testen Sie bei den obigen Übungsaufgaben verschiedene Linienstile und Farben. Farben können mit dem plt.plot()-Parameter color gewählt werden.

* Testen Sie bei den obigen Übungsaufgaben verschiedene Werte für a, c, r und R.

* Zeichnen Sie folgendes Bild (die Achsenbeschriftungen positionieren Sie z.B. mit den Befehlen &lt;code&gt;ax.set_xlabel(&quot;x&quot;, loc=&quot;right&quot;); ax.set_ylabel(&quot;y&quot;, loc=&quot;top&quot;)&lt;/code&gt;):

[[Bild:PythonIng_aufgabe24.svg|400px|center]] 

* Zeichnen Sie mit Python, matplotlib und NumPy folgendes Bild:

[[Bild:PythonIng_figure41.svg|400px|center]]

* Zeichnen Sie mit GridSpec ein Layout, das in etwa wie folgendes aussieht (&lt;code&gt;height_ratios=[1, 2], width_ratios=[2, 1]&lt;/code&gt;):

[[Bild:PythonIng_aufgabe23.svg|300px|center]]

== 3D ==
=== Räumliche Kurven ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0, 6*np.pi, 0.1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 z = t
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot(x, y, z)
 
 plt.show()

[[Datei:PythonIng_raumkurve1.png]]

=== Flächen ===
 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche1.png]]

Das Ganze in Netzdarstellung läßt sich so programmieren: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.5)
 y = np.arange(0, 10, 0.5)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_wireframe(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche2.png]]

Ein etwas komplexeres Beispiel:

 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0.1, 10, 0.1)
 y = np.arange(0.1, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z1 = np.sin(x) + 3 * np.cos(y)
 z2 = np.sin(x) + np.log(y)
 z3 = x + np.cos(y)
 z4 = x**2 - y
  
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;}, nrows=2, ncols=2)
 
 ax[0][0].plot_surface(x, y, z1)
 ax[0][1].plot_surface(x, y, z2)
 ax[1][0].plot_surface(x, y, z3)
 ax[1][1].plot_surface(x, y, z4)
 
 plt.show()

[[Datei:PythonIng_subplot1.png]]

Man beachte, dass man die Unterbilder im Bild nach dem Ausführen des Scripts z.B. mit der mittleren Maustaste einzeln drehen, oder über die Einträge in der Menüzeile einzeln bearbeiten kann. Mit ein paar Zeilen Programmtext lässt sich also eine Menge an Funktionalität generieren.

Die Farbgebung lässt sich über &lt;code&gt;colormaps&lt;/code&gt; variieren.

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm)
 
 plt.show()

[[Datei:PythonIng_colormap1.png]]

Es gibt eine Menge an Colormaps, z.B. &lt;code&gt;plasma, Greys, Dark2, ocean&lt;/code&gt;. Zwecks detaillierterer Infos siehe die matplotlib-Dokumentation. &lt;small&gt;Verwendet man die IDE namens IDLE, so gibt es dort auch die automatische Codevervollständigung. D.h. es werden alle Möglichkeiten (in unserem Fall nach dem Eintippen von &lt;code&gt;cm.&lt;/code&gt; alle verfügbaren Colormaps) angezeigt.&lt;/small&gt;

Die &quot;edgecolor&quot; und Linienbreite können auch frei gewählt werden:

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm, edgecolor=&quot;black&quot;, linewidth=1.0)
 
 plt.show()

[[Datei:PythonIng_colormap2.png]]

=== Höhenlinien ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 ax.contour(x, y, z)
 
 plt.show()

[[Datei:PythonIng_höhenlinien1.png|400px]]

Etwas abgewandelt sieht das so aus: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contour(x, y, z)
 ax.clabel(hl, inline = True)
 
 plt.show()

[[Datei:PythonIng_höhenlinien2.png|400px]]

Und noch eine Variante (mit einem Farbbalken) sei gezeigt. 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contourf(x, y, z)
 fig.colorbar(hl) 
 
 plt.show()

[[Datei:PythonIng_höhenlinien5.svg|400px]]

=== Aufgaben ===
* Zeichnen Sie die räumliche Kurve &lt;math&gt;x = 2 \cdot \cosh(t)&lt;/math&gt;, &lt;math&gt;y = 5 \cdot \sin(t)&lt;/math&gt;, &lt;math&gt; z = t^{2} - t&lt;/math&gt;, &lt;math&gt;0 \leq t \leq 3\pi&lt;/math&gt;.
* Zeichnen Sie die Fläche &lt;math&gt;z = \log(x) + \cos(y)&lt;/math&gt;.

== Animationen und fortgeschrittenes 3D ==
=== Mit matplotlib ===
Auch mit matplotlib sind Animationen möglich. Das ist ein bisschen komplizierter und wird deshalb hier nur mit einem sehr einfachen Beispiel dargestellt (bei Interesse siehe z.B. auch das [https://matplotlib.org/stable/users/explain/animations/animations.html#animations Animations using Matplotlib-Tutorial]).

 import matplotlib.pyplot as plt
 import matplotlib.animation as ani
 import matplotlib
 import numpy as np
 
 def update(frame):
     line.set_xdata(x[:frame])
     line.set_ydata(y[:frame])
     return (line)
 
 fig, ax = plt.subplots()
 
 x = np.arange(0, 10, .1)
 y = np.sin(x)
 
 line, = ax.plot(x[0], y[0])
 ax.set(xlim=[0, 10], ylim=[-1, 1])
 
 a = ani.FuncAnimation(fig=fig, func=update, frames=100, interval=20)
 plt.show()
 
 # Speichere die Animation in einem animierten GIF (optional)
 a.save(filename=&quot;c:/tmp/PythonIng_anim5.gif&quot;, writer=&quot;pillow&quot;)

[[Datei:PythonIng_anim5.gif]]

Es wird eine Sinuskurve auf den Bildschirm gezeichnet. In der letzten Zeile wird diese Animation in ein animiertes GIF gespeichert. Das ist natürlich optional und kann auch weggelassen werden.

=== Mit VPython ===
Aber auch mit dem Modul VPython lassen sich einfache 3D-Animationen erstellen. VPython ist ein externes Modul, das vorab installiert werden muss. Unter openSUSE Tumbleweed gibt es dzt. kein entsprechendes rpm-Paket. Die übliche Methode der Installation mittels YaST oder zypper ist somit nicht möglich. Auch eine direkte Verwendung von pip führt nur zu einer Fehlermeldung (&lt;code&gt;error: externally-managed-environment&lt;/code&gt;). Es empfiehlt sich dort folgende Vorgehensweise:
# Erstelle zuerst eine virtuelle Umgebung, z.B.: &lt;code&gt;python3.11 -m venv ~/tmp/venv1&lt;/code&gt;
# Wechsle das Verzeichnis: &lt;code&gt;cd ~/tmp/venv1/bin&lt;/code&gt;
# Installiere das entsprechende Paket: &lt;code&gt;./pip install vpython&lt;/code&gt;
# Führe das entsprechende Skript aus: &lt;code&gt;./python ~/tmp/test1.py&lt;/code&gt;

Aktuell (März 2026) ist dieses Programmpaket lt. der [https://vpython.org/presentation2018/install.html VPython-Homepage] nur für die Python-Versionen 3.8 bis 3.12 verfügbar.

Ein Beispiel zu einer einfachen Animation wird nachfolgend geliefert.

 from vpython import *
 
 scene.width = 1200
 scene.height = 600
 scene.center = vector(20,0,0)
 scene.background = color.white
 
 cylinder(pos=vector(0,0,0), axis=vector(20,0,0), radius=5, 
         color=color.blue)
 cone(pos=vector(0,0,0), axis=vector(-10,0,0), radius=5, 
         color=color.blue)
 helix(pos=vector(20,0,0), axis=vector(40,0,0), radius=2, 
         coils=10, thickness=0.5, color=color.blue)
 
 ball = sphere(pos=vector(20,0,0), color = color.green, radius = 1)
 ball.p = vector(0.15, 0, 0)
 
 toc = True
 
 while True:
     rate(200)
     if(ball.pos.x &lt;= 60 and toc == True):
         ball.pos += ball.p
     else:
         toc = False
         ball.pos -= ball.p
         if(ball.pos.x &lt;= 20 and toc == False):
             toc = True

[[Datei:PythonIng_vpython_anim.JPG]]

Idealerweise öffnet sich beim Ausführen des Scripts ein Browserfenster. Darin wird die programmierte Animation gezeigt (siehe auch den obigen Screenshot). Eine Größenänderung können Sie mit der mittleren Maustaste initiieren. Die Szenerie drehen können Sie mit der rechten Maustaste.

=== Mit build123d ===
Hiermit lassen sich einfach 3D-Modelle für CAD-Systeme erstellen. [https://build123d.readthedocs.io/en/latest/ build123d] ist ein externes Modul und muss vorab, wie schon für mehrere andere Module gezeigt, installiert werden (pip, venv etc.).

Beispielcode:

 from build123d import *
 
 # Bauteil
 with BuildPart() as bauteil: 
     # Zylinder erstellen
     Cylinder(100, 60)
        
     # Bohrung
     with BuildSketch(bauteil.faces().sort_by(Axis.Z)[-1]) as loch:
         Circle(radius=10)
     # negativ extrudieren
     extrude(amount=-60, mode=Mode.SUBTRACT)
     
     # Dem Bauteil z.B. die Farbe rot zuweisen
     # bauteil.part.color = Color(&quot;red&quot;, alpha=1.0)
 
     # Fertiges Modell exportieren
     export_step(bauteil.part, &quot;bauteil.step&quot;)

Ausgabe ({{W|Standard for the exchange of product model data | STEP}}-Datei, z.B. in {{W|FreeCAD}} importiert, Screenshot):

[[Datei:PythonIng_build123d.jpg | 300px]]

FreeCAD ist ein freies 3D-CAD-System. Die [[Ing_Mathematik:_Python#FreeCAD | Makroprogrammierung]] in diesem System wird später noch gezeigt. STEP steht für &quot;'''St'''andard for the '''e'''xchange of '''p'''roduct model data&quot; und ist ein Datenaustauschformat.

=== Mit VTK ===
Komplexer, aber auch mächtiger als VPython ist die Verwendung von VTK ('''V'''isualization '''T'''ool'''k'''it). Genauer gesagt des Python-Wrappers von VTK. Dieses externe Python-Modul muss vorab installiert werden (z.B. mittels YaST, pip oder in eine virtuelle Umgebung). VTK ist eine Softwarebibliothek zur 3D-Visualisierung und wurde ursprünglich in C++ geschrieben. Verbreitet eingesetzt wird diese Bibliothek in der Wissenschaft und Forschung, z.B. 
* in der medizinischen Bildgebung
* für Strömungssimulationen
* für Klimadaten

VTK funktioniert nach dem {{W|Grafikpipeline|Pipeline-Prinzip}}:

 Source (Quellen) -&gt;  Filter -&gt; Mapper (Senken) -&gt; Actor/Renderer

Daten fließen von den Quellen zu den Senken.

Als einfaches Beispiel wird die Darstellung eines Zylinders gezeigt, der mit den Maustasten gedreht oder in der Größe geändert werden kann:

 import vtk
 
 # Zylinder erzeugen
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 # Geometrie in darstellbare Daten umwandeln
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 # Objekt in der Szene
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 # Szene verwalten
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 # Render-Fenster
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 # Maus/Tastatur-Steuerung
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 # Starten
 render_window.Render()
 interactor.Start()

Ausgabe:

[[Datei:PythonIng_VTK_1.png]]

Gleiches Beispiel wie oben, aber mit einer Animationssequenz:

 import vtk
 import time
 
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     render_window.Render()
     time.sleep(0.01)

Das Grafikfenster schließt sich nach Ablauf der Schleife. Das Fenster bleibt geöffnet, wenn Sie am Programmende folgenden Befehl hinschreiben

 interactor.Start()

Um den animierten Zylinder grün einzufärben, müssen Sie Folgendes im obigen Programm ergänzen (Farbnamen):

 colors = vtk.vtkNamedColors()
 actor.GetProperty().SetColor(colors.GetColor3d(&quot;Green&quot;))

Als Namen können Sie u.a. die CSS3 Web-Farben verwenden (siehe z.B. [https://wiki.selfhtml.org/wiki/Farbe/Farbangaben] und {{W|Webfarbe#CSS_3}}).

Alternativ funktioniert auch das ({{W|RGB-Farbraum|RGB}}):

 actor.GetProperty().SetColor(0.0, 0.6, 0.0)

Wie der Zylinder mit einer Textur versehen wird, zeigt folgendes Programm:

 import vtk
 import time
 
 cylinder = vtk.vtkCylinderSource()
 cylinder.SetResolution(30)
 cylinder.SetHeight(3.0)
 cylinder.SetRadius(1.0)
 cylinder.CappingOn()
 
 texture_coords = vtk.vtkTextureMapToCylinder()
 texture_coords.SetInputConnection(cylinder.GetOutputPort())
 texture_coords.PreventSeamOn()
 
 reader = vtk.vtkJPEGReader()
 reader.SetFileName(&quot;PythonIng_textur.jpg&quot;)
 
 texture = vtk.vtkTexture()
 texture.SetInputConnection(reader.GetOutputPort()) 
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(texture_coords.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 actor.SetTexture(texture)
 
 renderer = vtk.vtkRenderer()
 renderWindow = vtk.vtkRenderWindow()
 renderWindow.AddRenderer(renderer)
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(renderWindow)
 
 renderer.AddActor(actor)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     renderWindow.Render()
     time.sleep(0.01)
 
 interactor.Start()

&lt;gallery&gt;
PythonIng_textur.jpg | Textur-Datei
PythonIng_VTK_2.png | Ausgabe (Screenshot)
&lt;/gallery&gt;

== Sonstige Grafikbibliotheken ==
=== Py5 ===
Im Buch ''Iacono et al.: Programmieren trainieren, mit über 150 Workouts in Java und Python; 3. Aufl., Hanser, 2023'' werden zahlreiche Aufgaben gestellt, die u.a. mit Processing zu lösen sind.  Processing ist eine einfache Programmiersprache und Entwicklungsumgebung. Warum ich das erwähne? Weil in älteren Processing-Versionen auch die Programmiersprache Python 2 abgedeckt war. Bei neueren Versionen gibt es keine Python-Anbindung mehr (getestet nur mit openSUSE Tumbleweed und Python 3). Somit funktioniert der Python-Teil im genannten Buch zum Teil nicht mehr. Ist das tragisch, oder kann das Buch weggeschmissen werden? Nein! Es gibt Alternativen zu Processing. Zum einen die im Buch selbst genannten Bibliotheken tkinter oder pygame. Pygame wird dort auch kurz anhand eines Beispiels thematisiert. Aber noch besser ist es, die py5-Bibliothek zu verwenden (lt. Google KI vom 30. Sept. 2026: ''Der echte, moderne „spirituelle Nachfolger“''). Damit ist die Funktionalität von Processing gewährleistet. Man kann aber beliebige Editoren oder IDEs zur Programmerstellung verwenden, ohne an Processing als IDE gebunden zu sein. Nachfolgend werden ein paar Beispiele zu dieser externen Bibliothek gegeben. Der erste Schritt ist wieder, die py5-Bibliothek zu installieren (z.B. mittels pip in eine virtuelle Umgebung; Python&gt;=3.10 und ein JDK&gt;=17 müssen auch installiert sein (Stand Okt. 2026)). Dann kann es schon mit dem Programmieren losgehen.

Beispiel (angelehnt an die ''Aufgabe W.2.3 Haus'' des genannten Buchs, jedoch etwas erweitert):

 import py5
 
 def setup():
     py5.size(600, 600)            # Fenstergröße 600px x 600px 
     py5.background(255, 255, 255) # Hintergrundfarbe ... weiss
     
 def draw():
     # Haus zeichnen
     py5.fill(255, 255, 255)       # Hintergrundfarbe ... weiss
     py5.stroke(255, 0, 0)         # Linienfarbe ... rot 
     py5.stroke_weight(3)          # Linienbreite ... 3px
     py5.rect(150, 200, 300, 300)  # Rechteck zeichnen (x, y, b, h)
     py5.triangle(150, 200, 300, 100, 450, 200) # Dreieck zeichnen
     py5.circle(250, 300, 70)      # Kreis zeichnen (x, y, d)   
     
     # Bemassung zeichnen
     py5.stroke(0, 255, 0)
     py5.stroke_weight(1)
     py5.line(300, 100, 550, 100)  # Linie zeichnen
     py5.line(450, 200, 550, 200) 
     py5.line(450, 500, 550, 500) 
     py5.line(150, 500, 150, 550)
     py5.line(450, 500, 450, 550)
     py5.text_size(20)             # Textgroesse
     py5.fill(0, 255, 0)           # Textfarbe
     py5.text(&quot;300&quot;, 280, 550)     # Text zeichnen
     py5.text(&quot;100&quot;, 500, 150)
     py5.text(&quot;300&quot;, 500, 350)  
 
     # Gedrehtes Rechteck zeichnen
     py5.stroke(255, 255, 0)
     py5.stroke_weight(3)
     py5.fill(200, 200, 200) 
     py5.translate(320, 260)  
     py5.rotate(0.3)               # Drehung (in Radiant)
     py5.rect(0, 0, 100, 50)
 
 # Startet den Sketch
 py5.run_sketch()


Ausgabe:

[[Datei:PythonIng_py5_1.png|300px]]

Das skizzierte Haus ist mit einer rudimentären Bemaßung versehen und hat zwei Fenster, ein rundes und ein gedrehtes, trübes rechteckiges. 

Beispiel (Mausoperationen):

 import py5
 
 def setup():
     py5.size(600, 600)            
     py5.background(255, 255, 255)
 
 def draw():
     pass
    
 def mouse_pressed():
     py5.text_size(15) 
     py5.fill(0, 0, 255)
     x = py5.mouse_x
     y = py5.mouse_y
     py5.text(&quot;(%d, %d)&quot; %(x, y), x, y) # Positionsdaten bei Maus-Klick schreiben
 
 py5.run_sketch()

Ausgabe:

[[Datei:PythonIng_py5_2.png|300px]]

Obiges Bild zeigt das Resultat nach einigen Mausklicks. Man erkennt, dass links-oben der Koordinatennullpunkt ist. Die x-Achse zeigt nach rechts, die y-Achse nach unten.

Beispiel (Fünfeck):

 import py5
 import random 
 
 def setup():
     py5.size(400, 400)
     py5.no_loop()       # statisches Bild (schont die Ressourcen)
 
 def draw():
     py5.translate(py5.width / 2, py5.height / 2)  # KS setzen
 
     radius = 150
     eck_anzahl = 5
 
     py5.fill(random.randint(0, 255), random.randint(0, 255), 
              random.randint(0, 255))    # Füllfarbe auf Zufallswert setzen
     py5.stroke(155, 0, 0)            
     py5.stroke_weight(5)     
     
     # Fünfeck als Polygon zeichnen
     py5.begin_shape()
     for i in range(eck_anzahl):
         winkel = i * py5.TWO_PI / eck_anzahl - py5.HALF_PI
         x = py5.cos(winkel) * radius
         y = py5.sin(winkel) * radius
         py5.vertex(x, y)
     py5.end_shape(py5.CLOSE)
 
 py5.run_sketch()

Ausgabe, bspw.:

[[Datei:PythonIng_py5_5.png|200px]]

&lt;u&gt;Kleine Aufgaben:&lt;/u&gt;
* Um die Funktionsweise von &lt;code&gt;py5.no_loop()&lt;/code&gt; zu verstehen, kommentieren Sie die Anweisung im Beispiel einfach aus, und starten Sie das Programm erneut.
* Zeichnen Sie ein Siebeneck.
* Was passiert, wenn man &lt;code&gt;py5.CLOSE&lt;/code&gt; im &lt;code&gt;py5.end_shape()&lt;/code&gt;-Befehl weglässt?

Beispiel (Grafik laden und zeichnen):

 import py5
 
 image1 = None
 
 def setup():
     global image1
     py5.size(600, 600)
     py5.no_loop()
     image1 = py5.load_image(&quot;PythonIng_py5_1.png&quot;)
 
 def draw():
     py5.image(image1, 0, 0)
 
 py5.run_sketch()

Hier wird einfach das Bild vom Haus-Beispiel (Screenshot von weiter oben) geladen und gezeichnet.

Beispiel (angelehnt an ''W.5.10 Wurfparabel'' des genannten Buches; mit OOP erstellt):

 import py5
 
 class Wurfparabel(py5.Sketch):
     def __init__(self, v0, angle):
         super().__init__()
         self.v0 = v0
         self.angle = self.radians(angle)
         self.g = 9.81
         self.t = 0.0
         self.scale = 1.5
 
     def settings(self):
         self.size(800, 600)
 
     def setup(self):        
         self.background(0, 0, 0)
         
     def draw(self):
         self.t += 0.1
 
         self.translate(50, 500)
       
         # KS Zeichnen
         self.fill(255, 255, 0)
         self.stroke(255, 255, 0)
         self.stroke_weight(1)
         self.line(0, 0, 0, -300)
         self.line(0, 0, 700, 0)
 
         # Punkt zeichnen
         cx = self.v0 * self.cos(self.angle) * self.t * self.scale
         cy = -(self.v0 * self.sin(self.angle) * self.t - \
                self.g/2 * self.t**2) * self.scale
         self.fill(255, 0, 0)
         self.stroke(255, 0, 0)
         self.circle(cx, cy, 3)
        
         # Stoppen bei Bodenkontakt
         if cy &gt;= -5:
             self.no_loop()
            
 def wurfparabel(v0=50, angle=45):
     sketch = Wurfparabel(v0, angle)
     sketch.run_sketch()
 
 v0 = float(input(&quot;v0 = &quot;))
 winkel = float(input(&quot;winkel = &quot;))
 wurfparabel(v0=v0, angle=winkel)

Eingabe auf der Konsole:

 v0 = 60
 winkel = 45

Ausgabe:

[[Datei:PythonIng_py5_13.png|200px]]

Die benötigten Formeln der Bewegungsgleichung kann man leicht herleiten, bzw. man benutzt folgende Grafik als Hilfestellung:

[[Datei:Wurfparabel_Zusammenfassung_aktualisierung.png|700px]]

&lt;u&gt;Aufgabe:&lt;/u&gt; Berechnen Sie den Scheitelpunkt und die Wurfweite bei gegebener Anfangsgeschwindigkeit und gegebenem Abwurfwinkel. Die Abwurfhöhe &lt;math&gt;y_0&lt;/math&gt; sei 0. Der Wurf soll auf der Erde stattfinden (g = 9.81 m/s²). Die dazu benötigten Formeln können aus obiger Grafik entnommen werden (oder Sie leiten sie selbst her). Geben Sie die Ergebnisse auf der Konsole aus.

Beispiel (eine einfache Animation):

 import py5
 
 i = 0
 
 def setup():
     py5.size(600, 600)
     py5.frame_rate(5)
     py5.stroke_weight(20)
 
 def draw():
     global i
     
     py5.background(255, 255, 255)
     py5.translate(py5.width/2, py5.height/2)
     py5.rotate(py5.PI/8 * i)    
 
     py5.line(-100, 0, 100, 0)
     i += 1
 
 py5.run_sketch()

Es wird eine rotierende Linie gezeichnet (z.B. wie bei einem Installationsprozess verwendet - zeigt an, dass der Installationsfortschritt nicht eingefroren ist). Hierbei ist nur aufzupassen, dass der Hintergrund in &lt;code&gt;draw()&lt;/code&gt; gesetzt wird, ansonsten würden die Linien additiv gezeichnet. Das ist zwar auch schön, aber eben nicht das gewünschte Resultat.

Hiermit belassen wir es mit der py5-Bibliothek und wenden uns wieder &quot;mathematischeren&quot; Themen zu.

=== Bokeh ===
Mit Bokeh kann man interaktive Datenvisualisierungen für Webbrowser in Python erstellen. Bokeh ist eine externe Bibliokek, die vorab installiert werden muss (z.B. mittel YaST oder pip).

Python-Code:

 from bokeh.plotting import figure, output_file, show
 
 x = [1, 2, 3, 4, 5, 6]
 y = [10, 5, 6, 8, 9, 11]
 
 output_file(&quot;interpolation.html&quot;) 
 
 p = figure(
     title=&quot;Interpolation&quot;,
     x_axis_label=&quot;x&quot;,
     y_axis_label=&quot;y&quot;,
 )
 
 p.line(x, y, legend_label=&quot;Interpolierende&quot;, line_width=2, color=&quot;blue&quot;)
 p.scatter(x, y, legend_label=&quot;Stützpunkte&quot;, size=7, color=&quot;orange&quot;)
 p.legend.location = &quot;top_left&quot;
 
 show(p)

Ausgabe:

[[File:PythonIng_bokeh1.png|300px]]

Python-Code (angelehnt an ein Beispiel aus der Bokeh-Dokumentation, aber wesentlich gekürzt
und vereinfacht):

 from bokeh.layouts import layout
 from bokeh.models import Spinner
 from bokeh.plotting import figure, show
 
 x = [1, 2, 3, 4, 5]
 y = [2, 7, 3, 6, 4] 
 
 p = figure(x_range=(1, 5), width=500, height=350)
 points = p.scatter(x=x, y=y, size=30, fill_color=&quot;blue&quot;)
 
 spinner = Spinner(
     title=&quot;Kreisgröße&quot;,
     low=0,
     high=60,
     step=5,
     value=points.glyph.size,
     width=200,
 )
 spinner.js_link(&quot;value&quot;, points.glyph, &quot;size&quot;)
 
 layout = layout(
     [
         [spinner],
         [p],
     ],
 )
 
 show(layout)

Ausgabe:

[[File:PythonIng_bokeh2.png|300px]]

Die Dokumentation zu Bokeh findet sich auf [https://docs.bokeh.org/en/latest/]

= Vektoren und Matrizen =
== Zahlenfolgen ==
Für das Erstellen von Zahlenfolgen bieten sich die Funktionen &lt;code&gt;arange&lt;/code&gt; und &lt;code&gt;linspace&lt;/code&gt; aus dem &lt;code&gt;numpy&lt;/code&gt;-Modul an.

 from numpy import *
 
 start = 0
 stop = 10
 step = 2
 num = 10
 
 r = arange(start, stop, step)   # step ... Schrittweite
 l = linspace(start, stop, num)  # num ... Anzahl der Werte
 
 print(&quot;r = &quot;, r)
 print(&quot;l = &quot;, l)

Ausgabe:
 r =  [0 2 4 6 8]
 l =  [ 0.          1.11111111  2.22222222  3.33333333  4.44444444  5.55555556
   6.66666667  7.77777778  8.88888889 10.        ]

Bei &lt;code&gt;arange&lt;/code&gt; ist der &lt;code&gt;stop&lt;/code&gt;-Wert nicht im Ergebnis enthalten, bei &lt;code&gt;linspace&lt;/code&gt; standardmäßig aber sehr wohl. Jedoch kann man das bei &lt;code&gt;linspace&lt;/code&gt; auch ändern. Dann ist der Stoppwert nicht mehr enthalten: 

 linspace(start, stop, num, endpoint=False)

== Vektoren ==
Vektoren sollten jedem aus der Linearen Algebra bekannt sein. 

=== Arrays ===
In Python mit NumPy kann man Vektoren durch die Funktion array erzeugen.

 import numpy as np
 
 l1 = (-5, 3, 2)
 l2 = (1, 1, 4)
 
 a1 = np.array(l1)
 a2 = np.array(l2)
 
 a3 = a1 + a2
 a4 = 2 * a2
 
 print(a1)
 print(a2)
 print(a3)
 print(a3[2])
 print(a4)

Ausgabe:
 [-5  3  2]
 [1 1 4]
 [-4  4  6]
 6
 [2 2 8]

=== Zeilen- und Spaltenvektoren ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 print(z)
 print(s)

Ausgabe:
 [ [-5  3  2] ]
 [[1]
  [1]
  [4]]

=== Skalarprodukt ===
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4))
 
 skalarprodukt = np.dot(a1, a2)  
 
 print(skalarprodukt)

Ausgabe:
 6

=== Vektorprodukt ===
&lt;math&gt;a\ast b=\left(\begin{array}{c}
a_{1}\\
a_{2}\\
a_{3}
\end{array}\right)\ast\left(\begin{array}{c}
b_{1}\\
b_{2}\\
b_{3}
\end{array}\right)=\left(\begin{array}{c}
a_{2}b_{3}-a_{3}b_{2}\\
a_{3}b_{1}-a_{1}b_{3}\\
a_{1}b_{2}-a_{2}b_{1}
\end{array}\right)
&lt;/math&gt; 

Python-Code:
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4)) 
 
 vektorprodukt = np.cross(a1, a2) 
 
 print(vektorprodukt)

Ausgabe:
 [10 22 -8]

=== Transponierter Vektor ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 # transponierter Vektor
 z_tp = np.transpose(z)
 # transponierter Vektor
 s_tp = np.transpose(s)
 
 print(z_tp)
 print(s_tp)

Ausgabe:
 [[-5]
  [ 3]
  [ 2]]
 [ [1 1 4] ]

=== Vektorfelder visualisieren ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 # Daten generieren
 x = np.arange(0, 10, 1)
 y = np.arange(0, 10, 1)
 X, Y = np.meshgrid(x, y)
 U = X * Y
 V = Y + X
 
 # Plotten
 fig, ax = plt.subplots()
 
 ax.quiver(X, Y, U, V, angles='xy')
 
 plt.show()

Ausgabe:

[[Datei:PythonIng_quiver1.png]]

== Matrizen==
 import numpy as np
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 print(m1)

Ausgabe:
 [[1 2 3]
  [4 5 6]]

=== Zugriff auf Matrizenelemente ===
Beispiel:

 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 
 # Element aus Zeile 2 und Spalte 3 (Achtung! Index startet bei Null)
 print(m1[1,2])

Ausgabe:
 6

Visualisierung:
  
     0   1   2
   +-----------+
 0 | 1 | 2 | 3 |
   +-----------+
 1 | 4 | 5 | '''6''' |
   +-----------+


Beispiel:

 import numpy as np
 
 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
 
 B = np.matrix(A)     
 
 print(B[2::, ::2])

Ausgabe:

 [['20' '22']
  ['30' '32']
  ['40' '42']]

Mit der NumPy-Bibliothek funktioniert das zweidimensionale Slicing. Mit normalen Listen/Tupels geht das nicht, was wir schon früher thematisiert haben.

=== Addition und Subtraktion von Matrizen ===
 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 m2 = np.matrix([[0, 0, 2], [1, 3, 2]])
 
 print(m1 + m2)
 print(m1 - m2)

Ausgabe:
 [[1 2 5]
  [5 8 8]]
 [[1 2 1]
  [3 2 4]]

=== Transponierte Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 2, 3], [4, 5, 6]])
 mt = np.transpose(m) 
 
 print(m)
 print(mt)

Ausgabe:
 [[1 2 3]
  [4 5 6]]
 [[1 4]
  [2 5]
  [3 6]]

=== Rang einer Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 rg = np.linalg.matrix_rank(m)
 
 print(rg)

Ausgabe:
 2

=== Inverse Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 mi = np.linalg.inv(m)
 
 print(mi)

Ausgabe:
 [[ 1.   0.6]
  [-0.  -0.2]]

=== Multiplikation von Matrizen (falksches Schema) ===
 import numpy as np
 
 m1 = np.matrix([[1, 3, 4],  [0, -5, 1]])
 m2 = np.matrix([[1, 2], [2, 3], [0, 2]])
 
 print(m1 @ m2)

Ausgabe:
 [[  7  19]
  [-10 -13]]

=== Eigenwerte und Eigenvektoren ===
 import numpy as np
 
 m = np.matrix([[5, 8],  [1, 3]])
 D,V = np.linalg.eig(m)
 
 # Eigenwerte
 print(D)
 # Eigenvektoren
 print(V)

Ausgabe:
 [7. 1.]
 [[ 0.9701425  -0.89442719]
  [ 0.24253563  0.4472136 ]]

=== Teilmatrizen ===
 import numpy as np
 m = np.matrix([[1, 3, 4],  [0, -5, 1]])
 print(&quot;m = &quot;, m)
 
 # Erste Zeile extrahieren
 m1 = m[0,:]
 print(&quot;m1 = &quot;, m1)
 
 # Das Element aus der 1. Zeile und der 2. Spalte extrahieren
 m2 = m[0,1]
 print(&quot;m2 = &quot;, m2)
 
 # Zweite Spalte extrahieren
 m3 = m[:, 1]
 print(&quot;m3 = &quot;, m3)

Ausgabe:
 m =  [[ 1  3  4]
  [ 0 -5  1]]
 m1 =  [ [1 3 4] ]
 m2 =  3
 m3 =  [[ 3]
  [-5]]

=== Spezielle Matrizen ===
==== Nullmatrix ====
 import numpy as np
 z = np.zeros((3, 2))
 print(z)

Ausgabe:
 [[0. 0.]
  [0. 0.]
  [0. 0.]]

==== Einheitsmatrix ====
 import numpy as np
 z = np.eye(3)
 print(z)

Ausgabe:
 [[1. 0. 0.]
  [0. 1. 0.]
  [0. 0. 1.]]

==== Matrix mit lauter Einsen ====
 import numpy as np
 z = np.ones((3, 2))
 print(z)

Ausgabe:
 [[1. 1.]
  [1. 1.]
  [1. 1.]]

=== Spärlich besetzte Matrizen ===
Das Thema spärlich besetzter Matrizen wird hier nur kurz angerissen. Nähere Details siehe unter dem Weblink  [https://docs.scipy.org/doc/scipy/reference/sparse.html#module-scipy.sparse]. 

Beispiel:

 import numpy as np
 import scipy
 
 A = scipy.sparse.csr_array(np.eye(5))
 
 print(A)

Ausgabe:
 &lt;Compressed Sparse Row sparse array of dtype 'float64'
         with 5 stored elements and shape (5, 5)&gt;
   Coords        Values
   (0, 0)        1.0
   (1, 1)        1.0
   (2, 2)        1.0
   (3, 3)        1.0
   (4, 4)        1.0

csr steht für '''c'''ompressed '''s'''parse '''r'''ow.

Andere Möglichkeiten:
* coo-Format ('''coo'''rdinate Format): &lt;code&gt;scipy.sparse.coo_array()&lt;/code&gt;
* lil-Format ('''li'''st of '''l'''ists): &lt;code&gt;scipy.sparse.lil_array()&lt;/code&gt;
* csc-Format ('''c'''ompressed '''s'''parse '''c'''olumn): &lt;code&gt;scipy.sparse.csc_array()&lt;/code&gt;

Es gibt auch &lt;code&gt;scipy.sparse.csr_matrix()&lt;/code&gt; etc. Diese Befehle sind aber veraltet und es wird empfohlen, statt dessen die &lt;code&gt;..._array()&lt;/code&gt;-Funktionen zu verwenden.

&lt;u&gt;Aufgaben:&lt;/u&gt; 
Recherchieren Sie im Internet 
* generell zum Thema &quot;spärlich besetzte Matrizen mit Python&quot;.
* Was sind die Vor-/Nachteile von csr-arrays gegenüber coo- und lil-arrays?
* Wann verwendet man sinnvollerweise csr- und wann csc-arrays?
* Wie wandelt man coo-arrays in csr-arrays um?

= Lineare Gleichungssysteme =
Sei &lt;math&gt;Ax = b&lt;/math&gt; ein lineares Gleichungssystem. &lt;math&gt;A&lt;/math&gt; sei die Koeffizientenmatrix, &lt;math&gt;x&lt;/math&gt; der Lösungsvektor und &lt;math&gt;b&lt;/math&gt; ein bekannter Vektor.

Beispiel:
 import numpy as np
 
 A = np.array([[5, 1], [0, 2]])
 b = np.array([1, 2])
 
 x = np.linalg.solve(A, b)
 
 print(x)

Ausgabe:
 [0. 1.]

Siehe dazu auch das Kapitel [[Ing Mathematik: Numerisches Lösen von linearen Gleichungssystemen]]. Dort wird dieses Themengebiet u.a. mit weitergehenden Python-Skripten vertieft.

== Aufgabe ==
* Lösen Sie folgendes Gleichungssystem mittels Python (und zur Kontrolle auch händisch): 
 5x + 6y - 2z = 12
 3x - y  - 3z = 6
 2x + 2y + 4z = 5

= Polynome =
== Ein erstes einfaches Beispiel ==
Gegeben sei das Polynom &lt;math&gt;7x^3+5x^2+1&lt;/math&gt;. In Python:

 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p)

Ausgabe:
    3     2
 7 x + 5 x + 1

== Einzelne Polynomwerte berechnen ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p(1.5))

Ausgabe:
 35.875

== Polynome integrieren und differenzieren ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 
 # 1. Ableitung
 p1 = p.deriv()
 p2 = p.deriv(1)
 
 # 2. Ableitung
 p3 = p.deriv(2)
 
 # Integral
 p4 = p.integ()
 
 print(p1)
 print(p2)
 print(p3)
 print(p4)

Ausgabe:
     2
 21 x + 10 x
     2
 21 x + 10 x
 
 42 x + 10
       4         3
 1.75 x + 1.667 x + 1 x

== Nullstellen bestimmen ==
 import numpy as np
 
 p = np.poly1d([2, 5, 0, 4])
 r = np.roots(p)
 
 print(r)

Ausgabe:
 [-2.7621427 +0.j          0.13107135+0.84077099j  0.13107135-0.84077099j]

== Aufgaben ==
* Berechnen Sie den Wert für x = 3 des Polynoms &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Differenzieren und integrieren Sie das Polynom &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Berechnen Sie die Nullstellen von &lt;math&gt;y = 7x^5 - 3x^2 + 12&lt;/math&gt;.

= Nichtlineare Gleichungen und Gleichungssysteme =
== Nullstellenbestimmung ==
Löse eine beliebige Gleichung f(x) = 0, z.B. &lt;math&gt; f(x) = x^2 - 5\cos(x) - 10 = 0 &lt;/math&gt;:
 import scipy
 import numpy as np
 
 def f(x):
     return x**2 - 5*np.cos(x) - 10
    
 xstart = [-1, 1]        # Startwerte
 xn = scipy.optimize.root(f, xstart)
 
 print(xn.x)

Ausgabe:
 [-2.46813009  2.46813009]

Funktionsgraph:

[[Datei:octave_nichtlin2.jpg]]

== Gleichungssysteme ==
SymPy ist ein externes Modul, das symbolisches Rechnen ('''Sym'''bolic '''Py'''thon) ermöglicht. 

Folgende Aufgabe ist dem Buch &quot;Knorrenschild: Numerische Mathematik, Hanser, 2017, Seite 72&quot; entnommen. Zu lösen ist das nichtlineare Gleichungssystem

&lt;math&gt;f_1 = 2x_1 + 4x_2 = 0 &lt;/math&gt;

&lt;math&gt;f_2 = 4x_1 + 8x_2^3 = 0&lt;/math&gt;

Mit Python ist das so möglich:
 import sympy
 
 x1, x2 = sympy.symbols(&quot;x1 x2&quot;) 
 
 f1 = 2*x1 + 4*x2
 f2 = 4*x1 + 8*x2**3
 
 s = sympy.solve((f1, f2), x1, x2) 
 
 print(s)

Ausgabe:
 [(-2, 1), (0, 0), (2, -1)]

Plot:

[[Datei:IngPython_nl_gleichung1.svg|500px]]

= Komplexe Zahlen =
Die imaginäre Einheit wird in Python durch den Buchstaben &lt;code&gt;j&lt;/code&gt; symbolisiert. Darstellen kann man eine komplexe Zahl bekannterweise in mehreren Formen:
* Kartesische Darstellung &lt;math&gt;z = \Re(z) + j \cdot \Im(z)&lt;/math&gt;
* Polardarstellungen &lt;math&gt;z = r \cdot (\cos(\phi) + j \cdot \sin(\phi)) = r \cdot e^{j\cdot \phi}&lt;/math&gt;

Die konjugiert komplexe Zahl ist &lt;math&gt;z^* = \Re(z) - j \cdot \Im(z)&lt;/math&gt;

Nachfolgend einige mathematische Operationen mit Python und NumPy.

 import numpy as np
 
 z1 = 2 + 5j           # kartesische Darstellung
 z2 = 3 * np.exp(3j)   # Polardarstellung
  
 # Addition
 res = z1 + z2
 print(&quot;z1 + z2 = &quot;, res)
 
 # Multiplikation
 res = z1 * z2
 print(&quot;z1 * z2 = &quot;, res)
 
 # Realteil
 res = np.real(z2)
 print(&quot;Realteil von z2 = &quot;, res)
 
 # Imaginärteil
 res = np.imag(z2)
 print(&quot;Imaginaerteil von z2 = &quot;, res)
 
 # Betrag
 res = np.abs(z1)
 print(&quot;Betrag von z1 = &quot;, res)
 
 # Argument
 res = np.angle(z1)
 print(&quot;Argument von z1 = &quot;, res)
 
 # Konjugiert komplexe Zahl
 res = np.conj(z1)
 print(&quot;Konjugiert komplexe Zahl von z1 = &quot;, res)

Ausgabe:
 z1 + z2 =  (-0.9699774898013365+5.423360024179601j)
 z1 * z2 =  (-8.05675510050068-14.003167400647481j)
 Realteil von z2 =  -2.9699774898013365
 Imaginaerteil von z2 =  0.4233600241796016
 Betrag von z1 =  5.385164807134504
 Argument von z1 =  1.1902899496825317
 Konjugiert komplexe Zahl von z1 =  (2-5j)

= Interpolation =
 import numpy as np
 import scipy
 import matplotlib.pyplot as plt
 
 # Stützpunkte
 xp = np.arange(1, 6)
 yp = (0, -5, 2, 7, 6)
 
 ti = np.arange(1, 5, 0.01)
 
 i1 = scipy.interpolate.interp1d(xp, yp, kind = &quot;linear&quot;)
 i2 = scipy.interpolate.interp1d(xp, yp, kind = &quot;cubic&quot;) 
 
 plt.plot(xp, yp, &quot;rx&quot;)
 plt.plot(xp, i1(xp))
 plt.plot(ti, i2(ti))
 plt.show()

Ausgabe:

[[Datei:PythonIng_interpol1.png]]

&lt;code&gt;scipy.interpolate.interp1d()&lt;/code&gt; gilt als veraltet ([https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.interp1d.html]). Stattdessen soll man modernere Alternativen wie &lt;code&gt;scipy.interpolate.Akima1DInterpolator()&lt;/code&gt; oder &lt;code&gt;scipy.interpolate.CubicSpline()&lt;/code&gt; benutzen. Für die lineare Interpolation tut es &lt;code&gt;np.interp()&lt;/code&gt;.

&lt;u&gt;Aufgaben:&lt;/u&gt;
* Recherchieren Sie im Internet zu den oben genannten modernen Alternativen.
* Schreiben Sie obiges Programm auf die genannten moderneren Alternativen um.

= Differenzialrechnung =
== Numerisches Differenzieren ==
Als Beispiel differenzieren wir &lt;math&gt;y = 5x\sin{x}&lt;/math&gt; und stellen das Ganze grafisch dar.

 from findiff import Diff
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.linspace(0, 10, 1000)
 f = 5 * x * np.sin(x)
 dx = x[1] - x[0]
 
 # Ableitung
 d_dx = Diff(0, dx)
 df_dx = d_dx(f)
 
 # Grafik
 plt.plot(x, f, label = &quot;y&quot;)
 plt.plot(x, df_dx, label = &quot;y'&quot;)
 plt.grid()
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

Ausgabe:

[[Datei:octave_diff1.jpg]]

&lt;small&gt;findiff ist ein externes Modul. Dieses muss installiert werden (z.B. so: ...\Python\Scripts\pip.exe install --upgrade findiff). Für die Vorgehensweise unter openSUSE Tumbleweed siehe das Kapitel [[Ing_Mathematik:_Python#Mit_VPython | VPython]], nur dass das Ganze mit einer aktuelleren Python-Version exekutiert wird, z.B. mit Python 3.13.  Das im Buch &quot;Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler, Rheinwerk&quot; verwendete Modul &quot;scipy.misc&quot; ist veraltet (deprecated ... missbilligt). Lt. [https://docs.scipy.org/doc/scipy-1.17.0/dev/roadmap-detailed.html#misc SciPy-Dokumentation für die Version 1.17.0] wurden alle entsprechenden Features schon entfernt.&lt;/small&gt;

== Symbolisches Differenzieren ==
Differenzieren Sie die Funktionen &lt;math&gt;f_1(x) = x^2&lt;/math&gt; und &lt;math&gt;f_2(x) = \sin(x)\cos\left(\frac{x}{2}\right)&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2;
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 d1 = sympy.diff(f1, x)
 d2 = sympy.diff(f2, x)
 
 print(d1)
 print(d2)

Ausgabe:
 2*x
 -0.5*sin(0.5*x)*sin(x) + cos(0.5*x)*cos(x)

== Aufgaben ==
* Differenzieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.
* Differenzieren Sie die Funktion &lt;math&gt;y = \frac{\sinh(x)}{(1+x)}&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.

= Integralrechnung =
== Numerisches Integrieren ==
Berechnen Sie das Integral &lt;math&gt;\int_{0}^{3}x^2 dx&lt;/math&gt;.

 import scipy
 
 def f(x):
     return x**2
    
 i = scipy.integrate.quad(f, 0, 3)
 print(i)

Ausgabe:
 (9.000000000000002, 9.992007221626411e-14)

Das trifft den exakten Wert 9.0 ziemlich genau.

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} dx&lt;/math&gt;.

 import scipy
 import numpy as np
 
 def f(x):
     return 2**(-x)
   
 i = scipy.integrate.quad(f, 0, np.inf)
 print(i)

Ausgabe:
 (1.4426950408889556, 4.486558477977586e-09)

== Symbolisches Integrieren ==
Berechnen Sie &lt;math&gt;\int x^2 \text{d}x&lt;/math&gt; und &lt;math&gt;\int \sin{x}\cos{\frac{x}{2}} \text{d}x&lt;/math&gt;.
 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 i1 = sympy.integrate(f1, x)
 i2 = sympy.integrate(f2, x)
 
 print(i1)
 print(i2)

Ausgabe:
 x**3/3
 -0.666666666666667*sin(0.5*x)*sin(x) - 1.33333333333333*cos(0.5*x)*cos(x)

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} \text{d}x&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f = 2**(-x)
 i = sympy.integrate(f, (x, 0, sympy.oo))
 print(i)

Ausgabe:
 1/log(2)

&lt;code&gt;sympy.oo&lt;/code&gt; steht für das {{W|Unendlichzeichen}} &lt;math&gt;\infty&lt;/math&gt; (die liegende Acht oder das Möbiusband). Mit &lt;code&gt;sympy.pprint(i)&lt;/code&gt; ließe sich letzere Ausgabe etwas schöner schreiben:

   1   
 ──────
 log(2)

Man beachtete, &lt;code&gt;log&lt;/code&gt; steht hier für den natürlichen Logarithmus &lt;code&gt;ln&lt;/code&gt;.

== Aufgaben ==
* Integrieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; von 1 bis 5.
* Integrieren Sie die Funktion &lt;math&gt;y = x^3&lt;/math&gt; von 0 bis 4.
* Integrieren Sie &lt;math&gt;\int x^x(\log (x) + 1)\mathrm dx&lt;/math&gt; symbolisch.

= Gewöhnliche Differenzialgleichungen =
== DGL numerisch lösen ==
Für die Lösung von Differenzialgleichungen steht u.a. die Funktion scipy.integrate.solve_ivp() zur Verfügung. Diese Funktion implementiert auch das Runge-Kutta-Verfahren (RK45).

{{Wikipedia | Runge-Kutta-Verfahren}}

Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import scipy
 import numpy as np
 import matplotlib.pyplot as plt
 
 def dy_dx(x, y):
     return x**2 + y**3
 
 y0 = [1]
 xi = [0, 1]
 x = np.arange(0, 1, 0.01)
 
 z = scipy.integrate.solve_ivp(dy_dx, xi, y0, method=&quot;RK45&quot;, dense_output=True)
 y = z.sol(x)
 
 plt.plot(x, y.T)
 plt.grid()
 plt.show()

[[Datei:PythonIng_dgl1.png]]

== DGL symbolisch lösen ==
Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 print(lsg)

Ausgabe:
 [Eq(f(x), (-x**2)**(1/3)), Eq(f(x), (-x**2)**(1/3)*(-1 - sqrt(3)*I)/2), Eq(f(x), (-x**2)**(1/3)*(-1 + sqrt(3)*I)/2)]

Mit &lt;code&gt;sympy.pprint&lt;/code&gt; (pretty print) lässt sich die Ausgabe etwas übersichtlicher darstellen.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 sympy.pprint(lsg)

Ausgabe:
 ⎡                           _____                        _____            ⎤
 ⎢          _____         3 ╱   2                      3 ╱   2             ⎥
 ⎢       3 ╱   2          ╲╱  -x  ⋅(-1 - √3⋅ⅈ)         ╲╱  -x  ⋅(-1 + √3⋅ⅈ)⎥
 ⎢f(x) = ╲╱  -x  , f(x) = ────────────────────, f(x) = ────────────────────⎥
 ⎣                                 2                            2          ⎦

== Aufgaben ==
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \frac{1}{x\cdot y}&lt;/math&gt; mit Python. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;m' = -k\cdot m&lt;/math&gt;. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \sqrt{|y|}&lt;/math&gt;.

=Laplace-Transformation=
Laplace-Transformation:

&lt;math&gt;F(s) =\mathcal{L} \left\{f\right\}(s) = \int_{0}^{\infty} f(t) \mathrm e^{-st} \,\mathrm{d}t, \qquad s\in\mathbb{C}
&lt;/math&gt;

Inverse Laplace-Transformation:

&lt;math&gt;\mathcal{L}^{-1} \left\{F\right\}(t)
  = \frac{1}{2 \pi \mathrm j} \int_{ \gamma - \mathrm j \infty}^{ \gamma + \mathrm j \infty} \mathrm e^{st} F(s)\,\mathrm ds 
= \begin{cases}
      f(t) &amp; \text{für } t \geq 0 \\
      0    &amp; \text{für } t &lt; 0
    \end{cases}
&lt;/math&gt;

Siehe auch [[Ing_Mathematik:_Laplace-Transformation]]

Code:
 import sympy
 from sympy.abc import t, s
 
 # Laplace-Transformation der Funktion f(t) = 1 (Heaviside-Fkt.)
 f = 1
 # alternativ: f = sympy.Heaviside(t)
 F = sympy.laplace_transform(f, t, s, noconds=True)
 print(&quot;Laplace-Transformierte F(s):&quot;, F) 
 
 # Inverse Laplace-Transformation zurück in den Zeitbereich
 f_inv = sympy.inverse_laplace_transform(F, s, t)
 print(&quot;Inverse Transformation f(t):&quot;, f_inv)

Ausgabe:
 Laplace-Transformierte F(s): 1/s
 Inverse Transformation f(t): Heaviside(t)

Die Zeile

 from sympy.abc import t, s

steht alternativ für

 t = sympy.symbols(&quot;t&quot;)
 s = sympy.symbols(&quot;s&quot;)

&lt;u&gt;Aufgaben&lt;/u&gt;: Ermitteln Sie mittels SymPy die &lt;math&gt;\mathcal{L}&lt;/math&gt;-Transformierten und dann wieder die  &lt;math&gt;\mathcal{L}^{-1}&lt;/math&gt;-Transformationen (ähnlich wie beim obigen Beispiel):
* &lt;math&gt;\sin(t) \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;t^3 \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;\text{e}^{\omega t} \circ\! -\! \bullet \ ?&lt;/math&gt;

=Fourier-Reihen=
&lt;math&gt;
f(x)\approx \frac{a_{0}}{2}+\sum_{k=1}^{\infty}\left(a_{k}\cos\left(kx\right)+b_{k}\sin\left(kx\right)\right)
&lt;/math&gt;

&lt;math&gt;
a_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\cos\left(kx\right)\mathrm dx\quad\text{für }k\geq0
&lt;/math&gt;

&lt;math&gt;
b_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\sin\left(kx\right)\mathrm dx\quad\text{für }k\geq1
&lt;/math&gt;

Für die Sägezahnfunktion &lt;math&gt;y=x;\, 0 &lt; x &lt; 2\pi&lt;/math&gt; sei die Fourierreihe mit einem Python-Programm (unter Mithilfe von sympy) hergeleitet.

Code:

 from sympy import fourier_series, pi, symbols, pprint
 
 x = symbols('x')
 f = x
 s = fourier_series(f, (x, 0, 2*pi))
 pprint(s.truncate(n=4))

Ausgabe:

                        2⋅sin(3⋅x)    
 -2⋅sin(x) - sin(2⋅x) - ────────── + π
                            3

Siehe auch [[Ing Mathematik: Fourierreihen]].

Ein komplizierteres Beispiel:

[[Datei:IngMath fourier bsp13.svg | 300px]]

&lt;math&gt;0\le t &lt; T/2\text{:}\quad f(t) = H&lt;/math&gt;

&lt;math&gt;T/2 \le t \le T\text{:}\quad f(t) = \frac{2H}{T}\left( t-\frac{T}{2}\right)&lt;/math&gt;

Code:

 import sympy as sp
 
 H = sp.Symbol('H', positive=True)
 T = sp.Symbol('T', positive=True)
 t = sp.Symbol('t')
 
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T/2)),
     (2*H/T*(t-T/2), (t &gt; T/2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Ausgabe:

      ⎛2⋅π⋅t⎞        ⎛4⋅π⋅t⎞        ⎛6⋅π⋅t⎞          ⎛2⋅π⋅t⎞          ⎛6⋅π⋅t⎞      
 H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   2⋅H⋅cos⎜─────⎟   2⋅H⋅cos⎜─────⎟      
      ⎝  T  ⎠        ⎝  T  ⎠        ⎝  T  ⎠          ⎝  T  ⎠          ⎝  T  ⎠   3⋅H
 ──────────── - ──────────── + ──────────── + ────────────── + ────────────── + ───
      π             2⋅π            3⋅π               2                 2         4 
                                                    π               9⋅π

=Rechnen mit wirklich großen Zahlen=
Bekannt ist, dass Python kaum Einschränkungen beim Wertebereich von Ganzzahlen hat, z.B.

 print(10**300)

Ausgabe (gekürzt):

 100000000000000000000...00000000000000000000000000000000000000000000000000000000000000000000000

Ähnliches geht auch mit Gleitpunktzahlen, z.B. durch die Verwendung des Moduls [https://mpmath.org/ mpmath]:

 import mpmath
 print(mpmath.mpf(1500.4)**mpmath.mpf(300))

Ausgabe:

 7.27975299218612e+952

Anderes Beispiel:

 from mpmath import mp, pi
 mp.dps = 100
 print(pi)

Ausgabe:

 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068

mpmath kann noch einiges mehr, dazu sei aber auf die entsprechende Dokumentation auf der mpmath-Homepage verwiesen. mpmath ist Bestandteil von SymPy, kann aber auch separat installiert werden.

Aber auch Python selbst besitzt eine Möglichkeit, um mit großen bzw. exakten Gleitpunktzahlen zu rechnen, nämlich das interne Modul decimal. Dieses hat einige Vorteile gegenüber mpmath, aber auch gravierende Nachteile. Diese seien hier nicht detailliert aufgezählt. Grob gesagt hat decimal im Finanzwesen seine Berechtigung. Für wissenschaftliche Anwendungen wird aber mpmath vorzuziehen sein, da es u.a. vielfältige mathematische Funktionen bereit stellt. Nachfolgend ein einfaches Beispiel mit decimal:

 import decimal
 print(&quot;Potenzierung:&quot;, decimal.Decimal(1500.4) ** decimal.Decimal(300.0))
 print(&quot;Einfache Addition:&quot;, 0.1 + 0.2)
 decimal.getcontext().prec = 50
 print(&quot;Addition mit decimal:&quot;, decimal.Decimal(&quot;0.1&quot;) + decimal.Decimal(&quot;0.2&quot;))

Ausgabe:

 Potenzierung: 7.279752992186121551039839134E+952
 Einfache Addition: 0.30000000000000004
 Addition mit decimal: 0.3

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet die genauen Vor- und Nachteile von decimal und mpmath. Verwenden Sie dazu auch KI (z.B. von Google, chatgpt).

= pint - mit physikalischen Größen rechnen = 
[[File:Pint-Glas_UK.jpg|right|100px]]
pint ist ein externes Python-Paket zur Manipulation von physikalischen Einheiten. Es muss vor der ersten Benutzung installiert werden (Vorgehensweise wie immer: pip, YaST, via venv etc.).

Beispiel:

 import pint
 import numpy as np
 
 ureg = pint.UnitRegistry()
 
 # Einfache Berechnung
 print(3 * ureg.meter + 4 * ureg.cm)
 
 # Mit NumPy
 npeinzel = [3, 4] * ureg.meter + [2, 5] * ureg.cm
 print(npeinzel)
 npsum = np.sum(npeinzel)
 print(npsum)
 
 # Konvertierung von Einheiten
 npsum_inch = npsum.to(ureg.inch)
 print(npsum_inch)
 
 print(npeinzel.magnitude)
 print(npeinzel.units)
 print(npeinzel.dimensionality)

Ausgabe:

 3.04 meter
 [3.02 4.05] meter
 7.07 meter
 278.3464566929134 inch
 [3.02 4.05]
 meter
 [length]

Die Dokumentation zu pint findet sich auf [https://pint.readthedocs.io/en/stable/].

=Regelungstechnische Aufgabenstellungen=
Für regelungstechnische Aufgaben gibt es u.a. das externe Paket &lt;code&gt;control&lt;/code&gt;. Hier soll nicht detailliert darauf eingegangen werden. Anhand eines Beispiels soll anschließend nur die Visualisierung in Form eines Bode-Diagramms und der Sprungantwort gezeigt werden. Gegeben sei ein P-Regler mit &lt;math&gt;R = \frac{5}{2}&lt;/math&gt; und eine Strecke &lt;math&gt;S= \frac{1}{30s^3+20s^2+10s+1,5}&lt;/math&gt;. Gesucht sei vorerst ein Bode-Diagramm für den offenen Regelkreis und das Führungsverhalten.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke  # oder: G0 = ct.series(regler, strecke)
 Gw = ct.feedback(G0)
 
 ct.bode_plot(G0, label='G0')
 ct.bode_plot(Gw, label='Gw')
 plt.show()

[[Datei:PythonIng_bode1.svg]]

Nun noch für obiges Beispiel die Sprungantwort. Diese zeigt einige große Überschwinger, d.h. der Regler kann sicher noch optimiert werden.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke 
 Gw = ct.feedback(G0) 
 
 t, y = ct.step_response(Gw)
 
 plt.plot(t,y)
 plt.title('Sprungantwort')
 plt.xlabel('t')
 plt.ylabel('h(t)')
 plt.grid()
 plt.show()

[[Datei:PythonIng_bode3.svg]]

Einige weitere wichtige Daten (Phasenreserve, Amplitudenreserve, Durchtrittsfrequenz) lassen sich mittels der &lt;code&gt;control&lt;/code&gt;-Funktion &lt;code&gt;margin()&lt;/code&gt; ermitteln. Die Ortskurve lässt sich mit der Funktion &lt;code&gt;nyquist_plot()&lt;/code&gt; zeichnen. Dies sei hier aber nicht weiter ausgeführt.

==Aufgaben==
* Zeichen Sie mit Python die Ortskurve für obiges Beispiel.
* Was passiert, wenn man die Reglerverstärkung weiter aufdreht (z.B. auf &lt;math&gt;R = \frac{25}{2}&lt;/math&gt;)?
* Wie sehen das Bode-Diagramm und die Sprungantwort aus, wenn ein PI-Regler verwendet wird?

= Stereostatik etc. =
Das Modul SymPy bietet einige Möglichkeiten einfache Bauwerke zu berechnen, z.B. Balken oder Fachwerke. Nachfolgend wird ein einfaches Fachwerk berechnet und gezeichnet.

Python-Code:
 from sympy.physics.continuum_mechanics.truss import Truss 
 
 t = Truss()
 # Knoten
 t.add_node((&quot;A&quot;, -3, 0), (&quot;B&quot;, 0, 0), (&quot;C&quot;, 4, 0), (&quot;D&quot;, 7, 0),
            (&quot;E&quot;, 6, 1.5), (&quot;F&quot;, 2, 3), (&quot;G&quot;, -2, 1.5))
 # Stäbe
 t.add_member((&quot;AB&quot;,&quot;A&quot;,&quot;B&quot;), (&quot;BC&quot;,&quot;B&quot;,&quot;C&quot;), (&quot;CD&quot;,&quot;C&quot;,&quot;D&quot;))
 t.add_member((&quot;AG&quot;,&quot;A&quot;,&quot;G&quot;), (&quot;GB&quot;,&quot;G&quot;,&quot;B&quot;), (&quot;GF&quot;,&quot;G&quot;,&quot;F&quot;))
 t.add_member((&quot;BF&quot;,&quot;B&quot;,&quot;F&quot;), (&quot;FC&quot;,&quot;F&quot;,&quot;C&quot;), (&quot;CE&quot;,&quot;C&quot;,&quot;E&quot;))
 t.add_member((&quot;FE&quot;,&quot;F&quot;,&quot;E&quot;), (&quot;DE&quot;,&quot;D&quot;,&quot;E&quot;))
 # Auflager; roller ... Loslager, pinned ... Festlager
 t.apply_support((&quot;A&quot;,&quot;roller&quot;), (&quot;D&quot;,&quot;pinned&quot;))
 # Einwirkende Kräfte
 t.apply_load((&quot;G&quot;, 5, 270), (&quot;E&quot;, 3, 90))
 
 # Berechnung 
 t.solve()
 print(&quot;Reaction Forces: &quot;, t.reaction_loads)
 print(&quot;Internal Forces: &quot;, t.internal_forces)
 
 # Fachwerk zeichnen
 p = t.draw()
 p.show()

Ausgabe auf der Konsole:

 Reaction Forces:  {'R_A_y': 4.20000000000000, 'R_D_x': 0, 'R_D_y': -2.20000000000000}
 Internal Forces:  {'AB': 2.80000000000000, 'BC': 0.333333333333333, 'CD': -1.46666666666667, 
 'AG': -5.04777178564958, 'GB': -2.05555555555556, 'GF': -1.23413387432364, 
 'BF': 0.411111111111111*sqrt(13), 'FC': -0.3*sqrt(13), 'CE': 1.50000000000000, 
 'FE': 0.284800124843917, 'DE': 2.64407093534026}

Zeichnung:

[[File:PythonIng_fachwerk1.svg|300px]]

Details zu diesem Thema siehe z.B. [https://docs.sympy.org/latest/modules/physics/continuum_mechanics/index.html Continuum Mechanics] oder [https://docs.sympy.org/latest/tutorials/physics/continuum_mechanics/index.html Continuum Mechanics Tutorials]. Auch andere mechanische Probleme werden von SymPy abgehandelt ([https://docs.sympy.org/latest/tutorials/physics/index.html Physics Tutorials]).

== Aufgabe ==
Gegeben sei ein einseitig eingespannter Kragträger. Belastet wird er durch eine Einzellast am Trägerende. Für die Daten siehe folgende ASCII-Skizze:

                            | 20 kN  
    //|---&gt; x               |
    //|                     V
    //|----------------------
    //|         10 m        |
 
 Elastizitätsmodul E = 2,1*10⁵ N/mm²
 Flächenträgheitsmoment I = 0.001 m⁴

Berechnen Sie die Auflagerreaktionen, den Querkraft- und Biegemomentenverlauf, sowie die Verformungen.
Stellen Sie dies mit Hilfe von SymPy graphisch und auch mittels Formeln dar. Verwenden Sie dazu auch pprint (pretty print) aus dem SymPy-Modul. Zwecks Lösungsansatz siehe die oben aufgeführte Seite &quot;Continuum Mechanics Tutorials&quot;. Achten Sie auch auf die Einheiten! Kontrollieren Sie das Ganze mittels händischer Rechnung. In dem genannten Tutorial ist von &quot;Singularity Functions&quot; die Rede. Gemeint ist damit in diesem Kontext die {{W|Föppl-Klammer}}.

Einige Python-Programme, vorrangig zu Maschinenelementen, finden sich auf [https://baymp.de/download_python.html BayMP für Python] (Balken, Zahnräder, Stabknickung usw.).

=Thermodynamik= 
== PYroMat ==
Für thermodynamische Aufgabenstellungen gibt es verschiedene externe Module. Eines davon ist PYroMat (siehe auch [http://pyromat.org]). Damit lassen sich thermodynamische Stoffdaten für viele Substanzen berechnen.

Beispiel (einige Stoffdaten für Wasser bei 400°C und 20 bar berechnen):

 import pyromat as pm
 
 # Wasserdaten laden:
 H2O = pm.get('mp.H2O')
 
 # Stoffdaten berechnen:
 T = 673.15  # Temperatur in Kelvin
 p = 20      # Druck in bar
 v = H2O.v(T, p)
 h = H2O.h(T, p)
 s = H2O.s(T, p)
 print(f&quot;Spezifisches Volumen: {v} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {h} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {s} kJ/(kg K)&quot;)

Ausgabe:

 Spezifisches Volumen: [0.1512163] m³/kg
 Spezifische Enthalpie: [3248.3789473] kJ/kg
 Spezifische Entropie: [7.12924142] kJ/(kg K)

&lt;small&gt;
PYroMat muss vorab installiert werden (z.B. mittels pip, in eine virtuelle Umgebung)
&lt;/small&gt;

&lt;code&gt;mp&lt;/code&gt; steht für &quot;multi phase&quot;. Für ein ideales Gas wäre &lt;code&gt;ig&lt;/code&gt; zuständig, z.B. &lt;code&gt;'ig.O2'&lt;/code&gt;.

Beispiel (T-s-Diagramm für Wasser zeichnen):
 import numpy as np
 import matplotlib.pyplot as plt
 import pyromat as pm
 
 # Konfigurieren
 pm.config[&quot;unit_pressure&quot;] = &quot;bar&quot;
 pm.config[&quot;unit_temperature&quot;] = &quot;K&quot;
 fluid = pm.get(&quot;mp.H2O&quot;)
 
 # Temperaturbereich für das Nassdampfgebiet
 T_tripel = 273.16
 T_crit = 647.096
 T = np.linspace(T_tripel, T_crit - 0.1, 200)
 
 # Sättigungslinien berechnen und zeichnen
 for x in np.linspace(0.0, 1.0, 5):
     s = fluid.s(T=T, x=x)
     if(x&lt;=0.0):
         plt.plot(s, T, label=&quot;Siedelinie x=%3.1f&quot; % x, linewidth=2.0)
     elif(x&gt;=1.0):
         plt.plot(s, T, label=&quot;Taulinie x=%3.1f&quot; % x, linewidth=2.0)
     else:
         plt.plot(s, T, label=&quot;x=%3.1f&quot; % x, linewidth=1.0)
 
 # Isobaren zeichnen
 p_values = [0.1, 1, 10, 50, 100]
 T_isobar = np.linspace(T_tripel, 1000, 200)
 t = 0.7
 
 for p in p_values:
     s_iso = fluid.s(T=T_isobar, p=p)
     plt.plot(s_iso, T_isobar, 'k-', alpha=0.8, linewidth=0.8)
 
     t += .05
     idx = int(len(s_iso) * t)
     plt.text(s_iso[idx], T_isobar[idx], f&quot;{p} bar&quot;, fontsize=9, alpha=0.8)
 
 # Diagramm zeichnen
 plt.title(&quot;T-s-Diagramm für Wasser&quot;)
 plt.xlabel(&quot;Spezifische Entropie s in kJ/kg K&quot;, fontsize=10)
 plt.ylabel(&quot;Temperatur T in K&quot;, fontsize=10)
 plt.legend(loc=&quot;best&quot;)
 plt.grid(True)
 plt.show()

Ausgabe (in etwa so):

[[Datei:T-s-Diagramm fuer Wasser.svg|400px]]

== CoolProp ==
Auch mit CoolProp können Stoffdaten berechnet werden. Siehe auch [https://coolprop.org/coolprop/wrappers/Python/index.html]

Beispiel (Wasser bei 20bar und 400°C):
 import CoolProp.CoolProp as CP
 
 fluid = 'Water'
 T = 673.15   # Temperatur in Kelvin
 P = 20e5     # Druck in Pascal
 
 dichte = CP.PropsSI('D', 'T', T, 'P', P, fluid)
 enthalpie = CP.PropsSI('H', 'T', T, 'P', P, fluid)
 entropie = CP.PropsSI('S', 'T', T, 'P', P, fluid)
 
 print(f&quot;Spez. Volumen: {1/dichte:.6f} m³/kg&quot;)
 print(f&quot;Spez. Enthalpie: {enthalpie:.2f} J/kg&quot;)
 print(f&quot;Spez. Entropie: {entropie:.2f} J/kgK&quot;)

Ausgabe:
 Spez. Volumen: 0.151215 m³/kg
 Spez. Enthalpie: 3248344.02 J/kg
 Spez. Entropie: 7129.16 J/kgK

== iapws ==
Um Werte für Wasser(dampf) zu erhalten (IAPWS; '''I'''nternational '''A'''ssociation for the '''P'''roperties of '''W'''ater and '''S'''team) gibt es die Bibliothek iapws. Siehe auch [https://iapws.org/] und [https://pypi.org/project/iapws/]

Beispiel (Wasser für 20bar und 400°C):
 from iapws import IAPWS97
 
 dampf = IAPWS97(P=2.0, T=673.15)
 
 print(f&quot;Spezifisches Volumen: {dampf.v:.6f} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {dampf.h:.2f} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {dampf.s:.4f} kJ/(kgK)&quot;)
 print(f&quot;Phase: {dampf.phase}&quot;)

Ausgabe:
 Spezifisches Volumen: 0.151208 m³/kg
 Spezifische Enthalpie: 3248.23 kJ/kg
 Spezifische Entropie: 7.1290 kJ/(kgK)
 Phase: Gas

== TESPy ==
Ein anderes Modul für einen anderen Aufgabenzweck ist TESPy ('''T'''hermal '''E'''ngineering '''S'''ystems in '''Py'''thon). Dieses Modul ist für die Anlagensimulation zuständig. Für nähere Informationen siehe [https://tespy.readthedocs.io/en/main/getting_started/introduction.html]. Als Beipiel sei hier vorerst Code, der von der Google KI generiert wurde, angeführt. Der Code wurde überarbeitet, damit keine Warnungen auftreten. Bitte aber den Code trotzdem mit Vorsicht genießen, auch KI-generierter Code kann Fehler aufweisen. Eine Pumpe wird berechnet:

 from tespy.components import Sink, Source, Pump
 from tespy.connections import Connection
 from tespy.networks import Network
 
 # 1. Netzwerk definieren (Zentrales Steuerungselement)
 # Wir wählen Wasser als Fluid und bar/Celsius als Einheiten
 nw = Network(fluids=[&quot;water&quot;])
 nw.units.set_defaults(pressure=&quot;bar&quot;, pressure_difference=&quot;bar&quot;, 
                       temperature=&quot;°C&quot;, enthalpy=&quot;kJ / kg&quot;)
 
 # 2. Komponenten erstellen
 eingang = Source(&quot;Wasserquelle&quot;)
 ausgang = Sink(&quot;Wasserspeicher&quot;)
 pumpe = Pump(&quot;Speisewasserpumpe&quot;)
 
 # 3. Verbindungen definieren (Komponenten miteinander verknüpfen)
 c1 = Connection(eingang, &quot;out1&quot;, pumpe, &quot;in1&quot;)
 c2 = Connection(pumpe, &quot;out1&quot;, ausgang, &quot;in1&quot;)
 
 # Verbindungen dem Netzwerk hinzufügen
 nw.add_conns(c1, c2)
 
 # 4. Randbedingungen und Parameter festlegen
 # Zustand am Eingang (Druck, Temperatur, Massenstrom, Fluid-Zusammensetzung)
 c1.set_attr(
     v=1,  # Massenstrom: 1 kg/s
     T=20,  # Temperatur: 20 °C
     p=1,  # Druck: 1 bar
     fluid={&quot;water&quot;: 1},  # 100% Wasser
 )
 
 # Zustand am Ausgang / Zielwerte der Pumpe
 c2.set_attr(p=10)  # Ziel-Druck nach der Pumpe: 10 bar
 
 # Pumpeneigenschaften festlegen
 pumpe.set_attr(eta_s=0.8)  # Isentroper Wirkungsgrad von 80%
 
 # 5. Simulation ausführen
 nw.solve(mode=&quot;design&quot;)
 
 # 6. Ergebnisse ausgeben
 nw.print_results()
 
 # Spezifische Werte direkt auslesen
 print(&quot;\n--- Auswertung ---&quot;)
 print(f&quot;Erforderliche Pumpenleistung: {pumpe.P.val / 1000:.2f} kW&quot;)
 print(f&quot;Temperatur nach der Pumpe: {c2.T.val:.2f} °C&quot;)

Ausgabe (gekürzt):
  iter  | residual   | progress   | massflow   | pressure   | enthalpy   | fluid      | component  
 -------+------------+------------+------------+------------+------------+------------+------------
  1     | 7.04e+04   | 12 %       | 9.96e+02   | 0.00e+00   | 8.81e+04   | 0.00e+00   | 0.00e+00   
  2     | 5.91e-12   | 100 %      | 1.11e-13   | 0.00e+00   | 7.39e-12   | 0.00e+00   | 0.00e+00   
  3     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
  4     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
 Total iterations: 4, Calculation time: 0.01 s, Iterations per second: 480.85
 
 ##### RESULTS (Pump) #####
 +-------------------+----------+----------+-----------+----------+----------+----------+
 |                   |        P |       pr |        dp |      eta |    eta_s |     head |
 |-------------------+----------+----------+-----------+----------+----------+----------|
 | Speisewasserpumpe | 1.12e+06 | 1.00e+01 | -9.00e+00 | 8.00e-01 | 8.00e-01 | 9.19e+01 |
 +-------------------+----------+----------+-----------+----------+----------+----------+
 ...
 ...
 --- Auswertung ---
 Erforderliche Pumpenleistung: 1124.77 kW
 Temperatur nach der Pumpe: 20.07 °C

= Stochastik =
Die {{W|Stochastik}} ist ein sehr weites Feld. Hier werden etliche wichtige Themen kurz angerissen. Python stellt mit den Moduln math und statistics Software zu diesem Zwecke bereit. math und statistics sind bereits im Lieferumfang von Python enthalten. Aber auch mit den externen Modulen NumPy, SciPy, stochastic und pandas kann man Stochastik in Python betreiben. Die Theorie der Wahrscheinlichkeitsrechnung und Statistik soll etwas später in Band 5 dieser Buchreihe behandelt werden.

== Lageparameter == 
 import statistics
 
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 
 m1 = statistics.mean(werte)
 m2 = statistics.mode(werte)
 m3 = statistics.median(werte)
 
 print(&quot;Arithmetischer Mittelwert = &quot;, m1)
 print(&quot;Modalwert = &quot;, m2)
 print(&quot;Median = &quot;, m3)

Ausgabe:
 Arithmetischer Mittelwert =  3.5
 Modalwert =  1
 Median =  3.0

== Streuungsparameter ==
Beispiel (Berechnung der Standardabweichung):
 import statistics
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 s = statistics.stdev(werte)
 print(&quot;Standardabweichung = &quot;, s)

Ausgabe:
 Standardabweichung =  2.6770630673681683

Beispiel (Berechnung des Variationskoeffizienten V = Standardabweichung/Mittelwert)
 import numpy as np
 from scipy import stats
 import statistics
 
 k = 50
 
 dat1 = [14, 21, 18, 25, 30, 17, 20]
 dat = np.array(dat1)
 
 # Mit SciPy
 v = stats.variation(dat)
 vddof = stats.variation(dat, ddof=1)
 print(&quot;V SciPy: &quot;, v)
 print(&quot;V DDOF SciPy: &quot;, vddof)
 print(k*&quot;-&quot;)
 
 # mit NumPy
 mittelwert1 = np.mean(dat)
 std_abw1 = np.std(dat)
 std_abw1ddof = np.std(dat, ddof=1) 
 v1= std_abw1 / mittelwert1
 v1ddof = std_abw1ddof / mittelwert1
 print(&quot;Mittelwert NumPy: &quot;, mittelwert1)
 print(&quot;Std.abw. NumPy: &quot;, std_abw1)
 print(&quot;Std.abw. DDOF NumPy: &quot;, std_abw1ddof)
 print(&quot;V NumPy: &quot;, v1)
 print(&quot;V DDOF NumPy: &quot;, v1ddof)
 print(k*&quot;-&quot;)
 
 # nur mit reinem Python
 mittelwert2 = statistics.mean(dat1)
 std_abw2 = statistics.stdev(dat1)
 v2 = std_abw2 / mittelwert2
 print(&quot;Mittelwert Python: &quot;, mittelwert2)
 print(&quot;Std.abw. Python: &quot;, std_abw2)
 print(&quot;V Python:&quot;, v2)
 print(k*&quot;-&quot;)

Ausgabe:
 V SciPy:  0.23890355966467272
 V DDOF SciPy:  0.25804533701889254
 --------------------------------------------------
 Mittelwert NumPy:  20.714285714285715
 Std.abw. NumPy:  4.948716593053935
 Std.abw. DDOF NumPy:  5.3452248382484875
 V NumPy:  0.23890355966467272
 V DDOF NumPy:  0.2580453370188925
 --------------------------------------------------
 Mittelwert Python:  20.714285714285715
 Std.abw. Python:  5.3452248382484875
 V Python: 0.2580453370188925
 --------------------------------------------------

Der Unterschied bei der Standardabweichung zwischen reinem Python und den externen Bibliotheken SciPy und NumPy entsteht dadurch, dass einmal durch (n-1) und das andere Mal nur durch n dividiert wird. Dies kann bei NumPy und SciPy dadurch entschärft werden, indem &lt;code&gt;ddof=1&lt;/code&gt; gesetzt wird. ddof steht für '''D'''elta '''D'''egrees '''o'''f '''F'''reedom. &lt;small&gt;Je größer die Anzahl der Datensätze n wird, umso weniger spielt das eine Rolle.&lt;/small&gt;

== Kombinatorik ==
Beispiel:

 import math
 
 n = 7
 k = 5
 
 print(&quot;n! = &quot;, math.factorial(n))
 print(&quot;Kombinationen (n über k) = &quot;, math.comb(n, k))

Ausgabe:
 n! =  5040
 Kombinationen (n über k) =  21

Siehe zu diesem Thema auch [[Ing Mathematik: Permutationen, Kombinationen, binomischer Lehrsatz]]. Die Anzahlen lassen sich einfach aus den dortigen Formeln ermitteln, z.B. bei Permutationen mit &lt;math&gt;n!&lt;/math&gt; oder Variationen mit Wiederholungen als &lt;math&gt;n^k&lt;/math&gt;. Will man die Kombinationen oder Variationen aber auch als Liste ausgeben, so kann das Modul &lt;code&gt;itertools&lt;/code&gt; nützlich sein.  

Beispiel (Variationen ohne Wiederholung):

 from itertools import permutations
 
 menge = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]  # n = 4
 k = 3
 
 variationen = list(permutations(menge, k))
 
 for v in variationen:
     print(&quot;&quot;.join(v))
 
 print(50*&quot;-&quot;)
 print(len(variationen))

Ausgabe (gekürzt):
 ABC
 ABD
 ACB
 ...
 DCA
 DCB
 --------------------------------------------------
 24

Siehe zum Modul &lt;code&gt;itertools&lt;/code&gt; auch die Website [https://docs.python.org/3/library/itertools.html].

* Variationen mit Wiederholung: &lt;code&gt;itertools.product()&lt;/code&gt;
* Kombinationen ohne Wiederholung: &lt;code&gt;itertools.combinations()&lt;/code&gt;
* Kombinationen mit Wiederholung: &lt;code&gt;itertools.combinations_with_replacement()&lt;/code&gt;

== Zufallszahlen ==
Beispiel:
 import random
 
 # Ganzzahlige Zufallszahl von 1 bis 10
 zufallszahl1 = random.randint(1, 10)
 
 # Gleitpunktzahlen
 # zwischen 0.0 und 1.0
 zufallszahl2 = random.random()
 # Zahl zwischen 1.5 und 9.5
 zufallszahl3 = random.uniform(1.5, 9.5)
 
 # aus Liste auswählen
 farbe = [&quot;Rot&quot;, &quot;Grün&quot;, &quot;Blau&quot;]
 zufallswert = random.choice(farbe)
 
 print(zufallszahl1)
 print(zufallszahl2)
 print(zufallszahl3)
 print(zufallswert)

Ausgabe, z.B.:
 5
 0.14147945849015753
 6.894003397570905
 Rot

Benötigt man mehrere Zufallszahlen, so ist das Modul &lt;code&gt;numpy&lt;/code&gt; zu bevorzugen, z.B.:
* Normalverteilung: &lt;code&gt;np.random.normal(...)&lt;/code&gt;
* Gleichverteilung: &lt;code&gt;np.random.uniform(...)&lt;/code&gt;

== Histogramm ==
Zum Thema Histogramm siehe {{W|Histogramm}}.

Beispiel (mit Matplotlib):

 import matplotlib.pyplot as plt
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 
 plt.hist(daten, bins=25, edgecolor='darkgray')
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm.svg|300px]]

Beispiel (mit Seaborn):

 import matplotlib.pyplot as plt
 import seaborn as sns
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 sns.set_theme(style=&quot;darkgrid&quot;)
 sns.histplot(data=daten)
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm2.svg|300px]]

Das Kürzel &lt;code&gt;sns&lt;/code&gt; ist Konvention und steht für die fiktive Figur '''S'''amuel '''N'''orman '''S'''eaborn aus der US-Fernsehserie {{W|The West Wing – Im Zentrum der Macht | The West Wing}}.

== Box-Plot ==
[[File:Elements of a boxplot.svg|400px]]

Siehe auch {{W|Box-Plot}}.

Beispiel (mit Seaborn erstellt):
 import seaborn as sns
 import matplotlib.pyplot as plt
 
 df = sns.load_dataset(&quot;tips&quot;)
 sns.boxplot(data=df, x=&quot;day&quot;, y=&quot;tip&quot;, hue=&quot;day&quot;, legend=False)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot.svg|400px]]

Beispiel (mit Matplotlib erstellt):

 import matplotlib.pyplot as plt
 
 daten = [12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25]
 
 plt.boxplot(daten, patch_artist=True)
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot2.svg|300px]]

Um mehrere Box-Plots unterschiedlicher Farbe mit Matplotlib in einem Diagramm zu zeichnen, können Sie folgendermaßen vorgehen:

 import matplotlib.pyplot as plt
 
 daten = [[12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25],
          [10, 19, 20, 21, 20, 30, 19, 40, 11, 17, 19, 21]]
 
 farben = [&quot;green&quot;, &quot;blue&quot;]
 
 boxplot = plt.boxplot(daten, patch_artist=True)
 
 for patch, farbe in zip(boxplot['boxes'], farben):
     patch.set_facecolor(farbe)
 
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

== Regressionsrechnung ==
Beispiel:
 import numpy as np
 import matplotlib.pyplot as plt
 
 # Messpunkte
 x = np.array([1, 3, 5, 6, 8, 10, 20])
 y = np.array([3, 4, 5, 5, 7, 9, 11])
 
 # Regressionskurve (Grad 1 = lineare Regression, 2 = Polynom-Regression 2. Gr.)
 # y = kx + d
 k, d = np.polyfit(x, y, deg=1)
 # y = ax**2 + bx + c
 a, b, c = np.polyfit(x, y, deg=2)
 
 x_l = np.linspace(1, 20, 100)
 y_p = a * x_l**2 + b * x_l + c
 
 # Zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.plot(x, k*x + d, color='blue', label='Regressionsgerade')
 plt.plot(x_l, y_p, color='red', label='Regressionspolynom 2. Gr.')
 plt.xlabel('x')
 plt.ylabel('y')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_regression.svg|400px]]

== Korrelationsrechnung ==
Beispiel:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 # Messdaten
 x = [1, 3, 4, 5, 6]
 y = [2, 4, 6, 8, 5]
 
 daten = {'X': x, 'Y': y}
 df = pd.DataFrame(daten)
 
 # Korrelation
 korr = df['X'].corr(df['Y'])
 print(f&quot;Korrelationskoeff.: {korr}&quot;) 
 
 # Messpunkte zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:
 Korrelationskoeff.: 0.7556096518348252

[[Datei:IngMath_korrelation.svg|300px]]

== Mengen und Venn-Diagramme ==
Beispiel: 
 import matplotlib.pyplot as plt
 from matplotlib_venn import venn2
 
 menge_a = {1, 2, 3, 4, 5, 6}
 menge_b = {4, 5, 6, 7, 8}
 
 vereinigung = menge_a | menge_b
 schnitt = menge_a &amp; menge_b
 print(&quot;Vereinigungsmenge = &quot;, vereinigung)
 print(&quot;Schnittmenge = &quot;, schnitt)
 
 venn2([menge_a, menge_b], set_labels=('Menge A', 'Menge B'))
 plt.show()

Ausgabe:
 Vereinigungsmenge =  {1, 2, 3, 4, 5, 6, 7, 8}
 Schnittmenge =  {4, 5, 6}

[[Datei:IngMath_venn.svg|300px]]

Siehe auch {{W|Mengendiagramm#Venn-Diagramme}}.

== Verteilungs- und Dichtefunktion ==
* CDF ... '''C'''umulative '''D'''istribution '''F'''unction, Verteilungsfunktion
* PDF ... '''P'''robability '''D'''ensity '''F'''unction, Dichtefunktion

Beispiel (Normalverteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 from scipy.stats import norm
 
 my, sigma = 0, 1
 x = np.linspace(-4, 4, 50)
 
 pdf = norm.pdf(x, my, sigma)
 cdf = norm.cdf(x, my, sigma)
 
 plt.plot(x, pdf, lw=2, label=&quot;Dichtefunktion&quot;)
 plt.plot(x, cdf, lw=2, label=&quot;Verteilungsfunktion&quot;)
 plt.legend()
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:IngMath_cdf_pdf.svg|300px]]

Beispiel (&lt;math&gt;\chi^2&lt;/math&gt;-Verteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 import scipy.stats as stats
 
 x = np.linspace(0, 20, 500)
 
 # df ... degree of freedom, Freiheitsgrad
 pdf = (stats.chi2.pdf(x, df=2), stats.chi2.pdf(x, df=5), stats.chi2.pdf(x, df=10))
 
 for i in range(0,3):
     if(i==0):
         lab = &quot;Freiheitsgrad 2&quot;
     elif(i==1):
         lab = &quot;Freiheitsgrad 5&quot;
     else:
         lab = &quot;Freiheitsgrad 10&quot;
 
     plt.plot(x, pdf[i], label=lab, lw=2)
 
 plt.grid()
 plt.legend()
 plt.show()

Ausgabe:

[[Datei:IngMath_chi2.svg | 300px]]

== Schätzen und Testen ==
=== Intervallschätzung ===
Als Beispiel seien Daten gegeben, die von ''Dürr, Mayer: Wahrscheinlichkeitsrechnung und Schließende Statistik; 7. Aufl., Hanser, 2014, Seite 137'' stammen. Und zwar soll das 95%-Vertrauensintervall für den Mittelwert des Kaloriengehalts (kcal/100g) von Hähnchen ermittelt werden. Wir wollen das mit Python inkl. NumPy und SciPy durchführen. Die Stichprobe ist groß (50 Hähnchen):

Python-Code:
 import numpy as np
 import scipy.stats as stats
 
 # Stichprobe
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203]
 
 # Parameter definieren
 konfidenzniveau = 0.95
 mean = np.mean(daten)
 std = np.std(daten, ddof=1)
 stdfehler = stats.sem(daten)
 
 intervall = stats.norm.interval(confidence=konfidenzniveau, loc=mean, scale=stdfehler)
 
 print(f&quot;Mittelwert: {mean}&quot;)
 print(f&quot;Standardabweichung: {std}&quot;)
 print(f&quot;Konfidenzintervall: {intervall}&quot;)

Ausgabe:
 Mittelwert: 215.48
 Standardabweichung: 33.14238915925757
 Konfidenzintervall: (np.float64(206.29356722321992), np.float64(224.66643277678006))

Diese Werte stimmen gerundet mit denen im genannten Buch überein. Zum Code selbst:
* sem steht für '''s'''tandard '''e'''rror of the '''m'''ean.
* &lt;code&gt;scipy.stats.norm&lt;/code&gt; ... Modul für die Normalverteilung.

=== Punktschätzung ===
Gleiche Daten wie oben bei der Intervallschätzung.

Python-Code:
 import numpy as np
 from scipy import stats
 
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203
         ]
 
 mu_hat, sigma_hat = stats.norm.fit(daten) 
 
 print(f&quot;Schätzer für den Erwartungswert (μ): {mu_hat:.4f}&quot;)
 print(f&quot;Schätzer für die Standardabweichung (σ): {sigma_hat:.4f}&quot;)

Ausgabe:
 Schätzer für den Erwartungswert (μ): 215.4800
 Schätzer für die Standardabweichung (σ): 32.8093

=== Hypothesentests ===
Beispiel:

 import numpy as np
 import scipy.stats as stats
 
 x_quer = 12.075      # Stichproben-Mittelwert
 var    = 0.069       # Stichproben-Varianz
 n      = 90          # Stichprobengröße
 my_0   = 12.0        # Nullhypothese
 alpha  = 0.05        # Signifikanzniveau
 
 z_stat = (x_quer - my_0) / np.sqrt(var / n)
 p_val = 2 * (1 - stats.norm.cdf(np.abs(z_stat)))
 
 print(f&quot;Z-Statistik: {z_stat:.4f}&quot;)
 
 if p_val &lt; alpha:
     print(f&quot;p-Wert: {p_val:.6f} &lt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird verworfen.&quot;)
 else:
     print(f&quot;p-Wert: {p_val:.6f} &gt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird nicht verworfen.&quot;)

Ausgabe:

 Z-Statistik: 2.7087
 p-Wert: 0.006755 &lt; alpha: 0.05
 Die Nullhypothese wird verworfen.

== Statistische Qualitätskontrolle ==
Beispiel (Mittelwertkarte):

 import numpy as np
 import matplotlib.pyplot as plt
 
 # Gegeben
 sollwert = 50.0
 varianz = 4.0
 stichproben_umfang = 1
 daten = [49.5, 50.2, 53.0, 48.1, 52.6, 53.4, 49.8]
 
 # Berechnung
 standardabweichung = np.sqrt(varianz)
 streuung = standardabweichung / np.sqrt(stichproben_umfang)
 
 cl = sollwert
 ucl = cl + 3 * streuung
 lcl = cl - 3 * streuung
 
 # Darstellung
 plt.plot(daten, marker='o', linestyle='-', color='b', label='Messdaten')
 plt.axhline(cl, color='green', linestyle='-', label=f'CL: {cl}')
 plt.axhline(ucl, color='red', linestyle='--', label=f'UCL: {ucl:.2f}')
 plt.axhline(lcl, color='red', linestyle='--', label=f'LCL: {lcl:.2f}')
 
 plt.title('Mittelwertkarte')
 plt.xlabel('Stichprobe')
 plt.ylabel('Wert')
 plt.legend(loc='lower left')
 plt.grid(True)
 plt.show()

Ausgabe:

[[Datei:IngMath_mittelwertkarte.svg|300px]]

Siehe auch {{W|Shewhart-Regelkarte}} und {{W|Qualitätsregelkarte}}.

* UCL ... '''U'''pper '''C'''ontrol '''Limit''', Obere Eingriffsgrenze
* LCL ... '''L'''ower '''C'''ontrol '''Limit''', Untere Eingriffsgrenze
* CL ... '''C'''enter '''L'''ine, Mittellinie

= Ein- und Ausgabe =
== print ==
Die Anweisung print haben wir schon oft verwendet. Hier soll anhand von Beispielen kurz beschrieben werden, was der Befehl print leisten kann.

 print(&quot;Hallo&quot;, &quot;Welt&quot;, 1, sep=&quot;-&quot;)
 print(&quot;Hallo&quot;, end=&quot; &quot;)
 print(&quot;Welt&quot;)

Ausgabe:
 Hallo-Welt-1
 Hallo Welt

== input ==
 a = int(input(&quot;Zahl 1: &quot;))
 b = int(input(&quot;Zahl 2: &quot;))
 
 print(&quot;a + b = &quot;, a+b)

Ausgabe (nach Eingabe der beiden Ganzzahlen):
 Zahl 1: 4
 Zahl 2: 5
 a + b =  9

== Aus Dateien lesen ==
Es seinen die datei.txt
 Hallo Welt.
 Wie geht es dir?
 ...

und test1.py
 dat = open(&quot;datei.txt&quot;, mode = &quot;r&quot;)
 print(dat.read())
 dat.close()

Ausgabe
 Hallo Welt.
 Wie geht es dir?
 ...

Mit dem open()-Befehl wird die Datei datei.txt im Lesemodus geöffnet (r ... read). Mit dem read()-Befehl wird die Datei eingelesen und mittels print ausgegeben.

== In Dateien schreiben ==
 dat = open(&quot;datei.txt&quot;, mode = &quot;a&quot;, encoding = &quot;utf-8&quot;)
 dat.write(&quot;Hänge Zeile an\n&quot;)
 dat.close()

Die Datei datei.txt sieht nach Abarbeitung des obigen Skripts nun so aus
 Hallo Welt.
 Wie geht es dir?
 ...
 Hänge Zeile an

Es wird die Datei im Schreibmodus geöffnet (a ... append (anhängend), w ... write (überschreibend)).
write() fügt hier also eine Zeile Text am Dateiende ein. close() schließt die Datei wieder.

Das close() kann man sich mit der with-Anweisung auch sparen.

 with open(&quot;datei.txt&quot;, mode=&quot;a&quot;, encoding=&quot;utf-8&quot;) as dat:
     dat.write(&quot;Hänge Zeile an\n&quot;)

= Benutzeroberflächen erstellen =
== tkinter ==
{{Wikipedia | Tkinter}}

Python bietet standardmäßig das Modul tkinter zur Programmierung von Benutzeroberflächen. Es müssen also bei der Verwendung von tkinter keine externen Module installiert werden. Hier wird eine (sehr) kurze Einführung in das Erstellen von grafischen Oberflächen mittels tkinter gegeben.

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 win.minsize(300, 50)
 but = tk.Button(win, text = &quot;Push the button&quot;)
 but.pack()
 win.mainloop()

Ausgabe:

[[Datei:PythonIng_gui1.jpg]]

Ein etwas komplizierteres Beispiel sei nachfolgend gezeigt. Es sollen zwei Strings miteinander verknüpft und ausgegeben werden. 

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 
 def on_button_clicked():
     str = ent1.get() + ent2.get()
     lab2[&quot;text&quot;] = str
  
 ent1 = tk.Entry(win)
 ent2 = tk.Entry(win)
 lab1 = tk.Label(win, text=&quot;verknuepfen mit&quot;)
 lab2 = tk.Label(win, text=&quot;&quot;) 
 but = tk.Button(win, text = &quot;=&quot;, command=on_button_clicked)
 
 ent1.pack(side=&quot;left&quot;)
 lab1.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 but.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 lab2.pack(side=&quot;left&quot;)
 
 win.mainloop()

Ausgabe  (vor der Eingabe der Teilstrings): 

[[Datei:PythonIng_gui2.jpg]]

Ausgabe (nach der Eingabe der Teilstrings und dem Drücken des =-Buttons): 

[[Datei:PythonIng_gui3.jpg]]

== curses ==
{{Wikipedia | curses}}

Mit dem curses-Modul lassen sich u.a. TUIs ('''T'''ext '''U'''ser '''I'''nterfaces) erstellen. Ein sehr einfaches Beispiel zur allgemeinen Funktionsweise wird nachstehend geliefert.
 
 import curses
 
 stdscr = curses.initscr()
 curses.start_color()
 curses.init_pair(1, curses.COLOR_RED, curses.COLOR_WHITE)
 stdscr.clear()
 
 stdscr.addstr(&quot;Hallo Welt&quot;, curses.color_pair(1))
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()
 
Als Ausgabe sollte &lt;span style=&quot;color:#FF0000;&quot;&gt;Hallo Welt&lt;/span&gt; (rote Schrift auf weißem Hintergrund) auf dem Terminal/der Konsole erscheinen. Getestet wurde dies mit openSUSE Tumbleweed, Python-Version 3.13.12. Das entsprechende Python-curses-Package muss installiert sein.

Allgemeine Informationen zur Terminal-/Konsolengröße und Cursorposition liefert folgendes Programm:
 
 import curses
 
 stdscr = curses.initscr()
 
 stdscr.addstr(3, 5, &quot;LINES: %d&quot; % curses.LINES)
 stdscr.addstr(4, 5, &quot;COLS:  %d&quot; % curses.COLS)
 
 (y,x) = stdscr.getyx()
 stdscr.addstr(5, 5, &quot;Momentane Cursorposition:  [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getbegyx()
 stdscr.addstr(6, 5, &quot;Koordinatenursprung:       [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getmaxyx()
 stdscr.addstr(7, 5, &quot;Fenstergröße:              [%d, %d]&quot; % (y, x))
 
 stdscr.addstr(11, 2, &quot;Taste drücken -&gt; Ende&quot;)
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()

Es sollte sich in etwa folgende Ausgabe ergeben:

     LINES: 44
     COLS:  110
     Momentane Cursorposition:  [4, 15]
     Koordinatenursprung:       [0, 0]
     Fenstergröße:              [44, 110]
 
 
 Taste drücken -&gt; Ende

Zur Funktionsweise von curses siehe auch das Wikibook [[ncurses]]. Zum Verständnis sind dort allerdings elementare Kenntnisse in der Programmiersprache C erforderlich.

== Qt ==
{{Wikipedia | Qt (Bibliothek)}}

Auch für das Qt-Framework gibt es eine Anbindung an Python. Nachfolgend ein einfaches Beispiel.

 import sys
 from PySide6.QtWidgets import QApplication, QLabel
 
 app = QApplication(sys.argv)
 label = QLabel(&quot;Hallo Welt!&quot;)
 label.show()
 sys.exit(app.exec())

Ausgabe:

[[Datei:PythonIng_gui10.png]]

== Gtk ==
{{Wikipedia | GTK (Programmbibliothek)}}

Eine idente Ausgabe, wie oben für Qt gezeigt, erzeugt z.B. folgendes Gtk-Programm:

 import gi
 gi.require_version(&quot;Gtk&quot;, &quot;4.0&quot;)
 from gi.repository import Gtk
 
 def on_activate(app):
     win = Gtk.ApplicationWindow(application=app)
     lab = Gtk.Label(label=&quot;Hallo Welt!&quot;)
     win.set_child(lab)
     win.present()
 
 app = Gtk.Application()
 app.connect('activate', on_activate)
 app.run(None)

Auch für die Benutzung von Qt und Gtk müssen die jeweiligen Packages installiert sein. Getestet wurden die entsprechenden Python-Programme nur unter openSUSE Tumbleweed. Wie das GTK-Paket unter MS Windows 11 installiert wird, siehe z.B. [https://www.gtk.org/docs/installations/windows Setting up GTK for Windows].

Damit sei aber das Thema &quot;Benutzeroberflächen erstellen&quot; hier abgeschlossen, da dies schon ein sehr spezielles Aufgabengebiet ist, das eher Informatiker und nicht so sehr Ingenieure anspricht. Bei Bedarf siehe aber ggf. die entsprechenden Links unten in diesem Tutorial. Dort sind weiterführende Informationen zu finden.

= Pandas kurz erklärt =
Hier wird kurz auf das externe Modul Pandas eingegangen. Pandas steht für '''Pan'''el '''Da'''ta und ist ein Modul für die Datenanalyse und -manipulation.

== Series ==
Vorstellbar ist eine &quot;Series&quot; wie eine einzelne Spalte in einem Tabellenkalkulationsprogramm.

Beispiel (Index implizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5]) # Temperaturwerte
 print(temp)

Ausgabe:
 0     8.5
 1    11.0
 2    12.5
 3    10.0
 4    13.0
 5    11.0
 6    14.5
 dtype: float64

Das Kürzel &lt;code&gt;pd&lt;/code&gt; ist Konvention. Es seien Temperaturwerte gegeben. Die erste Spalte bei der Ausgabe ist der Index. Die zweite Spalte enthält die Werte.

Beispiel (separater Zugriff auf den Index und auf die Werte):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5])
 print(temp.index)
 print(temp.values)

Ausgabe:
 RangeIndex(start=0, stop=7, step=1)
 [ 8.5 11.  12.5 10.  13.  11.  14.5]

Beispiel (Index explizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 print(&quot;*** Die gesamte Series ***&quot;)
 print(temp)
 
 print(&quot;*** Temperatur am Donnerstag ***&quot;)
 print(temp[&quot;Do&quot;])
 
 print(&quot;*** Tage wärmer als 12 Grad ***&quot;)
 temp_gr_12 = temp[temp &gt; 12]
 print(temp_gr_12)

Ausgabe:
 *** Die gesamte Series ***
 Mo     8.5
 Di    11.0
 Mi    12.5
 Do    10.0
 Fr    13.0
 Sa    11.0
 So    14.5
 dtype: float64
 *** Temperatur am Donnerstag ***
 10.0
 *** Tage wärmer als 12 Grad ***
 Mi    12.5
 Fr    13.0
 So    14.5
 dtype: float64

== DataFrame ==
Ein DataFrame entspricht einer Tabelle.

Beispiel (Erzeugen eines DataFrames):
 import pandas as pd
 
 tag   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 v1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=tag)
 v2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=tag)
 v3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=tag)
 
 tab = pd.concat([v1, v2, v3], axis=1)
 tab.columns = stadt
 
 print(tab)
 print(type(tab))

Ausgabe:
     Linz  Salzburg Innsbruck
 Mo     1         8     Hallo
 Di     2         9        16
 Mi     3        10        17
 Do     4        11        18
 Fr     5        12        19
 Sa     6        13        20
 So     7        14        21
 &lt;class 'pandas.core.frame.DataFrame'&gt;

Wir haben hier drei Datenspalten (v1, v2, v3) mit den Spaltennamen &quot;Linz&quot;, &quot;Salzburg&quot; und &quot;Innsbruck&quot;, sowie sieben Zeilen &quot;Mo&quot; bis &quot;So&quot;.

Beispiel (Zugriff auf eine Spalte):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab[&quot;Salzburg&quot;])

Ausgabe:
 Mo     8
 Di     9
 Mi    10
 Do    11
 Fr    12
 Sa    13
 So    14
 Name: Salzburg, dtype: int64

Beispiel (Zugriff auf eine Zeile):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab.loc[&quot;Di&quot;])

Ausgabe:
 Linz          2
 Salzburg      9
 Innsbruck    16
 Name: Di, dtype: object

== Grafiken erstellen ==
Hier sei nur ein Torten- oder Kreisdiagramm gezeichnet:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 expl = [0, 0.2, 0, 0, 0, 0, 0]
 temp.plot.pie(figsize=(5,5), explode=expl)
 plt.show()

Ausgabe:

[[Datei:IngPython_pandas1.svg|350px]]

Die &lt;code&gt;figsize&lt;/code&gt; hat nichts mit der Spaltenanzahl zu tun, sondern setzt die Fenster- oder Diagrammgröße in Inches (Breite * Höhe).
 
Mit Pandas kann man auch noch andere Diagrammarten erstellen, z.B. Linien- oder Balkendiagramme. Dies wird hier aber nicht vorgeführt.

== Arbeiten mit CSV- und LibreOffice-Dateien ==
Gegeben sei eine CSV-Datei test1.csv:
 Mai;Juni;Juli
 12;17;45
 15;65;65
 16;32;23
 4;14;7
 23;17;Keine Daten verfügbar
 67;Keine Daten verfügbar;45
 15;24;12

Lesen von dieser CSV-Datei:
 import pandas as pd
 
 tab = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 print(tab)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Schreiben in eine CSV-Datei test2.csv:
 import pandas as pd
 
 val = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 val.to_csv(&quot;test2.csv&quot;, index=False)

Ausgabedatei:
 Mai,Juni,Juli
 12,17,45
 15,65,65
 16,32,23
 4,14,7
 23,17,Keine Daten verfügbar
 67,Keine Daten verfügbar,45
 15,24,12

Die Ausgabedatei ist beinahe gleich wie die Eingabedatei. Es werden aber Kommas statt Strichpunkten verwendet. Daher kommt auch der Name CSV ('''C'''omma '''S'''eparated '''V'''alue). Will man wieder Strichpunkte, so kann man dies über den Parameter &lt;code&gt;sep=&quot;;&quot;&lt;/code&gt; in der &lt;code&gt;to_csv&lt;/code&gt;-Funktion machen.

Um direkt von einer ODS-Datei (LibreOffice Calc, '''O'''pen '''D'''ocument '''S'''preadsheet) zu lesen muss das Modul odfpy extra installiert sein (per YaST, pip etc.). Gelesen wird dann folgendermaßen:
 import pandas as pd
 
 df = pd.read_excel('test1.ods', engine='odf')
 print(df)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Die Datei &quot;test1.ods&quot; sei die Datei, aus der das obige &quot;test1.csv&quot; generiert wurde. Schreiben kann man ebenfalls in eine ODS-Datei:

 import pandas as pd
 
 daten = {
     &quot;Name&quot;: [&quot;Hugo&quot;, &quot;Richie&quot;, &quot;Wilhelmine&quot;],
     &quot;Alter&quot;: [38, 30, 29],
     &quot;Ort&quot;: [&quot;Linz&quot;, &quot;Innsbruck&quot;, &quot;Salzburg&quot;]
 }
 
 tab = pd.DataFrame(daten)
 
 with pd.ExcelWriter(&quot;test2.ods&quot;, engine=&quot;odf&quot;) as writer:
     tab.to_excel(writer, sheet_name=&quot;Daten&quot;, index=False)

Es ergibt sich eine &quot;test2.ods&quot;-Datei (Screenshot):

[[Datei:IngPython_pandas2.png|250px]]

== Sonstiges ==
Hier seien stichpunktartig einige weitere Features von Pandas angeführt:
* {{W|Pivot-Tabelle|Pivot-Tabellen}} (pivot ... Dreh-, Angelpunkt): Zweck - große Datenmengen schnell zusammenfassen, filtern und analysieren.
* NaN ('''n'''ot '''a''' '''n'''umber): In einem Datensatz fehlt ein Wert oder ist nicht definiert.
* groupby-Funktion: Daten strukturieren, aggregieren oder Zwischensummen bilden. 
* {{W|Binning#Datenverarbeitung_und_-analyse|Binning}}: Klassenbildung.
* Mehrstufige Indizierung (Hierarchical Indexing oder MultiIndex).
* Zeitreihen (Time Series).
* MS Excel-Dateien schreiben mit dem Modul openpyxl.

Für tiefergehende und weiterführende Informationen wird auf das Buch von ''Klein: Numerisches Python; Hanser, 2023'' und [https://pandas.pydata.org/ pandas] verwiesen.

= Style Guide, flake8, pylint, Black etc. =
== Style Guide ==
Wie man schönen und richtigen Python-Code schreibt, erfahren Sie in
* [https://peps.python.org/pep-0008/ PEP 8 – Style Guide for Python Code]

== Formatter und Linter ==
Ein Modul, das prüft, ob die Richtlinien im Style Guide eingehalten wurden, ist ''flake8'':
* [https://flake8.pycqa.org/en/latest/ Flake8: Your Tool For Style Guide Enforcement]

Code formatieren kann man auch mit [https://pypi.org/project/black/ Black]. Z.B. übersetzt &lt;code&gt;black test1.py&lt;/code&gt; die Datei &lt;code&gt;test1.py&lt;/code&gt;

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)),
     (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

in 

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)), (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Die Programmausgabe ist 

 reformatted test1.py
 
 All done! ✨ 🍰 ✨
 1 file reformatted.

Der Unterschied zwischen Black und Flake8:
* Black ist ein Code-Formatter. Er formatiert Ihren Code um, sodass er im Einklang mit PEP 8 steht.
* Flake8 ist ein {{W|Lint (Programmierwerkzeug) | Code-Linter}}. Flake8 verändert Ihren Code nicht, sondern durchsucht ihn nach potenziellen Fehlern etc.

Am obigen Beispiel sieht man auch, dass flake8 und Black nicht immer einer Meinung sind. Flake8 (&lt;code&gt;flake8 test1.py&lt;/code&gt;) würde standardmäßig den mit Black formatierten Code bemängeln:

 test1.py:8:80: E501 line too long (80 &gt; 79 characters)

Diese Diskrepanz kann beseitigt werden. Da 79 Zeichen auf modernen Bildschirmen meist als zu kurz empfunden werden, ist ein Limit von 88 Zeichen (Black-Standard) oder mehr empfehlenswert. Um dies zu implementieren, erstellen Sie in Ihrem Projektverzeichnis eine &lt;code&gt;.flake8&lt;/code&gt;-Datei mit dem Inhalt

 [flake8]
 max-line-length = 88

Und schon ignoriert Flake8 dieses Problem.

Ein anderer Linter ist pylint. Der würde beim Abarbeiten des obigen Beispiels, z.B. mit &lt;code&gt;pylint test1.py&lt;/code&gt; noch eine Kleinigkeit bemängeln:

 ************* Module test1
 /home/hr/tmp/test1.py:1:0: C0114: Missing module docstring (missing-module-docstring)
 
 ------------------------------------------------------------------
 Your code has been rated at 8.57/10 (previous run: 8.57/10, +0.00)

Auch pylint muss vor der ersten Verwendung installiert werden (z.B. mittels pip, virtuelle Umgebung, YaST). Die Dokumentation zu pylint findet sich auf [https://pylint.readthedocs.io/en/latest/].

&lt;u&gt;Aufgabe:&lt;/u&gt; Fügen Sie einen &quot;module docstring&quot; in die &lt;code&gt;test1.py&lt;/code&gt;-Datei ein und testen Sie erneut mit flake8, Black und pylint. &lt;small&gt;Sehen Sie zum Thema docstrings auch [https://peps.python.org/pep-0257/#what-is-a-docstring PEP 257 – Docstring Conventions].&lt;/small&gt;

Es gibt noch weitere Formatierungswerkzeuge für Python-Code. Z.B. [https://docs.astral.sh/ruff/ Ruff], ein moderner Code-Formatter und -Linter. Mittels &lt;code&gt;ruff check test1.py&lt;/code&gt; würde obiger Code geprüft (Linter). &lt;code&gt;ruff format test1.py&lt;/code&gt; formatiert den Code (Formatter).

== Type Checker ==
&quot;Type Checker&quot; sind z.B.
* mypy
* pyright
* ty

Diese prüfen die Datentypen, z.B. in folgendem Code

 def greetings(name: str) -&gt; str:
     return &quot;Hello, %s&quot; % name
 
 
 print(greetings(42))

Python selbst, flake8, ruff oder black würden diesen Code ohne zu murren akzeptieren. &quot;Type Checker&quot; würden aber sehr wohl Alarm schlagen, z.B. liefert &lt;code&gt;mypy&lt;/code&gt; folgende Ausgabe

 test1.py:5: error: Argument 1 to &quot;greetings&quot; has incompatible type &quot;int&quot;; expected &quot;str&quot;  [arg-type]
 Found 1 error in 1 file (checked 1 source file)

Das funktioniert übrigens nicht nur bei Funktionsannotationen, sondern auch mit Variablen etc.

 from typing import Final
 
 # &quot;Konstante&quot;, ab Python 3.8
 NUMBER: Final = 123
 print(NUMBER)
 NUMBER = 125
 print(NUMBER)
 
 # Variable
 a: int = 345
 print(a)
 a = &quot;Irgendwas&quot;
 print(a)
 
 # Variable (Pipe-Symbol), ab Python 3.10
 b : int|str = 567
 print(b)
 b = &quot;sonstiges&quot;
 print(b)

Ausgabe mit python:
 123
 125
 345
 Irgendwas
 567
 sonstiges

Ausgabe mit mypy:
 test3.py:6: error: Cannot assign to final name &quot;NUMBER&quot;  [misc]
 test3.py:12: error: Incompatible types in assignment (expression has type &quot;str&quot;, variable has type &quot;int&quot;)  [assignment]
 Found 2 errors in 1 file (checked 1 source file)

Python kennt übrigens keine Konstanten. Man kann diese mittels Großbuchstaben andeuten. Das ist aber nur Konvention, hat aber keine sonstigen Auswirkungen. Oder man verwendet wie oben gezeigt &lt;code&gt;Final&lt;/code&gt;. Dann werfen Typchecker Errors aus.

==pydoc==
pydoc ist ein Werkzeug, um Python-Module, -Funktionen und -Klassen zu dokumentieren.

Beispiel &lt;code&gt;test1.py&lt;/code&gt;:
 &quot;&quot;&quot;Rechen-Modul.
 
 Funktionen die von pydoc gelesen werden.
 &quot;&quot;&quot;
 
 def multiply(a, b):
     &quot;&quot;&quot;Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
     
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a * b
     
 def add(a, b):
     &quot;&quot;&quot;Addiert zwei Zahlen und gibt das Ergebnis zurück.
    
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a + b
    
 
 if __name__ == '__main__':
     print(multiply(3, 5))
     print(add(4, 6))

Ausgabe mit &lt;code&gt;python3.13 -m pydoc test1&lt;/code&gt; auf der Konsole:

 Help on module test1:
 
 NAME
     test1 - Rechen-Modul. 
 
 DESCRIPTION
     Funktionen die von pydoc gelesen werden.
 
 FUNCTIONS
     add(a, b)
         Addiert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
     multiply(a, b)
         Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
 FILE
     /home/xyz/tmp/test1.py

Siehe zu diesem Thema z.B. auch [https://docs.python.org/3/library/pydoc.html]. Mittels &lt;code&gt;python3.13 -m pydoc -w test1&lt;/code&gt; kann man auch eine HTML-Dokumentation erstellen.

Wofür &lt;code&gt;if __name__ == '__main__':&lt;/code&gt; steht, siehe z.B. etwas später im Abschnitt [[Ing_Mathematik:_Python#Doctests]].

== Sonstige Tools ==
Andere Tools für die {{W|Statische Code-Analyse|statische Codeanalyse}}, die aber für Ingenieure weniger interessant sein dürften, sind z.B.
* Radon: Liefert verschiedene {{W|Softwaremetrik|Codemetriken}} (Komplexität, Wartbarkeitsindex ...)
* Bandit: Findet Sicherheitslücken

Tools für die {{W|Dynamisches Software-Testverfahren|dynamische Codeanalyse}}, z.B.:
* DynaPyt (Framework zur dynamischen Programmanalyse)
* cProfile (Profiler)
* Memory Profiler (Speicheranalyse)
* Memray (Speicheranalyse)
* tracemalloc (Speicheranalyse)

Paket- und Projektmanagement (pip-Ersatz etc.):
* uv
* Poetry
* Conda
* pipx

Packaging-Tools (Freezer) und {{W|Compiler#Sonderformen|Transpiler}} :
* pyinstaller
** erstellt eigenständige, ausführbare Binärdatei
** kein Cross-Compiler
** kein Schutz vor Reverse-Engineering
** langsam
** packt alles in eine Datei
** sehr große Datei
** Befehl, z.B.: &lt;code&gt;pyinstaller --onefile test1.py&lt;/code&gt;
** GUI: &lt;code&gt;auto-py-to-exe&lt;/code&gt;
* cx_Freeze
* nuitka
** Übersetzt Python-Code in C/C++-Code und weiter in eine ausführbare Datei
** kein Cross-Compiler
** Schutz vor Reverse-Engineering
** Befehl, z.B.: &lt;code&gt;nuitka --standalone --onefile test1.py&lt;/code&gt;
* cython

= Einige Integrierte Entwicklungsumgebungen (IDEs)=
Werden Programmtexte größer und umfangreicher, so ist das Arbeiten mit der interaktiven Programmierumgebung bzw. das direkte Ausführen von Python-Skripten mühsam. Man wünscht sich z.B. Hilfen zum Debuggen oder die automatische Code-Vervollständigung. Zu diesem Zweck wurden IDEs (Integrated Development Environments) geschaffen. Von diesen seinen nachfolgend auszugsweise einige kurz beschrieben. Testen Sie einfach aus, welche davon für Sie bzw. für Ihr Python-Projekt geeignet sind.

== IDLE ==
IDLE ist die mit dem Python-Programmpaket mitgelieferte IDE. Der Name leitet sich einerseits ab vom Monty-Python-Mitglied Eric Idle, andererseits steht es als Abkürzung für &quot;'''I'''ntegrated '''D'''evelopment and '''L'''earning '''E'''nvironment. IDLE ist einfach zu bedienen, bietet aber schon einen beachtlichen Leistungsumfang. Nachfolgend wird ein Screenshot zu IDLE geliefert. Rechts ist das Editor-Fenster zu sehen, links die interaktive Programmierumgebung. Um das Beispiel selbst nachvollziehen zu können, starten Sie IDLE. Das geht ähnlich, wie Sie die interaktive Programmierumgebung von Python starten (nur, dass Sie eben das IDLE-Icon doppelklicken und nicht das Python-Icon. Unter Linux geben Sie einfach in einem Terminal &lt;code&gt;idle3.13&lt;/code&gt; o. Ä. ein). Weiter geht es mit &quot;File - Open - ...&quot;. Die auszuführende Datei auswählen (im konkreten Fall ein &quot;Hallo-Welt&quot;-Programm). Es erscheint das rechte Fenster. Dort &quot;Run - Run Module&quot; auswählen. Und schon wird im linken Fenster &quot;Hallo Welt!&quot; ausgegeben.

[[Datei:PythonIng_idle1.jpg | 600px]]

Siehe auch {{W|IDLE}}.

== PyCharm ==
PyCharm ist ein kommerzielles Produkt. Es gab aber auch eine kostenlose Community Edition. Seit 2025 sind beide Varianten vereint. Für die ersten 30 Tage sind die Pro-Funktionen frei verfügbar, danach nur noch die Kernfunktionalitäten (oder man bezieht kostenpflichtig  die Pro-Version). Zu beziehen ist PyCharm unter dem Weblink [https://www.jetbrains.com/pycharm/]. Nachfolgend ein etwas abgewandeltes &quot;Hallo Welt&quot;-Programm, editiert und ausgeführt mit PyCharm.

[[Datei:PyCharm_IDE_2023_screenshot.png | 600px]]

Siehe auch {{W|PyCharm}}.

== Eric ==
Auch eric ist Open Source und steht unter der  GNU General Public License Version 3 oder später. Zu beziehen ist diese Software unter [https://eric-ide.python-projects.org/].

[[Datei:Screenshot_Eric_4.png | 600px]]

Siehe auch {{W|eric (Software)}}.

&lt;small&gt;
Unter openSUSE Tumbleweed sollte sich eric auch mit YaST installieren lassen. Bei mir gibt es aber dann beim Ausführen des eric-Programms eine Fehlermeldung (Stand März 2026): 
 
 ...
 ModuleNotFoundError: No module named 'PyQt6.QtPdfWidgets'

Umgehen kann man dieses Problem aber wieder mit dem Erstellen einer virtuellen Umgebung, in etwa so

 python3.13 -m venv ~/tmp/venv1
 cd ~/tmp/venv1/bin
 ./python3.13 -m pip install --upgrade --prefer-binary eric-ide
 ./eric7_ide
&lt;/small&gt;

== PyScripter ==
Vom Funktionsumfang vergleichbar mit den vorherigen IDEs ist PyScripter. Auch PyScripter ist Open Source. Die Projekt-Homepage findet sich auf [https://sourceforge.net/projects/pyscripter/]. PyScripter ist nur für MS Windows verfügbar.

[[Datei:PythonIng_pyscripter1.jpg | 600px]]

== Spyder IDE ==
Spyder enthält bereits eine stabile Python-Version und etliche Module (z.B. matplotlib, numpy, control). Ansonsten kann dieses Softwarepaket vom Funktionsumfang her mit den anderen genannten IDEs locker mithalten. Spyder wurde unter der MIT-Lizenz veröffentlicht. Diese Software findet sich auf [https://www.spyder-ide.org].

[[Datei:Spyder-windows-screenshot.png | 600px]]

Siehe auch {{W|Spyder (Software)}}

== Eclipse IDE==
Die {{W|Eclipse_(IDE)|Eclipse-IDE}} kann für Python aufgerüstet werden. Dazu gibt es das PyDev-Plugin. Installiert wird es über 
* Help &gt; Eclipse Marketplace... 
* Find - PyDev - Install
Danach muss noch der Pfad zum Python-Interpreter festgelegt werden 
* Window &gt; Preferences &gt; PyDev &gt; Interpreters &gt; Python Interpreter &gt; New ... 
Das Ergebnis ist ähnlich wie im folgenden Bild, nur dass statt C/C++ Python Verwendung findet. 

[[Datei:Setting Up Eclipse CDT helloout.png | 600px]]

== Sonstige ==
Die genannten IDEs sind nicht die Einzigen. Es gibt, um dem Image Pythons als beliebteste Programmiersprache gerecht zu werden, noch einige andere. Sowohl Open Source-Programme als auch kommerzielle Programme sind im Web zu finden, z.B. Thonny oder {{W|Visual Studio Code}}. Unter Linux kann man auch {{W|KDevelop}}, ausgestattet mit dem Python3-Plugin, einsetzen. Braucht man den Umfang von ausgewachsenen IDEs nicht, so kann man auch normale Texteditoren verwenden (z.B. {{W|Geany}} oder {{W|Kate_(Texteditor)|Kate}}).

= Debuggen und Testen =
Das Debuggen und Testen von Programmen sind wichtige Bestandteile der Programmierung. Syntaxfehler lassen sich i.A. leicht beheben. Schwieriger ist das Eingrenzen von logischen Fehlern, die ev. nur in bestimmten Situationen auftreten und keine explizite Fehlermeldung hervorrufen. Das Programm liefert falsche Ergebnisse oder es stürzt aus heiterem Himmel ab. Um das zu verhindern gibt es verschiedene Werkzeuge, die bei der Fehlersuche behilflich sein können. Vorerst siehe aber zwecks Begriffsklärung noch folgende Links: 
 
* {{W|Debuggen}}
* {{W|Debugger}}
* {{W|Softwaretest}}

&lt;gallery&gt;
First Computer Bug, 1947.jpg
Test ganzheitlich.png
V-Modell.svg
&lt;/gallery&gt;

== Das Modul pdb ==
Python bringt schon ein Modul zum Debuggen mit. Siehe z.B. [https://docs.python.org/3/library/pdb.html pdb — The Python Debugger].
Komfortabler lässt sich das aber mittels Integrierter Entwicklungsumgebungen (IDEs) angehen.

== Debuggen mit IDEs ==
Für die IDEs IDLE und Spyder sei kurz auf die entsprechenden Webseiten verwiesen:

* [https://www.cs.uky.edu/~keen/help/debug-tutorial/debug.html Debugging under IDLE].
* [https://docs.spyder-ide.org/current/panes/debugging.html Spyder Debugger]

Dort wird die Vorgehensweise auch mittels Screenshots erläutert.

== assert ==
assert ... behaupten, zusichern ({{W|Assertion (Informatik)}})

Python-Code:
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10., 0.)

Ausgabe:

 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10., 0.)
   File &quot;/home/hr/Develop/test1.py&quot;, line 4, in print1
     assert y != 0.0
            ^^^^^^^^
 AssertionError
 
Python-Code: 
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)
 
Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(&quot;10.&quot;, &quot;5.&quot;)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError
 
Aber auch bei nachfolgendem Code gibt es eine Fehlermeldung:

 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10, 5)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError

Damit letzteres funktioniert, kann man den Programmcode so umschreiben:
 def print1(x, y):
     assert type(x) == float or type(x) == int
     assert type(y) == float or type(y) == int
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 2.0
 
Und jetzt fangen wir den &lt;code&gt;AssertionError&lt;/code&gt; auf:
 def print1(x, y):
     try:
         assert type(x) == float or type(x) == int
         assert type(y) == float or type(y) == int
         assert y != 0.0
         print(x/y)
     except(AssertionError):
         print(&quot;Hallo&quot;)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)

Ausgabe:
 2.0
 Hallo

Ich hoffe, es ist wenigstens im Ansatz klar geworden, wofür &lt;code&gt;assert&lt;/code&gt; gut sein kann. Ausschalten kann man die &lt;code&gt;assert&lt;/code&gt;-Überprüfung übrigens mit dem Python-Schalter &lt;code&gt;-O&lt;/code&gt;.

== Doctests == 
Innerhalb eines Docstrings kann die Arbeit im interaktiven Modus simuliert werden. Nach den Promptzeichen (&gt;&gt;&gt;) erfolgen dann bei unserem Beispiel innerhalb des Docstrings simulierte Aufrufe der Funktion &lt;code&gt;print1()&lt;/code&gt;. Danach folgen jeweils die Sollresultate. Wird das Modul oder die Datei als Hauptprogramm aufgerufen, so wird die Funktion &lt;code&gt;doctest.testmode()&lt;/code&gt; aufgerufen und ein Bericht auf der Konsole ausgegeben. Wird das Modul nicht als Hauptprogramm aufgerufen, sondern importiert, dann wird diese &lt;code&gt;testmod&lt;/code&gt;-Funktion nicht aufgerufen. D.h. dieser Code kann sowohl für Testzwecke als auch für den produktiven Einsatz verwendet werden. Das ist auch sinnvoll, weil wenn man Teile der Datei immer löschen bzw. einfügen müsste, so würden sich Fehlerquellen auftun. Das würde den Sinn und Zweck von Doctests konterkarieren.  

 def print1(x=0., y=1.):
     &quot;&quot;&quot; Dividiere zwei Zahlen
     Autor: Intruder
     Datum: 12.08.2025
 
     &gt;&gt;&gt; print1(2., 1.)
     2.0
     &gt;&gt;&gt; print1(5., 2.)
     2.5
     &gt;&gt;&gt; print1(5.)
     5.0
     &quot;&quot;&quot;
     print(x/y)
 
 if __name__ == &quot;__main__&quot;:
     import doctest
     doctest.testmod(verbose=True)

Ausgabe:
 Trying:
     print1(2., 1.)
 Expecting:
     2.0
 ok
 Trying:
     print1(5., 2)
 Expecting:
     2.5
 ok
 Trying:
     print1(5.)
 Expecting:
     5.0
 ok
 1 items had no tests:
     __main__
 1 items passed all tests:
    3 tests in __main__.print1
 3 tests in 2 items.
 3 passed and 0 failed.
 Test passed.

Das gezeigte Beispiel ist so ziemlich das einfachste, das es gibt. Für weiterführende Details siehe z.B.:
* [https://peps.python.org/pep-0257/ PEP 257 – Docstring Conventions]
* [https://docs.python.org/3/library/doctest.html doctest — Test interactive Python examples]

''Einschub:'' Ganz ähnlich kann man auch Klassen testen, z.B. in folgendem Code-Fragment

 class Fahrzeug:
   # siehe Abschnitt &quot;Objektorientierte Programmierung&quot;
   # ...
 
 if __name__ == &quot;__main__&quot;:
   vauweh = Fahrzeug(170, 90)
   beemweh = Fahrzeug(200, 120)
   print(vauweh.convertGeschw())
   print(beemweh.convertGeschw())

Wird das Script als Hauptprogramm ausgeführt (z.B. zu Testzwecken), so erfolgt die Ausgabe der zwei, via &lt;code&gt;convertGeschw()&lt;/code&gt;, umgerechneten Geschwindigkeiten. Wird es aber als Modul eingebunden, so wird der letzte Programmabschnitt nicht ausgeführt (&lt;code&gt;__name__ == &quot;__main__&quot;&lt;/code&gt; ergibt &lt;code&gt;False&lt;/code&gt;).

== pytest ==
Siehe zu diesem Thema auch {{W|Modultest}}.

pytest ist ein externes Modul und muss vorab installiert werden, z.B. mittels 
 pip install -U pytest
 pip install -U pytest-html 

Python-Code, Datei test1.py:
 def add(x, y):
     return x + y
 
 def test_answer():
     assert add(1, 1) == 3

Starten von pytest in der Konsole:
 pytest test1.py
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py F                                                                                                            [100%]
 
 ========================================================= FAILURES ==========================================================
 ________________________________________________________ test_answer ________________________________________________________
 
     def test_answer():
 &gt;       assert add(1, 1) == 3
 E       assert 2 == 3
 E        +  where 2 = add(1, 1)
 
 test1.py:6: AssertionError
 ================================================== short test summary info ==================================================
 FAILED test1.py::test_answer - assert 2 == 3
 ===================================================== 1 failed in 0.09s =====================================================

Hier erhalten wir einen Fehler, da 1+1 eindeutig ungleich 3 ist. Aber aus irgendeinem Grund wollte der Programmierer oder Tester in diesem Fall, dass dies so ist. Testfälle werden übrigens mit dem Präfix &lt;code&gt;test_&lt;/code&gt; eingeleitet.

Python-Code:
 def add(x, y):
     return x + y + 1
 
 def test_answer():
     assert add(1, 1) == 3 
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py .                                                                                                            [100%]
 
 ===================================================== 1 passed in 0.01s =====================================================

Jetzt ist alles in Ordnung. Weiterführendes siehe z.B.

* [https://docs.pytest.org/en/stable/ pytest: helps you write better programs]

== unittest ==
Auch unittest dient zur Durchführung von Testreihen, ist aber Bestandteil von Python. Hier wird vorerst nicht näher darauf eingegangen. Siehe z.B. 
* [https://docs.python.org/3/library/unittest.html unittest — Unit testing framework]

Lt. ''Inden: Python Challenge; dpunkt, 2021, Seite 481''  soll unittest weniger komfortabel als pytest sein.

Einen Vergleich von unittest mit pytest findet man in
* [https://knapsackpro.com/testing_frameworks/difference_between/pytest/vs/unittest pytest vs unittest]

= Python und Anwendungsprogramme =
Bisher stand immer alleine die Programmiersprache Python (ev. unter Einbeziehung von Modulen) im Mittelpunkt der Betrachtungen. Aber Python kann auch als Makrosprache für Anwendungsprogramme auftreten. Als Beispiele seien {{W|FreeCAD}} und {{W|LibreOffice}} genannt.

== FreeCAD ==
FreeCAD ist ein freies 3D-CAD-Programm. Hier soll nicht auf die Bedienung dieses CAD-Pakets eingegangen werden, sondern nur auf die Möglichkeit, mittels Python Makros zu schreiben. Als einfacher Einstieg soll ein Makro erstellt werden, welches eine Kugel (rot) und einen Quader (blau) zeichnet. Folgende Vorbereitungsschritte sind erforderlich (es sei vorausgesetzt, dass FreeCAD schon am Rechner installiert ist. Downloaden können Sie das Programm von der Website [https://www.freecad.org/downloads.php?lang=en]):

* FreeCAD starten
* Leere Datei erstellen
* Makro &gt; Makros &gt; Erstellen ...

Es öffnet sich ein leeres Editorfenster, in das Sie folgenden Code eingeben können:

 import FreeCAD
 import Part
 
 doc = FreeCAD.newDocument()
 
 # Kugel
 kugel = Part.makeSphere(10)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Kugel&quot;)
 form_element.Shape = kugel
 kug = FreeCAD.ActiveDocument.getObject(&quot;Kugel&quot;)
 kug.ViewObject.ShapeColor = (1.0, 0.0, 0.0)
 neuePosition = App.Vector(5, 2.5, 2.5)
 kug.Placement = App.Placement(neuePosition, kug.Placement.Rotation)
 
 # Quader
 quader = Part.makeBox(5, 5, 50)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Quader&quot;)
 form_element.Shape = quader
 quad = FreeCAD.ActiveDocument.getObject(&quot;Quader&quot;)
 quad.ViewObject.ShapeColor = (0.0, 0.0, 1.0)
 
 doc.recompute()

Diesen Code können Sie nun ausführen:
* Makro &gt; Makro ausführen

Es ergibt sich folgende Ausgabe (gedreht und gezoomt):

[[Datei: PythonIng_freecad1.png|500px]]

Siehe auch [https://wiki.freecad.org/Python_scripting_tutorial/de# Anleitung Skripterstellung mit Python]. Getestet wurde obiges Beispiel mit FreeCAD 1.1.3 unter Linux und 1.1.1 unter MS Windows.

== LibreOffice ==
LibreOffice ist ein freies Officepaket ([https://de.libreoffice.org/]). Hier soll nur das Tabellenkalkulationsprogramm Calc kurz betrachtet werden. Es seinen in den ersten 3 Zellen (A1 bis A3) Zahlen gegeben. Diese sollen mit einem Python-Makro addiert und das Resultat in der Zelle A5 ausgegeben werden. Auch hier sind Vorbereitungsarbeiten nötig: 
* zuerst muss unter Linux das Verzeichnis &lt;code&gt;~/.config/libreoffice/4/user/Scripts/python&lt;/code&gt; erstellt werden
* für MS Windows ist es das Verzeichnis &lt;code&gt;%APPDATA%\LibreOffice\4\user\Scripts\python&lt;/code&gt; 
** drücken Sie zuerst Win + R (es öffnet sich das Ausführen-Fenster)
** geben Sie &lt;code&gt;%appdata%&lt;/code&gt; ein, danach drücken Sie Enter (es öffnet sich der Explorer)
** navigieren Sie zu dem genannten Verzeichnis bzw. erstellen Sie das Verzeichnis 
* in diesem Verzeichnis wird dann mit einem beliebigen Texteditor das Python-Makro erstellt, in unserem Fall die Datei &lt;code&gt;summiere_zellen.py&lt;/code&gt;:

 import uno
 
 def summiere_zellen(*args):
     # Zugriff auf das aktuelle Dokument und das aktive Tabellenblatt
     ctx = uno.getComponentContext()
     smgr = ctx.getServiceManager()
     desktop = smgr.createInstanceWithContext(&quot;com.sun.star.frame.Desktop&quot;, ctx)
     doc = desktop.getCurrentComponent()
     sheet = doc.getCurrentController().getActiveSheet()
 
     # Werte aus den Zellen A1 bis A3 auslesen
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
 
     # Addition der drei Werte
     summe = w1 + w2 + w3
 
     # Ergebnis in die Zelle A5 schreiben
     sheet.getCellRangeByName(&quot;A5&quot;).Value = summe

* siehe dazu ggf. auch [https://help.libreoffice.org/latest/de/text/sbasic/python/python_locations.html?DbPAR=BASIC].

Weiter geht es in LibreOffice Calc mit dem Menü ''Extras &gt; Makros &gt; Makros verwalten &gt; Python''. Dort wird das Makro &lt;code&gt;summiere_zellen&lt;/code&gt; ausgeführt. Es ergibt sich z.B. folgendes Resultat

[[Datei:PythonIng_libreoffice1.png]]

Das Kürzel &lt;code&gt;uno&lt;/code&gt; steht für '''U'''niversal '''N'''etwork '''O'''bjects. Etwas einfacher geht's auch so:

 def summiere_zellen():
     desktop = XSCRIPTCONTEXT.getDesktop()
     model = desktop.getCurrentComponent()
     sheets = model.getSheets()
     sheet = sheets.getByIndex(0)
     
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
     
     cell = sheet.getCellRangeByName(&quot;A5&quot;)    
     cell.setValue(w1 + w2 + w3) 

Empfohlen wird auch, das Erweiterungspaket APSO ('''A'''lternative '''P'''ython '''S'''cript '''O'''rganizer, apso.oxt) zu installieren. Die Vorgehensweise wird hier nicht gezeigt, sondern nur darauf hingewiesen, dass man das einfach &quot;googeln&quot; kann. Siehe zur Python-Programmierung für LibreOffice auch [https://wiki.documentfoundation.org/Macros/Python_Guide/de Makros/Python-Handbuch]. Getestet wurden obige Beispiele mit LibreOffice 26.2.5.1 unter Linux und 26.2.1.2 unter MS Windows.

= Ausblick =
Dies war eine kurze Einführung in die Berechnungs- und Darstellungsmöglichkeiten mit Python. Es sollten etliche relevante Themen behandelt, oder zumindest kurz angesprochen worden sein. Wem dieser Text nicht ausreichend ist, der sei auf die entsprechenden weiterführenden Weblinks, Bücher und die Python-Hilfefunktion verwiesen. Python kennt noch viel mehr Befehle, als hier dargestellt wurden. Das Themenspektrum ist auch durch die Einbindung externer Module fast beliebig erweiterbar.

= Weblinks=
== Python allgemein ==
* [https://www.python.org/ Python Homepage]

== Externe mathematische Module ==
* [https://numpy.org/ NumPy]
* [https://numpy.org/doc/stable/user/numpy-for-matlab-users.html NumPy for MATLAB users]
* [https://scipy.org/ SciPy]
* [https://www.sympy.org/en/index.html SymPy]
* [https://pandas.pydata.org/ pandas]
* [https://github.com/maroba/findiff findiff]
* [https://mpmath.org/ mpmath]

== Externe Module für Grafiken ==
* [https://matplotlib.org/ Matplotlib]
* [https://vpython.org/ VPython]
* [https://build123d.readthedocs.io/en/latest/ build123d]
* [https://docs.vtk.org/en/latest/api/python.html VTK]
* [https://docs.bokeh.org/en/latest/docs/first_steps.html bokeh]
* [https://py5coding.org/ py5]

== Erstellung von User Interfaces ==
* [https://docs.python.org/3/library/tkinter.html tkinter - Python interface to Tcl/Tk]
* [https://docs.python.org/3/library/curses.html curses - Terminal handling for character-cell displays]
* [https://wiki.qt.io/Qt_for_Python Qt for Python]
* [https://www.gtk.org/docs/language-bindings/python GTK and Python]

== Erstellen virtueller Umgebungen ==
* [https://docs.python.org/3/library/venv.html venv - Creation of virtual environments]

== Sonstige ==
* [https://python-control.readthedocs.io/en/stable/ Python Control Systems Library]
* [https://pypi.org/project/regex/ regex - Regular Expressions]
* [http://pyromat.org/ PYroMat]
* [https://coolprop.org/coolprop/wrappers/Python/index.html CoolProp]
* [https://pypi.org/project/iapws/ iapws]
* [https://tespy.readthedocs.io/en/main/getting_started/introduction.html TESPy - Thermal Engineering Systems in Python]
* [https://pint.readthedocs.io/en/stable/ pint]

= Bücher =
== Gedruckte Bücher, OpenBooks, Magazine ==
* Diverse: c't Python Lernen, Verstehen, Anwenden; Heise, 2022 
* Ernesti, Kaiser: Python3 - das umfassende Handbuch; 5. Aufl., Rheinwerk, [https://openbook.rheinwerk-verlag.de/python/ OpenBook]
* Iacono et al.: Programmieren trainieren; 3. Aufl., Hanser, 2023, ISBN 978-3-446-47766-7
* Inden: Python Challenge; dpunkt, 2021, ISBN 978-3-86490-809-5
* Klein: Numerisches Python; 2. Aufl., Hanser, 2023, ISBN 978-3-446-47170-2 
* Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler; Rheinwerk, 2021, ISBN 978-3-8362-7316-9
* Weigend: Python 3 - Das umfassende Praxisbuch; 9. Aufl., mitp, 2022, ISBN 978-3-7475-0544-1
* Woyand: Python für Ingenieure und Naturwissenschaftler; 4. Aufl., Hanser, 2021, ISBN 978-3-446-46483-4

== Andere Wikibooks ==
* [[:en:Subject:Python_programming_language | Englische Wikibooks zum Thema Python]]
* [[Python|Deutschsprachiges Python-Wikibook]] [[Bild:2von10.png|20%]]
* [[Python unter Linux|Python 2.7 unter Linux]] [[Bild:10von10.png|100%]]


{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}</text>
      <sha1>1e4y52pi2rtveys3ow33qw8oiztzf2o</sha1>
    </revision>
    <revision>
      <id>1092183</id>
      <parentid>1092182</parentid>
      <timestamp>2026-10-17T10:17:50Z</timestamp>
      <contributor>
        <username>Intruder</username>
        <id>1513</id>
      </contributor>
      <minor />
      <comment>/* Py5 */</comment>
      <origin>1092183</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="191375" sha1="l51xf8ntl9n2tk7ikdpifo0u74rm6kq" xml:space="preserve">{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}


= Hallo Welt und allgemeine Hinweise =
== Was ist Python ==
* Python ist eine universelle höhere Programmiersprache.
* Python ist objektorientiert.
* Python ist Open-Source (Python Software Foundation License).
* Python ist für viele Betriebssysteme erhältlich (z.B. für Linux, MS Windows, macOS).
* Python ist ein Interpreter.
* Python ist durch Module fast beliebig erweiterbar.
* Python als Programmiersprache ist case-sensitive - d.h. Groß- und Kleinschreibung ist relevant bei der Eingabe von Befehlen.
* Python ist in etlichen Anwendungsprogrammen (z.B. {{W|FreeCAD}}, {{W|LibreOffice}}, {{W|GIMP}}, {{W|Blender (Software) | Blender}}) als Makrosprache verwendbar.

{{Wikipedia | Python (Programmiersprache)}}

== Python installieren ==
=== MS Windows ===
Laden Sie das aktuelle Python-Paket von der Webseite [https://www.python.org/] herunter. Weiter geht es wie bei jedem anderen größeren zu installierenden Programm. Einfach das Installationsprogramm im Explorer doppelklicken und den Anweisungen des Setup-Programmes folgen.

=== Linux ===
Entweder ist Python bereits standardmäßig installiert, ansonsten ist die Installation mittels Paketmanagementsystem einfach möglich. Aber auch die Spyder-Entwicklungsumgebung ([https://www.spyder-ide.org]) bietet einen guten Einstieg mit Python (das gilt auch für MS Windows). Spyder bringt auch schon etliche wichtige Module standardmäßig mit.

== Python starten ==
=== MS Windows ===
Das Icon für das Python-Programm doppelklicken. Und schon startet das Programm.

[[Datei:PythonIng_start1.jpg]]

Python im interaktiven Modus (REPL ... '''R'''ead-'''E'''valuate-'''P'''rint-'''L'''oop) präsentiert sich dann so:

 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

Alternativ kann das Programm auch über die Eingabeaufforderung oder die PowerShell gestartet werden:

 c:\devel\Python&gt;python.exe
 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

=== Linux ===
Tippen Sie einfach das Wort „python“ (oder unter openSUSE Tumbleweed z.B. auch „python3.11“ oder „python3.13“) in einem Linux-Terminal ein, schließen den Befehl mit der RETURN-Taste ab, und schon startet Python im interaktiven Modus:
 
 Python 3.13.12 (main, Feb 09 2026, 22:37:44) [GCC] on linux
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt; 

Es gibt auch noch andere Möglichkeiten Python zwecks Programmausführung zu starten, z.&amp;nbsp;B. den {{W|Shebang}} (&lt;code&gt;#!&lt;/code&gt;) am Beginn eines Python-Scripts. Das Script sei als Script.py gespeichert. Dann kann das Script mit ./Script.py ausgeführt werden. Für openSUSE Tumbleweed sei nachfolgend ein lauffähiges &quot;Hallo Welt!&quot;-Script angegeben. Es wird in diesem Script der Python-Interpreter in der Version 3.13 verwendet :

 #!/usr/bin/python3.13
 print(&quot;Hallo Welt!&quot;)

Die Berechtigungen zum Ausführen der Datei müssen natürlich noch richtig gesetzt werden, z.B. mittels &lt;code&gt;chmod 777 Script.py&lt;/code&gt;. &lt;small&gt;&lt;code&gt;chmod&lt;/code&gt; ist die Abkürzung für&quot;'''ch'''ange file '''mod'''e bits&quot;.&lt;/small&gt; 

&lt;small&gt;Die &quot;Maske&quot; &lt;code&gt;777&lt;/code&gt; ist nur für Testzwecke sinnvoll, weil sie leicht zu merken ist und für alle Benutzer alle Zugriffsberechtigungen ('''r'''ead/'''w'''rite/e'''x'''ecute für owner/group/others) setzt. Im richtigen Einsatz wird man das aus Sicherheitsgründen nicht so handhaben, sondern nur die Berechtigungen setzen, die unbedingt erforderlich sind. Welche Zugriffsberechtigungen gesetzt sind, kann man z.B. mit dem Befehl &lt;code&gt;ls -l&lt;/code&gt; oder &lt;code&gt;ll&lt;/code&gt; ('''l'''i'''s'''t directory contents) erfragen. Aber dazu im Moment genug. Erfahrene Linux-Nutzer kennen das ohnehin und Anfänger sollen jetzt nicht mit Linux-Interna überfordert werden. Bei Bedarf siehe die Linux-Man-Pages oder dezidierte Bücher zu Linux.&lt;/code&gt;&lt;/small&gt;

&lt;small&gt;Oder das Script wird in einen Pfad verschoben, in dem sich ausführbare Programme generell befinden (welche Verzeichnisse im PATH liegen, kann bspw. mit &lt;code&gt;echo $PATH&lt;/code&gt; abgefragt werden). Das Script kann dann wie ein normales Programm ohne weitere Angaben mit Script.py gestartet werden. Alternativ wird nicht das Script an sich verschoben, sondern nur ein symbolischer Link angelegt, z.B. mit &lt;code&gt;ln -s ~/tmp/Script.py ~/.local/bin/Script.py&lt;/code&gt;. &lt;code&gt;~/.local/bin&lt;/code&gt; sei ein im PATH gelegenes Verzeichnis. Dies sind aber schon Features für fortgeschrittene Linux-Benutzer und werden am Anfang eher selten benötigt.&lt;/small&gt;

== Ein paar Worte zur Erklärung ==
=== Tests ===
Getestet wurden die Beispiele unter den Betriebssystemen 
* MS Windows 10 mit der Python-Version 3.12.0 (teilweise auch mit 3.12.2 und 3.13.1; nur die Inhalte die bis spätestens Juli 2025 erstellt wurden) 
* MS Windows 11 ab der Python-Version 3.13.4 (nur zum Teil; ab Juli 2025)
* openSUSE Leap 15.6 mit der Python-Version 3.11.12 (Spyder, nur vereinzelt) und zum Teil mit 3.12.11 (ab Juli 2025 bis November 2025).
* openSUSE Tumbleweed ab der Python-Version 3.13.9 (nur vereinzelt, ab November 2025)

=== Popularität ===
* An Beliebtheit rangiert Python mit Stand September 2026 mit einem Rating von 17,76% an 1. Stelle vor C und C++ (lt. [https://www.tiobe.com/tiobe-index/ TPCI - TIOBE Programming Community Index]). 
* Lt. [https://innovationgraph.github.com/global-metrics/programming-languages GitHub Top 50 Programming Languages Globally] lag Python im Q1/2026 auf Rang 2, vor TypeScript und hinter JavaScript. 
* [https://pypl.github.io/PYPL.html PYPL] (Popularity of Programming Language Index) ist ein anderer Popularitätsindex für Programmiersprachen. Auch hier liegt Python mit großem Vorsprung auf dem ersten Platz (52,08%), gefolgt von Java (13,34%) und C/C++ (7,99%) (Stand September 2026). 

=== Namensgebung ===
Der Name &quot;Python&quot; rührt von der Komikertruppe {{W|Monty Python}} her. Die Icons für Python (z.B. Python selbst, Eric IDE, IDLE) sind aber durch die Python-Schlangenart symbolisiert.

&lt;gallery&gt;
Python-logo-notext.svg|Python-Logo
Guido van Rossum in PyConUS24.jpg|{{W|Guido van Rossum}} (geb. 1956), der Erfinder von Python
&lt;/gallery&gt;

== Ein erstes Programm ==
Kommentare werden in Python mit der Raute (#) eingeleitet. Sie werden vom Python-Interpreter ignoriert. Text kann mit der print-Funktion ausgegeben werden. Starten Sie Python und geben sie folgende Anweisungen zeilenweise ein

 &gt;&gt;&gt; # Das ist ein Kommentar
 &gt;&gt;&gt; print(&quot;Hallo Welt!&quot;)

Als Ergebnis erhalten Sie

 Hallo Welt!

Der Prompt (&gt;&gt;&gt;) ist selbstverständlich nicht einzutippen, sondern wird vom Python-System geliefert.

Strings können in Python entweder in Anführungszeichen (&quot;) gesetzt werden oder in Hochkommatas('). In diesem Text wird die erste Variante bevorzugt eingesetzt.

Im Gegensatz zu Julia ist es hier egal, ob zwischen &lt;code&gt;print&lt;/code&gt; und der öffnenden Klammer Leerzeichen stehen.

= Python als Taschenrechner =
== Allgemeines ==
Wir wollen 3 * 5 berechnen. Dazu starten wir Python im interaktiven Modus. Geben Sie dann die Formel  

 &gt;&gt;&gt; 3 * 5

ein, drücken die Taste ENTER/RETURN ({{Taste|↵}}) und erhalten als Ergebnis

 15

Auch kompliziertere Ausdrücke sind möglich. Beispielsweise mit Winkelfunktionen, Quadratwurzeln etc. Wir wollen nun den Ausdruck &lt;math&gt;\sin\sqrt{15}&lt;/math&gt; berechnen :

 &gt;&gt;&gt; import math
 &gt;&gt;&gt; math.sin(math.sqrt(15))
 -0.6679052983383519

Als erstes wird das math-Modul importiert. Dann wird der mathematische Ausdruck berechnet.

Eine andere Variante, die dasselbe Ergebnis liefert, ist

 &gt;&gt;&gt; from math import *
 &gt;&gt;&gt; sin(sqrt(15))
 -0.6679052983383519

Es wird also aus dem Modul &lt;code&gt;math&lt;/code&gt; alles importiert (erkennbar am &lt;code&gt;*&lt;/code&gt;). Will man nicht alles importieren, so kann man das auch einschränken:

 &gt;&gt;&gt; from math import sin, sqrt

Beenden lässt sich das Python-Programm durch Eingabe von &lt;code&gt;exit()&lt;/code&gt; (und natürlich ist zur Bestätigung die RETURN-Taste zu drücken). &lt;code&gt;exit&lt;/code&gt; (ohne Klammern) oder &lt;code&gt;quit&lt;/code&gt; werden auch akzeptiert.

== Die Hilfefunktion von Python ==
Bei Eingabe der Anweisung &lt;code&gt;help&lt;/code&gt; oder &lt;code&gt;help()&lt;/code&gt; springt Python in den Hilfemodus. 

Eingabe:
 &gt;&gt;&gt; help()
 
Eingabe:
 help&gt; math.sin

Ausgabe:
 Help on built-in function sin in math:
 
 math.sin = sin(x, /)
     Return the sine of x (measured in radians).

Für die komplette Python-Dokumentation siehe [https://docs.python.org/3/]. Verlassen kann man den Hilfemodus durch das Drücken von STRG-C, bzw. der Eingabe von q, quit oder exit mit anschließendem Drücken der RETURN-Taste.

== Aufgaben ==
* Erkunden Sie die Tangensfunktion &quot;tan&quot; mittels Python-Hilfe (vergessen Sie nicht das math-Modul zu importieren und das &lt;code&gt;math.&lt;/code&gt; vor &lt;code&gt;tan&lt;/code&gt;)
* Berechnen Sie mit Python den Ausdruck &lt;math&gt;\frac{1}{2}\cdot \text{e}^2 \cdot \tan(\pi/3)&lt;/math&gt;. Siehe für die Exponentialfunktion im Python-Hilfesystem auch den Befehl &lt;code&gt;math.exp&lt;/code&gt;. Alternativ kann auch die Konstante &lt;code&gt;math.e&lt;/code&gt; eingesetzt werden. Potenzieren kann man bei Python mit dem **-Operator (z.B. 2**3 = 8). Für &lt;math&gt;\pi&lt;/math&gt; gibt es &lt;code&gt;math.pi&lt;/code&gt;.

= Python als Scriptsprache =
Häufig wird man aber kompliziertere Anweisungsfolgen verarbeiten müssen. Diese will man normalerweise nicht jedesmal neu eingeben, sondern in einer Datei speichern und diese Datei dann zur Ausführung bringen. Speichern Sie dazu folgenden Code in einer Textdatei, z.B. unter MS Windows als c:\tmp\test1.py

 # Das ist ein Kommentar
 print(&quot;Hallo Welt!&quot;)

Python-Dateien werden mit der Dateiendung .py versehen. Achten Sie darauf, dass vor dem print keine Leerzeichen vorhanden sind. Das ist eine Python-Eigenheit. Wie wir später sehen werden, nutzt Python Einrückungen als syntaktisches Mittel, z.B. um bei Schleifen den Schleifenkörper zu kennzeichnen. 

Danach bringen Sie die Skriptdatei test1.py (sozusagen das Hauptprogramm) folgendermaßen zur Ausführung:

1) Starten Sie unter MS Windows die Eingabeaufforderung (oder alternativ auch die Windows PowerShell). Das sieht dann etwa so aus:

 Microsoft Windows [Version 10.0.19045.3693]
 (c) Microsoft Corporation. Alle Rechte vorbehalten.
 
 C:\Users\xyz&gt;

: &lt;small&gt;Falls jemand nicht weiß, wie man die Eingabeaufforderung startet: Eine Möglichkeit ist, einfach in der Taskleiste von Windows das &quot;Start&quot;-Symbol &amp;nbsp;([[Image:Windows_logo_-_2021_(Black).svg|10px]])&amp;nbsp; mit der rechten Maustaste anklicken. &quot;Ausführen&quot; auswählen (oder alternativ für die PowerShell unter Windows 10 den Eintrag &quot;Windows PowerShell&quot;, unter Windows 11 den Eintrag &quot;Terminal&quot;). Im sich öffnenden Dialogfenster gibt man in die &quot;Öffnen&quot;-Zeile das Wort &lt;code&gt;cmd&lt;/code&gt; ein und mit &quot;OK&quot; wird das Ganze bestätigt.&lt;/small&gt; 
 
2) Wechseln Sie mittels &lt;code&gt;cd c:\tmp&lt;/code&gt; in das Verzeichnis c:\tmp

3) Angenommen, Sie haben Python unter dem Pfad &lt;code&gt;c:\devel\Python\&lt;/code&gt; installiert. Starten Sie das Programm so (der Prompt &lt;code&gt;c:\tmp&gt;&lt;/code&gt;ist natürlich nicht mit einzutippen): 

 c:\tmp&gt;c:\devel\Python\python.exe test1.py

4) Wie erwartet ergibt sich folgende Ausgabe am Bildschirm

 Hallo Welt!

Die Vorgehensweise unter Linux ist prinzipiell gleich. Die kleinen Unterschiede, wie z.B. der Slash statt dem Backslash in Pfadangaben, sollten für Linux-Benutzer keine Hürde darstellen.

== Variablen ==
Variablenbezeichner können aus Buchstaben (A-Za-z), Ziffern (0-9) und Underscores (_) bestehen, dürfen aber nicht mit einer Zahl beginnen. Führende Underscores haben u.a. im Kontext mit der Objektorientierten Programmierung eine spezielle Bedeutung und sollten nicht für &quot;normale&quot; Variablenbezeichner verwendet werden.

Gültige Variablenbezeichner wären also:
 xyz
 x1
 _wert
 name_anzahl

Theoretisch kann man auch Umlaute, griechische Buchstaben u.ä. in Variablenbezeichnern nutzen, z.B.

 ößÜ = 16
 α = 134 
 print(ößÜ)
 print(α)

Ausgabe:
 16
 134

Davon wird aber aus offensichtlichen Gründen ({{W|Englisch als Lingua franca}}) abgeraten. Das Eurozeichen (€) etc. darf man ohnehin nicht in Variablenbezeichnern verwenden, dies ergäbe einen Syntaxfehler. Siehe dazu auch [https://peps.python.org/pep-3131/].

Es gibt in Python etliche Schlüsselwörter (z.B. for, if oder return). Diese dürfen nicht als eigene Variablenbezeichner verwendet werden. Eine Liste aller Schlüsselwörter liefert das Script

 import keyword
 print(keyword.kwlist)

&lt;small&gt;Übung: Speichern Sie dieses Script in eine Datei, z.B. in c:\tmp\test1.py. Führen Sie diese Datei aus, um die Liste der Schlüsselwörter auszugeben.&lt;/small&gt;

Da Python case-sensitiv ist, repräsentieren folgende Bezeichner verschiedene Variablen:
 xyz
 XYZ
 xYz

Werte werden an Variablen mittels Gleich-Zeichen (=) zugewiesen. Im Folgenden wird der Code immer in der Datei c:\tmp\test1.py gespeichert.

 x = 5
 y = 10
 z = x*y
 print(z)

Bringen Sie die Datei test1.py zur Ausführung, so erhalten Sie folgende Bildschirmausgabe

 50

Sie können auch mehrere Anweisungen in einer Zeile durch Semikolon getrennt schreiben. Dies führt aber zu unübersichtlichem Code.

 x = 5; y = 10; z = x*y; print(z)

Ausgabe:
 50

Auch aus der Programmiersprache C/C++ oder Java bekannte Konstrukte können Sie verwenden, z.B.
 x = 5
 # x = x - 2
 x -= 2
 print(x)

Bildschirmausgabe:

 3
 
Beachten Sie, dass mit dem =-Zeichen eine Wertezuweisung durchgeführt wird. Dies ist nicht äquivalent zum mathematischen =-Zeichen, wie am vorigen Beispiel zu ersehen ist. Den Inkrement-/Dekrementoperator (z.B. x++ oder x--) aus C/C++ oder Java kennt Python aber nicht.

Variablen sind nicht an einen bestimmten Datentyp gebunden, folgendes ist mit Python problemlos möglich:

 import math
 wert = 10
 print(wert)
 wert = 35.5
 print(wert)
 wert = &quot;Hallo&quot;
 print(wert)
 wert = math.pi
 print(wert)

Ausgabe:
 10
 35.5
 Hallo
 3.141592653589793

== Physische und logische Zeilen ==
In Python muss eine Anweisung in einer logischen Zeile Platz finden. Wird eine Anweisung aber zu lang für eine Zeile, dann kann sie in mehrere physische Zeilen unterteilt werden. Dies kann einerseits durch einen Backslash am Ende einer Zeile geschehen, z.B.

 a = 2 + \
 5
 
Dies stellt eine logische Zeile dar, die in zwei physische Zeilen unterbrochen ist.

Geklammerte Ausdrücke werden automatisch zu einer logischen Zeile verbunden, z.B.

 a = (2 + 
 5)
 
Achtung: Im ersten Beispiel darf nach dem Backslash nichts mehr stehen, auch kein Kommentar. Dies trifft im zweiten Bespiel nicht zu, hier könnte noch ein Kommentar folgen, z.B.

 a = (2 +    # Kommentar 
 5)

Auch für Strings gibt es Möglichkeiten, diese auf mehrere Zeilen aufzuspalten.

 # Kurzer String
 str1 = &quot;ABC&quot;
 
 # Langer String
 str2 = &quot;&quot;&quot;Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle&quot;&quot;&quot;
 
 # Backslash
 str3 = &quot;UVW\
 XYZ&quot;
 
 # Mit Klammern
 str4 = (&quot;Sehr langer Text, der automatisch .............. &quot;
         &quot;in einer einzigen Variable zusammengefügt wird.&quot;
 )
 
 print(str1)
 print(str2)
 print(str3)
 print(str4)

Ausgabe:

 ABC
 Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle
 UVWXYZ
 Sehr langer Text, der automatisch .............. in einer einzigen Variable zusammengefügt wird.

==Hexadezimale, oktale, binäre und andere Zahlen==
 d = 1050         # Dezimalzahl
 h = 0xAA2        # Hexadezimalzahl
 o = 0o12         # Oktalzahl
 b = 0b100001101  # Binärzahl
 
 print(d)
 print(h)
 print(o)
 print(b)

Ausgabe:
 1050
 2722
 10
 269

Groß- und Kleinbuchstaben sind in obigen Literalen übrigens egal. So kann man z.B. statt &lt;code&gt;0b1001&lt;/code&gt; auch &lt;code&gt;0B1001&lt;/code&gt; schreiben (siehe dazu [https://docs.python.org/3/reference/lexical_analysis.html#integer-literals]).

Sie können auch dezimale in hexadezimale Zahlen umwandeln, usw.:
 h = hex(1050)    # Dezimalzahl -&gt; Hexadezimalzahl
 b = bin(1050)    # Dezimalzahl -&gt; Binärzahl
 o = oct(1050)    # Dezimalzahl -&gt; Oktalzahl
 print(h)
 print(b)
 print(o)

Ausgabe:
 0x41a
 0b10000011010
 0o2032

Gegeben sei die Zahl 121 zur Basis 3. Diese soll in eine Dezimalzahl umgewandelt werden. Das kann so geschehen:

 z = int(&quot;121&quot;, 3)
 print(z)

Ausgabe:
 16

Dass dies richtig ist, davon kann man sich folgendermaßen überzeugen:
 &lt;math&gt; 1 \cdot 3^2 + 2 \cdot 3^1 + 1 \cdot 3^0 = 9 + 6+ 1 = 16 &lt;/math&gt;

Zahlen übersichtlicher schreiben kann man auch mittels Underscore, z.B.:

 print(&quot;Eine Million (Variante 1) =&quot;, 1000000)
 print(&quot;Eine Million (Variante 2) =&quot;, 1_000_000)
 print(&quot;Eine Rechnung:&quot;, 2_000 * 400_000);

Es ergibt sich bei beiden Varianten die gleiche Ausgabe. Variante 2 ist aber im Sourcecode leichter lesbar, detto die Zahlen in der Rechnung:

 Eine Million (Variante 1) = 1000000
 Eine Million (Variante 2) = 1000000
 Eine Rechnung: 800000000

== Strings und Platzhalter==
Ein paar einfache Beispiele:

 print(&quot;Hallo {}&quot; . format(&quot;Hugo&quot;))     # new style string formatting
 print(&quot;Hallo {:s}&quot; . format(&quot;Hugo&quot;))   # new style string formatting
 print(&quot;Hallo %s&quot; % &quot;Hugo&quot;)             # %-String

Ausgabe:

 Hallo Hugo
 Hallo Hugo
 Hallo Hugo

Python-Code (formatted string literals, Beispiel 1):
 str1 = &quot;Hallo&quot;
 str2 = &quot;Hugo&quot;
 print(f&quot;{str1} {str2}&quot;)

Ausgabe:
 Hallo Hugo

f-Strings (ab Python 3.6) sind die modernere Variante gegenüber %-Strings oder das ''new style string formatting''. Sie sind in der Regel auch schneller.

Python-Code (formatted string literals, Beispiel 2):
 wert = 11.567
 print(f&quot;Ausgabe: {wert:.5f}&quot;)

Ausgabe:
 Ausgabe: 11.56700

Komplexere Beispiele:

 print(&quot;Hallo {} und {}&quot; . format(&quot;Hugo&quot;, &quot;Mike&quot;))
 print(&quot;Hallo {name1} und {name2}&quot; . format(name2=&quot;Hugo&quot;, name1=&quot;Mike&quot;))
 # Füllzeichen: *
 # Bündigkeit: &gt; (=rechts), &lt; (=links), ^ (=zentriert)
 # Feldweite: 10
 # Typ: s (=String), f (=Gleitkommazahl), d (=Dezimalzahl) etc.
 print(&quot;Hallo {:*&gt;10s}&quot; . format(&quot;Hugo&quot;))
 print(&quot;Hallo {:*&lt;10s}&quot; . format(&quot;Hugo&quot;))

Ausgabe:

 Hallo Hugo und Mike
 Hallo Mike und Hugo
 Hallo ******Hugo
 Hallo Hugo******

Python-Code:
 str = &quot;Hallo\t%s\t%7.2f\t%10.2e\t%i&quot; % (&quot;Hugo&quot;, 12.34567, 34.567, 264)
 print(str)

Ausgabe:
 Hallo	Hugo	  12.35	  3.46e+01	264

== Unicode ==
Neben den bekannten ASCII-Zeichen lassen sich Zeichen auch mittels Unicode beschreiben. Griechische Buchstaben oder komplexere mathematische Operatoren - all das sollte kein Problem sein. Siehe auch {{W|Unicode}}, {{W|Liste der Unicodeblöcke}} und {{W|Unicodeblock Mathematische Operatoren}}. Im Folgenden werden ein paar Zeichen (Allquantor, Nabla-Operator, Existenzquantor), die man aus der Mathematik kennt, erzeugt. 
 
 ch1 = &quot;\N{FOR ALL}&quot;
 ch2 = &quot;\N{NABLA}&quot;
 ch3 = &quot;\u2203&quot;
 print(ch1, ch2, ch3)

Ausgabe:
 ∀ ∇ ∃

&lt;small&gt;Diese Ausgabe ergibt sich z.B. mit der IDLE-Shell oder mit Cygwin. Beim Ausführen über die Windows-Eingabeaufforderung oder Windows PowerShell unter MS Windows 10 erfolgt keine korrekte Darstellung. IDLE ist die mit Python mitgelieferte IDE ('''I'''ntegrated '''D'''evelopment '''E'''nvironment, Integrierte Entwicklungsumgebung). Gegen Ende dieses Textes wird IDLE kurz beschrieben.
Das Problem mit der Windows Eingabeaufforderung lässt sich aber umgehen. Man muss nur eine Schriftart auswählen, die die Zeichen kennt, z.B. &quot;DejaVu Sans Mono&quot;. Dazu klicken Sie einfach bei der Eingabeaufforderung mit der rechten Maustaste oben auf die weiße Leiste und wählen im aufpoppenden Fenster den Menüpunkt &quot;Eigenschaften&quot;. Es öffnet sich ein Dialogfenster. Über den Reiter &quot;Schriftart&quot; lässt sich nun die Schriftart einstellen. Unter MS Windows 11 oder openSUSE Leap 15.6 (bash-Konsole) gibt es dieses Problem ohnehin nicht.&lt;/small&gt;

== Reguläre Ausdrücke ==
Python kennt auch {{W|Regulärer Ausdruck|reguläre Ausdrücke}}. Dazu gibt es in Python das Modul &lt;code&gt;re&lt;/code&gt;. Beipielsweise sollen alle Zahlen (&lt;math&gt;\text{zahl}\in\mathbb{N}_0&lt;/math&gt;) in einem String gesucht und ausgegeben werden. Als String sei gegeben: &lt;code&gt;3x Grüße und 100 Kekse.&lt;/code&gt; Das Muster (Pattern) ist &lt;code&gt;\d+&lt;/code&gt;. &lt;code&gt;\d&lt;/code&gt; steht für eine Dezimalziffer 0-9. Das Plus-Zeichen (+) steht symbolisch für ein oder mehrere Zeichen des vorherigen Ausdrucks. Hier also ein oder mehrere Dezimalziffern. Es wird die Funktion &lt;code&gt;findall&lt;/code&gt; aus dem Modul &lt;code&gt;re&lt;/code&gt;verwendet.

Python-Code:
 from re import findall
 
 str = &quot;3x Grüße und 100 Kekse.&quot;
 pat = &quot;\\d+&quot;  # Doppel-Backslashes müssen verwendet werden, sonst gibt Python eine Warnung aus!
               # alternativ: pat = r&quot;\d+&quot; 
               # oder: pat = &quot;[0-9]+&quot;
 
 numb = findall(pat, str)
 print(numb)

Ausgabe:
 ['3', '100']

Python kennt noch viele weitere Möglichkeiten mittels regulärer Ausdrücke zu hantieren. Dies soll hier aber nicht vertieft werden, da das Thema schon ziemlich speziell und komplex ist. Bei Bedarf siehe aber z.B. die Bücher ''Weigend, Seite 380ff'' und ''Ernesti, Kaiser'' [https://openbook.rheinwerk-verlag.de/python/28_001.html] oder die Python-Dokumentation [https://docs.python.org/3/library/re.html]. Auch [[Python unter Linux: Reguläre Ausdrücke]] liefert ein umfangreiches und brauchbares Python-2-Kapitel zu den regulären Ausdrücken. Die dort gelisteten Beispiele müssten ggf. vor Verwendung auf Python-3 umgeschrieben werden. &lt;small&gt;Wie macht  man das? Dazu siehe z.B. [https://openbook.rheinwerk-verlag.de/python/43_001.html], [https://portingguide.readthedocs.io/en/latest/] oder [https://www.digitalocean.com/community/tutorials/how-to-port-python-2-code-to-python-3]&lt;/small&gt;

&lt;small&gt;Es gibt auch ein externes Modul ''regex'', das bei Bedarf extra installiert werden muss ([https://pypi.org/project/regex/]). Es bietet zusätzliche Funktionalität und gründlicheren Unicode-Support. Dies sei hier aber nur der Vollständigkeit halber erwähnt.&lt;/small&gt;

== Verzweigungen ==
=== if ===
Die IF-Verzweigung sei aus anderen Programmiersprachen bereits bekannt. In {{W|Pseudocode}} lässt sie sich folgendermaßen darstellen:

 WENN bedingung TRUE
   führe block1 aus
 SONST
   führe block2 aus
 ENDE 

Als {{W|Aktivitätsdiagramm|UML-Aktivitätsdiagramm}} sieht das in etwa so aus:

[[File:If-Then-Else-diagram.svg|200px]]

Und als {{W|Nassi-Shneiderman-Diagramm|Nassi-Shneiderman-Struktogramm}} so:

[[File:Zweiseitige Auswahl.png|250px]]

In Python gibt es keinen expliziten ENDE-Kennzeichner. Stattdessen wird der Code durch Einrückungen strukturiert. Alles mit der gleichen Einrückungstiefe gehört zum selben Block. Dies zeichnet Python vor anderen Programmiersprachen aus.

Die test1.py-Datei laute also wie folgt:

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
   print(&quot;x ist groesser oder gleich 4&quot;)  

Ausgabe:

 Der else-Zweig wird ausgefuehrt
 x ist groesser oder gleich 4

Man achte auch auf die Doppelpunkte in der if- und else-Zeile. Darauf vergisst man gerne, wenn man von anderen Programmiersprachen kommt.

Folgendes wäre in Python ein Fehler (genauer gesagt ein IndentationError).

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
     print(&quot;x ist groesser oder gleich 4&quot;)  

Auch Nachstehendes würde nicht zum gewünschten Ergebnis führen (löst aber keine Fehlermeldung aus). Der letzte print-Befehl ist schon außerhalb der IF-ELSE-Verzweigung.

 x = 3
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
 print(&quot;x ist groesser oder gleich 4&quot;)

Ausgabe:

 x ist kleiner als 4
 x ist groesser oder gleich 4

Python kennt eine Reihe von Vergleichs- und Verknüpfungsoperatoren:

    &lt;, &lt;= ... kleiner (gleich)
    &gt;, &gt;= ... größer (gleich)
    == ... gleich
    != ... ungleich
    is ... identisch
    is not ... nicht identisch
    and ... AND
    or ... OR
    not ... NOT

Beispielsweise:

 a = 5
 b = 9
 
 if a&lt;=10 and b!=7:
   print(&quot;OK&quot;)
 else
   print(&quot;Nicht OK&quot;)

Ausgabe:

 OK

Der else-Block kann übrigens auch ersatzlos entfallen. Als Pseudocode sieht das so aus

 WENN bedingung TRUE
   führe block aus
 ENDE

Mehrfache Verzweigungen werden durch das elif-Konstrukt erstellt. In Pseudocode:

 WENN bedingung1 TRUE
   führe block1 aus
 SONST WENN bedingung2 TRUE
   führe block2 aus
 SONST WENN bedingung3 TRUE
   führe block3 aus
 SONST
   führe block4 aus
 ENDE

Ein Python-Beispiel:
 a = 14
 
 if a&lt;=10:   
   print(&quot;&lt;=10&quot;)
 elif a&gt;=11 and a&lt;=15:
   print(&quot;11 bis 15&quot;)
 elif a&gt;=16 and a&lt;=20:
   print(&quot;16 bis 20&quot;)
 else:
   print(&quot;&gt;20&quot;)

Ausgabe:

 11 bis 15

In Python gibt es auch die Schlüsselwörter &lt;code&gt;True&lt;/code&gt; (für wahr) und &lt;code&gt;False&lt;/code&gt; (für falsch). Man beachte, dass sie mit Großbuchstaben beginnen. Andere Schreibweisen wären ein Fehler. Sie gehören zum Datentyp &lt;code&gt;bool&lt;/code&gt;. Ihnen sind auch die Zahlen &lt;code&gt;1&lt;/code&gt; und &lt;code&gt;0&lt;/code&gt; zugewiesen.

Man beachte, dass {{W|Rundungsfehler}} auftreten können. D.h. man sollte  bei der Verwendung von {{W|Gleitkommazahl|Gleitpunktzahlen}} niemals auf absolute Genauigkeit prüfen, sondern eine Toleranz (einen &lt;math&gt;\varepsilon&lt;/math&gt;-Wert) vorgeben.
 
Ein klassisches Beispiel, das ein falsches Ergebnis liefert, ist:

 i = 0.1 + 0.2
 
 print(i)
 
 if i == 0.3:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 NOK

Und das, obwohl man schon in der Volksschule lernt, dass 0.1 + 0.2 gleich 0.3 ist.

Korrekt muss das obige Beispiel z.B. so umgeschrieben werden:

 ist = 0.1 + 0.2
 soll = 0.3
 epsilon = 0.000001
 
 print(ist)
 
 if abs(ist-soll) &lt; epsilon:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 OK

Alternativ kann auch die &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion verwendet werden. Das sei aber hier nur erwähnt und nicht konkret ausgeführt.

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet zum Thema &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion.

=== match ===
Ab Python 3.10 gibt es auch die match-Anweisung. Dies ist das Python-Pendant für die switch-Anweisung in anderen Programmiersprachen, geht aber bei näherer Betrachtung weit darüber hinaus. Hier nur ein einfaches Beispiel:

 x = &quot;Hello&quot;
 
 match x:
     case &quot;Servus&quot; | &quot;Ciao&quot;:         # or
         print(&quot;Servus an alle&quot;)
     case &quot;Grüetzi&quot;:
         print(&quot;Grüetzi Schwyzer&quot;)  
     case _:                         # other, default, sonstiges ...
         print(&quot;Hallo Welt&quot;)

Ausgabe: 
 Hallo Welt

Als Struktogramm sieht das in etwa so aus:

[[File:Mehrseitige Auswahl.png|250px]]

Für nähere Details siehe z.B. [https://www.geeksforgeeks.org/python-match-case-statement/], [https://learnpython.com/blog/python-match-case-statement/], [https://docs.python.org/3/tutorial/controlflow.html#match-statements] und das Python Enhancement Proposal (PEP) 636 – Structural Pattern Matching: Tutorial [https://peps.python.org/pep-0636] und dort insbesondere den Anhang A - Quick Intro.

&lt;small&gt;&lt;code&gt;match, case, _&lt;/code&gt; etc. sind sogenannte ''soft keywords''. Im Gegensatz zu den normalen Schlüsselwörtern dürfen ihnen auch Werte zugewiesen werden. Eine Liste der weichen Schlüsselwörter lässt sich durch &lt;code&gt;keyword.softkwlist&lt;/code&gt; erstellen (die Anweisung gibt es seit Python 3.9). Siehe dazu auch [https://stackoverflow.com/questions/65800344/what-are-soft-keywords] und [https://docs.python.org/3/library/keyword.html#keyword.softkwlist].&lt;/small&gt;

== Schleifen ==
Kopfgesteuerte Schleife, Endlosschleife und fußgesteuerte Schleife:

[[File:Programmingloops.svg|450px]]

=== while ===
Die WHILE-Schleife ist kopfgesteuert. Sie funktioniert wie aus anderen Programmiersprachen bekannt. 

In Pseudocode:
 SOLANGE bedingung TRUE
   führe block aus
 ENDE

In Python:
 x = 0
 
 while x &lt;= 10:
   print(x)
   x += 1

Ausgabe:
 0
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10

Eine Endlosschleife ergibt sich z.B. so:
 i = 5
 
 while True:
     print(i)
     i-=1

Beendet werden kann sie mit der Tastenkombination STRG-C.

Eine fußgesteuerte Schleife kann so simuliert werden:
 i = 5
 
 while True:
     print(i)
     i-=1
 
     if i&lt;=0:
         print(&quot;Fire&quot;)
         break

Ausgabe:
 5
 4
 3
 2
 1
 Fire

Der &lt;code&gt;break&lt;/code&gt;-Befehl wird etwas [[Ing_Mathematik:_Python#break|später]] noch einmal kurz thematisiert.

=== for ===
Struktogramm einer for-Schleife:

[[File:Zählschleife.png|200px]]

In Python bspw. so:

 for x in range(6):
   print(x*2)

Ausgabe:
 0
 2
 4
 6
 8
 10

Die Schleife läuft von 0 bis 5. Ausgegeben wird jeweils der Wert x*2. Aquivalent kann diese Schleife auch so geschrieben werden:
 for x in range(0, 11, 2):
   print(x)

Die Ausgabe ist wie oben. Der Startwert sei 0, der Endwert ist 11-1 und die Schrittweite ist 2.

Ein anderes Beispiel sei
 for x in &quot;text&quot;:
   print(x)

Ausgabe:
 t
 e
 x
 t

== Schleifen abbrechen ==
=== break ===
&lt;code&gt;break&lt;/code&gt; bricht die Schleife ab und setzt mit dem nächsten Befehl außerhalb der Schleife fort.

 for var in range(100):
   print(var) 
   if var == 5:
     break

Ausgabe:
 0
 1
 2
 3
 4
 5

=== continue ===
&lt;code&gt;continue&lt;/code&gt; bricht den aktuellen Schleifendurchlauf ab und setzt mit dem nächsten Schleifendurchlauf fort.

 for var in range (11):
   if var == 5:
     continue
   print(var)

Ausgabe:
 0
 1
 2 
 3
 4
 6
 7
 8
 9
 10

== try - except ==
 try:
     z1 = 12 / 0
     print(z1)
 except ZeroDivisionError:
     print(&quot;Das Ergebnis ist unendlich&quot;)
 except:
     print(&quot;Kann nicht berechnet werden!&quot;)
     print(&quot;Bitte die Formel korrigieren!&quot;)
 
 print(&quot;Setze Programm fort!&quot;)

Ausgabe:
 Das Ergebnis ist unendlich
 Setze Programm fort!

Es wird versucht, eine Zahl durch Null zu dividieren. Das ist nicht möglich, es wird eine Ausnahme ausgelöst. Das Programm springt daher in den except-ZeroDivisionError-Block und führt die dort gelisteten Anweisungen aus (in unserem Fall eine print-Anweisung). Danach wird das Programm fortgesetzt. Würden wir dieses Programm ohne try-except ausführen, so ergibt sich aus

 z1 = 12 / 0
 print(z1)

folgende Fehlermeldung und ein unmittelbarer Programmabbruch

 Traceback (most recent call last):
   File &quot;C:\tmp\test1.py&quot;, line 1, in &lt;module&gt;
     z1 = 12 / 0
 ZeroDivisionError: division by zero

Mit dem try-except-Mechanismus können also Ausnahmen oder Fehler aufgefangen und behandelt werden. In unserem Beispiel ist das eher trivial, aber bei größeren Programmen kann das durchaus Sinn machen.

Neu in Python 3.14 ist, dass mehrere Ausnahmen auch ohne Klammern angegeben werden können, z.B.:

bis inkl. Python 3.13 nur:
 except (ZeroDivisionError, ValueError):

ab Python 3.14 auch:
 except ZeroDivisionError, ValueError:

== pass ==
Ein leerer Block muss in Python mittels dem Schlüsselwort &lt;code&gt;pass&lt;/code&gt; dargestellt werden. Z.B.

 x = 2
 
 if x == 1:
     print(&quot;Wert ist &quot;, x)
 else:
     pass

Würde man das &lt;code&gt;pass&lt;/code&gt; im else-Block weglassen, so würde man eine Fehlermeldung erhalten:

 IndentationError: expected an indented block after 'else' statement on line 5

= Funktionen =
== Aufrufen von Funktionen ==
Funktionen sind uns im Rahmen dieses Kurses schon zuhauf begegnet. Sei es die print()-, die math.sin()- oder die hex()-Funktion. All diese Funktionen werden von Python zur Verfügung gestellt, ohne dass man sie explizit programmieren müsste. Aufgerufen werden diese Funktionen, indem man ihren Namen eintippt, gefolgt von runden Klammern. In diesen Klammern können noch Argumente übergeben werden. Auch Rückgabewerte sind möglich.

== Funktionen selber schreiben ==
Funktionen werden mit dem def-Schlüsselwort (man definiert die Funktion) eingeleitet, danach folgt der Funktionsname, danach wiederum runde Klammern, in denen formale Argumente stehen können. Abgeschlossen wird die def-Zeile mit einem Doppelpunkt. Danach folgt der Funktionskörper. Dieser Funktionskörper muss wiederum eingerückt werden (wie von den Verzweigungen und Schleifen bekannt). Aufgerufen wird diese Funktion, indem man ihren Funktionsnamen eingibt, gefolgt von runden Klammern (ggf. mit den aktuellen Parametern). Z.B.

 # Funktion definieren
 def halloWelt(i):
     # i ... beliebige Ganzzahl
     print(&quot;Hallo &quot; * i, end=&quot;&quot;)
     print(&quot;Welt!&quot;)
    
 # Funktion aufrufen
 halloWelt(3)

Ausgabe:
 Hallo Hallo Hallo Welt!

Unterschied zwischen formalen und aktuellen Parametern:

[[Datei:PythonIng_func1.jpg]]

&lt;small&gt;Aktuelle Parameter werden auch Argumente genannt.&lt;/small&gt;

Rückgabe von Funktionswerten:
 # Funktion definieren
 def mathFunc(a, b):
     r1 = a + b
     r2 = a * b
     return r1, r2
    
 # Funktion aufrufen
 c, d = mathFunc(3, 5)
 
 # Ausgabe der zurückgegebenen Werte
 print(c)
 print(d)

Ausgabe:
 8
 15

Es werden r1 und r2 zurückgegeben und den Variablen c und d zugewiesen. (r1, r2) und (c, d) sind Tupel. Was Tupel konkret sind, siehe etwas später in diesem Kapitel. 3 und 5 sind die aktuellen Parameter (die Argumente). a und b sind die formalen Parameter. Die Zuweisung der aktuellen zu den formalen Parametern erfolgt in der gegebenen Reihenfolge, also die Zahl 3 wird an a übergeben und die Zahl 5 an b.

Vorgabeparameter, z.B.:
 def mathFunc(a=10, b=20):
     r1 = a + b
     r2 = a * b
     return r1, r2
 
 c, d = mathFunc(3, 5)
 print(c)
 print(d) 
 
 e, f = mathFunc(5)
 print(e)
 print(f)
 
 g, h = mathFunc(b=6)
 print(g)
 print(h)

Ausgabe:
 8
 15
 25
 100
 16
 60

Erklärung:
* Erster &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es werden, wie weiter oben, die Argumente 3 und 5 an die formalen Parameter a und b übergeben. Die Rückgabewerte r1 und r2 werden an c und d übergeben. Somit ist c=8 und d=15.
* Zweiter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur das Argment 5 an a übergeben. b behält den Vorgabewert 20. D.h. e= 25 und f=100.
* Dritter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur die Zahl 6 an b übergeben, a behält seinen Vorgabewert 10. Somit ergibt sich g=16 und h=60.

Beispiel (Schlüsselwortargumente vs. Positionsargumente):
 def mathFunc(a, b):
     r1 = a - b
     r2 = a / b
     return r1, r2
 
 c, d = mathFunc(b=3, a=5)  # Schlüsselwortargumente
 e, f = mathFunc(3, 5)      # Positionsargumente

 print(c)
 print(d)
 print(e)
 print(f)

Ausgabe:
 2
 1.6666666666666667
 -2
 0.6

Durch die Verwendung von Schlüsselwortargumenten können die Argumente in beliebiger Reihenfolge angegeben werden. Bei den Positionsargumenten ist die Reihenfolge vorgegeben. Daraus resultiert auch der Unterschied bei den obigen Ausgaben. Werden beide Arten in einem Aufruf gemischt, so müssen die Positionsargumente zuerst angegeben werden. Den Unterschied zwischen beiden Argumentarten zu kennen ist wichtig, nicht nur bei selbst erstellten Funktionen. Auch beim Aufruf von Python-Funktionen verfolgt einen die Mischung von Schlüsselwort- und Positionsargumenten auf Schritt und Tritt, z.B. beim etwas später folgenden Abschnitt über &quot;Grafiken zeichnen&quot;:

 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)

Bei dieser &lt;code&gt;plot&lt;/code&gt;-Funktion aus dem Modul &lt;code&gt;matplotlib.pyplot&lt;/code&gt; sind &lt;code&gt;x&lt;/code&gt; und &lt;code&gt;y1&lt;/code&gt; Positionsargumente. &lt;code&gt;label, lw&lt;/code&gt; und &lt;code&gt;ls&lt;/code&gt; sind die Namen der Schlüsselwortargumente. Die Schlüsselwortargumente könnten auch in anderer Reihenfolge angeschrieben werden, nicht jedoch die Positionsargumente!
Siehe zu &lt;code&gt;matplotlib.pyplot.plot&lt;/code&gt; auch die Seite [https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html].

== Lambda-Funktionen ==
 print((lambda a, b: a*b) (3, 5))

Ausgabe:
 15

Eingeleitet wird eine Lambda-Funktion (auch Lambda-Form, Lambda-Operator oder anonyme Funktion genannt) mit dem Schlüsselwort &lt;code&gt;lambda&lt;/code&gt;. Es folgen die formalen Argumente, danach ein Doppelpunkt, die Berechnungsvorschrift und ggf. abschliessend in Klammern die aktuellen Parameter.

Man kann einer Lambda-Funktion auch einen Funktionsnamen geben und die Funktion über diesen Namen aufrufen, z.B.

 prod = lambda a, b: a*b
 print(prod(3, 5))

Als Ausgabe wird wieder die Zahl 15 geliefert.

== Rekursive Funktionen ==
Funktionen können wiederum andere Funktionen aufrufen. Von einem {{W|Rekursion|rekursiven Funktionsaufruf}} spricht man, wenn die aufgerufene Funktion gleich der aufrufenden ist. 

 def printFunc(i):
     if (i &gt;= 5):
         return 
     else:
         print(&quot;Hallo Welt&quot;)
         printFunc(i+1)
         
 printFunc(1)

Ausgabe:
 Hallo Welt
 Hallo Welt
 Hallo Welt
 Hallo Welt

Typische Beispiele für die Abarbeitung als rekursive Funktionen sind die {{W|Fibonacci-Folge}} und die {{W|Fakultät_(Mathematik)|Fakultät}}. Jedoch ist der iterative Ansatz (mit konventionellen Schleifen) meist schneller und speicherplatzschonender.

== Funktionsannotationen ==
Python ist sehr flexibel, was Typen angeht. Im Vorhergehenden haben wir generell keine Typangaben gemacht. Will man Typen angeben, so bietet Python das Konzept der Funktionsannotation.

 def calcFunc(a: int, b: int) -&gt; int:
     return a+b
 
 r1 = calcFunc(8, 9)
 r2 = calcFunc(8.0, 9.0)
 r3 = calcFunc(&quot;Hallo&quot;, &quot;Welt&quot;)
 
 print(r1)
 print(r2)
 print(r3)

Ausgabe:
 17
 17.0
 HalloWelt

Jetzt sieht man auf den ersten Blick, welche Typen der Programmierer im Sinn hatte, als er die Funktion erstellte. Das Problem dabei ist nur, dass es Python ziemlich egal ist, welche Typen man im Endeffekt eingibt. Im obigen Beispiel können statt Integer-Typen u.a. auch Float- oder String-Typen eingegeben werden.

&lt;small&gt;
Siehe zum Thema &quot;Type Checking&quot; aber auch den später folgenden Abschnitt [[Ing_Mathematik:_Python#Type_Checker]].
&lt;/small&gt;

== Variadische Funktionen ==
Python-Code:

 def test1(a, *b):
     print(a);
      
     for c in b:
         print(c);
        
 test1(&quot;Hallo&quot;, &quot;Welt&quot;, &quot;Schweizer&quot;, &quot;und alle anderen&quot;)

Ausgabe:

 Hallo
 Welt
 Schweizer
 und alle anderen

Mit dem Stern (auch als Splat-Operator bezeichnet) in der formalen Parameterliste bei der Funktion &lt;code&gt;test1&lt;/code&gt; wird angezeigt, dass eine beliebige Anzahl von Argumenten übergeben wird. &lt;small&gt; Dies entspricht in etwa dem, was in anderen Programmiersprachen (PHP etc.) mittels Ellipse (&lt;code&gt;...&lt;/code&gt;) angezeigt wird.&lt;/small&gt;

= Tupel, Listen und andere =
[[Datei:Python 3. The standard type hierarchy.png|mini|hochkant=1.7|Datentypen und Strukturen]]

== Tupel und Listen ==
Tupel, Listen und einige andere sind Datenstrukturen oder Sequenzen.

Listen (z.B. eine Einkaufsliste) sind veränderbar (mutable). Ein Tupel kann dagegen nicht verändert werden (immutable). Listen werden beim Anlegen in eckige Klammern eingeschlossen, Tupel in runde Klammern. Beim Tupel können die Klammern auch weggelassen werden. Ein Tupel mit nur einem Element muss mit einem Beistrich abgeschlossen werden. Der Grund ist, dass Python sonst nicht entscheiden kann, ob ein Tupel angelegt werden soll, oder nur ein geklammerter Wert. 

Als Gedächtnisstütze kann man sich den Unterschied zwischen Tupel und Liste ev. so leichter merken:
: T'''u'''pel ... r'''u'''nde Klammern, '''u'''nveränderlich
: L'''i'''ste ... eck'''i'''ge Klammern, veränderl'''i'''ch.

Nachfolgend werden einige Operationen mit Listen und Tupel dargestellt.

 # Liste und Tupel
 liste = [1, 2, &quot;Hallo&quot;]
 tupel = (1, 2, &quot;Hallo&quot;) 
 
 # Ausgabe von liste und tupel
 print(liste)
 print(tupel)
 
 # Ausgabe von Einzelelementen
 print(liste[1])
 print(tupel[2])
 
 # Element an Liste anhängen und einfügen 
 liste.append(55)
 liste.insert(4, &quot;Welt&quot;)
 print(liste)
 
 # Element aus Liste entfernen
 liste.remove(1)
 print(liste)
 
 # einige weitere Beispiele
 liste2 = [1,]
 tupel2 = 1, 2
 tupel3 = (1,) 
 print(liste2)
 print(tupel2)
 print(tupel3)

Ausgabe:
 [1, 2, 'Hallo']
 (1, 2, 'Hallo')
 2
 Hallo
 [1, 2, 'Hallo', 55, 'Welt']
 [2, 'Hallo', 55, 'Welt']
 [1]
 (1, 2)
 (1,)

Beispiel (eine Liste von Wörtern zu einem einzigen zusammenhängenden Text verbinden):

 woerter = [&quot;Hallo&quot;, &quot;Welt&quot;]
 satz = &quot; &quot;.join(woerter)
 print(satz)

Ausgabe:

 Hallo Welt

== Dictionaries und Mengen ==
Zu den Datenstrukturen gehören weiters auch Mengen und Dictionaries. Mengen sind von der Mathematik bekannt, sie sind ungeordnet und es kommen keine mehrfachen Elemente vor. Dictionaries sind durch Schlüssel :Wert-Paare gekennzeichnet. Mengen werden beim Anlegen wie Dictionaries in geschweifte Klammern eingeschlossen.

 dict = {&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot; }
 menge = {1, 1, 3, 4, 4, 4, &quot;Hallo&quot;}
 
 print(dict)
 print(menge)
 print(dict[&quot;vorname&quot;])

Ausgabe:
 {'vorname': 'Hugo', 'nachname': 'Meister'}
 {1, 3, 4, 'Hallo'}
 Hugo

Geschweifte Klammern ohne Inhalt stellen Dictionaries dar und keine Mengen:

 di = {}
 print(type(di))

Ausgabe:
 &lt;class 'dict'&gt;

Leere Mengen lassen sich mit &lt;code&gt;set()&lt;/code&gt; erzeugen:

 menge = set()      # leere Menge
 print(menge)
 menge.add(&quot;Hallo&quot;) # Element hinzufügen
 print(menge)

Ausgabe:
 set()
 {'Hallo'}

Beispiel (einige Mengenoperationen):
 mengeA = {&quot;Hallo&quot;, &quot;Welt&quot;}
 mengeB = {1, 2, &quot;Welt&quot;, 3}
 
 # Vereinigung
 print(mengeA | mengeB)
 print(mengeA.union(mengeB))
 
 # Durchschnitt
 print(mengeA &amp; mengeB)
 print(mengeA.intersection(mengeB))
 
 # Differenz
 print(mengeA - mengeB)
 print(mengeA.difference(mengeB))
 
 # Symmetrische Differenz
 print(mengeA ^ mengeB)
 print(mengeA.symmetric_difference(mengeB))
 
 # Teilmenge
 print(mengeA.issubset(mengeB))
 
 # Mehrere Elemente hinzu
 mengeA.update([&quot;Super&quot;, 67, 125])
 print(mengeA)
 
 # Element löschen
 mengeA.discard(&quot;Hallo&quot;)
 print(mengeA)

Ausgabe:
 {1, 2, 3, 'Welt', 'Hallo'}
 {1, 2, 3, 'Welt', 'Hallo'}
 {'Welt'}
 {'Welt'}
 {'Hallo'}
 {'Hallo'}
 {1, 2, 3, 'Hallo'}
 {1, 2, 3, 'Hallo'}
 False
 {67, 'Super', 'Welt', 'Hallo', 125}
 {67, 'Super', 'Welt', 125}

Es gibt schon seit &quot;ewigen&quot; Zeiten unveränderbare Mengen, die mittels &lt;code&gt;frozenset&lt;/code&gt; eingeleitet werden. Neu ab Python 3.15 ist dagegen das Pendant &lt;code&gt;frozendict&lt;/code&gt;, das unveränderbare Dictionaries darstellt.

 fdict = frozendict({&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot;})
 fset = frozenset({&quot;A&quot;, 1, &quot;A&quot;})
 
 print(fdict)
 print(fdict[&quot;vorname&quot;])
 print (fset) 
 
 try:
     fdict[&quot;vorname&quot;] = &quot;Max&quot;
     print(fdict[&quot;vorname&quot;])
 except TypeError as e:
     print(f&quot;Fehler: {e}&quot;)
 
 try:
     fset.add(&quot;B&quot;)
     print(fset)
 except AttributeError as e:
     print(f&quot;Fehler: {e}&quot;)

Ausgabe:
 frozendict({'vorname': 'Hugo', 'nachname': 'Meister'})
 Hugo
 frozenset({1, 'A'})
 Fehler: 'frozendict' object does not support item assignment
 Fehler: 'frozenset' object has no attribute 'add'

== List Comprehensions ==
Aus einer Eingabeliste soll eine Ausgabeliste erzeugt werden. Das kann folgendermaßen geschehen.

Mathematische Schreibweise: &lt;math&gt;lc = \{2x|x\in\ \mathbb{N}, 1\le x &lt; 11\}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11)]
 print(lc)

Ausgabe:
 [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Mathematische Schreibweise: &lt;math&gt;lc = \{2x | x \in \mathbb{N}, 1\le x &lt; 11, x \bmod 2 = 0 \}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11) if x%2 == 0]
 print(lc)

Ausgabe:
 [4, 8, 12, 16, 20]

Siehe auch {{W|List Comprehension}}.

== Set Comprehensions ==
Dies ist sehr ähnlich wie im vorigen Abschnitt beschrieben. Es wird aber keine Liste, sondern eine Menge erzeugt.

 sc = {x*2 for x in range(1,11)}
 print(sc)

Ausgabe:
 {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}

== Listen zusammenführen - zip() ==
 li1 = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]
 li2 = [1, 2, 3, 4]
 li3 = [5.5, 6.6, 7.7, 8.8]
 
 z = zip(li1, li2, li3)
 print(z)
 
 li4 = list(z)
 print(li4)

Ausgabe:
 &lt;zip object at 0x00000283B6C6AC80&gt;
 [('A', 1, 5.5), ('B', 2, 6.6), ('C', 3, 7.7), ('D', 4, 8.8)]

== Generatorausdruck ==
 g = (i*2 for i in range(1,11))
 print(g)
 t = tuple(g)
 print(t)
 print(t[1:3])

Ausgabe:
 &lt;generator object &lt;genexpr&gt; at 0x00000241D2A4A5A0&gt;
 (2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
 (4, 6)

== Slicing ==
slice ... Scheibe, Teil, in Scheiben schneiden

Beispiel: Zugriff auf Elemente eines geordneten sequentiellen Objekttyps (Liste, Tupel oder String):

 str1 = &quot;Hallo&quot;
 # Das erste Element wird mit dem Index 0 angesprochen
 # [start (inkl.) : stop (exkl.) : step (default=1)]
 str2 = str1[0:2]
 # Alternativ auch: str2 = str1[:2] 
 print(str2)
 
 tup1 = (0,1,2,3)
 # Das letzte Element hat auch den Index -1, das vorletzte den Index -2 usw.
 tup2 = tup1[-3:-1]
 print(tup2)
 
 lst1 = [[1,  5,  10, 20],
         [30, 40, 50, 60]]
 lst2 = lst1[1][1]
 print(lst2)
 
Ausgabe:
 Ha
 (1, 2)
 40

Beispiel:

 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2])
 print(x[-3]) 
 print(x)
 print(x[:])
 print(x[2:])
 print(x[:2])
 print(x[::-1])

Ausgabe:

 c
 c
 ('a', 'b', 'c', 'd', 'e')
 ('a', 'b', 'c', 'd', 'e')
 ('c', 'd', 'e')
 ('a', 'b')
 ('e', 'd', 'c', 'b', 'a')

Visualisierung:

    '''a'''     '''b'''     '''c'''     '''d'''     '''e'''
 +-----------------------------+
 |  0  |  1  |//'''2'''//|  3  |  4  |
 +-----------------------------+
 | -5  | -4  |/'''-3'''//| -2  | -1  | 
 +-----------------------------+
 |/////////////////////////////|
 +-----------------------------+
 |/////////////''':'''///////////////|
 +-----------------------------+
 |     |     |///////'''2:'''////////|
 +-----------------------------+
 |////''':2'''/////|     |     |     |
 +-----------------------------+
 |\\\\\&lt;--\\\\\'''::-1'''\\\\&lt;--\\\\\|
 +-----------------------------+

Beispiel:
 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2::2])
 print(x[2::-1])
 print(x[2:0:-1])

Ausgabe:

 ('c', 'e')
 ('c', 'b', 'a')
 ('c', 'b')

Hier sieht man sehr schön, dass beim letzen &lt;code&gt;print&lt;/code&gt;-Befehl die 0, die in diesem Fall den Buchstaben &quot;a&quot; repräsentiert, als letzer Wert nicht mehr dazugehört (wie weiter oben angedeutet ist der End- oder Stoppwert exklusiv). Will man den Buchstaben &quot;a&quot; dazunehmen, so ist die vorletzte Zeile die richtige.

Beispiel: Umdrehen von Strings

 str1 = &quot;Hallo&quot;
 str2 = str1[::-1]
 print(str2)

Ausgabe:
 ollaH

Mit zweidimensionalen Listen/Tupels wird das Ganze schon bedeutend komplexer.

Beispiel: Verkettetes Slicing

 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
     
 print(A[2::][::2])

Ausgabe:

 [['20', '21', '22', '23'], ['40', '41', '42', '43']]

Das erste Slicing erstellt folgenden Slice:

 [[&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
  [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
  [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]

Das zweite Slicing wird dann auf diesen Slice angewendet und ergibt das genannte Endergebnis. Will man Spalten statt Zeilen, so funktioniert dieser direkte Weg nicht. Man verwendet dann List Comprehensions oder die NumPy-Bibliothek. Diese Bibliothek erlaubt [[Ing_Mathematik:_Python#Zugriff_auf_Matrizenelemente|zweidimensionales Slicing]]. Sie wird erst später bei den Grafiken eingeführt. Deshalb wird hier dazu noch kein Beispiel gezeigt.

= Objektorientierte Programmierung =
{{Wikipedia|Objektorientierte Programmierung}}

* {{W|Klasse (Objektorientierung)|Klasse}} ... die Schablone oder der Bauplan, enthält Methoden und Attribute
* {{W|Objekt (Programmierung)|Objekt}} ... eine Klasseninstanz (die konkrete Ausprägung der Klasse)
* {{W|Attribut (Programmierung)|Attribute}} ... die Eigenschaften eines Objekts
* {{W|Methode (Programmierung)|Methoden}} ... die Aktionen (Operationen), die ein Objekt ausführen kann
* {{W|Vererbung (Programmierung)|Vererbung}} ... neue Klassen (Subklassen, Unterklassen, abgeleitete Klassen) aus vorhandenen Klassen (Superklassen, Oberklassen, Basisklassen, Elternklassen) ableiten. Ermöglicht den Aufbau von Klassenhierarchien. Die Subklasse &quot;erbt&quot; Attribute und Methoden von der Superklasse. Python unterstützt (so wie C++, aber im Gegensatz zu Java) Mehrfachvererbung.

== UML ==
* {{W|Unified Modeling Language|UML}} ... '''U'''nified '''M'''odeling '''L'''anguage, eine Modellierungssprache. Die UML enthält zahlreiche Diagrammarten, um Programme zu modellieren. Im Nachfolgenden wird nur das {{W|Klassendiagramm}} verwendet.

[[File:UmlCd Klasse-3.svg|300px]]

* {{W|Sichtbarkeit (Programmierung)|Sichtbarkeit}}:
** + ... public (öffentlich)
** - ... private
** # ... protected 

* {{W|Attribut_(UML)#Attribute_für_Instanzen_und_für_Klassen|Klassenattribute}} (statische Attribute): Werden nur einmal pro Klasse angelegt. Im Klassendiagramm werden sie unterstrichen.

[[File:Attribute-3.png|200px]]

* Vererbung:

&lt;gallery&gt;
InheritancePgmUML.svg | Abgeleitete Klasse erbt von Basisklasse (Einfachvererbung)
Diamond inheritance.svg | D erbt von B und C (Mehrfachvererbung). B und C erben von A (Einfachvererbung)
&lt;/gallery&gt;

Für weitergehende Betrachtungen zur UML wird auf Spezialliteratur verwiesen, z.B.:
* Seidl et al.: UML@Classroom. dpunkt, 2012, ISBN 978-3-89864-776-2
* Rupp et al.: UML 2 glasklar. Hanser, 4. Aufl., 2012, ISBN 978-3-446-43057-0

== Eine einfache Klasse ==

[[Datei:PythonIng_uml1.svg | 200px]]

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
 
 fahr = Fahrzeug(150, 90)
 
 print(fahr.convertGeschw())
 
Ausgabe:
 41.666666666666664

Die Klasse Fahrzeug wird durch das class-Schlüsselwort eingeleitet. raeder ist ein Klassenattribut und public. __init__ wird bei der Objekterzeugung automatisch aufgerufen (ist der sogenannte Konstruktor). Man achte darauf, dass diese Methode immer mit zwei Unterstrichen eingeleitet und abgeschlossen wird. Instanzattributen wird das Wort self vorangestellt. Wir sehen uns z.B. das Attribut self.__geschwind an. Auch hier werden zwei Unterstriche verwendet. Das bedeutet, dass dieses Attribut strikt/stark private ist. Wird nur ein Unterstrich verwendet, so deutet dies auf schwach/weakly private hin. Letzteres wird in Python deutlich häufiger verwendet. Bei den Methoden wird immer self als erster Parameter angegeben. Beim Aufruf der entsprechenden Funktion wird das self aber nicht berücksichtigt.

Besonderheiten bei stark und schwach private:
* '''stark private''':
** zwei führende Unterstriche
** Name Mangling: Name wird zu &lt;code&gt;_Klassenname__variablenname&lt;/code&gt;
** Schutz vor Namenskollisionen bei Vererbung
** am Ende des Namens dürfen keine zwei Unterstriche verwendet werden. Das wären dann Magic Methods oder Dunder-Methods (z.B. __init__). Diese sind public.

* '''schwach private''':
** ein führender Unterstrich
** Name bleibt gleich
** ist nur ein Hinweis an die Programmierer, kein starker Schutz
** &lt;code&gt;from modul import *&lt;/code&gt;: Objekte mit einem führenden Unterstrich werden standardmäßig nicht importiert
** Standard für die Kapselung bei Python. Schätzung: Weit mehr als 80% der nicht-öffentlichen Attribute/Methoden werden als schwach private deklariert. Weniger als 5-10% als stark private (Quelle: Google KI)

== Klassen importieren ==
Häufig ist es sinnvoll und übersichtlicher Klassen in eigenen Dateien zu speichern. Das sind dann eigene Module. Abgespeichert werden Sie mit der Endung py, wie bisher auch praktiziert. Aufgerufen werden Sie mit der import-Anweisung. Dann ist aber nur der Dateiname ohne Endung py zu verwenden. Klarer wird das mit einem Beispiel.

Datei c:\tmp\fahrzeug.py

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6

Datei c:\tmp\test1.py

 import fahrzeug
 fahr = fahrzeug.Fahrzeug(150, 90)
 print(fahr.convertGeschw())

Ausgabe:
 41.666666666666664

Die üblichen import-Anweisungen lauten wie folgt:
{| {{prettytable}}
! import-Befehl
! Instanz
|-
| import xyz      || xyz.Klasse
|-
| import xyz as x || x.Klasse
|-
| from xyz import Klasse || Klasse
|-
| from xyz import * || Klasse 
|}

Der Vorteil der ersten beiden import-Anweisungen ist, dass es kaum zu Namenskollisionen kommen kann. Dafür hat man bei den letzten beiden Varianten weniger Tipparbeit.

== Vererbung ==
=== Einfachvererbung ===

[[Datei:PythonIng_uml2.svg | 200px]]

Datei fahrzeug.py:
 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
        
     def setLeistung(self, leistung):
         self.__leistung = leistung
        
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
        
 class Luftfahrzeug(Fahrzeug):
     def __init__(self, geschwindigkeit, leistung, fluegel):
         super().__init__(geschwindigkeit, leistung)
         self.__flueg = fluegel
     
     def getFlueg(self):
         return self.__flueg

Datei test1.py:
 import fahrzeug
 fahr = fahrzeug.Luftfahrzeug(150, 90, 4)
 print(fahr.getFlueg())

Ausgabe:
 4

=== Mehrfachvererbung ===
Mit Python ist auch Mehrfachvererbung möglich, z.B.:

 class A:
     def _printA(self):
         print(&quot;Klasse A&quot;)
 
 class B:
     def _printB(self):
         print(&quot;Klasse B&quot;)
 
 class C(A,B):
     def __init__(self):
         self._printA()
         self._printB()
 
 c = C()

Ausgabe:

 Klasse A
 Klasse B

Die Klasse C erbt von A und B. In UML sieht das in etwa so aus:

 +-----------------------------+   +-------------------------+
 |            A                |   |          B              |
 +-----------------------------+   +-------------------------+
 |                             |   |                         |
 +-----------------------------+   +-------------------------+
 | # printA()                  |   | # printB()              |
 +-----------------------------+   +-------------------------+
                           .              .
                          / \            / \
                          ---            ---
                           |              |
                           |              |
                        +---------------------+
                        |          C          |
                        +---------------------+
                        |                     |
                        +---------------------+
                        |                     |
                        +---------------------+

&lt;code&gt;printA()&lt;/code&gt; und &lt;code&gt;printB()&lt;/code&gt; sind schwach private (in UML als &lt;code&gt;protected&lt;/code&gt; mit einem # dargestellt). Es ist aber zu beachten, dass schwach private nur Konvention ist. Praktisch könnte man auch von außerhalb auf diese Methoden zugreifen. Das soll man aber nicht tun, und das wird in Python durch einen Unterstrich angedeutet.

== Statische Attribute, statische Methoden und Klassenmethoden ==
Beispiel:

 class Math:
     pi = 3.14159265
     cnt = 0
     
     @staticmethod
     def expo():
         return 2.71828183
    
     @classmethod    
     def counterPlus(cls):
         cls.cnt += 1
        
 print(Math.pi)
 print(Math.expo())
 
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)

Ausgabe:

 3.14159265
 2.71828183
 1
 2
 3

Statische Attribute und Methoden, bzw. Klassenmethoden, sind direkt einer Klasse zugeordnet und nicht einem Objekt. Der Unterschied zwischen statischen Methoden und Klassenmethoden ist, dass statische Methoden nicht auf Klassenattribute (bzw. statische Attribute) zugreifen können, Klassenmethoden aber schon. &lt;code&gt;pi&lt;/code&gt; und &lt;code&gt;cnt&lt;/code&gt; sind statische Attribute. &lt;code&gt;expo()&lt;/code&gt; ist eine statische Methode. &lt;code&gt;counterPlus(cls)&lt;/code&gt; ist eine Klassenmethode. Die Bezeichnung des Parameters als &lt;code&gt;cls&lt;/code&gt; ist reine Konvention, man sollte sich aber daran halten. &lt;code&gt;@staticmethod&lt;/code&gt; und &lt;code&gt;@classmethod&lt;/code&gt; nennt man auch Dekoratoren.

= Grafiken zeichnen =
Für das Zeichnen von Grafiken wird hier das Modul &lt;code&gt;matplotlib&lt;/code&gt; verwendet. &lt;code&gt;matplotlib&lt;/code&gt; ist ein externes Modul und muss vor der ersten Verwendung installiert werden. Das geht so:

# Starten Sie ein Terminal (bei Windows die Eingabeaufforderung).
# Führen Sie darin folgenden Befehl aus &lt;code&gt;c:\devel\Python\Scripts\pip.exe install matplotlib&lt;/code&gt;

pip ist übrigens der Paketmanager von Python ({{W|Pip_(Python)}}). 

Optimalerweise installieren wir auch gleich das Modul &lt;code&gt;numpy&lt;/code&gt; (Numerical Python). Wir werden es im Folgenden oft benötigen (nicht nur bei den Grafiken). Das funktioniert vom Prinzip her genauso, wie für &lt;code&gt;matplotlib&lt;/code&gt; gezeigt.

&lt;small&gt;Verwenden Sie Spyder, so sind diese Schritte nicht nötig. Spyder inkludiert diese Pakete standardmäßig. Unter openSUSE Tumbleweed lassen sich diese Pakete mittels YaST oder zypper installieren.&lt;/small&gt;

== 2D ==
=== Graph einer Funktion ===
Es soll die cosh-Funktion im Intervall &lt;math&gt;x\in[-3,3]&lt;/math&gt; gezeichnet werden. Der Programmcode lautet in der einfachsten Form:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x)
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:PythonIng_cosh1.jpg]]

Der Code ist quasi selbsterklärend. Das Untermodul pyplot des matplotlib-Moduls und das numpy-Modul werden importiert. x läuft von -3 bis +3. y wird für jeden x-Wert per Formel ausgerechnet. &quot;plt.plot()&quot; ist der Zeichenbefehl. &quot;plt.show&quot; ist notwendig, um das Fenster mit der Grafik anzuzeigen.
Die Schrittweite 0.1 wurde so gewählt, um einen ausreichend glatten Verlauf des Graphen zu gewährleisten. Das ist immer ein Kompromiss zwischen Berechnungszeit und Ansehnlichkeit. Testen Sie einfach ein paar verschiedene Werte, um ein Gefühl dafür zu zu bekommen. &quot;plt.grid()&quot; zeichnet ein Gitter in die Grafik (kann auch weggelassen werden).
Die Bezeichnungen plt und np könnten auch anders gewählt werden. Es ist aber Konvention, diese so wie hier gezeigt zu wählen. Die &quot;arange&quot;-Funktion aus der NumPy-Bibliothek wird später ein bisschen genauer behandelt (siehe [[Ing_Mathematik:_Python#Zahlenfolgen|Zahlenfolgen]]).  

&lt;small&gt;Mit der im obigen Bild gezeigten Menüleiste kann die dargestellte Grafik nachträglich noch geändert werden (Zoom, Pan, Achsenparameter, Kurvenparameter etc.). Natürlich kann man das alles auch direkt programmieren. Wie das funktioniert wird ansatzweise etwas später gezeigt.&lt;/small&gt;

Ein etwas komplexeres Beispiel ist Folgendes:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x) + 2**x
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:
[[Datei:PythonIng_cosh4.png]]

Man beachte, dass im Gegensatz zu Octave und Julia der ominöse Punkt (.) bei 2**x mit Python nicht benötigt wird. Das macht das Programmiererleben etwas einfacher.

Die Farbe des Graphen kann man über den &lt;code&gt;color&lt;/code&gt;-Schalter einstellen, z.B. auf rot setzen:
 plt.plot(x, y, color=&quot;red&quot;)

Das ist nur eine Möglichkeit, es gibt auch andere, z.B. mittels
* hexadezimaler Zahl, z.B. &lt;code&gt;color=&quot;#ff0000&quot;&lt;/code&gt;
* Kurzform, z.B. &lt;code&gt;&quot;r&quot;&lt;/code&gt;

Statt &lt;code&gt;color&lt;/code&gt; kann auch die Kurzform &lt;code&gt;c&lt;/code&gt; verwendet werden.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie diese &quot;Farbspielereien&quot; am Computer aus.

=== Graphen mehrerer Funktionen und weiteres ===
==== Mehrere Funktionen in einen Plot zeichnen ==== 
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh2.png]]

Um die Linienstile etwas individueller zu gestalten, ist folgender Programmcode gedacht: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;, lw=3, ls=&quot;--&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh3.png]]

Einige weitere Bespiele zu &lt;code&gt;ls&lt;/code&gt;&lt;/code&gt;:
* - ... durchgezogene Linie
* -. ... Strichpunkt-Linie
* dashed ... gestrichelte Linie 

==== Marker ====
Desweiteren kann man Marker verwenden.

Beispiel:

 import matplotlib.pyplot as plt
 
 plt.plot(10, 10, &quot;ob&quot;, markersize=30)
 plt.plot(20,20, &quot;.r&quot;)
 plt.plot(30,30, &quot;Dg&quot;, ms=15)
 plt.plot(40, 40, &quot;ok&quot;, ms=20, mec=&quot;#FF5733&quot;, mew=3)
 plt.plot(50, 50, &quot;vk&quot;, ms=20, mec=&quot;yellow&quot;, mew=3)
 plt.grid()
 plt.show()


Das erste Zeichen im String nach den Koordinaten im plot-Befehl symbolisiert die Form (z.B. o für einen Kreis). Das zweite Zeichen steht für die Farbe (z.B. b für blue). &lt;code&gt;markersize&lt;/code&gt; oder &lt;code&gt;ms&lt;/code&gt; setzt die Größe des Markers.

Ausgabe:

[[Bild:PythonIng_formatpara1.svg|200px]]

Einige weitere Marker:
* * ... Stern
* + ... Plus
* h oder H ... Sechseck

Man kann mit den Parametern 
* &lt;code&gt;markeredgecolor&lt;/code&gt; oder kurz &lt;code&gt;mec&lt;/code&gt; die Farbe des Markerrandes
* &lt;code&gt;markeredgewidth&lt;/code&gt; oder kurz &lt;code&gt;mew&lt;/code&gt; die Dicke des Randes
* &lt;code&gt;markerfacecolor&lt;/code&gt; oder kurz &lt;code&gt;mfc&lt;/code&gt; die Innenfarbe des Markers
bestimmen.

=== Funktion in Parameterdarstellung ===
Es soll die archimedische Spirale &lt;math&gt;x = t \cos(t), y = t  \sin(t)&lt;/math&gt; im Intervall &lt;math&gt;[0, 6\pi[&lt;/math&gt; gezeichnet werden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
  
 plt.show()

[[Datei:PythonIng_spirale1.png]]

Diese Darstellung erscheint verzerrt. Will man gleiche Achsenskalierungen, so kann man den plt.axis()-Befehl verwenden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
 plt.axis(&quot;equal&quot;)
 
 plt.show()
 
[[Datei:PythonIng_spirale2.png]]

=== Funktion in Polardarstellung ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 fig = plt.figure()
 ax = fig.add_subplot(projection=&quot;polar&quot;)
 r = np.arange(0, 1, 0.01)
 theta = r**3
 line = ax.plot(theta, r)
 
 plt.show()

[[Datei:PythonIng_polar1.png]]

=== Logarithmische Achsenskalierung ===
==== Semilog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.semilogy()
 plt.show()

Ausgabe:

[[Datei:PythonIng_semilog1.png]]

==== LogLog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.loglog()
 plt.show()

[[Datei:PythonIng_loglog1.png]]

=== Gefüllte Fläche ===
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.arange(0, 3, 0.1)
 
 y1 = 3*x - 1
 y2 = x**2
 
 plt.plot(x, y1, x, y2, color='black')
 plt.fill_between(x, y1, y2, where=y1&gt;=y2)
 
 plt.show()

[[Datei:PythonIng_gefuellt.png]]

=== Linien, Pfeile, Rechtecke, Kreise und Texte ===
 import matplotlib as mpl
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 r = mpl.patches.Rectangle((0, 0), 3, 3, angle=30, fill=False)
 c = mpl.patches.Circle((4, 4), 2, fill=False)
 
 ax.add_patch(r)
 ax.add_patch(c)
 ax.plot([-2, 7], [-2, 0], color=&quot;black&quot;)
 ax.arrow(0, 7, 5, 0, length_includes_head=True, head_width=0.5, head_length=1.5,
          color=&quot;black&quot;)
 
 ax.set_aspect(&quot;equal&quot;)
 
 plt.axis([-3, 8, -3, 8])
 plt.show() 

[[Datei:PythonIng_linien_pfeile_etc.png]]

Text kann mit &lt;code&gt;ax.text(x, y, &quot;Text&quot;)&lt;/code&gt; hinzugefügt werden, bspw.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 ax.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

Oder einfacher auch ohne &lt;code&gt;subplots&lt;/code&gt;

 import matplotlib.pyplot as plt
 
 plt.text(0.1, 0.1, &quot;Hallo&quot;)
 plt.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

[[Datei:PythonIng_text1.png]]

Auch Sonderzeichen (griechische Buchstaben etc.) können verwendet werden (siehe dazu auch [https://matplotlib.org/stable/users/explain/text/mathtext.html]).

 import matplotlib.pyplot as plt
 
 plt.text(.3, .5,
          r'$\Omega\ \psi\ \oint\ \nabla\ \dot a\ \frac{a}{b}\ a_b$',
          size=&quot;20&quot;)
 plt.show() 

[[Datei:PythonIng_text20.svg]]

Jetzt wird noch gezeigt, wofür &lt;code&gt;subplots&lt;/code&gt; sinnvoll eingesetzt werden können.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(0.1, 0.1, &quot;Hallo&quot;)
 ax[1].text(0.1, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
            rotation=30.0)
 
 plt.show()

[[Datei:PythonIng_text2.png]]

=== Anmerkungen hinzufügen ===
Anmerkungen (engl. annotations) lassen sich mit matplotlib einfach hinzufügen. Unter Anmerkung wird hier ein Pfeil mit Text verstanden.

Beispiel:

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 ax.plot([1,10], [1,10])
 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
             arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0))
 plt.show()

Ausgabe:

[[Datei: PythonIng_ann1.svg|400px]]

&lt;code&gt;shrink&lt;/code&gt; verkürzt den Pfeil. Sinnvoll sind beim obigen Beispiel Werte irgendwo zwischen 0.0 und 0.3.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie verschiedene Pfeillängen aus. 

Die Schriftgröße verändern können Sie übrigens mit &lt;code&gt;fontsize&lt;/code&gt; oder &lt;code&gt;size&lt;/code&gt;, z.B.

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0), fontsize=25)

Eine andere Schreibweise für Dictionaries, die wir weiter oben schon kennengelernt haben, die wir aber nochmals explizit aufschreiben wollen, ist

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops={&quot;facecolor&quot;:&quot;red&quot;, &quot;shrink&quot;:0.0})

=== Figure, Axes etc.===
[[Bild:PythonIng_figure33.svg|350px]]

* fig (figure) ... das übergeordnete Fenster
* ax (axes) ... &quot;Plot&quot;, das eigentliche Zeichenfenster
* axis ... die Koordinatenachsen
* spine ... Begrenzungslinien des Zeichenfensters
* tick ... Markierung an den Achsen des Zeichenfensters

Beispiel (eine figure mit 6 axes, ax-Titel, y-axis-Titel):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=3, ncols=2)
 
 ax[0][0].text(0.1, 0.5, &quot;11&quot;)
 ax[0][1].text(0.1, 0.5, &quot;12&quot;)
 ax[1][0].text(0.1, 0.5, &quot;21&quot;)
 ax[1][1].text(0.1, 0.5, &quot;22&quot;)
 ax[2][0].text(0.1, 0.5, &quot;31&quot;)
 ax[2][1].text(0.1, 0.5, &quot;32&quot;)
 
 ax[0][0].set(ylabel=&quot;y-label&quot;, title=&quot;axes 1&quot;)
 
 plt.show()

[[Bild:PythonIng_figure34.png|350px]]

Beispiel (Achsenbereiche setzen):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 
 ax[0].axis((-1, 10, 1, 12))
 
 plt.show()

[[Bild:PythonIng_figure35.svg|350px]]

Beispiel (Gitter einschalten): 

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 ax[0].axis((-5, 10, 1, 12))
 ax[0].minorticks_on()
 ax[0].grid(which='minor')
 ax[1].grid(which='major')
 plt.show()

[[Bild:PythonIng_figure36.svg|350px]]

Beispiel (ticks setzen)

 import matplotlib.pyplot as plt
 import matplotlib.ticker as tick
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 pos = [0, .2, .5]
 lab = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
 
 ax.xaxis.set_major_locator(tick.FixedLocator(pos))
 ax.xaxis.set_major_formatter(tick.FixedFormatter(lab))
 
 plt.show()

[[Bild:PythonIng_figure37.svg|350px]]

Beispiel (Achsenkreuz beliebig setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 ax.spines['top'].set_color('none')
 ax.spines['right'].set_color('none')
 ax.spines['bottom'].set_position(('data', 0.3))
 ax.spines['left'].set_position(('data', 0.5))
 
 plt.show()

[[Bild:PythonIng_figure38.svg|350px]]

Beispiel (Inset):

 import matplotlib.pyplot as plt
 
 # Hauptplot erstellen
 fig, ax = plt.subplots()
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 
 # Inset hinzu:
 axin = ax.inset_axes([0.4, 0.4, 0.3, 0.3])
 axin.text(0, 0, &quot;Servus&quot;)
 axin.plot()
 
 plt.show()

[[Bild:PythonIng_figure40.svg|350px]]

Beispiel (Hintergrundfarben setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.set_facecolor(&quot;green&quot;)
 fig.set_facecolor(&quot;yellow&quot;)
 
 plt.plot([1, 3], [6, 8])
 plt.show()

[[Bild:PythonIng_figure39.svg|300px]]

=== GridSpec ===
Mit figures und axes lassen sich schon jede Menge an Grafikdetails einstellen. GridSpec ist dann der Turbo oder Raketenantrieb den matplotlib eingebaut hat. Naja, vielleicht ist das etwas übertrieben, aber GridSpec ist sozusagen ein flexibler Layout-Manager. Bisher haben wir immer gleich große axes gezeichnet. Mit GridSpec können wir Subplots über mehrere Zeilen und Spalten ziehen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 gs = fig.add_gridspec(3, 3)
 
 ax1 = fig.add_subplot(gs[0, :])
 ax1.set_title(&quot;Bereich 1: gs[0, :]&quot;)
 
 ax2 = fig.add_subplot(gs[1:, 0])
 ax2.set_title(&quot;Bereich 2: gs[1:, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 1:])
 ax3.set_title(&quot;Bereich 3: gs[1, 1:]&quot;)
 
 ax4 = fig.add_subplot(gs[2, 1:])
 ax4.set_title(&quot;Bereich 4: gs[2, 1:]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec1.svg|350px]]

Erklärung zu &lt;code&gt;(gs[zeile, spalte])&lt;/code&gt;: Slicing; damit legen Sie fest, welche Zellen ein Subplot belegt. Achtung! Die Indizes beginnen bei 0 und nicht bei 1 (d.h., die erste Zeile/Spalte hat den Index 0)
* : ... alle 
* 1: ... 1 bis Ende
* etc.

&lt;code&gt;constrained_layout=True&lt;/code&gt; sorgt dafür, dass sich die Subplots nicht überlappen.

Aber auch die Spaltenbreiten und Zeilenhöhen lassen sich anpassen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 
 # Verhältnis erste zu zweite Zeile = 1.5:1
 # Verhältnis erste zu zweite Spalte  = 1:4
 gs = fig.add_gridspec(2, 2, figure=fig, height_ratios=[1.5, 1], width_ratios=[1, 4])
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax1.set_title(&quot;Bereich 1: gs[0, 0]&quot;)
 
 ax2 = fig.add_subplot(gs[0, 1])
 ax2.set_title(&quot;Bereich 2: gs[0, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 0])
 ax3.set_title(&quot;Bereich 3: gs[1, 0]&quot;)
 
 ax4 = fig.add_subplot(gs[1, 1:])
 ax4.set_title(&quot;Bereich 4: gs[1, 1]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec2.svg|350px]]

Auch die Ränder lassen sich einstellen.

Beispiel 1:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.1, right=0.9, bottom=0.1,
                        top=0.9, wspace=0.2, hspace=0.2)
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec3.svg|300px]]

* hspace ... height space, vertikaler Abstand zwischen den Zeilen
* wspace ... width space, horizontaler Abstand zwischen den Spalten

Und im Vergleich dazu Beispiel 2:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.3, right=0.7, bottom=0.3, 
                        top=0.7, wspace=0.3, hspace=0.3) 
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec4.svg|300px]]

Es gibt noch einige weitere Details, die sich mit GridSpec variieren lassen (z.B. SubGridSpec ... verschachtelte Grid-Layouts). Aber wir belassen es vorerst dabei. Das bisher Gezeigte sollte für die meisten Probleme ausreichend sein.

=== Aufgaben ===
* Zeichnen Sie die Strophoide &lt;math&gt;x = \frac{a(t^2-1)}{t^2+1}, y = \frac{at(t^2-1)}{t^2+1}, a = 2, -3 \leq t \leq 3&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_strophoide.jpg|300px|center]]

* Zeichnen Sie die verschlungene Hypozykloide &lt;math&gt;x = (R-r)\cos t + c\cos\frac{R-r}{r}t, y = (R-r)\sin t - c\sin\frac{R-r}{r}t, c = 3, r = 2, R = 6, -15 \leq t \leq 15&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_hypozykloide.jpg|300px|center]]

* Testen Sie bei den obigen Übungsaufgaben verschiedene Linienstile und Farben. Farben können mit dem plt.plot()-Parameter color gewählt werden.

* Testen Sie bei den obigen Übungsaufgaben verschiedene Werte für a, c, r und R.

* Zeichnen Sie folgendes Bild (die Achsenbeschriftungen positionieren Sie z.B. mit den Befehlen &lt;code&gt;ax.set_xlabel(&quot;x&quot;, loc=&quot;right&quot;); ax.set_ylabel(&quot;y&quot;, loc=&quot;top&quot;)&lt;/code&gt;):

[[Bild:PythonIng_aufgabe24.svg|400px|center]] 

* Zeichnen Sie mit Python, matplotlib und NumPy folgendes Bild:

[[Bild:PythonIng_figure41.svg|400px|center]]

* Zeichnen Sie mit GridSpec ein Layout, das in etwa wie folgendes aussieht (&lt;code&gt;height_ratios=[1, 2], width_ratios=[2, 1]&lt;/code&gt;):

[[Bild:PythonIng_aufgabe23.svg|300px|center]]

== 3D ==
=== Räumliche Kurven ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0, 6*np.pi, 0.1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 z = t
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot(x, y, z)
 
 plt.show()

[[Datei:PythonIng_raumkurve1.png]]

=== Flächen ===
 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche1.png]]

Das Ganze in Netzdarstellung läßt sich so programmieren: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.5)
 y = np.arange(0, 10, 0.5)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_wireframe(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche2.png]]

Ein etwas komplexeres Beispiel:

 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0.1, 10, 0.1)
 y = np.arange(0.1, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z1 = np.sin(x) + 3 * np.cos(y)
 z2 = np.sin(x) + np.log(y)
 z3 = x + np.cos(y)
 z4 = x**2 - y
  
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;}, nrows=2, ncols=2)
 
 ax[0][0].plot_surface(x, y, z1)
 ax[0][1].plot_surface(x, y, z2)
 ax[1][0].plot_surface(x, y, z3)
 ax[1][1].plot_surface(x, y, z4)
 
 plt.show()

[[Datei:PythonIng_subplot1.png]]

Man beachte, dass man die Unterbilder im Bild nach dem Ausführen des Scripts z.B. mit der mittleren Maustaste einzeln drehen, oder über die Einträge in der Menüzeile einzeln bearbeiten kann. Mit ein paar Zeilen Programmtext lässt sich also eine Menge an Funktionalität generieren.

Die Farbgebung lässt sich über &lt;code&gt;colormaps&lt;/code&gt; variieren.

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm)
 
 plt.show()

[[Datei:PythonIng_colormap1.png]]

Es gibt eine Menge an Colormaps, z.B. &lt;code&gt;plasma, Greys, Dark2, ocean&lt;/code&gt;. Zwecks detaillierterer Infos siehe die matplotlib-Dokumentation. &lt;small&gt;Verwendet man die IDE namens IDLE, so gibt es dort auch die automatische Codevervollständigung. D.h. es werden alle Möglichkeiten (in unserem Fall nach dem Eintippen von &lt;code&gt;cm.&lt;/code&gt; alle verfügbaren Colormaps) angezeigt.&lt;/small&gt;

Die &quot;edgecolor&quot; und Linienbreite können auch frei gewählt werden:

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm, edgecolor=&quot;black&quot;, linewidth=1.0)
 
 plt.show()

[[Datei:PythonIng_colormap2.png]]

=== Höhenlinien ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 ax.contour(x, y, z)
 
 plt.show()

[[Datei:PythonIng_höhenlinien1.png|400px]]

Etwas abgewandelt sieht das so aus: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contour(x, y, z)
 ax.clabel(hl, inline = True)
 
 plt.show()

[[Datei:PythonIng_höhenlinien2.png|400px]]

Und noch eine Variante (mit einem Farbbalken) sei gezeigt. 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contourf(x, y, z)
 fig.colorbar(hl) 
 
 plt.show()

[[Datei:PythonIng_höhenlinien5.svg|400px]]

=== Aufgaben ===
* Zeichnen Sie die räumliche Kurve &lt;math&gt;x = 2 \cdot \cosh(t)&lt;/math&gt;, &lt;math&gt;y = 5 \cdot \sin(t)&lt;/math&gt;, &lt;math&gt; z = t^{2} - t&lt;/math&gt;, &lt;math&gt;0 \leq t \leq 3\pi&lt;/math&gt;.
* Zeichnen Sie die Fläche &lt;math&gt;z = \log(x) + \cos(y)&lt;/math&gt;.

== Animationen und fortgeschrittenes 3D ==
=== Mit matplotlib ===
Auch mit matplotlib sind Animationen möglich. Das ist ein bisschen komplizierter und wird deshalb hier nur mit einem sehr einfachen Beispiel dargestellt (bei Interesse siehe z.B. auch das [https://matplotlib.org/stable/users/explain/animations/animations.html#animations Animations using Matplotlib-Tutorial]).

 import matplotlib.pyplot as plt
 import matplotlib.animation as ani
 import matplotlib
 import numpy as np
 
 def update(frame):
     line.set_xdata(x[:frame])
     line.set_ydata(y[:frame])
     return (line)
 
 fig, ax = plt.subplots()
 
 x = np.arange(0, 10, .1)
 y = np.sin(x)
 
 line, = ax.plot(x[0], y[0])
 ax.set(xlim=[0, 10], ylim=[-1, 1])
 
 a = ani.FuncAnimation(fig=fig, func=update, frames=100, interval=20)
 plt.show()
 
 # Speichere die Animation in einem animierten GIF (optional)
 a.save(filename=&quot;c:/tmp/PythonIng_anim5.gif&quot;, writer=&quot;pillow&quot;)

[[Datei:PythonIng_anim5.gif]]

Es wird eine Sinuskurve auf den Bildschirm gezeichnet. In der letzten Zeile wird diese Animation in ein animiertes GIF gespeichert. Das ist natürlich optional und kann auch weggelassen werden.

=== Mit VPython ===
Aber auch mit dem Modul VPython lassen sich einfache 3D-Animationen erstellen. VPython ist ein externes Modul, das vorab installiert werden muss. Unter openSUSE Tumbleweed gibt es dzt. kein entsprechendes rpm-Paket. Die übliche Methode der Installation mittels YaST oder zypper ist somit nicht möglich. Auch eine direkte Verwendung von pip führt nur zu einer Fehlermeldung (&lt;code&gt;error: externally-managed-environment&lt;/code&gt;). Es empfiehlt sich dort folgende Vorgehensweise:
# Erstelle zuerst eine virtuelle Umgebung, z.B.: &lt;code&gt;python3.11 -m venv ~/tmp/venv1&lt;/code&gt;
# Wechsle das Verzeichnis: &lt;code&gt;cd ~/tmp/venv1/bin&lt;/code&gt;
# Installiere das entsprechende Paket: &lt;code&gt;./pip install vpython&lt;/code&gt;
# Führe das entsprechende Skript aus: &lt;code&gt;./python ~/tmp/test1.py&lt;/code&gt;

Aktuell (März 2026) ist dieses Programmpaket lt. der [https://vpython.org/presentation2018/install.html VPython-Homepage] nur für die Python-Versionen 3.8 bis 3.12 verfügbar.

Ein Beispiel zu einer einfachen Animation wird nachfolgend geliefert.

 from vpython import *
 
 scene.width = 1200
 scene.height = 600
 scene.center = vector(20,0,0)
 scene.background = color.white
 
 cylinder(pos=vector(0,0,0), axis=vector(20,0,0), radius=5, 
         color=color.blue)
 cone(pos=vector(0,0,0), axis=vector(-10,0,0), radius=5, 
         color=color.blue)
 helix(pos=vector(20,0,0), axis=vector(40,0,0), radius=2, 
         coils=10, thickness=0.5, color=color.blue)
 
 ball = sphere(pos=vector(20,0,0), color = color.green, radius = 1)
 ball.p = vector(0.15, 0, 0)
 
 toc = True
 
 while True:
     rate(200)
     if(ball.pos.x &lt;= 60 and toc == True):
         ball.pos += ball.p
     else:
         toc = False
         ball.pos -= ball.p
         if(ball.pos.x &lt;= 20 and toc == False):
             toc = True

[[Datei:PythonIng_vpython_anim.JPG]]

Idealerweise öffnet sich beim Ausführen des Scripts ein Browserfenster. Darin wird die programmierte Animation gezeigt (siehe auch den obigen Screenshot). Eine Größenänderung können Sie mit der mittleren Maustaste initiieren. Die Szenerie drehen können Sie mit der rechten Maustaste.

=== Mit build123d ===
Hiermit lassen sich einfach 3D-Modelle für CAD-Systeme erstellen. [https://build123d.readthedocs.io/en/latest/ build123d] ist ein externes Modul und muss vorab, wie schon für mehrere andere Module gezeigt, installiert werden (pip, venv etc.).

Beispielcode:

 from build123d import *
 
 # Bauteil
 with BuildPart() as bauteil: 
     # Zylinder erstellen
     Cylinder(100, 60)
        
     # Bohrung
     with BuildSketch(bauteil.faces().sort_by(Axis.Z)[-1]) as loch:
         Circle(radius=10)
     # negativ extrudieren
     extrude(amount=-60, mode=Mode.SUBTRACT)
     
     # Dem Bauteil z.B. die Farbe rot zuweisen
     # bauteil.part.color = Color(&quot;red&quot;, alpha=1.0)
 
     # Fertiges Modell exportieren
     export_step(bauteil.part, &quot;bauteil.step&quot;)

Ausgabe ({{W|Standard for the exchange of product model data | STEP}}-Datei, z.B. in {{W|FreeCAD}} importiert, Screenshot):

[[Datei:PythonIng_build123d.jpg | 300px]]

FreeCAD ist ein freies 3D-CAD-System. Die [[Ing_Mathematik:_Python#FreeCAD | Makroprogrammierung]] in diesem System wird später noch gezeigt. STEP steht für &quot;'''St'''andard for the '''e'''xchange of '''p'''roduct model data&quot; und ist ein Datenaustauschformat.

=== Mit VTK ===
Komplexer, aber auch mächtiger als VPython ist die Verwendung von VTK ('''V'''isualization '''T'''ool'''k'''it). Genauer gesagt des Python-Wrappers von VTK. Dieses externe Python-Modul muss vorab installiert werden (z.B. mittels YaST, pip oder in eine virtuelle Umgebung). VTK ist eine Softwarebibliothek zur 3D-Visualisierung und wurde ursprünglich in C++ geschrieben. Verbreitet eingesetzt wird diese Bibliothek in der Wissenschaft und Forschung, z.B. 
* in der medizinischen Bildgebung
* für Strömungssimulationen
* für Klimadaten

VTK funktioniert nach dem {{W|Grafikpipeline|Pipeline-Prinzip}}:

 Source (Quellen) -&gt;  Filter -&gt; Mapper (Senken) -&gt; Actor/Renderer

Daten fließen von den Quellen zu den Senken.

Als einfaches Beispiel wird die Darstellung eines Zylinders gezeigt, der mit den Maustasten gedreht oder in der Größe geändert werden kann:

 import vtk
 
 # Zylinder erzeugen
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 # Geometrie in darstellbare Daten umwandeln
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 # Objekt in der Szene
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 # Szene verwalten
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 # Render-Fenster
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 # Maus/Tastatur-Steuerung
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 # Starten
 render_window.Render()
 interactor.Start()

Ausgabe:

[[Datei:PythonIng_VTK_1.png]]

Gleiches Beispiel wie oben, aber mit einer Animationssequenz:

 import vtk
 import time
 
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     render_window.Render()
     time.sleep(0.01)

Das Grafikfenster schließt sich nach Ablauf der Schleife. Das Fenster bleibt geöffnet, wenn Sie am Programmende folgenden Befehl hinschreiben

 interactor.Start()

Um den animierten Zylinder grün einzufärben, müssen Sie Folgendes im obigen Programm ergänzen (Farbnamen):

 colors = vtk.vtkNamedColors()
 actor.GetProperty().SetColor(colors.GetColor3d(&quot;Green&quot;))

Als Namen können Sie u.a. die CSS3 Web-Farben verwenden (siehe z.B. [https://wiki.selfhtml.org/wiki/Farbe/Farbangaben] und {{W|Webfarbe#CSS_3}}).

Alternativ funktioniert auch das ({{W|RGB-Farbraum|RGB}}):

 actor.GetProperty().SetColor(0.0, 0.6, 0.0)

Wie der Zylinder mit einer Textur versehen wird, zeigt folgendes Programm:

 import vtk
 import time
 
 cylinder = vtk.vtkCylinderSource()
 cylinder.SetResolution(30)
 cylinder.SetHeight(3.0)
 cylinder.SetRadius(1.0)
 cylinder.CappingOn()
 
 texture_coords = vtk.vtkTextureMapToCylinder()
 texture_coords.SetInputConnection(cylinder.GetOutputPort())
 texture_coords.PreventSeamOn()
 
 reader = vtk.vtkJPEGReader()
 reader.SetFileName(&quot;PythonIng_textur.jpg&quot;)
 
 texture = vtk.vtkTexture()
 texture.SetInputConnection(reader.GetOutputPort()) 
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(texture_coords.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 actor.SetTexture(texture)
 
 renderer = vtk.vtkRenderer()
 renderWindow = vtk.vtkRenderWindow()
 renderWindow.AddRenderer(renderer)
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(renderWindow)
 
 renderer.AddActor(actor)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     renderWindow.Render()
     time.sleep(0.01)
 
 interactor.Start()

&lt;gallery&gt;
PythonIng_textur.jpg | Textur-Datei
PythonIng_VTK_2.png | Ausgabe (Screenshot)
&lt;/gallery&gt;

== Sonstige Grafikbibliotheken ==
=== Py5 ===
Im Buch ''Iacono et al.: Programmieren trainieren, mit über 150 Workouts in Java und Python; 3. Aufl., Hanser, 2023'' werden zahlreiche Aufgaben gestellt, die u.a. mit Processing zu lösen sind.  Processing ist eine einfache Programmiersprache und Entwicklungsumgebung. Warum ich das erwähne? Weil in älteren Processing-Versionen auch die Programmiersprache Python 2 abgedeckt war. Bei neueren Versionen gibt es keine Python-Anbindung mehr (getestet nur mit openSUSE Tumbleweed und Python 3). Somit funktioniert der Python-Teil im genannten Buch zum Teil nicht mehr. Ist das tragisch, oder kann das Buch weggeschmissen werden? Nein! Es gibt Alternativen zu Processing. Zum einen die im Buch selbst genannten Bibliotheken tkinter oder pygame. Pygame wird dort auch kurz anhand eines Beispiels thematisiert. Aber noch besser ist es, die py5-Bibliothek zu verwenden (lt. Google KI vom 30. Sept. 2026: ''Der echte, moderne „spirituelle Nachfolger“''). Damit ist die Funktionalität von Processing gewährleistet. Man kann aber beliebige Editoren oder IDEs zur Programmerstellung verwenden, ohne an Processing als IDE gebunden zu sein. Nachfolgend werden ein paar Beispiele zu dieser externen Bibliothek gegeben. Der erste Schritt ist wieder, die py5-Bibliothek zu installieren (z.B. mittels pip in eine virtuelle Umgebung; Python&gt;=3.10 und ein JDK&gt;=17 müssen auch installiert sein (Stand Okt. 2026)). Dann kann es schon mit dem Programmieren losgehen.

Beispiel (angelehnt an die ''Aufgabe W.2.3 Haus'' des genannten Buchs, jedoch etwas erweitert):

 import py5
 
 def setup():
     py5.size(600, 600)            # Fenstergröße 600px x 600px 
     py5.background(255, 255, 255) # Hintergrundfarbe ... weiss
     
 def draw():
     # Haus zeichnen
     py5.fill(255, 255, 255)       # Hintergrundfarbe ... weiss
     py5.stroke(255, 0, 0)         # Linienfarbe ... rot 
     py5.stroke_weight(3)          # Linienbreite ... 3px
     py5.rect(150, 200, 300, 300)  # Rechteck zeichnen (x, y, b, h)
     py5.triangle(150, 200, 300, 100, 450, 200) # Dreieck zeichnen
     py5.circle(250, 300, 70)      # Kreis zeichnen (x, y, d)   
     
     # Bemassung zeichnen
     py5.stroke(0, 255, 0)
     py5.stroke_weight(1)
     py5.line(300, 100, 550, 100)  # Linie zeichnen
     py5.line(450, 200, 550, 200) 
     py5.line(450, 500, 550, 500) 
     py5.line(150, 500, 150, 550)
     py5.line(450, 500, 450, 550)
     py5.text_size(20)             # Textgroesse
     py5.fill(0, 255, 0)           # Textfarbe
     py5.text(&quot;300&quot;, 280, 550)     # Text zeichnen
     py5.text(&quot;100&quot;, 500, 150)
     py5.text(&quot;300&quot;, 500, 350)  
 
     # Gedrehtes Rechteck zeichnen
     py5.stroke(255, 255, 0)
     py5.stroke_weight(3)
     py5.fill(200, 200, 200) 
     py5.translate(320, 260)  
     py5.rotate(0.3)               # Drehung (in Radiant)
     py5.rect(0, 0, 100, 50)
 
 # Startet den Sketch
 py5.run_sketch()


Ausgabe:

[[Datei:PythonIng_py5_1.png|300px]]

Das skizzierte Haus ist mit einer rudimentären Bemaßung versehen und hat zwei Fenster, ein rundes und ein gedrehtes, trübes rechteckiges. 

Beispiel (Mausoperationen):

 import py5
 
 def setup():
     py5.size(600, 600)            
     py5.background(255, 255, 255)
 
 def draw():
     pass
    
 def mouse_pressed():
     py5.text_size(15) 
     py5.fill(0, 0, 255)
     x = py5.mouse_x
     y = py5.mouse_y
     py5.text(&quot;(%d, %d)&quot; %(x, y), x, y) # Positionsdaten bei Maus-Klick schreiben
 
 py5.run_sketch()

Ausgabe:

[[Datei:PythonIng_py5_2.png|300px]]

Obiges Bild zeigt das Resultat nach einigen Mausklicks. Man erkennt, dass links-oben der Koordinatennullpunkt ist. Die x-Achse zeigt nach rechts, die y-Achse nach unten.

Beispiel (Fünfeck):

 import py5
 import random 
 
 def setup():
     py5.size(400, 400)
     py5.no_loop()       # statisches Bild (schont die Ressourcen)
 
 def draw():
     py5.translate(py5.width / 2, py5.height / 2)  # KS setzen
 
     radius = 150
     eck_anzahl = 5
 
     py5.fill(random.randint(0, 255), random.randint(0, 255), 
              random.randint(0, 255))    # Füllfarbe auf Zufallswert setzen
     py5.stroke(155, 0, 0)            
     py5.stroke_weight(5)     
     
     # Fünfeck als Polygon zeichnen
     py5.begin_shape()
     for i in range(eck_anzahl):
         winkel = i * py5.TWO_PI / eck_anzahl - py5.HALF_PI
         x = py5.cos(winkel) * radius
         y = py5.sin(winkel) * radius
         py5.vertex(x, y)
     py5.end_shape(py5.CLOSE)
 
 py5.run_sketch()

Ausgabe, bspw.:

[[Datei:PythonIng_py5_5.png|200px]]

&lt;u&gt;Kleine Aufgaben:&lt;/u&gt;
* Um die Funktionsweise von &lt;code&gt;py5.no_loop()&lt;/code&gt; zu verstehen, kommentieren Sie die Anweisung im Beispiel einfach aus, und starten Sie das Programm erneut.
* Zeichnen Sie ein Siebeneck.
* Was passiert, wenn man &lt;code&gt;py5.CLOSE&lt;/code&gt; im &lt;code&gt;py5.end_shape()&lt;/code&gt;-Befehl weglässt?

Beispiel (Grafik laden und zeichnen):

 import py5
 
 image1 = None
 
 def setup():
     global image1
     py5.size(600, 600)
     py5.no_loop()
     image1 = py5.load_image(&quot;PythonIng_py5_1.png&quot;)
 
 def draw():
     py5.image(image1, 0, 0)
 
 py5.run_sketch()

Hier wird einfach das Bild vom Haus-Beispiel (Screenshot von weiter oben) geladen und gezeichnet.

Beispiel (angelehnt an ''W.5.10 Wurfparabel'' des genannten Buches; mit OOP erstellt):

 import py5
 
 class Wurfparabel(py5.Sketch):
     def __init__(self, v0, angle):
         super().__init__()
         self.v0 = v0
         self.angle = self.radians(angle)
         self.g = 9.81
         self.t = 0.0
         self.scale = 1.5
 
     def settings(self):
         self.size(800, 600)
 
     def setup(self):        
         self.background(0, 0, 0)
         
     def draw(self):
         self.t += 0.1
 
         self.translate(50, 500)
       
         # KS Zeichnen
         self.fill(255, 255, 0)
         self.stroke(255, 255, 0)
         self.stroke_weight(1)
         self.line(0, 0, 0, -300)
         self.line(0, 0, 700, 0)
 
         # Punkt zeichnen
         cx = self.v0 * self.cos(self.angle) * self.t * self.scale
         cy = -(self.v0 * self.sin(self.angle) * self.t - \
                self.g/2 * self.t**2) * self.scale
         self.fill(255, 0, 0)
         self.stroke(255, 0, 0)
         self.circle(cx, cy, 3)
        
         # Stoppen bei Bodenkontakt
         if cy &gt;= -5:
             self.no_loop()
            
 def wurfparabel(v0=50, angle=45):
     sketch = Wurfparabel(v0, angle)
     sketch.run_sketch()
 
 v0 = float(input(&quot;v0 = &quot;))
 winkel = float(input(&quot;winkel = &quot;))
 wurfparabel(v0=v0, angle=winkel)

Eingabe auf der Konsole:

 v0 = 60
 winkel = 45

Ausgabe:

[[Datei:PythonIng_py5_13.png|200px]]

Die benötigten Formeln der Bewegungsgleichung kann man leicht herleiten, bzw. man benutzt folgende Grafik als Hilfestellung:

[[Datei:Wurfparabel_Zusammenfassung_aktualisierung.png|700px]]

&lt;u&gt;Aufgabe:&lt;/u&gt; Berechnen Sie den Scheitelpunkt und die Wurfweite bei gegebener Anfangsgeschwindigkeit und gegebenem Abwurfwinkel. Die Abwurfhöhe &lt;math&gt;y_0&lt;/math&gt; sei 0. Der Wurf soll auf der Erde stattfinden (g = 9.81 m/s²). Die dazu benötigten Formeln können aus obiger Grafik entnommen werden (oder Sie leiten sie selbst her). Geben Sie die Ergebnisse auf der Konsole aus.

Beispiel (eine einfache Animation):

 import py5
 
 i = 0
 
 def setup():
     py5.size(600, 600)
     py5.frame_rate(5)
     py5.stroke_weight(20)
 
 def draw():
     global i
     
     py5.background(255, 255, 255)
     py5.translate(py5.width/2, py5.height/2)
     py5.rotate(py5.PI/8 * i)    
 
     py5.line(-100, 0, 100, 0)
     i += 1
 
 py5.run_sketch()

Es wird eine rotierende Linie gezeichnet (z.B. wie bei einem Installationsprozess verwendet - zeigt an, dass der Installationsfortschritt nicht eingefroren ist). Hierbei ist nur aufzupassen, dass der Hintergrund in &lt;code&gt;draw()&lt;/code&gt; gesetzt wird, ansonsten würden die Linien additiv gezeichnet. Das ist zwar auch schön, aber eben nicht das gewünschte Resultat.

=== Bokeh ===
Mit Bokeh kann man interaktive Datenvisualisierungen für Webbrowser in Python erstellen. Bokeh ist eine externe Bibliokek, die vorab installiert werden muss (z.B. mittel YaST oder pip).

Python-Code:

 from bokeh.plotting import figure, output_file, show
 
 x = [1, 2, 3, 4, 5, 6]
 y = [10, 5, 6, 8, 9, 11]
 
 output_file(&quot;interpolation.html&quot;) 
 
 p = figure(
     title=&quot;Interpolation&quot;,
     x_axis_label=&quot;x&quot;,
     y_axis_label=&quot;y&quot;,
 )
 
 p.line(x, y, legend_label=&quot;Interpolierende&quot;, line_width=2, color=&quot;blue&quot;)
 p.scatter(x, y, legend_label=&quot;Stützpunkte&quot;, size=7, color=&quot;orange&quot;)
 p.legend.location = &quot;top_left&quot;
 
 show(p)

Ausgabe:

[[File:PythonIng_bokeh1.png|300px]]

Python-Code (angelehnt an ein Beispiel aus der Bokeh-Dokumentation, aber wesentlich gekürzt
und vereinfacht):

 from bokeh.layouts import layout
 from bokeh.models import Spinner
 from bokeh.plotting import figure, show
 
 x = [1, 2, 3, 4, 5]
 y = [2, 7, 3, 6, 4] 
 
 p = figure(x_range=(1, 5), width=500, height=350)
 points = p.scatter(x=x, y=y, size=30, fill_color=&quot;blue&quot;)
 
 spinner = Spinner(
     title=&quot;Kreisgröße&quot;,
     low=0,
     high=60,
     step=5,
     value=points.glyph.size,
     width=200,
 )
 spinner.js_link(&quot;value&quot;, points.glyph, &quot;size&quot;)
 
 layout = layout(
     [
         [spinner],
         [p],
     ],
 )
 
 show(layout)

Ausgabe:

[[File:PythonIng_bokeh2.png|300px]]

Die Dokumentation zu Bokeh findet sich auf [https://docs.bokeh.org/en/latest/]

= Vektoren und Matrizen =
== Zahlenfolgen ==
Für das Erstellen von Zahlenfolgen bieten sich die Funktionen &lt;code&gt;arange&lt;/code&gt; und &lt;code&gt;linspace&lt;/code&gt; aus dem &lt;code&gt;numpy&lt;/code&gt;-Modul an.

 from numpy import *
 
 start = 0
 stop = 10
 step = 2
 num = 10
 
 r = arange(start, stop, step)   # step ... Schrittweite
 l = linspace(start, stop, num)  # num ... Anzahl der Werte
 
 print(&quot;r = &quot;, r)
 print(&quot;l = &quot;, l)

Ausgabe:
 r =  [0 2 4 6 8]
 l =  [ 0.          1.11111111  2.22222222  3.33333333  4.44444444  5.55555556
   6.66666667  7.77777778  8.88888889 10.        ]

Bei &lt;code&gt;arange&lt;/code&gt; ist der &lt;code&gt;stop&lt;/code&gt;-Wert nicht im Ergebnis enthalten, bei &lt;code&gt;linspace&lt;/code&gt; standardmäßig aber sehr wohl. Jedoch kann man das bei &lt;code&gt;linspace&lt;/code&gt; auch ändern. Dann ist der Stoppwert nicht mehr enthalten: 

 linspace(start, stop, num, endpoint=False)

== Vektoren ==
Vektoren sollten jedem aus der Linearen Algebra bekannt sein. 

=== Arrays ===
In Python mit NumPy kann man Vektoren durch die Funktion array erzeugen.

 import numpy as np
 
 l1 = (-5, 3, 2)
 l2 = (1, 1, 4)
 
 a1 = np.array(l1)
 a2 = np.array(l2)
 
 a3 = a1 + a2
 a4 = 2 * a2
 
 print(a1)
 print(a2)
 print(a3)
 print(a3[2])
 print(a4)

Ausgabe:
 [-5  3  2]
 [1 1 4]
 [-4  4  6]
 6
 [2 2 8]

=== Zeilen- und Spaltenvektoren ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 print(z)
 print(s)

Ausgabe:
 [ [-5  3  2] ]
 [[1]
  [1]
  [4]]

=== Skalarprodukt ===
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4))
 
 skalarprodukt = np.dot(a1, a2)  
 
 print(skalarprodukt)

Ausgabe:
 6

=== Vektorprodukt ===
&lt;math&gt;a\ast b=\left(\begin{array}{c}
a_{1}\\
a_{2}\\
a_{3}
\end{array}\right)\ast\left(\begin{array}{c}
b_{1}\\
b_{2}\\
b_{3}
\end{array}\right)=\left(\begin{array}{c}
a_{2}b_{3}-a_{3}b_{2}\\
a_{3}b_{1}-a_{1}b_{3}\\
a_{1}b_{2}-a_{2}b_{1}
\end{array}\right)
&lt;/math&gt; 

Python-Code:
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4)) 
 
 vektorprodukt = np.cross(a1, a2) 
 
 print(vektorprodukt)

Ausgabe:
 [10 22 -8]

=== Transponierter Vektor ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 # transponierter Vektor
 z_tp = np.transpose(z)
 # transponierter Vektor
 s_tp = np.transpose(s)
 
 print(z_tp)
 print(s_tp)

Ausgabe:
 [[-5]
  [ 3]
  [ 2]]
 [ [1 1 4] ]

=== Vektorfelder visualisieren ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 # Daten generieren
 x = np.arange(0, 10, 1)
 y = np.arange(0, 10, 1)
 X, Y = np.meshgrid(x, y)
 U = X * Y
 V = Y + X
 
 # Plotten
 fig, ax = plt.subplots()
 
 ax.quiver(X, Y, U, V, angles='xy')
 
 plt.show()

Ausgabe:

[[Datei:PythonIng_quiver1.png]]

== Matrizen==
 import numpy as np
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 print(m1)

Ausgabe:
 [[1 2 3]
  [4 5 6]]

=== Zugriff auf Matrizenelemente ===
Beispiel:

 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 
 # Element aus Zeile 2 und Spalte 3 (Achtung! Index startet bei Null)
 print(m1[1,2])

Ausgabe:
 6

Visualisierung:
  
     0   1   2
   +-----------+
 0 | 1 | 2 | 3 |
   +-----------+
 1 | 4 | 5 | '''6''' |
   +-----------+


Beispiel:

 import numpy as np
 
 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
 
 B = np.matrix(A)     
 
 print(B[2::, ::2])

Ausgabe:

 [['20' '22']
  ['30' '32']
  ['40' '42']]

Mit der NumPy-Bibliothek funktioniert das zweidimensionale Slicing. Mit normalen Listen/Tupels geht das nicht, was wir schon früher thematisiert haben.

=== Addition und Subtraktion von Matrizen ===
 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 m2 = np.matrix([[0, 0, 2], [1, 3, 2]])
 
 print(m1 + m2)
 print(m1 - m2)

Ausgabe:
 [[1 2 5]
  [5 8 8]]
 [[1 2 1]
  [3 2 4]]

=== Transponierte Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 2, 3], [4, 5, 6]])
 mt = np.transpose(m) 
 
 print(m)
 print(mt)

Ausgabe:
 [[1 2 3]
  [4 5 6]]
 [[1 4]
  [2 5]
  [3 6]]

=== Rang einer Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 rg = np.linalg.matrix_rank(m)
 
 print(rg)

Ausgabe:
 2

=== Inverse Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 mi = np.linalg.inv(m)
 
 print(mi)

Ausgabe:
 [[ 1.   0.6]
  [-0.  -0.2]]

=== Multiplikation von Matrizen (falksches Schema) ===
 import numpy as np
 
 m1 = np.matrix([[1, 3, 4],  [0, -5, 1]])
 m2 = np.matrix([[1, 2], [2, 3], [0, 2]])
 
 print(m1 @ m2)

Ausgabe:
 [[  7  19]
  [-10 -13]]

=== Eigenwerte und Eigenvektoren ===
 import numpy as np
 
 m = np.matrix([[5, 8],  [1, 3]])
 D,V = np.linalg.eig(m)
 
 # Eigenwerte
 print(D)
 # Eigenvektoren
 print(V)

Ausgabe:
 [7. 1.]
 [[ 0.9701425  -0.89442719]
  [ 0.24253563  0.4472136 ]]

=== Teilmatrizen ===
 import numpy as np
 m = np.matrix([[1, 3, 4],  [0, -5, 1]])
 print(&quot;m = &quot;, m)
 
 # Erste Zeile extrahieren
 m1 = m[0,:]
 print(&quot;m1 = &quot;, m1)
 
 # Das Element aus der 1. Zeile und der 2. Spalte extrahieren
 m2 = m[0,1]
 print(&quot;m2 = &quot;, m2)
 
 # Zweite Spalte extrahieren
 m3 = m[:, 1]
 print(&quot;m3 = &quot;, m3)

Ausgabe:
 m =  [[ 1  3  4]
  [ 0 -5  1]]
 m1 =  [ [1 3 4] ]
 m2 =  3
 m3 =  [[ 3]
  [-5]]

=== Spezielle Matrizen ===
==== Nullmatrix ====
 import numpy as np
 z = np.zeros((3, 2))
 print(z)

Ausgabe:
 [[0. 0.]
  [0. 0.]
  [0. 0.]]

==== Einheitsmatrix ====
 import numpy as np
 z = np.eye(3)
 print(z)

Ausgabe:
 [[1. 0. 0.]
  [0. 1. 0.]
  [0. 0. 1.]]

==== Matrix mit lauter Einsen ====
 import numpy as np
 z = np.ones((3, 2))
 print(z)

Ausgabe:
 [[1. 1.]
  [1. 1.]
  [1. 1.]]

=== Spärlich besetzte Matrizen ===
Das Thema spärlich besetzter Matrizen wird hier nur kurz angerissen. Nähere Details siehe unter dem Weblink  [https://docs.scipy.org/doc/scipy/reference/sparse.html#module-scipy.sparse]. 

Beispiel:

 import numpy as np
 import scipy
 
 A = scipy.sparse.csr_array(np.eye(5))
 
 print(A)

Ausgabe:
 &lt;Compressed Sparse Row sparse array of dtype 'float64'
         with 5 stored elements and shape (5, 5)&gt;
   Coords        Values
   (0, 0)        1.0
   (1, 1)        1.0
   (2, 2)        1.0
   (3, 3)        1.0
   (4, 4)        1.0

csr steht für '''c'''ompressed '''s'''parse '''r'''ow.

Andere Möglichkeiten:
* coo-Format ('''coo'''rdinate Format): &lt;code&gt;scipy.sparse.coo_array()&lt;/code&gt;
* lil-Format ('''li'''st of '''l'''ists): &lt;code&gt;scipy.sparse.lil_array()&lt;/code&gt;
* csc-Format ('''c'''ompressed '''s'''parse '''c'''olumn): &lt;code&gt;scipy.sparse.csc_array()&lt;/code&gt;

Es gibt auch &lt;code&gt;scipy.sparse.csr_matrix()&lt;/code&gt; etc. Diese Befehle sind aber veraltet und es wird empfohlen, statt dessen die &lt;code&gt;..._array()&lt;/code&gt;-Funktionen zu verwenden.

&lt;u&gt;Aufgaben:&lt;/u&gt; 
Recherchieren Sie im Internet 
* generell zum Thema &quot;spärlich besetzte Matrizen mit Python&quot;.
* Was sind die Vor-/Nachteile von csr-arrays gegenüber coo- und lil-arrays?
* Wann verwendet man sinnvollerweise csr- und wann csc-arrays?
* Wie wandelt man coo-arrays in csr-arrays um?

= Lineare Gleichungssysteme =
Sei &lt;math&gt;Ax = b&lt;/math&gt; ein lineares Gleichungssystem. &lt;math&gt;A&lt;/math&gt; sei die Koeffizientenmatrix, &lt;math&gt;x&lt;/math&gt; der Lösungsvektor und &lt;math&gt;b&lt;/math&gt; ein bekannter Vektor.

Beispiel:
 import numpy as np
 
 A = np.array([[5, 1], [0, 2]])
 b = np.array([1, 2])
 
 x = np.linalg.solve(A, b)
 
 print(x)

Ausgabe:
 [0. 1.]

Siehe dazu auch das Kapitel [[Ing Mathematik: Numerisches Lösen von linearen Gleichungssystemen]]. Dort wird dieses Themengebiet u.a. mit weitergehenden Python-Skripten vertieft.

== Aufgabe ==
* Lösen Sie folgendes Gleichungssystem mittels Python (und zur Kontrolle auch händisch): 
 5x + 6y - 2z = 12
 3x - y  - 3z = 6
 2x + 2y + 4z = 5

= Polynome =
== Ein erstes einfaches Beispiel ==
Gegeben sei das Polynom &lt;math&gt;7x^3+5x^2+1&lt;/math&gt;. In Python:

 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p)

Ausgabe:
    3     2
 7 x + 5 x + 1

== Einzelne Polynomwerte berechnen ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p(1.5))

Ausgabe:
 35.875

== Polynome integrieren und differenzieren ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 
 # 1. Ableitung
 p1 = p.deriv()
 p2 = p.deriv(1)
 
 # 2. Ableitung
 p3 = p.deriv(2)
 
 # Integral
 p4 = p.integ()
 
 print(p1)
 print(p2)
 print(p3)
 print(p4)

Ausgabe:
     2
 21 x + 10 x
     2
 21 x + 10 x
 
 42 x + 10
       4         3
 1.75 x + 1.667 x + 1 x

== Nullstellen bestimmen ==
 import numpy as np
 
 p = np.poly1d([2, 5, 0, 4])
 r = np.roots(p)
 
 print(r)

Ausgabe:
 [-2.7621427 +0.j          0.13107135+0.84077099j  0.13107135-0.84077099j]

== Aufgaben ==
* Berechnen Sie den Wert für x = 3 des Polynoms &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Differenzieren und integrieren Sie das Polynom &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Berechnen Sie die Nullstellen von &lt;math&gt;y = 7x^5 - 3x^2 + 12&lt;/math&gt;.

= Nichtlineare Gleichungen und Gleichungssysteme =
== Nullstellenbestimmung ==
Löse eine beliebige Gleichung f(x) = 0, z.B. &lt;math&gt; f(x) = x^2 - 5\cos(x) - 10 = 0 &lt;/math&gt;:
 import scipy
 import numpy as np
 
 def f(x):
     return x**2 - 5*np.cos(x) - 10
    
 xstart = [-1, 1]        # Startwerte
 xn = scipy.optimize.root(f, xstart)
 
 print(xn.x)

Ausgabe:
 [-2.46813009  2.46813009]

Funktionsgraph:

[[Datei:octave_nichtlin2.jpg]]

== Gleichungssysteme ==
SymPy ist ein externes Modul, das symbolisches Rechnen ('''Sym'''bolic '''Py'''thon) ermöglicht. 

Folgende Aufgabe ist dem Buch &quot;Knorrenschild: Numerische Mathematik, Hanser, 2017, Seite 72&quot; entnommen. Zu lösen ist das nichtlineare Gleichungssystem

&lt;math&gt;f_1 = 2x_1 + 4x_2 = 0 &lt;/math&gt;

&lt;math&gt;f_2 = 4x_1 + 8x_2^3 = 0&lt;/math&gt;

Mit Python ist das so möglich:
 import sympy
 
 x1, x2 = sympy.symbols(&quot;x1 x2&quot;) 
 
 f1 = 2*x1 + 4*x2
 f2 = 4*x1 + 8*x2**3
 
 s = sympy.solve((f1, f2), x1, x2) 
 
 print(s)

Ausgabe:
 [(-2, 1), (0, 0), (2, -1)]

Plot:

[[Datei:IngPython_nl_gleichung1.svg|500px]]

= Komplexe Zahlen =
Die imaginäre Einheit wird in Python durch den Buchstaben &lt;code&gt;j&lt;/code&gt; symbolisiert. Darstellen kann man eine komplexe Zahl bekannterweise in mehreren Formen:
* Kartesische Darstellung &lt;math&gt;z = \Re(z) + j \cdot \Im(z)&lt;/math&gt;
* Polardarstellungen &lt;math&gt;z = r \cdot (\cos(\phi) + j \cdot \sin(\phi)) = r \cdot e^{j\cdot \phi}&lt;/math&gt;

Die konjugiert komplexe Zahl ist &lt;math&gt;z^* = \Re(z) - j \cdot \Im(z)&lt;/math&gt;

Nachfolgend einige mathematische Operationen mit Python und NumPy.

 import numpy as np
 
 z1 = 2 + 5j           # kartesische Darstellung
 z2 = 3 * np.exp(3j)   # Polardarstellung
  
 # Addition
 res = z1 + z2
 print(&quot;z1 + z2 = &quot;, res)
 
 # Multiplikation
 res = z1 * z2
 print(&quot;z1 * z2 = &quot;, res)
 
 # Realteil
 res = np.real(z2)
 print(&quot;Realteil von z2 = &quot;, res)
 
 # Imaginärteil
 res = np.imag(z2)
 print(&quot;Imaginaerteil von z2 = &quot;, res)
 
 # Betrag
 res = np.abs(z1)
 print(&quot;Betrag von z1 = &quot;, res)
 
 # Argument
 res = np.angle(z1)
 print(&quot;Argument von z1 = &quot;, res)
 
 # Konjugiert komplexe Zahl
 res = np.conj(z1)
 print(&quot;Konjugiert komplexe Zahl von z1 = &quot;, res)

Ausgabe:
 z1 + z2 =  (-0.9699774898013365+5.423360024179601j)
 z1 * z2 =  (-8.05675510050068-14.003167400647481j)
 Realteil von z2 =  -2.9699774898013365
 Imaginaerteil von z2 =  0.4233600241796016
 Betrag von z1 =  5.385164807134504
 Argument von z1 =  1.1902899496825317
 Konjugiert komplexe Zahl von z1 =  (2-5j)

= Interpolation =
 import numpy as np
 import scipy
 import matplotlib.pyplot as plt
 
 # Stützpunkte
 xp = np.arange(1, 6)
 yp = (0, -5, 2, 7, 6)
 
 ti = np.arange(1, 5, 0.01)
 
 i1 = scipy.interpolate.interp1d(xp, yp, kind = &quot;linear&quot;)
 i2 = scipy.interpolate.interp1d(xp, yp, kind = &quot;cubic&quot;) 
 
 plt.plot(xp, yp, &quot;rx&quot;)
 plt.plot(xp, i1(xp))
 plt.plot(ti, i2(ti))
 plt.show()

Ausgabe:

[[Datei:PythonIng_interpol1.png]]

&lt;code&gt;scipy.interpolate.interp1d()&lt;/code&gt; gilt als veraltet ([https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.interp1d.html]). Stattdessen soll man modernere Alternativen wie &lt;code&gt;scipy.interpolate.Akima1DInterpolator()&lt;/code&gt; oder &lt;code&gt;scipy.interpolate.CubicSpline()&lt;/code&gt; benutzen. Für die lineare Interpolation tut es &lt;code&gt;np.interp()&lt;/code&gt;.

&lt;u&gt;Aufgaben:&lt;/u&gt;
* Recherchieren Sie im Internet zu den oben genannten modernen Alternativen.
* Schreiben Sie obiges Programm auf die genannten moderneren Alternativen um.

= Differenzialrechnung =
== Numerisches Differenzieren ==
Als Beispiel differenzieren wir &lt;math&gt;y = 5x\sin{x}&lt;/math&gt; und stellen das Ganze grafisch dar.

 from findiff import Diff
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.linspace(0, 10, 1000)
 f = 5 * x * np.sin(x)
 dx = x[1] - x[0]
 
 # Ableitung
 d_dx = Diff(0, dx)
 df_dx = d_dx(f)
 
 # Grafik
 plt.plot(x, f, label = &quot;y&quot;)
 plt.plot(x, df_dx, label = &quot;y'&quot;)
 plt.grid()
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

Ausgabe:

[[Datei:octave_diff1.jpg]]

&lt;small&gt;findiff ist ein externes Modul. Dieses muss installiert werden (z.B. so: ...\Python\Scripts\pip.exe install --upgrade findiff). Für die Vorgehensweise unter openSUSE Tumbleweed siehe das Kapitel [[Ing_Mathematik:_Python#Mit_VPython | VPython]], nur dass das Ganze mit einer aktuelleren Python-Version exekutiert wird, z.B. mit Python 3.13.  Das im Buch &quot;Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler, Rheinwerk&quot; verwendete Modul &quot;scipy.misc&quot; ist veraltet (deprecated ... missbilligt). Lt. [https://docs.scipy.org/doc/scipy-1.17.0/dev/roadmap-detailed.html#misc SciPy-Dokumentation für die Version 1.17.0] wurden alle entsprechenden Features schon entfernt.&lt;/small&gt;

== Symbolisches Differenzieren ==
Differenzieren Sie die Funktionen &lt;math&gt;f_1(x) = x^2&lt;/math&gt; und &lt;math&gt;f_2(x) = \sin(x)\cos\left(\frac{x}{2}\right)&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2;
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 d1 = sympy.diff(f1, x)
 d2 = sympy.diff(f2, x)
 
 print(d1)
 print(d2)

Ausgabe:
 2*x
 -0.5*sin(0.5*x)*sin(x) + cos(0.5*x)*cos(x)

== Aufgaben ==
* Differenzieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.
* Differenzieren Sie die Funktion &lt;math&gt;y = \frac{\sinh(x)}{(1+x)}&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.

= Integralrechnung =
== Numerisches Integrieren ==
Berechnen Sie das Integral &lt;math&gt;\int_{0}^{3}x^2 dx&lt;/math&gt;.

 import scipy
 
 def f(x):
     return x**2
    
 i = scipy.integrate.quad(f, 0, 3)
 print(i)

Ausgabe:
 (9.000000000000002, 9.992007221626411e-14)

Das trifft den exakten Wert 9.0 ziemlich genau.

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} dx&lt;/math&gt;.

 import scipy
 import numpy as np
 
 def f(x):
     return 2**(-x)
   
 i = scipy.integrate.quad(f, 0, np.inf)
 print(i)

Ausgabe:
 (1.4426950408889556, 4.486558477977586e-09)

== Symbolisches Integrieren ==
Berechnen Sie &lt;math&gt;\int x^2 \text{d}x&lt;/math&gt; und &lt;math&gt;\int \sin{x}\cos{\frac{x}{2}} \text{d}x&lt;/math&gt;.
 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 i1 = sympy.integrate(f1, x)
 i2 = sympy.integrate(f2, x)
 
 print(i1)
 print(i2)

Ausgabe:
 x**3/3
 -0.666666666666667*sin(0.5*x)*sin(x) - 1.33333333333333*cos(0.5*x)*cos(x)

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} \text{d}x&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f = 2**(-x)
 i = sympy.integrate(f, (x, 0, sympy.oo))
 print(i)

Ausgabe:
 1/log(2)

&lt;code&gt;sympy.oo&lt;/code&gt; steht für das {{W|Unendlichzeichen}} &lt;math&gt;\infty&lt;/math&gt; (die liegende Acht oder das Möbiusband). Mit &lt;code&gt;sympy.pprint(i)&lt;/code&gt; ließe sich letzere Ausgabe etwas schöner schreiben:

   1   
 ──────
 log(2)

Man beachtete, &lt;code&gt;log&lt;/code&gt; steht hier für den natürlichen Logarithmus &lt;code&gt;ln&lt;/code&gt;.

== Aufgaben ==
* Integrieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; von 1 bis 5.
* Integrieren Sie die Funktion &lt;math&gt;y = x^3&lt;/math&gt; von 0 bis 4.
* Integrieren Sie &lt;math&gt;\int x^x(\log (x) + 1)\mathrm dx&lt;/math&gt; symbolisch.

= Gewöhnliche Differenzialgleichungen =
== DGL numerisch lösen ==
Für die Lösung von Differenzialgleichungen steht u.a. die Funktion scipy.integrate.solve_ivp() zur Verfügung. Diese Funktion implementiert auch das Runge-Kutta-Verfahren (RK45).

{{Wikipedia | Runge-Kutta-Verfahren}}

Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import scipy
 import numpy as np
 import matplotlib.pyplot as plt
 
 def dy_dx(x, y):
     return x**2 + y**3
 
 y0 = [1]
 xi = [0, 1]
 x = np.arange(0, 1, 0.01)
 
 z = scipy.integrate.solve_ivp(dy_dx, xi, y0, method=&quot;RK45&quot;, dense_output=True)
 y = z.sol(x)
 
 plt.plot(x, y.T)
 plt.grid()
 plt.show()

[[Datei:PythonIng_dgl1.png]]

== DGL symbolisch lösen ==
Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 print(lsg)

Ausgabe:
 [Eq(f(x), (-x**2)**(1/3)), Eq(f(x), (-x**2)**(1/3)*(-1 - sqrt(3)*I)/2), Eq(f(x), (-x**2)**(1/3)*(-1 + sqrt(3)*I)/2)]

Mit &lt;code&gt;sympy.pprint&lt;/code&gt; (pretty print) lässt sich die Ausgabe etwas übersichtlicher darstellen.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 sympy.pprint(lsg)

Ausgabe:
 ⎡                           _____                        _____            ⎤
 ⎢          _____         3 ╱   2                      3 ╱   2             ⎥
 ⎢       3 ╱   2          ╲╱  -x  ⋅(-1 - √3⋅ⅈ)         ╲╱  -x  ⋅(-1 + √3⋅ⅈ)⎥
 ⎢f(x) = ╲╱  -x  , f(x) = ────────────────────, f(x) = ────────────────────⎥
 ⎣                                 2                            2          ⎦

== Aufgaben ==
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \frac{1}{x\cdot y}&lt;/math&gt; mit Python. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;m' = -k\cdot m&lt;/math&gt;. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \sqrt{|y|}&lt;/math&gt;.

=Laplace-Transformation=
Laplace-Transformation:

&lt;math&gt;F(s) =\mathcal{L} \left\{f\right\}(s) = \int_{0}^{\infty} f(t) \mathrm e^{-st} \,\mathrm{d}t, \qquad s\in\mathbb{C}
&lt;/math&gt;

Inverse Laplace-Transformation:

&lt;math&gt;\mathcal{L}^{-1} \left\{F\right\}(t)
  = \frac{1}{2 \pi \mathrm j} \int_{ \gamma - \mathrm j \infty}^{ \gamma + \mathrm j \infty} \mathrm e^{st} F(s)\,\mathrm ds 
= \begin{cases}
      f(t) &amp; \text{für } t \geq 0 \\
      0    &amp; \text{für } t &lt; 0
    \end{cases}
&lt;/math&gt;

Siehe auch [[Ing_Mathematik:_Laplace-Transformation]]

Code:
 import sympy
 from sympy.abc import t, s
 
 # Laplace-Transformation der Funktion f(t) = 1 (Heaviside-Fkt.)
 f = 1
 # alternativ: f = sympy.Heaviside(t)
 F = sympy.laplace_transform(f, t, s, noconds=True)
 print(&quot;Laplace-Transformierte F(s):&quot;, F) 
 
 # Inverse Laplace-Transformation zurück in den Zeitbereich
 f_inv = sympy.inverse_laplace_transform(F, s, t)
 print(&quot;Inverse Transformation f(t):&quot;, f_inv)

Ausgabe:
 Laplace-Transformierte F(s): 1/s
 Inverse Transformation f(t): Heaviside(t)

Die Zeile

 from sympy.abc import t, s

steht alternativ für

 t = sympy.symbols(&quot;t&quot;)
 s = sympy.symbols(&quot;s&quot;)

&lt;u&gt;Aufgaben&lt;/u&gt;: Ermitteln Sie mittels SymPy die &lt;math&gt;\mathcal{L}&lt;/math&gt;-Transformierten und dann wieder die  &lt;math&gt;\mathcal{L}^{-1}&lt;/math&gt;-Transformationen (ähnlich wie beim obigen Beispiel):
* &lt;math&gt;\sin(t) \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;t^3 \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;\text{e}^{\omega t} \circ\! -\! \bullet \ ?&lt;/math&gt;

=Fourier-Reihen=
&lt;math&gt;
f(x)\approx \frac{a_{0}}{2}+\sum_{k=1}^{\infty}\left(a_{k}\cos\left(kx\right)+b_{k}\sin\left(kx\right)\right)
&lt;/math&gt;

&lt;math&gt;
a_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\cos\left(kx\right)\mathrm dx\quad\text{für }k\geq0
&lt;/math&gt;

&lt;math&gt;
b_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\sin\left(kx\right)\mathrm dx\quad\text{für }k\geq1
&lt;/math&gt;

Für die Sägezahnfunktion &lt;math&gt;y=x;\, 0 &lt; x &lt; 2\pi&lt;/math&gt; sei die Fourierreihe mit einem Python-Programm (unter Mithilfe von sympy) hergeleitet.

Code:

 from sympy import fourier_series, pi, symbols, pprint
 
 x = symbols('x')
 f = x
 s = fourier_series(f, (x, 0, 2*pi))
 pprint(s.truncate(n=4))

Ausgabe:

                        2⋅sin(3⋅x)    
 -2⋅sin(x) - sin(2⋅x) - ────────── + π
                            3

Siehe auch [[Ing Mathematik: Fourierreihen]].

Ein komplizierteres Beispiel:

[[Datei:IngMath fourier bsp13.svg | 300px]]

&lt;math&gt;0\le t &lt; T/2\text{:}\quad f(t) = H&lt;/math&gt;

&lt;math&gt;T/2 \le t \le T\text{:}\quad f(t) = \frac{2H}{T}\left( t-\frac{T}{2}\right)&lt;/math&gt;

Code:

 import sympy as sp
 
 H = sp.Symbol('H', positive=True)
 T = sp.Symbol('T', positive=True)
 t = sp.Symbol('t')
 
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T/2)),
     (2*H/T*(t-T/2), (t &gt; T/2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Ausgabe:

      ⎛2⋅π⋅t⎞        ⎛4⋅π⋅t⎞        ⎛6⋅π⋅t⎞          ⎛2⋅π⋅t⎞          ⎛6⋅π⋅t⎞      
 H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   2⋅H⋅cos⎜─────⎟   2⋅H⋅cos⎜─────⎟      
      ⎝  T  ⎠        ⎝  T  ⎠        ⎝  T  ⎠          ⎝  T  ⎠          ⎝  T  ⎠   3⋅H
 ──────────── - ──────────── + ──────────── + ────────────── + ────────────── + ───
      π             2⋅π            3⋅π               2                 2         4 
                                                    π               9⋅π

=Rechnen mit wirklich großen Zahlen=
Bekannt ist, dass Python kaum Einschränkungen beim Wertebereich von Ganzzahlen hat, z.B.

 print(10**300)

Ausgabe (gekürzt):

 100000000000000000000...00000000000000000000000000000000000000000000000000000000000000000000000

Ähnliches geht auch mit Gleitpunktzahlen, z.B. durch die Verwendung des Moduls [https://mpmath.org/ mpmath]:

 import mpmath
 print(mpmath.mpf(1500.4)**mpmath.mpf(300))

Ausgabe:

 7.27975299218612e+952

Anderes Beispiel:

 from mpmath import mp, pi
 mp.dps = 100
 print(pi)

Ausgabe:

 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068

mpmath kann noch einiges mehr, dazu sei aber auf die entsprechende Dokumentation auf der mpmath-Homepage verwiesen. mpmath ist Bestandteil von SymPy, kann aber auch separat installiert werden.

Aber auch Python selbst besitzt eine Möglichkeit, um mit großen bzw. exakten Gleitpunktzahlen zu rechnen, nämlich das interne Modul decimal. Dieses hat einige Vorteile gegenüber mpmath, aber auch gravierende Nachteile. Diese seien hier nicht detailliert aufgezählt. Grob gesagt hat decimal im Finanzwesen seine Berechtigung. Für wissenschaftliche Anwendungen wird aber mpmath vorzuziehen sein, da es u.a. vielfältige mathematische Funktionen bereit stellt. Nachfolgend ein einfaches Beispiel mit decimal:

 import decimal
 print(&quot;Potenzierung:&quot;, decimal.Decimal(1500.4) ** decimal.Decimal(300.0))
 print(&quot;Einfache Addition:&quot;, 0.1 + 0.2)
 decimal.getcontext().prec = 50
 print(&quot;Addition mit decimal:&quot;, decimal.Decimal(&quot;0.1&quot;) + decimal.Decimal(&quot;0.2&quot;))

Ausgabe:

 Potenzierung: 7.279752992186121551039839134E+952
 Einfache Addition: 0.30000000000000004
 Addition mit decimal: 0.3

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet die genauen Vor- und Nachteile von decimal und mpmath. Verwenden Sie dazu auch KI (z.B. von Google, chatgpt).

= pint - mit physikalischen Größen rechnen = 
[[File:Pint-Glas_UK.jpg|right|100px]]
pint ist ein externes Python-Paket zur Manipulation von physikalischen Einheiten. Es muss vor der ersten Benutzung installiert werden (Vorgehensweise wie immer: pip, YaST, via venv etc.).

Beispiel:

 import pint
 import numpy as np
 
 ureg = pint.UnitRegistry()
 
 # Einfache Berechnung
 print(3 * ureg.meter + 4 * ureg.cm)
 
 # Mit NumPy
 npeinzel = [3, 4] * ureg.meter + [2, 5] * ureg.cm
 print(npeinzel)
 npsum = np.sum(npeinzel)
 print(npsum)
 
 # Konvertierung von Einheiten
 npsum_inch = npsum.to(ureg.inch)
 print(npsum_inch)
 
 print(npeinzel.magnitude)
 print(npeinzel.units)
 print(npeinzel.dimensionality)

Ausgabe:

 3.04 meter
 [3.02 4.05] meter
 7.07 meter
 278.3464566929134 inch
 [3.02 4.05]
 meter
 [length]

Die Dokumentation zu pint findet sich auf [https://pint.readthedocs.io/en/stable/].

=Regelungstechnische Aufgabenstellungen=
Für regelungstechnische Aufgaben gibt es u.a. das externe Paket &lt;code&gt;control&lt;/code&gt;. Hier soll nicht detailliert darauf eingegangen werden. Anhand eines Beispiels soll anschließend nur die Visualisierung in Form eines Bode-Diagramms und der Sprungantwort gezeigt werden. Gegeben sei ein P-Regler mit &lt;math&gt;R = \frac{5}{2}&lt;/math&gt; und eine Strecke &lt;math&gt;S= \frac{1}{30s^3+20s^2+10s+1,5}&lt;/math&gt;. Gesucht sei vorerst ein Bode-Diagramm für den offenen Regelkreis und das Führungsverhalten.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke  # oder: G0 = ct.series(regler, strecke)
 Gw = ct.feedback(G0)
 
 ct.bode_plot(G0, label='G0')
 ct.bode_plot(Gw, label='Gw')
 plt.show()

[[Datei:PythonIng_bode1.svg]]

Nun noch für obiges Beispiel die Sprungantwort. Diese zeigt einige große Überschwinger, d.h. der Regler kann sicher noch optimiert werden.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke 
 Gw = ct.feedback(G0) 
 
 t, y = ct.step_response(Gw)
 
 plt.plot(t,y)
 plt.title('Sprungantwort')
 plt.xlabel('t')
 plt.ylabel('h(t)')
 plt.grid()
 plt.show()

[[Datei:PythonIng_bode3.svg]]

Einige weitere wichtige Daten (Phasenreserve, Amplitudenreserve, Durchtrittsfrequenz) lassen sich mittels der &lt;code&gt;control&lt;/code&gt;-Funktion &lt;code&gt;margin()&lt;/code&gt; ermitteln. Die Ortskurve lässt sich mit der Funktion &lt;code&gt;nyquist_plot()&lt;/code&gt; zeichnen. Dies sei hier aber nicht weiter ausgeführt.

==Aufgaben==
* Zeichen Sie mit Python die Ortskurve für obiges Beispiel.
* Was passiert, wenn man die Reglerverstärkung weiter aufdreht (z.B. auf &lt;math&gt;R = \frac{25}{2}&lt;/math&gt;)?
* Wie sehen das Bode-Diagramm und die Sprungantwort aus, wenn ein PI-Regler verwendet wird?

= Stereostatik etc. =
Das Modul SymPy bietet einige Möglichkeiten einfache Bauwerke zu berechnen, z.B. Balken oder Fachwerke. Nachfolgend wird ein einfaches Fachwerk berechnet und gezeichnet.

Python-Code:
 from sympy.physics.continuum_mechanics.truss import Truss 
 
 t = Truss()
 # Knoten
 t.add_node((&quot;A&quot;, -3, 0), (&quot;B&quot;, 0, 0), (&quot;C&quot;, 4, 0), (&quot;D&quot;, 7, 0),
            (&quot;E&quot;, 6, 1.5), (&quot;F&quot;, 2, 3), (&quot;G&quot;, -2, 1.5))
 # Stäbe
 t.add_member((&quot;AB&quot;,&quot;A&quot;,&quot;B&quot;), (&quot;BC&quot;,&quot;B&quot;,&quot;C&quot;), (&quot;CD&quot;,&quot;C&quot;,&quot;D&quot;))
 t.add_member((&quot;AG&quot;,&quot;A&quot;,&quot;G&quot;), (&quot;GB&quot;,&quot;G&quot;,&quot;B&quot;), (&quot;GF&quot;,&quot;G&quot;,&quot;F&quot;))
 t.add_member((&quot;BF&quot;,&quot;B&quot;,&quot;F&quot;), (&quot;FC&quot;,&quot;F&quot;,&quot;C&quot;), (&quot;CE&quot;,&quot;C&quot;,&quot;E&quot;))
 t.add_member((&quot;FE&quot;,&quot;F&quot;,&quot;E&quot;), (&quot;DE&quot;,&quot;D&quot;,&quot;E&quot;))
 # Auflager; roller ... Loslager, pinned ... Festlager
 t.apply_support((&quot;A&quot;,&quot;roller&quot;), (&quot;D&quot;,&quot;pinned&quot;))
 # Einwirkende Kräfte
 t.apply_load((&quot;G&quot;, 5, 270), (&quot;E&quot;, 3, 90))
 
 # Berechnung 
 t.solve()
 print(&quot;Reaction Forces: &quot;, t.reaction_loads)
 print(&quot;Internal Forces: &quot;, t.internal_forces)
 
 # Fachwerk zeichnen
 p = t.draw()
 p.show()

Ausgabe auf der Konsole:

 Reaction Forces:  {'R_A_y': 4.20000000000000, 'R_D_x': 0, 'R_D_y': -2.20000000000000}
 Internal Forces:  {'AB': 2.80000000000000, 'BC': 0.333333333333333, 'CD': -1.46666666666667, 
 'AG': -5.04777178564958, 'GB': -2.05555555555556, 'GF': -1.23413387432364, 
 'BF': 0.411111111111111*sqrt(13), 'FC': -0.3*sqrt(13), 'CE': 1.50000000000000, 
 'FE': 0.284800124843917, 'DE': 2.64407093534026}

Zeichnung:

[[File:PythonIng_fachwerk1.svg|300px]]

Details zu diesem Thema siehe z.B. [https://docs.sympy.org/latest/modules/physics/continuum_mechanics/index.html Continuum Mechanics] oder [https://docs.sympy.org/latest/tutorials/physics/continuum_mechanics/index.html Continuum Mechanics Tutorials]. Auch andere mechanische Probleme werden von SymPy abgehandelt ([https://docs.sympy.org/latest/tutorials/physics/index.html Physics Tutorials]).

== Aufgabe ==
Gegeben sei ein einseitig eingespannter Kragträger. Belastet wird er durch eine Einzellast am Trägerende. Für die Daten siehe folgende ASCII-Skizze:

                            | 20 kN  
    //|---&gt; x               |
    //|                     V
    //|----------------------
    //|         10 m        |
 
 Elastizitätsmodul E = 2,1*10⁵ N/mm²
 Flächenträgheitsmoment I = 0.001 m⁴

Berechnen Sie die Auflagerreaktionen, den Querkraft- und Biegemomentenverlauf, sowie die Verformungen.
Stellen Sie dies mit Hilfe von SymPy graphisch und auch mittels Formeln dar. Verwenden Sie dazu auch pprint (pretty print) aus dem SymPy-Modul. Zwecks Lösungsansatz siehe die oben aufgeführte Seite &quot;Continuum Mechanics Tutorials&quot;. Achten Sie auch auf die Einheiten! Kontrollieren Sie das Ganze mittels händischer Rechnung. In dem genannten Tutorial ist von &quot;Singularity Functions&quot; die Rede. Gemeint ist damit in diesem Kontext die {{W|Föppl-Klammer}}.

Einige Python-Programme, vorrangig zu Maschinenelementen, finden sich auf [https://baymp.de/download_python.html BayMP für Python] (Balken, Zahnräder, Stabknickung usw.).

=Thermodynamik= 
== PYroMat ==
Für thermodynamische Aufgabenstellungen gibt es verschiedene externe Module. Eines davon ist PYroMat (siehe auch [http://pyromat.org]). Damit lassen sich thermodynamische Stoffdaten für viele Substanzen berechnen.

Beispiel (einige Stoffdaten für Wasser bei 400°C und 20 bar berechnen):

 import pyromat as pm
 
 # Wasserdaten laden:
 H2O = pm.get('mp.H2O')
 
 # Stoffdaten berechnen:
 T = 673.15  # Temperatur in Kelvin
 p = 20      # Druck in bar
 v = H2O.v(T, p)
 h = H2O.h(T, p)
 s = H2O.s(T, p)
 print(f&quot;Spezifisches Volumen: {v} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {h} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {s} kJ/(kg K)&quot;)

Ausgabe:

 Spezifisches Volumen: [0.1512163] m³/kg
 Spezifische Enthalpie: [3248.3789473] kJ/kg
 Spezifische Entropie: [7.12924142] kJ/(kg K)

&lt;small&gt;
PYroMat muss vorab installiert werden (z.B. mittels pip, in eine virtuelle Umgebung)
&lt;/small&gt;

&lt;code&gt;mp&lt;/code&gt; steht für &quot;multi phase&quot;. Für ein ideales Gas wäre &lt;code&gt;ig&lt;/code&gt; zuständig, z.B. &lt;code&gt;'ig.O2'&lt;/code&gt;.

Beispiel (T-s-Diagramm für Wasser zeichnen):
 import numpy as np
 import matplotlib.pyplot as plt
 import pyromat as pm
 
 # Konfigurieren
 pm.config[&quot;unit_pressure&quot;] = &quot;bar&quot;
 pm.config[&quot;unit_temperature&quot;] = &quot;K&quot;
 fluid = pm.get(&quot;mp.H2O&quot;)
 
 # Temperaturbereich für das Nassdampfgebiet
 T_tripel = 273.16
 T_crit = 647.096
 T = np.linspace(T_tripel, T_crit - 0.1, 200)
 
 # Sättigungslinien berechnen und zeichnen
 for x in np.linspace(0.0, 1.0, 5):
     s = fluid.s(T=T, x=x)
     if(x&lt;=0.0):
         plt.plot(s, T, label=&quot;Siedelinie x=%3.1f&quot; % x, linewidth=2.0)
     elif(x&gt;=1.0):
         plt.plot(s, T, label=&quot;Taulinie x=%3.1f&quot; % x, linewidth=2.0)
     else:
         plt.plot(s, T, label=&quot;x=%3.1f&quot; % x, linewidth=1.0)
 
 # Isobaren zeichnen
 p_values = [0.1, 1, 10, 50, 100]
 T_isobar = np.linspace(T_tripel, 1000, 200)
 t = 0.7
 
 for p in p_values:
     s_iso = fluid.s(T=T_isobar, p=p)
     plt.plot(s_iso, T_isobar, 'k-', alpha=0.8, linewidth=0.8)
 
     t += .05
     idx = int(len(s_iso) * t)
     plt.text(s_iso[idx], T_isobar[idx], f&quot;{p} bar&quot;, fontsize=9, alpha=0.8)
 
 # Diagramm zeichnen
 plt.title(&quot;T-s-Diagramm für Wasser&quot;)
 plt.xlabel(&quot;Spezifische Entropie s in kJ/kg K&quot;, fontsize=10)
 plt.ylabel(&quot;Temperatur T in K&quot;, fontsize=10)
 plt.legend(loc=&quot;best&quot;)
 plt.grid(True)
 plt.show()

Ausgabe (in etwa so):

[[Datei:T-s-Diagramm fuer Wasser.svg|400px]]

== CoolProp ==
Auch mit CoolProp können Stoffdaten berechnet werden. Siehe auch [https://coolprop.org/coolprop/wrappers/Python/index.html]

Beispiel (Wasser bei 20bar und 400°C):
 import CoolProp.CoolProp as CP
 
 fluid = 'Water'
 T = 673.15   # Temperatur in Kelvin
 P = 20e5     # Druck in Pascal
 
 dichte = CP.PropsSI('D', 'T', T, 'P', P, fluid)
 enthalpie = CP.PropsSI('H', 'T', T, 'P', P, fluid)
 entropie = CP.PropsSI('S', 'T', T, 'P', P, fluid)
 
 print(f&quot;Spez. Volumen: {1/dichte:.6f} m³/kg&quot;)
 print(f&quot;Spez. Enthalpie: {enthalpie:.2f} J/kg&quot;)
 print(f&quot;Spez. Entropie: {entropie:.2f} J/kgK&quot;)

Ausgabe:
 Spez. Volumen: 0.151215 m³/kg
 Spez. Enthalpie: 3248344.02 J/kg
 Spez. Entropie: 7129.16 J/kgK

== iapws ==
Um Werte für Wasser(dampf) zu erhalten (IAPWS; '''I'''nternational '''A'''ssociation for the '''P'''roperties of '''W'''ater and '''S'''team) gibt es die Bibliothek iapws. Siehe auch [https://iapws.org/] und [https://pypi.org/project/iapws/]

Beispiel (Wasser für 20bar und 400°C):
 from iapws import IAPWS97
 
 dampf = IAPWS97(P=2.0, T=673.15)
 
 print(f&quot;Spezifisches Volumen: {dampf.v:.6f} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {dampf.h:.2f} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {dampf.s:.4f} kJ/(kgK)&quot;)
 print(f&quot;Phase: {dampf.phase}&quot;)

Ausgabe:
 Spezifisches Volumen: 0.151208 m³/kg
 Spezifische Enthalpie: 3248.23 kJ/kg
 Spezifische Entropie: 7.1290 kJ/(kgK)
 Phase: Gas

== TESPy ==
Ein anderes Modul für einen anderen Aufgabenzweck ist TESPy ('''T'''hermal '''E'''ngineering '''S'''ystems in '''Py'''thon). Dieses Modul ist für die Anlagensimulation zuständig. Für nähere Informationen siehe [https://tespy.readthedocs.io/en/main/getting_started/introduction.html]. Als Beipiel sei hier vorerst Code, der von der Google KI generiert wurde, angeführt. Der Code wurde überarbeitet, damit keine Warnungen auftreten. Bitte aber den Code trotzdem mit Vorsicht genießen, auch KI-generierter Code kann Fehler aufweisen. Eine Pumpe wird berechnet:

 from tespy.components import Sink, Source, Pump
 from tespy.connections import Connection
 from tespy.networks import Network
 
 # 1. Netzwerk definieren (Zentrales Steuerungselement)
 # Wir wählen Wasser als Fluid und bar/Celsius als Einheiten
 nw = Network(fluids=[&quot;water&quot;])
 nw.units.set_defaults(pressure=&quot;bar&quot;, pressure_difference=&quot;bar&quot;, 
                       temperature=&quot;°C&quot;, enthalpy=&quot;kJ / kg&quot;)
 
 # 2. Komponenten erstellen
 eingang = Source(&quot;Wasserquelle&quot;)
 ausgang = Sink(&quot;Wasserspeicher&quot;)
 pumpe = Pump(&quot;Speisewasserpumpe&quot;)
 
 # 3. Verbindungen definieren (Komponenten miteinander verknüpfen)
 c1 = Connection(eingang, &quot;out1&quot;, pumpe, &quot;in1&quot;)
 c2 = Connection(pumpe, &quot;out1&quot;, ausgang, &quot;in1&quot;)
 
 # Verbindungen dem Netzwerk hinzufügen
 nw.add_conns(c1, c2)
 
 # 4. Randbedingungen und Parameter festlegen
 # Zustand am Eingang (Druck, Temperatur, Massenstrom, Fluid-Zusammensetzung)
 c1.set_attr(
     v=1,  # Massenstrom: 1 kg/s
     T=20,  # Temperatur: 20 °C
     p=1,  # Druck: 1 bar
     fluid={&quot;water&quot;: 1},  # 100% Wasser
 )
 
 # Zustand am Ausgang / Zielwerte der Pumpe
 c2.set_attr(p=10)  # Ziel-Druck nach der Pumpe: 10 bar
 
 # Pumpeneigenschaften festlegen
 pumpe.set_attr(eta_s=0.8)  # Isentroper Wirkungsgrad von 80%
 
 # 5. Simulation ausführen
 nw.solve(mode=&quot;design&quot;)
 
 # 6. Ergebnisse ausgeben
 nw.print_results()
 
 # Spezifische Werte direkt auslesen
 print(&quot;\n--- Auswertung ---&quot;)
 print(f&quot;Erforderliche Pumpenleistung: {pumpe.P.val / 1000:.2f} kW&quot;)
 print(f&quot;Temperatur nach der Pumpe: {c2.T.val:.2f} °C&quot;)

Ausgabe (gekürzt):
  iter  | residual   | progress   | massflow   | pressure   | enthalpy   | fluid      | component  
 -------+------------+------------+------------+------------+------------+------------+------------
  1     | 7.04e+04   | 12 %       | 9.96e+02   | 0.00e+00   | 8.81e+04   | 0.00e+00   | 0.00e+00   
  2     | 5.91e-12   | 100 %      | 1.11e-13   | 0.00e+00   | 7.39e-12   | 0.00e+00   | 0.00e+00   
  3     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
  4     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
 Total iterations: 4, Calculation time: 0.01 s, Iterations per second: 480.85
 
 ##### RESULTS (Pump) #####
 +-------------------+----------+----------+-----------+----------+----------+----------+
 |                   |        P |       pr |        dp |      eta |    eta_s |     head |
 |-------------------+----------+----------+-----------+----------+----------+----------|
 | Speisewasserpumpe | 1.12e+06 | 1.00e+01 | -9.00e+00 | 8.00e-01 | 8.00e-01 | 9.19e+01 |
 +-------------------+----------+----------+-----------+----------+----------+----------+
 ...
 ...
 --- Auswertung ---
 Erforderliche Pumpenleistung: 1124.77 kW
 Temperatur nach der Pumpe: 20.07 °C

= Stochastik =
Die {{W|Stochastik}} ist ein sehr weites Feld. Hier werden etliche wichtige Themen kurz angerissen. Python stellt mit den Moduln math und statistics Software zu diesem Zwecke bereit. math und statistics sind bereits im Lieferumfang von Python enthalten. Aber auch mit den externen Modulen NumPy, SciPy, stochastic und pandas kann man Stochastik in Python betreiben. Die Theorie der Wahrscheinlichkeitsrechnung und Statistik soll etwas später in Band 5 dieser Buchreihe behandelt werden.

== Lageparameter == 
 import statistics
 
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 
 m1 = statistics.mean(werte)
 m2 = statistics.mode(werte)
 m3 = statistics.median(werte)
 
 print(&quot;Arithmetischer Mittelwert = &quot;, m1)
 print(&quot;Modalwert = &quot;, m2)
 print(&quot;Median = &quot;, m3)

Ausgabe:
 Arithmetischer Mittelwert =  3.5
 Modalwert =  1
 Median =  3.0

== Streuungsparameter ==
Beispiel (Berechnung der Standardabweichung):
 import statistics
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 s = statistics.stdev(werte)
 print(&quot;Standardabweichung = &quot;, s)

Ausgabe:
 Standardabweichung =  2.6770630673681683

Beispiel (Berechnung des Variationskoeffizienten V = Standardabweichung/Mittelwert)
 import numpy as np
 from scipy import stats
 import statistics
 
 k = 50
 
 dat1 = [14, 21, 18, 25, 30, 17, 20]
 dat = np.array(dat1)
 
 # Mit SciPy
 v = stats.variation(dat)
 vddof = stats.variation(dat, ddof=1)
 print(&quot;V SciPy: &quot;, v)
 print(&quot;V DDOF SciPy: &quot;, vddof)
 print(k*&quot;-&quot;)
 
 # mit NumPy
 mittelwert1 = np.mean(dat)
 std_abw1 = np.std(dat)
 std_abw1ddof = np.std(dat, ddof=1) 
 v1= std_abw1 / mittelwert1
 v1ddof = std_abw1ddof / mittelwert1
 print(&quot;Mittelwert NumPy: &quot;, mittelwert1)
 print(&quot;Std.abw. NumPy: &quot;, std_abw1)
 print(&quot;Std.abw. DDOF NumPy: &quot;, std_abw1ddof)
 print(&quot;V NumPy: &quot;, v1)
 print(&quot;V DDOF NumPy: &quot;, v1ddof)
 print(k*&quot;-&quot;)
 
 # nur mit reinem Python
 mittelwert2 = statistics.mean(dat1)
 std_abw2 = statistics.stdev(dat1)
 v2 = std_abw2 / mittelwert2
 print(&quot;Mittelwert Python: &quot;, mittelwert2)
 print(&quot;Std.abw. Python: &quot;, std_abw2)
 print(&quot;V Python:&quot;, v2)
 print(k*&quot;-&quot;)

Ausgabe:
 V SciPy:  0.23890355966467272
 V DDOF SciPy:  0.25804533701889254
 --------------------------------------------------
 Mittelwert NumPy:  20.714285714285715
 Std.abw. NumPy:  4.948716593053935
 Std.abw. DDOF NumPy:  5.3452248382484875
 V NumPy:  0.23890355966467272
 V DDOF NumPy:  0.2580453370188925
 --------------------------------------------------
 Mittelwert Python:  20.714285714285715
 Std.abw. Python:  5.3452248382484875
 V Python: 0.2580453370188925
 --------------------------------------------------

Der Unterschied bei der Standardabweichung zwischen reinem Python und den externen Bibliotheken SciPy und NumPy entsteht dadurch, dass einmal durch (n-1) und das andere Mal nur durch n dividiert wird. Dies kann bei NumPy und SciPy dadurch entschärft werden, indem &lt;code&gt;ddof=1&lt;/code&gt; gesetzt wird. ddof steht für '''D'''elta '''D'''egrees '''o'''f '''F'''reedom. &lt;small&gt;Je größer die Anzahl der Datensätze n wird, umso weniger spielt das eine Rolle.&lt;/small&gt;

== Kombinatorik ==
Beispiel:

 import math
 
 n = 7
 k = 5
 
 print(&quot;n! = &quot;, math.factorial(n))
 print(&quot;Kombinationen (n über k) = &quot;, math.comb(n, k))

Ausgabe:
 n! =  5040
 Kombinationen (n über k) =  21

Siehe zu diesem Thema auch [[Ing Mathematik: Permutationen, Kombinationen, binomischer Lehrsatz]]. Die Anzahlen lassen sich einfach aus den dortigen Formeln ermitteln, z.B. bei Permutationen mit &lt;math&gt;n!&lt;/math&gt; oder Variationen mit Wiederholungen als &lt;math&gt;n^k&lt;/math&gt;. Will man die Kombinationen oder Variationen aber auch als Liste ausgeben, so kann das Modul &lt;code&gt;itertools&lt;/code&gt; nützlich sein.  

Beispiel (Variationen ohne Wiederholung):

 from itertools import permutations
 
 menge = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]  # n = 4
 k = 3
 
 variationen = list(permutations(menge, k))
 
 for v in variationen:
     print(&quot;&quot;.join(v))
 
 print(50*&quot;-&quot;)
 print(len(variationen))

Ausgabe (gekürzt):
 ABC
 ABD
 ACB
 ...
 DCA
 DCB
 --------------------------------------------------
 24

Siehe zum Modul &lt;code&gt;itertools&lt;/code&gt; auch die Website [https://docs.python.org/3/library/itertools.html].

* Variationen mit Wiederholung: &lt;code&gt;itertools.product()&lt;/code&gt;
* Kombinationen ohne Wiederholung: &lt;code&gt;itertools.combinations()&lt;/code&gt;
* Kombinationen mit Wiederholung: &lt;code&gt;itertools.combinations_with_replacement()&lt;/code&gt;

== Zufallszahlen ==
Beispiel:
 import random
 
 # Ganzzahlige Zufallszahl von 1 bis 10
 zufallszahl1 = random.randint(1, 10)
 
 # Gleitpunktzahlen
 # zwischen 0.0 und 1.0
 zufallszahl2 = random.random()
 # Zahl zwischen 1.5 und 9.5
 zufallszahl3 = random.uniform(1.5, 9.5)
 
 # aus Liste auswählen
 farbe = [&quot;Rot&quot;, &quot;Grün&quot;, &quot;Blau&quot;]
 zufallswert = random.choice(farbe)
 
 print(zufallszahl1)
 print(zufallszahl2)
 print(zufallszahl3)
 print(zufallswert)

Ausgabe, z.B.:
 5
 0.14147945849015753
 6.894003397570905
 Rot

Benötigt man mehrere Zufallszahlen, so ist das Modul &lt;code&gt;numpy&lt;/code&gt; zu bevorzugen, z.B.:
* Normalverteilung: &lt;code&gt;np.random.normal(...)&lt;/code&gt;
* Gleichverteilung: &lt;code&gt;np.random.uniform(...)&lt;/code&gt;

== Histogramm ==
Zum Thema Histogramm siehe {{W|Histogramm}}.

Beispiel (mit Matplotlib):

 import matplotlib.pyplot as plt
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 
 plt.hist(daten, bins=25, edgecolor='darkgray')
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm.svg|300px]]

Beispiel (mit Seaborn):

 import matplotlib.pyplot as plt
 import seaborn as sns
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 sns.set_theme(style=&quot;darkgrid&quot;)
 sns.histplot(data=daten)
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm2.svg|300px]]

Das Kürzel &lt;code&gt;sns&lt;/code&gt; ist Konvention und steht für die fiktive Figur '''S'''amuel '''N'''orman '''S'''eaborn aus der US-Fernsehserie {{W|The West Wing – Im Zentrum der Macht | The West Wing}}.

== Box-Plot ==
[[File:Elements of a boxplot.svg|400px]]

Siehe auch {{W|Box-Plot}}.

Beispiel (mit Seaborn erstellt):
 import seaborn as sns
 import matplotlib.pyplot as plt
 
 df = sns.load_dataset(&quot;tips&quot;)
 sns.boxplot(data=df, x=&quot;day&quot;, y=&quot;tip&quot;, hue=&quot;day&quot;, legend=False)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot.svg|400px]]

Beispiel (mit Matplotlib erstellt):

 import matplotlib.pyplot as plt
 
 daten = [12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25]
 
 plt.boxplot(daten, patch_artist=True)
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot2.svg|300px]]

Um mehrere Box-Plots unterschiedlicher Farbe mit Matplotlib in einem Diagramm zu zeichnen, können Sie folgendermaßen vorgehen:

 import matplotlib.pyplot as plt
 
 daten = [[12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25],
          [10, 19, 20, 21, 20, 30, 19, 40, 11, 17, 19, 21]]
 
 farben = [&quot;green&quot;, &quot;blue&quot;]
 
 boxplot = plt.boxplot(daten, patch_artist=True)
 
 for patch, farbe in zip(boxplot['boxes'], farben):
     patch.set_facecolor(farbe)
 
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

== Regressionsrechnung ==
Beispiel:
 import numpy as np
 import matplotlib.pyplot as plt
 
 # Messpunkte
 x = np.array([1, 3, 5, 6, 8, 10, 20])
 y = np.array([3, 4, 5, 5, 7, 9, 11])
 
 # Regressionskurve (Grad 1 = lineare Regression, 2 = Polynom-Regression 2. Gr.)
 # y = kx + d
 k, d = np.polyfit(x, y, deg=1)
 # y = ax**2 + bx + c
 a, b, c = np.polyfit(x, y, deg=2)
 
 x_l = np.linspace(1, 20, 100)
 y_p = a * x_l**2 + b * x_l + c
 
 # Zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.plot(x, k*x + d, color='blue', label='Regressionsgerade')
 plt.plot(x_l, y_p, color='red', label='Regressionspolynom 2. Gr.')
 plt.xlabel('x')
 plt.ylabel('y')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_regression.svg|400px]]

== Korrelationsrechnung ==
Beispiel:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 # Messdaten
 x = [1, 3, 4, 5, 6]
 y = [2, 4, 6, 8, 5]
 
 daten = {'X': x, 'Y': y}
 df = pd.DataFrame(daten)
 
 # Korrelation
 korr = df['X'].corr(df['Y'])
 print(f&quot;Korrelationskoeff.: {korr}&quot;) 
 
 # Messpunkte zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:
 Korrelationskoeff.: 0.7556096518348252

[[Datei:IngMath_korrelation.svg|300px]]

== Mengen und Venn-Diagramme ==
Beispiel: 
 import matplotlib.pyplot as plt
 from matplotlib_venn import venn2
 
 menge_a = {1, 2, 3, 4, 5, 6}
 menge_b = {4, 5, 6, 7, 8}
 
 vereinigung = menge_a | menge_b
 schnitt = menge_a &amp; menge_b
 print(&quot;Vereinigungsmenge = &quot;, vereinigung)
 print(&quot;Schnittmenge = &quot;, schnitt)
 
 venn2([menge_a, menge_b], set_labels=('Menge A', 'Menge B'))
 plt.show()

Ausgabe:
 Vereinigungsmenge =  {1, 2, 3, 4, 5, 6, 7, 8}
 Schnittmenge =  {4, 5, 6}

[[Datei:IngMath_venn.svg|300px]]

Siehe auch {{W|Mengendiagramm#Venn-Diagramme}}.

== Verteilungs- und Dichtefunktion ==
* CDF ... '''C'''umulative '''D'''istribution '''F'''unction, Verteilungsfunktion
* PDF ... '''P'''robability '''D'''ensity '''F'''unction, Dichtefunktion

Beispiel (Normalverteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 from scipy.stats import norm
 
 my, sigma = 0, 1
 x = np.linspace(-4, 4, 50)
 
 pdf = norm.pdf(x, my, sigma)
 cdf = norm.cdf(x, my, sigma)
 
 plt.plot(x, pdf, lw=2, label=&quot;Dichtefunktion&quot;)
 plt.plot(x, cdf, lw=2, label=&quot;Verteilungsfunktion&quot;)
 plt.legend()
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:IngMath_cdf_pdf.svg|300px]]

Beispiel (&lt;math&gt;\chi^2&lt;/math&gt;-Verteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 import scipy.stats as stats
 
 x = np.linspace(0, 20, 500)
 
 # df ... degree of freedom, Freiheitsgrad
 pdf = (stats.chi2.pdf(x, df=2), stats.chi2.pdf(x, df=5), stats.chi2.pdf(x, df=10))
 
 for i in range(0,3):
     if(i==0):
         lab = &quot;Freiheitsgrad 2&quot;
     elif(i==1):
         lab = &quot;Freiheitsgrad 5&quot;
     else:
         lab = &quot;Freiheitsgrad 10&quot;
 
     plt.plot(x, pdf[i], label=lab, lw=2)
 
 plt.grid()
 plt.legend()
 plt.show()

Ausgabe:

[[Datei:IngMath_chi2.svg | 300px]]

== Schätzen und Testen ==
=== Intervallschätzung ===
Als Beispiel seien Daten gegeben, die von ''Dürr, Mayer: Wahrscheinlichkeitsrechnung und Schließende Statistik; 7. Aufl., Hanser, 2014, Seite 137'' stammen. Und zwar soll das 95%-Vertrauensintervall für den Mittelwert des Kaloriengehalts (kcal/100g) von Hähnchen ermittelt werden. Wir wollen das mit Python inkl. NumPy und SciPy durchführen. Die Stichprobe ist groß (50 Hähnchen):

Python-Code:
 import numpy as np
 import scipy.stats as stats
 
 # Stichprobe
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203]
 
 # Parameter definieren
 konfidenzniveau = 0.95
 mean = np.mean(daten)
 std = np.std(daten, ddof=1)
 stdfehler = stats.sem(daten)
 
 intervall = stats.norm.interval(confidence=konfidenzniveau, loc=mean, scale=stdfehler)
 
 print(f&quot;Mittelwert: {mean}&quot;)
 print(f&quot;Standardabweichung: {std}&quot;)
 print(f&quot;Konfidenzintervall: {intervall}&quot;)

Ausgabe:
 Mittelwert: 215.48
 Standardabweichung: 33.14238915925757
 Konfidenzintervall: (np.float64(206.29356722321992), np.float64(224.66643277678006))

Diese Werte stimmen gerundet mit denen im genannten Buch überein. Zum Code selbst:
* sem steht für '''s'''tandard '''e'''rror of the '''m'''ean.
* &lt;code&gt;scipy.stats.norm&lt;/code&gt; ... Modul für die Normalverteilung.

=== Punktschätzung ===
Gleiche Daten wie oben bei der Intervallschätzung.

Python-Code:
 import numpy as np
 from scipy import stats
 
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203
         ]
 
 mu_hat, sigma_hat = stats.norm.fit(daten) 
 
 print(f&quot;Schätzer für den Erwartungswert (μ): {mu_hat:.4f}&quot;)
 print(f&quot;Schätzer für die Standardabweichung (σ): {sigma_hat:.4f}&quot;)

Ausgabe:
 Schätzer für den Erwartungswert (μ): 215.4800
 Schätzer für die Standardabweichung (σ): 32.8093

=== Hypothesentests ===
Beispiel:

 import numpy as np
 import scipy.stats as stats
 
 x_quer = 12.075      # Stichproben-Mittelwert
 var    = 0.069       # Stichproben-Varianz
 n      = 90          # Stichprobengröße
 my_0   = 12.0        # Nullhypothese
 alpha  = 0.05        # Signifikanzniveau
 
 z_stat = (x_quer - my_0) / np.sqrt(var / n)
 p_val = 2 * (1 - stats.norm.cdf(np.abs(z_stat)))
 
 print(f&quot;Z-Statistik: {z_stat:.4f}&quot;)
 
 if p_val &lt; alpha:
     print(f&quot;p-Wert: {p_val:.6f} &lt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird verworfen.&quot;)
 else:
     print(f&quot;p-Wert: {p_val:.6f} &gt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird nicht verworfen.&quot;)

Ausgabe:

 Z-Statistik: 2.7087
 p-Wert: 0.006755 &lt; alpha: 0.05
 Die Nullhypothese wird verworfen.

== Statistische Qualitätskontrolle ==
Beispiel (Mittelwertkarte):

 import numpy as np
 import matplotlib.pyplot as plt
 
 # Gegeben
 sollwert = 50.0
 varianz = 4.0
 stichproben_umfang = 1
 daten = [49.5, 50.2, 53.0, 48.1, 52.6, 53.4, 49.8]
 
 # Berechnung
 standardabweichung = np.sqrt(varianz)
 streuung = standardabweichung / np.sqrt(stichproben_umfang)
 
 cl = sollwert
 ucl = cl + 3 * streuung
 lcl = cl - 3 * streuung
 
 # Darstellung
 plt.plot(daten, marker='o', linestyle='-', color='b', label='Messdaten')
 plt.axhline(cl, color='green', linestyle='-', label=f'CL: {cl}')
 plt.axhline(ucl, color='red', linestyle='--', label=f'UCL: {ucl:.2f}')
 plt.axhline(lcl, color='red', linestyle='--', label=f'LCL: {lcl:.2f}')
 
 plt.title('Mittelwertkarte')
 plt.xlabel('Stichprobe')
 plt.ylabel('Wert')
 plt.legend(loc='lower left')
 plt.grid(True)
 plt.show()

Ausgabe:

[[Datei:IngMath_mittelwertkarte.svg|300px]]

Siehe auch {{W|Shewhart-Regelkarte}} und {{W|Qualitätsregelkarte}}.

* UCL ... '''U'''pper '''C'''ontrol '''Limit''', Obere Eingriffsgrenze
* LCL ... '''L'''ower '''C'''ontrol '''Limit''', Untere Eingriffsgrenze
* CL ... '''C'''enter '''L'''ine, Mittellinie

= Ein- und Ausgabe =
== print ==
Die Anweisung print haben wir schon oft verwendet. Hier soll anhand von Beispielen kurz beschrieben werden, was der Befehl print leisten kann.

 print(&quot;Hallo&quot;, &quot;Welt&quot;, 1, sep=&quot;-&quot;)
 print(&quot;Hallo&quot;, end=&quot; &quot;)
 print(&quot;Welt&quot;)

Ausgabe:
 Hallo-Welt-1
 Hallo Welt

== input ==
 a = int(input(&quot;Zahl 1: &quot;))
 b = int(input(&quot;Zahl 2: &quot;))
 
 print(&quot;a + b = &quot;, a+b)

Ausgabe (nach Eingabe der beiden Ganzzahlen):
 Zahl 1: 4
 Zahl 2: 5
 a + b =  9

== Aus Dateien lesen ==
Es seinen die datei.txt
 Hallo Welt.
 Wie geht es dir?
 ...

und test1.py
 dat = open(&quot;datei.txt&quot;, mode = &quot;r&quot;)
 print(dat.read())
 dat.close()

Ausgabe
 Hallo Welt.
 Wie geht es dir?
 ...

Mit dem open()-Befehl wird die Datei datei.txt im Lesemodus geöffnet (r ... read). Mit dem read()-Befehl wird die Datei eingelesen und mittels print ausgegeben.

== In Dateien schreiben ==
 dat = open(&quot;datei.txt&quot;, mode = &quot;a&quot;, encoding = &quot;utf-8&quot;)
 dat.write(&quot;Hänge Zeile an\n&quot;)
 dat.close()

Die Datei datei.txt sieht nach Abarbeitung des obigen Skripts nun so aus
 Hallo Welt.
 Wie geht es dir?
 ...
 Hänge Zeile an

Es wird die Datei im Schreibmodus geöffnet (a ... append (anhängend), w ... write (überschreibend)).
write() fügt hier also eine Zeile Text am Dateiende ein. close() schließt die Datei wieder.

Das close() kann man sich mit der with-Anweisung auch sparen.

 with open(&quot;datei.txt&quot;, mode=&quot;a&quot;, encoding=&quot;utf-8&quot;) as dat:
     dat.write(&quot;Hänge Zeile an\n&quot;)

= Benutzeroberflächen erstellen =
== tkinter ==
{{Wikipedia | Tkinter}}

Python bietet standardmäßig das Modul tkinter zur Programmierung von Benutzeroberflächen. Es müssen also bei der Verwendung von tkinter keine externen Module installiert werden. Hier wird eine (sehr) kurze Einführung in das Erstellen von grafischen Oberflächen mittels tkinter gegeben.

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 win.minsize(300, 50)
 but = tk.Button(win, text = &quot;Push the button&quot;)
 but.pack()
 win.mainloop()

Ausgabe:

[[Datei:PythonIng_gui1.jpg]]

Ein etwas komplizierteres Beispiel sei nachfolgend gezeigt. Es sollen zwei Strings miteinander verknüpft und ausgegeben werden. 

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 
 def on_button_clicked():
     str = ent1.get() + ent2.get()
     lab2[&quot;text&quot;] = str
  
 ent1 = tk.Entry(win)
 ent2 = tk.Entry(win)
 lab1 = tk.Label(win, text=&quot;verknuepfen mit&quot;)
 lab2 = tk.Label(win, text=&quot;&quot;) 
 but = tk.Button(win, text = &quot;=&quot;, command=on_button_clicked)
 
 ent1.pack(side=&quot;left&quot;)
 lab1.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 but.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 lab2.pack(side=&quot;left&quot;)
 
 win.mainloop()

Ausgabe  (vor der Eingabe der Teilstrings): 

[[Datei:PythonIng_gui2.jpg]]

Ausgabe (nach der Eingabe der Teilstrings und dem Drücken des =-Buttons): 

[[Datei:PythonIng_gui3.jpg]]

== curses ==
{{Wikipedia | curses}}

Mit dem curses-Modul lassen sich u.a. TUIs ('''T'''ext '''U'''ser '''I'''nterfaces) erstellen. Ein sehr einfaches Beispiel zur allgemeinen Funktionsweise wird nachstehend geliefert.
 
 import curses
 
 stdscr = curses.initscr()
 curses.start_color()
 curses.init_pair(1, curses.COLOR_RED, curses.COLOR_WHITE)
 stdscr.clear()
 
 stdscr.addstr(&quot;Hallo Welt&quot;, curses.color_pair(1))
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()
 
Als Ausgabe sollte &lt;span style=&quot;color:#FF0000;&quot;&gt;Hallo Welt&lt;/span&gt; (rote Schrift auf weißem Hintergrund) auf dem Terminal/der Konsole erscheinen. Getestet wurde dies mit openSUSE Tumbleweed, Python-Version 3.13.12. Das entsprechende Python-curses-Package muss installiert sein.

Allgemeine Informationen zur Terminal-/Konsolengröße und Cursorposition liefert folgendes Programm:
 
 import curses
 
 stdscr = curses.initscr()
 
 stdscr.addstr(3, 5, &quot;LINES: %d&quot; % curses.LINES)
 stdscr.addstr(4, 5, &quot;COLS:  %d&quot; % curses.COLS)
 
 (y,x) = stdscr.getyx()
 stdscr.addstr(5, 5, &quot;Momentane Cursorposition:  [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getbegyx()
 stdscr.addstr(6, 5, &quot;Koordinatenursprung:       [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getmaxyx()
 stdscr.addstr(7, 5, &quot;Fenstergröße:              [%d, %d]&quot; % (y, x))
 
 stdscr.addstr(11, 2, &quot;Taste drücken -&gt; Ende&quot;)
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()

Es sollte sich in etwa folgende Ausgabe ergeben:

     LINES: 44
     COLS:  110
     Momentane Cursorposition:  [4, 15]
     Koordinatenursprung:       [0, 0]
     Fenstergröße:              [44, 110]
 
 
 Taste drücken -&gt; Ende

Zur Funktionsweise von curses siehe auch das Wikibook [[ncurses]]. Zum Verständnis sind dort allerdings elementare Kenntnisse in der Programmiersprache C erforderlich.

== Qt ==
{{Wikipedia | Qt (Bibliothek)}}

Auch für das Qt-Framework gibt es eine Anbindung an Python. Nachfolgend ein einfaches Beispiel.

 import sys
 from PySide6.QtWidgets import QApplication, QLabel
 
 app = QApplication(sys.argv)
 label = QLabel(&quot;Hallo Welt!&quot;)
 label.show()
 sys.exit(app.exec())

Ausgabe:

[[Datei:PythonIng_gui10.png]]

== Gtk ==
{{Wikipedia | GTK (Programmbibliothek)}}

Eine idente Ausgabe, wie oben für Qt gezeigt, erzeugt z.B. folgendes Gtk-Programm:

 import gi
 gi.require_version(&quot;Gtk&quot;, &quot;4.0&quot;)
 from gi.repository import Gtk
 
 def on_activate(app):
     win = Gtk.ApplicationWindow(application=app)
     lab = Gtk.Label(label=&quot;Hallo Welt!&quot;)
     win.set_child(lab)
     win.present()
 
 app = Gtk.Application()
 app.connect('activate', on_activate)
 app.run(None)

Auch für die Benutzung von Qt und Gtk müssen die jeweiligen Packages installiert sein. Getestet wurden die entsprechenden Python-Programme nur unter openSUSE Tumbleweed. Wie das GTK-Paket unter MS Windows 11 installiert wird, siehe z.B. [https://www.gtk.org/docs/installations/windows Setting up GTK for Windows].

Damit sei aber das Thema &quot;Benutzeroberflächen erstellen&quot; hier abgeschlossen, da dies schon ein sehr spezielles Aufgabengebiet ist, das eher Informatiker und nicht so sehr Ingenieure anspricht. Bei Bedarf siehe aber ggf. die entsprechenden Links unten in diesem Tutorial. Dort sind weiterführende Informationen zu finden.

= Pandas kurz erklärt =
Hier wird kurz auf das externe Modul Pandas eingegangen. Pandas steht für '''Pan'''el '''Da'''ta und ist ein Modul für die Datenanalyse und -manipulation.

== Series ==
Vorstellbar ist eine &quot;Series&quot; wie eine einzelne Spalte in einem Tabellenkalkulationsprogramm.

Beispiel (Index implizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5]) # Temperaturwerte
 print(temp)

Ausgabe:
 0     8.5
 1    11.0
 2    12.5
 3    10.0
 4    13.0
 5    11.0
 6    14.5
 dtype: float64

Das Kürzel &lt;code&gt;pd&lt;/code&gt; ist Konvention. Es seien Temperaturwerte gegeben. Die erste Spalte bei der Ausgabe ist der Index. Die zweite Spalte enthält die Werte.

Beispiel (separater Zugriff auf den Index und auf die Werte):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5])
 print(temp.index)
 print(temp.values)

Ausgabe:
 RangeIndex(start=0, stop=7, step=1)
 [ 8.5 11.  12.5 10.  13.  11.  14.5]

Beispiel (Index explizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 print(&quot;*** Die gesamte Series ***&quot;)
 print(temp)
 
 print(&quot;*** Temperatur am Donnerstag ***&quot;)
 print(temp[&quot;Do&quot;])
 
 print(&quot;*** Tage wärmer als 12 Grad ***&quot;)
 temp_gr_12 = temp[temp &gt; 12]
 print(temp_gr_12)

Ausgabe:
 *** Die gesamte Series ***
 Mo     8.5
 Di    11.0
 Mi    12.5
 Do    10.0
 Fr    13.0
 Sa    11.0
 So    14.5
 dtype: float64
 *** Temperatur am Donnerstag ***
 10.0
 *** Tage wärmer als 12 Grad ***
 Mi    12.5
 Fr    13.0
 So    14.5
 dtype: float64

== DataFrame ==
Ein DataFrame entspricht einer Tabelle.

Beispiel (Erzeugen eines DataFrames):
 import pandas as pd
 
 tag   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 v1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=tag)
 v2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=tag)
 v3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=tag)
 
 tab = pd.concat([v1, v2, v3], axis=1)
 tab.columns = stadt
 
 print(tab)
 print(type(tab))

Ausgabe:
     Linz  Salzburg Innsbruck
 Mo     1         8     Hallo
 Di     2         9        16
 Mi     3        10        17
 Do     4        11        18
 Fr     5        12        19
 Sa     6        13        20
 So     7        14        21
 &lt;class 'pandas.core.frame.DataFrame'&gt;

Wir haben hier drei Datenspalten (v1, v2, v3) mit den Spaltennamen &quot;Linz&quot;, &quot;Salzburg&quot; und &quot;Innsbruck&quot;, sowie sieben Zeilen &quot;Mo&quot; bis &quot;So&quot;.

Beispiel (Zugriff auf eine Spalte):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab[&quot;Salzburg&quot;])

Ausgabe:
 Mo     8
 Di     9
 Mi    10
 Do    11
 Fr    12
 Sa    13
 So    14
 Name: Salzburg, dtype: int64

Beispiel (Zugriff auf eine Zeile):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab.loc[&quot;Di&quot;])

Ausgabe:
 Linz          2
 Salzburg      9
 Innsbruck    16
 Name: Di, dtype: object

== Grafiken erstellen ==
Hier sei nur ein Torten- oder Kreisdiagramm gezeichnet:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 expl = [0, 0.2, 0, 0, 0, 0, 0]
 temp.plot.pie(figsize=(5,5), explode=expl)
 plt.show()

Ausgabe:

[[Datei:IngPython_pandas1.svg|350px]]

Die &lt;code&gt;figsize&lt;/code&gt; hat nichts mit der Spaltenanzahl zu tun, sondern setzt die Fenster- oder Diagrammgröße in Inches (Breite * Höhe).
 
Mit Pandas kann man auch noch andere Diagrammarten erstellen, z.B. Linien- oder Balkendiagramme. Dies wird hier aber nicht vorgeführt.

== Arbeiten mit CSV- und LibreOffice-Dateien ==
Gegeben sei eine CSV-Datei test1.csv:
 Mai;Juni;Juli
 12;17;45
 15;65;65
 16;32;23
 4;14;7
 23;17;Keine Daten verfügbar
 67;Keine Daten verfügbar;45
 15;24;12

Lesen von dieser CSV-Datei:
 import pandas as pd
 
 tab = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 print(tab)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Schreiben in eine CSV-Datei test2.csv:
 import pandas as pd
 
 val = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 val.to_csv(&quot;test2.csv&quot;, index=False)

Ausgabedatei:
 Mai,Juni,Juli
 12,17,45
 15,65,65
 16,32,23
 4,14,7
 23,17,Keine Daten verfügbar
 67,Keine Daten verfügbar,45
 15,24,12

Die Ausgabedatei ist beinahe gleich wie die Eingabedatei. Es werden aber Kommas statt Strichpunkten verwendet. Daher kommt auch der Name CSV ('''C'''omma '''S'''eparated '''V'''alue). Will man wieder Strichpunkte, so kann man dies über den Parameter &lt;code&gt;sep=&quot;;&quot;&lt;/code&gt; in der &lt;code&gt;to_csv&lt;/code&gt;-Funktion machen.

Um direkt von einer ODS-Datei (LibreOffice Calc, '''O'''pen '''D'''ocument '''S'''preadsheet) zu lesen muss das Modul odfpy extra installiert sein (per YaST, pip etc.). Gelesen wird dann folgendermaßen:
 import pandas as pd
 
 df = pd.read_excel('test1.ods', engine='odf')
 print(df)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Die Datei &quot;test1.ods&quot; sei die Datei, aus der das obige &quot;test1.csv&quot; generiert wurde. Schreiben kann man ebenfalls in eine ODS-Datei:

 import pandas as pd
 
 daten = {
     &quot;Name&quot;: [&quot;Hugo&quot;, &quot;Richie&quot;, &quot;Wilhelmine&quot;],
     &quot;Alter&quot;: [38, 30, 29],
     &quot;Ort&quot;: [&quot;Linz&quot;, &quot;Innsbruck&quot;, &quot;Salzburg&quot;]
 }
 
 tab = pd.DataFrame(daten)
 
 with pd.ExcelWriter(&quot;test2.ods&quot;, engine=&quot;odf&quot;) as writer:
     tab.to_excel(writer, sheet_name=&quot;Daten&quot;, index=False)

Es ergibt sich eine &quot;test2.ods&quot;-Datei (Screenshot):

[[Datei:IngPython_pandas2.png|250px]]

== Sonstiges ==
Hier seien stichpunktartig einige weitere Features von Pandas angeführt:
* {{W|Pivot-Tabelle|Pivot-Tabellen}} (pivot ... Dreh-, Angelpunkt): Zweck - große Datenmengen schnell zusammenfassen, filtern und analysieren.
* NaN ('''n'''ot '''a''' '''n'''umber): In einem Datensatz fehlt ein Wert oder ist nicht definiert.
* groupby-Funktion: Daten strukturieren, aggregieren oder Zwischensummen bilden. 
* {{W|Binning#Datenverarbeitung_und_-analyse|Binning}}: Klassenbildung.
* Mehrstufige Indizierung (Hierarchical Indexing oder MultiIndex).
* Zeitreihen (Time Series).
* MS Excel-Dateien schreiben mit dem Modul openpyxl.

Für tiefergehende und weiterführende Informationen wird auf das Buch von ''Klein: Numerisches Python; Hanser, 2023'' und [https://pandas.pydata.org/ pandas] verwiesen.

= Style Guide, flake8, pylint, Black etc. =
== Style Guide ==
Wie man schönen und richtigen Python-Code schreibt, erfahren Sie in
* [https://peps.python.org/pep-0008/ PEP 8 – Style Guide for Python Code]

== Formatter und Linter ==
Ein Modul, das prüft, ob die Richtlinien im Style Guide eingehalten wurden, ist ''flake8'':
* [https://flake8.pycqa.org/en/latest/ Flake8: Your Tool For Style Guide Enforcement]

Code formatieren kann man auch mit [https://pypi.org/project/black/ Black]. Z.B. übersetzt &lt;code&gt;black test1.py&lt;/code&gt; die Datei &lt;code&gt;test1.py&lt;/code&gt;

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)),
     (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

in 

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)), (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Die Programmausgabe ist 

 reformatted test1.py
 
 All done! ✨ 🍰 ✨
 1 file reformatted.

Der Unterschied zwischen Black und Flake8:
* Black ist ein Code-Formatter. Er formatiert Ihren Code um, sodass er im Einklang mit PEP 8 steht.
* Flake8 ist ein {{W|Lint (Programmierwerkzeug) | Code-Linter}}. Flake8 verändert Ihren Code nicht, sondern durchsucht ihn nach potenziellen Fehlern etc.

Am obigen Beispiel sieht man auch, dass flake8 und Black nicht immer einer Meinung sind. Flake8 (&lt;code&gt;flake8 test1.py&lt;/code&gt;) würde standardmäßig den mit Black formatierten Code bemängeln:

 test1.py:8:80: E501 line too long (80 &gt; 79 characters)

Diese Diskrepanz kann beseitigt werden. Da 79 Zeichen auf modernen Bildschirmen meist als zu kurz empfunden werden, ist ein Limit von 88 Zeichen (Black-Standard) oder mehr empfehlenswert. Um dies zu implementieren, erstellen Sie in Ihrem Projektverzeichnis eine &lt;code&gt;.flake8&lt;/code&gt;-Datei mit dem Inhalt

 [flake8]
 max-line-length = 88

Und schon ignoriert Flake8 dieses Problem.

Ein anderer Linter ist pylint. Der würde beim Abarbeiten des obigen Beispiels, z.B. mit &lt;code&gt;pylint test1.py&lt;/code&gt; noch eine Kleinigkeit bemängeln:

 ************* Module test1
 /home/hr/tmp/test1.py:1:0: C0114: Missing module docstring (missing-module-docstring)
 
 ------------------------------------------------------------------
 Your code has been rated at 8.57/10 (previous run: 8.57/10, +0.00)

Auch pylint muss vor der ersten Verwendung installiert werden (z.B. mittels pip, virtuelle Umgebung, YaST). Die Dokumentation zu pylint findet sich auf [https://pylint.readthedocs.io/en/latest/].

&lt;u&gt;Aufgabe:&lt;/u&gt; Fügen Sie einen &quot;module docstring&quot; in die &lt;code&gt;test1.py&lt;/code&gt;-Datei ein und testen Sie erneut mit flake8, Black und pylint. &lt;small&gt;Sehen Sie zum Thema docstrings auch [https://peps.python.org/pep-0257/#what-is-a-docstring PEP 257 – Docstring Conventions].&lt;/small&gt;

Es gibt noch weitere Formatierungswerkzeuge für Python-Code. Z.B. [https://docs.astral.sh/ruff/ Ruff], ein moderner Code-Formatter und -Linter. Mittels &lt;code&gt;ruff check test1.py&lt;/code&gt; würde obiger Code geprüft (Linter). &lt;code&gt;ruff format test1.py&lt;/code&gt; formatiert den Code (Formatter).

== Type Checker ==
&quot;Type Checker&quot; sind z.B.
* mypy
* pyright
* ty

Diese prüfen die Datentypen, z.B. in folgendem Code

 def greetings(name: str) -&gt; str:
     return &quot;Hello, %s&quot; % name
 
 
 print(greetings(42))

Python selbst, flake8, ruff oder black würden diesen Code ohne zu murren akzeptieren. &quot;Type Checker&quot; würden aber sehr wohl Alarm schlagen, z.B. liefert &lt;code&gt;mypy&lt;/code&gt; folgende Ausgabe

 test1.py:5: error: Argument 1 to &quot;greetings&quot; has incompatible type &quot;int&quot;; expected &quot;str&quot;  [arg-type]
 Found 1 error in 1 file (checked 1 source file)

Das funktioniert übrigens nicht nur bei Funktionsannotationen, sondern auch mit Variablen etc.

 from typing import Final
 
 # &quot;Konstante&quot;, ab Python 3.8
 NUMBER: Final = 123
 print(NUMBER)
 NUMBER = 125
 print(NUMBER)
 
 # Variable
 a: int = 345
 print(a)
 a = &quot;Irgendwas&quot;
 print(a)
 
 # Variable (Pipe-Symbol), ab Python 3.10
 b : int|str = 567
 print(b)
 b = &quot;sonstiges&quot;
 print(b)

Ausgabe mit python:
 123
 125
 345
 Irgendwas
 567
 sonstiges

Ausgabe mit mypy:
 test3.py:6: error: Cannot assign to final name &quot;NUMBER&quot;  [misc]
 test3.py:12: error: Incompatible types in assignment (expression has type &quot;str&quot;, variable has type &quot;int&quot;)  [assignment]
 Found 2 errors in 1 file (checked 1 source file)

Python kennt übrigens keine Konstanten. Man kann diese mittels Großbuchstaben andeuten. Das ist aber nur Konvention, hat aber keine sonstigen Auswirkungen. Oder man verwendet wie oben gezeigt &lt;code&gt;Final&lt;/code&gt;. Dann werfen Typchecker Errors aus.

==pydoc==
pydoc ist ein Werkzeug, um Python-Module, -Funktionen und -Klassen zu dokumentieren.

Beispiel &lt;code&gt;test1.py&lt;/code&gt;:
 &quot;&quot;&quot;Rechen-Modul.
 
 Funktionen die von pydoc gelesen werden.
 &quot;&quot;&quot;
 
 def multiply(a, b):
     &quot;&quot;&quot;Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
     
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a * b
     
 def add(a, b):
     &quot;&quot;&quot;Addiert zwei Zahlen und gibt das Ergebnis zurück.
    
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a + b
    
 
 if __name__ == '__main__':
     print(multiply(3, 5))
     print(add(4, 6))

Ausgabe mit &lt;code&gt;python3.13 -m pydoc test1&lt;/code&gt; auf der Konsole:

 Help on module test1:
 
 NAME
     test1 - Rechen-Modul. 
 
 DESCRIPTION
     Funktionen die von pydoc gelesen werden.
 
 FUNCTIONS
     add(a, b)
         Addiert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
     multiply(a, b)
         Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
 FILE
     /home/xyz/tmp/test1.py

Siehe zu diesem Thema z.B. auch [https://docs.python.org/3/library/pydoc.html]. Mittels &lt;code&gt;python3.13 -m pydoc -w test1&lt;/code&gt; kann man auch eine HTML-Dokumentation erstellen.

Wofür &lt;code&gt;if __name__ == '__main__':&lt;/code&gt; steht, siehe z.B. etwas später im Abschnitt [[Ing_Mathematik:_Python#Doctests]].

== Sonstige Tools ==
Andere Tools für die {{W|Statische Code-Analyse|statische Codeanalyse}}, die aber für Ingenieure weniger interessant sein dürften, sind z.B.
* Radon: Liefert verschiedene {{W|Softwaremetrik|Codemetriken}} (Komplexität, Wartbarkeitsindex ...)
* Bandit: Findet Sicherheitslücken

Tools für die {{W|Dynamisches Software-Testverfahren|dynamische Codeanalyse}}, z.B.:
* DynaPyt (Framework zur dynamischen Programmanalyse)
* cProfile (Profiler)
* Memory Profiler (Speicheranalyse)
* Memray (Speicheranalyse)
* tracemalloc (Speicheranalyse)

Paket- und Projektmanagement (pip-Ersatz etc.):
* uv
* Poetry
* Conda
* pipx

Packaging-Tools (Freezer) und {{W|Compiler#Sonderformen|Transpiler}} :
* pyinstaller
** erstellt eigenständige, ausführbare Binärdatei
** kein Cross-Compiler
** kein Schutz vor Reverse-Engineering
** langsam
** packt alles in eine Datei
** sehr große Datei
** Befehl, z.B.: &lt;code&gt;pyinstaller --onefile test1.py&lt;/code&gt;
** GUI: &lt;code&gt;auto-py-to-exe&lt;/code&gt;
* cx_Freeze
* nuitka
** Übersetzt Python-Code in C/C++-Code und weiter in eine ausführbare Datei
** kein Cross-Compiler
** Schutz vor Reverse-Engineering
** Befehl, z.B.: &lt;code&gt;nuitka --standalone --onefile test1.py&lt;/code&gt;
* cython

= Einige Integrierte Entwicklungsumgebungen (IDEs)=
Werden Programmtexte größer und umfangreicher, so ist das Arbeiten mit der interaktiven Programmierumgebung bzw. das direkte Ausführen von Python-Skripten mühsam. Man wünscht sich z.B. Hilfen zum Debuggen oder die automatische Code-Vervollständigung. Zu diesem Zweck wurden IDEs (Integrated Development Environments) geschaffen. Von diesen seinen nachfolgend auszugsweise einige kurz beschrieben. Testen Sie einfach aus, welche davon für Sie bzw. für Ihr Python-Projekt geeignet sind.

== IDLE ==
IDLE ist die mit dem Python-Programmpaket mitgelieferte IDE. Der Name leitet sich einerseits ab vom Monty-Python-Mitglied Eric Idle, andererseits steht es als Abkürzung für &quot;'''I'''ntegrated '''D'''evelopment and '''L'''earning '''E'''nvironment. IDLE ist einfach zu bedienen, bietet aber schon einen beachtlichen Leistungsumfang. Nachfolgend wird ein Screenshot zu IDLE geliefert. Rechts ist das Editor-Fenster zu sehen, links die interaktive Programmierumgebung. Um das Beispiel selbst nachvollziehen zu können, starten Sie IDLE. Das geht ähnlich, wie Sie die interaktive Programmierumgebung von Python starten (nur, dass Sie eben das IDLE-Icon doppelklicken und nicht das Python-Icon. Unter Linux geben Sie einfach in einem Terminal &lt;code&gt;idle3.13&lt;/code&gt; o. Ä. ein). Weiter geht es mit &quot;File - Open - ...&quot;. Die auszuführende Datei auswählen (im konkreten Fall ein &quot;Hallo-Welt&quot;-Programm). Es erscheint das rechte Fenster. Dort &quot;Run - Run Module&quot; auswählen. Und schon wird im linken Fenster &quot;Hallo Welt!&quot; ausgegeben.

[[Datei:PythonIng_idle1.jpg | 600px]]

Siehe auch {{W|IDLE}}.

== PyCharm ==
PyCharm ist ein kommerzielles Produkt. Es gab aber auch eine kostenlose Community Edition. Seit 2025 sind beide Varianten vereint. Für die ersten 30 Tage sind die Pro-Funktionen frei verfügbar, danach nur noch die Kernfunktionalitäten (oder man bezieht kostenpflichtig  die Pro-Version). Zu beziehen ist PyCharm unter dem Weblink [https://www.jetbrains.com/pycharm/]. Nachfolgend ein etwas abgewandeltes &quot;Hallo Welt&quot;-Programm, editiert und ausgeführt mit PyCharm.

[[Datei:PyCharm_IDE_2023_screenshot.png | 600px]]

Siehe auch {{W|PyCharm}}.

== Eric ==
Auch eric ist Open Source und steht unter der  GNU General Public License Version 3 oder später. Zu beziehen ist diese Software unter [https://eric-ide.python-projects.org/].

[[Datei:Screenshot_Eric_4.png | 600px]]

Siehe auch {{W|eric (Software)}}.

&lt;small&gt;
Unter openSUSE Tumbleweed sollte sich eric auch mit YaST installieren lassen. Bei mir gibt es aber dann beim Ausführen des eric-Programms eine Fehlermeldung (Stand März 2026): 
 
 ...
 ModuleNotFoundError: No module named 'PyQt6.QtPdfWidgets'

Umgehen kann man dieses Problem aber wieder mit dem Erstellen einer virtuellen Umgebung, in etwa so

 python3.13 -m venv ~/tmp/venv1
 cd ~/tmp/venv1/bin
 ./python3.13 -m pip install --upgrade --prefer-binary eric-ide
 ./eric7_ide
&lt;/small&gt;

== PyScripter ==
Vom Funktionsumfang vergleichbar mit den vorherigen IDEs ist PyScripter. Auch PyScripter ist Open Source. Die Projekt-Homepage findet sich auf [https://sourceforge.net/projects/pyscripter/]. PyScripter ist nur für MS Windows verfügbar.

[[Datei:PythonIng_pyscripter1.jpg | 600px]]

== Spyder IDE ==
Spyder enthält bereits eine stabile Python-Version und etliche Module (z.B. matplotlib, numpy, control). Ansonsten kann dieses Softwarepaket vom Funktionsumfang her mit den anderen genannten IDEs locker mithalten. Spyder wurde unter der MIT-Lizenz veröffentlicht. Diese Software findet sich auf [https://www.spyder-ide.org].

[[Datei:Spyder-windows-screenshot.png | 600px]]

Siehe auch {{W|Spyder (Software)}}

== Eclipse IDE==
Die {{W|Eclipse_(IDE)|Eclipse-IDE}} kann für Python aufgerüstet werden. Dazu gibt es das PyDev-Plugin. Installiert wird es über 
* Help &gt; Eclipse Marketplace... 
* Find - PyDev - Install
Danach muss noch der Pfad zum Python-Interpreter festgelegt werden 
* Window &gt; Preferences &gt; PyDev &gt; Interpreters &gt; Python Interpreter &gt; New ... 
Das Ergebnis ist ähnlich wie im folgenden Bild, nur dass statt C/C++ Python Verwendung findet. 

[[Datei:Setting Up Eclipse CDT helloout.png | 600px]]

== Sonstige ==
Die genannten IDEs sind nicht die Einzigen. Es gibt, um dem Image Pythons als beliebteste Programmiersprache gerecht zu werden, noch einige andere. Sowohl Open Source-Programme als auch kommerzielle Programme sind im Web zu finden, z.B. Thonny oder {{W|Visual Studio Code}}. Unter Linux kann man auch {{W|KDevelop}}, ausgestattet mit dem Python3-Plugin, einsetzen. Braucht man den Umfang von ausgewachsenen IDEs nicht, so kann man auch normale Texteditoren verwenden (z.B. {{W|Geany}} oder {{W|Kate_(Texteditor)|Kate}}).

= Debuggen und Testen =
Das Debuggen und Testen von Programmen sind wichtige Bestandteile der Programmierung. Syntaxfehler lassen sich i.A. leicht beheben. Schwieriger ist das Eingrenzen von logischen Fehlern, die ev. nur in bestimmten Situationen auftreten und keine explizite Fehlermeldung hervorrufen. Das Programm liefert falsche Ergebnisse oder es stürzt aus heiterem Himmel ab. Um das zu verhindern gibt es verschiedene Werkzeuge, die bei der Fehlersuche behilflich sein können. Vorerst siehe aber zwecks Begriffsklärung noch folgende Links: 
 
* {{W|Debuggen}}
* {{W|Debugger}}
* {{W|Softwaretest}}

&lt;gallery&gt;
First Computer Bug, 1947.jpg
Test ganzheitlich.png
V-Modell.svg
&lt;/gallery&gt;

== Das Modul pdb ==
Python bringt schon ein Modul zum Debuggen mit. Siehe z.B. [https://docs.python.org/3/library/pdb.html pdb — The Python Debugger].
Komfortabler lässt sich das aber mittels Integrierter Entwicklungsumgebungen (IDEs) angehen.

== Debuggen mit IDEs ==
Für die IDEs IDLE und Spyder sei kurz auf die entsprechenden Webseiten verwiesen:

* [https://www.cs.uky.edu/~keen/help/debug-tutorial/debug.html Debugging under IDLE].
* [https://docs.spyder-ide.org/current/panes/debugging.html Spyder Debugger]

Dort wird die Vorgehensweise auch mittels Screenshots erläutert.

== assert ==
assert ... behaupten, zusichern ({{W|Assertion (Informatik)}})

Python-Code:
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10., 0.)

Ausgabe:

 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10., 0.)
   File &quot;/home/hr/Develop/test1.py&quot;, line 4, in print1
     assert y != 0.0
            ^^^^^^^^
 AssertionError
 
Python-Code: 
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)
 
Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(&quot;10.&quot;, &quot;5.&quot;)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError
 
Aber auch bei nachfolgendem Code gibt es eine Fehlermeldung:

 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10, 5)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError

Damit letzteres funktioniert, kann man den Programmcode so umschreiben:
 def print1(x, y):
     assert type(x) == float or type(x) == int
     assert type(y) == float or type(y) == int
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 2.0
 
Und jetzt fangen wir den &lt;code&gt;AssertionError&lt;/code&gt; auf:
 def print1(x, y):
     try:
         assert type(x) == float or type(x) == int
         assert type(y) == float or type(y) == int
         assert y != 0.0
         print(x/y)
     except(AssertionError):
         print(&quot;Hallo&quot;)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)

Ausgabe:
 2.0
 Hallo

Ich hoffe, es ist wenigstens im Ansatz klar geworden, wofür &lt;code&gt;assert&lt;/code&gt; gut sein kann. Ausschalten kann man die &lt;code&gt;assert&lt;/code&gt;-Überprüfung übrigens mit dem Python-Schalter &lt;code&gt;-O&lt;/code&gt;.

== Doctests == 
Innerhalb eines Docstrings kann die Arbeit im interaktiven Modus simuliert werden. Nach den Promptzeichen (&gt;&gt;&gt;) erfolgen dann bei unserem Beispiel innerhalb des Docstrings simulierte Aufrufe der Funktion &lt;code&gt;print1()&lt;/code&gt;. Danach folgen jeweils die Sollresultate. Wird das Modul oder die Datei als Hauptprogramm aufgerufen, so wird die Funktion &lt;code&gt;doctest.testmode()&lt;/code&gt; aufgerufen und ein Bericht auf der Konsole ausgegeben. Wird das Modul nicht als Hauptprogramm aufgerufen, sondern importiert, dann wird diese &lt;code&gt;testmod&lt;/code&gt;-Funktion nicht aufgerufen. D.h. dieser Code kann sowohl für Testzwecke als auch für den produktiven Einsatz verwendet werden. Das ist auch sinnvoll, weil wenn man Teile der Datei immer löschen bzw. einfügen müsste, so würden sich Fehlerquellen auftun. Das würde den Sinn und Zweck von Doctests konterkarieren.  

 def print1(x=0., y=1.):
     &quot;&quot;&quot; Dividiere zwei Zahlen
     Autor: Intruder
     Datum: 12.08.2025
 
     &gt;&gt;&gt; print1(2., 1.)
     2.0
     &gt;&gt;&gt; print1(5., 2.)
     2.5
     &gt;&gt;&gt; print1(5.)
     5.0
     &quot;&quot;&quot;
     print(x/y)
 
 if __name__ == &quot;__main__&quot;:
     import doctest
     doctest.testmod(verbose=True)

Ausgabe:
 Trying:
     print1(2., 1.)
 Expecting:
     2.0
 ok
 Trying:
     print1(5., 2)
 Expecting:
     2.5
 ok
 Trying:
     print1(5.)
 Expecting:
     5.0
 ok
 1 items had no tests:
     __main__
 1 items passed all tests:
    3 tests in __main__.print1
 3 tests in 2 items.
 3 passed and 0 failed.
 Test passed.

Das gezeigte Beispiel ist so ziemlich das einfachste, das es gibt. Für weiterführende Details siehe z.B.:
* [https://peps.python.org/pep-0257/ PEP 257 – Docstring Conventions]
* [https://docs.python.org/3/library/doctest.html doctest — Test interactive Python examples]

''Einschub:'' Ganz ähnlich kann man auch Klassen testen, z.B. in folgendem Code-Fragment

 class Fahrzeug:
   # siehe Abschnitt &quot;Objektorientierte Programmierung&quot;
   # ...
 
 if __name__ == &quot;__main__&quot;:
   vauweh = Fahrzeug(170, 90)
   beemweh = Fahrzeug(200, 120)
   print(vauweh.convertGeschw())
   print(beemweh.convertGeschw())

Wird das Script als Hauptprogramm ausgeführt (z.B. zu Testzwecken), so erfolgt die Ausgabe der zwei, via &lt;code&gt;convertGeschw()&lt;/code&gt;, umgerechneten Geschwindigkeiten. Wird es aber als Modul eingebunden, so wird der letzte Programmabschnitt nicht ausgeführt (&lt;code&gt;__name__ == &quot;__main__&quot;&lt;/code&gt; ergibt &lt;code&gt;False&lt;/code&gt;).

== pytest ==
Siehe zu diesem Thema auch {{W|Modultest}}.

pytest ist ein externes Modul und muss vorab installiert werden, z.B. mittels 
 pip install -U pytest
 pip install -U pytest-html 

Python-Code, Datei test1.py:
 def add(x, y):
     return x + y
 
 def test_answer():
     assert add(1, 1) == 3

Starten von pytest in der Konsole:
 pytest test1.py
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py F                                                                                                            [100%]
 
 ========================================================= FAILURES ==========================================================
 ________________________________________________________ test_answer ________________________________________________________
 
     def test_answer():
 &gt;       assert add(1, 1) == 3
 E       assert 2 == 3
 E        +  where 2 = add(1, 1)
 
 test1.py:6: AssertionError
 ================================================== short test summary info ==================================================
 FAILED test1.py::test_answer - assert 2 == 3
 ===================================================== 1 failed in 0.09s =====================================================

Hier erhalten wir einen Fehler, da 1+1 eindeutig ungleich 3 ist. Aber aus irgendeinem Grund wollte der Programmierer oder Tester in diesem Fall, dass dies so ist. Testfälle werden übrigens mit dem Präfix &lt;code&gt;test_&lt;/code&gt; eingeleitet.

Python-Code:
 def add(x, y):
     return x + y + 1
 
 def test_answer():
     assert add(1, 1) == 3 
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py .                                                                                                            [100%]
 
 ===================================================== 1 passed in 0.01s =====================================================

Jetzt ist alles in Ordnung. Weiterführendes siehe z.B.

* [https://docs.pytest.org/en/stable/ pytest: helps you write better programs]

== unittest ==
Auch unittest dient zur Durchführung von Testreihen, ist aber Bestandteil von Python. Hier wird vorerst nicht näher darauf eingegangen. Siehe z.B. 
* [https://docs.python.org/3/library/unittest.html unittest — Unit testing framework]

Lt. ''Inden: Python Challenge; dpunkt, 2021, Seite 481''  soll unittest weniger komfortabel als pytest sein.

Einen Vergleich von unittest mit pytest findet man in
* [https://knapsackpro.com/testing_frameworks/difference_between/pytest/vs/unittest pytest vs unittest]

= Python und Anwendungsprogramme =
Bisher stand immer alleine die Programmiersprache Python (ev. unter Einbeziehung von Modulen) im Mittelpunkt der Betrachtungen. Aber Python kann auch als Makrosprache für Anwendungsprogramme auftreten. Als Beispiele seien {{W|FreeCAD}} und {{W|LibreOffice}} genannt.

== FreeCAD ==
FreeCAD ist ein freies 3D-CAD-Programm. Hier soll nicht auf die Bedienung dieses CAD-Pakets eingegangen werden, sondern nur auf die Möglichkeit, mittels Python Makros zu schreiben. Als einfacher Einstieg soll ein Makro erstellt werden, welches eine Kugel (rot) und einen Quader (blau) zeichnet. Folgende Vorbereitungsschritte sind erforderlich (es sei vorausgesetzt, dass FreeCAD schon am Rechner installiert ist. Downloaden können Sie das Programm von der Website [https://www.freecad.org/downloads.php?lang=en]):

* FreeCAD starten
* Leere Datei erstellen
* Makro &gt; Makros &gt; Erstellen ...

Es öffnet sich ein leeres Editorfenster, in das Sie folgenden Code eingeben können:

 import FreeCAD
 import Part
 
 doc = FreeCAD.newDocument()
 
 # Kugel
 kugel = Part.makeSphere(10)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Kugel&quot;)
 form_element.Shape = kugel
 kug = FreeCAD.ActiveDocument.getObject(&quot;Kugel&quot;)
 kug.ViewObject.ShapeColor = (1.0, 0.0, 0.0)
 neuePosition = App.Vector(5, 2.5, 2.5)
 kug.Placement = App.Placement(neuePosition, kug.Placement.Rotation)
 
 # Quader
 quader = Part.makeBox(5, 5, 50)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Quader&quot;)
 form_element.Shape = quader
 quad = FreeCAD.ActiveDocument.getObject(&quot;Quader&quot;)
 quad.ViewObject.ShapeColor = (0.0, 0.0, 1.0)
 
 doc.recompute()

Diesen Code können Sie nun ausführen:
* Makro &gt; Makro ausführen

Es ergibt sich folgende Ausgabe (gedreht und gezoomt):

[[Datei: PythonIng_freecad1.png|500px]]

Siehe auch [https://wiki.freecad.org/Python_scripting_tutorial/de# Anleitung Skripterstellung mit Python]. Getestet wurde obiges Beispiel mit FreeCAD 1.1.3 unter Linux und 1.1.1 unter MS Windows.

== LibreOffice ==
LibreOffice ist ein freies Officepaket ([https://de.libreoffice.org/]). Hier soll nur das Tabellenkalkulationsprogramm Calc kurz betrachtet werden. Es seinen in den ersten 3 Zellen (A1 bis A3) Zahlen gegeben. Diese sollen mit einem Python-Makro addiert und das Resultat in der Zelle A5 ausgegeben werden. Auch hier sind Vorbereitungsarbeiten nötig: 
* zuerst muss unter Linux das Verzeichnis &lt;code&gt;~/.config/libreoffice/4/user/Scripts/python&lt;/code&gt; erstellt werden
* für MS Windows ist es das Verzeichnis &lt;code&gt;%APPDATA%\LibreOffice\4\user\Scripts\python&lt;/code&gt; 
** drücken Sie zuerst Win + R (es öffnet sich das Ausführen-Fenster)
** geben Sie &lt;code&gt;%appdata%&lt;/code&gt; ein, danach drücken Sie Enter (es öffnet sich der Explorer)
** navigieren Sie zu dem genannten Verzeichnis bzw. erstellen Sie das Verzeichnis 
* in diesem Verzeichnis wird dann mit einem beliebigen Texteditor das Python-Makro erstellt, in unserem Fall die Datei &lt;code&gt;summiere_zellen.py&lt;/code&gt;:

 import uno
 
 def summiere_zellen(*args):
     # Zugriff auf das aktuelle Dokument und das aktive Tabellenblatt
     ctx = uno.getComponentContext()
     smgr = ctx.getServiceManager()
     desktop = smgr.createInstanceWithContext(&quot;com.sun.star.frame.Desktop&quot;, ctx)
     doc = desktop.getCurrentComponent()
     sheet = doc.getCurrentController().getActiveSheet()
 
     # Werte aus den Zellen A1 bis A3 auslesen
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
 
     # Addition der drei Werte
     summe = w1 + w2 + w3
 
     # Ergebnis in die Zelle A5 schreiben
     sheet.getCellRangeByName(&quot;A5&quot;).Value = summe

* siehe dazu ggf. auch [https://help.libreoffice.org/latest/de/text/sbasic/python/python_locations.html?DbPAR=BASIC].

Weiter geht es in LibreOffice Calc mit dem Menü ''Extras &gt; Makros &gt; Makros verwalten &gt; Python''. Dort wird das Makro &lt;code&gt;summiere_zellen&lt;/code&gt; ausgeführt. Es ergibt sich z.B. folgendes Resultat

[[Datei:PythonIng_libreoffice1.png]]

Das Kürzel &lt;code&gt;uno&lt;/code&gt; steht für '''U'''niversal '''N'''etwork '''O'''bjects. Etwas einfacher geht's auch so:

 def summiere_zellen():
     desktop = XSCRIPTCONTEXT.getDesktop()
     model = desktop.getCurrentComponent()
     sheets = model.getSheets()
     sheet = sheets.getByIndex(0)
     
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
     
     cell = sheet.getCellRangeByName(&quot;A5&quot;)    
     cell.setValue(w1 + w2 + w3) 

Empfohlen wird auch, das Erweiterungspaket APSO ('''A'''lternative '''P'''ython '''S'''cript '''O'''rganizer, apso.oxt) zu installieren. Die Vorgehensweise wird hier nicht gezeigt, sondern nur darauf hingewiesen, dass man das einfach &quot;googeln&quot; kann. Siehe zur Python-Programmierung für LibreOffice auch [https://wiki.documentfoundation.org/Macros/Python_Guide/de Makros/Python-Handbuch]. Getestet wurden obige Beispiele mit LibreOffice 26.2.5.1 unter Linux und 26.2.1.2 unter MS Windows.

= Ausblick =
Dies war eine kurze Einführung in die Berechnungs- und Darstellungsmöglichkeiten mit Python. Es sollten etliche relevante Themen behandelt, oder zumindest kurz angesprochen worden sein. Wem dieser Text nicht ausreichend ist, der sei auf die entsprechenden weiterführenden Weblinks, Bücher und die Python-Hilfefunktion verwiesen. Python kennt noch viel mehr Befehle, als hier dargestellt wurden. Das Themenspektrum ist auch durch die Einbindung externer Module fast beliebig erweiterbar.

= Weblinks=
== Python allgemein ==
* [https://www.python.org/ Python Homepage]

== Externe mathematische Module ==
* [https://numpy.org/ NumPy]
* [https://numpy.org/doc/stable/user/numpy-for-matlab-users.html NumPy for MATLAB users]
* [https://scipy.org/ SciPy]
* [https://www.sympy.org/en/index.html SymPy]
* [https://pandas.pydata.org/ pandas]
* [https://github.com/maroba/findiff findiff]
* [https://mpmath.org/ mpmath]

== Externe Module für Grafiken ==
* [https://matplotlib.org/ Matplotlib]
* [https://vpython.org/ VPython]
* [https://build123d.readthedocs.io/en/latest/ build123d]
* [https://docs.vtk.org/en/latest/api/python.html VTK]
* [https://docs.bokeh.org/en/latest/docs/first_steps.html bokeh]
* [https://py5coding.org/ py5]

== Erstellung von User Interfaces ==
* [https://docs.python.org/3/library/tkinter.html tkinter - Python interface to Tcl/Tk]
* [https://docs.python.org/3/library/curses.html curses - Terminal handling for character-cell displays]
* [https://wiki.qt.io/Qt_for_Python Qt for Python]
* [https://www.gtk.org/docs/language-bindings/python GTK and Python]

== Erstellen virtueller Umgebungen ==
* [https://docs.python.org/3/library/venv.html venv - Creation of virtual environments]

== Sonstige ==
* [https://python-control.readthedocs.io/en/stable/ Python Control Systems Library]
* [https://pypi.org/project/regex/ regex - Regular Expressions]
* [http://pyromat.org/ PYroMat]
* [https://coolprop.org/coolprop/wrappers/Python/index.html CoolProp]
* [https://pypi.org/project/iapws/ iapws]
* [https://tespy.readthedocs.io/en/main/getting_started/introduction.html TESPy - Thermal Engineering Systems in Python]
* [https://pint.readthedocs.io/en/stable/ pint]

= Bücher =
== Gedruckte Bücher, OpenBooks, Magazine ==
* Diverse: c't Python Lernen, Verstehen, Anwenden; Heise, 2022 
* Ernesti, Kaiser: Python3 - das umfassende Handbuch; 5. Aufl., Rheinwerk, [https://openbook.rheinwerk-verlag.de/python/ OpenBook]
* Iacono et al.: Programmieren trainieren; 3. Aufl., Hanser, 2023, ISBN 978-3-446-47766-7
* Inden: Python Challenge; dpunkt, 2021, ISBN 978-3-86490-809-5
* Klein: Numerisches Python; 2. Aufl., Hanser, 2023, ISBN 978-3-446-47170-2 
* Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler; Rheinwerk, 2021, ISBN 978-3-8362-7316-9
* Weigend: Python 3 - Das umfassende Praxisbuch; 9. Aufl., mitp, 2022, ISBN 978-3-7475-0544-1
* Woyand: Python für Ingenieure und Naturwissenschaftler; 4. Aufl., Hanser, 2021, ISBN 978-3-446-46483-4

== Andere Wikibooks ==
* [[:en:Subject:Python_programming_language | Englische Wikibooks zum Thema Python]]
* [[Python|Deutschsprachiges Python-Wikibook]] [[Bild:2von10.png|20%]]
* [[Python unter Linux|Python 2.7 unter Linux]] [[Bild:10von10.png|100%]]


{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}</text>
      <sha1>l51xf8ntl9n2tk7ikdpifo0u74rm6kq</sha1>
    </revision>
    <revision>
      <id>1092184</id>
      <parentid>1092183</parentid>
      <timestamp>2026-10-17T10:18:49Z</timestamp>
      <contributor>
        <username>Intruder</username>
        <id>1513</id>
      </contributor>
      <minor />
      <comment>/* Bokeh */</comment>
      <origin>1092184</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="191480" sha1="i03351cd9pjxr9e1cpatel15kjsmgvs" xml:space="preserve">{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}


= Hallo Welt und allgemeine Hinweise =
== Was ist Python ==
* Python ist eine universelle höhere Programmiersprache.
* Python ist objektorientiert.
* Python ist Open-Source (Python Software Foundation License).
* Python ist für viele Betriebssysteme erhältlich (z.B. für Linux, MS Windows, macOS).
* Python ist ein Interpreter.
* Python ist durch Module fast beliebig erweiterbar.
* Python als Programmiersprache ist case-sensitive - d.h. Groß- und Kleinschreibung ist relevant bei der Eingabe von Befehlen.
* Python ist in etlichen Anwendungsprogrammen (z.B. {{W|FreeCAD}}, {{W|LibreOffice}}, {{W|GIMP}}, {{W|Blender (Software) | Blender}}) als Makrosprache verwendbar.

{{Wikipedia | Python (Programmiersprache)}}

== Python installieren ==
=== MS Windows ===
Laden Sie das aktuelle Python-Paket von der Webseite [https://www.python.org/] herunter. Weiter geht es wie bei jedem anderen größeren zu installierenden Programm. Einfach das Installationsprogramm im Explorer doppelklicken und den Anweisungen des Setup-Programmes folgen.

=== Linux ===
Entweder ist Python bereits standardmäßig installiert, ansonsten ist die Installation mittels Paketmanagementsystem einfach möglich. Aber auch die Spyder-Entwicklungsumgebung ([https://www.spyder-ide.org]) bietet einen guten Einstieg mit Python (das gilt auch für MS Windows). Spyder bringt auch schon etliche wichtige Module standardmäßig mit.

== Python starten ==
=== MS Windows ===
Das Icon für das Python-Programm doppelklicken. Und schon startet das Programm.

[[Datei:PythonIng_start1.jpg]]

Python im interaktiven Modus (REPL ... '''R'''ead-'''E'''valuate-'''P'''rint-'''L'''oop) präsentiert sich dann so:

 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

Alternativ kann das Programm auch über die Eingabeaufforderung oder die PowerShell gestartet werden:

 c:\devel\Python&gt;python.exe
 Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun  6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt;

=== Linux ===
Tippen Sie einfach das Wort „python“ (oder unter openSUSE Tumbleweed z.B. auch „python3.11“ oder „python3.13“) in einem Linux-Terminal ein, schließen den Befehl mit der RETURN-Taste ab, und schon startet Python im interaktiven Modus:
 
 Python 3.13.12 (main, Feb 09 2026, 22:37:44) [GCC] on linux
 Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
 &gt;&gt;&gt; 

Es gibt auch noch andere Möglichkeiten Python zwecks Programmausführung zu starten, z.&amp;nbsp;B. den {{W|Shebang}} (&lt;code&gt;#!&lt;/code&gt;) am Beginn eines Python-Scripts. Das Script sei als Script.py gespeichert. Dann kann das Script mit ./Script.py ausgeführt werden. Für openSUSE Tumbleweed sei nachfolgend ein lauffähiges &quot;Hallo Welt!&quot;-Script angegeben. Es wird in diesem Script der Python-Interpreter in der Version 3.13 verwendet :

 #!/usr/bin/python3.13
 print(&quot;Hallo Welt!&quot;)

Die Berechtigungen zum Ausführen der Datei müssen natürlich noch richtig gesetzt werden, z.B. mittels &lt;code&gt;chmod 777 Script.py&lt;/code&gt;. &lt;small&gt;&lt;code&gt;chmod&lt;/code&gt; ist die Abkürzung für&quot;'''ch'''ange file '''mod'''e bits&quot;.&lt;/small&gt; 

&lt;small&gt;Die &quot;Maske&quot; &lt;code&gt;777&lt;/code&gt; ist nur für Testzwecke sinnvoll, weil sie leicht zu merken ist und für alle Benutzer alle Zugriffsberechtigungen ('''r'''ead/'''w'''rite/e'''x'''ecute für owner/group/others) setzt. Im richtigen Einsatz wird man das aus Sicherheitsgründen nicht so handhaben, sondern nur die Berechtigungen setzen, die unbedingt erforderlich sind. Welche Zugriffsberechtigungen gesetzt sind, kann man z.B. mit dem Befehl &lt;code&gt;ls -l&lt;/code&gt; oder &lt;code&gt;ll&lt;/code&gt; ('''l'''i'''s'''t directory contents) erfragen. Aber dazu im Moment genug. Erfahrene Linux-Nutzer kennen das ohnehin und Anfänger sollen jetzt nicht mit Linux-Interna überfordert werden. Bei Bedarf siehe die Linux-Man-Pages oder dezidierte Bücher zu Linux.&lt;/code&gt;&lt;/small&gt;

&lt;small&gt;Oder das Script wird in einen Pfad verschoben, in dem sich ausführbare Programme generell befinden (welche Verzeichnisse im PATH liegen, kann bspw. mit &lt;code&gt;echo $PATH&lt;/code&gt; abgefragt werden). Das Script kann dann wie ein normales Programm ohne weitere Angaben mit Script.py gestartet werden. Alternativ wird nicht das Script an sich verschoben, sondern nur ein symbolischer Link angelegt, z.B. mit &lt;code&gt;ln -s ~/tmp/Script.py ~/.local/bin/Script.py&lt;/code&gt;. &lt;code&gt;~/.local/bin&lt;/code&gt; sei ein im PATH gelegenes Verzeichnis. Dies sind aber schon Features für fortgeschrittene Linux-Benutzer und werden am Anfang eher selten benötigt.&lt;/small&gt;

== Ein paar Worte zur Erklärung ==
=== Tests ===
Getestet wurden die Beispiele unter den Betriebssystemen 
* MS Windows 10 mit der Python-Version 3.12.0 (teilweise auch mit 3.12.2 und 3.13.1; nur die Inhalte die bis spätestens Juli 2025 erstellt wurden) 
* MS Windows 11 ab der Python-Version 3.13.4 (nur zum Teil; ab Juli 2025)
* openSUSE Leap 15.6 mit der Python-Version 3.11.12 (Spyder, nur vereinzelt) und zum Teil mit 3.12.11 (ab Juli 2025 bis November 2025).
* openSUSE Tumbleweed ab der Python-Version 3.13.9 (nur vereinzelt, ab November 2025)

=== Popularität ===
* An Beliebtheit rangiert Python mit Stand September 2026 mit einem Rating von 17,76% an 1. Stelle vor C und C++ (lt. [https://www.tiobe.com/tiobe-index/ TPCI - TIOBE Programming Community Index]). 
* Lt. [https://innovationgraph.github.com/global-metrics/programming-languages GitHub Top 50 Programming Languages Globally] lag Python im Q1/2026 auf Rang 2, vor TypeScript und hinter JavaScript. 
* [https://pypl.github.io/PYPL.html PYPL] (Popularity of Programming Language Index) ist ein anderer Popularitätsindex für Programmiersprachen. Auch hier liegt Python mit großem Vorsprung auf dem ersten Platz (52,08%), gefolgt von Java (13,34%) und C/C++ (7,99%) (Stand September 2026). 

=== Namensgebung ===
Der Name &quot;Python&quot; rührt von der Komikertruppe {{W|Monty Python}} her. Die Icons für Python (z.B. Python selbst, Eric IDE, IDLE) sind aber durch die Python-Schlangenart symbolisiert.

&lt;gallery&gt;
Python-logo-notext.svg|Python-Logo
Guido van Rossum in PyConUS24.jpg|{{W|Guido van Rossum}} (geb. 1956), der Erfinder von Python
&lt;/gallery&gt;

== Ein erstes Programm ==
Kommentare werden in Python mit der Raute (#) eingeleitet. Sie werden vom Python-Interpreter ignoriert. Text kann mit der print-Funktion ausgegeben werden. Starten Sie Python und geben sie folgende Anweisungen zeilenweise ein

 &gt;&gt;&gt; # Das ist ein Kommentar
 &gt;&gt;&gt; print(&quot;Hallo Welt!&quot;)

Als Ergebnis erhalten Sie

 Hallo Welt!

Der Prompt (&gt;&gt;&gt;) ist selbstverständlich nicht einzutippen, sondern wird vom Python-System geliefert.

Strings können in Python entweder in Anführungszeichen (&quot;) gesetzt werden oder in Hochkommatas('). In diesem Text wird die erste Variante bevorzugt eingesetzt.

Im Gegensatz zu Julia ist es hier egal, ob zwischen &lt;code&gt;print&lt;/code&gt; und der öffnenden Klammer Leerzeichen stehen.

= Python als Taschenrechner =
== Allgemeines ==
Wir wollen 3 * 5 berechnen. Dazu starten wir Python im interaktiven Modus. Geben Sie dann die Formel  

 &gt;&gt;&gt; 3 * 5

ein, drücken die Taste ENTER/RETURN ({{Taste|↵}}) und erhalten als Ergebnis

 15

Auch kompliziertere Ausdrücke sind möglich. Beispielsweise mit Winkelfunktionen, Quadratwurzeln etc. Wir wollen nun den Ausdruck &lt;math&gt;\sin\sqrt{15}&lt;/math&gt; berechnen :

 &gt;&gt;&gt; import math
 &gt;&gt;&gt; math.sin(math.sqrt(15))
 -0.6679052983383519

Als erstes wird das math-Modul importiert. Dann wird der mathematische Ausdruck berechnet.

Eine andere Variante, die dasselbe Ergebnis liefert, ist

 &gt;&gt;&gt; from math import *
 &gt;&gt;&gt; sin(sqrt(15))
 -0.6679052983383519

Es wird also aus dem Modul &lt;code&gt;math&lt;/code&gt; alles importiert (erkennbar am &lt;code&gt;*&lt;/code&gt;). Will man nicht alles importieren, so kann man das auch einschränken:

 &gt;&gt;&gt; from math import sin, sqrt

Beenden lässt sich das Python-Programm durch Eingabe von &lt;code&gt;exit()&lt;/code&gt; (und natürlich ist zur Bestätigung die RETURN-Taste zu drücken). &lt;code&gt;exit&lt;/code&gt; (ohne Klammern) oder &lt;code&gt;quit&lt;/code&gt; werden auch akzeptiert.

== Die Hilfefunktion von Python ==
Bei Eingabe der Anweisung &lt;code&gt;help&lt;/code&gt; oder &lt;code&gt;help()&lt;/code&gt; springt Python in den Hilfemodus. 

Eingabe:
 &gt;&gt;&gt; help()
 
Eingabe:
 help&gt; math.sin

Ausgabe:
 Help on built-in function sin in math:
 
 math.sin = sin(x, /)
     Return the sine of x (measured in radians).

Für die komplette Python-Dokumentation siehe [https://docs.python.org/3/]. Verlassen kann man den Hilfemodus durch das Drücken von STRG-C, bzw. der Eingabe von q, quit oder exit mit anschließendem Drücken der RETURN-Taste.

== Aufgaben ==
* Erkunden Sie die Tangensfunktion &quot;tan&quot; mittels Python-Hilfe (vergessen Sie nicht das math-Modul zu importieren und das &lt;code&gt;math.&lt;/code&gt; vor &lt;code&gt;tan&lt;/code&gt;)
* Berechnen Sie mit Python den Ausdruck &lt;math&gt;\frac{1}{2}\cdot \text{e}^2 \cdot \tan(\pi/3)&lt;/math&gt;. Siehe für die Exponentialfunktion im Python-Hilfesystem auch den Befehl &lt;code&gt;math.exp&lt;/code&gt;. Alternativ kann auch die Konstante &lt;code&gt;math.e&lt;/code&gt; eingesetzt werden. Potenzieren kann man bei Python mit dem **-Operator (z.B. 2**3 = 8). Für &lt;math&gt;\pi&lt;/math&gt; gibt es &lt;code&gt;math.pi&lt;/code&gt;.

= Python als Scriptsprache =
Häufig wird man aber kompliziertere Anweisungsfolgen verarbeiten müssen. Diese will man normalerweise nicht jedesmal neu eingeben, sondern in einer Datei speichern und diese Datei dann zur Ausführung bringen. Speichern Sie dazu folgenden Code in einer Textdatei, z.B. unter MS Windows als c:\tmp\test1.py

 # Das ist ein Kommentar
 print(&quot;Hallo Welt!&quot;)

Python-Dateien werden mit der Dateiendung .py versehen. Achten Sie darauf, dass vor dem print keine Leerzeichen vorhanden sind. Das ist eine Python-Eigenheit. Wie wir später sehen werden, nutzt Python Einrückungen als syntaktisches Mittel, z.B. um bei Schleifen den Schleifenkörper zu kennzeichnen. 

Danach bringen Sie die Skriptdatei test1.py (sozusagen das Hauptprogramm) folgendermaßen zur Ausführung:

1) Starten Sie unter MS Windows die Eingabeaufforderung (oder alternativ auch die Windows PowerShell). Das sieht dann etwa so aus:

 Microsoft Windows [Version 10.0.19045.3693]
 (c) Microsoft Corporation. Alle Rechte vorbehalten.
 
 C:\Users\xyz&gt;

: &lt;small&gt;Falls jemand nicht weiß, wie man die Eingabeaufforderung startet: Eine Möglichkeit ist, einfach in der Taskleiste von Windows das &quot;Start&quot;-Symbol &amp;nbsp;([[Image:Windows_logo_-_2021_(Black).svg|10px]])&amp;nbsp; mit der rechten Maustaste anklicken. &quot;Ausführen&quot; auswählen (oder alternativ für die PowerShell unter Windows 10 den Eintrag &quot;Windows PowerShell&quot;, unter Windows 11 den Eintrag &quot;Terminal&quot;). Im sich öffnenden Dialogfenster gibt man in die &quot;Öffnen&quot;-Zeile das Wort &lt;code&gt;cmd&lt;/code&gt; ein und mit &quot;OK&quot; wird das Ganze bestätigt.&lt;/small&gt; 
 
2) Wechseln Sie mittels &lt;code&gt;cd c:\tmp&lt;/code&gt; in das Verzeichnis c:\tmp

3) Angenommen, Sie haben Python unter dem Pfad &lt;code&gt;c:\devel\Python\&lt;/code&gt; installiert. Starten Sie das Programm so (der Prompt &lt;code&gt;c:\tmp&gt;&lt;/code&gt;ist natürlich nicht mit einzutippen): 

 c:\tmp&gt;c:\devel\Python\python.exe test1.py

4) Wie erwartet ergibt sich folgende Ausgabe am Bildschirm

 Hallo Welt!

Die Vorgehensweise unter Linux ist prinzipiell gleich. Die kleinen Unterschiede, wie z.B. der Slash statt dem Backslash in Pfadangaben, sollten für Linux-Benutzer keine Hürde darstellen.

== Variablen ==
Variablenbezeichner können aus Buchstaben (A-Za-z), Ziffern (0-9) und Underscores (_) bestehen, dürfen aber nicht mit einer Zahl beginnen. Führende Underscores haben u.a. im Kontext mit der Objektorientierten Programmierung eine spezielle Bedeutung und sollten nicht für &quot;normale&quot; Variablenbezeichner verwendet werden.

Gültige Variablenbezeichner wären also:
 xyz
 x1
 _wert
 name_anzahl

Theoretisch kann man auch Umlaute, griechische Buchstaben u.ä. in Variablenbezeichnern nutzen, z.B.

 ößÜ = 16
 α = 134 
 print(ößÜ)
 print(α)

Ausgabe:
 16
 134

Davon wird aber aus offensichtlichen Gründen ({{W|Englisch als Lingua franca}}) abgeraten. Das Eurozeichen (€) etc. darf man ohnehin nicht in Variablenbezeichnern verwenden, dies ergäbe einen Syntaxfehler. Siehe dazu auch [https://peps.python.org/pep-3131/].

Es gibt in Python etliche Schlüsselwörter (z.B. for, if oder return). Diese dürfen nicht als eigene Variablenbezeichner verwendet werden. Eine Liste aller Schlüsselwörter liefert das Script

 import keyword
 print(keyword.kwlist)

&lt;small&gt;Übung: Speichern Sie dieses Script in eine Datei, z.B. in c:\tmp\test1.py. Führen Sie diese Datei aus, um die Liste der Schlüsselwörter auszugeben.&lt;/small&gt;

Da Python case-sensitiv ist, repräsentieren folgende Bezeichner verschiedene Variablen:
 xyz
 XYZ
 xYz

Werte werden an Variablen mittels Gleich-Zeichen (=) zugewiesen. Im Folgenden wird der Code immer in der Datei c:\tmp\test1.py gespeichert.

 x = 5
 y = 10
 z = x*y
 print(z)

Bringen Sie die Datei test1.py zur Ausführung, so erhalten Sie folgende Bildschirmausgabe

 50

Sie können auch mehrere Anweisungen in einer Zeile durch Semikolon getrennt schreiben. Dies führt aber zu unübersichtlichem Code.

 x = 5; y = 10; z = x*y; print(z)

Ausgabe:
 50

Auch aus der Programmiersprache C/C++ oder Java bekannte Konstrukte können Sie verwenden, z.B.
 x = 5
 # x = x - 2
 x -= 2
 print(x)

Bildschirmausgabe:

 3
 
Beachten Sie, dass mit dem =-Zeichen eine Wertezuweisung durchgeführt wird. Dies ist nicht äquivalent zum mathematischen =-Zeichen, wie am vorigen Beispiel zu ersehen ist. Den Inkrement-/Dekrementoperator (z.B. x++ oder x--) aus C/C++ oder Java kennt Python aber nicht.

Variablen sind nicht an einen bestimmten Datentyp gebunden, folgendes ist mit Python problemlos möglich:

 import math
 wert = 10
 print(wert)
 wert = 35.5
 print(wert)
 wert = &quot;Hallo&quot;
 print(wert)
 wert = math.pi
 print(wert)

Ausgabe:
 10
 35.5
 Hallo
 3.141592653589793

== Physische und logische Zeilen ==
In Python muss eine Anweisung in einer logischen Zeile Platz finden. Wird eine Anweisung aber zu lang für eine Zeile, dann kann sie in mehrere physische Zeilen unterteilt werden. Dies kann einerseits durch einen Backslash am Ende einer Zeile geschehen, z.B.

 a = 2 + \
 5
 
Dies stellt eine logische Zeile dar, die in zwei physische Zeilen unterbrochen ist.

Geklammerte Ausdrücke werden automatisch zu einer logischen Zeile verbunden, z.B.

 a = (2 + 
 5)
 
Achtung: Im ersten Beispiel darf nach dem Backslash nichts mehr stehen, auch kein Kommentar. Dies trifft im zweiten Bespiel nicht zu, hier könnte noch ein Kommentar folgen, z.B.

 a = (2 +    # Kommentar 
 5)

Auch für Strings gibt es Möglichkeiten, diese auf mehrere Zeilen aufzuspalten.

 # Kurzer String
 str1 = &quot;ABC&quot;
 
 # Langer String
 str2 = &quot;&quot;&quot;Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle&quot;&quot;&quot;
 
 # Backslash
 str3 = &quot;UVW\
 XYZ&quot;
 
 # Mit Klammern
 str4 = (&quot;Sehr langer Text, der automatisch .............. &quot;
         &quot;in einer einzigen Variable zusammengefügt wird.&quot;
 )
 
 print(str1)
 print(str2)
 print(str3)
 print(str4)

Ausgabe:

 ABC
 Hallo Welt,
 Grüetzi Schwyzer,
 Servus an alle
 UVWXYZ
 Sehr langer Text, der automatisch .............. in einer einzigen Variable zusammengefügt wird.

==Hexadezimale, oktale, binäre und andere Zahlen==
 d = 1050         # Dezimalzahl
 h = 0xAA2        # Hexadezimalzahl
 o = 0o12         # Oktalzahl
 b = 0b100001101  # Binärzahl
 
 print(d)
 print(h)
 print(o)
 print(b)

Ausgabe:
 1050
 2722
 10
 269

Groß- und Kleinbuchstaben sind in obigen Literalen übrigens egal. So kann man z.B. statt &lt;code&gt;0b1001&lt;/code&gt; auch &lt;code&gt;0B1001&lt;/code&gt; schreiben (siehe dazu [https://docs.python.org/3/reference/lexical_analysis.html#integer-literals]).

Sie können auch dezimale in hexadezimale Zahlen umwandeln, usw.:
 h = hex(1050)    # Dezimalzahl -&gt; Hexadezimalzahl
 b = bin(1050)    # Dezimalzahl -&gt; Binärzahl
 o = oct(1050)    # Dezimalzahl -&gt; Oktalzahl
 print(h)
 print(b)
 print(o)

Ausgabe:
 0x41a
 0b10000011010
 0o2032

Gegeben sei die Zahl 121 zur Basis 3. Diese soll in eine Dezimalzahl umgewandelt werden. Das kann so geschehen:

 z = int(&quot;121&quot;, 3)
 print(z)

Ausgabe:
 16

Dass dies richtig ist, davon kann man sich folgendermaßen überzeugen:
 &lt;math&gt; 1 \cdot 3^2 + 2 \cdot 3^1 + 1 \cdot 3^0 = 9 + 6+ 1 = 16 &lt;/math&gt;

Zahlen übersichtlicher schreiben kann man auch mittels Underscore, z.B.:

 print(&quot;Eine Million (Variante 1) =&quot;, 1000000)
 print(&quot;Eine Million (Variante 2) =&quot;, 1_000_000)
 print(&quot;Eine Rechnung:&quot;, 2_000 * 400_000);

Es ergibt sich bei beiden Varianten die gleiche Ausgabe. Variante 2 ist aber im Sourcecode leichter lesbar, detto die Zahlen in der Rechnung:

 Eine Million (Variante 1) = 1000000
 Eine Million (Variante 2) = 1000000
 Eine Rechnung: 800000000

== Strings und Platzhalter==
Ein paar einfache Beispiele:

 print(&quot;Hallo {}&quot; . format(&quot;Hugo&quot;))     # new style string formatting
 print(&quot;Hallo {:s}&quot; . format(&quot;Hugo&quot;))   # new style string formatting
 print(&quot;Hallo %s&quot; % &quot;Hugo&quot;)             # %-String

Ausgabe:

 Hallo Hugo
 Hallo Hugo
 Hallo Hugo

Python-Code (formatted string literals, Beispiel 1):
 str1 = &quot;Hallo&quot;
 str2 = &quot;Hugo&quot;
 print(f&quot;{str1} {str2}&quot;)

Ausgabe:
 Hallo Hugo

f-Strings (ab Python 3.6) sind die modernere Variante gegenüber %-Strings oder das ''new style string formatting''. Sie sind in der Regel auch schneller.

Python-Code (formatted string literals, Beispiel 2):
 wert = 11.567
 print(f&quot;Ausgabe: {wert:.5f}&quot;)

Ausgabe:
 Ausgabe: 11.56700

Komplexere Beispiele:

 print(&quot;Hallo {} und {}&quot; . format(&quot;Hugo&quot;, &quot;Mike&quot;))
 print(&quot;Hallo {name1} und {name2}&quot; . format(name2=&quot;Hugo&quot;, name1=&quot;Mike&quot;))
 # Füllzeichen: *
 # Bündigkeit: &gt; (=rechts), &lt; (=links), ^ (=zentriert)
 # Feldweite: 10
 # Typ: s (=String), f (=Gleitkommazahl), d (=Dezimalzahl) etc.
 print(&quot;Hallo {:*&gt;10s}&quot; . format(&quot;Hugo&quot;))
 print(&quot;Hallo {:*&lt;10s}&quot; . format(&quot;Hugo&quot;))

Ausgabe:

 Hallo Hugo und Mike
 Hallo Mike und Hugo
 Hallo ******Hugo
 Hallo Hugo******

Python-Code:
 str = &quot;Hallo\t%s\t%7.2f\t%10.2e\t%i&quot; % (&quot;Hugo&quot;, 12.34567, 34.567, 264)
 print(str)

Ausgabe:
 Hallo	Hugo	  12.35	  3.46e+01	264

== Unicode ==
Neben den bekannten ASCII-Zeichen lassen sich Zeichen auch mittels Unicode beschreiben. Griechische Buchstaben oder komplexere mathematische Operatoren - all das sollte kein Problem sein. Siehe auch {{W|Unicode}}, {{W|Liste der Unicodeblöcke}} und {{W|Unicodeblock Mathematische Operatoren}}. Im Folgenden werden ein paar Zeichen (Allquantor, Nabla-Operator, Existenzquantor), die man aus der Mathematik kennt, erzeugt. 
 
 ch1 = &quot;\N{FOR ALL}&quot;
 ch2 = &quot;\N{NABLA}&quot;
 ch3 = &quot;\u2203&quot;
 print(ch1, ch2, ch3)

Ausgabe:
 ∀ ∇ ∃

&lt;small&gt;Diese Ausgabe ergibt sich z.B. mit der IDLE-Shell oder mit Cygwin. Beim Ausführen über die Windows-Eingabeaufforderung oder Windows PowerShell unter MS Windows 10 erfolgt keine korrekte Darstellung. IDLE ist die mit Python mitgelieferte IDE ('''I'''ntegrated '''D'''evelopment '''E'''nvironment, Integrierte Entwicklungsumgebung). Gegen Ende dieses Textes wird IDLE kurz beschrieben.
Das Problem mit der Windows Eingabeaufforderung lässt sich aber umgehen. Man muss nur eine Schriftart auswählen, die die Zeichen kennt, z.B. &quot;DejaVu Sans Mono&quot;. Dazu klicken Sie einfach bei der Eingabeaufforderung mit der rechten Maustaste oben auf die weiße Leiste und wählen im aufpoppenden Fenster den Menüpunkt &quot;Eigenschaften&quot;. Es öffnet sich ein Dialogfenster. Über den Reiter &quot;Schriftart&quot; lässt sich nun die Schriftart einstellen. Unter MS Windows 11 oder openSUSE Leap 15.6 (bash-Konsole) gibt es dieses Problem ohnehin nicht.&lt;/small&gt;

== Reguläre Ausdrücke ==
Python kennt auch {{W|Regulärer Ausdruck|reguläre Ausdrücke}}. Dazu gibt es in Python das Modul &lt;code&gt;re&lt;/code&gt;. Beipielsweise sollen alle Zahlen (&lt;math&gt;\text{zahl}\in\mathbb{N}_0&lt;/math&gt;) in einem String gesucht und ausgegeben werden. Als String sei gegeben: &lt;code&gt;3x Grüße und 100 Kekse.&lt;/code&gt; Das Muster (Pattern) ist &lt;code&gt;\d+&lt;/code&gt;. &lt;code&gt;\d&lt;/code&gt; steht für eine Dezimalziffer 0-9. Das Plus-Zeichen (+) steht symbolisch für ein oder mehrere Zeichen des vorherigen Ausdrucks. Hier also ein oder mehrere Dezimalziffern. Es wird die Funktion &lt;code&gt;findall&lt;/code&gt; aus dem Modul &lt;code&gt;re&lt;/code&gt;verwendet.

Python-Code:
 from re import findall
 
 str = &quot;3x Grüße und 100 Kekse.&quot;
 pat = &quot;\\d+&quot;  # Doppel-Backslashes müssen verwendet werden, sonst gibt Python eine Warnung aus!
               # alternativ: pat = r&quot;\d+&quot; 
               # oder: pat = &quot;[0-9]+&quot;
 
 numb = findall(pat, str)
 print(numb)

Ausgabe:
 ['3', '100']

Python kennt noch viele weitere Möglichkeiten mittels regulärer Ausdrücke zu hantieren. Dies soll hier aber nicht vertieft werden, da das Thema schon ziemlich speziell und komplex ist. Bei Bedarf siehe aber z.B. die Bücher ''Weigend, Seite 380ff'' und ''Ernesti, Kaiser'' [https://openbook.rheinwerk-verlag.de/python/28_001.html] oder die Python-Dokumentation [https://docs.python.org/3/library/re.html]. Auch [[Python unter Linux: Reguläre Ausdrücke]] liefert ein umfangreiches und brauchbares Python-2-Kapitel zu den regulären Ausdrücken. Die dort gelisteten Beispiele müssten ggf. vor Verwendung auf Python-3 umgeschrieben werden. &lt;small&gt;Wie macht  man das? Dazu siehe z.B. [https://openbook.rheinwerk-verlag.de/python/43_001.html], [https://portingguide.readthedocs.io/en/latest/] oder [https://www.digitalocean.com/community/tutorials/how-to-port-python-2-code-to-python-3]&lt;/small&gt;

&lt;small&gt;Es gibt auch ein externes Modul ''regex'', das bei Bedarf extra installiert werden muss ([https://pypi.org/project/regex/]). Es bietet zusätzliche Funktionalität und gründlicheren Unicode-Support. Dies sei hier aber nur der Vollständigkeit halber erwähnt.&lt;/small&gt;

== Verzweigungen ==
=== if ===
Die IF-Verzweigung sei aus anderen Programmiersprachen bereits bekannt. In {{W|Pseudocode}} lässt sie sich folgendermaßen darstellen:

 WENN bedingung TRUE
   führe block1 aus
 SONST
   führe block2 aus
 ENDE 

Als {{W|Aktivitätsdiagramm|UML-Aktivitätsdiagramm}} sieht das in etwa so aus:

[[File:If-Then-Else-diagram.svg|200px]]

Und als {{W|Nassi-Shneiderman-Diagramm|Nassi-Shneiderman-Struktogramm}} so:

[[File:Zweiseitige Auswahl.png|250px]]

In Python gibt es keinen expliziten ENDE-Kennzeichner. Stattdessen wird der Code durch Einrückungen strukturiert. Alles mit der gleichen Einrückungstiefe gehört zum selben Block. Dies zeichnet Python vor anderen Programmiersprachen aus.

Die test1.py-Datei laute also wie folgt:

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
   print(&quot;x ist groesser oder gleich 4&quot;)  

Ausgabe:

 Der else-Zweig wird ausgefuehrt
 x ist groesser oder gleich 4

Man achte auch auf die Doppelpunkte in der if- und else-Zeile. Darauf vergisst man gerne, wenn man von anderen Programmiersprachen kommt.

Folgendes wäre in Python ein Fehler (genauer gesagt ein IndentationError).

 x = 5
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
     print(&quot;x ist groesser oder gleich 4&quot;)  

Auch Nachstehendes würde nicht zum gewünschten Ergebnis führen (löst aber keine Fehlermeldung aus). Der letzte print-Befehl ist schon außerhalb der IF-ELSE-Verzweigung.

 x = 3
 
 if x &lt; 4:
   print(&quot;x ist kleiner als 4&quot;)
 else:
   print(&quot;Der else-Zweig wird ausgefuehrt&quot;)
 print(&quot;x ist groesser oder gleich 4&quot;)

Ausgabe:

 x ist kleiner als 4
 x ist groesser oder gleich 4

Python kennt eine Reihe von Vergleichs- und Verknüpfungsoperatoren:

    &lt;, &lt;= ... kleiner (gleich)
    &gt;, &gt;= ... größer (gleich)
    == ... gleich
    != ... ungleich
    is ... identisch
    is not ... nicht identisch
    and ... AND
    or ... OR
    not ... NOT

Beispielsweise:

 a = 5
 b = 9
 
 if a&lt;=10 and b!=7:
   print(&quot;OK&quot;)
 else
   print(&quot;Nicht OK&quot;)

Ausgabe:

 OK

Der else-Block kann übrigens auch ersatzlos entfallen. Als Pseudocode sieht das so aus

 WENN bedingung TRUE
   führe block aus
 ENDE

Mehrfache Verzweigungen werden durch das elif-Konstrukt erstellt. In Pseudocode:

 WENN bedingung1 TRUE
   führe block1 aus
 SONST WENN bedingung2 TRUE
   führe block2 aus
 SONST WENN bedingung3 TRUE
   führe block3 aus
 SONST
   führe block4 aus
 ENDE

Ein Python-Beispiel:
 a = 14
 
 if a&lt;=10:   
   print(&quot;&lt;=10&quot;)
 elif a&gt;=11 and a&lt;=15:
   print(&quot;11 bis 15&quot;)
 elif a&gt;=16 and a&lt;=20:
   print(&quot;16 bis 20&quot;)
 else:
   print(&quot;&gt;20&quot;)

Ausgabe:

 11 bis 15

In Python gibt es auch die Schlüsselwörter &lt;code&gt;True&lt;/code&gt; (für wahr) und &lt;code&gt;False&lt;/code&gt; (für falsch). Man beachte, dass sie mit Großbuchstaben beginnen. Andere Schreibweisen wären ein Fehler. Sie gehören zum Datentyp &lt;code&gt;bool&lt;/code&gt;. Ihnen sind auch die Zahlen &lt;code&gt;1&lt;/code&gt; und &lt;code&gt;0&lt;/code&gt; zugewiesen.

Man beachte, dass {{W|Rundungsfehler}} auftreten können. D.h. man sollte  bei der Verwendung von {{W|Gleitkommazahl|Gleitpunktzahlen}} niemals auf absolute Genauigkeit prüfen, sondern eine Toleranz (einen &lt;math&gt;\varepsilon&lt;/math&gt;-Wert) vorgeben.
 
Ein klassisches Beispiel, das ein falsches Ergebnis liefert, ist:

 i = 0.1 + 0.2
 
 print(i)
 
 if i == 0.3:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 NOK

Und das, obwohl man schon in der Volksschule lernt, dass 0.1 + 0.2 gleich 0.3 ist.

Korrekt muss das obige Beispiel z.B. so umgeschrieben werden:

 ist = 0.1 + 0.2
 soll = 0.3
 epsilon = 0.000001
 
 print(ist)
 
 if abs(ist-soll) &lt; epsilon:
     print(&quot;OK&quot;)
 else:
     print(&quot;NOK&quot;)

Ausgabe:
 0.30000000000000004
 OK

Alternativ kann auch die &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion verwendet werden. Das sei aber hier nur erwähnt und nicht konkret ausgeführt.

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet zum Thema &lt;code&gt;math.isclose()&lt;/code&gt;-Funktion.

=== match ===
Ab Python 3.10 gibt es auch die match-Anweisung. Dies ist das Python-Pendant für die switch-Anweisung in anderen Programmiersprachen, geht aber bei näherer Betrachtung weit darüber hinaus. Hier nur ein einfaches Beispiel:

 x = &quot;Hello&quot;
 
 match x:
     case &quot;Servus&quot; | &quot;Ciao&quot;:         # or
         print(&quot;Servus an alle&quot;)
     case &quot;Grüetzi&quot;:
         print(&quot;Grüetzi Schwyzer&quot;)  
     case _:                         # other, default, sonstiges ...
         print(&quot;Hallo Welt&quot;)

Ausgabe: 
 Hallo Welt

Als Struktogramm sieht das in etwa so aus:

[[File:Mehrseitige Auswahl.png|250px]]

Für nähere Details siehe z.B. [https://www.geeksforgeeks.org/python-match-case-statement/], [https://learnpython.com/blog/python-match-case-statement/], [https://docs.python.org/3/tutorial/controlflow.html#match-statements] und das Python Enhancement Proposal (PEP) 636 – Structural Pattern Matching: Tutorial [https://peps.python.org/pep-0636] und dort insbesondere den Anhang A - Quick Intro.

&lt;small&gt;&lt;code&gt;match, case, _&lt;/code&gt; etc. sind sogenannte ''soft keywords''. Im Gegensatz zu den normalen Schlüsselwörtern dürfen ihnen auch Werte zugewiesen werden. Eine Liste der weichen Schlüsselwörter lässt sich durch &lt;code&gt;keyword.softkwlist&lt;/code&gt; erstellen (die Anweisung gibt es seit Python 3.9). Siehe dazu auch [https://stackoverflow.com/questions/65800344/what-are-soft-keywords] und [https://docs.python.org/3/library/keyword.html#keyword.softkwlist].&lt;/small&gt;

== Schleifen ==
Kopfgesteuerte Schleife, Endlosschleife und fußgesteuerte Schleife:

[[File:Programmingloops.svg|450px]]

=== while ===
Die WHILE-Schleife ist kopfgesteuert. Sie funktioniert wie aus anderen Programmiersprachen bekannt. 

In Pseudocode:
 SOLANGE bedingung TRUE
   führe block aus
 ENDE

In Python:
 x = 0
 
 while x &lt;= 10:
   print(x)
   x += 1

Ausgabe:
 0
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10

Eine Endlosschleife ergibt sich z.B. so:
 i = 5
 
 while True:
     print(i)
     i-=1

Beendet werden kann sie mit der Tastenkombination STRG-C.

Eine fußgesteuerte Schleife kann so simuliert werden:
 i = 5
 
 while True:
     print(i)
     i-=1
 
     if i&lt;=0:
         print(&quot;Fire&quot;)
         break

Ausgabe:
 5
 4
 3
 2
 1
 Fire

Der &lt;code&gt;break&lt;/code&gt;-Befehl wird etwas [[Ing_Mathematik:_Python#break|später]] noch einmal kurz thematisiert.

=== for ===
Struktogramm einer for-Schleife:

[[File:Zählschleife.png|200px]]

In Python bspw. so:

 for x in range(6):
   print(x*2)

Ausgabe:
 0
 2
 4
 6
 8
 10

Die Schleife läuft von 0 bis 5. Ausgegeben wird jeweils der Wert x*2. Aquivalent kann diese Schleife auch so geschrieben werden:
 for x in range(0, 11, 2):
   print(x)

Die Ausgabe ist wie oben. Der Startwert sei 0, der Endwert ist 11-1 und die Schrittweite ist 2.

Ein anderes Beispiel sei
 for x in &quot;text&quot;:
   print(x)

Ausgabe:
 t
 e
 x
 t

== Schleifen abbrechen ==
=== break ===
&lt;code&gt;break&lt;/code&gt; bricht die Schleife ab und setzt mit dem nächsten Befehl außerhalb der Schleife fort.

 for var in range(100):
   print(var) 
   if var == 5:
     break

Ausgabe:
 0
 1
 2
 3
 4
 5

=== continue ===
&lt;code&gt;continue&lt;/code&gt; bricht den aktuellen Schleifendurchlauf ab und setzt mit dem nächsten Schleifendurchlauf fort.

 for var in range (11):
   if var == 5:
     continue
   print(var)

Ausgabe:
 0
 1
 2 
 3
 4
 6
 7
 8
 9
 10

== try - except ==
 try:
     z1 = 12 / 0
     print(z1)
 except ZeroDivisionError:
     print(&quot;Das Ergebnis ist unendlich&quot;)
 except:
     print(&quot;Kann nicht berechnet werden!&quot;)
     print(&quot;Bitte die Formel korrigieren!&quot;)
 
 print(&quot;Setze Programm fort!&quot;)

Ausgabe:
 Das Ergebnis ist unendlich
 Setze Programm fort!

Es wird versucht, eine Zahl durch Null zu dividieren. Das ist nicht möglich, es wird eine Ausnahme ausgelöst. Das Programm springt daher in den except-ZeroDivisionError-Block und führt die dort gelisteten Anweisungen aus (in unserem Fall eine print-Anweisung). Danach wird das Programm fortgesetzt. Würden wir dieses Programm ohne try-except ausführen, so ergibt sich aus

 z1 = 12 / 0
 print(z1)

folgende Fehlermeldung und ein unmittelbarer Programmabbruch

 Traceback (most recent call last):
   File &quot;C:\tmp\test1.py&quot;, line 1, in &lt;module&gt;
     z1 = 12 / 0
 ZeroDivisionError: division by zero

Mit dem try-except-Mechanismus können also Ausnahmen oder Fehler aufgefangen und behandelt werden. In unserem Beispiel ist das eher trivial, aber bei größeren Programmen kann das durchaus Sinn machen.

Neu in Python 3.14 ist, dass mehrere Ausnahmen auch ohne Klammern angegeben werden können, z.B.:

bis inkl. Python 3.13 nur:
 except (ZeroDivisionError, ValueError):

ab Python 3.14 auch:
 except ZeroDivisionError, ValueError:

== pass ==
Ein leerer Block muss in Python mittels dem Schlüsselwort &lt;code&gt;pass&lt;/code&gt; dargestellt werden. Z.B.

 x = 2
 
 if x == 1:
     print(&quot;Wert ist &quot;, x)
 else:
     pass

Würde man das &lt;code&gt;pass&lt;/code&gt; im else-Block weglassen, so würde man eine Fehlermeldung erhalten:

 IndentationError: expected an indented block after 'else' statement on line 5

= Funktionen =
== Aufrufen von Funktionen ==
Funktionen sind uns im Rahmen dieses Kurses schon zuhauf begegnet. Sei es die print()-, die math.sin()- oder die hex()-Funktion. All diese Funktionen werden von Python zur Verfügung gestellt, ohne dass man sie explizit programmieren müsste. Aufgerufen werden diese Funktionen, indem man ihren Namen eintippt, gefolgt von runden Klammern. In diesen Klammern können noch Argumente übergeben werden. Auch Rückgabewerte sind möglich.

== Funktionen selber schreiben ==
Funktionen werden mit dem def-Schlüsselwort (man definiert die Funktion) eingeleitet, danach folgt der Funktionsname, danach wiederum runde Klammern, in denen formale Argumente stehen können. Abgeschlossen wird die def-Zeile mit einem Doppelpunkt. Danach folgt der Funktionskörper. Dieser Funktionskörper muss wiederum eingerückt werden (wie von den Verzweigungen und Schleifen bekannt). Aufgerufen wird diese Funktion, indem man ihren Funktionsnamen eingibt, gefolgt von runden Klammern (ggf. mit den aktuellen Parametern). Z.B.

 # Funktion definieren
 def halloWelt(i):
     # i ... beliebige Ganzzahl
     print(&quot;Hallo &quot; * i, end=&quot;&quot;)
     print(&quot;Welt!&quot;)
    
 # Funktion aufrufen
 halloWelt(3)

Ausgabe:
 Hallo Hallo Hallo Welt!

Unterschied zwischen formalen und aktuellen Parametern:

[[Datei:PythonIng_func1.jpg]]

&lt;small&gt;Aktuelle Parameter werden auch Argumente genannt.&lt;/small&gt;

Rückgabe von Funktionswerten:
 # Funktion definieren
 def mathFunc(a, b):
     r1 = a + b
     r2 = a * b
     return r1, r2
    
 # Funktion aufrufen
 c, d = mathFunc(3, 5)
 
 # Ausgabe der zurückgegebenen Werte
 print(c)
 print(d)

Ausgabe:
 8
 15

Es werden r1 und r2 zurückgegeben und den Variablen c und d zugewiesen. (r1, r2) und (c, d) sind Tupel. Was Tupel konkret sind, siehe etwas später in diesem Kapitel. 3 und 5 sind die aktuellen Parameter (die Argumente). a und b sind die formalen Parameter. Die Zuweisung der aktuellen zu den formalen Parametern erfolgt in der gegebenen Reihenfolge, also die Zahl 3 wird an a übergeben und die Zahl 5 an b.

Vorgabeparameter, z.B.:
 def mathFunc(a=10, b=20):
     r1 = a + b
     r2 = a * b
     return r1, r2
 
 c, d = mathFunc(3, 5)
 print(c)
 print(d) 
 
 e, f = mathFunc(5)
 print(e)
 print(f)
 
 g, h = mathFunc(b=6)
 print(g)
 print(h)

Ausgabe:
 8
 15
 25
 100
 16
 60

Erklärung:
* Erster &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es werden, wie weiter oben, die Argumente 3 und 5 an die formalen Parameter a und b übergeben. Die Rückgabewerte r1 und r2 werden an c und d übergeben. Somit ist c=8 und d=15.
* Zweiter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur das Argment 5 an a übergeben. b behält den Vorgabewert 20. D.h. e= 25 und f=100.
* Dritter &lt;code&gt;mathFunc&lt;/code&gt;-Aufruf: Es wird nur die Zahl 6 an b übergeben, a behält seinen Vorgabewert 10. Somit ergibt sich g=16 und h=60.

Beispiel (Schlüsselwortargumente vs. Positionsargumente):
 def mathFunc(a, b):
     r1 = a - b
     r2 = a / b
     return r1, r2
 
 c, d = mathFunc(b=3, a=5)  # Schlüsselwortargumente
 e, f = mathFunc(3, 5)      # Positionsargumente

 print(c)
 print(d)
 print(e)
 print(f)

Ausgabe:
 2
 1.6666666666666667
 -2
 0.6

Durch die Verwendung von Schlüsselwortargumenten können die Argumente in beliebiger Reihenfolge angegeben werden. Bei den Positionsargumenten ist die Reihenfolge vorgegeben. Daraus resultiert auch der Unterschied bei den obigen Ausgaben. Werden beide Arten in einem Aufruf gemischt, so müssen die Positionsargumente zuerst angegeben werden. Den Unterschied zwischen beiden Argumentarten zu kennen ist wichtig, nicht nur bei selbst erstellten Funktionen. Auch beim Aufruf von Python-Funktionen verfolgt einen die Mischung von Schlüsselwort- und Positionsargumenten auf Schritt und Tritt, z.B. beim etwas später folgenden Abschnitt über &quot;Grafiken zeichnen&quot;:

 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)

Bei dieser &lt;code&gt;plot&lt;/code&gt;-Funktion aus dem Modul &lt;code&gt;matplotlib.pyplot&lt;/code&gt; sind &lt;code&gt;x&lt;/code&gt; und &lt;code&gt;y1&lt;/code&gt; Positionsargumente. &lt;code&gt;label, lw&lt;/code&gt; und &lt;code&gt;ls&lt;/code&gt; sind die Namen der Schlüsselwortargumente. Die Schlüsselwortargumente könnten auch in anderer Reihenfolge angeschrieben werden, nicht jedoch die Positionsargumente!
Siehe zu &lt;code&gt;matplotlib.pyplot.plot&lt;/code&gt; auch die Seite [https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html].

== Lambda-Funktionen ==
 print((lambda a, b: a*b) (3, 5))

Ausgabe:
 15

Eingeleitet wird eine Lambda-Funktion (auch Lambda-Form, Lambda-Operator oder anonyme Funktion genannt) mit dem Schlüsselwort &lt;code&gt;lambda&lt;/code&gt;. Es folgen die formalen Argumente, danach ein Doppelpunkt, die Berechnungsvorschrift und ggf. abschliessend in Klammern die aktuellen Parameter.

Man kann einer Lambda-Funktion auch einen Funktionsnamen geben und die Funktion über diesen Namen aufrufen, z.B.

 prod = lambda a, b: a*b
 print(prod(3, 5))

Als Ausgabe wird wieder die Zahl 15 geliefert.

== Rekursive Funktionen ==
Funktionen können wiederum andere Funktionen aufrufen. Von einem {{W|Rekursion|rekursiven Funktionsaufruf}} spricht man, wenn die aufgerufene Funktion gleich der aufrufenden ist. 

 def printFunc(i):
     if (i &gt;= 5):
         return 
     else:
         print(&quot;Hallo Welt&quot;)
         printFunc(i+1)
         
 printFunc(1)

Ausgabe:
 Hallo Welt
 Hallo Welt
 Hallo Welt
 Hallo Welt

Typische Beispiele für die Abarbeitung als rekursive Funktionen sind die {{W|Fibonacci-Folge}} und die {{W|Fakultät_(Mathematik)|Fakultät}}. Jedoch ist der iterative Ansatz (mit konventionellen Schleifen) meist schneller und speicherplatzschonender.

== Funktionsannotationen ==
Python ist sehr flexibel, was Typen angeht. Im Vorhergehenden haben wir generell keine Typangaben gemacht. Will man Typen angeben, so bietet Python das Konzept der Funktionsannotation.

 def calcFunc(a: int, b: int) -&gt; int:
     return a+b
 
 r1 = calcFunc(8, 9)
 r2 = calcFunc(8.0, 9.0)
 r3 = calcFunc(&quot;Hallo&quot;, &quot;Welt&quot;)
 
 print(r1)
 print(r2)
 print(r3)

Ausgabe:
 17
 17.0
 HalloWelt

Jetzt sieht man auf den ersten Blick, welche Typen der Programmierer im Sinn hatte, als er die Funktion erstellte. Das Problem dabei ist nur, dass es Python ziemlich egal ist, welche Typen man im Endeffekt eingibt. Im obigen Beispiel können statt Integer-Typen u.a. auch Float- oder String-Typen eingegeben werden.

&lt;small&gt;
Siehe zum Thema &quot;Type Checking&quot; aber auch den später folgenden Abschnitt [[Ing_Mathematik:_Python#Type_Checker]].
&lt;/small&gt;

== Variadische Funktionen ==
Python-Code:

 def test1(a, *b):
     print(a);
      
     for c in b:
         print(c);
        
 test1(&quot;Hallo&quot;, &quot;Welt&quot;, &quot;Schweizer&quot;, &quot;und alle anderen&quot;)

Ausgabe:

 Hallo
 Welt
 Schweizer
 und alle anderen

Mit dem Stern (auch als Splat-Operator bezeichnet) in der formalen Parameterliste bei der Funktion &lt;code&gt;test1&lt;/code&gt; wird angezeigt, dass eine beliebige Anzahl von Argumenten übergeben wird. &lt;small&gt; Dies entspricht in etwa dem, was in anderen Programmiersprachen (PHP etc.) mittels Ellipse (&lt;code&gt;...&lt;/code&gt;) angezeigt wird.&lt;/small&gt;

= Tupel, Listen und andere =
[[Datei:Python 3. The standard type hierarchy.png|mini|hochkant=1.7|Datentypen und Strukturen]]

== Tupel und Listen ==
Tupel, Listen und einige andere sind Datenstrukturen oder Sequenzen.

Listen (z.B. eine Einkaufsliste) sind veränderbar (mutable). Ein Tupel kann dagegen nicht verändert werden (immutable). Listen werden beim Anlegen in eckige Klammern eingeschlossen, Tupel in runde Klammern. Beim Tupel können die Klammern auch weggelassen werden. Ein Tupel mit nur einem Element muss mit einem Beistrich abgeschlossen werden. Der Grund ist, dass Python sonst nicht entscheiden kann, ob ein Tupel angelegt werden soll, oder nur ein geklammerter Wert. 

Als Gedächtnisstütze kann man sich den Unterschied zwischen Tupel und Liste ev. so leichter merken:
: T'''u'''pel ... r'''u'''nde Klammern, '''u'''nveränderlich
: L'''i'''ste ... eck'''i'''ge Klammern, veränderl'''i'''ch.

Nachfolgend werden einige Operationen mit Listen und Tupel dargestellt.

 # Liste und Tupel
 liste = [1, 2, &quot;Hallo&quot;]
 tupel = (1, 2, &quot;Hallo&quot;) 
 
 # Ausgabe von liste und tupel
 print(liste)
 print(tupel)
 
 # Ausgabe von Einzelelementen
 print(liste[1])
 print(tupel[2])
 
 # Element an Liste anhängen und einfügen 
 liste.append(55)
 liste.insert(4, &quot;Welt&quot;)
 print(liste)
 
 # Element aus Liste entfernen
 liste.remove(1)
 print(liste)
 
 # einige weitere Beispiele
 liste2 = [1,]
 tupel2 = 1, 2
 tupel3 = (1,) 
 print(liste2)
 print(tupel2)
 print(tupel3)

Ausgabe:
 [1, 2, 'Hallo']
 (1, 2, 'Hallo')
 2
 Hallo
 [1, 2, 'Hallo', 55, 'Welt']
 [2, 'Hallo', 55, 'Welt']
 [1]
 (1, 2)
 (1,)

Beispiel (eine Liste von Wörtern zu einem einzigen zusammenhängenden Text verbinden):

 woerter = [&quot;Hallo&quot;, &quot;Welt&quot;]
 satz = &quot; &quot;.join(woerter)
 print(satz)

Ausgabe:

 Hallo Welt

== Dictionaries und Mengen ==
Zu den Datenstrukturen gehören weiters auch Mengen und Dictionaries. Mengen sind von der Mathematik bekannt, sie sind ungeordnet und es kommen keine mehrfachen Elemente vor. Dictionaries sind durch Schlüssel :Wert-Paare gekennzeichnet. Mengen werden beim Anlegen wie Dictionaries in geschweifte Klammern eingeschlossen.

 dict = {&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot; }
 menge = {1, 1, 3, 4, 4, 4, &quot;Hallo&quot;}
 
 print(dict)
 print(menge)
 print(dict[&quot;vorname&quot;])

Ausgabe:
 {'vorname': 'Hugo', 'nachname': 'Meister'}
 {1, 3, 4, 'Hallo'}
 Hugo

Geschweifte Klammern ohne Inhalt stellen Dictionaries dar und keine Mengen:

 di = {}
 print(type(di))

Ausgabe:
 &lt;class 'dict'&gt;

Leere Mengen lassen sich mit &lt;code&gt;set()&lt;/code&gt; erzeugen:

 menge = set()      # leere Menge
 print(menge)
 menge.add(&quot;Hallo&quot;) # Element hinzufügen
 print(menge)

Ausgabe:
 set()
 {'Hallo'}

Beispiel (einige Mengenoperationen):
 mengeA = {&quot;Hallo&quot;, &quot;Welt&quot;}
 mengeB = {1, 2, &quot;Welt&quot;, 3}
 
 # Vereinigung
 print(mengeA | mengeB)
 print(mengeA.union(mengeB))
 
 # Durchschnitt
 print(mengeA &amp; mengeB)
 print(mengeA.intersection(mengeB))
 
 # Differenz
 print(mengeA - mengeB)
 print(mengeA.difference(mengeB))
 
 # Symmetrische Differenz
 print(mengeA ^ mengeB)
 print(mengeA.symmetric_difference(mengeB))
 
 # Teilmenge
 print(mengeA.issubset(mengeB))
 
 # Mehrere Elemente hinzu
 mengeA.update([&quot;Super&quot;, 67, 125])
 print(mengeA)
 
 # Element löschen
 mengeA.discard(&quot;Hallo&quot;)
 print(mengeA)

Ausgabe:
 {1, 2, 3, 'Welt', 'Hallo'}
 {1, 2, 3, 'Welt', 'Hallo'}
 {'Welt'}
 {'Welt'}
 {'Hallo'}
 {'Hallo'}
 {1, 2, 3, 'Hallo'}
 {1, 2, 3, 'Hallo'}
 False
 {67, 'Super', 'Welt', 'Hallo', 125}
 {67, 'Super', 'Welt', 125}

Es gibt schon seit &quot;ewigen&quot; Zeiten unveränderbare Mengen, die mittels &lt;code&gt;frozenset&lt;/code&gt; eingeleitet werden. Neu ab Python 3.15 ist dagegen das Pendant &lt;code&gt;frozendict&lt;/code&gt;, das unveränderbare Dictionaries darstellt.

 fdict = frozendict({&quot;vorname&quot;:&quot;Hugo&quot;, &quot;nachname&quot;:&quot;Meister&quot;})
 fset = frozenset({&quot;A&quot;, 1, &quot;A&quot;})
 
 print(fdict)
 print(fdict[&quot;vorname&quot;])
 print (fset) 
 
 try:
     fdict[&quot;vorname&quot;] = &quot;Max&quot;
     print(fdict[&quot;vorname&quot;])
 except TypeError as e:
     print(f&quot;Fehler: {e}&quot;)
 
 try:
     fset.add(&quot;B&quot;)
     print(fset)
 except AttributeError as e:
     print(f&quot;Fehler: {e}&quot;)

Ausgabe:
 frozendict({'vorname': 'Hugo', 'nachname': 'Meister'})
 Hugo
 frozenset({1, 'A'})
 Fehler: 'frozendict' object does not support item assignment
 Fehler: 'frozenset' object has no attribute 'add'

== List Comprehensions ==
Aus einer Eingabeliste soll eine Ausgabeliste erzeugt werden. Das kann folgendermaßen geschehen.

Mathematische Schreibweise: &lt;math&gt;lc = \{2x|x\in\ \mathbb{N}, 1\le x &lt; 11\}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11)]
 print(lc)

Ausgabe:
 [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Mathematische Schreibweise: &lt;math&gt;lc = \{2x | x \in \mathbb{N}, 1\le x &lt; 11, x \bmod 2 = 0 \}&lt;/math&gt;

Python-Code:
 lc = [x*2 for x in range(1,11) if x%2 == 0]
 print(lc)

Ausgabe:
 [4, 8, 12, 16, 20]

Siehe auch {{W|List Comprehension}}.

== Set Comprehensions ==
Dies ist sehr ähnlich wie im vorigen Abschnitt beschrieben. Es wird aber keine Liste, sondern eine Menge erzeugt.

 sc = {x*2 for x in range(1,11)}
 print(sc)

Ausgabe:
 {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}

== Listen zusammenführen - zip() ==
 li1 = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]
 li2 = [1, 2, 3, 4]
 li3 = [5.5, 6.6, 7.7, 8.8]
 
 z = zip(li1, li2, li3)
 print(z)
 
 li4 = list(z)
 print(li4)

Ausgabe:
 &lt;zip object at 0x00000283B6C6AC80&gt;
 [('A', 1, 5.5), ('B', 2, 6.6), ('C', 3, 7.7), ('D', 4, 8.8)]

== Generatorausdruck ==
 g = (i*2 for i in range(1,11))
 print(g)
 t = tuple(g)
 print(t)
 print(t[1:3])

Ausgabe:
 &lt;generator object &lt;genexpr&gt; at 0x00000241D2A4A5A0&gt;
 (2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
 (4, 6)

== Slicing ==
slice ... Scheibe, Teil, in Scheiben schneiden

Beispiel: Zugriff auf Elemente eines geordneten sequentiellen Objekttyps (Liste, Tupel oder String):

 str1 = &quot;Hallo&quot;
 # Das erste Element wird mit dem Index 0 angesprochen
 # [start (inkl.) : stop (exkl.) : step (default=1)]
 str2 = str1[0:2]
 # Alternativ auch: str2 = str1[:2] 
 print(str2)
 
 tup1 = (0,1,2,3)
 # Das letzte Element hat auch den Index -1, das vorletzte den Index -2 usw.
 tup2 = tup1[-3:-1]
 print(tup2)
 
 lst1 = [[1,  5,  10, 20],
         [30, 40, 50, 60]]
 lst2 = lst1[1][1]
 print(lst2)
 
Ausgabe:
 Ha
 (1, 2)
 40

Beispiel:

 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2])
 print(x[-3]) 
 print(x)
 print(x[:])
 print(x[2:])
 print(x[:2])
 print(x[::-1])

Ausgabe:

 c
 c
 ('a', 'b', 'c', 'd', 'e')
 ('a', 'b', 'c', 'd', 'e')
 ('c', 'd', 'e')
 ('a', 'b')
 ('e', 'd', 'c', 'b', 'a')

Visualisierung:

    '''a'''     '''b'''     '''c'''     '''d'''     '''e'''
 +-----------------------------+
 |  0  |  1  |//'''2'''//|  3  |  4  |
 +-----------------------------+
 | -5  | -4  |/'''-3'''//| -2  | -1  | 
 +-----------------------------+
 |/////////////////////////////|
 +-----------------------------+
 |/////////////''':'''///////////////|
 +-----------------------------+
 |     |     |///////'''2:'''////////|
 +-----------------------------+
 |////''':2'''/////|     |     |     |
 +-----------------------------+
 |\\\\\&lt;--\\\\\'''::-1'''\\\\&lt;--\\\\\|
 +-----------------------------+

Beispiel:
 x = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;)
 print(x[2::2])
 print(x[2::-1])
 print(x[2:0:-1])

Ausgabe:

 ('c', 'e')
 ('c', 'b', 'a')
 ('c', 'b')

Hier sieht man sehr schön, dass beim letzen &lt;code&gt;print&lt;/code&gt;-Befehl die 0, die in diesem Fall den Buchstaben &quot;a&quot; repräsentiert, als letzer Wert nicht mehr dazugehört (wie weiter oben angedeutet ist der End- oder Stoppwert exklusiv). Will man den Buchstaben &quot;a&quot; dazunehmen, so ist die vorletzte Zeile die richtige.

Beispiel: Umdrehen von Strings

 str1 = &quot;Hallo&quot;
 str2 = str1[::-1]
 print(str2)

Ausgabe:
 ollaH

Mit zweidimensionalen Listen/Tupels wird das Ganze schon bedeutend komplexer.

Beispiel: Verkettetes Slicing

 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
     
 print(A[2::][::2])

Ausgabe:

 [['20', '21', '22', '23'], ['40', '41', '42', '43']]

Das erste Slicing erstellt folgenden Slice:

 [[&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
  [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
  [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]

Das zweite Slicing wird dann auf diesen Slice angewendet und ergibt das genannte Endergebnis. Will man Spalten statt Zeilen, so funktioniert dieser direkte Weg nicht. Man verwendet dann List Comprehensions oder die NumPy-Bibliothek. Diese Bibliothek erlaubt [[Ing_Mathematik:_Python#Zugriff_auf_Matrizenelemente|zweidimensionales Slicing]]. Sie wird erst später bei den Grafiken eingeführt. Deshalb wird hier dazu noch kein Beispiel gezeigt.

= Objektorientierte Programmierung =
{{Wikipedia|Objektorientierte Programmierung}}

* {{W|Klasse (Objektorientierung)|Klasse}} ... die Schablone oder der Bauplan, enthält Methoden und Attribute
* {{W|Objekt (Programmierung)|Objekt}} ... eine Klasseninstanz (die konkrete Ausprägung der Klasse)
* {{W|Attribut (Programmierung)|Attribute}} ... die Eigenschaften eines Objekts
* {{W|Methode (Programmierung)|Methoden}} ... die Aktionen (Operationen), die ein Objekt ausführen kann
* {{W|Vererbung (Programmierung)|Vererbung}} ... neue Klassen (Subklassen, Unterklassen, abgeleitete Klassen) aus vorhandenen Klassen (Superklassen, Oberklassen, Basisklassen, Elternklassen) ableiten. Ermöglicht den Aufbau von Klassenhierarchien. Die Subklasse &quot;erbt&quot; Attribute und Methoden von der Superklasse. Python unterstützt (so wie C++, aber im Gegensatz zu Java) Mehrfachvererbung.

== UML ==
* {{W|Unified Modeling Language|UML}} ... '''U'''nified '''M'''odeling '''L'''anguage, eine Modellierungssprache. Die UML enthält zahlreiche Diagrammarten, um Programme zu modellieren. Im Nachfolgenden wird nur das {{W|Klassendiagramm}} verwendet.

[[File:UmlCd Klasse-3.svg|300px]]

* {{W|Sichtbarkeit (Programmierung)|Sichtbarkeit}}:
** + ... public (öffentlich)
** - ... private
** # ... protected 

* {{W|Attribut_(UML)#Attribute_für_Instanzen_und_für_Klassen|Klassenattribute}} (statische Attribute): Werden nur einmal pro Klasse angelegt. Im Klassendiagramm werden sie unterstrichen.

[[File:Attribute-3.png|200px]]

* Vererbung:

&lt;gallery&gt;
InheritancePgmUML.svg | Abgeleitete Klasse erbt von Basisklasse (Einfachvererbung)
Diamond inheritance.svg | D erbt von B und C (Mehrfachvererbung). B und C erben von A (Einfachvererbung)
&lt;/gallery&gt;

Für weitergehende Betrachtungen zur UML wird auf Spezialliteratur verwiesen, z.B.:
* Seidl et al.: UML@Classroom. dpunkt, 2012, ISBN 978-3-89864-776-2
* Rupp et al.: UML 2 glasklar. Hanser, 4. Aufl., 2012, ISBN 978-3-446-43057-0

== Eine einfache Klasse ==

[[Datei:PythonIng_uml1.svg | 200px]]

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
 
 fahr = Fahrzeug(150, 90)
 
 print(fahr.convertGeschw())
 
Ausgabe:
 41.666666666666664

Die Klasse Fahrzeug wird durch das class-Schlüsselwort eingeleitet. raeder ist ein Klassenattribut und public. __init__ wird bei der Objekterzeugung automatisch aufgerufen (ist der sogenannte Konstruktor). Man achte darauf, dass diese Methode immer mit zwei Unterstrichen eingeleitet und abgeschlossen wird. Instanzattributen wird das Wort self vorangestellt. Wir sehen uns z.B. das Attribut self.__geschwind an. Auch hier werden zwei Unterstriche verwendet. Das bedeutet, dass dieses Attribut strikt/stark private ist. Wird nur ein Unterstrich verwendet, so deutet dies auf schwach/weakly private hin. Letzteres wird in Python deutlich häufiger verwendet. Bei den Methoden wird immer self als erster Parameter angegeben. Beim Aufruf der entsprechenden Funktion wird das self aber nicht berücksichtigt.

Besonderheiten bei stark und schwach private:
* '''stark private''':
** zwei führende Unterstriche
** Name Mangling: Name wird zu &lt;code&gt;_Klassenname__variablenname&lt;/code&gt;
** Schutz vor Namenskollisionen bei Vererbung
** am Ende des Namens dürfen keine zwei Unterstriche verwendet werden. Das wären dann Magic Methods oder Dunder-Methods (z.B. __init__). Diese sind public.

* '''schwach private''':
** ein führender Unterstrich
** Name bleibt gleich
** ist nur ein Hinweis an die Programmierer, kein starker Schutz
** &lt;code&gt;from modul import *&lt;/code&gt;: Objekte mit einem führenden Unterstrich werden standardmäßig nicht importiert
** Standard für die Kapselung bei Python. Schätzung: Weit mehr als 80% der nicht-öffentlichen Attribute/Methoden werden als schwach private deklariert. Weniger als 5-10% als stark private (Quelle: Google KI)

== Klassen importieren ==
Häufig ist es sinnvoll und übersichtlicher Klassen in eigenen Dateien zu speichern. Das sind dann eigene Module. Abgespeichert werden Sie mit der Endung py, wie bisher auch praktiziert. Aufgerufen werden Sie mit der import-Anweisung. Dann ist aber nur der Dateiname ohne Endung py zu verwenden. Klarer wird das mit einem Beispiel.

Datei c:\tmp\fahrzeug.py

 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
         
     def setLeistung(self, leistung):
         self.__leistung = leistung
         
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6

Datei c:\tmp\test1.py

 import fahrzeug
 fahr = fahrzeug.Fahrzeug(150, 90)
 print(fahr.convertGeschw())

Ausgabe:
 41.666666666666664

Die üblichen import-Anweisungen lauten wie folgt:
{| {{prettytable}}
! import-Befehl
! Instanz
|-
| import xyz      || xyz.Klasse
|-
| import xyz as x || x.Klasse
|-
| from xyz import Klasse || Klasse
|-
| from xyz import * || Klasse 
|}

Der Vorteil der ersten beiden import-Anweisungen ist, dass es kaum zu Namenskollisionen kommen kann. Dafür hat man bei den letzten beiden Varianten weniger Tipparbeit.

== Vererbung ==
=== Einfachvererbung ===

[[Datei:PythonIng_uml2.svg | 200px]]

Datei fahrzeug.py:
 class Fahrzeug:
     raeder = 4
    
     def __init__(self, geschwindigkeit, leistung):
         self.__geschwind = geschwindigkeit
         self.__leistung = leistung
         
     def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
         self.__geschwind = geschwindigkeit
        
     def setLeistung(self, leistung):
         self.__leistung = leistung
        
     def convertGeschw(self):
         # geschwindigkeit in m/s rueckgeben
         return self.__geschwind / 3.6
        
        
 class Luftfahrzeug(Fahrzeug):
     def __init__(self, geschwindigkeit, leistung, fluegel):
         super().__init__(geschwindigkeit, leistung)
         self.__flueg = fluegel
     
     def getFlueg(self):
         return self.__flueg

Datei test1.py:
 import fahrzeug
 fahr = fahrzeug.Luftfahrzeug(150, 90, 4)
 print(fahr.getFlueg())

Ausgabe:
 4

=== Mehrfachvererbung ===
Mit Python ist auch Mehrfachvererbung möglich, z.B.:

 class A:
     def _printA(self):
         print(&quot;Klasse A&quot;)
 
 class B:
     def _printB(self):
         print(&quot;Klasse B&quot;)
 
 class C(A,B):
     def __init__(self):
         self._printA()
         self._printB()
 
 c = C()

Ausgabe:

 Klasse A
 Klasse B

Die Klasse C erbt von A und B. In UML sieht das in etwa so aus:

 +-----------------------------+   +-------------------------+
 |            A                |   |          B              |
 +-----------------------------+   +-------------------------+
 |                             |   |                         |
 +-----------------------------+   +-------------------------+
 | # printA()                  |   | # printB()              |
 +-----------------------------+   +-------------------------+
                           .              .
                          / \            / \
                          ---            ---
                           |              |
                           |              |
                        +---------------------+
                        |          C          |
                        +---------------------+
                        |                     |
                        +---------------------+
                        |                     |
                        +---------------------+

&lt;code&gt;printA()&lt;/code&gt; und &lt;code&gt;printB()&lt;/code&gt; sind schwach private (in UML als &lt;code&gt;protected&lt;/code&gt; mit einem # dargestellt). Es ist aber zu beachten, dass schwach private nur Konvention ist. Praktisch könnte man auch von außerhalb auf diese Methoden zugreifen. Das soll man aber nicht tun, und das wird in Python durch einen Unterstrich angedeutet.

== Statische Attribute, statische Methoden und Klassenmethoden ==
Beispiel:

 class Math:
     pi = 3.14159265
     cnt = 0
     
     @staticmethod
     def expo():
         return 2.71828183
    
     @classmethod    
     def counterPlus(cls):
         cls.cnt += 1
        
 print(Math.pi)
 print(Math.expo())
 
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)
 Math.counterPlus()
 print(Math.cnt)

Ausgabe:

 3.14159265
 2.71828183
 1
 2
 3

Statische Attribute und Methoden, bzw. Klassenmethoden, sind direkt einer Klasse zugeordnet und nicht einem Objekt. Der Unterschied zwischen statischen Methoden und Klassenmethoden ist, dass statische Methoden nicht auf Klassenattribute (bzw. statische Attribute) zugreifen können, Klassenmethoden aber schon. &lt;code&gt;pi&lt;/code&gt; und &lt;code&gt;cnt&lt;/code&gt; sind statische Attribute. &lt;code&gt;expo()&lt;/code&gt; ist eine statische Methode. &lt;code&gt;counterPlus(cls)&lt;/code&gt; ist eine Klassenmethode. Die Bezeichnung des Parameters als &lt;code&gt;cls&lt;/code&gt; ist reine Konvention, man sollte sich aber daran halten. &lt;code&gt;@staticmethod&lt;/code&gt; und &lt;code&gt;@classmethod&lt;/code&gt; nennt man auch Dekoratoren.

= Grafiken zeichnen =
Für das Zeichnen von Grafiken wird hier das Modul &lt;code&gt;matplotlib&lt;/code&gt; verwendet. &lt;code&gt;matplotlib&lt;/code&gt; ist ein externes Modul und muss vor der ersten Verwendung installiert werden. Das geht so:

# Starten Sie ein Terminal (bei Windows die Eingabeaufforderung).
# Führen Sie darin folgenden Befehl aus &lt;code&gt;c:\devel\Python\Scripts\pip.exe install matplotlib&lt;/code&gt;

pip ist übrigens der Paketmanager von Python ({{W|Pip_(Python)}}). 

Optimalerweise installieren wir auch gleich das Modul &lt;code&gt;numpy&lt;/code&gt; (Numerical Python). Wir werden es im Folgenden oft benötigen (nicht nur bei den Grafiken). Das funktioniert vom Prinzip her genauso, wie für &lt;code&gt;matplotlib&lt;/code&gt; gezeigt.

&lt;small&gt;Verwenden Sie Spyder, so sind diese Schritte nicht nötig. Spyder inkludiert diese Pakete standardmäßig. Unter openSUSE Tumbleweed lassen sich diese Pakete mittels YaST oder zypper installieren.&lt;/small&gt;

== 2D ==
=== Graph einer Funktion ===
Es soll die cosh-Funktion im Intervall &lt;math&gt;x\in[-3,3]&lt;/math&gt; gezeichnet werden. Der Programmcode lautet in der einfachsten Form:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x)
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:PythonIng_cosh1.jpg]]

Der Code ist quasi selbsterklärend. Das Untermodul pyplot des matplotlib-Moduls und das numpy-Modul werden importiert. x läuft von -3 bis +3. y wird für jeden x-Wert per Formel ausgerechnet. &quot;plt.plot()&quot; ist der Zeichenbefehl. &quot;plt.show&quot; ist notwendig, um das Fenster mit der Grafik anzuzeigen.
Die Schrittweite 0.1 wurde so gewählt, um einen ausreichend glatten Verlauf des Graphen zu gewährleisten. Das ist immer ein Kompromiss zwischen Berechnungszeit und Ansehnlichkeit. Testen Sie einfach ein paar verschiedene Werte, um ein Gefühl dafür zu zu bekommen. &quot;plt.grid()&quot; zeichnet ein Gitter in die Grafik (kann auch weggelassen werden).
Die Bezeichnungen plt und np könnten auch anders gewählt werden. Es ist aber Konvention, diese so wie hier gezeigt zu wählen. Die &quot;arange&quot;-Funktion aus der NumPy-Bibliothek wird später ein bisschen genauer behandelt (siehe [[Ing_Mathematik:_Python#Zahlenfolgen|Zahlenfolgen]]).  

&lt;small&gt;Mit der im obigen Bild gezeigten Menüleiste kann die dargestellte Grafik nachträglich noch geändert werden (Zoom, Pan, Achsenparameter, Kurvenparameter etc.). Natürlich kann man das alles auch direkt programmieren. Wie das funktioniert wird ansatzweise etwas später gezeigt.&lt;/small&gt;

Ein etwas komplexeres Beispiel ist Folgendes:

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y = np.cosh(x) + 2**x
 
 plt.plot(x,y)
 plt.grid()
 plt.show()

Ausgabe:
[[Datei:PythonIng_cosh4.png]]

Man beachte, dass im Gegensatz zu Octave und Julia der ominöse Punkt (.) bei 2**x mit Python nicht benötigt wird. Das macht das Programmiererleben etwas einfacher.

Die Farbe des Graphen kann man über den &lt;code&gt;color&lt;/code&gt;-Schalter einstellen, z.B. auf rot setzen:
 plt.plot(x, y, color=&quot;red&quot;)

Das ist nur eine Möglichkeit, es gibt auch andere, z.B. mittels
* hexadezimaler Zahl, z.B. &lt;code&gt;color=&quot;#ff0000&quot;&lt;/code&gt;
* Kurzform, z.B. &lt;code&gt;&quot;r&quot;&lt;/code&gt;

Statt &lt;code&gt;color&lt;/code&gt; kann auch die Kurzform &lt;code&gt;c&lt;/code&gt; verwendet werden.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie diese &quot;Farbspielereien&quot; am Computer aus.

=== Graphen mehrerer Funktionen und weiteres ===
==== Mehrere Funktionen in einen Plot zeichnen ==== 
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh2.png]]

Um die Linienstile etwas individueller zu gestalten, ist folgender Programmcode gedacht: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(-3., 3.1, .1)
 y1 = np.cosh(x) + 2**x
 y2 = np.sin(x) * np.cos(x)
 
 plt.plot(x, y1, label = &quot;cosh(x) + 2**x&quot;, lw=5, ls=&quot;dotted&quot;)
 plt.plot(x, y2, label = &quot;sin(x) * cos(x)&quot;, lw=3, ls=&quot;--&quot;)
 plt.grid()
 plt.title(&quot;Funktionsgraphen&quot;)
 plt.xlabel(&quot;x&quot;)
 plt.ylabel(&quot;y&quot;)
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

[[Datei:PythonIng_cosh3.png]]

Einige weitere Bespiele zu &lt;code&gt;ls&lt;/code&gt;&lt;/code&gt;:
* - ... durchgezogene Linie
* -. ... Strichpunkt-Linie
* dashed ... gestrichelte Linie 

==== Marker ====
Desweiteren kann man Marker verwenden.

Beispiel:

 import matplotlib.pyplot as plt
 
 plt.plot(10, 10, &quot;ob&quot;, markersize=30)
 plt.plot(20,20, &quot;.r&quot;)
 plt.plot(30,30, &quot;Dg&quot;, ms=15)
 plt.plot(40, 40, &quot;ok&quot;, ms=20, mec=&quot;#FF5733&quot;, mew=3)
 plt.plot(50, 50, &quot;vk&quot;, ms=20, mec=&quot;yellow&quot;, mew=3)
 plt.grid()
 plt.show()


Das erste Zeichen im String nach den Koordinaten im plot-Befehl symbolisiert die Form (z.B. o für einen Kreis). Das zweite Zeichen steht für die Farbe (z.B. b für blue). &lt;code&gt;markersize&lt;/code&gt; oder &lt;code&gt;ms&lt;/code&gt; setzt die Größe des Markers.

Ausgabe:

[[Bild:PythonIng_formatpara1.svg|200px]]

Einige weitere Marker:
* * ... Stern
* + ... Plus
* h oder H ... Sechseck

Man kann mit den Parametern 
* &lt;code&gt;markeredgecolor&lt;/code&gt; oder kurz &lt;code&gt;mec&lt;/code&gt; die Farbe des Markerrandes
* &lt;code&gt;markeredgewidth&lt;/code&gt; oder kurz &lt;code&gt;mew&lt;/code&gt; die Dicke des Randes
* &lt;code&gt;markerfacecolor&lt;/code&gt; oder kurz &lt;code&gt;mfc&lt;/code&gt; die Innenfarbe des Markers
bestimmen.

=== Funktion in Parameterdarstellung ===
Es soll die archimedische Spirale &lt;math&gt;x = t \cos(t), y = t  \sin(t)&lt;/math&gt; im Intervall &lt;math&gt;[0, 6\pi[&lt;/math&gt; gezeichnet werden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
  
 plt.show()

[[Datei:PythonIng_spirale1.png]]

Diese Darstellung erscheint verzerrt. Will man gleiche Achsenskalierungen, so kann man den plt.axis()-Befehl verwenden.

 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0., 6*np.pi, .1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 
 plt.plot(x, y)
 plt.grid()
 plt.title(&quot;Archimedische Spirale&quot;)
 plt.axis(&quot;equal&quot;)
 
 plt.show()
 
[[Datei:PythonIng_spirale2.png]]

=== Funktion in Polardarstellung ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 fig = plt.figure()
 ax = fig.add_subplot(projection=&quot;polar&quot;)
 r = np.arange(0, 1, 0.01)
 theta = r**3
 line = ax.plot(theta, r)
 
 plt.show()

[[Datei:PythonIng_polar1.png]]

=== Logarithmische Achsenskalierung ===
==== Semilog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.semilogy()
 plt.show()

Ausgabe:

[[Datei:PythonIng_semilog1.png]]

==== LogLog ====
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0., 10, .1)
 y = 10**x
 
 plt.plot(x, y)
 plt.grid()
 plt.loglog()
 plt.show()

[[Datei:PythonIng_loglog1.png]]

=== Gefüllte Fläche ===
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.arange(0, 3, 0.1)
 
 y1 = 3*x - 1
 y2 = x**2
 
 plt.plot(x, y1, x, y2, color='black')
 plt.fill_between(x, y1, y2, where=y1&gt;=y2)
 
 plt.show()

[[Datei:PythonIng_gefuellt.png]]

=== Linien, Pfeile, Rechtecke, Kreise und Texte ===
 import matplotlib as mpl
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 r = mpl.patches.Rectangle((0, 0), 3, 3, angle=30, fill=False)
 c = mpl.patches.Circle((4, 4), 2, fill=False)
 
 ax.add_patch(r)
 ax.add_patch(c)
 ax.plot([-2, 7], [-2, 0], color=&quot;black&quot;)
 ax.arrow(0, 7, 5, 0, length_includes_head=True, head_width=0.5, head_length=1.5,
          color=&quot;black&quot;)
 
 ax.set_aspect(&quot;equal&quot;)
 
 plt.axis([-3, 8, -3, 8])
 plt.show() 

[[Datei:PythonIng_linien_pfeile_etc.png]]

Text kann mit &lt;code&gt;ax.text(x, y, &quot;Text&quot;)&lt;/code&gt; hinzugefügt werden, bspw.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 ax.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

Oder einfacher auch ohne &lt;code&gt;subplots&lt;/code&gt;

 import matplotlib.pyplot as plt
 
 plt.text(0.1, 0.1, &quot;Hallo&quot;)
 plt.text(0.5, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
         rotation=30.0)
 
 plt.show() 

[[Datei:PythonIng_text1.png]]

Auch Sonderzeichen (griechische Buchstaben etc.) können verwendet werden (siehe dazu auch [https://matplotlib.org/stable/users/explain/text/mathtext.html]).

 import matplotlib.pyplot as plt
 
 plt.text(.3, .5,
          r'$\Omega\ \psi\ \oint\ \nabla\ \dot a\ \frac{a}{b}\ a_b$',
          size=&quot;20&quot;)
 plt.show() 

[[Datei:PythonIng_text20.svg]]

Jetzt wird noch gezeigt, wofür &lt;code&gt;subplots&lt;/code&gt; sinnvoll eingesetzt werden können.

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(0.1, 0.1, &quot;Hallo&quot;)
 ax[1].text(0.1, 0.5, &quot;Welt&quot;, size=&quot;40&quot;, family=&quot;cursive&quot;, style=&quot;italic&quot;,
            rotation=30.0)
 
 plt.show()

[[Datei:PythonIng_text2.png]]

=== Anmerkungen hinzufügen ===
Anmerkungen (engl. annotations) lassen sich mit matplotlib einfach hinzufügen. Unter Anmerkung wird hier ein Pfeil mit Text verstanden.

Beispiel:

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 ax.plot([1,10], [1,10])
 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
             arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0))
 plt.show()

Ausgabe:

[[Datei: PythonIng_ann1.svg|400px]]

&lt;code&gt;shrink&lt;/code&gt; verkürzt den Pfeil. Sinnvoll sind beim obigen Beispiel Werte irgendwo zwischen 0.0 und 0.3.

&lt;u&gt;Kleine Aufgabe:&lt;/u&gt; Probieren Sie verschiedene Pfeillängen aus. 

Die Schriftgröße verändern können Sie übrigens mit &lt;code&gt;fontsize&lt;/code&gt; oder &lt;code&gt;size&lt;/code&gt;, z.B.

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops=dict(facecolor=&quot;red&quot;, shrink=0.0), fontsize=25)

Eine andere Schreibweise für Dictionaries, die wir weiter oben schon kennengelernt haben, die wir aber nochmals explizit aufschreiben wollen, ist

 ax.annotate(&quot;Test&quot;, xy=(2, 2), xytext=(3, 5), 
            arrowprops={&quot;facecolor&quot;:&quot;red&quot;, &quot;shrink&quot;:0.0})

=== Figure, Axes etc.===
[[Bild:PythonIng_figure33.svg|350px]]

* fig (figure) ... das übergeordnete Fenster
* ax (axes) ... &quot;Plot&quot;, das eigentliche Zeichenfenster
* axis ... die Koordinatenachsen
* spine ... Begrenzungslinien des Zeichenfensters
* tick ... Markierung an den Achsen des Zeichenfensters

Beispiel (eine figure mit 6 axes, ax-Titel, y-axis-Titel):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=3, ncols=2)
 
 ax[0][0].text(0.1, 0.5, &quot;11&quot;)
 ax[0][1].text(0.1, 0.5, &quot;12&quot;)
 ax[1][0].text(0.1, 0.5, &quot;21&quot;)
 ax[1][1].text(0.1, 0.5, &quot;22&quot;)
 ax[2][0].text(0.1, 0.5, &quot;31&quot;)
 ax[2][1].text(0.1, 0.5, &quot;32&quot;)
 
 ax[0][0].set(ylabel=&quot;y-label&quot;, title=&quot;axes 1&quot;)
 
 plt.show()

[[Bild:PythonIng_figure34.png|350px]]

Beispiel (Achsenbereiche setzen):
 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 
 ax[0].axis((-1, 10, 1, 12))
 
 plt.show()

[[Bild:PythonIng_figure35.svg|350px]]

Beispiel (Gitter einschalten): 

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots(nrows=1, ncols=2)
 
 ax[0].text(5, 5, &quot;Hallo Welt&quot;)
 ax[1].text(.5, .5, &quot;Servus&quot;)
 ax[0].axis((-5, 10, 1, 12))
 ax[0].minorticks_on()
 ax[0].grid(which='minor')
 ax[1].grid(which='major')
 plt.show()

[[Bild:PythonIng_figure36.svg|350px]]

Beispiel (ticks setzen)

 import matplotlib.pyplot as plt
 import matplotlib.ticker as tick
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 pos = [0, .2, .5]
 lab = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
 
 ax.xaxis.set_major_locator(tick.FixedLocator(pos))
 ax.xaxis.set_major_formatter(tick.FixedFormatter(lab))
 
 plt.show()

[[Bild:PythonIng_figure37.svg|350px]]

Beispiel (Achsenkreuz beliebig setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.text(0.1, 0.5, &quot;11&quot;)
 
 ax.spines['top'].set_color('none')
 ax.spines['right'].set_color('none')
 ax.spines['bottom'].set_position(('data', 0.3))
 ax.spines['left'].set_position(('data', 0.5))
 
 plt.show()

[[Bild:PythonIng_figure38.svg|350px]]

Beispiel (Inset):

 import matplotlib.pyplot as plt
 
 # Hauptplot erstellen
 fig, ax = plt.subplots()
 ax.text(0.1, 0.1, &quot;Hallo&quot;)
 
 # Inset hinzu:
 axin = ax.inset_axes([0.4, 0.4, 0.3, 0.3])
 axin.text(0, 0, &quot;Servus&quot;)
 axin.plot()
 
 plt.show()

[[Bild:PythonIng_figure40.svg|350px]]

Beispiel (Hintergrundfarben setzen):

 import matplotlib.pyplot as plt
 
 fig, ax = plt.subplots()
 
 ax.set_facecolor(&quot;green&quot;)
 fig.set_facecolor(&quot;yellow&quot;)
 
 plt.plot([1, 3], [6, 8])
 plt.show()

[[Bild:PythonIng_figure39.svg|300px]]

=== GridSpec ===
Mit figures und axes lassen sich schon jede Menge an Grafikdetails einstellen. GridSpec ist dann der Turbo oder Raketenantrieb den matplotlib eingebaut hat. Naja, vielleicht ist das etwas übertrieben, aber GridSpec ist sozusagen ein flexibler Layout-Manager. Bisher haben wir immer gleich große axes gezeichnet. Mit GridSpec können wir Subplots über mehrere Zeilen und Spalten ziehen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 gs = fig.add_gridspec(3, 3)
 
 ax1 = fig.add_subplot(gs[0, :])
 ax1.set_title(&quot;Bereich 1: gs[0, :]&quot;)
 
 ax2 = fig.add_subplot(gs[1:, 0])
 ax2.set_title(&quot;Bereich 2: gs[1:, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 1:])
 ax3.set_title(&quot;Bereich 3: gs[1, 1:]&quot;)
 
 ax4 = fig.add_subplot(gs[2, 1:])
 ax4.set_title(&quot;Bereich 4: gs[2, 1:]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec1.svg|350px]]

Erklärung zu &lt;code&gt;(gs[zeile, spalte])&lt;/code&gt;: Slicing; damit legen Sie fest, welche Zellen ein Subplot belegt. Achtung! Die Indizes beginnen bei 0 und nicht bei 1 (d.h., die erste Zeile/Spalte hat den Index 0)
* : ... alle 
* 1: ... 1 bis Ende
* etc.

&lt;code&gt;constrained_layout=True&lt;/code&gt; sorgt dafür, dass sich die Subplots nicht überlappen.

Aber auch die Spaltenbreiten und Zeilenhöhen lassen sich anpassen.

Beispiel:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gs
 
 fig = plt.figure(constrained_layout=True)
 
 # Verhältnis erste zu zweite Zeile = 1.5:1
 # Verhältnis erste zu zweite Spalte  = 1:4
 gs = fig.add_gridspec(2, 2, figure=fig, height_ratios=[1.5, 1], width_ratios=[1, 4])
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax1.set_title(&quot;Bereich 1: gs[0, 0]&quot;)
 
 ax2 = fig.add_subplot(gs[0, 1])
 ax2.set_title(&quot;Bereich 2: gs[0, 0]&quot;)
 
 ax3 = fig.add_subplot(gs[1, 0])
 ax3.set_title(&quot;Bereich 3: gs[1, 0]&quot;)
 
 ax4 = fig.add_subplot(gs[1, 1:])
 ax4.set_title(&quot;Bereich 4: gs[1, 1]&quot;)
 
 plt.show()

[[Bild:PythonIng_gridspec2.svg|350px]]

Auch die Ränder lassen sich einstellen.

Beispiel 1:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.1, right=0.9, bottom=0.1,
                        top=0.9, wspace=0.2, hspace=0.2)
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec3.svg|300px]]

* hspace ... height space, vertikaler Abstand zwischen den Zeilen
* wspace ... width space, horizontaler Abstand zwischen den Spalten

Und im Vergleich dazu Beispiel 2:

 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
 
 fig = plt.figure()
 
 gs = gridspec.GridSpec(2, 2, left=0.3, right=0.7, bottom=0.3, 
                        top=0.7, wspace=0.3, hspace=0.3) 
 
 ax1 = fig.add_subplot(gs[0, 0])
 ax2 = fig.add_subplot(gs[1, 0])
 ax3 = fig.add_subplot(gs[0, 1])
 ax4 = fig.add_subplot(gs[1, 1])
 
 plt.show()

[[Bild:PythonIng_gridspec4.svg|300px]]

Es gibt noch einige weitere Details, die sich mit GridSpec variieren lassen (z.B. SubGridSpec ... verschachtelte Grid-Layouts). Aber wir belassen es vorerst dabei. Das bisher Gezeigte sollte für die meisten Probleme ausreichend sein.

=== Aufgaben ===
* Zeichnen Sie die Strophoide &lt;math&gt;x = \frac{a(t^2-1)}{t^2+1}, y = \frac{at(t^2-1)}{t^2+1}, a = 2, -3 \leq t \leq 3&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_strophoide.jpg|300px|center]]

* Zeichnen Sie die verschlungene Hypozykloide &lt;math&gt;x = (R-r)\cos t + c\cos\frac{R-r}{r}t, y = (R-r)\sin t - c\sin\frac{R-r}{r}t, c = 3, r = 2, R = 6, -15 \leq t \leq 15&lt;/math&gt;. Das Ganze sollte in etwa so aussehen wie folgende Grafik:

[[Datei:octave_hypozykloide.jpg|300px|center]]

* Testen Sie bei den obigen Übungsaufgaben verschiedene Linienstile und Farben. Farben können mit dem plt.plot()-Parameter color gewählt werden.

* Testen Sie bei den obigen Übungsaufgaben verschiedene Werte für a, c, r und R.

* Zeichnen Sie folgendes Bild (die Achsenbeschriftungen positionieren Sie z.B. mit den Befehlen &lt;code&gt;ax.set_xlabel(&quot;x&quot;, loc=&quot;right&quot;); ax.set_ylabel(&quot;y&quot;, loc=&quot;top&quot;)&lt;/code&gt;):

[[Bild:PythonIng_aufgabe24.svg|400px|center]] 

* Zeichnen Sie mit Python, matplotlib und NumPy folgendes Bild:

[[Bild:PythonIng_figure41.svg|400px|center]]

* Zeichnen Sie mit GridSpec ein Layout, das in etwa wie folgendes aussieht (&lt;code&gt;height_ratios=[1, 2], width_ratios=[2, 1]&lt;/code&gt;):

[[Bild:PythonIng_aufgabe23.svg|300px|center]]

== 3D ==
=== Räumliche Kurven ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 t = np.arange(0, 6*np.pi, 0.1)
 x = t * np.cos(t)
 y = t * np.sin(t)
 z = t
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot(x, y, z)
 
 plt.show()

[[Datei:PythonIng_raumkurve1.png]]

=== Flächen ===
 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche1.png]]

Das Ganze in Netzdarstellung läßt sich so programmieren: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.5)
 y = np.arange(0, 10, 0.5)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_wireframe(x, y, z)
 
 plt.show()

[[Datei:PythonIng_fläche2.png]]

Ein etwas komplexeres Beispiel:

 import matplotlib.pyplot as plt
 import numpy as np 
 
 x = np.arange(0.1, 10, 0.1)
 y = np.arange(0.1, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z1 = np.sin(x) + 3 * np.cos(y)
 z2 = np.sin(x) + np.log(y)
 z3 = x + np.cos(y)
 z4 = x**2 - y
  
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;}, nrows=2, ncols=2)
 
 ax[0][0].plot_surface(x, y, z1)
 ax[0][1].plot_surface(x, y, z2)
 ax[1][0].plot_surface(x, y, z3)
 ax[1][1].plot_surface(x, y, z4)
 
 plt.show()

[[Datei:PythonIng_subplot1.png]]

Man beachte, dass man die Unterbilder im Bild nach dem Ausführen des Scripts z.B. mit der mittleren Maustaste einzeln drehen, oder über die Einträge in der Menüzeile einzeln bearbeiten kann. Mit ein paar Zeilen Programmtext lässt sich also eine Menge an Funktionalität generieren.

Die Farbgebung lässt sich über &lt;code&gt;colormaps&lt;/code&gt; variieren.

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm)
 
 plt.show()

[[Datei:PythonIng_colormap1.png]]

Es gibt eine Menge an Colormaps, z.B. &lt;code&gt;plasma, Greys, Dark2, ocean&lt;/code&gt;. Zwecks detaillierterer Infos siehe die matplotlib-Dokumentation. &lt;small&gt;Verwendet man die IDE namens IDLE, so gibt es dort auch die automatische Codevervollständigung. D.h. es werden alle Möglichkeiten (in unserem Fall nach dem Eintippen von &lt;code&gt;cm.&lt;/code&gt; alle verfügbaren Colormaps) angezeigt.&lt;/small&gt;

Die &quot;edgecolor&quot; und Linienbreite können auch frei gewählt werden:

 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib import cm
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots(subplot_kw={&quot;projection&quot;: &quot;3d&quot;})
 ax.plot_surface(x, y, z, cmap = cm.coolwarm, edgecolor=&quot;black&quot;, linewidth=1.0)
 
 plt.show()

[[Datei:PythonIng_colormap2.png]]

=== Höhenlinien ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 ax.contour(x, y, z)
 
 plt.show()

[[Datei:PythonIng_höhenlinien1.png|400px]]

Etwas abgewandelt sieht das so aus: 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contour(x, y, z)
 ax.clabel(hl, inline = True)
 
 plt.show()

[[Datei:PythonIng_höhenlinien2.png|400px]]

Und noch eine Variante (mit einem Farbbalken) sei gezeigt. 

 import matplotlib.pyplot as plt
 import numpy as np
 
 x = np.arange(0, 10, 0.1)
 y = np.arange(0, 10, 0.1)
 x, y = np.meshgrid(x, y)
 z = np.sin(x) + 3 * np.cos(y)
 
 fig, ax = plt.subplots()
 hl = ax.contourf(x, y, z)
 fig.colorbar(hl) 
 
 plt.show()

[[Datei:PythonIng_höhenlinien5.svg|400px]]

=== Aufgaben ===
* Zeichnen Sie die räumliche Kurve &lt;math&gt;x = 2 \cdot \cosh(t)&lt;/math&gt;, &lt;math&gt;y = 5 \cdot \sin(t)&lt;/math&gt;, &lt;math&gt; z = t^{2} - t&lt;/math&gt;, &lt;math&gt;0 \leq t \leq 3\pi&lt;/math&gt;.
* Zeichnen Sie die Fläche &lt;math&gt;z = \log(x) + \cos(y)&lt;/math&gt;.

== Animationen und fortgeschrittenes 3D ==
=== Mit matplotlib ===
Auch mit matplotlib sind Animationen möglich. Das ist ein bisschen komplizierter und wird deshalb hier nur mit einem sehr einfachen Beispiel dargestellt (bei Interesse siehe z.B. auch das [https://matplotlib.org/stable/users/explain/animations/animations.html#animations Animations using Matplotlib-Tutorial]).

 import matplotlib.pyplot as plt
 import matplotlib.animation as ani
 import matplotlib
 import numpy as np
 
 def update(frame):
     line.set_xdata(x[:frame])
     line.set_ydata(y[:frame])
     return (line)
 
 fig, ax = plt.subplots()
 
 x = np.arange(0, 10, .1)
 y = np.sin(x)
 
 line, = ax.plot(x[0], y[0])
 ax.set(xlim=[0, 10], ylim=[-1, 1])
 
 a = ani.FuncAnimation(fig=fig, func=update, frames=100, interval=20)
 plt.show()
 
 # Speichere die Animation in einem animierten GIF (optional)
 a.save(filename=&quot;c:/tmp/PythonIng_anim5.gif&quot;, writer=&quot;pillow&quot;)

[[Datei:PythonIng_anim5.gif]]

Es wird eine Sinuskurve auf den Bildschirm gezeichnet. In der letzten Zeile wird diese Animation in ein animiertes GIF gespeichert. Das ist natürlich optional und kann auch weggelassen werden.

=== Mit VPython ===
Aber auch mit dem Modul VPython lassen sich einfache 3D-Animationen erstellen. VPython ist ein externes Modul, das vorab installiert werden muss. Unter openSUSE Tumbleweed gibt es dzt. kein entsprechendes rpm-Paket. Die übliche Methode der Installation mittels YaST oder zypper ist somit nicht möglich. Auch eine direkte Verwendung von pip führt nur zu einer Fehlermeldung (&lt;code&gt;error: externally-managed-environment&lt;/code&gt;). Es empfiehlt sich dort folgende Vorgehensweise:
# Erstelle zuerst eine virtuelle Umgebung, z.B.: &lt;code&gt;python3.11 -m venv ~/tmp/venv1&lt;/code&gt;
# Wechsle das Verzeichnis: &lt;code&gt;cd ~/tmp/venv1/bin&lt;/code&gt;
# Installiere das entsprechende Paket: &lt;code&gt;./pip install vpython&lt;/code&gt;
# Führe das entsprechende Skript aus: &lt;code&gt;./python ~/tmp/test1.py&lt;/code&gt;

Aktuell (März 2026) ist dieses Programmpaket lt. der [https://vpython.org/presentation2018/install.html VPython-Homepage] nur für die Python-Versionen 3.8 bis 3.12 verfügbar.

Ein Beispiel zu einer einfachen Animation wird nachfolgend geliefert.

 from vpython import *
 
 scene.width = 1200
 scene.height = 600
 scene.center = vector(20,0,0)
 scene.background = color.white
 
 cylinder(pos=vector(0,0,0), axis=vector(20,0,0), radius=5, 
         color=color.blue)
 cone(pos=vector(0,0,0), axis=vector(-10,0,0), radius=5, 
         color=color.blue)
 helix(pos=vector(20,0,0), axis=vector(40,0,0), radius=2, 
         coils=10, thickness=0.5, color=color.blue)
 
 ball = sphere(pos=vector(20,0,0), color = color.green, radius = 1)
 ball.p = vector(0.15, 0, 0)
 
 toc = True
 
 while True:
     rate(200)
     if(ball.pos.x &lt;= 60 and toc == True):
         ball.pos += ball.p
     else:
         toc = False
         ball.pos -= ball.p
         if(ball.pos.x &lt;= 20 and toc == False):
             toc = True

[[Datei:PythonIng_vpython_anim.JPG]]

Idealerweise öffnet sich beim Ausführen des Scripts ein Browserfenster. Darin wird die programmierte Animation gezeigt (siehe auch den obigen Screenshot). Eine Größenänderung können Sie mit der mittleren Maustaste initiieren. Die Szenerie drehen können Sie mit der rechten Maustaste.

=== Mit build123d ===
Hiermit lassen sich einfach 3D-Modelle für CAD-Systeme erstellen. [https://build123d.readthedocs.io/en/latest/ build123d] ist ein externes Modul und muss vorab, wie schon für mehrere andere Module gezeigt, installiert werden (pip, venv etc.).

Beispielcode:

 from build123d import *
 
 # Bauteil
 with BuildPart() as bauteil: 
     # Zylinder erstellen
     Cylinder(100, 60)
        
     # Bohrung
     with BuildSketch(bauteil.faces().sort_by(Axis.Z)[-1]) as loch:
         Circle(radius=10)
     # negativ extrudieren
     extrude(amount=-60, mode=Mode.SUBTRACT)
     
     # Dem Bauteil z.B. die Farbe rot zuweisen
     # bauteil.part.color = Color(&quot;red&quot;, alpha=1.0)
 
     # Fertiges Modell exportieren
     export_step(bauteil.part, &quot;bauteil.step&quot;)

Ausgabe ({{W|Standard for the exchange of product model data | STEP}}-Datei, z.B. in {{W|FreeCAD}} importiert, Screenshot):

[[Datei:PythonIng_build123d.jpg | 300px]]

FreeCAD ist ein freies 3D-CAD-System. Die [[Ing_Mathematik:_Python#FreeCAD | Makroprogrammierung]] in diesem System wird später noch gezeigt. STEP steht für &quot;'''St'''andard for the '''e'''xchange of '''p'''roduct model data&quot; und ist ein Datenaustauschformat.

=== Mit VTK ===
Komplexer, aber auch mächtiger als VPython ist die Verwendung von VTK ('''V'''isualization '''T'''ool'''k'''it). Genauer gesagt des Python-Wrappers von VTK. Dieses externe Python-Modul muss vorab installiert werden (z.B. mittels YaST, pip oder in eine virtuelle Umgebung). VTK ist eine Softwarebibliothek zur 3D-Visualisierung und wurde ursprünglich in C++ geschrieben. Verbreitet eingesetzt wird diese Bibliothek in der Wissenschaft und Forschung, z.B. 
* in der medizinischen Bildgebung
* für Strömungssimulationen
* für Klimadaten

VTK funktioniert nach dem {{W|Grafikpipeline|Pipeline-Prinzip}}:

 Source (Quellen) -&gt;  Filter -&gt; Mapper (Senken) -&gt; Actor/Renderer

Daten fließen von den Quellen zu den Senken.

Als einfaches Beispiel wird die Darstellung eines Zylinders gezeigt, der mit den Maustasten gedreht oder in der Größe geändert werden kann:

 import vtk
 
 # Zylinder erzeugen
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 # Geometrie in darstellbare Daten umwandeln
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 # Objekt in der Szene
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 # Szene verwalten
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 # Render-Fenster
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 # Maus/Tastatur-Steuerung
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 # Starten
 render_window.Render()
 interactor.Start()

Ausgabe:

[[Datei:PythonIng_VTK_1.png]]

Gleiches Beispiel wie oben, aber mit einer Animationssequenz:

 import vtk
 import time
 
 cyl = vtk.vtkCylinderSource()
 cyl.SetRadius(5.0)
 cyl.SetHeight(20.0)
 cyl.SetResolution(40)
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(cyl.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 
 renderer = vtk.vtkRenderer()
 renderer.AddActor(actor)
 
 render_window = vtk.vtkRenderWindow()
 render_window.AddRenderer(renderer)
 
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(render_window)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     render_window.Render()
     time.sleep(0.01)

Das Grafikfenster schließt sich nach Ablauf der Schleife. Das Fenster bleibt geöffnet, wenn Sie am Programmende folgenden Befehl hinschreiben

 interactor.Start()

Um den animierten Zylinder grün einzufärben, müssen Sie Folgendes im obigen Programm ergänzen (Farbnamen):

 colors = vtk.vtkNamedColors()
 actor.GetProperty().SetColor(colors.GetColor3d(&quot;Green&quot;))

Als Namen können Sie u.a. die CSS3 Web-Farben verwenden (siehe z.B. [https://wiki.selfhtml.org/wiki/Farbe/Farbangaben] und {{W|Webfarbe#CSS_3}}).

Alternativ funktioniert auch das ({{W|RGB-Farbraum|RGB}}):

 actor.GetProperty().SetColor(0.0, 0.6, 0.0)

Wie der Zylinder mit einer Textur versehen wird, zeigt folgendes Programm:

 import vtk
 import time
 
 cylinder = vtk.vtkCylinderSource()
 cylinder.SetResolution(30)
 cylinder.SetHeight(3.0)
 cylinder.SetRadius(1.0)
 cylinder.CappingOn()
 
 texture_coords = vtk.vtkTextureMapToCylinder()
 texture_coords.SetInputConnection(cylinder.GetOutputPort())
 texture_coords.PreventSeamOn()
 
 reader = vtk.vtkJPEGReader()
 reader.SetFileName(&quot;PythonIng_textur.jpg&quot;)
 
 texture = vtk.vtkTexture()
 texture.SetInputConnection(reader.GetOutputPort()) 
 
 mapper = vtk.vtkPolyDataMapper()
 mapper.SetInputConnection(texture_coords.GetOutputPort())
 
 actor = vtk.vtkActor()
 actor.SetMapper(mapper)
 actor.SetTexture(texture)
 
 renderer = vtk.vtkRenderer()
 renderWindow = vtk.vtkRenderWindow()
 renderWindow.AddRenderer(renderer)
 interactor = vtk.vtkRenderWindowInteractor()
 interactor.SetRenderWindow(renderWindow)
 
 renderer.AddActor(actor)
 
 for i in range(360):
     actor.RotateZ(1)
     actor.RotateY(.5)
     renderWindow.Render()
     time.sleep(0.01)
 
 interactor.Start()

&lt;gallery&gt;
PythonIng_textur.jpg | Textur-Datei
PythonIng_VTK_2.png | Ausgabe (Screenshot)
&lt;/gallery&gt;

== Sonstige Grafikbibliotheken ==
=== Py5 ===
Im Buch ''Iacono et al.: Programmieren trainieren, mit über 150 Workouts in Java und Python; 3. Aufl., Hanser, 2023'' werden zahlreiche Aufgaben gestellt, die u.a. mit Processing zu lösen sind.  Processing ist eine einfache Programmiersprache und Entwicklungsumgebung. Warum ich das erwähne? Weil in älteren Processing-Versionen auch die Programmiersprache Python 2 abgedeckt war. Bei neueren Versionen gibt es keine Python-Anbindung mehr (getestet nur mit openSUSE Tumbleweed und Python 3). Somit funktioniert der Python-Teil im genannten Buch zum Teil nicht mehr. Ist das tragisch, oder kann das Buch weggeschmissen werden? Nein! Es gibt Alternativen zu Processing. Zum einen die im Buch selbst genannten Bibliotheken tkinter oder pygame. Pygame wird dort auch kurz anhand eines Beispiels thematisiert. Aber noch besser ist es, die py5-Bibliothek zu verwenden (lt. Google KI vom 30. Sept. 2026: ''Der echte, moderne „spirituelle Nachfolger“''). Damit ist die Funktionalität von Processing gewährleistet. Man kann aber beliebige Editoren oder IDEs zur Programmerstellung verwenden, ohne an Processing als IDE gebunden zu sein. Nachfolgend werden ein paar Beispiele zu dieser externen Bibliothek gegeben. Der erste Schritt ist wieder, die py5-Bibliothek zu installieren (z.B. mittels pip in eine virtuelle Umgebung; Python&gt;=3.10 und ein JDK&gt;=17 müssen auch installiert sein (Stand Okt. 2026)). Dann kann es schon mit dem Programmieren losgehen.

Beispiel (angelehnt an die ''Aufgabe W.2.3 Haus'' des genannten Buchs, jedoch etwas erweitert):

 import py5
 
 def setup():
     py5.size(600, 600)            # Fenstergröße 600px x 600px 
     py5.background(255, 255, 255) # Hintergrundfarbe ... weiss
     
 def draw():
     # Haus zeichnen
     py5.fill(255, 255, 255)       # Hintergrundfarbe ... weiss
     py5.stroke(255, 0, 0)         # Linienfarbe ... rot 
     py5.stroke_weight(3)          # Linienbreite ... 3px
     py5.rect(150, 200, 300, 300)  # Rechteck zeichnen (x, y, b, h)
     py5.triangle(150, 200, 300, 100, 450, 200) # Dreieck zeichnen
     py5.circle(250, 300, 70)      # Kreis zeichnen (x, y, d)   
     
     # Bemassung zeichnen
     py5.stroke(0, 255, 0)
     py5.stroke_weight(1)
     py5.line(300, 100, 550, 100)  # Linie zeichnen
     py5.line(450, 200, 550, 200) 
     py5.line(450, 500, 550, 500) 
     py5.line(150, 500, 150, 550)
     py5.line(450, 500, 450, 550)
     py5.text_size(20)             # Textgroesse
     py5.fill(0, 255, 0)           # Textfarbe
     py5.text(&quot;300&quot;, 280, 550)     # Text zeichnen
     py5.text(&quot;100&quot;, 500, 150)
     py5.text(&quot;300&quot;, 500, 350)  
 
     # Gedrehtes Rechteck zeichnen
     py5.stroke(255, 255, 0)
     py5.stroke_weight(3)
     py5.fill(200, 200, 200) 
     py5.translate(320, 260)  
     py5.rotate(0.3)               # Drehung (in Radiant)
     py5.rect(0, 0, 100, 50)
 
 # Startet den Sketch
 py5.run_sketch()


Ausgabe:

[[Datei:PythonIng_py5_1.png|300px]]

Das skizzierte Haus ist mit einer rudimentären Bemaßung versehen und hat zwei Fenster, ein rundes und ein gedrehtes, trübes rechteckiges. 

Beispiel (Mausoperationen):

 import py5
 
 def setup():
     py5.size(600, 600)            
     py5.background(255, 255, 255)
 
 def draw():
     pass
    
 def mouse_pressed():
     py5.text_size(15) 
     py5.fill(0, 0, 255)
     x = py5.mouse_x
     y = py5.mouse_y
     py5.text(&quot;(%d, %d)&quot; %(x, y), x, y) # Positionsdaten bei Maus-Klick schreiben
 
 py5.run_sketch()

Ausgabe:

[[Datei:PythonIng_py5_2.png|300px]]

Obiges Bild zeigt das Resultat nach einigen Mausklicks. Man erkennt, dass links-oben der Koordinatennullpunkt ist. Die x-Achse zeigt nach rechts, die y-Achse nach unten.

Beispiel (Fünfeck):

 import py5
 import random 
 
 def setup():
     py5.size(400, 400)
     py5.no_loop()       # statisches Bild (schont die Ressourcen)
 
 def draw():
     py5.translate(py5.width / 2, py5.height / 2)  # KS setzen
 
     radius = 150
     eck_anzahl = 5
 
     py5.fill(random.randint(0, 255), random.randint(0, 255), 
              random.randint(0, 255))    # Füllfarbe auf Zufallswert setzen
     py5.stroke(155, 0, 0)            
     py5.stroke_weight(5)     
     
     # Fünfeck als Polygon zeichnen
     py5.begin_shape()
     for i in range(eck_anzahl):
         winkel = i * py5.TWO_PI / eck_anzahl - py5.HALF_PI
         x = py5.cos(winkel) * radius
         y = py5.sin(winkel) * radius
         py5.vertex(x, y)
     py5.end_shape(py5.CLOSE)
 
 py5.run_sketch()

Ausgabe, bspw.:

[[Datei:PythonIng_py5_5.png|200px]]

&lt;u&gt;Kleine Aufgaben:&lt;/u&gt;
* Um die Funktionsweise von &lt;code&gt;py5.no_loop()&lt;/code&gt; zu verstehen, kommentieren Sie die Anweisung im Beispiel einfach aus, und starten Sie das Programm erneut.
* Zeichnen Sie ein Siebeneck.
* Was passiert, wenn man &lt;code&gt;py5.CLOSE&lt;/code&gt; im &lt;code&gt;py5.end_shape()&lt;/code&gt;-Befehl weglässt?

Beispiel (Grafik laden und zeichnen):

 import py5
 
 image1 = None
 
 def setup():
     global image1
     py5.size(600, 600)
     py5.no_loop()
     image1 = py5.load_image(&quot;PythonIng_py5_1.png&quot;)
 
 def draw():
     py5.image(image1, 0, 0)
 
 py5.run_sketch()

Hier wird einfach das Bild vom Haus-Beispiel (Screenshot von weiter oben) geladen und gezeichnet.

Beispiel (angelehnt an ''W.5.10 Wurfparabel'' des genannten Buches; mit OOP erstellt):

 import py5
 
 class Wurfparabel(py5.Sketch):
     def __init__(self, v0, angle):
         super().__init__()
         self.v0 = v0
         self.angle = self.radians(angle)
         self.g = 9.81
         self.t = 0.0
         self.scale = 1.5
 
     def settings(self):
         self.size(800, 600)
 
     def setup(self):        
         self.background(0, 0, 0)
         
     def draw(self):
         self.t += 0.1
 
         self.translate(50, 500)
       
         # KS Zeichnen
         self.fill(255, 255, 0)
         self.stroke(255, 255, 0)
         self.stroke_weight(1)
         self.line(0, 0, 0, -300)
         self.line(0, 0, 700, 0)
 
         # Punkt zeichnen
         cx = self.v0 * self.cos(self.angle) * self.t * self.scale
         cy = -(self.v0 * self.sin(self.angle) * self.t - \
                self.g/2 * self.t**2) * self.scale
         self.fill(255, 0, 0)
         self.stroke(255, 0, 0)
         self.circle(cx, cy, 3)
        
         # Stoppen bei Bodenkontakt
         if cy &gt;= -5:
             self.no_loop()
            
 def wurfparabel(v0=50, angle=45):
     sketch = Wurfparabel(v0, angle)
     sketch.run_sketch()
 
 v0 = float(input(&quot;v0 = &quot;))
 winkel = float(input(&quot;winkel = &quot;))
 wurfparabel(v0=v0, angle=winkel)

Eingabe auf der Konsole:

 v0 = 60
 winkel = 45

Ausgabe:

[[Datei:PythonIng_py5_13.png|200px]]

Die benötigten Formeln der Bewegungsgleichung kann man leicht herleiten, bzw. man benutzt folgende Grafik als Hilfestellung:

[[Datei:Wurfparabel_Zusammenfassung_aktualisierung.png|700px]]

&lt;u&gt;Aufgabe:&lt;/u&gt; Berechnen Sie den Scheitelpunkt und die Wurfweite bei gegebener Anfangsgeschwindigkeit und gegebenem Abwurfwinkel. Die Abwurfhöhe &lt;math&gt;y_0&lt;/math&gt; sei 0. Der Wurf soll auf der Erde stattfinden (g = 9.81 m/s²). Die dazu benötigten Formeln können aus obiger Grafik entnommen werden (oder Sie leiten sie selbst her). Geben Sie die Ergebnisse auf der Konsole aus.

Beispiel (eine einfache Animation):

 import py5
 
 i = 0
 
 def setup():
     py5.size(600, 600)
     py5.frame_rate(5)
     py5.stroke_weight(20)
 
 def draw():
     global i
     
     py5.background(255, 255, 255)
     py5.translate(py5.width/2, py5.height/2)
     py5.rotate(py5.PI/8 * i)    
 
     py5.line(-100, 0, 100, 0)
     i += 1
 
 py5.run_sketch()

Es wird eine rotierende Linie gezeichnet (z.B. wie bei einem Installationsprozess verwendet - zeigt an, dass der Installationsfortschritt nicht eingefroren ist). Hierbei ist nur aufzupassen, dass der Hintergrund in &lt;code&gt;draw()&lt;/code&gt; gesetzt wird, ansonsten würden die Linien additiv gezeichnet. Das ist zwar auch schön, aber eben nicht das gewünschte Resultat.

=== Bokeh ===
Mit Bokeh kann man interaktive Datenvisualisierungen für Webbrowser in Python erstellen. Bokeh ist eine externe Bibliokek, die vorab installiert werden muss (z.B. mittel YaST oder pip).

Python-Code:

 from bokeh.plotting import figure, output_file, show
 
 x = [1, 2, 3, 4, 5, 6]
 y = [10, 5, 6, 8, 9, 11]
 
 output_file(&quot;interpolation.html&quot;) 
 
 p = figure(
     title=&quot;Interpolation&quot;,
     x_axis_label=&quot;x&quot;,
     y_axis_label=&quot;y&quot;,
 )
 
 p.line(x, y, legend_label=&quot;Interpolierende&quot;, line_width=2, color=&quot;blue&quot;)
 p.scatter(x, y, legend_label=&quot;Stützpunkte&quot;, size=7, color=&quot;orange&quot;)
 p.legend.location = &quot;top_left&quot;
 
 show(p)

Ausgabe:

[[File:PythonIng_bokeh1.png|300px]]

Python-Code (angelehnt an ein Beispiel aus der Bokeh-Dokumentation, aber wesentlich gekürzt
und vereinfacht):

 from bokeh.layouts import layout
 from bokeh.models import Spinner
 from bokeh.plotting import figure, show
 
 x = [1, 2, 3, 4, 5]
 y = [2, 7, 3, 6, 4] 
 
 p = figure(x_range=(1, 5), width=500, height=350)
 points = p.scatter(x=x, y=y, size=30, fill_color=&quot;blue&quot;)
 
 spinner = Spinner(
     title=&quot;Kreisgröße&quot;,
     low=0,
     high=60,
     step=5,
     value=points.glyph.size,
     width=200,
 )
 spinner.js_link(&quot;value&quot;, points.glyph, &quot;size&quot;)
 
 layout = layout(
     [
         [spinner],
         [p],
     ],
 )
 
 show(layout)

Ausgabe:

[[File:PythonIng_bokeh2.png|300px]]

Die Dokumentation zu Bokeh findet sich auf [https://docs.bokeh.org/en/latest/].

Hiermit belassen wir es mit den Grafikbibliotheken und wenden uns wieder &quot;mathematischeren&quot; Themen zu.

= Vektoren und Matrizen =
== Zahlenfolgen ==
Für das Erstellen von Zahlenfolgen bieten sich die Funktionen &lt;code&gt;arange&lt;/code&gt; und &lt;code&gt;linspace&lt;/code&gt; aus dem &lt;code&gt;numpy&lt;/code&gt;-Modul an.

 from numpy import *
 
 start = 0
 stop = 10
 step = 2
 num = 10
 
 r = arange(start, stop, step)   # step ... Schrittweite
 l = linspace(start, stop, num)  # num ... Anzahl der Werte
 
 print(&quot;r = &quot;, r)
 print(&quot;l = &quot;, l)

Ausgabe:
 r =  [0 2 4 6 8]
 l =  [ 0.          1.11111111  2.22222222  3.33333333  4.44444444  5.55555556
   6.66666667  7.77777778  8.88888889 10.        ]

Bei &lt;code&gt;arange&lt;/code&gt; ist der &lt;code&gt;stop&lt;/code&gt;-Wert nicht im Ergebnis enthalten, bei &lt;code&gt;linspace&lt;/code&gt; standardmäßig aber sehr wohl. Jedoch kann man das bei &lt;code&gt;linspace&lt;/code&gt; auch ändern. Dann ist der Stoppwert nicht mehr enthalten: 

 linspace(start, stop, num, endpoint=False)

== Vektoren ==
Vektoren sollten jedem aus der Linearen Algebra bekannt sein. 

=== Arrays ===
In Python mit NumPy kann man Vektoren durch die Funktion array erzeugen.

 import numpy as np
 
 l1 = (-5, 3, 2)
 l2 = (1, 1, 4)
 
 a1 = np.array(l1)
 a2 = np.array(l2)
 
 a3 = a1 + a2
 a4 = 2 * a2
 
 print(a1)
 print(a2)
 print(a3)
 print(a3[2])
 print(a4)

Ausgabe:
 [-5  3  2]
 [1 1 4]
 [-4  4  6]
 6
 [2 2 8]

=== Zeilen- und Spaltenvektoren ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 print(z)
 print(s)

Ausgabe:
 [ [-5  3  2] ]
 [[1]
  [1]
  [4]]

=== Skalarprodukt ===
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4))
 
 skalarprodukt = np.dot(a1, a2)  
 
 print(skalarprodukt)

Ausgabe:
 6

=== Vektorprodukt ===
&lt;math&gt;a\ast b=\left(\begin{array}{c}
a_{1}\\
a_{2}\\
a_{3}
\end{array}\right)\ast\left(\begin{array}{c}
b_{1}\\
b_{2}\\
b_{3}
\end{array}\right)=\left(\begin{array}{c}
a_{2}b_{3}-a_{3}b_{2}\\
a_{3}b_{1}-a_{1}b_{3}\\
a_{1}b_{2}-a_{2}b_{1}
\end{array}\right)
&lt;/math&gt; 

Python-Code:
 import numpy as np
 
 a1 = np.array((-5, 3, 2))
 a2 = np.array((1, 1, 4)) 
 
 vektorprodukt = np.cross(a1, a2) 
 
 print(vektorprodukt)

Ausgabe:
 [10 22 -8]

=== Transponierter Vektor ===
 import numpy as np
 
 # Zeilenvektor
 z = np.array([ [-5, 3, 2] ])
 # Spaltenvektor
 s = np.array([[1], [1], [4]])
 
 # transponierter Vektor
 z_tp = np.transpose(z)
 # transponierter Vektor
 s_tp = np.transpose(s)
 
 print(z_tp)
 print(s_tp)

Ausgabe:
 [[-5]
  [ 3]
  [ 2]]
 [ [1 1 4] ]

=== Vektorfelder visualisieren ===
 import matplotlib.pyplot as plt
 import numpy as np
 
 # Daten generieren
 x = np.arange(0, 10, 1)
 y = np.arange(0, 10, 1)
 X, Y = np.meshgrid(x, y)
 U = X * Y
 V = Y + X
 
 # Plotten
 fig, ax = plt.subplots()
 
 ax.quiver(X, Y, U, V, angles='xy')
 
 plt.show()

Ausgabe:

[[Datei:PythonIng_quiver1.png]]

== Matrizen==
 import numpy as np
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 print(m1)

Ausgabe:
 [[1 2 3]
  [4 5 6]]

=== Zugriff auf Matrizenelemente ===
Beispiel:

 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 
 # Element aus Zeile 2 und Spalte 3 (Achtung! Index startet bei Null)
 print(m1[1,2])

Ausgabe:
 6

Visualisierung:
  
     0   1   2
   +-----------+
 0 | 1 | 2 | 3 |
   +-----------+
 1 | 4 | 5 | '''6''' |
   +-----------+


Beispiel:

 import numpy as np
 
 A = [[&quot;00&quot;, &quot;01&quot;, &quot;02&quot;, &quot;03&quot;],
      [&quot;10&quot;, &quot;11&quot;, &quot;12&quot;, &quot;13&quot;],
      [&quot;20&quot;, &quot;21&quot;, &quot;22&quot;, &quot;23&quot;],
      [&quot;30&quot;, &quot;31&quot;, &quot;32&quot;, &quot;33&quot;],
      [&quot;40&quot;, &quot;41&quot;, &quot;42&quot;, &quot;43&quot;]]
 
 B = np.matrix(A)     
 
 print(B[2::, ::2])

Ausgabe:

 [['20' '22']
  ['30' '32']
  ['40' '42']]

Mit der NumPy-Bibliothek funktioniert das zweidimensionale Slicing. Mit normalen Listen/Tupels geht das nicht, was wir schon früher thematisiert haben.

=== Addition und Subtraktion von Matrizen ===
 import numpy as np
 
 m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
 m2 = np.matrix([[0, 0, 2], [1, 3, 2]])
 
 print(m1 + m2)
 print(m1 - m2)

Ausgabe:
 [[1 2 5]
  [5 8 8]]
 [[1 2 1]
  [3 2 4]]

=== Transponierte Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 2, 3], [4, 5, 6]])
 mt = np.transpose(m) 
 
 print(m)
 print(mt)

Ausgabe:
 [[1 2 3]
  [4 5 6]]
 [[1 4]
  [2 5]
  [3 6]]

=== Rang einer Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 rg = np.linalg.matrix_rank(m)
 
 print(rg)

Ausgabe:
 2

=== Inverse Matrix ===
 import numpy as np
 
 m = np.matrix([[1, 3],  [0, -5]])
 mi = np.linalg.inv(m)
 
 print(mi)

Ausgabe:
 [[ 1.   0.6]
  [-0.  -0.2]]

=== Multiplikation von Matrizen (falksches Schema) ===
 import numpy as np
 
 m1 = np.matrix([[1, 3, 4],  [0, -5, 1]])
 m2 = np.matrix([[1, 2], [2, 3], [0, 2]])
 
 print(m1 @ m2)

Ausgabe:
 [[  7  19]
  [-10 -13]]

=== Eigenwerte und Eigenvektoren ===
 import numpy as np
 
 m = np.matrix([[5, 8],  [1, 3]])
 D,V = np.linalg.eig(m)
 
 # Eigenwerte
 print(D)
 # Eigenvektoren
 print(V)

Ausgabe:
 [7. 1.]
 [[ 0.9701425  -0.89442719]
  [ 0.24253563  0.4472136 ]]

=== Teilmatrizen ===
 import numpy as np
 m = np.matrix([[1, 3, 4],  [0, -5, 1]])
 print(&quot;m = &quot;, m)
 
 # Erste Zeile extrahieren
 m1 = m[0,:]
 print(&quot;m1 = &quot;, m1)
 
 # Das Element aus der 1. Zeile und der 2. Spalte extrahieren
 m2 = m[0,1]
 print(&quot;m2 = &quot;, m2)
 
 # Zweite Spalte extrahieren
 m3 = m[:, 1]
 print(&quot;m3 = &quot;, m3)

Ausgabe:
 m =  [[ 1  3  4]
  [ 0 -5  1]]
 m1 =  [ [1 3 4] ]
 m2 =  3
 m3 =  [[ 3]
  [-5]]

=== Spezielle Matrizen ===
==== Nullmatrix ====
 import numpy as np
 z = np.zeros((3, 2))
 print(z)

Ausgabe:
 [[0. 0.]
  [0. 0.]
  [0. 0.]]

==== Einheitsmatrix ====
 import numpy as np
 z = np.eye(3)
 print(z)

Ausgabe:
 [[1. 0. 0.]
  [0. 1. 0.]
  [0. 0. 1.]]

==== Matrix mit lauter Einsen ====
 import numpy as np
 z = np.ones((3, 2))
 print(z)

Ausgabe:
 [[1. 1.]
  [1. 1.]
  [1. 1.]]

=== Spärlich besetzte Matrizen ===
Das Thema spärlich besetzter Matrizen wird hier nur kurz angerissen. Nähere Details siehe unter dem Weblink  [https://docs.scipy.org/doc/scipy/reference/sparse.html#module-scipy.sparse]. 

Beispiel:

 import numpy as np
 import scipy
 
 A = scipy.sparse.csr_array(np.eye(5))
 
 print(A)

Ausgabe:
 &lt;Compressed Sparse Row sparse array of dtype 'float64'
         with 5 stored elements and shape (5, 5)&gt;
   Coords        Values
   (0, 0)        1.0
   (1, 1)        1.0
   (2, 2)        1.0
   (3, 3)        1.0
   (4, 4)        1.0

csr steht für '''c'''ompressed '''s'''parse '''r'''ow.

Andere Möglichkeiten:
* coo-Format ('''coo'''rdinate Format): &lt;code&gt;scipy.sparse.coo_array()&lt;/code&gt;
* lil-Format ('''li'''st of '''l'''ists): &lt;code&gt;scipy.sparse.lil_array()&lt;/code&gt;
* csc-Format ('''c'''ompressed '''s'''parse '''c'''olumn): &lt;code&gt;scipy.sparse.csc_array()&lt;/code&gt;

Es gibt auch &lt;code&gt;scipy.sparse.csr_matrix()&lt;/code&gt; etc. Diese Befehle sind aber veraltet und es wird empfohlen, statt dessen die &lt;code&gt;..._array()&lt;/code&gt;-Funktionen zu verwenden.

&lt;u&gt;Aufgaben:&lt;/u&gt; 
Recherchieren Sie im Internet 
* generell zum Thema &quot;spärlich besetzte Matrizen mit Python&quot;.
* Was sind die Vor-/Nachteile von csr-arrays gegenüber coo- und lil-arrays?
* Wann verwendet man sinnvollerweise csr- und wann csc-arrays?
* Wie wandelt man coo-arrays in csr-arrays um?

= Lineare Gleichungssysteme =
Sei &lt;math&gt;Ax = b&lt;/math&gt; ein lineares Gleichungssystem. &lt;math&gt;A&lt;/math&gt; sei die Koeffizientenmatrix, &lt;math&gt;x&lt;/math&gt; der Lösungsvektor und &lt;math&gt;b&lt;/math&gt; ein bekannter Vektor.

Beispiel:
 import numpy as np
 
 A = np.array([[5, 1], [0, 2]])
 b = np.array([1, 2])
 
 x = np.linalg.solve(A, b)
 
 print(x)

Ausgabe:
 [0. 1.]

Siehe dazu auch das Kapitel [[Ing Mathematik: Numerisches Lösen von linearen Gleichungssystemen]]. Dort wird dieses Themengebiet u.a. mit weitergehenden Python-Skripten vertieft.

== Aufgabe ==
* Lösen Sie folgendes Gleichungssystem mittels Python (und zur Kontrolle auch händisch): 
 5x + 6y - 2z = 12
 3x - y  - 3z = 6
 2x + 2y + 4z = 5

= Polynome =
== Ein erstes einfaches Beispiel ==
Gegeben sei das Polynom &lt;math&gt;7x^3+5x^2+1&lt;/math&gt;. In Python:

 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p)

Ausgabe:
    3     2
 7 x + 5 x + 1

== Einzelne Polynomwerte berechnen ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 print(p(1.5))

Ausgabe:
 35.875

== Polynome integrieren und differenzieren ==
 import numpy as np
 
 p = np.poly1d([7, 5, 0, 1])
 
 # 1. Ableitung
 p1 = p.deriv()
 p2 = p.deriv(1)
 
 # 2. Ableitung
 p3 = p.deriv(2)
 
 # Integral
 p4 = p.integ()
 
 print(p1)
 print(p2)
 print(p3)
 print(p4)

Ausgabe:
     2
 21 x + 10 x
     2
 21 x + 10 x
 
 42 x + 10
       4         3
 1.75 x + 1.667 x + 1 x

== Nullstellen bestimmen ==
 import numpy as np
 
 p = np.poly1d([2, 5, 0, 4])
 r = np.roots(p)
 
 print(r)

Ausgabe:
 [-2.7621427 +0.j          0.13107135+0.84077099j  0.13107135-0.84077099j]

== Aufgaben ==
* Berechnen Sie den Wert für x = 3 des Polynoms &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Differenzieren und integrieren Sie das Polynom &lt;math&gt;y = 2x^4 - 3x^3 - x + 7&lt;/math&gt;.
* Berechnen Sie die Nullstellen von &lt;math&gt;y = 7x^5 - 3x^2 + 12&lt;/math&gt;.

= Nichtlineare Gleichungen und Gleichungssysteme =
== Nullstellenbestimmung ==
Löse eine beliebige Gleichung f(x) = 0, z.B. &lt;math&gt; f(x) = x^2 - 5\cos(x) - 10 = 0 &lt;/math&gt;:
 import scipy
 import numpy as np
 
 def f(x):
     return x**2 - 5*np.cos(x) - 10
    
 xstart = [-1, 1]        # Startwerte
 xn = scipy.optimize.root(f, xstart)
 
 print(xn.x)

Ausgabe:
 [-2.46813009  2.46813009]

Funktionsgraph:

[[Datei:octave_nichtlin2.jpg]]

== Gleichungssysteme ==
SymPy ist ein externes Modul, das symbolisches Rechnen ('''Sym'''bolic '''Py'''thon) ermöglicht. 

Folgende Aufgabe ist dem Buch &quot;Knorrenschild: Numerische Mathematik, Hanser, 2017, Seite 72&quot; entnommen. Zu lösen ist das nichtlineare Gleichungssystem

&lt;math&gt;f_1 = 2x_1 + 4x_2 = 0 &lt;/math&gt;

&lt;math&gt;f_2 = 4x_1 + 8x_2^3 = 0&lt;/math&gt;

Mit Python ist das so möglich:
 import sympy
 
 x1, x2 = sympy.symbols(&quot;x1 x2&quot;) 
 
 f1 = 2*x1 + 4*x2
 f2 = 4*x1 + 8*x2**3
 
 s = sympy.solve((f1, f2), x1, x2) 
 
 print(s)

Ausgabe:
 [(-2, 1), (0, 0), (2, -1)]

Plot:

[[Datei:IngPython_nl_gleichung1.svg|500px]]

= Komplexe Zahlen =
Die imaginäre Einheit wird in Python durch den Buchstaben &lt;code&gt;j&lt;/code&gt; symbolisiert. Darstellen kann man eine komplexe Zahl bekannterweise in mehreren Formen:
* Kartesische Darstellung &lt;math&gt;z = \Re(z) + j \cdot \Im(z)&lt;/math&gt;
* Polardarstellungen &lt;math&gt;z = r \cdot (\cos(\phi) + j \cdot \sin(\phi)) = r \cdot e^{j\cdot \phi}&lt;/math&gt;

Die konjugiert komplexe Zahl ist &lt;math&gt;z^* = \Re(z) - j \cdot \Im(z)&lt;/math&gt;

Nachfolgend einige mathematische Operationen mit Python und NumPy.

 import numpy as np
 
 z1 = 2 + 5j           # kartesische Darstellung
 z2 = 3 * np.exp(3j)   # Polardarstellung
  
 # Addition
 res = z1 + z2
 print(&quot;z1 + z2 = &quot;, res)
 
 # Multiplikation
 res = z1 * z2
 print(&quot;z1 * z2 = &quot;, res)
 
 # Realteil
 res = np.real(z2)
 print(&quot;Realteil von z2 = &quot;, res)
 
 # Imaginärteil
 res = np.imag(z2)
 print(&quot;Imaginaerteil von z2 = &quot;, res)
 
 # Betrag
 res = np.abs(z1)
 print(&quot;Betrag von z1 = &quot;, res)
 
 # Argument
 res = np.angle(z1)
 print(&quot;Argument von z1 = &quot;, res)
 
 # Konjugiert komplexe Zahl
 res = np.conj(z1)
 print(&quot;Konjugiert komplexe Zahl von z1 = &quot;, res)

Ausgabe:
 z1 + z2 =  (-0.9699774898013365+5.423360024179601j)
 z1 * z2 =  (-8.05675510050068-14.003167400647481j)
 Realteil von z2 =  -2.9699774898013365
 Imaginaerteil von z2 =  0.4233600241796016
 Betrag von z1 =  5.385164807134504
 Argument von z1 =  1.1902899496825317
 Konjugiert komplexe Zahl von z1 =  (2-5j)

= Interpolation =
 import numpy as np
 import scipy
 import matplotlib.pyplot as plt
 
 # Stützpunkte
 xp = np.arange(1, 6)
 yp = (0, -5, 2, 7, 6)
 
 ti = np.arange(1, 5, 0.01)
 
 i1 = scipy.interpolate.interp1d(xp, yp, kind = &quot;linear&quot;)
 i2 = scipy.interpolate.interp1d(xp, yp, kind = &quot;cubic&quot;) 
 
 plt.plot(xp, yp, &quot;rx&quot;)
 plt.plot(xp, i1(xp))
 plt.plot(ti, i2(ti))
 plt.show()

Ausgabe:

[[Datei:PythonIng_interpol1.png]]

&lt;code&gt;scipy.interpolate.interp1d()&lt;/code&gt; gilt als veraltet ([https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.interp1d.html]). Stattdessen soll man modernere Alternativen wie &lt;code&gt;scipy.interpolate.Akima1DInterpolator()&lt;/code&gt; oder &lt;code&gt;scipy.interpolate.CubicSpline()&lt;/code&gt; benutzen. Für die lineare Interpolation tut es &lt;code&gt;np.interp()&lt;/code&gt;.

&lt;u&gt;Aufgaben:&lt;/u&gt;
* Recherchieren Sie im Internet zu den oben genannten modernen Alternativen.
* Schreiben Sie obiges Programm auf die genannten moderneren Alternativen um.

= Differenzialrechnung =
== Numerisches Differenzieren ==
Als Beispiel differenzieren wir &lt;math&gt;y = 5x\sin{x}&lt;/math&gt; und stellen das Ganze grafisch dar.

 from findiff import Diff
 import numpy as np
 import matplotlib.pyplot as plt
 
 x = np.linspace(0, 10, 1000)
 f = 5 * x * np.sin(x)
 dx = x[1] - x[0]
 
 # Ableitung
 d_dx = Diff(0, dx)
 df_dx = d_dx(f)
 
 # Grafik
 plt.plot(x, f, label = &quot;y&quot;)
 plt.plot(x, df_dx, label = &quot;y'&quot;)
 plt.grid()
 plt.legend(loc=&quot;best&quot;)
 
 plt.show()

Ausgabe:

[[Datei:octave_diff1.jpg]]

&lt;small&gt;findiff ist ein externes Modul. Dieses muss installiert werden (z.B. so: ...\Python\Scripts\pip.exe install --upgrade findiff). Für die Vorgehensweise unter openSUSE Tumbleweed siehe das Kapitel [[Ing_Mathematik:_Python#Mit_VPython | VPython]], nur dass das Ganze mit einer aktuelleren Python-Version exekutiert wird, z.B. mit Python 3.13.  Das im Buch &quot;Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler, Rheinwerk&quot; verwendete Modul &quot;scipy.misc&quot; ist veraltet (deprecated ... missbilligt). Lt. [https://docs.scipy.org/doc/scipy-1.17.0/dev/roadmap-detailed.html#misc SciPy-Dokumentation für die Version 1.17.0] wurden alle entsprechenden Features schon entfernt.&lt;/small&gt;

== Symbolisches Differenzieren ==
Differenzieren Sie die Funktionen &lt;math&gt;f_1(x) = x^2&lt;/math&gt; und &lt;math&gt;f_2(x) = \sin(x)\cos\left(\frac{x}{2}\right)&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2;
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 d1 = sympy.diff(f1, x)
 d2 = sympy.diff(f2, x)
 
 print(d1)
 print(d2)

Ausgabe:
 2*x
 -0.5*sin(0.5*x)*sin(x) + cos(0.5*x)*cos(x)

== Aufgaben ==
* Differenzieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.
* Differenzieren Sie die Funktion &lt;math&gt;y = \frac{\sinh(x)}{(1+x)}&lt;/math&gt; und stellen Sie y, sowie y' grafisch am Bildschirm dar.

= Integralrechnung =
== Numerisches Integrieren ==
Berechnen Sie das Integral &lt;math&gt;\int_{0}^{3}x^2 dx&lt;/math&gt;.

 import scipy
 
 def f(x):
     return x**2
    
 i = scipy.integrate.quad(f, 0, 3)
 print(i)

Ausgabe:
 (9.000000000000002, 9.992007221626411e-14)

Das trifft den exakten Wert 9.0 ziemlich genau.

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} dx&lt;/math&gt;.

 import scipy
 import numpy as np
 
 def f(x):
     return 2**(-x)
   
 i = scipy.integrate.quad(f, 0, np.inf)
 print(i)

Ausgabe:
 (1.4426950408889556, 4.486558477977586e-09)

== Symbolisches Integrieren ==
Berechnen Sie &lt;math&gt;\int x^2 \text{d}x&lt;/math&gt; und &lt;math&gt;\int \sin{x}\cos{\frac{x}{2}} \text{d}x&lt;/math&gt;.
 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f1 = x**2
 f2 = sympy.sin(x) * sympy.cos(x/2.)   
 
 i1 = sympy.integrate(f1, x)
 i2 = sympy.integrate(f2, x)
 
 print(i1)
 print(i2)

Ausgabe:
 x**3/3
 -0.666666666666667*sin(0.5*x)*sin(x) - 1.33333333333333*cos(0.5*x)*cos(x)

Berechnen Sie das Integral &lt;math&gt;\int_{0}^{\infty} 2^{-x} \text{d}x&lt;/math&gt;.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 
 f = 2**(-x)
 i = sympy.integrate(f, (x, 0, sympy.oo))
 print(i)

Ausgabe:
 1/log(2)

&lt;code&gt;sympy.oo&lt;/code&gt; steht für das {{W|Unendlichzeichen}} &lt;math&gt;\infty&lt;/math&gt; (die liegende Acht oder das Möbiusband). Mit &lt;code&gt;sympy.pprint(i)&lt;/code&gt; ließe sich letzere Ausgabe etwas schöner schreiben:

   1   
 ──────
 log(2)

Man beachtete, &lt;code&gt;log&lt;/code&gt; steht hier für den natürlichen Logarithmus &lt;code&gt;ln&lt;/code&gt;.

== Aufgaben ==
* Integrieren Sie die Funktion &lt;math&gt;y = \log(x) + 10x&lt;/math&gt; von 1 bis 5.
* Integrieren Sie die Funktion &lt;math&gt;y = x^3&lt;/math&gt; von 0 bis 4.
* Integrieren Sie &lt;math&gt;\int x^x(\log (x) + 1)\mathrm dx&lt;/math&gt; symbolisch.

= Gewöhnliche Differenzialgleichungen =
== DGL numerisch lösen ==
Für die Lösung von Differenzialgleichungen steht u.a. die Funktion scipy.integrate.solve_ivp() zur Verfügung. Diese Funktion implementiert auch das Runge-Kutta-Verfahren (RK45).

{{Wikipedia | Runge-Kutta-Verfahren}}

Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import scipy
 import numpy as np
 import matplotlib.pyplot as plt
 
 def dy_dx(x, y):
     return x**2 + y**3
 
 y0 = [1]
 xi = [0, 1]
 x = np.arange(0, 1, 0.01)
 
 z = scipy.integrate.solve_ivp(dy_dx, xi, y0, method=&quot;RK45&quot;, dense_output=True)
 y = z.sol(x)
 
 plt.plot(x, y.T)
 plt.grid()
 plt.show()

[[Datei:PythonIng_dgl1.png]]

== DGL symbolisch lösen ==
Beispiel &lt;math&gt;y' = x^2 + y^3&lt;/math&gt;:

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 print(lsg)

Ausgabe:
 [Eq(f(x), (-x**2)**(1/3)), Eq(f(x), (-x**2)**(1/3)*(-1 - sqrt(3)*I)/2), Eq(f(x), (-x**2)**(1/3)*(-1 + sqrt(3)*I)/2)]

Mit &lt;code&gt;sympy.pprint&lt;/code&gt; (pretty print) lässt sich die Ausgabe etwas übersichtlicher darstellen.

 import sympy
 
 x = sympy.symbols(&quot;x&quot;)
 y = sympy.Function(&quot;f&quot;)(x)
 
 dgl = x**2 + y**3 
 
 lsg = sympy.dsolve(dgl, y)
 
 sympy.pprint(lsg)

Ausgabe:
 ⎡                           _____                        _____            ⎤
 ⎢          _____         3 ╱   2                      3 ╱   2             ⎥
 ⎢       3 ╱   2          ╲╱  -x  ⋅(-1 - √3⋅ⅈ)         ╲╱  -x  ⋅(-1 + √3⋅ⅈ)⎥
 ⎢f(x) = ╲╱  -x  , f(x) = ────────────────────, f(x) = ────────────────────⎥
 ⎣                                 2                            2          ⎦

== Aufgaben ==
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \frac{1}{x\cdot y}&lt;/math&gt; mit Python. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;m' = -k\cdot m&lt;/math&gt;. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung &lt;math&gt;y' = \sqrt{|y|}&lt;/math&gt;.

=Laplace-Transformation=
Laplace-Transformation:

&lt;math&gt;F(s) =\mathcal{L} \left\{f\right\}(s) = \int_{0}^{\infty} f(t) \mathrm e^{-st} \,\mathrm{d}t, \qquad s\in\mathbb{C}
&lt;/math&gt;

Inverse Laplace-Transformation:

&lt;math&gt;\mathcal{L}^{-1} \left\{F\right\}(t)
  = \frac{1}{2 \pi \mathrm j} \int_{ \gamma - \mathrm j \infty}^{ \gamma + \mathrm j \infty} \mathrm e^{st} F(s)\,\mathrm ds 
= \begin{cases}
      f(t) &amp; \text{für } t \geq 0 \\
      0    &amp; \text{für } t &lt; 0
    \end{cases}
&lt;/math&gt;

Siehe auch [[Ing_Mathematik:_Laplace-Transformation]]

Code:
 import sympy
 from sympy.abc import t, s
 
 # Laplace-Transformation der Funktion f(t) = 1 (Heaviside-Fkt.)
 f = 1
 # alternativ: f = sympy.Heaviside(t)
 F = sympy.laplace_transform(f, t, s, noconds=True)
 print(&quot;Laplace-Transformierte F(s):&quot;, F) 
 
 # Inverse Laplace-Transformation zurück in den Zeitbereich
 f_inv = sympy.inverse_laplace_transform(F, s, t)
 print(&quot;Inverse Transformation f(t):&quot;, f_inv)

Ausgabe:
 Laplace-Transformierte F(s): 1/s
 Inverse Transformation f(t): Heaviside(t)

Die Zeile

 from sympy.abc import t, s

steht alternativ für

 t = sympy.symbols(&quot;t&quot;)
 s = sympy.symbols(&quot;s&quot;)

&lt;u&gt;Aufgaben&lt;/u&gt;: Ermitteln Sie mittels SymPy die &lt;math&gt;\mathcal{L}&lt;/math&gt;-Transformierten und dann wieder die  &lt;math&gt;\mathcal{L}^{-1}&lt;/math&gt;-Transformationen (ähnlich wie beim obigen Beispiel):
* &lt;math&gt;\sin(t) \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;t^3 \circ\! -\! \bullet \ ?&lt;/math&gt;
* &lt;math&gt;\text{e}^{\omega t} \circ\! -\! \bullet \ ?&lt;/math&gt;

=Fourier-Reihen=
&lt;math&gt;
f(x)\approx \frac{a_{0}}{2}+\sum_{k=1}^{\infty}\left(a_{k}\cos\left(kx\right)+b_{k}\sin\left(kx\right)\right)
&lt;/math&gt;

&lt;math&gt;
a_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\cos\left(kx\right)\mathrm dx\quad\text{für }k\geq0
&lt;/math&gt;

&lt;math&gt;
b_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\sin\left(kx\right)\mathrm dx\quad\text{für }k\geq1
&lt;/math&gt;

Für die Sägezahnfunktion &lt;math&gt;y=x;\, 0 &lt; x &lt; 2\pi&lt;/math&gt; sei die Fourierreihe mit einem Python-Programm (unter Mithilfe von sympy) hergeleitet.

Code:

 from sympy import fourier_series, pi, symbols, pprint
 
 x = symbols('x')
 f = x
 s = fourier_series(f, (x, 0, 2*pi))
 pprint(s.truncate(n=4))

Ausgabe:

                        2⋅sin(3⋅x)    
 -2⋅sin(x) - sin(2⋅x) - ────────── + π
                            3

Siehe auch [[Ing Mathematik: Fourierreihen]].

Ein komplizierteres Beispiel:

[[Datei:IngMath fourier bsp13.svg | 300px]]

&lt;math&gt;0\le t &lt; T/2\text{:}\quad f(t) = H&lt;/math&gt;

&lt;math&gt;T/2 \le t \le T\text{:}\quad f(t) = \frac{2H}{T}\left( t-\frac{T}{2}\right)&lt;/math&gt;

Code:

 import sympy as sp
 
 H = sp.Symbol('H', positive=True)
 T = sp.Symbol('T', positive=True)
 t = sp.Symbol('t')
 
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T/2)),
     (2*H/T*(t-T/2), (t &gt; T/2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Ausgabe:

      ⎛2⋅π⋅t⎞        ⎛4⋅π⋅t⎞        ⎛6⋅π⋅t⎞          ⎛2⋅π⋅t⎞          ⎛6⋅π⋅t⎞      
 H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   H⋅sin⎜─────⎟   2⋅H⋅cos⎜─────⎟   2⋅H⋅cos⎜─────⎟      
      ⎝  T  ⎠        ⎝  T  ⎠        ⎝  T  ⎠          ⎝  T  ⎠          ⎝  T  ⎠   3⋅H
 ──────────── - ──────────── + ──────────── + ────────────── + ────────────── + ───
      π             2⋅π            3⋅π               2                 2         4 
                                                    π               9⋅π

=Rechnen mit wirklich großen Zahlen=
Bekannt ist, dass Python kaum Einschränkungen beim Wertebereich von Ganzzahlen hat, z.B.

 print(10**300)

Ausgabe (gekürzt):

 100000000000000000000...00000000000000000000000000000000000000000000000000000000000000000000000

Ähnliches geht auch mit Gleitpunktzahlen, z.B. durch die Verwendung des Moduls [https://mpmath.org/ mpmath]:

 import mpmath
 print(mpmath.mpf(1500.4)**mpmath.mpf(300))

Ausgabe:

 7.27975299218612e+952

Anderes Beispiel:

 from mpmath import mp, pi
 mp.dps = 100
 print(pi)

Ausgabe:

 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068

mpmath kann noch einiges mehr, dazu sei aber auf die entsprechende Dokumentation auf der mpmath-Homepage verwiesen. mpmath ist Bestandteil von SymPy, kann aber auch separat installiert werden.

Aber auch Python selbst besitzt eine Möglichkeit, um mit großen bzw. exakten Gleitpunktzahlen zu rechnen, nämlich das interne Modul decimal. Dieses hat einige Vorteile gegenüber mpmath, aber auch gravierende Nachteile. Diese seien hier nicht detailliert aufgezählt. Grob gesagt hat decimal im Finanzwesen seine Berechtigung. Für wissenschaftliche Anwendungen wird aber mpmath vorzuziehen sein, da es u.a. vielfältige mathematische Funktionen bereit stellt. Nachfolgend ein einfaches Beispiel mit decimal:

 import decimal
 print(&quot;Potenzierung:&quot;, decimal.Decimal(1500.4) ** decimal.Decimal(300.0))
 print(&quot;Einfache Addition:&quot;, 0.1 + 0.2)
 decimal.getcontext().prec = 50
 print(&quot;Addition mit decimal:&quot;, decimal.Decimal(&quot;0.1&quot;) + decimal.Decimal(&quot;0.2&quot;))

Ausgabe:

 Potenzierung: 7.279752992186121551039839134E+952
 Einfache Addition: 0.30000000000000004
 Addition mit decimal: 0.3

&lt;u&gt;Aufgabe:&lt;/u&gt; Recherchieren Sie im Internet die genauen Vor- und Nachteile von decimal und mpmath. Verwenden Sie dazu auch KI (z.B. von Google, chatgpt).

= pint - mit physikalischen Größen rechnen = 
[[File:Pint-Glas_UK.jpg|right|100px]]
pint ist ein externes Python-Paket zur Manipulation von physikalischen Einheiten. Es muss vor der ersten Benutzung installiert werden (Vorgehensweise wie immer: pip, YaST, via venv etc.).

Beispiel:

 import pint
 import numpy as np
 
 ureg = pint.UnitRegistry()
 
 # Einfache Berechnung
 print(3 * ureg.meter + 4 * ureg.cm)
 
 # Mit NumPy
 npeinzel = [3, 4] * ureg.meter + [2, 5] * ureg.cm
 print(npeinzel)
 npsum = np.sum(npeinzel)
 print(npsum)
 
 # Konvertierung von Einheiten
 npsum_inch = npsum.to(ureg.inch)
 print(npsum_inch)
 
 print(npeinzel.magnitude)
 print(npeinzel.units)
 print(npeinzel.dimensionality)

Ausgabe:

 3.04 meter
 [3.02 4.05] meter
 7.07 meter
 278.3464566929134 inch
 [3.02 4.05]
 meter
 [length]

Die Dokumentation zu pint findet sich auf [https://pint.readthedocs.io/en/stable/].

=Regelungstechnische Aufgabenstellungen=
Für regelungstechnische Aufgaben gibt es u.a. das externe Paket &lt;code&gt;control&lt;/code&gt;. Hier soll nicht detailliert darauf eingegangen werden. Anhand eines Beispiels soll anschließend nur die Visualisierung in Form eines Bode-Diagramms und der Sprungantwort gezeigt werden. Gegeben sei ein P-Regler mit &lt;math&gt;R = \frac{5}{2}&lt;/math&gt; und eine Strecke &lt;math&gt;S= \frac{1}{30s^3+20s^2+10s+1,5}&lt;/math&gt;. Gesucht sei vorerst ein Bode-Diagramm für den offenen Regelkreis und das Führungsverhalten.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke  # oder: G0 = ct.series(regler, strecke)
 Gw = ct.feedback(G0)
 
 ct.bode_plot(G0, label='G0')
 ct.bode_plot(Gw, label='Gw')
 plt.show()

[[Datei:PythonIng_bode1.svg]]

Nun noch für obiges Beispiel die Sprungantwort. Diese zeigt einige große Überschwinger, d.h. der Regler kann sicher noch optimiert werden.

 import numpy as np
 import control as ct
 import matplotlib.pyplot as plt
 
 zaehler1 = np.array([1.])
 nenner1  = np.array([30., 20., 10., 1.5])
 strecke  = ct.tf(zaehler1, nenner1)
 
 zaehler2 = np.array([5.])
 nenner2  = np.array([2.])
 regler   = ct.tf(zaehler2, nenner2)
 
 G0 = regler*strecke 
 Gw = ct.feedback(G0) 
 
 t, y = ct.step_response(Gw)
 
 plt.plot(t,y)
 plt.title('Sprungantwort')
 plt.xlabel('t')
 plt.ylabel('h(t)')
 plt.grid()
 plt.show()

[[Datei:PythonIng_bode3.svg]]

Einige weitere wichtige Daten (Phasenreserve, Amplitudenreserve, Durchtrittsfrequenz) lassen sich mittels der &lt;code&gt;control&lt;/code&gt;-Funktion &lt;code&gt;margin()&lt;/code&gt; ermitteln. Die Ortskurve lässt sich mit der Funktion &lt;code&gt;nyquist_plot()&lt;/code&gt; zeichnen. Dies sei hier aber nicht weiter ausgeführt.

==Aufgaben==
* Zeichen Sie mit Python die Ortskurve für obiges Beispiel.
* Was passiert, wenn man die Reglerverstärkung weiter aufdreht (z.B. auf &lt;math&gt;R = \frac{25}{2}&lt;/math&gt;)?
* Wie sehen das Bode-Diagramm und die Sprungantwort aus, wenn ein PI-Regler verwendet wird?

= Stereostatik etc. =
Das Modul SymPy bietet einige Möglichkeiten einfache Bauwerke zu berechnen, z.B. Balken oder Fachwerke. Nachfolgend wird ein einfaches Fachwerk berechnet und gezeichnet.

Python-Code:
 from sympy.physics.continuum_mechanics.truss import Truss 
 
 t = Truss()
 # Knoten
 t.add_node((&quot;A&quot;, -3, 0), (&quot;B&quot;, 0, 0), (&quot;C&quot;, 4, 0), (&quot;D&quot;, 7, 0),
            (&quot;E&quot;, 6, 1.5), (&quot;F&quot;, 2, 3), (&quot;G&quot;, -2, 1.5))
 # Stäbe
 t.add_member((&quot;AB&quot;,&quot;A&quot;,&quot;B&quot;), (&quot;BC&quot;,&quot;B&quot;,&quot;C&quot;), (&quot;CD&quot;,&quot;C&quot;,&quot;D&quot;))
 t.add_member((&quot;AG&quot;,&quot;A&quot;,&quot;G&quot;), (&quot;GB&quot;,&quot;G&quot;,&quot;B&quot;), (&quot;GF&quot;,&quot;G&quot;,&quot;F&quot;))
 t.add_member((&quot;BF&quot;,&quot;B&quot;,&quot;F&quot;), (&quot;FC&quot;,&quot;F&quot;,&quot;C&quot;), (&quot;CE&quot;,&quot;C&quot;,&quot;E&quot;))
 t.add_member((&quot;FE&quot;,&quot;F&quot;,&quot;E&quot;), (&quot;DE&quot;,&quot;D&quot;,&quot;E&quot;))
 # Auflager; roller ... Loslager, pinned ... Festlager
 t.apply_support((&quot;A&quot;,&quot;roller&quot;), (&quot;D&quot;,&quot;pinned&quot;))
 # Einwirkende Kräfte
 t.apply_load((&quot;G&quot;, 5, 270), (&quot;E&quot;, 3, 90))
 
 # Berechnung 
 t.solve()
 print(&quot;Reaction Forces: &quot;, t.reaction_loads)
 print(&quot;Internal Forces: &quot;, t.internal_forces)
 
 # Fachwerk zeichnen
 p = t.draw()
 p.show()

Ausgabe auf der Konsole:

 Reaction Forces:  {'R_A_y': 4.20000000000000, 'R_D_x': 0, 'R_D_y': -2.20000000000000}
 Internal Forces:  {'AB': 2.80000000000000, 'BC': 0.333333333333333, 'CD': -1.46666666666667, 
 'AG': -5.04777178564958, 'GB': -2.05555555555556, 'GF': -1.23413387432364, 
 'BF': 0.411111111111111*sqrt(13), 'FC': -0.3*sqrt(13), 'CE': 1.50000000000000, 
 'FE': 0.284800124843917, 'DE': 2.64407093534026}

Zeichnung:

[[File:PythonIng_fachwerk1.svg|300px]]

Details zu diesem Thema siehe z.B. [https://docs.sympy.org/latest/modules/physics/continuum_mechanics/index.html Continuum Mechanics] oder [https://docs.sympy.org/latest/tutorials/physics/continuum_mechanics/index.html Continuum Mechanics Tutorials]. Auch andere mechanische Probleme werden von SymPy abgehandelt ([https://docs.sympy.org/latest/tutorials/physics/index.html Physics Tutorials]).

== Aufgabe ==
Gegeben sei ein einseitig eingespannter Kragträger. Belastet wird er durch eine Einzellast am Trägerende. Für die Daten siehe folgende ASCII-Skizze:

                            | 20 kN  
    //|---&gt; x               |
    //|                     V
    //|----------------------
    //|         10 m        |
 
 Elastizitätsmodul E = 2,1*10⁵ N/mm²
 Flächenträgheitsmoment I = 0.001 m⁴

Berechnen Sie die Auflagerreaktionen, den Querkraft- und Biegemomentenverlauf, sowie die Verformungen.
Stellen Sie dies mit Hilfe von SymPy graphisch und auch mittels Formeln dar. Verwenden Sie dazu auch pprint (pretty print) aus dem SymPy-Modul. Zwecks Lösungsansatz siehe die oben aufgeführte Seite &quot;Continuum Mechanics Tutorials&quot;. Achten Sie auch auf die Einheiten! Kontrollieren Sie das Ganze mittels händischer Rechnung. In dem genannten Tutorial ist von &quot;Singularity Functions&quot; die Rede. Gemeint ist damit in diesem Kontext die {{W|Föppl-Klammer}}.

Einige Python-Programme, vorrangig zu Maschinenelementen, finden sich auf [https://baymp.de/download_python.html BayMP für Python] (Balken, Zahnräder, Stabknickung usw.).

=Thermodynamik= 
== PYroMat ==
Für thermodynamische Aufgabenstellungen gibt es verschiedene externe Module. Eines davon ist PYroMat (siehe auch [http://pyromat.org]). Damit lassen sich thermodynamische Stoffdaten für viele Substanzen berechnen.

Beispiel (einige Stoffdaten für Wasser bei 400°C und 20 bar berechnen):

 import pyromat as pm
 
 # Wasserdaten laden:
 H2O = pm.get('mp.H2O')
 
 # Stoffdaten berechnen:
 T = 673.15  # Temperatur in Kelvin
 p = 20      # Druck in bar
 v = H2O.v(T, p)
 h = H2O.h(T, p)
 s = H2O.s(T, p)
 print(f&quot;Spezifisches Volumen: {v} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {h} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {s} kJ/(kg K)&quot;)

Ausgabe:

 Spezifisches Volumen: [0.1512163] m³/kg
 Spezifische Enthalpie: [3248.3789473] kJ/kg
 Spezifische Entropie: [7.12924142] kJ/(kg K)

&lt;small&gt;
PYroMat muss vorab installiert werden (z.B. mittels pip, in eine virtuelle Umgebung)
&lt;/small&gt;

&lt;code&gt;mp&lt;/code&gt; steht für &quot;multi phase&quot;. Für ein ideales Gas wäre &lt;code&gt;ig&lt;/code&gt; zuständig, z.B. &lt;code&gt;'ig.O2'&lt;/code&gt;.

Beispiel (T-s-Diagramm für Wasser zeichnen):
 import numpy as np
 import matplotlib.pyplot as plt
 import pyromat as pm
 
 # Konfigurieren
 pm.config[&quot;unit_pressure&quot;] = &quot;bar&quot;
 pm.config[&quot;unit_temperature&quot;] = &quot;K&quot;
 fluid = pm.get(&quot;mp.H2O&quot;)
 
 # Temperaturbereich für das Nassdampfgebiet
 T_tripel = 273.16
 T_crit = 647.096
 T = np.linspace(T_tripel, T_crit - 0.1, 200)
 
 # Sättigungslinien berechnen und zeichnen
 for x in np.linspace(0.0, 1.0, 5):
     s = fluid.s(T=T, x=x)
     if(x&lt;=0.0):
         plt.plot(s, T, label=&quot;Siedelinie x=%3.1f&quot; % x, linewidth=2.0)
     elif(x&gt;=1.0):
         plt.plot(s, T, label=&quot;Taulinie x=%3.1f&quot; % x, linewidth=2.0)
     else:
         plt.plot(s, T, label=&quot;x=%3.1f&quot; % x, linewidth=1.0)
 
 # Isobaren zeichnen
 p_values = [0.1, 1, 10, 50, 100]
 T_isobar = np.linspace(T_tripel, 1000, 200)
 t = 0.7
 
 for p in p_values:
     s_iso = fluid.s(T=T_isobar, p=p)
     plt.plot(s_iso, T_isobar, 'k-', alpha=0.8, linewidth=0.8)
 
     t += .05
     idx = int(len(s_iso) * t)
     plt.text(s_iso[idx], T_isobar[idx], f&quot;{p} bar&quot;, fontsize=9, alpha=0.8)
 
 # Diagramm zeichnen
 plt.title(&quot;T-s-Diagramm für Wasser&quot;)
 plt.xlabel(&quot;Spezifische Entropie s in kJ/kg K&quot;, fontsize=10)
 plt.ylabel(&quot;Temperatur T in K&quot;, fontsize=10)
 plt.legend(loc=&quot;best&quot;)
 plt.grid(True)
 plt.show()

Ausgabe (in etwa so):

[[Datei:T-s-Diagramm fuer Wasser.svg|400px]]

== CoolProp ==
Auch mit CoolProp können Stoffdaten berechnet werden. Siehe auch [https://coolprop.org/coolprop/wrappers/Python/index.html]

Beispiel (Wasser bei 20bar und 400°C):
 import CoolProp.CoolProp as CP
 
 fluid = 'Water'
 T = 673.15   # Temperatur in Kelvin
 P = 20e5     # Druck in Pascal
 
 dichte = CP.PropsSI('D', 'T', T, 'P', P, fluid)
 enthalpie = CP.PropsSI('H', 'T', T, 'P', P, fluid)
 entropie = CP.PropsSI('S', 'T', T, 'P', P, fluid)
 
 print(f&quot;Spez. Volumen: {1/dichte:.6f} m³/kg&quot;)
 print(f&quot;Spez. Enthalpie: {enthalpie:.2f} J/kg&quot;)
 print(f&quot;Spez. Entropie: {entropie:.2f} J/kgK&quot;)

Ausgabe:
 Spez. Volumen: 0.151215 m³/kg
 Spez. Enthalpie: 3248344.02 J/kg
 Spez. Entropie: 7129.16 J/kgK

== iapws ==
Um Werte für Wasser(dampf) zu erhalten (IAPWS; '''I'''nternational '''A'''ssociation for the '''P'''roperties of '''W'''ater and '''S'''team) gibt es die Bibliothek iapws. Siehe auch [https://iapws.org/] und [https://pypi.org/project/iapws/]

Beispiel (Wasser für 20bar und 400°C):
 from iapws import IAPWS97
 
 dampf = IAPWS97(P=2.0, T=673.15)
 
 print(f&quot;Spezifisches Volumen: {dampf.v:.6f} m³/kg&quot;)
 print(f&quot;Spezifische Enthalpie: {dampf.h:.2f} kJ/kg&quot;)
 print(f&quot;Spezifische Entropie: {dampf.s:.4f} kJ/(kgK)&quot;)
 print(f&quot;Phase: {dampf.phase}&quot;)

Ausgabe:
 Spezifisches Volumen: 0.151208 m³/kg
 Spezifische Enthalpie: 3248.23 kJ/kg
 Spezifische Entropie: 7.1290 kJ/(kgK)
 Phase: Gas

== TESPy ==
Ein anderes Modul für einen anderen Aufgabenzweck ist TESPy ('''T'''hermal '''E'''ngineering '''S'''ystems in '''Py'''thon). Dieses Modul ist für die Anlagensimulation zuständig. Für nähere Informationen siehe [https://tespy.readthedocs.io/en/main/getting_started/introduction.html]. Als Beipiel sei hier vorerst Code, der von der Google KI generiert wurde, angeführt. Der Code wurde überarbeitet, damit keine Warnungen auftreten. Bitte aber den Code trotzdem mit Vorsicht genießen, auch KI-generierter Code kann Fehler aufweisen. Eine Pumpe wird berechnet:

 from tespy.components import Sink, Source, Pump
 from tespy.connections import Connection
 from tespy.networks import Network
 
 # 1. Netzwerk definieren (Zentrales Steuerungselement)
 # Wir wählen Wasser als Fluid und bar/Celsius als Einheiten
 nw = Network(fluids=[&quot;water&quot;])
 nw.units.set_defaults(pressure=&quot;bar&quot;, pressure_difference=&quot;bar&quot;, 
                       temperature=&quot;°C&quot;, enthalpy=&quot;kJ / kg&quot;)
 
 # 2. Komponenten erstellen
 eingang = Source(&quot;Wasserquelle&quot;)
 ausgang = Sink(&quot;Wasserspeicher&quot;)
 pumpe = Pump(&quot;Speisewasserpumpe&quot;)
 
 # 3. Verbindungen definieren (Komponenten miteinander verknüpfen)
 c1 = Connection(eingang, &quot;out1&quot;, pumpe, &quot;in1&quot;)
 c2 = Connection(pumpe, &quot;out1&quot;, ausgang, &quot;in1&quot;)
 
 # Verbindungen dem Netzwerk hinzufügen
 nw.add_conns(c1, c2)
 
 # 4. Randbedingungen und Parameter festlegen
 # Zustand am Eingang (Druck, Temperatur, Massenstrom, Fluid-Zusammensetzung)
 c1.set_attr(
     v=1,  # Massenstrom: 1 kg/s
     T=20,  # Temperatur: 20 °C
     p=1,  # Druck: 1 bar
     fluid={&quot;water&quot;: 1},  # 100% Wasser
 )
 
 # Zustand am Ausgang / Zielwerte der Pumpe
 c2.set_attr(p=10)  # Ziel-Druck nach der Pumpe: 10 bar
 
 # Pumpeneigenschaften festlegen
 pumpe.set_attr(eta_s=0.8)  # Isentroper Wirkungsgrad von 80%
 
 # 5. Simulation ausführen
 nw.solve(mode=&quot;design&quot;)
 
 # 6. Ergebnisse ausgeben
 nw.print_results()
 
 # Spezifische Werte direkt auslesen
 print(&quot;\n--- Auswertung ---&quot;)
 print(f&quot;Erforderliche Pumpenleistung: {pumpe.P.val / 1000:.2f} kW&quot;)
 print(f&quot;Temperatur nach der Pumpe: {c2.T.val:.2f} °C&quot;)

Ausgabe (gekürzt):
  iter  | residual   | progress   | massflow   | pressure   | enthalpy   | fluid      | component  
 -------+------------+------------+------------+------------+------------+------------+------------
  1     | 7.04e+04   | 12 %       | 9.96e+02   | 0.00e+00   | 8.81e+04   | 0.00e+00   | 0.00e+00   
  2     | 5.91e-12   | 100 %      | 1.11e-13   | 0.00e+00   | 7.39e-12   | 0.00e+00   | 0.00e+00   
  3     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
  4     | 5.80e-12   | 100 %      | 0.00e+00   | 0.00e+00   | 7.25e-12   | 0.00e+00   | 0.00e+00   
 Total iterations: 4, Calculation time: 0.01 s, Iterations per second: 480.85
 
 ##### RESULTS (Pump) #####
 +-------------------+----------+----------+-----------+----------+----------+----------+
 |                   |        P |       pr |        dp |      eta |    eta_s |     head |
 |-------------------+----------+----------+-----------+----------+----------+----------|
 | Speisewasserpumpe | 1.12e+06 | 1.00e+01 | -9.00e+00 | 8.00e-01 | 8.00e-01 | 9.19e+01 |
 +-------------------+----------+----------+-----------+----------+----------+----------+
 ...
 ...
 --- Auswertung ---
 Erforderliche Pumpenleistung: 1124.77 kW
 Temperatur nach der Pumpe: 20.07 °C

= Stochastik =
Die {{W|Stochastik}} ist ein sehr weites Feld. Hier werden etliche wichtige Themen kurz angerissen. Python stellt mit den Moduln math und statistics Software zu diesem Zwecke bereit. math und statistics sind bereits im Lieferumfang von Python enthalten. Aber auch mit den externen Modulen NumPy, SciPy, stochastic und pandas kann man Stochastik in Python betreiben. Die Theorie der Wahrscheinlichkeitsrechnung und Statistik soll etwas später in Band 5 dieser Buchreihe behandelt werden.

== Lageparameter == 
 import statistics
 
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 
 m1 = statistics.mean(werte)
 m2 = statistics.mode(werte)
 m3 = statistics.median(werte)
 
 print(&quot;Arithmetischer Mittelwert = &quot;, m1)
 print(&quot;Modalwert = &quot;, m2)
 print(&quot;Median = &quot;, m3)

Ausgabe:
 Arithmetischer Mittelwert =  3.5
 Modalwert =  1
 Median =  3.0

== Streuungsparameter ==
Beispiel (Berechnung der Standardabweichung):
 import statistics
 werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
 s = statistics.stdev(werte)
 print(&quot;Standardabweichung = &quot;, s)

Ausgabe:
 Standardabweichung =  2.6770630673681683

Beispiel (Berechnung des Variationskoeffizienten V = Standardabweichung/Mittelwert)
 import numpy as np
 from scipy import stats
 import statistics
 
 k = 50
 
 dat1 = [14, 21, 18, 25, 30, 17, 20]
 dat = np.array(dat1)
 
 # Mit SciPy
 v = stats.variation(dat)
 vddof = stats.variation(dat, ddof=1)
 print(&quot;V SciPy: &quot;, v)
 print(&quot;V DDOF SciPy: &quot;, vddof)
 print(k*&quot;-&quot;)
 
 # mit NumPy
 mittelwert1 = np.mean(dat)
 std_abw1 = np.std(dat)
 std_abw1ddof = np.std(dat, ddof=1) 
 v1= std_abw1 / mittelwert1
 v1ddof = std_abw1ddof / mittelwert1
 print(&quot;Mittelwert NumPy: &quot;, mittelwert1)
 print(&quot;Std.abw. NumPy: &quot;, std_abw1)
 print(&quot;Std.abw. DDOF NumPy: &quot;, std_abw1ddof)
 print(&quot;V NumPy: &quot;, v1)
 print(&quot;V DDOF NumPy: &quot;, v1ddof)
 print(k*&quot;-&quot;)
 
 # nur mit reinem Python
 mittelwert2 = statistics.mean(dat1)
 std_abw2 = statistics.stdev(dat1)
 v2 = std_abw2 / mittelwert2
 print(&quot;Mittelwert Python: &quot;, mittelwert2)
 print(&quot;Std.abw. Python: &quot;, std_abw2)
 print(&quot;V Python:&quot;, v2)
 print(k*&quot;-&quot;)

Ausgabe:
 V SciPy:  0.23890355966467272
 V DDOF SciPy:  0.25804533701889254
 --------------------------------------------------
 Mittelwert NumPy:  20.714285714285715
 Std.abw. NumPy:  4.948716593053935
 Std.abw. DDOF NumPy:  5.3452248382484875
 V NumPy:  0.23890355966467272
 V DDOF NumPy:  0.2580453370188925
 --------------------------------------------------
 Mittelwert Python:  20.714285714285715
 Std.abw. Python:  5.3452248382484875
 V Python: 0.2580453370188925
 --------------------------------------------------

Der Unterschied bei der Standardabweichung zwischen reinem Python und den externen Bibliotheken SciPy und NumPy entsteht dadurch, dass einmal durch (n-1) und das andere Mal nur durch n dividiert wird. Dies kann bei NumPy und SciPy dadurch entschärft werden, indem &lt;code&gt;ddof=1&lt;/code&gt; gesetzt wird. ddof steht für '''D'''elta '''D'''egrees '''o'''f '''F'''reedom. &lt;small&gt;Je größer die Anzahl der Datensätze n wird, umso weniger spielt das eine Rolle.&lt;/small&gt;

== Kombinatorik ==
Beispiel:

 import math
 
 n = 7
 k = 5
 
 print(&quot;n! = &quot;, math.factorial(n))
 print(&quot;Kombinationen (n über k) = &quot;, math.comb(n, k))

Ausgabe:
 n! =  5040
 Kombinationen (n über k) =  21

Siehe zu diesem Thema auch [[Ing Mathematik: Permutationen, Kombinationen, binomischer Lehrsatz]]. Die Anzahlen lassen sich einfach aus den dortigen Formeln ermitteln, z.B. bei Permutationen mit &lt;math&gt;n!&lt;/math&gt; oder Variationen mit Wiederholungen als &lt;math&gt;n^k&lt;/math&gt;. Will man die Kombinationen oder Variationen aber auch als Liste ausgeben, so kann das Modul &lt;code&gt;itertools&lt;/code&gt; nützlich sein.  

Beispiel (Variationen ohne Wiederholung):

 from itertools import permutations
 
 menge = [&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;]  # n = 4
 k = 3
 
 variationen = list(permutations(menge, k))
 
 for v in variationen:
     print(&quot;&quot;.join(v))
 
 print(50*&quot;-&quot;)
 print(len(variationen))

Ausgabe (gekürzt):
 ABC
 ABD
 ACB
 ...
 DCA
 DCB
 --------------------------------------------------
 24

Siehe zum Modul &lt;code&gt;itertools&lt;/code&gt; auch die Website [https://docs.python.org/3/library/itertools.html].

* Variationen mit Wiederholung: &lt;code&gt;itertools.product()&lt;/code&gt;
* Kombinationen ohne Wiederholung: &lt;code&gt;itertools.combinations()&lt;/code&gt;
* Kombinationen mit Wiederholung: &lt;code&gt;itertools.combinations_with_replacement()&lt;/code&gt;

== Zufallszahlen ==
Beispiel:
 import random
 
 # Ganzzahlige Zufallszahl von 1 bis 10
 zufallszahl1 = random.randint(1, 10)
 
 # Gleitpunktzahlen
 # zwischen 0.0 und 1.0
 zufallszahl2 = random.random()
 # Zahl zwischen 1.5 und 9.5
 zufallszahl3 = random.uniform(1.5, 9.5)
 
 # aus Liste auswählen
 farbe = [&quot;Rot&quot;, &quot;Grün&quot;, &quot;Blau&quot;]
 zufallswert = random.choice(farbe)
 
 print(zufallszahl1)
 print(zufallszahl2)
 print(zufallszahl3)
 print(zufallswert)

Ausgabe, z.B.:
 5
 0.14147945849015753
 6.894003397570905
 Rot

Benötigt man mehrere Zufallszahlen, so ist das Modul &lt;code&gt;numpy&lt;/code&gt; zu bevorzugen, z.B.:
* Normalverteilung: &lt;code&gt;np.random.normal(...)&lt;/code&gt;
* Gleichverteilung: &lt;code&gt;np.random.uniform(...)&lt;/code&gt;

== Histogramm ==
Zum Thema Histogramm siehe {{W|Histogramm}}.

Beispiel (mit Matplotlib):

 import matplotlib.pyplot as plt
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 
 plt.hist(daten, bins=25, edgecolor='darkgray')
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm.svg|300px]]

Beispiel (mit Seaborn):

 import matplotlib.pyplot as plt
 import seaborn as sns
 import numpy as np
 
 daten = np.random.normal(loc=50, scale=10, size=1000)
 sns.set_theme(style=&quot;darkgrid&quot;)
 sns.histplot(data=daten)
 plt.show()

Ausgabe:

[[Datei:IngMath_histogramm2.svg|300px]]

Das Kürzel &lt;code&gt;sns&lt;/code&gt; ist Konvention und steht für die fiktive Figur '''S'''amuel '''N'''orman '''S'''eaborn aus der US-Fernsehserie {{W|The West Wing – Im Zentrum der Macht | The West Wing}}.

== Box-Plot ==
[[File:Elements of a boxplot.svg|400px]]

Siehe auch {{W|Box-Plot}}.

Beispiel (mit Seaborn erstellt):
 import seaborn as sns
 import matplotlib.pyplot as plt
 
 df = sns.load_dataset(&quot;tips&quot;)
 sns.boxplot(data=df, x=&quot;day&quot;, y=&quot;tip&quot;, hue=&quot;day&quot;, legend=False)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot.svg|400px]]

Beispiel (mit Matplotlib erstellt):

 import matplotlib.pyplot as plt
 
 daten = [12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25]
 
 plt.boxplot(daten, patch_artist=True)
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_boxplot2.svg|300px]]

Um mehrere Box-Plots unterschiedlicher Farbe mit Matplotlib in einem Diagramm zu zeichnen, können Sie folgendermaßen vorgehen:

 import matplotlib.pyplot as plt
 
 daten = [[12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25],
          [10, 19, 20, 21, 20, 30, 19, 40, 11, 17, 19, 21]]
 
 farben = [&quot;green&quot;, &quot;blue&quot;]
 
 boxplot = plt.boxplot(daten, patch_artist=True)
 
 for patch, farbe in zip(boxplot['boxes'], farben):
     patch.set_facecolor(farbe)
 
 plt.title(&quot;Boxplot mit Matplotlib&quot;)
 plt.ylabel(&quot;Daten&quot;)
 plt.show()

== Regressionsrechnung ==
Beispiel:
 import numpy as np
 import matplotlib.pyplot as plt
 
 # Messpunkte
 x = np.array([1, 3, 5, 6, 8, 10, 20])
 y = np.array([3, 4, 5, 5, 7, 9, 11])
 
 # Regressionskurve (Grad 1 = lineare Regression, 2 = Polynom-Regression 2. Gr.)
 # y = kx + d
 k, d = np.polyfit(x, y, deg=1)
 # y = ax**2 + bx + c
 a, b, c = np.polyfit(x, y, deg=2)
 
 x_l = np.linspace(1, 20, 100)
 y_p = a * x_l**2 + b * x_l + c
 
 # Zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.plot(x, k*x + d, color='blue', label='Regressionsgerade')
 plt.plot(x_l, y_p, color='red', label='Regressionspolynom 2. Gr.')
 plt.xlabel('x')
 plt.ylabel('y')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:

[[Datei:IngMath_regression.svg|400px]]

== Korrelationsrechnung ==
Beispiel:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 # Messdaten
 x = [1, 3, 4, 5, 6]
 y = [2, 4, 6, 8, 5]
 
 daten = {'X': x, 'Y': y}
 df = pd.DataFrame(daten)
 
 # Korrelation
 korr = df['X'].corr(df['Y'])
 print(f&quot;Korrelationskoeff.: {korr}&quot;) 
 
 # Messpunkte zeichnen
 plt.scatter(x, y, color='green', label='Messpunkte')
 plt.grid()
 plt.axis(&quot;equal&quot;)
 plt.legend(loc=&quot;best&quot;)
 plt.show()

Ausgabe:
 Korrelationskoeff.: 0.7556096518348252

[[Datei:IngMath_korrelation.svg|300px]]

== Mengen und Venn-Diagramme ==
Beispiel: 
 import matplotlib.pyplot as plt
 from matplotlib_venn import venn2
 
 menge_a = {1, 2, 3, 4, 5, 6}
 menge_b = {4, 5, 6, 7, 8}
 
 vereinigung = menge_a | menge_b
 schnitt = menge_a &amp; menge_b
 print(&quot;Vereinigungsmenge = &quot;, vereinigung)
 print(&quot;Schnittmenge = &quot;, schnitt)
 
 venn2([menge_a, menge_b], set_labels=('Menge A', 'Menge B'))
 plt.show()

Ausgabe:
 Vereinigungsmenge =  {1, 2, 3, 4, 5, 6, 7, 8}
 Schnittmenge =  {4, 5, 6}

[[Datei:IngMath_venn.svg|300px]]

Siehe auch {{W|Mengendiagramm#Venn-Diagramme}}.

== Verteilungs- und Dichtefunktion ==
* CDF ... '''C'''umulative '''D'''istribution '''F'''unction, Verteilungsfunktion
* PDF ... '''P'''robability '''D'''ensity '''F'''unction, Dichtefunktion

Beispiel (Normalverteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 from scipy.stats import norm
 
 my, sigma = 0, 1
 x = np.linspace(-4, 4, 50)
 
 pdf = norm.pdf(x, my, sigma)
 cdf = norm.cdf(x, my, sigma)
 
 plt.plot(x, pdf, lw=2, label=&quot;Dichtefunktion&quot;)
 plt.plot(x, cdf, lw=2, label=&quot;Verteilungsfunktion&quot;)
 plt.legend()
 plt.grid()
 plt.show()

Ausgabe:

[[Datei:IngMath_cdf_pdf.svg|300px]]

Beispiel (&lt;math&gt;\chi^2&lt;/math&gt;-Verteilung):
 import numpy as np
 import matplotlib.pyplot as plt
 import scipy.stats as stats
 
 x = np.linspace(0, 20, 500)
 
 # df ... degree of freedom, Freiheitsgrad
 pdf = (stats.chi2.pdf(x, df=2), stats.chi2.pdf(x, df=5), stats.chi2.pdf(x, df=10))
 
 for i in range(0,3):
     if(i==0):
         lab = &quot;Freiheitsgrad 2&quot;
     elif(i==1):
         lab = &quot;Freiheitsgrad 5&quot;
     else:
         lab = &quot;Freiheitsgrad 10&quot;
 
     plt.plot(x, pdf[i], label=lab, lw=2)
 
 plt.grid()
 plt.legend()
 plt.show()

Ausgabe:

[[Datei:IngMath_chi2.svg | 300px]]

== Schätzen und Testen ==
=== Intervallschätzung ===
Als Beispiel seien Daten gegeben, die von ''Dürr, Mayer: Wahrscheinlichkeitsrechnung und Schließende Statistik; 7. Aufl., Hanser, 2014, Seite 137'' stammen. Und zwar soll das 95%-Vertrauensintervall für den Mittelwert des Kaloriengehalts (kcal/100g) von Hähnchen ermittelt werden. Wir wollen das mit Python inkl. NumPy und SciPy durchführen. Die Stichprobe ist groß (50 Hähnchen):

Python-Code:
 import numpy as np
 import scipy.stats as stats
 
 # Stichprobe
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203]
 
 # Parameter definieren
 konfidenzniveau = 0.95
 mean = np.mean(daten)
 std = np.std(daten, ddof=1)
 stdfehler = stats.sem(daten)
 
 intervall = stats.norm.interval(confidence=konfidenzniveau, loc=mean, scale=stdfehler)
 
 print(f&quot;Mittelwert: {mean}&quot;)
 print(f&quot;Standardabweichung: {std}&quot;)
 print(f&quot;Konfidenzintervall: {intervall}&quot;)

Ausgabe:
 Mittelwert: 215.48
 Standardabweichung: 33.14238915925757
 Konfidenzintervall: (np.float64(206.29356722321992), np.float64(224.66643277678006))

Diese Werte stimmen gerundet mit denen im genannten Buch überein. Zum Code selbst:
* sem steht für '''s'''tandard '''e'''rror of the '''m'''ean.
* &lt;code&gt;scipy.stats.norm&lt;/code&gt; ... Modul für die Normalverteilung.

=== Punktschätzung ===
Gleiche Daten wie oben bei der Intervallschätzung.

Python-Code:
 import numpy as np
 from scipy import stats
 
 daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
          236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
          207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
          238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
          242, 236, 174, 240, 195, 223, 213, 209, 200, 203
         ]
 
 mu_hat, sigma_hat = stats.norm.fit(daten) 
 
 print(f&quot;Schätzer für den Erwartungswert (μ): {mu_hat:.4f}&quot;)
 print(f&quot;Schätzer für die Standardabweichung (σ): {sigma_hat:.4f}&quot;)

Ausgabe:
 Schätzer für den Erwartungswert (μ): 215.4800
 Schätzer für die Standardabweichung (σ): 32.8093

=== Hypothesentests ===
Beispiel:

 import numpy as np
 import scipy.stats as stats
 
 x_quer = 12.075      # Stichproben-Mittelwert
 var    = 0.069       # Stichproben-Varianz
 n      = 90          # Stichprobengröße
 my_0   = 12.0        # Nullhypothese
 alpha  = 0.05        # Signifikanzniveau
 
 z_stat = (x_quer - my_0) / np.sqrt(var / n)
 p_val = 2 * (1 - stats.norm.cdf(np.abs(z_stat)))
 
 print(f&quot;Z-Statistik: {z_stat:.4f}&quot;)
 
 if p_val &lt; alpha:
     print(f&quot;p-Wert: {p_val:.6f} &lt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird verworfen.&quot;)
 else:
     print(f&quot;p-Wert: {p_val:.6f} &gt; alpha:&quot;, alpha)
     print(&quot;Die Nullhypothese wird nicht verworfen.&quot;)

Ausgabe:

 Z-Statistik: 2.7087
 p-Wert: 0.006755 &lt; alpha: 0.05
 Die Nullhypothese wird verworfen.

== Statistische Qualitätskontrolle ==
Beispiel (Mittelwertkarte):

 import numpy as np
 import matplotlib.pyplot as plt
 
 # Gegeben
 sollwert = 50.0
 varianz = 4.0
 stichproben_umfang = 1
 daten = [49.5, 50.2, 53.0, 48.1, 52.6, 53.4, 49.8]
 
 # Berechnung
 standardabweichung = np.sqrt(varianz)
 streuung = standardabweichung / np.sqrt(stichproben_umfang)
 
 cl = sollwert
 ucl = cl + 3 * streuung
 lcl = cl - 3 * streuung
 
 # Darstellung
 plt.plot(daten, marker='o', linestyle='-', color='b', label='Messdaten')
 plt.axhline(cl, color='green', linestyle='-', label=f'CL: {cl}')
 plt.axhline(ucl, color='red', linestyle='--', label=f'UCL: {ucl:.2f}')
 plt.axhline(lcl, color='red', linestyle='--', label=f'LCL: {lcl:.2f}')
 
 plt.title('Mittelwertkarte')
 plt.xlabel('Stichprobe')
 plt.ylabel('Wert')
 plt.legend(loc='lower left')
 plt.grid(True)
 plt.show()

Ausgabe:

[[Datei:IngMath_mittelwertkarte.svg|300px]]

Siehe auch {{W|Shewhart-Regelkarte}} und {{W|Qualitätsregelkarte}}.

* UCL ... '''U'''pper '''C'''ontrol '''Limit''', Obere Eingriffsgrenze
* LCL ... '''L'''ower '''C'''ontrol '''Limit''', Untere Eingriffsgrenze
* CL ... '''C'''enter '''L'''ine, Mittellinie

= Ein- und Ausgabe =
== print ==
Die Anweisung print haben wir schon oft verwendet. Hier soll anhand von Beispielen kurz beschrieben werden, was der Befehl print leisten kann.

 print(&quot;Hallo&quot;, &quot;Welt&quot;, 1, sep=&quot;-&quot;)
 print(&quot;Hallo&quot;, end=&quot; &quot;)
 print(&quot;Welt&quot;)

Ausgabe:
 Hallo-Welt-1
 Hallo Welt

== input ==
 a = int(input(&quot;Zahl 1: &quot;))
 b = int(input(&quot;Zahl 2: &quot;))
 
 print(&quot;a + b = &quot;, a+b)

Ausgabe (nach Eingabe der beiden Ganzzahlen):
 Zahl 1: 4
 Zahl 2: 5
 a + b =  9

== Aus Dateien lesen ==
Es seinen die datei.txt
 Hallo Welt.
 Wie geht es dir?
 ...

und test1.py
 dat = open(&quot;datei.txt&quot;, mode = &quot;r&quot;)
 print(dat.read())
 dat.close()

Ausgabe
 Hallo Welt.
 Wie geht es dir?
 ...

Mit dem open()-Befehl wird die Datei datei.txt im Lesemodus geöffnet (r ... read). Mit dem read()-Befehl wird die Datei eingelesen und mittels print ausgegeben.

== In Dateien schreiben ==
 dat = open(&quot;datei.txt&quot;, mode = &quot;a&quot;, encoding = &quot;utf-8&quot;)
 dat.write(&quot;Hänge Zeile an\n&quot;)
 dat.close()

Die Datei datei.txt sieht nach Abarbeitung des obigen Skripts nun so aus
 Hallo Welt.
 Wie geht es dir?
 ...
 Hänge Zeile an

Es wird die Datei im Schreibmodus geöffnet (a ... append (anhängend), w ... write (überschreibend)).
write() fügt hier also eine Zeile Text am Dateiende ein. close() schließt die Datei wieder.

Das close() kann man sich mit der with-Anweisung auch sparen.

 with open(&quot;datei.txt&quot;, mode=&quot;a&quot;, encoding=&quot;utf-8&quot;) as dat:
     dat.write(&quot;Hänge Zeile an\n&quot;)

= Benutzeroberflächen erstellen =
== tkinter ==
{{Wikipedia | Tkinter}}

Python bietet standardmäßig das Modul tkinter zur Programmierung von Benutzeroberflächen. Es müssen also bei der Verwendung von tkinter keine externen Module installiert werden. Hier wird eine (sehr) kurze Einführung in das Erstellen von grafischen Oberflächen mittels tkinter gegeben.

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 win.minsize(300, 50)
 but = tk.Button(win, text = &quot;Push the button&quot;)
 but.pack()
 win.mainloop()

Ausgabe:

[[Datei:PythonIng_gui1.jpg]]

Ein etwas komplizierteres Beispiel sei nachfolgend gezeigt. Es sollen zwei Strings miteinander verknüpft und ausgegeben werden. 

 import tkinter as tk
 
 win = tk.Tk()
 win.title(&quot;Hallo Welt!&quot;)
 
 def on_button_clicked():
     str = ent1.get() + ent2.get()
     lab2[&quot;text&quot;] = str
  
 ent1 = tk.Entry(win)
 ent2 = tk.Entry(win)
 lab1 = tk.Label(win, text=&quot;verknuepfen mit&quot;)
 lab2 = tk.Label(win, text=&quot;&quot;) 
 but = tk.Button(win, text = &quot;=&quot;, command=on_button_clicked)
 
 ent1.pack(side=&quot;left&quot;)
 lab1.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 but.pack(side=&quot;left&quot;)
 ent2.pack(side=&quot;left&quot;)
 lab2.pack(side=&quot;left&quot;)
 
 win.mainloop()

Ausgabe  (vor der Eingabe der Teilstrings): 

[[Datei:PythonIng_gui2.jpg]]

Ausgabe (nach der Eingabe der Teilstrings und dem Drücken des =-Buttons): 

[[Datei:PythonIng_gui3.jpg]]

== curses ==
{{Wikipedia | curses}}

Mit dem curses-Modul lassen sich u.a. TUIs ('''T'''ext '''U'''ser '''I'''nterfaces) erstellen. Ein sehr einfaches Beispiel zur allgemeinen Funktionsweise wird nachstehend geliefert.
 
 import curses
 
 stdscr = curses.initscr()
 curses.start_color()
 curses.init_pair(1, curses.COLOR_RED, curses.COLOR_WHITE)
 stdscr.clear()
 
 stdscr.addstr(&quot;Hallo Welt&quot;, curses.color_pair(1))
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()
 
Als Ausgabe sollte &lt;span style=&quot;color:#FF0000;&quot;&gt;Hallo Welt&lt;/span&gt; (rote Schrift auf weißem Hintergrund) auf dem Terminal/der Konsole erscheinen. Getestet wurde dies mit openSUSE Tumbleweed, Python-Version 3.13.12. Das entsprechende Python-curses-Package muss installiert sein.

Allgemeine Informationen zur Terminal-/Konsolengröße und Cursorposition liefert folgendes Programm:
 
 import curses
 
 stdscr = curses.initscr()
 
 stdscr.addstr(3, 5, &quot;LINES: %d&quot; % curses.LINES)
 stdscr.addstr(4, 5, &quot;COLS:  %d&quot; % curses.COLS)
 
 (y,x) = stdscr.getyx()
 stdscr.addstr(5, 5, &quot;Momentane Cursorposition:  [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getbegyx()
 stdscr.addstr(6, 5, &quot;Koordinatenursprung:       [%d, %d]&quot; % (y, x))
 
 (y,x) = stdscr.getmaxyx()
 stdscr.addstr(7, 5, &quot;Fenstergröße:              [%d, %d]&quot; % (y, x))
 
 stdscr.addstr(11, 2, &quot;Taste drücken -&gt; Ende&quot;)
 stdscr.refresh()
 
 stdscr.getch()
 
 curses.endwin()

Es sollte sich in etwa folgende Ausgabe ergeben:

     LINES: 44
     COLS:  110
     Momentane Cursorposition:  [4, 15]
     Koordinatenursprung:       [0, 0]
     Fenstergröße:              [44, 110]
 
 
 Taste drücken -&gt; Ende

Zur Funktionsweise von curses siehe auch das Wikibook [[ncurses]]. Zum Verständnis sind dort allerdings elementare Kenntnisse in der Programmiersprache C erforderlich.

== Qt ==
{{Wikipedia | Qt (Bibliothek)}}

Auch für das Qt-Framework gibt es eine Anbindung an Python. Nachfolgend ein einfaches Beispiel.

 import sys
 from PySide6.QtWidgets import QApplication, QLabel
 
 app = QApplication(sys.argv)
 label = QLabel(&quot;Hallo Welt!&quot;)
 label.show()
 sys.exit(app.exec())

Ausgabe:

[[Datei:PythonIng_gui10.png]]

== Gtk ==
{{Wikipedia | GTK (Programmbibliothek)}}

Eine idente Ausgabe, wie oben für Qt gezeigt, erzeugt z.B. folgendes Gtk-Programm:

 import gi
 gi.require_version(&quot;Gtk&quot;, &quot;4.0&quot;)
 from gi.repository import Gtk
 
 def on_activate(app):
     win = Gtk.ApplicationWindow(application=app)
     lab = Gtk.Label(label=&quot;Hallo Welt!&quot;)
     win.set_child(lab)
     win.present()
 
 app = Gtk.Application()
 app.connect('activate', on_activate)
 app.run(None)

Auch für die Benutzung von Qt und Gtk müssen die jeweiligen Packages installiert sein. Getestet wurden die entsprechenden Python-Programme nur unter openSUSE Tumbleweed. Wie das GTK-Paket unter MS Windows 11 installiert wird, siehe z.B. [https://www.gtk.org/docs/installations/windows Setting up GTK for Windows].

Damit sei aber das Thema &quot;Benutzeroberflächen erstellen&quot; hier abgeschlossen, da dies schon ein sehr spezielles Aufgabengebiet ist, das eher Informatiker und nicht so sehr Ingenieure anspricht. Bei Bedarf siehe aber ggf. die entsprechenden Links unten in diesem Tutorial. Dort sind weiterführende Informationen zu finden.

= Pandas kurz erklärt =
Hier wird kurz auf das externe Modul Pandas eingegangen. Pandas steht für '''Pan'''el '''Da'''ta und ist ein Modul für die Datenanalyse und -manipulation.

== Series ==
Vorstellbar ist eine &quot;Series&quot; wie eine einzelne Spalte in einem Tabellenkalkulationsprogramm.

Beispiel (Index implizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5]) # Temperaturwerte
 print(temp)

Ausgabe:
 0     8.5
 1    11.0
 2    12.5
 3    10.0
 4    13.0
 5    11.0
 6    14.5
 dtype: float64

Das Kürzel &lt;code&gt;pd&lt;/code&gt; ist Konvention. Es seien Temperaturwerte gegeben. Die erste Spalte bei der Ausgabe ist der Index. Die zweite Spalte enthält die Werte.

Beispiel (separater Zugriff auf den Index und auf die Werte):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5])
 print(temp.index)
 print(temp.values)

Ausgabe:
 RangeIndex(start=0, stop=7, step=1)
 [ 8.5 11.  12.5 10.  13.  11.  14.5]

Beispiel (Index explizit vorgegeben):
 import pandas as pd
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 print(&quot;*** Die gesamte Series ***&quot;)
 print(temp)
 
 print(&quot;*** Temperatur am Donnerstag ***&quot;)
 print(temp[&quot;Do&quot;])
 
 print(&quot;*** Tage wärmer als 12 Grad ***&quot;)
 temp_gr_12 = temp[temp &gt; 12]
 print(temp_gr_12)

Ausgabe:
 *** Die gesamte Series ***
 Mo     8.5
 Di    11.0
 Mi    12.5
 Do    10.0
 Fr    13.0
 Sa    11.0
 So    14.5
 dtype: float64
 *** Temperatur am Donnerstag ***
 10.0
 *** Tage wärmer als 12 Grad ***
 Mi    12.5
 Fr    13.0
 So    14.5
 dtype: float64

== DataFrame ==
Ein DataFrame entspricht einer Tabelle.

Beispiel (Erzeugen eines DataFrames):
 import pandas as pd
 
 tag   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 v1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=tag)
 v2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=tag)
 v3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=tag)
 
 tab = pd.concat([v1, v2, v3], axis=1)
 tab.columns = stadt
 
 print(tab)
 print(type(tab))

Ausgabe:
     Linz  Salzburg Innsbruck
 Mo     1         8     Hallo
 Di     2         9        16
 Mi     3        10        17
 Do     4        11        18
 Fr     5        12        19
 Sa     6        13        20
 So     7        14        21
 &lt;class 'pandas.core.frame.DataFrame'&gt;

Wir haben hier drei Datenspalten (v1, v2, v3) mit den Spaltennamen &quot;Linz&quot;, &quot;Salzburg&quot; und &quot;Innsbruck&quot;, sowie sieben Zeilen &quot;Mo&quot; bis &quot;So&quot;.

Beispiel (Zugriff auf eine Spalte):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab[&quot;Salzburg&quot;])

Ausgabe:
 Mo     8
 Di     9
 Mi    10
 Do    11
 Fr    12
 Sa    13
 So    14
 Name: Salzburg, dtype: int64

Beispiel (Zugriff auf eine Zeile):
 import pandas as pd
 
 ind   = [&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;]
 stadt = [&quot;Linz&quot;, &quot;Salzburg&quot;, &quot;Innsbruck&quot;]
 
 temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
            index=ind)
 temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
            index=ind)
 temp3 = pd.Series([&quot;Hallo&quot;, 16, 17, 18, 19, 20, 21],
            index=ind)
 
 tab = pd.concat([temp1, temp2, temp3], axis=1)
 tab.columns = stadt
 
 print(tab.loc[&quot;Di&quot;])

Ausgabe:
 Linz          2
 Salzburg      9
 Innsbruck    16
 Name: Di, dtype: object

== Grafiken erstellen ==
Hier sei nur ein Torten- oder Kreisdiagramm gezeichnet:
 import pandas as pd
 import matplotlib.pyplot as plt
 
 temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
            index=[&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;])
 
 expl = [0, 0.2, 0, 0, 0, 0, 0]
 temp.plot.pie(figsize=(5,5), explode=expl)
 plt.show()

Ausgabe:

[[Datei:IngPython_pandas1.svg|350px]]

Die &lt;code&gt;figsize&lt;/code&gt; hat nichts mit der Spaltenanzahl zu tun, sondern setzt die Fenster- oder Diagrammgröße in Inches (Breite * Höhe).
 
Mit Pandas kann man auch noch andere Diagrammarten erstellen, z.B. Linien- oder Balkendiagramme. Dies wird hier aber nicht vorgeführt.

== Arbeiten mit CSV- und LibreOffice-Dateien ==
Gegeben sei eine CSV-Datei test1.csv:
 Mai;Juni;Juli
 12;17;45
 15;65;65
 16;32;23
 4;14;7
 23;17;Keine Daten verfügbar
 67;Keine Daten verfügbar;45
 15;24;12

Lesen von dieser CSV-Datei:
 import pandas as pd
 
 tab = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 print(tab)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Schreiben in eine CSV-Datei test2.csv:
 import pandas as pd
 
 val = pd.read_csv(&quot;test1.csv&quot;, sep=&quot;;&quot;)
 val.to_csv(&quot;test2.csv&quot;, index=False)

Ausgabedatei:
 Mai,Juni,Juli
 12,17,45
 15,65,65
 16,32,23
 4,14,7
 23,17,Keine Daten verfügbar
 67,Keine Daten verfügbar,45
 15,24,12

Die Ausgabedatei ist beinahe gleich wie die Eingabedatei. Es werden aber Kommas statt Strichpunkten verwendet. Daher kommt auch der Name CSV ('''C'''omma '''S'''eparated '''V'''alue). Will man wieder Strichpunkte, so kann man dies über den Parameter &lt;code&gt;sep=&quot;;&quot;&lt;/code&gt; in der &lt;code&gt;to_csv&lt;/code&gt;-Funktion machen.

Um direkt von einer ODS-Datei (LibreOffice Calc, '''O'''pen '''D'''ocument '''S'''preadsheet) zu lesen muss das Modul odfpy extra installiert sein (per YaST, pip etc.). Gelesen wird dann folgendermaßen:
 import pandas as pd
 
 df = pd.read_excel('test1.ods', engine='odf')
 print(df)

Ausgabe:
    Mai                   Juni                   Juli
 0   12                     17                     45
 1   15                     65                     65
 2   16                     32                     23
 3    4                     14                      7
 4   23                     17  Keine Daten verfügbar
 5   67  Keine Daten verfügbar                     45
 6   15                     24                     12

Die Datei &quot;test1.ods&quot; sei die Datei, aus der das obige &quot;test1.csv&quot; generiert wurde. Schreiben kann man ebenfalls in eine ODS-Datei:

 import pandas as pd
 
 daten = {
     &quot;Name&quot;: [&quot;Hugo&quot;, &quot;Richie&quot;, &quot;Wilhelmine&quot;],
     &quot;Alter&quot;: [38, 30, 29],
     &quot;Ort&quot;: [&quot;Linz&quot;, &quot;Innsbruck&quot;, &quot;Salzburg&quot;]
 }
 
 tab = pd.DataFrame(daten)
 
 with pd.ExcelWriter(&quot;test2.ods&quot;, engine=&quot;odf&quot;) as writer:
     tab.to_excel(writer, sheet_name=&quot;Daten&quot;, index=False)

Es ergibt sich eine &quot;test2.ods&quot;-Datei (Screenshot):

[[Datei:IngPython_pandas2.png|250px]]

== Sonstiges ==
Hier seien stichpunktartig einige weitere Features von Pandas angeführt:
* {{W|Pivot-Tabelle|Pivot-Tabellen}} (pivot ... Dreh-, Angelpunkt): Zweck - große Datenmengen schnell zusammenfassen, filtern und analysieren.
* NaN ('''n'''ot '''a''' '''n'''umber): In einem Datensatz fehlt ein Wert oder ist nicht definiert.
* groupby-Funktion: Daten strukturieren, aggregieren oder Zwischensummen bilden. 
* {{W|Binning#Datenverarbeitung_und_-analyse|Binning}}: Klassenbildung.
* Mehrstufige Indizierung (Hierarchical Indexing oder MultiIndex).
* Zeitreihen (Time Series).
* MS Excel-Dateien schreiben mit dem Modul openpyxl.

Für tiefergehende und weiterführende Informationen wird auf das Buch von ''Klein: Numerisches Python; Hanser, 2023'' und [https://pandas.pydata.org/ pandas] verwiesen.

= Style Guide, flake8, pylint, Black etc. =
== Style Guide ==
Wie man schönen und richtigen Python-Code schreibt, erfahren Sie in
* [https://peps.python.org/pep-0008/ PEP 8 – Style Guide for Python Code]

== Formatter und Linter ==
Ein Modul, das prüft, ob die Richtlinien im Style Guide eingehalten wurden, ist ''flake8'':
* [https://flake8.pycqa.org/en/latest/ Flake8: Your Tool For Style Guide Enforcement]

Code formatieren kann man auch mit [https://pypi.org/project/black/ Black]. Z.B. übersetzt &lt;code&gt;black test1.py&lt;/code&gt; die Datei &lt;code&gt;test1.py&lt;/code&gt;

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)),
     (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

in 

 import sympy as sp
 
 H = sp.Symbol(&quot;H&quot;, positive=True)
 T = sp.Symbol(&quot;T&quot;, positive=True)
 t = sp.Symbol(&quot;t&quot;)
 
 f = sp.Piecewise(
     (H, (t &gt; 0) &amp; (t &lt; T / 2)), (2 * H / T * (t - T / 2), (t &gt; T / 2) &amp; (t &lt; T))
 )
 
 f_series = sp.fourier_series(f, (t, 0, T))
 sp.pprint(f_series.truncate(4))

Die Programmausgabe ist 

 reformatted test1.py
 
 All done! ✨ 🍰 ✨
 1 file reformatted.

Der Unterschied zwischen Black und Flake8:
* Black ist ein Code-Formatter. Er formatiert Ihren Code um, sodass er im Einklang mit PEP 8 steht.
* Flake8 ist ein {{W|Lint (Programmierwerkzeug) | Code-Linter}}. Flake8 verändert Ihren Code nicht, sondern durchsucht ihn nach potenziellen Fehlern etc.

Am obigen Beispiel sieht man auch, dass flake8 und Black nicht immer einer Meinung sind. Flake8 (&lt;code&gt;flake8 test1.py&lt;/code&gt;) würde standardmäßig den mit Black formatierten Code bemängeln:

 test1.py:8:80: E501 line too long (80 &gt; 79 characters)

Diese Diskrepanz kann beseitigt werden. Da 79 Zeichen auf modernen Bildschirmen meist als zu kurz empfunden werden, ist ein Limit von 88 Zeichen (Black-Standard) oder mehr empfehlenswert. Um dies zu implementieren, erstellen Sie in Ihrem Projektverzeichnis eine &lt;code&gt;.flake8&lt;/code&gt;-Datei mit dem Inhalt

 [flake8]
 max-line-length = 88

Und schon ignoriert Flake8 dieses Problem.

Ein anderer Linter ist pylint. Der würde beim Abarbeiten des obigen Beispiels, z.B. mit &lt;code&gt;pylint test1.py&lt;/code&gt; noch eine Kleinigkeit bemängeln:

 ************* Module test1
 /home/hr/tmp/test1.py:1:0: C0114: Missing module docstring (missing-module-docstring)
 
 ------------------------------------------------------------------
 Your code has been rated at 8.57/10 (previous run: 8.57/10, +0.00)

Auch pylint muss vor der ersten Verwendung installiert werden (z.B. mittels pip, virtuelle Umgebung, YaST). Die Dokumentation zu pylint findet sich auf [https://pylint.readthedocs.io/en/latest/].

&lt;u&gt;Aufgabe:&lt;/u&gt; Fügen Sie einen &quot;module docstring&quot; in die &lt;code&gt;test1.py&lt;/code&gt;-Datei ein und testen Sie erneut mit flake8, Black und pylint. &lt;small&gt;Sehen Sie zum Thema docstrings auch [https://peps.python.org/pep-0257/#what-is-a-docstring PEP 257 – Docstring Conventions].&lt;/small&gt;

Es gibt noch weitere Formatierungswerkzeuge für Python-Code. Z.B. [https://docs.astral.sh/ruff/ Ruff], ein moderner Code-Formatter und -Linter. Mittels &lt;code&gt;ruff check test1.py&lt;/code&gt; würde obiger Code geprüft (Linter). &lt;code&gt;ruff format test1.py&lt;/code&gt; formatiert den Code (Formatter).

== Type Checker ==
&quot;Type Checker&quot; sind z.B.
* mypy
* pyright
* ty

Diese prüfen die Datentypen, z.B. in folgendem Code

 def greetings(name: str) -&gt; str:
     return &quot;Hello, %s&quot; % name
 
 
 print(greetings(42))

Python selbst, flake8, ruff oder black würden diesen Code ohne zu murren akzeptieren. &quot;Type Checker&quot; würden aber sehr wohl Alarm schlagen, z.B. liefert &lt;code&gt;mypy&lt;/code&gt; folgende Ausgabe

 test1.py:5: error: Argument 1 to &quot;greetings&quot; has incompatible type &quot;int&quot;; expected &quot;str&quot;  [arg-type]
 Found 1 error in 1 file (checked 1 source file)

Das funktioniert übrigens nicht nur bei Funktionsannotationen, sondern auch mit Variablen etc.

 from typing import Final
 
 # &quot;Konstante&quot;, ab Python 3.8
 NUMBER: Final = 123
 print(NUMBER)
 NUMBER = 125
 print(NUMBER)
 
 # Variable
 a: int = 345
 print(a)
 a = &quot;Irgendwas&quot;
 print(a)
 
 # Variable (Pipe-Symbol), ab Python 3.10
 b : int|str = 567
 print(b)
 b = &quot;sonstiges&quot;
 print(b)

Ausgabe mit python:
 123
 125
 345
 Irgendwas
 567
 sonstiges

Ausgabe mit mypy:
 test3.py:6: error: Cannot assign to final name &quot;NUMBER&quot;  [misc]
 test3.py:12: error: Incompatible types in assignment (expression has type &quot;str&quot;, variable has type &quot;int&quot;)  [assignment]
 Found 2 errors in 1 file (checked 1 source file)

Python kennt übrigens keine Konstanten. Man kann diese mittels Großbuchstaben andeuten. Das ist aber nur Konvention, hat aber keine sonstigen Auswirkungen. Oder man verwendet wie oben gezeigt &lt;code&gt;Final&lt;/code&gt;. Dann werfen Typchecker Errors aus.

==pydoc==
pydoc ist ein Werkzeug, um Python-Module, -Funktionen und -Klassen zu dokumentieren.

Beispiel &lt;code&gt;test1.py&lt;/code&gt;:
 &quot;&quot;&quot;Rechen-Modul.
 
 Funktionen die von pydoc gelesen werden.
 &quot;&quot;&quot;
 
 def multiply(a, b):
     &quot;&quot;&quot;Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
     
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a * b
     
 def add(a, b):
     &quot;&quot;&quot;Addiert zwei Zahlen und gibt das Ergebnis zurück.
    
     Argumente:
     a -- erste Zahl
     b -- zweite Zahl
     &quot;&quot;&quot;
     return a + b
    
 
 if __name__ == '__main__':
     print(multiply(3, 5))
     print(add(4, 6))

Ausgabe mit &lt;code&gt;python3.13 -m pydoc test1&lt;/code&gt; auf der Konsole:

 Help on module test1:
 
 NAME
     test1 - Rechen-Modul. 
 
 DESCRIPTION
     Funktionen die von pydoc gelesen werden.
 
 FUNCTIONS
     add(a, b)
         Addiert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
     multiply(a, b)
         Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
 
         Argumente:
         a -- erste Zahl
         b -- zweite Zahl
 
 FILE
     /home/xyz/tmp/test1.py

Siehe zu diesem Thema z.B. auch [https://docs.python.org/3/library/pydoc.html]. Mittels &lt;code&gt;python3.13 -m pydoc -w test1&lt;/code&gt; kann man auch eine HTML-Dokumentation erstellen.

Wofür &lt;code&gt;if __name__ == '__main__':&lt;/code&gt; steht, siehe z.B. etwas später im Abschnitt [[Ing_Mathematik:_Python#Doctests]].

== Sonstige Tools ==
Andere Tools für die {{W|Statische Code-Analyse|statische Codeanalyse}}, die aber für Ingenieure weniger interessant sein dürften, sind z.B.
* Radon: Liefert verschiedene {{W|Softwaremetrik|Codemetriken}} (Komplexität, Wartbarkeitsindex ...)
* Bandit: Findet Sicherheitslücken

Tools für die {{W|Dynamisches Software-Testverfahren|dynamische Codeanalyse}}, z.B.:
* DynaPyt (Framework zur dynamischen Programmanalyse)
* cProfile (Profiler)
* Memory Profiler (Speicheranalyse)
* Memray (Speicheranalyse)
* tracemalloc (Speicheranalyse)

Paket- und Projektmanagement (pip-Ersatz etc.):
* uv
* Poetry
* Conda
* pipx

Packaging-Tools (Freezer) und {{W|Compiler#Sonderformen|Transpiler}} :
* pyinstaller
** erstellt eigenständige, ausführbare Binärdatei
** kein Cross-Compiler
** kein Schutz vor Reverse-Engineering
** langsam
** packt alles in eine Datei
** sehr große Datei
** Befehl, z.B.: &lt;code&gt;pyinstaller --onefile test1.py&lt;/code&gt;
** GUI: &lt;code&gt;auto-py-to-exe&lt;/code&gt;
* cx_Freeze
* nuitka
** Übersetzt Python-Code in C/C++-Code und weiter in eine ausführbare Datei
** kein Cross-Compiler
** Schutz vor Reverse-Engineering
** Befehl, z.B.: &lt;code&gt;nuitka --standalone --onefile test1.py&lt;/code&gt;
* cython

= Einige Integrierte Entwicklungsumgebungen (IDEs)=
Werden Programmtexte größer und umfangreicher, so ist das Arbeiten mit der interaktiven Programmierumgebung bzw. das direkte Ausführen von Python-Skripten mühsam. Man wünscht sich z.B. Hilfen zum Debuggen oder die automatische Code-Vervollständigung. Zu diesem Zweck wurden IDEs (Integrated Development Environments) geschaffen. Von diesen seinen nachfolgend auszugsweise einige kurz beschrieben. Testen Sie einfach aus, welche davon für Sie bzw. für Ihr Python-Projekt geeignet sind.

== IDLE ==
IDLE ist die mit dem Python-Programmpaket mitgelieferte IDE. Der Name leitet sich einerseits ab vom Monty-Python-Mitglied Eric Idle, andererseits steht es als Abkürzung für &quot;'''I'''ntegrated '''D'''evelopment and '''L'''earning '''E'''nvironment. IDLE ist einfach zu bedienen, bietet aber schon einen beachtlichen Leistungsumfang. Nachfolgend wird ein Screenshot zu IDLE geliefert. Rechts ist das Editor-Fenster zu sehen, links die interaktive Programmierumgebung. Um das Beispiel selbst nachvollziehen zu können, starten Sie IDLE. Das geht ähnlich, wie Sie die interaktive Programmierumgebung von Python starten (nur, dass Sie eben das IDLE-Icon doppelklicken und nicht das Python-Icon. Unter Linux geben Sie einfach in einem Terminal &lt;code&gt;idle3.13&lt;/code&gt; o. Ä. ein). Weiter geht es mit &quot;File - Open - ...&quot;. Die auszuführende Datei auswählen (im konkreten Fall ein &quot;Hallo-Welt&quot;-Programm). Es erscheint das rechte Fenster. Dort &quot;Run - Run Module&quot; auswählen. Und schon wird im linken Fenster &quot;Hallo Welt!&quot; ausgegeben.

[[Datei:PythonIng_idle1.jpg | 600px]]

Siehe auch {{W|IDLE}}.

== PyCharm ==
PyCharm ist ein kommerzielles Produkt. Es gab aber auch eine kostenlose Community Edition. Seit 2025 sind beide Varianten vereint. Für die ersten 30 Tage sind die Pro-Funktionen frei verfügbar, danach nur noch die Kernfunktionalitäten (oder man bezieht kostenpflichtig  die Pro-Version). Zu beziehen ist PyCharm unter dem Weblink [https://www.jetbrains.com/pycharm/]. Nachfolgend ein etwas abgewandeltes &quot;Hallo Welt&quot;-Programm, editiert und ausgeführt mit PyCharm.

[[Datei:PyCharm_IDE_2023_screenshot.png | 600px]]

Siehe auch {{W|PyCharm}}.

== Eric ==
Auch eric ist Open Source und steht unter der  GNU General Public License Version 3 oder später. Zu beziehen ist diese Software unter [https://eric-ide.python-projects.org/].

[[Datei:Screenshot_Eric_4.png | 600px]]

Siehe auch {{W|eric (Software)}}.

&lt;small&gt;
Unter openSUSE Tumbleweed sollte sich eric auch mit YaST installieren lassen. Bei mir gibt es aber dann beim Ausführen des eric-Programms eine Fehlermeldung (Stand März 2026): 
 
 ...
 ModuleNotFoundError: No module named 'PyQt6.QtPdfWidgets'

Umgehen kann man dieses Problem aber wieder mit dem Erstellen einer virtuellen Umgebung, in etwa so

 python3.13 -m venv ~/tmp/venv1
 cd ~/tmp/venv1/bin
 ./python3.13 -m pip install --upgrade --prefer-binary eric-ide
 ./eric7_ide
&lt;/small&gt;

== PyScripter ==
Vom Funktionsumfang vergleichbar mit den vorherigen IDEs ist PyScripter. Auch PyScripter ist Open Source. Die Projekt-Homepage findet sich auf [https://sourceforge.net/projects/pyscripter/]. PyScripter ist nur für MS Windows verfügbar.

[[Datei:PythonIng_pyscripter1.jpg | 600px]]

== Spyder IDE ==
Spyder enthält bereits eine stabile Python-Version und etliche Module (z.B. matplotlib, numpy, control). Ansonsten kann dieses Softwarepaket vom Funktionsumfang her mit den anderen genannten IDEs locker mithalten. Spyder wurde unter der MIT-Lizenz veröffentlicht. Diese Software findet sich auf [https://www.spyder-ide.org].

[[Datei:Spyder-windows-screenshot.png | 600px]]

Siehe auch {{W|Spyder (Software)}}

== Eclipse IDE==
Die {{W|Eclipse_(IDE)|Eclipse-IDE}} kann für Python aufgerüstet werden. Dazu gibt es das PyDev-Plugin. Installiert wird es über 
* Help &gt; Eclipse Marketplace... 
* Find - PyDev - Install
Danach muss noch der Pfad zum Python-Interpreter festgelegt werden 
* Window &gt; Preferences &gt; PyDev &gt; Interpreters &gt; Python Interpreter &gt; New ... 
Das Ergebnis ist ähnlich wie im folgenden Bild, nur dass statt C/C++ Python Verwendung findet. 

[[Datei:Setting Up Eclipse CDT helloout.png | 600px]]

== Sonstige ==
Die genannten IDEs sind nicht die Einzigen. Es gibt, um dem Image Pythons als beliebteste Programmiersprache gerecht zu werden, noch einige andere. Sowohl Open Source-Programme als auch kommerzielle Programme sind im Web zu finden, z.B. Thonny oder {{W|Visual Studio Code}}. Unter Linux kann man auch {{W|KDevelop}}, ausgestattet mit dem Python3-Plugin, einsetzen. Braucht man den Umfang von ausgewachsenen IDEs nicht, so kann man auch normale Texteditoren verwenden (z.B. {{W|Geany}} oder {{W|Kate_(Texteditor)|Kate}}).

= Debuggen und Testen =
Das Debuggen und Testen von Programmen sind wichtige Bestandteile der Programmierung. Syntaxfehler lassen sich i.A. leicht beheben. Schwieriger ist das Eingrenzen von logischen Fehlern, die ev. nur in bestimmten Situationen auftreten und keine explizite Fehlermeldung hervorrufen. Das Programm liefert falsche Ergebnisse oder es stürzt aus heiterem Himmel ab. Um das zu verhindern gibt es verschiedene Werkzeuge, die bei der Fehlersuche behilflich sein können. Vorerst siehe aber zwecks Begriffsklärung noch folgende Links: 
 
* {{W|Debuggen}}
* {{W|Debugger}}
* {{W|Softwaretest}}

&lt;gallery&gt;
First Computer Bug, 1947.jpg
Test ganzheitlich.png
V-Modell.svg
&lt;/gallery&gt;

== Das Modul pdb ==
Python bringt schon ein Modul zum Debuggen mit. Siehe z.B. [https://docs.python.org/3/library/pdb.html pdb — The Python Debugger].
Komfortabler lässt sich das aber mittels Integrierter Entwicklungsumgebungen (IDEs) angehen.

== Debuggen mit IDEs ==
Für die IDEs IDLE und Spyder sei kurz auf die entsprechenden Webseiten verwiesen:

* [https://www.cs.uky.edu/~keen/help/debug-tutorial/debug.html Debugging under IDLE].
* [https://docs.spyder-ide.org/current/panes/debugging.html Spyder Debugger]

Dort wird die Vorgehensweise auch mittels Screenshots erläutert.

== assert ==
assert ... behaupten, zusichern ({{W|Assertion (Informatik)}})

Python-Code:
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10., 0.)

Ausgabe:

 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10., 0.)
   File &quot;/home/hr/Develop/test1.py&quot;, line 4, in print1
     assert y != 0.0
            ^^^^^^^^
 AssertionError
 
Python-Code: 
 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)
 
Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(&quot;10.&quot;, &quot;5.&quot;)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError
 
Aber auch bei nachfolgendem Code gibt es eine Fehlermeldung:

 def print1(x, y):
     assert type(x) == float
     assert type(y) == float
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 Traceback (most recent call last):
   File &quot;/home/hr/Develop/test1.py&quot;, line 8, in &lt;module&gt;
     print1(10, 5)
   File &quot;/home/hr/Develop/test1.py&quot;, line 2, in print1
     assert type(x) == float
            ^^^^^^^^^^^^^^^^
 AssertionError

Damit letzteres funktioniert, kann man den Programmcode so umschreiben:
 def print1(x, y):
     assert type(x) == float or type(x) == int
     assert type(y) == float or type(y) == int
     assert y != 0.0
     print(x/y)
 
 print1(10., 5.)
 print1(10, 5)

Ausgabe:
 2.0
 2.0
 
Und jetzt fangen wir den &lt;code&gt;AssertionError&lt;/code&gt; auf:
 def print1(x, y):
     try:
         assert type(x) == float or type(x) == int
         assert type(y) == float or type(y) == int
         assert y != 0.0
         print(x/y)
     except(AssertionError):
         print(&quot;Hallo&quot;)
 
 print1(10., 5.)
 print1(&quot;10.&quot;, &quot;5.&quot;)

Ausgabe:
 2.0
 Hallo

Ich hoffe, es ist wenigstens im Ansatz klar geworden, wofür &lt;code&gt;assert&lt;/code&gt; gut sein kann. Ausschalten kann man die &lt;code&gt;assert&lt;/code&gt;-Überprüfung übrigens mit dem Python-Schalter &lt;code&gt;-O&lt;/code&gt;.

== Doctests == 
Innerhalb eines Docstrings kann die Arbeit im interaktiven Modus simuliert werden. Nach den Promptzeichen (&gt;&gt;&gt;) erfolgen dann bei unserem Beispiel innerhalb des Docstrings simulierte Aufrufe der Funktion &lt;code&gt;print1()&lt;/code&gt;. Danach folgen jeweils die Sollresultate. Wird das Modul oder die Datei als Hauptprogramm aufgerufen, so wird die Funktion &lt;code&gt;doctest.testmode()&lt;/code&gt; aufgerufen und ein Bericht auf der Konsole ausgegeben. Wird das Modul nicht als Hauptprogramm aufgerufen, sondern importiert, dann wird diese &lt;code&gt;testmod&lt;/code&gt;-Funktion nicht aufgerufen. D.h. dieser Code kann sowohl für Testzwecke als auch für den produktiven Einsatz verwendet werden. Das ist auch sinnvoll, weil wenn man Teile der Datei immer löschen bzw. einfügen müsste, so würden sich Fehlerquellen auftun. Das würde den Sinn und Zweck von Doctests konterkarieren.  

 def print1(x=0., y=1.):
     &quot;&quot;&quot; Dividiere zwei Zahlen
     Autor: Intruder
     Datum: 12.08.2025
 
     &gt;&gt;&gt; print1(2., 1.)
     2.0
     &gt;&gt;&gt; print1(5., 2.)
     2.5
     &gt;&gt;&gt; print1(5.)
     5.0
     &quot;&quot;&quot;
     print(x/y)
 
 if __name__ == &quot;__main__&quot;:
     import doctest
     doctest.testmod(verbose=True)

Ausgabe:
 Trying:
     print1(2., 1.)
 Expecting:
     2.0
 ok
 Trying:
     print1(5., 2)
 Expecting:
     2.5
 ok
 Trying:
     print1(5.)
 Expecting:
     5.0
 ok
 1 items had no tests:
     __main__
 1 items passed all tests:
    3 tests in __main__.print1
 3 tests in 2 items.
 3 passed and 0 failed.
 Test passed.

Das gezeigte Beispiel ist so ziemlich das einfachste, das es gibt. Für weiterführende Details siehe z.B.:
* [https://peps.python.org/pep-0257/ PEP 257 – Docstring Conventions]
* [https://docs.python.org/3/library/doctest.html doctest — Test interactive Python examples]

''Einschub:'' Ganz ähnlich kann man auch Klassen testen, z.B. in folgendem Code-Fragment

 class Fahrzeug:
   # siehe Abschnitt &quot;Objektorientierte Programmierung&quot;
   # ...
 
 if __name__ == &quot;__main__&quot;:
   vauweh = Fahrzeug(170, 90)
   beemweh = Fahrzeug(200, 120)
   print(vauweh.convertGeschw())
   print(beemweh.convertGeschw())

Wird das Script als Hauptprogramm ausgeführt (z.B. zu Testzwecken), so erfolgt die Ausgabe der zwei, via &lt;code&gt;convertGeschw()&lt;/code&gt;, umgerechneten Geschwindigkeiten. Wird es aber als Modul eingebunden, so wird der letzte Programmabschnitt nicht ausgeführt (&lt;code&gt;__name__ == &quot;__main__&quot;&lt;/code&gt; ergibt &lt;code&gt;False&lt;/code&gt;).

== pytest ==
Siehe zu diesem Thema auch {{W|Modultest}}.

pytest ist ein externes Modul und muss vorab installiert werden, z.B. mittels 
 pip install -U pytest
 pip install -U pytest-html 

Python-Code, Datei test1.py:
 def add(x, y):
     return x + y
 
 def test_answer():
     assert add(1, 1) == 3

Starten von pytest in der Konsole:
 pytest test1.py
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py F                                                                                                            [100%]
 
 ========================================================= FAILURES ==========================================================
 ________________________________________________________ test_answer ________________________________________________________
 
     def test_answer():
 &gt;       assert add(1, 1) == 3
 E       assert 2 == 3
 E        +  where 2 = add(1, 1)
 
 test1.py:6: AssertionError
 ================================================== short test summary info ==================================================
 FAILED test1.py::test_answer - assert 2 == 3
 ===================================================== 1 failed in 0.09s =====================================================

Hier erhalten wir einen Fehler, da 1+1 eindeutig ungleich 3 ist. Aber aus irgendeinem Grund wollte der Programmierer oder Tester in diesem Fall, dass dies so ist. Testfälle werden übrigens mit dem Präfix &lt;code&gt;test_&lt;/code&gt; eingeleitet.

Python-Code:
 def add(x, y):
     return x + y + 1
 
 def test_answer():
     assert add(1, 1) == 3 
 
Ausgabe:
 ==================================================== test session starts ====================================================
 platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
 rootdir: /home/hr/Develop
 plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
 collected 1 item                                                                                                            
 
 test1.py .                                                                                                            [100%]
 
 ===================================================== 1 passed in 0.01s =====================================================

Jetzt ist alles in Ordnung. Weiterführendes siehe z.B.

* [https://docs.pytest.org/en/stable/ pytest: helps you write better programs]

== unittest ==
Auch unittest dient zur Durchführung von Testreihen, ist aber Bestandteil von Python. Hier wird vorerst nicht näher darauf eingegangen. Siehe z.B. 
* [https://docs.python.org/3/library/unittest.html unittest — Unit testing framework]

Lt. ''Inden: Python Challenge; dpunkt, 2021, Seite 481''  soll unittest weniger komfortabel als pytest sein.

Einen Vergleich von unittest mit pytest findet man in
* [https://knapsackpro.com/testing_frameworks/difference_between/pytest/vs/unittest pytest vs unittest]

= Python und Anwendungsprogramme =
Bisher stand immer alleine die Programmiersprache Python (ev. unter Einbeziehung von Modulen) im Mittelpunkt der Betrachtungen. Aber Python kann auch als Makrosprache für Anwendungsprogramme auftreten. Als Beispiele seien {{W|FreeCAD}} und {{W|LibreOffice}} genannt.

== FreeCAD ==
FreeCAD ist ein freies 3D-CAD-Programm. Hier soll nicht auf die Bedienung dieses CAD-Pakets eingegangen werden, sondern nur auf die Möglichkeit, mittels Python Makros zu schreiben. Als einfacher Einstieg soll ein Makro erstellt werden, welches eine Kugel (rot) und einen Quader (blau) zeichnet. Folgende Vorbereitungsschritte sind erforderlich (es sei vorausgesetzt, dass FreeCAD schon am Rechner installiert ist. Downloaden können Sie das Programm von der Website [https://www.freecad.org/downloads.php?lang=en]):

* FreeCAD starten
* Leere Datei erstellen
* Makro &gt; Makros &gt; Erstellen ...

Es öffnet sich ein leeres Editorfenster, in das Sie folgenden Code eingeben können:

 import FreeCAD
 import Part
 
 doc = FreeCAD.newDocument()
 
 # Kugel
 kugel = Part.makeSphere(10)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Kugel&quot;)
 form_element.Shape = kugel
 kug = FreeCAD.ActiveDocument.getObject(&quot;Kugel&quot;)
 kug.ViewObject.ShapeColor = (1.0, 0.0, 0.0)
 neuePosition = App.Vector(5, 2.5, 2.5)
 kug.Placement = App.Placement(neuePosition, kug.Placement.Rotation)
 
 # Quader
 quader = Part.makeBox(5, 5, 50)
 form_element = doc.addObject(&quot;Part::Feature&quot;, &quot;Quader&quot;)
 form_element.Shape = quader
 quad = FreeCAD.ActiveDocument.getObject(&quot;Quader&quot;)
 quad.ViewObject.ShapeColor = (0.0, 0.0, 1.0)
 
 doc.recompute()

Diesen Code können Sie nun ausführen:
* Makro &gt; Makro ausführen

Es ergibt sich folgende Ausgabe (gedreht und gezoomt):

[[Datei: PythonIng_freecad1.png|500px]]

Siehe auch [https://wiki.freecad.org/Python_scripting_tutorial/de# Anleitung Skripterstellung mit Python]. Getestet wurde obiges Beispiel mit FreeCAD 1.1.3 unter Linux und 1.1.1 unter MS Windows.

== LibreOffice ==
LibreOffice ist ein freies Officepaket ([https://de.libreoffice.org/]). Hier soll nur das Tabellenkalkulationsprogramm Calc kurz betrachtet werden. Es seinen in den ersten 3 Zellen (A1 bis A3) Zahlen gegeben. Diese sollen mit einem Python-Makro addiert und das Resultat in der Zelle A5 ausgegeben werden. Auch hier sind Vorbereitungsarbeiten nötig: 
* zuerst muss unter Linux das Verzeichnis &lt;code&gt;~/.config/libreoffice/4/user/Scripts/python&lt;/code&gt; erstellt werden
* für MS Windows ist es das Verzeichnis &lt;code&gt;%APPDATA%\LibreOffice\4\user\Scripts\python&lt;/code&gt; 
** drücken Sie zuerst Win + R (es öffnet sich das Ausführen-Fenster)
** geben Sie &lt;code&gt;%appdata%&lt;/code&gt; ein, danach drücken Sie Enter (es öffnet sich der Explorer)
** navigieren Sie zu dem genannten Verzeichnis bzw. erstellen Sie das Verzeichnis 
* in diesem Verzeichnis wird dann mit einem beliebigen Texteditor das Python-Makro erstellt, in unserem Fall die Datei &lt;code&gt;summiere_zellen.py&lt;/code&gt;:

 import uno
 
 def summiere_zellen(*args):
     # Zugriff auf das aktuelle Dokument und das aktive Tabellenblatt
     ctx = uno.getComponentContext()
     smgr = ctx.getServiceManager()
     desktop = smgr.createInstanceWithContext(&quot;com.sun.star.frame.Desktop&quot;, ctx)
     doc = desktop.getCurrentComponent()
     sheet = doc.getCurrentController().getActiveSheet()
 
     # Werte aus den Zellen A1 bis A3 auslesen
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
 
     # Addition der drei Werte
     summe = w1 + w2 + w3
 
     # Ergebnis in die Zelle A5 schreiben
     sheet.getCellRangeByName(&quot;A5&quot;).Value = summe

* siehe dazu ggf. auch [https://help.libreoffice.org/latest/de/text/sbasic/python/python_locations.html?DbPAR=BASIC].

Weiter geht es in LibreOffice Calc mit dem Menü ''Extras &gt; Makros &gt; Makros verwalten &gt; Python''. Dort wird das Makro &lt;code&gt;summiere_zellen&lt;/code&gt; ausgeführt. Es ergibt sich z.B. folgendes Resultat

[[Datei:PythonIng_libreoffice1.png]]

Das Kürzel &lt;code&gt;uno&lt;/code&gt; steht für '''U'''niversal '''N'''etwork '''O'''bjects. Etwas einfacher geht's auch so:

 def summiere_zellen():
     desktop = XSCRIPTCONTEXT.getDesktop()
     model = desktop.getCurrentComponent()
     sheets = model.getSheets()
     sheet = sheets.getByIndex(0)
     
     w1 = sheet.getCellRangeByName(&quot;A1&quot;).Value
     w2 = sheet.getCellRangeByName(&quot;A2&quot;).Value
     w3 = sheet.getCellRangeByName(&quot;A3&quot;).Value
     
     cell = sheet.getCellRangeByName(&quot;A5&quot;)    
     cell.setValue(w1 + w2 + w3) 

Empfohlen wird auch, das Erweiterungspaket APSO ('''A'''lternative '''P'''ython '''S'''cript '''O'''rganizer, apso.oxt) zu installieren. Die Vorgehensweise wird hier nicht gezeigt, sondern nur darauf hingewiesen, dass man das einfach &quot;googeln&quot; kann. Siehe zur Python-Programmierung für LibreOffice auch [https://wiki.documentfoundation.org/Macros/Python_Guide/de Makros/Python-Handbuch]. Getestet wurden obige Beispiele mit LibreOffice 26.2.5.1 unter Linux und 26.2.1.2 unter MS Windows.

= Ausblick =
Dies war eine kurze Einführung in die Berechnungs- und Darstellungsmöglichkeiten mit Python. Es sollten etliche relevante Themen behandelt, oder zumindest kurz angesprochen worden sein. Wem dieser Text nicht ausreichend ist, der sei auf die entsprechenden weiterführenden Weblinks, Bücher und die Python-Hilfefunktion verwiesen. Python kennt noch viel mehr Befehle, als hier dargestellt wurden. Das Themenspektrum ist auch durch die Einbindung externer Module fast beliebig erweiterbar.

= Weblinks=
== Python allgemein ==
* [https://www.python.org/ Python Homepage]

== Externe mathematische Module ==
* [https://numpy.org/ NumPy]
* [https://numpy.org/doc/stable/user/numpy-for-matlab-users.html NumPy for MATLAB users]
* [https://scipy.org/ SciPy]
* [https://www.sympy.org/en/index.html SymPy]
* [https://pandas.pydata.org/ pandas]
* [https://github.com/maroba/findiff findiff]
* [https://mpmath.org/ mpmath]

== Externe Module für Grafiken ==
* [https://matplotlib.org/ Matplotlib]
* [https://vpython.org/ VPython]
* [https://build123d.readthedocs.io/en/latest/ build123d]
* [https://docs.vtk.org/en/latest/api/python.html VTK]
* [https://docs.bokeh.org/en/latest/docs/first_steps.html bokeh]
* [https://py5coding.org/ py5]

== Erstellung von User Interfaces ==
* [https://docs.python.org/3/library/tkinter.html tkinter - Python interface to Tcl/Tk]
* [https://docs.python.org/3/library/curses.html curses - Terminal handling for character-cell displays]
* [https://wiki.qt.io/Qt_for_Python Qt for Python]
* [https://www.gtk.org/docs/language-bindings/python GTK and Python]

== Erstellen virtueller Umgebungen ==
* [https://docs.python.org/3/library/venv.html venv - Creation of virtual environments]

== Sonstige ==
* [https://python-control.readthedocs.io/en/stable/ Python Control Systems Library]
* [https://pypi.org/project/regex/ regex - Regular Expressions]
* [http://pyromat.org/ PYroMat]
* [https://coolprop.org/coolprop/wrappers/Python/index.html CoolProp]
* [https://pypi.org/project/iapws/ iapws]
* [https://tespy.readthedocs.io/en/main/getting_started/introduction.html TESPy - Thermal Engineering Systems in Python]
* [https://pint.readthedocs.io/en/stable/ pint]

= Bücher =
== Gedruckte Bücher, OpenBooks, Magazine ==
* Diverse: c't Python Lernen, Verstehen, Anwenden; Heise, 2022 
* Ernesti, Kaiser: Python3 - das umfassende Handbuch; 5. Aufl., Rheinwerk, [https://openbook.rheinwerk-verlag.de/python/ OpenBook]
* Iacono et al.: Programmieren trainieren; 3. Aufl., Hanser, 2023, ISBN 978-3-446-47766-7
* Inden: Python Challenge; dpunkt, 2021, ISBN 978-3-86490-809-5
* Klein: Numerisches Python; 2. Aufl., Hanser, 2023, ISBN 978-3-446-47170-2 
* Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler; Rheinwerk, 2021, ISBN 978-3-8362-7316-9
* Weigend: Python 3 - Das umfassende Praxisbuch; 9. Aufl., mitp, 2022, ISBN 978-3-7475-0544-1
* Woyand: Python für Ingenieure und Naturwissenschaftler; 4. Aufl., Hanser, 2021, ISBN 978-3-446-46483-4

== Andere Wikibooks ==
* [[:en:Subject:Python_programming_language | Englische Wikibooks zum Thema Python]]
* [[Python|Deutschsprachiges Python-Wikibook]] [[Bild:2von10.png|20%]]
* [[Python unter Linux|Python 2.7 unter Linux]] [[Bild:10von10.png|100%]]


{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}</text>
      <sha1>i03351cd9pjxr9e1cpatel15kjsmgvs</sha1>
    </revision>
  </page>
  <page>
    <title>Stenografie/ Kapitel 7</title>
    <ns>0</ns>
    <id>120059</id>
    <revision>
      <id>1092175</id>
      <parentid>1044998</parentid>
      <timestamp>2026-10-16T19:21:32Z</timestamp>
      <contributor>
        <username>~2026-55371-50</username>
        <id>117057</id>
      </contributor>
      <origin>1092175</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="8292" sha1="b23j42jav9jke1e6gzz5q3e7cih8htm" xml:space="preserve">[[Stenografie/ Kapitel 6|Kapitel 6]] ← '''Kapitel 7''' → [[Stenografie/ Kapitel 8|Kapitel 8]] 


== k, ck ==

:Das Zeichen für „k“ ist halbstufig. Es ähnelt dem oberen Teil eines Kreises. Das gleiche Zeichen steht auch für „ck“. (c = ck)
:Wenn das &quot;k&quot; auf einen Selbstlaut folgt erhält es einen schrägen Anstrich.
:{| class=&quot;wikitable&quot; style=&quot;margin: 1em auto 1em auto; margin-left: 10px&quot;
|-align=&quot;center&quot;
|  bgcolor=&quot;#ff88ff &quot; |    [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - k.svg|thumb| Buchstabe: k  ]]    ||  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - Kette.svg|thumb| {{Antwort1|Kette}}  ]]  
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - nette.svg|thumb| {{Antwort1|nette}}  ]]    ||  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - der Kenner.svg|thumb|{{Antwort1|der Kenner}}  ]] 
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - kennen.svg|thumb| {{Antwort1|kennen}}  ]]    || [[File:B DEK Deutsche Einheitskurzschrift - Verkehrsschrift - die Motte.svg|thumb|{{Antwort1|die Motte}}  ]] 
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - necken.svg|thumb| {{Antwort1|necken}}  ]]    ||  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - kommen.svg|thumb|{{Antwort1|kommen}}  ]] 
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - komm.svg|thumb| {{Antwort1|komm}}  ]]    ||  [[File:B DEK Deutsche Einheitskurzschrift - Verkehrsschrift - ich komme.svg|thumb|{{Antwort1|ich komme}}  ]]  
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - Becken.svg|thumb| {{Antwort1|Becken}}  ]]    ||  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - Ketten.svg|thumb| {{Antwort1|Ketten}}  ]]  
|}

== „ek-“ ==

:Ein &quot;e&quot; vor dem &quot;k&quot; wird durch einen verlängerten Anstrich des &quot;k&quot; versinnbildlicht.

:{| class=&quot;wikitable&quot; style=&quot;margin: 1em auto 1em auto; margin-left: 10px&quot;
|-align=&quot;center&quot;
|  [[File:B DEK Deutsche Einheitskurzschrift - Verkehrsschrift - die Ecke.svg|thumb| {{Antwort1|die Ecke}}  ]]    ||  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - Ecken.svg|thumb|{{Antwort1|Ecken}}  ]]  
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - Otto ist keck.svg|thumb| {{Antwort1|Otto ist keck}}  ]]    ||  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - toben.svg|thumb|{{Antwort1|toben}}  ]] 
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - mehr Rohre.svg|thumb| {{Antwort1|mehr Rohre}}  ]]    ||  [[File:G DEK Deutsche Einheitskurzschrift - Verkehrsschrift - Rom.svg|thumb|{{Antwort1|Rom}}  ]]  
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - der Meter.svg|thumb| {{Antwort1|der Meter}}  ]]    ||  [[File:B DEK Deutsche Einheitskurzschrift - Verkehrsschrift - das Meter.svg|thumb|{{Antwort1|das Meter}}  ]] 
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - Motor.svg|thumb| {{Antwort1|Motor}}  ]]    ||  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - Rad.svg|thumb|{{Antwort1|Rad}}  ]]  
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - Rat.svg|thumb| {{Antwort1|Rat}}  ]]    ||  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - Motorrad.svg|thumb|{{Antwort1|Motorrad}}  ]]   
|}

== 015 ==

:{| class=&quot;wikitable&quot; style=&quot;margin: 1em auto 1em auto; margin-left: 10px&quot;
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - nehmen.svg|thumb| {{Antwort1|nehmen}}  ]]    ||  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - neben.svg|thumb|{{Antwort1|neben}}  ]]  
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - eben.svg|thumb| {{Antwort1|eben}}  ]]    ||  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - Theben.svg|thumb|{{Antwort1|Theben}}  ]] 
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - toben.svg|thumb| {{Antwort1|toben}}  ]]    ||  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - monoton.svg|thumb|{{Antwort1|monoton}}  ]]  
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - nennen.svg|thumb| {{Antwort1|nennen}}  ]]    ||  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - beben.svg|thumb|{{Antwort1|beben}}  ]] 
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - boten.svg|thumb| {{Antwort1|boten}} oder {{Antwort1|Boten}} oder {{Antwort1|Booten}} ]]    ||  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - bergen.svg|thumb|{{Antwort1|bergen}}  ]]  
|-align=&quot;center&quot;
|  [[File:B DEK Deutsche Einheitskurzschrift - Verkehrsschrift - der Berg.svg|thumb| {{Antwort1|der Berg}}  ]]    ||  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - borgen.svg|thumb|{{Antwort1|borgen}}  ]]   
|}


== f ==

:Das Zeichen für „f“ ist zweistufig, ähnelt aber ansonsten dem „d“
:{| class=&quot;wikitable&quot; style=&quot;margin: 1em auto 1em auto; margin-left: 10px&quot;
|-align=&quot;center&quot;
| bgcolor=&quot;#ff88ff &quot; |    [[File:K DEK Deutsche Einheitskurzschrift - Verkehrsschrift - f.svg|thumb| Buchstabe: f ]]  || bgcolor=&quot;#ffddff&quot; |   [[File:K DEK Deutsche Einheitskurzschrift - Verkehrsschrift - d.svg|thumb| Buchstabe: d ]] 
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - fegen.svg|thumb|{{Antwort1|fegen}}  ]]   ||  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - kommen.svg|thumb|{{Antwort1|fegen}}  ]] 
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - Ocker.svg|thumb| {{Antwort1|Ocker}}  ]]    ||  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - Ecke.svg|thumb|{{Antwort1|Ecke}}  ]]  
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - Decke.svg|thumb| {{Antwort1|Decke}}  ]]    ||  [[File:B DEK Deutsche Einheitskurzschrift - Verkehrsschrift - die Feder.svg|thumb|{{Antwort1|die Feder}}  ]] 
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - reden.svg|thumb| {{Antwort1|reden}}  ]]    ||  [[File:B DEK Deutsche Einheitskurzschrift - Verkehrsschrift - der Koffer.svg|thumb|{{Antwort1|der Koffer}}  ]]  
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - Rotton.svg|thumb| {{Antwort1|Rotton}}  ]]    ||  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - oder.svg|thumb|{{Antwort1|oder}}  ]]   
|}

== für ==

:Für das Kürzel „für“ verwenden wir das gleiche Zeichen wie für den Buchstaben „f“.
:{| class=&quot;wikitable&quot; style=&quot;margin: 1em auto 1em auto; margin-left: 10px&quot;
|-align=&quot;center&quot;
| bgcolor=&quot;#ff88ff &quot; |   [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - für.svg|thumb| Kürzel: für ]]    ||  [[File:P DEK Deutsche Einheitskurzschrift - Verkehrsschrift - für Otto.svg|thumb| {{Antwort1|für Otto}}  ]]  
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - mohnrot.svg|thumb| {{Antwort1|mohnrot}}  ]]    ||   [[File:z DEK Deutsche Einheitskurzschrift - Verkehrsschrift - ist das für Benno.svg|thumb|{{Antwort1|ist das für Benno}}  ]]  
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - roter Mohn.svg|thumb| {{Antwort1|roter Mohn}}  ]]    ||  [[File:B DEK Deutsche Einheitskurzschrift - Verkehrsschrift - mehr Regen.svg|thumb|{{Antwort1|mehr Regen}}  ]]  
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - begeben.svg|thumb| {{Antwort1|begeben}}  ]]    ||  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - begonnen.svg|thumb|{{Antwort1|begonnen}}  ]] 
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - benehmen.svg|thumb| {{Antwort1|benehmen}}  ]]    ||  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - benommen.svg|thumb|{{Antwort1|benommen}}  ]]  
|-align=&quot;center&quot;
|  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - Roboter.svg|thumb| {{Antwort1|Roboter}}  ]]    ||  [[File:DEK Deutsche Einheitskurzschrift - Verkehrsschrift - betonen.svg|thumb|{{Antwort1|betonen}}  ]]   
|}


[[Stenografie/ Kapitel 6|Kapitel 6]] ← '''Kapitel 7''' → [[Stenografie/ Kapitel 8|Kapitel 8]]</text>
      <sha1>b23j42jav9jke1e6gzz5q3e7cih8htm</sha1>
    </revision>
  </page>
  <page>
    <title>Diskussion:Stenografie/ Kapitel 7</title>
    <ns>1</ns>
    <id>123175</id>
    <revision>
      <id>1092177</id>
      <timestamp>2026-10-16T19:47:07Z</timestamp>
      <contributor>
        <username>~2026-55371-50</username>
        <id>117057</id>
      </contributor>
      <comment>Neuer Abschnitt /* Fehler bei &quot;ek&quot;? */</comment>
      <origin>1092177</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="301" sha1="7vacujh4gbc81n15m2grlhlm64hixm4" xml:space="preserve">== Fehler bei &quot;ek&quot;? ==
Das letzte Wort des &quot;ek&quot; Teils soll &quot;Motorrad&quot; sein, die Buchstaben ergeben jedoch &quot;Motorerad&quot;. Ich weiß leider nicht wie das zu korrigieren ist. [[Spezial:Beiträge/~2026-55371-50|~2026-55371-50]] ([[Benutzer Diskussion:~2026-55371-50|Diskussion]]) 21:47, 16. Okt. 2026 (CEST)</text>
      <sha1>7vacujh4gbc81n15m2grlhlm64hixm4</sha1>
    </revision>
  </page>
</mediawiki>