python logo


Category: Anfänger

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-vs-c

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

Datentypen beschreiben was für Data der Rechner benutzt. Zum Beispiel, integers (1,2,3) sind kein floating point numbers (3.1415..).

Rechners benutzen immer das Binary System (0,1), trotzdem müssen Software Entwickler diesen meistens nicht benutzen. Sie können einfach integers oder andern Datentypen benutzen.

In Python ist explizite Definition von Datentypen nicht verpflichtet.

Python Programming Bootcamp: Go from zero to hero

Datentypen


Datentypen der Python unterstützt sind:



Datentypen Beschreibung Beispiel Note
int Integers. 0,1,2,3.. Mit diesem Programm bekommst du das maximal Zahl: {% codeblock lang:python line_number:false %} import sys print(sys.maxint) {% endcodeblock %}
float Floating point numbers. 6.7395, 1.6840 Für das Minimum und Maximum Zahl: {% codeblock lang:python line_number:false %} import sys print(sys.float_info) {% endcodeblock %}
long Long integers. * -
complex Complex numbers. 2r, 3i Komplexen Zahlen erweitern den Zahlenbereich der reellen Zahlen mit einer imaginären Zahl.
boolean Boolean numbers. True, False Subtype von integers.

Floating point numbers
Die floating point numbers sind manchmal nicht korrekt wegen Abrundens Fehler. Sei Vorsicht als du die floating point numbers benutzt.

Beispiel von floating point Fehler:


x = 1
y = 0.00000000000000007
print(x + y)
# output 1

Der Arianne 5 Rakete war abgestürzt wegen floating point Fehler. Der Rakete war in 1996 gemacht und hat 7 Billionen gekostet.

Beispiel


Explizite Definition von Datentypen ist nicht verpflichtet, wie das Beispiel hierunter zeigt.


#!/usr/bin/python

x = 3 # integer (variablen x)
f = 3.1415926 # floating (variablen f)
name = "Python" # string
big = 358315791 # long
z = complex(2,3) # (2+3i) Komplexe Zahl.

print(x)
print(f)
print(name)
print(big)
print(z)

Resultat:

3
3.1415926
Python
358315791
(2+3j)

Operatoren


Du kannst arithmetische Operatoren benutzen wie Addieren (+), Subtraktion (-), Teilung (-) und Multiplikation (*).



Operation Result
x + y Summe von x und y.
x * y Multiplikation von x und y.
x - y Unterschied zwischen x und y.
x / y Teilung von x durch y.
x % y Rest x/y
x ** y x hoch y
abs(x) absolute wert von x
sqrt(x) Quadratwurzel von x

In die Code hierunter machen wir zwei variablen (x und y). Exekutieren die Expression (x+y) und in speichern das Resultat in die variablen sum.


#!/usr/bin/env python

x = 3
y = 8

sum = x + y

print(sum)

Mathematische Funktionen


Python unterstützt verschiedene mathematische Funktionen.



Function Returns Example
abs(x) Returns the absolute value of x. {% codeblock lang:python line_number:false %} x = -35 x = abs(x) print(x) {% endcodeblock %}
cmp(x,y) Returns -1 if x < y
Returns 0 if x equals to y
Returns 1 if x > y.
{% codeblock lang:python line_number:false %} x = 6 y = 4 print( cmp(x,y) ) {% endcodeblock %}
exp(x) Returns the exponential of x {% codeblock lang:python line_number:false %} import math x = 6 print( math.exp(x) ) {% endcodeblock %}
log(x) The natural logarithm of x {% codeblock lang:python line_number:false %} import math x = 6 print( math.log(x) ) {% endcodeblock %}
log10(x) The base-10 logarithm of x {% codeblock lang:python line_number:false %} import math x = 6 print( math.log10(x) ) {% endcodeblock %}
pow(x,y) The result of x**y {% codeblock lang:python line_number:false %} import math x = 6 print( math.pow(x,2) ) {% endcodeblock %}
sqrt(x) The square root of x {% codeblock lang:python line_number:false %} import math x = 6 print( math.sqrt(x) ) {% endcodeblock %}

Manchmal ist konvertieren zwischen Datentypen Essential.



