Seit Jahrzehnten beschäftigen wir uns mit Programmierung. Ebenso unterrichten wir seit Jahrzehnten darin. Was wir gelernt haben: Man lernt Programmierung nicht mal nebenbei oder in wenigen Tagen. Es hört nie auf, daß man nicht mehr lernen muß. Es ist ein Prozess, der viel Zeit braucht, bis man professionelle Entwicklungen realisieren kann.

Bspw.: Schon bei einfachen Anwendungen, wie einem Taschenrechner, der wunderbar funktioniert. Dahinter stecken viele, viele.... viele Stunden/Tage (hier zumindest: Monate weniger) Arbeit drin.

Python gehört mittlerweile zu einer der beliebtesten Programmiersprachen im Anfängerbereich. Ebenso können wir hiermit auch professionelle Programme schreiben. Dies wird stark an Schulen und Universitäten eingesetzt, wie auch in der Industrie. Daher entspricht dies nicht ganz richtig, daß es eine leichte Programmiersprache ist. Denn man muss lernen, was es heißt zu programmieren?

Python weist viel mehr Strukturen auf, die es einem Anfänger erleichtern, einen Einstieg in die Programmierwelt zu finden.
- Wie fange ich denn jetzt überhaupt mit Python an?
- Womit starte ich?
- Wieso benötigt man für das Programmieren immer noch eine Konsole?
- Wie bekomme ich überhaupt eine Zeile Code zum Ausführen?
- usw.

Auf den folgenden Seiten lernen wir die Programmierung kennen. Dazu nutzen wir hier explizit Python.

- Wir lernen den Einstieg mit Python.
- Wir lernen anschließend Aufbauwissen mit Python.
- Welche unterschiedlichen Programmierparadigmen gibt es und warum gibt es Unterschiede?
- Wir lernen anschließend den Einsatz in die Profiwelt mit Python.
- Als Abschluß lernen wir, warum Python für KI so beliebt ist und wie wir hiermit KI Entwicklungen realisieren.

Anschließend braucht man das hier nicht mehr, man nutzt es als Profi nur noch als Referenz!
Typische Anwendungen eines Profis:
- Wie genau hieß nochmal die Methode?
- Wie genau funktionierte die Methode und die zugehörigen Parameter?
- Ach ja, da war doch irgendwas mit std::out | std::in | std::err | stacktrace ?!| buffer ?!| streams ? oder steam ( .funkion1...) ?!,, uvm...?

---

Auszug: Funktionale Programmierung

>>> from pyxtension.streams import stream

def func_aussen(func):
     def func_innen(*args):
        if (len(args)) >= func.__code__.co_argcount:
               if args[-1] == "L":
                   return ((stream(args).filter(lambda _: _ != '')).flatMap().toList())
               elif args[-1] == "R":
                  return list(func(*args[:-1][::-1] + tuple(args[-1])))
              else:
                   return func(*args[:func.__code__.co_argcount])
        else:
               return lambda *neu_args: func_innen(*(args + neu_args))
     return func_innen

@func_aussen
def ausgabe_console(W1, W2, W3, W4, W5):
    _ = ' '.join(map(str, [W1,W2,W3,W4])) if W5=='N' else W1+W2+W3+W4
    return _

ausgabe = ausgabe_console("Hallo")("Welt")("in")("Python")
print (f"{list(reversed(ausgabe("R")))=}")
print (f"{ausgabe('L')[:-1]=}")
print (f"{ausgabe('N')=}")

Mit FlatMap & Argument 'L' # =
ausgabe=['H', 'a', 'l', 'l', 'o', 'W', 'e', 'l', 't', 'i', 'n', 'P', 'y', 't', 'h', 'o', 'n']

Mit Argument 'R' #
ausgabe=['o', 'l', 'l', 'a', 'H', 't', 'l', 'e', 'W', 'n', 'i', 'n', 'o', 'h', 't', 'y', 'P']

Mit Argument 'L' #
ausgabe=['Hallo ', 'Welt ', 'in ', 'Python ']

Mit Argument 'N' #
ausgabe=Hallo Welt in Python

Hier greifen viele Elemente der Programmierkunst ineinander. Man sieht sofort die Schönheit, die Klarheit, die Übersichtlichkeit, die Eleganz und die Effizienz der Codierung.

