Einsteigerkochbuch

Zurück zur Hauptseite

zum Python - Lexikon

Vorbemerkungen

Auf dieser Seite werden kurze Funktionen zusammengestellt, die in Modulen ihre Arbeit tun und wiederverwendungsfähig sind und sich besonders dadurch auszeichnen, dass sie irgendetwas pythonspezifisches verwenden, das in anderen Programmiersprachen so nicht gehen würde. Teilweise sind diese Beispiele mir mal irgenwann/irgendwo positiv aufgefallen, teilweise stammen sie aus Hinweisen anderer Python-Fans. Die Sammlung wird anfangs klein sein, also bitte ich die Enttäuschung zu unterdrücken. Aber in der Hoffnung, dass die Sammlung wächst und wächst und wächst ... :-)

Da es auf dem Büchermarkt noch kein Buch gibt mit dem Titel "Algorithmen für Python", und schon gar kein deutschsprachiges, soll diese Sammlung dem Neuling helfen, sich schneller in die wahnsinnig umfangreichen Lösungsmöglichkeiten hineinzufinden.

Um dem breiten Grinsen der alten Python-Insider vorzubeugen, diese Seite ist für Einsteiger gedacht. Speziell Umsteiger von anderen Sprachen finden hier die Dinge, an die man sich erst gewöhnen muß, mit denen man nicht rechnet, weil man es doch viele Jahre ganz anders gemacht hat. Nur ein kleines selbsterlebtes Beispiel. Als ich das erste mal in einem String ein einzelnes Zeichen ändern wollte, schrieb ich mir folgende mid() - Funktion, die auch ihre Arbeit machte:

# in einem String das Zeichen an der i-ten Position überschreiben
def mid(urstring, position, neuzeichen):
    neustring = ''
    for i in range(0, position):
        neustring = neustring + urstring[i]
    neustring = neustring + neuzeichen
    for i in range(position + 1, len(urstring)):
        neustring = neustring + urstring[i]
    return neustring

s = 'Das @ steht an der Position 4'
print mid(s, 4, '*')

# Antwort: Das * steht an der Position 4

Später fand ich in irgend einem Beispielprogramm dann eine Schreibweise, die nichts weiter machte, als eben die Python - Eigenschaften zu nutzen und reichlich eleganter war:

def mid(s, pos, ch):
    temp1 = s[:pos]
    temp2 = s[pos+1:]
    return temp1 + ch + temp2

s = 'Das @ steht an der Position 4'
print mid(s, 4, '*')
# Antwort: Das * steht an der Position 4

Noch später fand ich eine Möglichkeit, eine eigene Stringklasse so zu formulieren, die mit Index angesprochen werden kann, so dass veränderliche Strings herauskommen. So wird sichtbar, dass Python immer wieder neue kleine Entdeckungen zuläßt, je länger man sich mit der Sprache beschäftigt. Da diese "Überraschungen" bei Python überwiegend positiv sind, schätze ich Python immer mehr!
 

Sammlung der Funktionsbeispiele

• mathematische Funktionen
  • Primzahlen
  • Fakultät
  • Vergleich, ob x in einem bestimmten Intervall liegt

• Umgang mit Variablen, Strings, Listen und Dictionarys
  • Inkrementieren einer Zahl
  • Vertauschen zweier Variabler
  • Splitten eines Tupels
  • Umwandeln von String oder Tupel in eine Liste
  • Verkettungen von Zeichen, String, Tupel und Liste
  • von einem String n Zeichen von links hernehmen
  • in einem String das Zeichen an der i-ten Position überschreiben
  • einen String herstellen, der aus n gleichen Zeichen besteht
  • Liste Sortieren
  • Liste umgekehrt ordnen
  • Wiederfinden
  • Kopieren
  • Eine Liste mit n Leerzeichen herstellen (Vergleichbar einem char - array)

• Besonderheiten bei Funktionen
  
  • Eine Funktion soll sich ihre Vorgeschichte merken
    
    
    
    