Function Purpose
int(x) Convert x to integer
long(x) Convert x to long
float(x) Convert x to float

Keyboard Input


Wenn du variablen an der Endbenutzer fragen möchtest, kannst du der (Python 3) input() oder der raw_input() Funktion benutzen.

Python 3 version:


x = int(input("Enter x:"))
y = int(input("Enter y:"))

sum = x + y
print(sum)

Python 2 version:


x = int(raw_input("Enter x:"))
y = int(raw_input("Enter y:"))

sum = x + y
print(sum)

Strings

Variablen in Mathematik besitzen oft bestimmte Werten wie Zahlen.

Doch müsst das nicht immer so sein, manchmal können variablen ein Zeichen oder Zeichenkette (Strings) besitzen.

Python Programming Bootcamp: Go from zero to hero

Strings


Ein String kannst du als nummerierte Zeichenkette sehen:

python-string python-string

Jeder Zeichen in einem String kannst du mit ein Index nummern erreichen.
Eine Sammlung in Python startet immer mit der 0-index.


s = "Python"
print(s)
print(s[0])

Es gibt drei weisen für String Definition: single (‘), double quotes (“) oder triple quotes (“””).
Zum Beispiel:


s = 'hello'
s = "hello"
s = """hello"""
print(s)

Du kannst das Resultat von einer Methode speichern, wie s = s.replace(“world”,”python”).

String slices


Die Syntax für ein teil -string ist:


s[ startIndex : pastIndex ]

Der startIndex ist null (erste Zeichen) oder mehr. Als du der startIndex nicht spezifiziert ist es immer null. Der variablen pastIndex ist die Länge einer String plus eins.


#!/usr/bin/python

s = "Hello Python"
print(s[0:2]) # prints "He"
print(s[2:4]) # prints "ll"
print(s[6:]) # prints "Python"

Strings bearbeiten


Es gibt verschiedene weisen für String Bearbeitung.


#!/usr/bin/python

s = "Hello Python"

print(s + ' ' + s) # print concatenated string.
print(s.replace('Hello','Thanks')) # print a string with a replaced word

# convert string to uppercase
s = s.upper()
print(s)

# convert to lowercase
s = s.lower()
print(s)

Comparison, contains and concatenation


Der Operator (==) kannst du benutzen für Vergleich von zwei Strings. Das in keyword kannst du benutzen für suchen in einem String. Du kannst ein String an ein String hinzufügen mit der (+) Operator.


#!/usr/bin/python

sentence = "The cat is brown"
q = "cat"

if q == sentence:
print('strings equal')

if q in sentence:
print(q + " found in " + sentence)

Escape- oder Fluchtzeichen


Es gibt speciale Zeichen in Python, wie der ‘\n’ fuer neuregeln.


#!/usr/bin/env python

str1 = "In Python,\nyou can use special characters in strings.\nThese special characters can be..."
print(str1)



'Escape' Zeichen Beschreibung
\n Neuregeln.
\" Quotes.
\' Single Quote.
\t Tab.
\\ Backslash.

Methoden


Mit dieser Methoden kannst du strings bearbeiten



Method with description
capitalize(str)
Returns first letter capitalized string.
count(str)
Count the frequency of the word str. It can also be applied to words: s.count("Hello")
find(str)
Find the position of the first occurence.
index(str)
Find the position of the first occurence, raise exception if not found.
isdecimal()
Returns true if string is decimal.
isdigit()
Returns true if string contains digits only.
isnumeric()
Returns true if string contains numeric only.
lower()
Returns string in lowercase.
len(str)
Returns the length of str.
upper()
Returns string in uppercase.
replace(old, new)
Replaces the first argument with the second argument.

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

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)

Dictionary

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

Operator Beschreibung
!= nicht gleich
== gleich
> grosser als
< kleiner als

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


Diesen Code schreibt (oder überschreibt) Data.


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


Dieser Code überschreibt Dateien nicht:


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


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. Wir können das nur beim methoden machen (klassen), nicht funktionen.

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

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

In Python programmiersprache können Klassen Funktionalität und variablen von anderen Klassen erben (Englisch: Inheritance). Das ist ein conzept aus der “object-oriented programming”.

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

Als wir ein Klasse definieren 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).

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

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

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

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