Einleitung

Python ist eine Programmiersprache. Im Vergleich mit die Programmiersprache C++ und Java ist die deutlich kürzer.

Zum Beispiel, das „Hello Welt“ Programm Links das Programm in die Programmiersprache C, rechts in Python:

Python Programming Bootcamp: Go from zero to hero

Python herunterladen? Python funktioniert auf viele Systeme so wie: Apple Mac OS X, Microsoft Windows, Linux/UNIX und Handy: Google Android und Apple iOS. Du kannst Python herunterladen von Python.org

Wenn du mehr Information über der Python Installation benutzt kannst du auf die englische Seite schauen.

Datentypen und Variablen

Strings

Lists

Eine Liste ist einer Sammlung. Liste können Zahlen, Strings (Zeichenkette) oder beides besitzen.

Beispiel
Zum beispiel:

l = [ "Drake", "Derp", "Derek", "Dominique" ]
 
print(l)     # prints all elements
print(l[0])  # print first element
print(l[1])  # prints second element

Resultat:

['Drake', 'Derp', 'Derek', 'Dominique']
Drake
Derp

Python Programming Bootcamp: Go from zero to hero

Hinzufügen und entfernen

Du kannst der Methode append() und remove() benutzen für List bearbeitung.

#!/usr/bin/python
 
l = [ "Drake", "Derp", "Derek", "Dominique" ]
 
print l                # prints all elements
l.append("Victoria")   # add element.
print(l)                # print all elements
l.remove("Derp")       # remove element.
l.remove("Drake")      # remove element.
print(l)                # print all elements.

Resultat:

['Drake', 'Derp', 'Derek', 'Dominique']
['Drake', 'Derp', 'Derek', 'Dominique', 'Victoria']
['Derek', 'Dominique', 'Victoria']

Sortieren
Mit dem sort() Funktion kannst du einer List sortieren.

#!/usr/bin/python
 
l = [ "Drake", "Derp", "Derek", "Dominique" ]
 
print(l)     # prints all elements
l.sort()    # sorts the list in alphabetical order
print(l)     # prints all elements

Wenn du das umkehren mochtest kannst du die reverse() Funktion benutzen.

#!/usr/bin/python
 
l = [ "Drake", "Derp", "Derek", "Dominique" ]
 
print(l)     # prints all elements
l.sort()    # sorts the list in alphabetical order
l.reverse() # reverse order.
print(l)     # prints all elements

python tuple

Das Tupel Datenstruktur wird verwendet, um eine Gruppe von Daten zu speichern.

Die Elemente in dieser Gruppe werden durch Komma getrennt. Einmal erstellt, ändern sich die Werte eines Tupels nicht.

Python Programming Bootcamp: Go from zero to hero

Beispiel
Ein leeres Tupel in Python würde definiert als:

tuple = ()

Ein Komma ist benötigt für ein Tupel mit nur einen Wert:

tuple = (3,)

Für mehrere Werte, müssen Sie kein Komma am Ende setzen. Dieser Tupel ist ein Beispiel:

personInfo = ("Diana", 32, "New York")

Die Daten in einem Tupel können aus einem oder mehreren Datentypen bestehen.

#!/usr/bin/env python 
 
personInfo = ("Diana", 32, "New York")
print(personInfo[0])
print(personInfo[1])

und

#!/usr/bin/env python
 
name,age,country,career = ('Diana',32,'Canada','CompSci')
print(country)

Hinzufügen
Wenn sie an einem Tupel werte hinzufügen möchtest kannst du der plus (+) Operator benutzen.

x = (3,4,5,6)
x = x + (1,2,3)
print(x)

Konvertieren
Konvertieren von einem Tupel zum einer List.

listNumbers = [6,3,7,4]
x = tuple(listNumbers)
print(x)

Konvertieren von einem List zum einer Tupel:

x = (4,5)       
listNumbers = list(x)  
print(listNumbers)

Konvertieren vom einem List zum einer String:

person = ('Diana','Canada','CompSci')
s = ' '.join(person) 
print(s)

