Grundlagen

Python ist eine objektorientierte Skriptsprache.
Sie wurde von Guido van Rossum Anfang der 90er entwickelt, der sie nach der englischen Comedyreihe Monty Python's Flying Circus benannt hat.

Grundkonzepte

objektorientiert
- alles ist ein Objekt
portabel
- auf jeder Plattform verfügbar, insbesondere unter den Unix Systemen, Linux, Windows und Mac
mächtig
- dynamische Typisierung
- automatische Speicherverwaltung (garbage collection)
- Unterstützung komplexer Systeme durch Packages, Module, Klassen und Exceptions
- mächtige Operationen auf den built-in Datentypen wie Listen, Dictionaries und Strings
- reichhaltige Bibliothek
kommunikativ
- gute Python-C Bindung (ctypes Modul)
- Python Implementierung in
  - C: CPython
  - java: Jython
  - C#: IronPython
  - python: PyPy
einfach zu nutzen
- unterstützt gut den try and error Ansatz Prototyping
- kurzer Weg bis zum ersten Programm
einfach zu erlernen
- Syntax an C angelehnt
- folgt dem Prinzip der kleinsten Überraschung
- unterstützt Introspektion sehr gut

Programmausführung

Mehrere Wege bieten sich an, Python Code auszuführen.

Command String

grimm@ackbar ~ $ python -c "print 3.0/3.1"

0.967741935484

Interaktiver Prompt für den try and error Ansatz

grimm@sirrah uml $ python
Python 2.3.3 (#2, Feb 16 2004, 10:50:52)

[GCC 3.3.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.

>>>

System Command

python test.py

als Applikation, durch den Aufruf des Pythoninterpreters #!/usr/bin/env python in TestProgramm

grimm@sirrah TestProgramm

Syntax

ein paar einfache Syntaxmerkmale von Python

>>> import sys
>>> if 1 :
...     a="eins"

...     print a # ein
...     print 3+4\
... -5    

...     print sys.path

Unterstrukturen werden durch
- : eingeleitet
- Einrückung ausgezeichnet
# erklärt alles rechts davon zum Kommentar
; ist am Ende eines Ausdrucks nicht notwendig
Variablen werden impliziert definiert
\ leiten Fortsetzungszeilen ein
import lädt Dateien (Module) oder Verzeichnisse (Pakete); diese werden über den Modulnamen referenziert

Erste Schritte

Interaktiver Prompt

nach Aufruf von python öffnet sich eine Interaktive Python Shell
Zahlen

ein bißchen Arithmetik

2+2
3/2
3.0/2
1j*1j
a=(1j*1j)

a.real
a.imag

Strings

werden durch doppelte (") oder einfache (') Anführungszeichen definiert

s1="0123456"
s2='0123456'
print s1, s2

erlauben eine einfache Arithmetik

s1+s2
3*s1

Zeichen escapen

test="escape\"me"

über mehrere Zeilen

a="1234\
567"
b="""1234

567"""

raw String

c="1234\

567"
cRaw=r"1234\
567"

Indexzugriff
- das erste Element besitzt den Index 0
- negative Indizes werden von hinten her ermittelt
  - a[-n] ist das nt letzte Zeichen

a="0123456789"

a[0] 
a[len(a)-1]
a[-1] # das letzte Zeichen

a[-3] # das drittletzte Zeichen

Strings sind immutable; d.h.: sie können nicht mehr verändert werden
die Indexgrenzen werden überprüft

a[3]=5 
a[len(a)]

Scheibchenweise (slices) Strings
- string[i:j] ergibt einen neuen String einschließlich dem Anfangsindex i und ausschließlich dem Endindex j

MyString="0123456789"
MyString[1:2]
MyString[:2]

MyString[1:]
MyString[:]
MyString[-1000:10000]

für fehlende Grenzwerte wird 0 bzw sys.maxint eingesetzt, so wird MyString[:] als MyString[0:sys.maxint] interpretiert
das slicen von Objekten kann auf alle sequentiellen Datentypen angewandt werden

lasse durch einen beliebigen String ein -Zeichen durchlaufen

mittels

for i in range(len(MyString)):

  print i

erhälst du die Indizes
Listen

Listen sind im Gegensatz zu Strings veränderbar (mutable), ihnen kann daher ein neuer Wert zugewiesen werden

a = ['spam', 'eggs', 100, 1234]

a[-2] 
a[0:2] = [1, 12]

a[0:2] = []
a[1:1] = ['bletch', 'xyzzy']

a[1:2] = ['bb', 'cc']
q = [2, 3]

p = [1, q, 4]
p[1][0]

Beispiele

Die Funktionen werden durch

import sys
sys.path.append("/home/grimm/schulung/Python/Beispiele")

import grundlagen

geladen

Die built-in Funktion dir


dir (grundlagen)

gibt einen Überlick über das Modul.

Wo liegen die Grenzen von n Fakultät ?

def fakRange(scope):
    result=1
    for i in range(1,scope+1):

        result *= i
    print result

Alle nichttrivialen Teiler

Bestimme alle nichttrivialen Teiler von start bis end.

 
def teiler(start,end):                                                    
    print [(n,"teiler: " +str( [ i for i in range (2, int(2,int(n/2)+1     ) if n%i == 0 ])) for n in range( start,end+1)]

Fakultät.

Bestimme alle Fakultäten von start bis end.

 def fakultaet(start,end):

    print [ (n,"Fak= " + str (reduce(( lambda x,y: x*y),[ i for i in range(1,n+1)  ] ) ) ) for n in range( start,end+1)]

Quicksort

def qsort(L):
    if len(L) <= 1: return L

    return qsort([lt for lt in L[1:] if lt <  L[0] ] ) + L[0:1] + qsort([ge for ge in L[1:] if ge >= L[0]])

Zähle das Vorkommen jedes Wortes

import re
re_word= re.compile(r"(\w+)")

def wordCount(s):
    allParts= re_word.split(s)

    wordDict= {}
    for word in allParts[1::2]:

        wordDict[word]=  wordDict.setdefault(word,0) + 1

    return wordDict

Filtere einen String

def makefilter(keep):

    """ Return a function that takes a string and returns a new string, 
        consisting only of the characters from the old string in 'keep'.
    """
    import string
    # make a string of all chars, and one of all those NOT in 'keep'
    allchars = string.maketrans('', '')

    delchars = ''.join([c for c in allchars if c not in keep])

    # return the function
    return lambda s,a=allchars,d=delchars: s.translate(a, d)