Das Beispiel macht für den realen Einsatz nicht viel Sinn, schließlich tätigen wir nur eine Ausgabe auf der Konsole. Das Besondere liegt hier darin, wie wir die Ausgabe realisieren, dass ist das Wesentliche von Funktionaler Programmierung. Es ist aber nicht weit von realer Programmierung entfernt. Es lässt sich ohne weiteres adaptieren. Des Weiteren wirkt es kompliziert, denn eine Ausgabe von 'Hello Welt in Python' lässt sich natürlich wesentlich einfacher gestalten. Aber, sobald die Komplexität in unserem Quellcode steigt, wird man diesen entscheidenden Vorteil erkennen. Es soll an diesem Beispiel nur die Grundlagen der Funktionalen Programmierung erklärt werden.

Als Lernbeispiel hier prädestiniert. Man kann mit der Programmierkunst jonglieren, wenn man diese Programmierwelt verstehen kann. Dieser Code ist zudem robust, sicher, einfach, lesbarer. Bei iterativem Stil bräuchte man grob mehr als 100 Zeilen, um dies nachzubauen, wodurch all die Schönheit und die weiteren, viele Vorteile der Programmierkunst verloren gehen. Essentiell entstehen dann auch wieder Seiteneffekte, die bei Funktionaler Programmierung vermieden werden, durch referentielle transparente Funktionen oder durch generische Programmierung. Dieses Beispiel an Quellcode links ist frei von jeglicher Programmiersprache. Es ist ein Konstrukt, eine Architektur, genau genommen ein Paradigma: Wie man mit einer Programmiersprache (hier Python) dies realisieren kann.

Es ist so wundervoll dynamisch, man könnte dies mit wenigen Befehlen, minimale Umstrukturierungen noch schöner, noch dynamischer... gestalten...

Die ausführlichen Erklärungen und wie es gemeint und zu verstehen ist folgen in Kapitel IV...

---

Auszug: KI - Entwicklung eines neuronalen Netzes

Objektorientierte Programmierung

Hier können Sie das trainierte, neuronale KI-Netz herunterladen und selbst testen:

Click to Download

Inhalt der Datei: 1x M_E_V.txt = Trainiertes Eingangsnetz der KI

1x M_V_A.txt = Trainiertes Ausgangsnetz der KI

1x Python-Script: Deployment - Abfrage des trainierten neuronalem KI-Netz

1x Python-Script: Zur Erzeugung eigener Bilder u. / o. zur Erzeugung von weiteren Testdatensätzen durch Rotationsverfahren für die Optimierung der KI

1x Testdaten der MNIST-Datenbank als .CSV-Datei mit 10.000 Datensätzen. Beachte: Numerische Werte. Erstes Element stellt das Identifikationselement dar und alle weiteren Elemente repräsentieren das Bild.

>>> import matplotlib.pyplot as plt
from matplotlib import cm
import scipy.special
import numpy as np

class Manuelle_KI_Berechnungen:
  def __init__(self, d1, d2):
     self.e_v, self.v_a = np.loadtxt(d1, dtype=np.float64), np.loadtxt(d2)
     self.aktivierungf = lambda _ : scipy.special.expit(_)

  def abfrage_KI(self, _):
     _ = self.aktivierungf(self.e_v @ np.array(_, ndmin=2).T)
     return self.aktivierungf(self.v_a @ _)

_ = np.array(numeric[_].split(',')[1:], dtype=np.float64)
plt.imshow(_.reshape(28,28), cmap=cm.PuBu_r, interpolation=None)
plt.show() # Das zu erkennende Bild sichtbar machen

o = Manuelle_KI_Berechnungen("M_E_V.txt", "M_V_A.txt")
_ = o.abfrage_KI((_.ravel(order='C') / 255.0 * 0.99) + 0.01)
print (f'{np.argmax(_)=}') # Das Ergebnis der KI

Hier haben wir ein Beispiel für ein neuronales Netz (KI) entwickelt. Auf Basis mit Python und auf unterster Ebene der Programmierung wird das lernende neuronale Netz programmiert, dass in der Lage ist, stets 10 verschiedene, bestimmte Zeichen auf Bildern zu identifizieren!
Heute gilt dies als ein Einsteigermodell für die Entwicklung von neuronalen Netzen, ohne die Nutzung von fertigen Bibliotheken! Denn durch die Nutzung solcher Bibliotheken erkennt der Mensch nicht mehr was genau hier im Hintergrund passiert! Anhand dieses Beispiels, ohne fertige Bibliotheken, stellen wir fest, dass es im Grunde genommen, trivial ist und ermöglicht uns die absolute Kontrolle über die KI zu bewahren. Dies ist essentiell bei KI-Entwicklungen oder bei anderen Programmier-Entwicklungen! Das macht den Informatiker (Programmierer) aus! Dieser beherrscht das System und nicht umgekehrt! Leider ist dies, in der Realität, nicht immer der Fall. Die hier gelittenen Anforderungen eines Informatik-Studiums entsprechend nicht die eines Medizin-Studiums. So begegnet man immer wieder: Verwendung von fertigen Modulen, verstehen aber nicht, wie es funktioniert. Man kann Werte bei diesen Modulen setzen und irgendwas passiert da! Nachteil: Wie soll man dann überhaupt Optimierungen vornehmen oder gar Fehler beseitigen?