Sortieren
Tupels sind kein Arrays und kannst du deswegen nicht sortieren. Wenn du die Werte sortieren möchtest gibt es aber einer Option: konvertieren zum List, sortieren und zurück konvertieren zum einem Tupel.

person = ('Alison','Victoria','Brenda','Rachel','Trevor')
person = tuple(sorted(person))
print(person)

dict python

Ein Dictionary (engl: Wörterbuch) kann als eine Gruppe von Schlüssel - Werte paare gesehen werden.

Jeder Schlüssel hat einen Wert. Ein Paar von Klammern macht ein leeres Dictionary: {}

Python Programming Bootcamp: Go from zero to hero

Beispiel
Zum bespiel:

#!/usr/bin/python
 
words = {}
words["Hello"] = "Bonjour"
words["Yes"] = "Oui"
words["No"] = "Non"
words["Bye"] = "Au Revoir"
 
print(words["Hello"])
print(words["No"])

Erstens wird den dictionairy definiert. In diesem Beispiel ist “Hello” Schlüssel und “Bonjour” ein wert. Am Ende Printn wir individuellen werten via Schlüssels.

Es gibt kein Wort Limit:

#!/usr/bin/python
 
dict = {}
dict['Ford'] = "Car"
dict['Python'] = "The Python Programming Language"
dict[2] = "This sentence is stored here."
 
print(dict['Ford'])
print(dict['Python'])
print(dict[2])

Manipulieren von einem dictionary

#!/usr/bin/python
 
words = {}
words["Hello"] = "Bonjour"
words["Yes"] = "Oui"
words["No"] = "Non"
words["Bye"] = "Au Revoir"
 
print(words)            # print key-pairs.
del words["Yes"]       # delete a key-pair.
print(words)            # print key-pairs.
words["Yes"] = "Oui!"  # add new key-pair.
print(words)            # print key-pairs.

Bedingte Anweisungen

In Python können Sie bedingte Anweisungen, bekannt als if-statements definieren.

#!/usr/bin/python
 
x = 3
if x < 10:
   print("x smaller than 10")
else:
   print("x is bigger than 10 or equal")

Wenn x größer ist als 10, wird es die zweite Codeblock ausgeführt. Wir verwenden Vertiefung (4 Spaces), um die Blöcke zu definieren.

Python Programming Bootcamp: Go from zero to hero

Ein kleines Spiel:
Eine Variable kann nicht immer durch den Benutzer definiert werden, betrachten dieses kleine Spiel:

age = 24
 
print "Guess my age, you have 1 chances!"
guess = int(raw_input("Guess: "))
 
if guess != age:
    print("Wrong!")
else:
    print("Correct")

Konditional Operators

Konditionen kombinieren

a = 12 
b = 33
 
if a > 10:
    if b > 20:
        print("Good")

oder das gleiche:

guess = 24
if guess > 10 and guess < 20:
    print("In range")
else:
    print("Out of range")

Funktionen

Schleifen

Schleifen werden benutzt um einen Codeblock wiederholt auszuführen Python hat zwei schleifen: for und while.

Kurs:
Python Programming Bootcamp: Go from zero to hero

For Schleife
Wenn du schon vorher wie viel mal einen Codeblock wiederholt werden müsst, brauchst du einen for-schleife.

#!/usr/bin/python
 
items = [ "Abby","Brenda","Cindy","Diddy" ]
 
for item in items:
    print(item)

#!/usr/bin/python
 
for i in range(1,10):
    print(i)

While schleife

Wenn du nicht vorher weißt wie viel mal ein Codeblock wiederholt müsst werden, gibt es der while-schleife. Meistens werden die while-schleife benutzt als du auf das Netzwerk oder etwas warten musst.

x = 0
while x != 10:
     x = x + 1

Zufallszahlen

Mit der Python Random Module können wir Zufallszahlen generieren. Der random() Funktion gibt Zufallszahlen zurück zwischen null und eins. [0, 0.1 .. 1], also kein integer sondern ein float.