• Umgang mit Dateien
• prüfen, ob ein File existiert
  
  

• Zusammenarbeit mit dem Betriebssystem
• Anderes Programm aus einem Pythonscript heraus aufrufen

• Portierungsprobleme
  • Umlaute
  • Zeilenendekennzeichen

• Shell für den Textmodus
  • mit einzelnen Kommandos
  • mit einer Kommandoverwaltung im Dictionary

def primzahl(anfang, ende):
    """ in werte werden als Liste alle durch das Programm selbst gefundenen
    Primzahlen ab 2 gesammelt, die dann für die Prüfung der nachfolgenden
    höheren Zahlen gebraucht werden. Ausgedruckt hingegen wird nur
    der geforderte Wertebereich """
    if anfang < 3: print 2,
    werte = [2]
    i = 3
    while i <= ende:
        for p in werte:
            if  i  %  p == 0 or p * p > i: break
            # es reicht, nur die Werte bis sqrt(i) zu prüfen
        if i % p <> 0:
            werte.append(i)
            if  i >= anfang: print i,
        i = i + 2
        # die Sprungweite ist 2, weil die geraden Zahlen entfallen

primzahl(13, 23)

13 17 19 23

# Fakultätsfunktion (nichtrekursiv)

def fakul1(n):
    a, b = 1, 1
    while b <= n:
        a, b = a * b, b + 1
    return a
 

# Fakultätsfunktion mit Anwendung der Rekursion

def fakul2(n):
    if n == 1: return 1
    else: return n * fakul2(n - 1)

print fakul1(4)
print fakul2(4)

24
24

Anmerkungen:

Offensichtlich ist die rekursive Darstellung kürzer. Sie schein auch eleganter, was wohl auch geschmackssache sein dürfte. Aber solche Probleme, bei denen sich eine rekursive Vorgehensweise anbietet, wie z.B. bei der Fakultätsberechnung, lassen sich auch in anderer Schreibweise nicht rekursiv lösen.

Vergleich, ob x in einem bestimmten Intervall liegt

Will man so etwas in Pascal machen, benötigt man solche Konstrukte:

if  3 < x then
    if x < 5 then
        writeln(x, 'trifft zu');

oder if (3 < x) and (x < 5) then ...

In Python geht das mehr so, wie es in der Mathematik auch gemacht wird. Beispiel:

def view(x):
    if 3 < x < 5:
       return 1 == 1 # Rückgabewert true/wahr
    else:
       return 1 == 2 # Rückgabewert false/falsch

for i in range(0,6):
    if view(i): print I, 'trifft zu'

Das bringt dann als Resultat:

4 trifft zu

Umgang mit Variablen, Strings, Listen und Dictionarys

Inkrementieren einer Zahl

Seit der Version 2.x gibt es nun auch eine Kurzschreibweise für das Inkrementieren

Langform: a = a + 1

Kurzform: a += 1

Diese kombinierten Operatoren gehen übrigens auch in anderen Varianten, z.B.

a -= 1 # zum dekrementieren

a **= 2 # zum Potenzieren

'hallo' += '!' # also auch mit Strings, na prima!

also insgesamt schon eine schöne Hilfe, besonders zur Freude der bsiherigen C - Programmierer.

    a = 1
    b = 2
    a, b = b, a
    print a, b
    # Antwort:  2    1

a, b, c = (100, 200, 300)
print a, b, c
# Antwort: 100    200    300

a = 'Hallo'
b = (100, 200, 300)
c = list(a)
d = list(b)
print c, d
# Antwort: ['H', 'a', 'l', 'l', 'o']   [100, 200, 300]

# Zeichen = String aus 1 Zeichen
c1 = 'a'
c2 = 'b'

# Strings
s1 = 'Hallo'
s2 = 'Welt'

# Tupels
t1 = (100, 200)
t2 = ('p', 'q')

