Wenn Sie also die Programmiersprache Python lernen möchten, aber kein prägnantes und dennoch voll ausgestattetes Tutorial finden können, wird dieses Tutorial versuchen, Ihnen Python in 10 Minuten beizubringen. Es ist wahrscheinlich nicht so sehr ein Tutorial, sondern eine Verknüpfung zwischen einem Tutorial und einem Cheatsheet, so dass es Ihnen nur einige grundlegende Konzepte zeigt, um Sie zu starten. Offensichtlich müssen Sie, wenn Sie wirklich eine Sprache lernen möchten, eine Weile darin programmieren. Ich gehe davon aus, dass Sie bereits mit Programmieren vertraut sind und daher die meisten nicht-sprachspezifischen Dinge überspringen. Die wichtigen Schlüsselwörter werden hervorgehoben, damit Sie sie leicht erkennen können. Auch, weil aufgrund der Kürze dieses Tutorials einige Dinge direkt in den Code eingeführt werden und nur kurz kommentiert werden.
Wir werden uns auf Python 3 konzentrieren, denn das ist die Version, die Sie verwenden sollten. Alle Beispiele im Buch sind in Python 3, und wenn jemand Ihnen empfiehlt, 2 zu verwenden, sind sie nicht Ihre Freunde.
Python ist stark typisch (d.h. Typen werden durchgesetzt), dynamisch, implizit typisch (d.h. Sie müssen keine Variablen deklarieren), case-sensitiv (d.h. var und VAR sind zwei verschiedene Variablen) und objektorientiert (d.h. alles ist ein Objekt).
Hilfe in Python ist immer direkt im Interpreter verfügbar. Wenn Sie wissen möchten, wie ein Objekt funktioniert, müssen Sie nur
>>> help(5)
Help on int object:
(etc etc)
>>> dir(5)
['__abs__', '__add__', ...]
>>> abs.__doc__
'abs(number) -> number
Return the absolute value of the argument.
In Python gibt es keine obligatorischen Anweisungsabschlusszeichen und Blöcke werden durch Einschlag angegeben. Einschlag zum Beginn eines Blocks, Abschlag zum Ende eines. Anweisungen, die ein Einschlagniveau erwarten, enden mit einem Doppelpunkt (:). Kommentare beginnen mit dem Pfundzeichen (#) und sind einzeilige, mehrzeilige Zeichenfolgen werden für mehrzeilige Kommentare verwendet. Werte werden mit dem Gleichheitszeichen (
>>> myvar = 3
>>> myvar += 2
>>> myvar
5
>>> myvar -= 1
>>> myvar
4
"""This is a multiline comment.
The following lines concatenate the two strings."""
>>> mystring = "Hello"
>>> mystring += " world."
>>> print(mystring)
Hello world.
# This swaps the variables in one line(!).
# It doesn't violate strong typing because values aren't
# actually being assigned, but new objects are bound to
# the old names.
>>> myvar, mystring = mystring, myvar
Die in Python verfügbaren Datenstrukturen sind Listen, Tupel und Wörterbücher. Sätze sind in der Satzbibliothek verfügbar (sind aber in Python 2.5 und höher integriert). Listen sind wie eindimensionale Arrays (aber Sie können auch Listen anderer Listen haben), Wörterbücher sind assoziative Arrays (auch Hashtabellen genannt) und Tupel sind unveränderliche eindimensionale Arrays (Python
>>> sample = [1, ["another", "list"], ("a", "tuple")]
>>> mylist = ["List item 1", 2, 3.14]
>>> mylist[0] = "List item 1 again" # We're changing the item.
>>> mylist[-1] = 3.21 # Here, we refer to the last item.
>>> mydict = {"Key 1": "Value 1", 2: 3, "pi": 3.14}
>>> mydict["pi"] = 3.15 # This is how you change dictionary values.
>>> mytuple = (1, 2, 3)
>>> myfunction = len
>>> print(myfunction(mylist))
3
Sie können die Array-Bereiche mit einem Doppelpunkt (:) aufrufen. Wenn Sie den Startindex leer lassen, wird der erste Punkt angenommen, wenn Sie den Endindex verlassen, wird der letzte Punkt angenommen. Die Indexierung ist inklusiv-exklusiv, so dass die Angabe von
>>> mylist = ["List item 1", 2, 3.14]
>>> print(mylist[:])
['List item 1', 2, 3.1400000000000001]
>>> print(mylist[0:2])
['List item 1', 2]
>>> print(mylist[-3:-1])
['List item 1', 2]
>>> print(mylist[1:])
[2, 3.14]
# Adding a third parameter, "step" will have Python step in
# N item increments, rather than 1.
# E.g., this will return the first item, then go to the third and
# return that (so, items 0 and 2 in 0-indexing).
>>> print(mylist[::2])
['List item 1', 3.14]
Seine Zeichenfolgen können entweder einzelne oder doppelte Anführungszeichen verwenden, und Sie können Anführungszeichen einer Art in einer Zeichenfolge haben, die die andere Art verwendet (dh
>>> print("Name: %s\
Number: %s\
String: %s" % (myclass.name, 3, 3 * "-"))
Name: Stavros
Number: 3
String: ---
strString = """This is
a multiline
string."""
# WARNING: Watch out for the trailing s in "%(key)s".
>>> print("This %(verb)s a %(noun)s." % {"noun": "test", "verb": "is"})
This is a test.
>>> name = "Stavros"
>>> "Hello, {}!".format(name)
Hello, Stavros!
>>> print(f"Hello, {name}!")
Hello, Stavros!
Flow-Control-Anweisungen sind
rangelist = list(range(10))
>>> print(rangelist)
range(0, 10)
>>> print(list(rangelist))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for number in rangelist:
# Check if number is one of
# the numbers in the tuple.
if number in (3, 4, 7, 9):
# "Break" terminates a for without
# executing the "else" clause.
break
else:
# "Continue" starts the next iteration
# of the loop. It's rather useless here,
# as it's the last statement of the loop.
continue
else:
# The "else" clause is optional and is
# executed only if the loop didn't "break".
pass # Do nothing
if rangelist[1] == 2:
print("The second item (lists are 0-based) is 2")
elif rangelist[1] == 3:
print("The second item (lists are 0-based) is 3")
else:
print("Dunno")
while rangelist[1] == 1:
print("We are trapped in an infinite loop!")
Funktionen werden mit dem Schlüsselwort
# Same as def funcvar(x): return x + 1
funcvar = lambda x: x + 1
>>> print(funcvar(1))
2
# an_int and a_string are optional, they have default values
# if one is not passed (2 and "A default string", respectively).
def passing_example(a_list, an_int=2, a_string="A default string"):
a_list.append("A new item")
an_int = 4
return a_list, an_int, a_string
>>> my_list = [1, 2, 3]
>>> my_int = 10
>>> print(passing_example(my_list, my_int))
([1, 2, 3, 'A new item'], 4, "A default string")
>>> my_list
[1, 2, 3, 'A new item']
>>> my_int
10
Python unterstützt eine beschränkte Form der Mehrfacherben in Klassen. Private Variablen und Methoden können durch Hinzufügen eines führenden Unterstriches (z.B.
class MyClass(object):
common = 10
def __init__(self):
self.myvariable = 3
def myfunction(self, arg1, arg2):
return self.myvariable
# This is the class instantiation
>>> classinstance = MyClass()
>>> classinstance.myfunction(1, 2)
3
# This variable is shared by all instances.
>>> classinstance2 = MyClass()
>>> classinstance.common
10
>>> classinstance2.common
10
# Note how we use the class name
# instead of the instance.
>>> MyClass.common = 30
>>> classinstance.common
30
>>> classinstance2.common
30
# This will not update the variable on the class,
# instead it will bind a new object to the old
# variable name.
>>> classinstance.common = 10
>>> classinstance.common
10
>>> classinstance2.common
30
>>> MyClass.common = 50
# This has not changed, because "common" is
# now an instance variable.
>>> classinstance.common
10
>>> classinstance2.common
50
# This class inherits from MyClass. The example
# class above inherits from "object", which makes
# it what's called a "new-style class".
# Multiple inheritance is declared as:
# class OtherClass(MyClass1, MyClass2, MyClassN)
class OtherClass(MyClass):
# The "self" argument is passed automatically
# and refers to the class instance, so you can set
# instance variables as above, but from inside the class.
def __init__(self, arg1):
self.myvariable = 3
print(arg1)
>>> classinstance = OtherClass("hello")
hello
>>> classinstance.myfunction(1, 2)
3
# This class doesn't have a .test member, but
# we can add one to the instance anyway. Note
# that this will only be a member of classinstance.
>>> classinstance.test = 10
>>> classinstance.test
10
Ausnahmen in Python werden mit try-except [Exceptionname] Blocks behandelt:
def some_function():
try:
# Division by zero raises an exception
10 / 0
except ZeroDivisionError:
print("Oops, invalid.")
else:
# Exception didn't occur, we're good.
pass
finally:
# This is executed after the code block is run
# and all exceptions have been handled, even
# if a new exception is raised while handling.
print("We're done with that.")
>>> some_function()
Oops, invalid.
We're done with that.
Externe Bibliotheken werden mit dem Schlüsselwort
import random
from time import clock
randomint = random.randint(1, 100)
>>> print(randomint)
64
Python verfügt über eine breite Palette von Bibliotheken. Hier ist ein Beispiel, wie die Serialisierung (Konvertierung von Datenstrukturen in Strings mit der
import pickle
mylist = ["This", "is", 4, 13327]
# Open the file C:\\binary.dat for writing. The letter r before the
# filename string is used to prevent backslash escaping.
myfile = open(r"C:\\binary.dat", "wb")
pickle.dump(mylist, myfile)
myfile.close()
myfile = open(r"C:\\text.txt", "w")
myfile.write("This is a sample string")
myfile.close()
myfile = open(r"C:\\text.txt")
>>> print(myfile.read())
'This is a sample string'
myfile.close()
# Open the file for reading.
myfile = open(r"C:\\binary.dat", "rb")
loadedlist = pickle.load(myfile)
myfile.close()
>>> print(loadedlist)
['This', 'is', 4, 13327]
>>> lst1 = [1, 2, 3]
>>> lst2 = [3, 4, 5]
>>> print([x * y for x in lst1 for y in lst2])
[3, 4, 5, 6, 8, 10, 9, 12, 15]
>>> print([x for x in lst1 if 4 > x > 1])
[2, 3]
# Check if a condition is true for any items.
# "any" returns true if any item in the list is true.
>>> any([i % 3 for i in [3, 3, 4, 4, 3]])
True
# This is because 4 % 3 = 1, and 1 is true, so any()
# returns True.
# Check for how many items a condition is true.
>>> sum(1 for i in [3, 3, 4, 4, 3] if i == 4)
2
>>> del lst1[0]
>>> print(lst1)
[2, 3]
>>> del lst1
number = 5
def myfunc():
# This will print 5.
print(number)
def anotherfunc():
# This raises an exception because the variable has not
# been bound before printing. Python knows that it an
# object will be bound to it later and creates a new, local
# object instead of accessing the global one.
print(number)
number = 3
def yetanotherfunc():
global number
# This will correctly change the global.
number = 3
Dieses Tutorial ist nicht dazu gedacht, eine vollständige Liste aller (oder sogar einer Teilmenge) von Python zu sein. Python hat eine große Auswahl an Bibliotheken und viel mehr Funktionalität, die Sie durch andere Mittel entdecken müssen, wie das ausgezeichnete Buch Dive into Python. Ich hoffe, ich habe Ihren Übergang in Python erleichtert. Bitte hinterlassen Sie Kommentare, wenn Sie glauben, dass etwas verbessert oder hinzugefügt werden könnte oder wenn es etwas anderes gibt, das Sie sehen möchten (Klassen, Fehlerbearbeitung, alles).