Related course:
Python Programming Bootcamp: Go from zero to hero

Zufallszahlen null bis eins
Du kannst einer Zahl genieren zwischen 0 und 1 mit:

from random import *
 
print random()   

Zufallszahlen 0 bis 100
Du kannst einer Zahl genieren zwischen 0 und 100 mit:

from random import *
 
print randint(1, 100)    # Pick a random number between 1 and 100.

oder

from random import *
 
x = randint(1, 100)    # Pick a random number between 1 and 100.
print x

Dateien lesen

Sie können Datei (file) lesen mit dieser Python Code. Datei müsst im dieselbe Directory stehen als dem Python Programm, sonst musst du auch das ‘path’ schreiben.

Related Course:
Python Programming Bootcamp: Go from zero to hero

#!/usr/bin/env python
 
# Define a filename.
filename = "bestand.py"
 
# Open the file as f.
# The function readlines() reads the file.             
with open(filename) as f:
    content = f.readlines()
 
# Show the file contents line by line.
# We added the comma to print single newlines and not double newlines.
# This is because the lines contain the newline character '\n'. 
for line in content:
    print(line),

Das erste teil von dieser Code liest der Datei. Alle Setzen werden speichert in die variablen conent. Das zweite teil schreibt jeder Satz von dieser variablen.

Wenn Sie neu Satz nicht lesen möchtest, schreib dann einfach f.readlines() so wie:

#!/usr/bin/env python
 
# Define a filename.
filename = "bestand.py"
 
# Open the file as f.
# The function readlines() reads the file.
with open(filename) as f:
    content = f.read().splitlines()
 
# Show the file contents line by line.
# We added the comma to print single newlines and not double newlines.
# This is because the lines contain the newline character '\n'. 
for line in content:
    print(line)

Wir willen nur Datei lesen wenn das überhaupt existiert, das können wir so machen:

import os.path
 
# Define a filename.
filename = "bestand.py"
 
if not os.path.isfile(filename):
    print 'File does not exist.'
else:
    # Open the file as f. 
    # The function readlines() reads the file.
    with open(filename) as f:
        content = f.read().splitlines()
 
    # Show the file contents line by line.
    # We added the comma to print single newlines and not double newlines.
    # This is because the lines contain the newline character '\n'. 
    for line in content:
        print(line)

Dateien speichern

Für Dateien schreiben sind kein speziellen Modulen benötigt. Sie können einfach Dateien schreiben mit dem write() Methoden.

Dateien speichern

#!/usr/bin/env python
 
# Filename to write
filename = "newfile.txt"
 
# Open the file with writing permission
myfile = open(filename, 'w')
 
# Write a line to the file
myfile.write('Written with Python\n')
 
# Close the file
myfile.close()

Der ‘w’ Parameter überschreibt Data wenn es schon existiert.

Related Course:
Python Programming Bootcamp: Go from zero to hero

Hinzufugen

#!/usr/bin/env python
 
# Filename to append
filename = "newfile.txt"
 
# The 'a' flag tells Python to keep the file contents
# and append (add line) at the end of the file.
myfile = open(filename, 'a')
 
# Add the line 
myfile.write('Written with Python\n')
 
# Close the file
myfile.close()

Klassen

Technologie evaluierst immer.

1. Statements
das meist einfache Programm besteht nur aus sogenannte Statements, also Kommando regeln.

2. Funktionen
einer Gruppe Statements, damit können Sie der Code strukturieren.

3. Klassen
mit dem Klassen können Sie virtuellen Objekten machen. Ein Objekt kann variablen und Methoden besitzen.

Python Programming Bootcamp: Go from zero to hero

Python Klass

class User:
    name = ""
 
    def __init__(self, name):
        self.name = name
 
    def sayHello(self):
        print "Hello, my name is " + self.name
 
# create virtual objects
james = User("James")
david = User("David")
eric = User("Eric")
 
# call methods owned by virtual objects
james.sayHello()
david.sayHello()

In diesem Code haben wir drei virtuelles Objekten: James, David und Eric. Alle Objekten werden durch die klasse User gemacht.