# Listen
l1 = [100, 200]
l2 = ['r', 's']

# Verkettung von gleichen Typen
print c1 + c2
print s1 + s2
print t1 + t2
print l1 + l2

# Verkettung verschiedener Typen
print c1 + s1
# print c1 + t1 (geht so nicht)
print (c1,) + t1
# print c1 + l1 (geht so nicht)
print [c1,] + l1
# print s1 + t1 (geht so nicht)
print (s1,) + t1
# print s1 + l1 (geht so nicht)
print [s1,] + l1
# print l1 + s1 (geht so nicht)
l1.append(s1)
print l1
# print t1 + l1 (geht so nicht)
print [t1,] + l1 # fügt t1 als ein Element ein!
print list(t1) + l1

a = '1234567'
b = a[:3]
print b
# Antwort: 123

pythonuntypisch, wenn auch auch funktionstüchtig wäre:

def zeile(ch, n):
    z = ''
    for i in range(1, n+1):
        z = z + ch
    return z

Nicht jeder Umsteiger denkt nämlich daran, dass es unter Python ja so geht:

def zeile(ch, n):
    return n * ch

Dieses Beispiel steht in den Vorbemerkungen, wo es als Beispiel für das Ziel dieser Sammlung dienen soll. :-)

# Liste Sortieren, Liste umgekehrt ordnen

Nichts einfacher als das:

a = ['paul', 'artur', 'beate', 'rudi']
a.sort()
print a
a.reverse()
print a

das bringt folgende Ausgabe:

['artur', 'beate', 'paul', 'rudi']

['rudi', 'paul', 'beate', 'artur']

a = 20 *[' '])  # aha, hier geht es also auch mit dem * - Operator!!

print a

[' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ']

Anmerkung:

Das hier geschaffene Gebilde ist nun wie üblich ansprechbar wie ein array:

a[5] = 'X'
print a

[' ', ' ', ' ', ' ', ' ', 'X', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ']

# Funktion merkt sich eine Vorgeschichte

def fu(summand):
    fu.summe += summand

# einmalig setzen des Anfangswertes, sonst ist dieser nicht definiert!
fu.summe = 0

fu(31)
fu(87)
fu(12)
fu(5)
print fu.summe

Wer versucht, ein nichtexistierendes File zum lesen zu öffnen, erntet eine Fehlermeldung. Daher prüft man vorher. Das macht man mit der Funktion isfile(suchname),die im Modul os steckt. Hier ein kleines Beispiel zum probieren:

# prüfen, ob ein bestimmtes File existiert

import os

def fileexists(suchname):
  print suchname,
  if os.path.isfile(suchname):
    print "vorhanden"
else:
    print "nicht vorhanden"

fileexists('file.py')

Abhängig davon, ob beispielsweise das File 'file.py' auf Eurem Rechner im aktuellen Pfad steht, kommt die passende Antwort. Achtung: Das File kann auch mit Pfadangaben hinterfragt werden. Auf Windows-Rechnern ist dazu der '\' entsprechend mit einem vorangesetzten weiteren '\' zu maskieren oder ein Raw-String (Rohstring) zu übergeben. Das geht dann so:

fileexists('c:\\autoexec.bat')

oder

fileexists(r'c:\autoexec.bat')

Shell für den Textmodus mit einzelnen Kommandos

Ein anschauliches Beispiel für eine solche einfache Lösung, die zwar ohne Grafik auskommt, dafür aber unkompliziert ist, kann anhand des praktischen Beispiels nachvollzogen werden, das ich im Einsteigerkurs beschreibe. Das Listing einer solchen Shell ist hier zu sehen, wobei hier die Funktion shell() insbesondere gemeint ist. Es handelt sich um eine While - Schleife ohne Abbruchbedingung. Damit trotzdem das Programm mal beendet werden kann, gibt es nach Eingabe des Zeichens "q" für quit einen break - Befehl, der die Schleife zwangsweise verläßt.