Wahre Geschichten:
Viele Antworten mir: Ich schiebe den gesamten Code zu ChatGPT & Co. und wenn ich Glück habe, kommt da was Sinnvolles raus! Keine Ahnung, aber ich glaube es! Und so lange es so funktioniert... irgendwie...
Mein Kommentar: Ich lasse es so stehen! Ohne Worte...

Wie wir die Klassifizierungsrate der Kombinationen von KI-Techniken von de facto 100% erreichen, lernen wir im übernächsten Kapitel. (U.a. Kombinationen mit CNN, mit Bäumen, mit Wäldern, mit Auto-Encodern... erweitern wir die KNN).
Solche Kombinationen der KI-Techniken werden u.a. beim autonomen Fahren eingesetzt! KNN alleine schaffen 98% bei der MNIST-DB! Die Kombination von KNN & CNN erzielen eine Klassifizierungsrate von bis zu 99,7 %! Jetzt fehlen noch 0,3% um die 100% zu erreichen.
Kommen wir zum aktuellen Beispiel zurück: Anhand diesem Beispiel erlernen wir alles, von Null an, was man für die Entwicklung von KIs braucht und worauf man alles achten muss: Anzahl der Knoten und der inneren Schichten. Normalisierung der Daten. Welche Aktivierungsfunktion? Welche Verlustfunktion? Definieren eines Bias-Wert? Achtung: Mehrfachdeutung des Begriffs BIAS: [1. Datenverzerrung bei Korrelation vs. Kausalität | 2. KI-Optimierungsparameter bei KNN...]. Die Gewichts-Einteilung ist von absoluter Relevanz und abhängig von der eingesetzten Aktivierungsfunktion. Bestimmung der Lernrate und Epochenanzahl, uvm...
Die ausführlichen Erklärungen und wie es gemeint und zu verstehen ist folgen in Kapitel IV...
Damit man es besser verstehen mag. Wir programmieren seit Jahrzehnten in mehreren Programmiersprachen. Je nach Wunsch des Auftragsgebers und nach Eignung:
Welche Programmiersprache eignet sich am Effizientesten! Auch in Betracht bezogen auf die genutzte IT-Hardware. Nur, weil man von Python gehört hat, muss es nicht die Vorteilhafteste Programmiersprache sein. Auch, daß sind Gedanken, die sich ein Entwickler machen muss. Ist es notwendig, eine Programmiersprache einzusetzen, wo man die IT-Architektur anpassen muss? NEIN!

In C++, dann PHP, dann REACT, mal in C, mal in VBA ... und auch wir stoßen an Grenzen, um diese aufzubrechen, müssen wir viel Zeit investieren, von denen der Auftraggeber nichts mitbekommt und wenig Interesse hat.

Ein sehr wichtiger Punkt, der nicht zu verachten ist, denn wir beschrieben es einmal, daß wir Kunst mit der Programmiersprache realisieren, aber ähnlich wie ein Künstler hierzulande am Ende auch von was Leben müssen: Scheiden sich die (Frei)-Geister.
Man kann einem Künstler nicht sagen: Male das Bild bitte immer von Mo. - Fr. von Punkt 8 Uhr morgens bis 17 Uhr, zwischendurch eine Stunde Pause und dann Feierabend.

---

An Albert Camus: ”Hör auf an Deinem Werk zu schreiben!” -Die Pest- oder -Der Mythos des Sisyphos-
”Es ist ... Feierabend...” - ”...Meeting...!” - ”...Besprechung...!” - ”...Jahresgespräch...!” - ”...Mitarbeitergespräch...!” - ”...Bürokratiezeit...!” - ”...Berichte schreiben...!” - ”...Videokonferenz...!” ” - Der Nobelpreis kann warten.”

So funktioniert Programmierung nicht! Auch, daß sind Gedanken, die eher sich die Verantwortlichen hinter die Ohren schreiben müssen.
Was ist einer der Folgen: Das hierzulande auch in der heutigen Zeit, aktueller als jemals zuvor, die meiste Software aus dem Ausland kommt und viele geborene Genies sich anderen Aufgaben widmen, als der Programmierung, obwohl ein Talent in Ihnen schlummerte! Aber, dies betrifft viele der MINT-Fächer...
Ein Gedanke, an denen man arbeiten und entsprechend die Strukturen schaffen muss.