In dieser Klasse haben wir der Methoden sayHello() definiert. Wir können dieser Methoden in jede Objekte anrufen. Der init Methode ist der sogenannte Konstruktor und wird immer angerufen als ein neues Objekt gemacht wird. Der variable in diesen klasse ist ‘name’ (nur eine). Jedes Objekt besitzt dieser variablen mit ein wert. Manchmal werden variablen Attributen genannt. Methoden können variablen von Objekten updaten.

Klasse variablen

def addBean(self):
    self.bean = self.bean + 1
 
def removeBean(self):
    self.bean = self.bean - 1

Für die variablen water machen wir dasselbe. Wir haben dieser Code:

class CoffeeMachine:
    name = ""
    beans = 0
    water = 0
 
    def __init__(self, name, beans, water):
        self.name = name
        self.beans = beans
        self.water = water
 
    def addBean(self):
        self.beans = self.beans + 1
 
    def removeBean(self):
        self.beans = self.beans - 1
 
    def addWater(self):
        self.water = self.water + 1
 
    def removeWater(self):
        self.water = self.water - 1
 
    def printState(self):
        print("Name  = " + self.name)
        print("Beans = " + str(self.beans))
        print("Water = " + str(self.water))
 
pythonBean = CoffeeMachine("Python Bean", 83, 20)
pythonBean.printState()
print("")
pythonBean.addBean()
pythonBean.printState()

Das erste teil von dieser Code definiert der Klasse. Wir machen ein virtuelles Objekten genannt ‘pythonBean’. Diesem Objekt besitzt Methoden und variablen. Als wir die Methoden anrufen können wir der interne variablen diesem Objekt verändern.

Datenkapselung

Datenkapselung in Python

Datenkapselung ist ein zentrales Konzept in der Programmierung, besonders in Python. Durch die Begrenzung des Zugriffs auf Methoden und Variablen in einem Python-Programm können wir sicherstellen, dass Daten nicht unabsichtlich geändert werden. Dies ist besonders wichtig in objektorientierter Programmierung und Klassen, während es bei Funktionen nicht direkt anwendbar ist.

Related Course: Python Programming Bootcamp: Go from zero to hero

Private Methoden in Python

Betrachten Sie das Beispiel einer Car Klasse mit zwei Methoden: drive() und __updateSoftware(). Wenn wir ein Objekt dieser Klasse erstellen, wird automatisch die private Methode __updateSoftware() aufgerufen.

Beachten Sie, dass private Methoden in Python mit zwei Unterstrichen vor dem Methodennamen gekennzeichnet sind. Diese Methoden können nicht direkt von einem Objekt aus aufgerufen werden, sondern nur innerhalb der Klasse selbst.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#!/usr/bin/env python

class Car:

    def __init__(self):
        self.__updateSoftware()

    def drive(self):
        print('driving')

    def __updateSoftware(self):
        print('updating software')

redcar = Car()
redcar.drive()
# redcar.__updateSoftware()  is not accessible from the object.

Die Methode __updateSoftware() ist privat und kann nur innerhalb der Car Klasse aufgerufen werden, nicht von außerhalb.

Private Variablen in Python

So wie es private Methoden gibt, gibt es auch private Variablen in Python. Diese Variablen können nur innerhalb der Klasse geändert werden, in der sie definiert sind.

Ein Hauptgrund für private Variablen ist die Sicherheit: Sie können wichtige Informationen speichern, die nicht ohne spezifische Klassenmethoden geändert werden sollten.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#!/usr/bin/env python

class Car:

    __maxspeed = 0
    __name = ""

    def __init__(self):
        self.__maxspeed = 200
        self.__name = "Supercar"

    def drive(self):
        print('driving. max speed is ' + str(self.__maxspeed))

redcar = Car()
redcar.drive()
redcar.__maxspeed = 10  # will not change the variable because it's private
redcar.drive()

Wenn Sie den Wert einer privaten Variable ändern möchten, können Sie eine setter Methode verwenden. Ein setter ermöglicht es, den Wert einer privaten Variable sicher zu ändern.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#!/usr/bin/env python

