4.3 Der Einstieg in die Python-Sprache

Vorläufige Flusse

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.

Eigenschaften

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 holen

Hilfe in Python ist immer direkt im Interpreter verfügbar. Wenn Sie wissen möchten, wie ein Objekt funktioniert, müssen Sie nur help ((- Ich weiß., die Ihnen die Dokumentationsfolge zeigt:

>>> help(5)
Help on int object:
(etc etc)

>>> dir(5)
['__abs__', '__add__', ...]

>>> abs.__doc__
'abs(number) -> number

Return the absolute value of the argument.

Syntax

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 (=) zugeordnet (tatsächlich sind Objekte an Namen gebunden) und die Gleichheitsprüfung wird mit zwei Gleichheitszeichen (==) durchgeführt.

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

Datenarten

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 arrays kann jeden Typ haben, so dass Sie z.B. Ganzzahlen, Zeichenfolgen usw. in Listen/Wörterbüchern/Tupeln mischen können). Der Index des ersten Elements in allen Arraytypen ist 0. Negative Zahlen zählen vom Ende zum Anfang, -1 ist der letzte Eintrag. Variablen können auf Funktionen verweisen.

>>> 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 [2:10] die Elemente [2] (das dritte Element aufgrund der 0-Indexierung) zu [9] (das zehnte Element) zurückgibt, inklusive (8 Elemente). Negative Indizes werden von dem letzten Element rückwärts gezählt (so ist -1 der letzte Element) wie folgt:

>>> 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]

Strings

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 Er sagte hello. ist gültig).dreifache doppelte (oder einzelne) Anmerkungen(). Python-Strings sind immer Unicode, aber es gibt einen anderen String-Typ, der reine Bytes sind. Diese werden Bytestrings genannt und werden mit dem Präfix b dargestellt, zum Beispiel bHallo \xce\xb1. Um eine Zeichenfolge mit Werten zu füllen, verwenden Sie den % (modulo) -Operator und ein Tuple. Jedes %s wird mit einem Element aus dem Tuple, von links nach rechts, ersetzt, und Sie können auch Wörterbuchersetzungen wie folgt verwenden:

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

Flusssteuerungsanweisungen

Flow-Control-Anweisungen sind if, for und while. Es gibt keine switch; stattdessen verwenden Sie if. Verwenden Sie for, um durch Mitglieder einer Liste zu zählen. Um eine Sequenz von Zahlen zu erhalten, die Sie überwinden können, verwenden Sie range() . Die Syntax dieser Anweisungen ist folgendermaßen:

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

Funktionen werden mit dem Schlüsselwort def deklariert. Optionale Argumente werden in der Funktionsdeklaration nach den obligatorischen Argumenten gesetzt, indem ihnen ein Standardwert zugewiesen wird. Für benannte Argumente wird dem Namen des Arguments ein Wert zugewiesen. Funktionen können ein Tuple zurückgeben (und mit einem Tuple-Unpacking können Sie effektiv mehrere Werte zurückgeben). Lambda-Funktionen sind Ad-hoc-Funktionen, die aus einer einzigen Anweisung bestehen. Parameter werden durch Referenz übermittelt, aber unveränderliche Typen (Tuple, Int, Strings usw.) können vom Anrufer nicht im Anrufer geändert werden. Dies liegt daran, dass nur der Speicherort des Elements übergeben wird und die Bindung eines anderen Objekts an eine Variable das alte wegwirft, so dass unveränderliche Typen ersetzt werden. Zum Beispiel:

# 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

Klassen

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. _spam) deklariert werden.

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

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.

Einfuhr

Externe Bibliotheken werden mit dem Schlüsselwort import [libname] verwendet. Sie können auch from [libname] import [funcname] für einzelne Funktionen verwenden.

import random
from time import clock

randomint = random.randint(1, 100)
>>> print(randomint)
64

Datei I/O

Python verfügt über eine breite Palette von Bibliotheken. Hier ist ein Beispiel, wie die Serialisierung (Konvertierung von Datenstrukturen in Strings mit der pickle-Bibliothek) mit Datei-Eingabe/Ausgabe verwendet wird:

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]

Weitere

• Die Bedingungen können gekettet werden: 1 < a < 3 prüft, ob a sowohl kleiner als 3 als auch größer als 1 ist.
• Sie können del verwenden, um Variablen oder Elemente in Arrays zu löschen.
• Listenverständnisse bieten eine leistungsstarke Möglichkeit, Listen zu erstellen und zu manipulieren. Sie bestehen aus einem Ausdruck, gefolgt von einer for Klausel, gefolgt von null oder mehr if oder for Klauseln, so:

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

• Globale Variablen werden außerhalb von Funktionen deklariert und können ohne spezielle Deklarationen gelesen werden, aber wenn Sie an sie schreiben möchten, müssen Sie sie zu Beginn der Funktion mit dem Schlüsselwort global deklarieren, andernfalls wird Python dieses Objekt an eine neue lokale Variable binden (seien Sie vorsichtig, es ist ein kleiner Haken, der Sie bekommen kann, wenn Sie es nicht kennen).

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

Epiloge

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