Category: anfanger

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 Crashkurs: Eine praktische, projektbasierte Programmiereinführung

Python Klass

Wir können virtuellen Objekten machen in Python. Ein virtuelles Objekt kann Methoden und variablen besitzen. Alle Objekten in Python werden durch ein klasse gemacht. Zum Beispiel:

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

Wir definieren einer Klasse genannt CoffeeMachine. Objekten besitzen der variablen ‘beans’ und ‘amount of water’. Beides sind von der Dateitypen integer. Wir definieren Methoden die diesen variablen verändern können

    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

In ein Python Programm können wir Zugang zum Methoden und variablen limitieren. Damit verhindern wir das Data zufällig verändert.

Privaten Methoden

Wir machen einer Klasse mit zwei Methoden: drive() und updateSoftware(). Als wir einem Objekt machen von der Klasse car, ruft der die privaten Methoden __updateSoftware() an.

Wir können diesen Methoden nicht direkt beim Objekt anrufen, nur in der Klasse.

#!/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()  not accesible from object.

Der privaten Methoden __updateSoftware() kann nur in die Klasse angerufen werden, niemals außer der Klasse.

Privaten Variablen

Variablen können private sein. Einen privaten variablen kann nur in die Klasse mit einer Methode verändern

Objekten können wichtige Datei behalten und wir möchten nicht das die Daten ohne Klasse Methoden verändern wird.

Zum Beispiel:

#!/usr/bin/env python
 
class Car:
 
    __maxspeed = 0
    __name = ""
 
    def __init__(self):
        self.__maxspeed = 200
        self.__name = "Supercar"
 
    def drive(self):
        print 'driving. maxspeed ' + str(self.__maxspeed)
 
redcar = Car()
redcar.drive()
redcar.__maxspeed = 10  # will not change variable because its private
redcar.drive()

Wenn Sie die wert einen privaten variablen anderen willst, benutzt Sie ein setter Methoden. Ein setter Methode verändert die wert einer privaten variablen.

#!/usr/bin/env python
 
class Car:
 
    __maxspeed = 0
    __name = ""
 
    def __init__(self):
        self.__maxspeed = 200
        self.__name = "Supercar"
 
    def drive(self):
        print 'driving. maxspeed ' + str(self.__maxspeed)
 
    def setMaxSpeed(self,speed):
        self.__maxspeed = speed
 
redcar = Car()
redcar.drive()
redcar.setMaxSpeed(320)
redcar.drive()

Datenkapselung in Python

In Python gibt es:

Privaten Variablen
Privaten Methoden
Public Variablen
Public Methoden

In anderen Programmiersprachen gibt es auch protected Methoden, aber im Python nicht.

Vererbung

Klassen können Funktionalität und variablen von anderen Klassen erben (Englisch: Inheritance)

Wir definieren einer Klasse genannt User:

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 machen wir ein Objekt genannt Brian. Wir machen einer Klasse genannt Programmer.

class Programmer(User):
 
    def __init__(self, name):
        self.name = name
    def doPython(self):
        print "Programming Python"

Dieser Klasse seht aus wie ein Standard Klasse außerdem das User zwischen des Parameters steht. Das bedeutet das alle Funktionalität in die Klasse User jetzt auch zugänglich in der Programmer Klasse ist.

Vererbung beispiel

Ein Beispiel von 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 einer Instanz von die Klasse User und hat nur der Methoden printName(). Diana ist einer Instanz von die Klasse Programmer, dieser Klasse hat Vererbung von die Klasse User, und kann Methoden in die Klasse Programmer und User benutzen.

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).

Polymorphie mit einer Funktion

Wir machen zwei Klassen: Bear und Dog, beiden können ‘sprechen’. Wir machen zwei Instanzen von diesen Klassen und rufen der Methode sound() an.

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

Als Sie einen editor macht wissen Sie nicht ob der User ein PDF oder Word Dokument offenen möchtest. Alle Dokumenten brauchen dasselbe Funktionalität: zeigen, schließen usw.

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 Crashkurs: Eine praktische, projektbasierte Programmiereinführung

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 &gt; 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

Jeder Funktion Anruf speichert der Computer im Memory. Also, so einer Funktion benutzt mehr Memory. Python wird das Enden nach 1000 anrufen. Wenn Sie diesem Beispiel ausfuhrt:

#!/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))

Logdatei

Python logging

Logdatei hilft beim debugging und Entwicklung. Nach der Entwicklung können wir Sie auschalten. Eine weitere Möglichkeit besteht darin, ihn in einer Datei zu speichern. Beginnen wir mit einem einfachen Beispiel.

Alternative kurs

Python Crash Course: Master Python Programming

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

Wir können den Schweregrad setzen mit dieser Zeile:

logging.basicConfig(level=logging.DEBUG)

Diese logging gibt es:

Type	Beschreibung
DEBUG	Nur fur problemen aufspueren
INFO	Normales Prozess
WARNING	Etwas stimmt nicht
ERROR	Fehler
CRITICAL	Schwerer Fehler

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

Sie können die Zeit Aktivieren mit der folgenden Codezeile:

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')