class Car:

    __maxspeed = 0
    __name = ""

    def __init__(self):
        self.__maxspeed = 200
        self.__name = "Supercar"

    def drive(self):
        print('driving. max speed is ' + str(self.__maxspeed))

    def setMaxSpeed(self, speed):
        self.__maxspeed = speed

redcar = Car()
redcar.drive()
redcar.setMaxSpeed(320)
redcar.drive()

Zusammenfassung der Datenkapselung in Python

In Python haben wir:

• Private Variablen
• Private Methoden
• Öffentliche Variablen
• Öffentliche Methoden

Es ist erwähnenswert, dass einige andere Programmiersprachen zusätzlich geschützte (“protected”) Methoden und Variablen haben, aber Python hat diese Unterscheidung nicht.

Vererbung

In der Python-Programmiersprache können Klassen Funktionen und Variablen von anderen Klassen durch das Prinzip der Vererbung (Englisch: Inheritance) übernehmen. Dies ist ein grundlegendes Konzept der objektorientierten Programmierung (OOP).

Related course: Python Programming Bootcamp: Go from zero to hero.

Wenn wir eine Klasse namens User definieren:

class User:
    name = ""

    def __init__(self, name):
        self.name = name

    def printName(self):
        print("Name = " + self.name")

brian = User("brian")
brian.printName()

Mit dieser Klasse erstellen wir ein Objekt namens Brian. Danach definieren wir eine weitere Klasse namens Programmer.

class Programmer(User):

    def __init__(self, name):
        self.name = name

    def doPython(self):
        print("Programming Python")

Diese Klasse sieht aus wie eine normale Klasse, aber sie erbt von der Klasse User (angegeben durch User in den Klammern). Das bedeutet, dass alle Funktionen und Variablen der Klasse User auch in der Klasse Programmer verfügbar sind.

Vererbungsbeispiel

Hier ist ein Beispiel für Vererbung:

class User:
    name = ""

    def __init__(self, name):
        self.name = name

    def printName(self):
        print("Name = " + self.name")

class Programmer(User):
    def __init__(self, name):
        self.name = name

    def doPython(self):
        print("Programming Python")

brian = User("brian")
brian.printName()

diana = Programmer("Diana")
diana.printName()
diana.doPython()

Brian ist eine Instanz der Klasse User und hat Zugriff auf die Methode printName(). Diana hingegen ist eine Instanz der Klasse Programmer. Da die Klasse Programmer von der Klasse User erbt, hat Diana Zugriff auf die Methoden beider Klassen.

Polymorphie

Manchmal kommt ein Objekt in viele formen. Zum Beispiel, es gibt viele Sorten Schaltfläche aber sie haben dasselbe verhalten. Kurz: alle Schaltflächen haben ein onClick() Funktion aber die Schaltfläche sehen nicht alle dasselbe aus. Dieser Idee wird Polymorphie genannt.

Das Wort Polymorphie ist basiert auf Griechische Worten Poly (viele) und Morphism (formen).

Related Course:
Python Programming Bootcamp: Go from zero to hero

Polymorphie mit einer Funktion

class Bear(object):
    def sound(self):
        print("Groarrr")
 
class Dog(object):
    def sound(self):
        print("Woof woof!")
 
def makeSound(animalType):
    animalType.sound()
 
 
bearObj = Bear()
dogObj = Dog()
 
makeSound(bearObj)
makeSound(dogObj)

Polymorphie mit einer abstrakten Klasse

for document in documents:
    print(document.name + ': ' + document.show())

Wir definieren eine (abstrakte) Klasse genannt Dokument. Dieser Klasse ist abstrakt: es definiert nur die Struktur. Wir definieren einer Funktion show() das durch beide Klassen PdfDocument und WordDocument implementiert wird.

class Document:
    def __init__(self, name):    
        self.name = name
 
    def show(self):             
        raise NotImplementedError("Subclass must implement abstract method")
 
class Pdf(Document):
    def show(self):
        return 'Show pdf contents!'
 
class Word(Document):
    def show(self):
        return 'Show word contents!'
 
documents = [Pdf('Document1'),
             Pdf('Document2'),
             Word('Document3')]
 
for document in documents:
    print(document.name + ': ' + document.show())

Wir haben ein abstrakten Struktur(document) und verschiedene Klassen die dieser Struktur implementieren. Wenn Sie ein neuen Type Dokument machen möchtest, kannst du einfach die Struktur von der Klasse Dokument benutzen.

Rekursive Programmierung

Einer Funktion ist rekursiv als es sich selbst wieder aufruft. Ein terminal Konditionen ist notwendig, sonst wird es immer dauern.

Python Programming Bootcamp: Go from zero to hero

Rekursion mit ein List
Wir können mit einem einfache Beispiel anfangen: nummern an einen liste hinzufügen Ohne Rekursive Methoden kann es so sein:

#!/usr/bin/env python
 
def sum(list):
    sum = 0
 
    # Add every number in the list.
    for i in range(0, len(list)):
        sum = sum + list[i]
 
    # Return the sum.
    return sum
 
print(sum([5,7,3,8,10]))

Dieser Methoden addiert alle Elementen und gibt die summe.
So können wir das rekursiv machen:

#!/usr/bin/env python
 
def sum(list):
   if len(list) == 1:
        return list[0]
   else:
        return list[0] + sum(list[1:])
 
print(sum([5,7,3,8,10]))

Als die List nur ein Element hat, gibt es direkt der Antwort. Sonst, ruft er die sum() Funktion minus ein Element der liste. Wenn alle anrufen vorbei sind, gibt dieser Funktion der Antwort.

Fakultät mit Rekursion
Der mathematische Definition von Fakultät ist: n! = n * (n-1)!, if n > 1 and f(1) = 1. Zum Beispiel: 3! = 3 x 2 x 1 = 6. Wir können das in Python machen mit einer rekursiven Funktion.

#!/usr/bin/env python
 
def factorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n-1)
 
print(factorial(3))

Als wir der factorial Funktion anrufen mit n=3, Antwort der Funktion mit n * factorial(n-1). Dieser Prozess wiederholt sich bis n=1. Als n==1 wahr ist, gibt der Funktion der Losung.

Limit

#!/usr/bin/env python
 
def factorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n-1)
 