Um das Paradoxe mal aufzuzeigen:
Was wir in den Jahrzehnten erlebt haben, immer wieder, waren rießige Aufträge von großen Auftraggebern, an die auch wir nicht rankamen. Oder manchmal nur über Dritte, ohne das Wissen des Auftragsgebers. Oder man hatte das Personal im Haus, stattdessen zahlte man Millionen, wenn nicht gar Milliarden von Geldern an Firmen im Ausland, nur damit die eigenen Mitarbeiter keinen Vorteil erhielten!

Um dies klarzustellen, es existiert keine Programmiersprache oder Mathematik auf diesem Planeten, dessen Menschen hierzulande nicht auch auf wissentschaftlichen höchstem Niveau mit arbeiten. Wir sind froh, daß wir hier und da, dann doch Menschen, Firmen, öffentliche Einrichtungen begegneten, die unsere Kunst zu schätzen wissen und am Ende als kleines Rädchen im Getriebe der Großen viel Bewegung brachten, wo die großen Auftraggeber bis heute nur staunen und sich immer noch fragen, wie ist das nur möglich gewesen...!

Wir berichten darüber, damit die Erwartungshaltung realisistischer eingeordnet wird. Auch, wenn Sie am Ende begnadet Programmieren können oder eine geniale Mathematikerin werden. Kann es sein, daß Sie keine Möglichkeit finden werden, diese Kunst der Menschheit hierzulande weiterzugeben. Wegen dem ^paradoxem Verhalten von einigen Menschen hierzulande.

Wir haben so viele geniale Programmierer hier kennen gelernt, aber kaum einer hatte langfristig Freude hier zu programmieren...
Wenn man dann hört. "Wir wollen Weltspitze werden und investieren Milliarden!"
Irgendwie passt es mit der Realität nicht zusammen!

Wie war das nochmals mit Short-Hand in C++?

Wie war denn nochmal die Ausgabe auf der Konsole:

---

Usw... ff... pp... etc...

Komplexer und Schwieriger wird es bei Anwendungen, wie u.a. Short-Hand oder bei Methodeneinsatz: Hat Python auch Funktionsverkettung, wie in RUST? Normalerweise NEiN! Aber dann doch JA! Wie hieß die Methode nochmals für die Funktionsverkettung in Python: Referenz: stream(...)

Das ist typisch Mensch, man hat nicht immer alles parat vor Augen und sobald man bspw. ein Projekt in C++ fertig hat. Der nächste Kunde aber den Wunsch äußert: ”Mein Projekt bitte in Python!” Dann müssen wir immer wieder nachschauen.

Damit man ein Bild davon hat:
Man war monatelang so vertieft in der C++-Welt eingestiegen, um das Projekt fertig zu stellen und abzuschließen, daher spricht man auch vom - Tunneleffekt: Wo Raum und Zeit für den Programmierer nicht mehr existieren, bis der menschliche Körper sich wieder bemerkbar macht. ”Hey, wir müssen was Essen...und Schlafen...!”
Es ist wie bei den Pianisten: Man hört es, daß man im Flow ist, wenn es einmal läuft...

Anschließend, wenn ein völlig anderes Projekt startet und hier der Wunsch geäußert wird, es in Java zu implementieren, dann müssen wir wieder quasi von vorne starten. Dazu dient auch diese Seite hier:
Als Referenz.

Zu jedem Kapitel haben wir bewusst auf interaktive Elemente gesetzt:

- Zu jedem Kapitel finden Sie zahlreiche Beispiele.
- Umfangreiche Übungen und Aufgaben zu jedem Kapitel.
- Dynamische Quizfragen in jedem Kapitel.
- Von einfachen bis hin zu komplexen Beispielen erlernen Sie hier die Materie.
- Im Laufe der Zeit entwickeln wir hier konkret umfangreiche Software. Damit Sie auch lernen, wie Python professionell eingesetzt wird.
- Direkt und Live programmieren.
- Hier ist für jeden was dabei...

Auch, wenn Sie jetzt hier nicht alles verstehen oder weniger, dann sind Sie genau richtig hier.
Damit das Ganze auch fruchtet, setzen wir Eins voraus:

Bringen Sie Zeit mit, sehr viel Zeit mit...und als Rat geben wir immer wieder mit: ”Lernen und Wiederholen!”

Fangen wir mit Python an:

---

Mehr von Python... ?

Area Log-In | Python-Entwicklung