print(factorial(3000))

Bekommst du der Fehler Meldung:

RuntimeError: maximum recursion depth exceeded

Wir können das Losen mit:

#!/usr/bin/env python
import sys
 
sys.setrecursionlimit(5000)
 
def factorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n-1)
 
print(factorial(3000))

python log file

Python logging

Alternative kurs

• Python Programming Bootcamp: Go from zero to hero

Logging example

import logging

# print a log message to the console.
logging.warning('This is a warning!')

Ausgabe:

WARNING:root:This is a warning!

zu speichern:

import logging

logging.basicConfig(filename='program.log',level=logging.DEBUG)
logging.warning('An example message.')
logging.warning('Another message')

Es gibt sogennante ‘degrees of severity’, wie wichtig ist die Fehler meldung?.

Degrees of severity

logging.basicConfig(level=logging.DEBUG)

Diese logging gibt es:

Die standard Einstellung ist Warnung, was bedeutet, dass andere Nachrichten ignoriert werden. Wenn Sie debug oder info möchten Sie drucken müssen die Einstellung wie folgt ändern:

import logging

logging.basicConfig(level=logging.DEBUG)
logging.debug('Debug message')

Zeit im log

logging.basicConfig(format='%(asctime)s %(message)s')

Bespiel:

import logging

logging.basicConfig(format='%(asctime)s %(message)s', level=logging.DEBUG)
logging.info('Logging app started')
logging.warning('An example logging message.')
logging.warning('Another log message')

Ausgabe:

2015-06-25 23:24:01,153 Logging app started
2015-06-25 23:24:01,153 An example message.
2015-06-25 23:24:01,153 Another message