Python Language Tutorial
Erste Schritte mit Python Language

Bemerkungen

Versionen

Fertig machen

Python ist eine weit verbreitete Programmiersprache für allgemeine Zwecke, die von Guido van Rossum entwickelt und erstmals 1991 veröffentlicht wurde. Python verfügt über ein dynamisches Typsystem und eine automatische Speicherverwaltung und unterstützt mehrere Programmierparadigmen, einschließlich objektorientierter, funktionale Programmierung und prozedurale Stile. Es verfügt über eine große und umfassende Standardbibliothek.

Derzeit sind zwei Hauptversionen von Python aktiv:

• Python 3.x ist die aktuelle Version und wird derzeit weiterentwickelt.
• Python 2.x ist die ältere Version und wird bis 2020 nur Sicherheitsupdates erhalten. Es werden keine neuen Funktionen implementiert. Beachten Sie, dass viele Projekte weiterhin Python 2 verwenden, obwohl die Migration zu Python 3 einfacher wird.

Sie können beide Versionen von Python hier herunterladen und installieren. Siehe Python 3 vs. Python 2 für einen Vergleich. Darüber hinaus bieten einige Drittanbieter neu verpackte Versionen von Python an, die häufig verwendete Bibliotheken und andere Funktionen hinzufügen, um das Einrichten allgemeiner Anwendungsfälle wie Mathematik, Datenanalyse oder wissenschaftliche Verwendung zu erleichtern. Siehe die Liste auf der offiziellen Website .

Überprüfen Sie, ob Python installiert ist

Um zu bestätigen, dass Python korrekt installiert wurde, können Sie dies überprüfen, indem Sie den folgenden Befehl in Ihrem bevorzugten Terminal ausführen (Wenn Sie ein Windows-Betriebssystem verwenden, müssen Sie der Umgebungsvariablen den Pfad von Python hinzufügen, bevor Sie ihn in der Eingabeaufforderung verwenden):

$ python --version

$ python --version
Python 3.6.0

$ python --version
Python 2.7.13

Wenn Sie Python 3 installiert haben, aber $ python --version eine Python 2-Version ausgibt, haben Sie auch Python 2 installiert. Dies ist häufig auf MacOS und vielen Linux-Distributionen der Fall. Verwenden $ python3 stattdessen $ python3 , um den Python 3-Interpreter explizit zu verwenden.

Hallo, World in Python mit IDLE

IDLE ist ein einfacher Editor für Python, der im Lieferumfang von Python enthalten ist.

So erstellen Sie ein Hello, World-Programm in IDLE

• Öffnen Sie IDLE auf Ihrem System Ihrer Wahl.
  • In älteren Windows-Versionen finden Sie es unter All Programs im Windows-Menü.
  • Suchen Sie in Windows 8+ nach IDLE oder suchen Sie nach den Apps, die in Ihrem System vorhanden sind.
  • Auf Unix-basierten (einschließlich Mac) Systemen können Sie es von der Shell aus öffnen, indem Sie $ idle python_file.py .
• Es wird eine Shell mit Optionen oben geöffnet.

In der Schale werden drei rechtwinklige Klammern angezeigt:

>>>

Schreiben Sie nun den folgenden Code in die Eingabeaufforderung:

>>> print("Hello, World")

Drücken Sie die Eingabetaste .

>>> print("Hello, World")
Hello, World

Hallo Welt Python-Datei

Erstellen Sie eine neue Datei hello.py , die die folgende Zeile enthält:

print('Hello, World')

from __future__ import print_function

print 'Hello, World'

Navigieren Sie in Ihrem Terminal zu dem Verzeichnis, in dem sich die Datei hello.py .

python hello.py und python hello.py die Eingabetaste .

$ python hello.py
Hello, World

Sie sollten Hello, World auf der Konsole anzeigen.

Sie können auch hello.py durch den Pfad zu Ihrer Datei hello.py . Wenn sich die Datei beispielsweise in Ihrem Home-Verzeichnis befindet und Ihr Benutzer unter Linux "Benutzer" ist, können Sie python /home/user/hello.py .

Starten Sie eine interaktive Python-Shell

Durch Ausführen (Ausführen) des python Befehls in Ihrem Terminal wird eine interaktive Python-Shell angezeigt. Dies wird auch als Python-Interpreter oder REPL (für "Read Evaluate Print Loop") bezeichnet.

$ python
Python 2.7.12 (default, Jun 28 2016, 08:46:01) 
[GCC 6.1.1 20160602] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print 'Hello, World'
Hello, World
>>>

Wenn Sie Python 3 von Ihrem Terminal aus ausführen python3 , führen Sie den Befehl python3 .

$ python3
Python 3.6.0 (default, Jan 13 2017, 00:00:00) 
[GCC 6.1.1 20160602] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print('Hello, World')
Hello, World
>>>

Alternativ können Sie die interaktive Eingabeaufforderung starten und die Datei mit python -i <file.py> .

Führen Sie in der Befehlszeile Folgendes aus:

$ python -i hello.py
"Hello World"
>>>

Es gibt mehrere Möglichkeiten, die Python-Shell zu schließen:

>>> exit()

oder

>>> quit()

Alternativ schließen Sie STRG + D die Shell und setzen Sie wieder in die Befehlszeile Ihres Terminals.

Wenn Sie einen Befehl abbrechen möchten, befinden Sie sich mitten in der Eingabe und kehren zu einer Eingabeaufforderung zum Reinigen zurück, während Sie sich in der Interpreter-Shell befinden, und drücken Sie STRG + C.

Testen Sie eine interaktive Python-Shell online .

Andere Online-Shells

Verschiedene Websites bieten Online-Zugriff auf Python-Shells.

Online-Shells können für folgende Zwecke nützlich sein:

• Führen Sie ein kleines Code-Snippet von einer Maschine aus, auf der Python-Installation fehlt (Smartphones, Tablets usw.).
• Lernen oder lehren Sie grundlegende Python.
• Lösen Sie Online-Richterprobleme.

Beispiele:

Haftungsausschluss: Dokumentationsautor (en) sind nicht mit den unten aufgeführten Ressourcen verbunden.

• https://www.python.org/shell/ - Die auf der offiziellen Python-Website gehostete Online-Python-Shell.
• https://ideone.com/ - Wird im Internet häufig verwendet, um das Verhalten von Codeausschnitten darzustellen.
• https://repl.it/languages/python3 - Leistungsfähiger und einfacher Online-Compiler, IDE und Interpreter. Code programmieren, kompilieren und Code in Python ausführen.
• https://www.tutorialspoint.com/execute_python_online.php - Eine voll funktionsfähige UNIX-Shell und ein benutzerfreundlicher Projektexplorer.
• http://rextester.com/l/python3_online_compiler - Einfache und benutzerfreundliche IDE, die die Ausführungszeit anzeigt

Befehle als String ausführen

Python kann beliebigen Code als String in der Shell übergeben werden:

$ python -c 'print("Hello, World")'
Hello, World

Dies kann hilfreich sein, wenn Sie die Ergebnisse von Skripts in der Shell miteinander verketten.

Muscheln und jenseits

Paketverwaltung - Das von PyPA empfohlene Werkzeug zum Installieren von Python-Paketen ist PIP . Zur Installation führen Sie auf Ihrer Kommandozeile pip install <the package name> . Zum Beispiel pip install numpy . (Hinweis: Unter Windows müssen Sie den PATH-Umgebungsvariablen pip hinzufügen. Um dies zu vermeiden, verwenden Sie python -m pip install <the package name> )

Shells - Bisher haben wir verschiedene Möglichkeiten zur Ausführung von Code mit Pythons nativer interaktiver Shell beschrieben. Shells verwenden Pythons Interpretationskraft, um mit Code in Echtzeit zu experimentieren. Zu den alternativen Shells gehören IDLE - eine vorgefertigte GUI, IPython -, die für die Erweiterung der interaktiven Erfahrung usw. bekannt ist.

Programme - Zur Langzeitspeicherung können Sie Inhalte in .py-Dateien speichern und als Skripte oder Programme mit externen Tools wie Shell, IDEs (wie PyCharm ), Jupyter-Notebooks usw. bearbeiten / ausführen. Benutzer mit Zwischenspeicher können diese Tools verwenden. Die hier besprochenen Methoden reichen jedoch für den Einstieg aus.

Mit dem Python-Tutor können Sie schrittweise durch den Python-Code navigieren, um zu visualisieren, wie das Programm abläuft, und hilft Ihnen zu verstehen, wo Ihr Programm fehlerhaft ist.

PEP8 definiert Richtlinien zum Formatieren von Python-Code. Das Formatieren von Code ist wichtig, damit Sie schnell lesen können, was der Code bewirkt.

Variablen anlegen und Werte zuweisen

Um eine Variable in Python zu erstellen, müssen Sie nur den Variablennamen angeben und dieser einen Wert zuweisen.

<variable name> = <value>

Python verwendet = , um Variablen Werte zuzuweisen. Es ist nicht erforderlich, eine Variable im Voraus zu deklarieren (oder ihr einen Datentyp zuzuweisen). Wenn Sie einer Variablen einen Wert zuweisen, deklariert und initialisiert sie die Variable mit diesem Wert. Es gibt keine Möglichkeit, eine Variable zu deklarieren, ohne ihr einen Anfangswert zuzuweisen.

# Integer
a = 2
print(a)
# Output: 2

# Integer    
b = 9223372036854775807
print(b)
# Output: 9223372036854775807

# Floating point
pi = 3.14
print(pi)
# Output: 3.14

# String
c = 'A'
print(c)
# Output: A

# String    
name = 'John Doe'
print(name)
# Output: John Doe

# Boolean    
q = True
print(q)
# Output: True

# Empty value or null data type
x = None
print(x)
# Output: None

Die variable Zuweisung funktioniert von links nach rechts. Im Folgenden erhalten Sie einen Syntaxfehler.

0 = x
=> Output: SyntaxError: can't assign to literal

Sie können die Schlüsselwörter von python nicht als gültigen Variablennamen verwenden. Sie können die Liste der Keywords anzeigen:

import keyword
print(keyword.kwlist)

Regeln für die Benennung von Variablen:

1. Variablennamen müssen mit einem Buchstaben oder einem Unterstrich beginnen.

 x  = True   # valid
 _y = True   # valid

 9x = False  # starts with numeral 
 => SyntaxError: invalid syntax   

 $y = False #  starts with symbol 
 => SyntaxError: invalid syntax

2. Der Rest Ihres Variablennamens kann aus Buchstaben, Zahlen und Unterstrichen bestehen.

has_0_in_it = "Still Valid" 

3. Namen sind case sensitive.

x = 9  
y = X*5   
=>NameError: name 'X' is not defined

Obwohl bei der Deklaration einer Variablen in Python kein Datentyp angegeben werden muss, während der erforderliche Speicherbereich für die Variable reserviert wird, wählt der Python-Interpreter automatisch den am besten geeigneten integrierten Typ dafür aus:

a = 2
print(type(a))
# Output: <type 'int'>

b = 9223372036854775807
print(type(b))
# Output: <type 'int'>

pi = 3.14
print(type(pi))
# Output: <type 'float'>

c = 'A'
print(type(c))
# Output: <type 'str'>

name = 'John Doe'
print(type(name))
# Output: <type 'str'>

q = True
print(type(q))
# Output: <type 'bool'>

x = None
print(type(x))
# Output: <type 'NoneType'>

Jetzt kennen Sie die Grundlagen der Zuweisung. Lassen Sie uns diese Feinheiten über die Zuweisung in Python aus dem Weg räumen.

Wenn Sie = für eine Zuweisungsoperation verwenden, ist links von = ein Name für das Objekt auf der rechten Seite. Schließlich , was = tut , ist die Referenz des Objekts auf der linken Seite auf der rechten Seite auf den Namen zuweisen.

Das ist:

a_name = an_object  # "a_name" is now a name for the reference to the object "an_object"

Wenn wir also aus vielen Zuordnungsbeispielen oben pi = 3.14 auswählen, ist pi ein Name (nicht der Name, da ein Objekt mehrere Namen haben kann) für das Objekt 3.14 . Wenn Sie unten etwas nicht verstehen, kommen Sie zu diesem Punkt zurück und lesen Sie das noch einmal! Sie können dies auch zum besseren Verständnis betrachten.

Sie können mehreren Variablen in einer Zeile mehrere Werte zuweisen. Beachten Sie, dass auf der rechten und linken Seite des Operators = die gleiche Anzahl von Argumenten vorhanden sein muss:

a, b, c = 1, 2, 3
print(a, b, c)
# Output: 1 2 3

a, b, c = 1, 2
=> Traceback (most recent call last):
=>   File "name.py", line N, in <module>
=>     a, b, c = 1, 2
=> ValueError: need more than 2 values to unpack

a, b = 1, 2, 3
=> Traceback (most recent call last):
=>   File "name.py", line N, in <module>
=>     a, b = 1, 2, 3
=> ValueError: too many values to unpack

Der Fehler im letzten Beispiel kann vermieden werden, indem der gleichen Anzahl von beliebigen Variablen verbleibende Werte zugewiesen werden. Diese Dummy-Variable kann einen beliebigen Namen haben, es ist jedoch üblich, den Unterstrich ( _ ) zum Zuweisen unerwünschter Werte zu verwenden:

a, b, _ = 1, 2, 3
print(a, b)
# Output: 1, 2

Beachten Sie, dass die Anzahl von _ und die Anzahl der verbleibenden Werte gleich sein müssen. Andernfalls wird "zu viele Werte zum Auspacken des Fehlers" wie oben ausgegeben:

a, b, _ = 1,2,3,4
=>Traceback (most recent call last):
=>File "name.py", line N, in <module>
=>a, b, _ = 1,2,3,4
=>ValueError: too many values to unpack (expected 3)

Sie können auch mehreren Variablen gleichzeitig einen einzelnen Wert zuweisen.

a = b = c = 1
print(a, b, c)
# Output: 1 1 1

Wenn Sie eine solche kaskadierende Zuweisung verwenden, ist es wichtig zu beachten, dass sich alle drei Variablen a , b und c auf dasselbe Objekt im Speicher beziehen, ein int Objekt mit dem Wert 1. Mit anderen Worten sind a , b und c drei verschiedene Namen auf dasselbe int Objekt gegeben. Wenn Sie einem Objekt anschließend ein anderes Objekt zuweisen, werden die anderen Objekte nicht wie erwartet geändert:

a = b = c = 1    # all three names a, b and c refer to same int object with value 1
print(a, b, c)
# Output: 1 1 1
b = 2            # b now refers to another int object, one with a value of 2
print(a, b, c)
# Output: 1 2 1  # so output is as expected.

Das Obige gilt auch für veränderliche Typen (wie list , dict usw.), ebenso wie für unveränderliche Typen (wie int , string , tuple usw.):

x = y = [7, 8, 9]   # x and y refer to the same list object just created, [7, 8, 9]
x = [13, 8, 9]      # x now refers to a different list object just created, [13, 8, 9]
print(y)            # y still refers to the list it was first assigned
# Output: [7, 8, 9]

So weit, ist es gut. Bei der Änderung des Objekts sieht die Sache etwas anders aus (im Gegensatz zur Zuweisung des Namens zu einem anderen Objekt, wie oben beschrieben), wenn die kaskadierende Zuordnung für veränderliche Typen verwendet wird. Schauen Sie unten, und Sie werden es aus erster Hand sehen:

x = y = [7, 8, 9]     # x and y are two different names for the same list object just created, [7, 8, 9]
x[0] = 13             # we are updating the value of the list [7, 8, 9] through one of its names, x in this case
print(y)              # printing the value of the list using its other name
# Output: [13, 8, 9]  # hence, naturally the change is reflected

Verschachtelte Listen sind auch in Python gültig. Das bedeutet, dass eine Liste eine andere Liste als Element enthalten kann.

x = [1, 2, [3, 4, 5], 6, 7] # this is nested list
print x[2]
# Output: [3, 4, 5]
print x[2][1]
# Output: 4

Schließlich müssen Variablen in Python nicht den Typ beibehalten, für den sie zuerst definiert wurden. Sie können einfach = , um einer Variablen einen neuen Wert zuzuweisen, selbst wenn dieser Wert einen anderen Typ hat.

a = 2 
print(a)
# Output: 2

a = "New value"
print(a)
# Output: New value

Wenn dies Sie stört, denken Sie darüber nach, dass das, was links von = ist, nur ein Name für ein Objekt ist. Zuerst Sie den Anruf int mit dem Wert 2 Objekt a , dann ändern Sie Ihre Meinung und entscheiden , den Namen zu geben , a zu einem string - Objekt, Wert ‚Neuer Wert‘ mit. Einfach, richtig?

Benutzereingabe

Interaktive Eingabe

Um vom Benutzer Eingaben zu erhalten, verwenden Sie die input ( Hinweis : In Python 2.x heißt die Funktion stattdessen raw_input , obwohl Python 2.x eine eigene input , die sich völlig unterscheidet):

name = raw_input("What is your name? ")
# Out: What is your name? _

name = input("What is your name? ")
# Out: What is your name? _

Der Rest dieses Beispiels verwendet die Python 3-Syntax.

Die Funktion nimmt ein Zeichenfolgenargument an, das es als Eingabeaufforderung anzeigt und eine Zeichenfolge zurückgibt. Der obige Code bietet eine Eingabeaufforderung, die auf die Eingabe des Benutzers wartet.

name = input("What is your name? ")
# Out: What is your name?

Wenn der Benutzer „Bob“ und Hits eingeben, der Variable name wird mit dem String zugewiesen werden "Bob" :

name = input("What is your name? ")
# Out: What is your name? Bob
print(name)
# Out: Bob

Beachten Sie, dass die input immer vom Typ str ist. str ist wichtig, wenn der Benutzer Zahlen eingeben soll. Daher müssen Sie den str konvertieren, bevor Sie ihn als Zahl verwenden str :

x = input("Write a number:")
# Out: Write a number: 10
x / 2
# Out: TypeError: unsupported operand type(s) for /: 'str' and 'int'
float(x) / 2
# Out: 5.0

Hinweis: Es wird empfohlen, try / except Blöcke zu verwenden, um Ausnahmen bei Benutzereingaben abzufangen . Wenn zum Beispiel Ihr Code einen raw_input in ein int umwandeln möchte und der Benutzer nichts zu schreiben hat, ist dies nicht der ValueError . Dies führt zu einem ValueError .

IDLE - Python-GUI

IDLE ist die integrierte Entwicklungs- und Lernumgebung von Python und ist eine Alternative zur Befehlszeile. Wie der Name schon sagt, ist IDLE sehr nützlich, um neuen Code zu entwickeln oder Python zu lernen. Unter Windows wird dieser mit dem Python-Interpreter ausgeliefert. Bei anderen Betriebssystemen müssen Sie ihn möglicherweise über Ihren Paketmanager installieren.

Die Hauptziele von IDLE sind:

• Texteditor für mehrere Fenster mit Syntaxhervorhebung, Autovervollständigung und intelligentem Einzug
• Python-Shell mit Syntaxhervorhebung
• Integrierter Debugger mit schrittweisen, dauerhaften Haltepunkten und Sichtbarkeit der Aufrufstapel
• Automatische Einrückung (nützlich für Anfänger, die etwas über Pythons Einzug erfahren)
• Speichern Sie das Python-Programm als .py-Dateien, führen Sie sie aus und bearbeiten Sie sie später mit IDLE.

Drücken Sie unter IDLE die Taste F5 oder run Python Shell , um einen Interpreter zu starten. Die Verwendung von IDLE kann für neue Benutzer eine bessere Lernerfahrung sein, da Code beim Schreiben des Benutzers interpretiert wird.

Beachten Sie, dass es viele Alternativen gibt, siehe zum Beispiel diese Diskussion oder diese Liste .

Fehlerbehebung

• Windows

  Unter Windows ist der Standardbefehl python . Wenn Sie den Fehler "'python' is not recognized" , liegt die wahrscheinlichste Ursache darin, dass sich der Ort von Python nicht in der Umgebungsvariablen PATH Ihres Systems befindet. Sie können auf diesen zugreifen, indem Sie mit der rechten Maustaste auf 'Arbeitsplatz' klicken und 'Eigenschaften' auswählen oder über 'Systemsteuerung' zu 'System' navigieren. Klicken Sie auf "Erweiterte Systemeinstellungen" und dann auf "Umgebungsvariablen ...". Bearbeiten Sie die PATH Variable, um das Verzeichnis Ihrer Python-Installation sowie den C:\Python27;C:\Python27\Scripts (normalerweise C:\Python27;C:\Python27\Scripts ) C:\Python27;C:\Python27\Scripts . Dies erfordert Administratorrechte und erfordert möglicherweise einen Neustart.

  Wenn Sie mehrere Versionen von Python auf demselben Computer verwenden, können Sie eine der python.exe Dateien umbenennen. Wenn Sie beispielsweise eine Version python27.exe python27 , wird python27 zum Python-Befehl für diese Version.

  Sie können auch den Python Launcher für Windows verwenden, der im Installationsprogramm verfügbar ist und standardmäßig enthalten ist. Sie können die Version von Python auswählen, indem Sie py -[xy] anstelle von python[xy] . Sie können die neueste Version von Python 2 verwenden, indem Sie Skripts mit py -2 und die neueste Version von Python 3 py -3 indem Sie Skripts mit py -3 .

• Debian / Ubuntu / MacOS

  In diesem Abschnitt wird davon ausgegangen, dass die Position der ausführbaren python Datei der Umgebungsvariablen PATH hinzugefügt wurde.

  Wenn Sie Debian / Ubuntu / MacOS verwenden, öffnen Sie das Terminal und geben Sie python für Python 2.x oder python3 für Python 3.x ein.

  Geben Sie which python zu sehen, welcher Python-Interpreter verwendet wird.

• Arch Linux

  Der Standard-Python für Arch Linux (und seine Nachkommen) ist Python 3. Verwenden Sie daher python oder python3 für Python 3.x und python2 für Python 2.x.

• Andere Systeme

  Python 3 ist manchmal an python statt an python3 gebunden. Um Python 2 auf diesen Systemen, auf denen es installiert ist, zu verwenden, können Sie python2 .

Datentypen

Eingebaute Typen

Booleaner

bool : Ein boolescher Wert von " True oder " False . Logische Operationen wie and , or , not auf booleans durchgeführt werden.

x or y    # if x is False then y otherwise x 
x and y   # if x is False then x otherwise y
not x     # if x is True then False, otherwise True

In Python 2.x und Python 3.x ist ein Boolean auch ein int . Der bool Typ ist eine Unterklasse des int Typs, und True und False sind die einzigen Instanzen:

issubclass(bool, int) # True

isinstance(True, bool) # True
isinstance(False, bool) # True

Wenn boolesche Werte in arithmetischen Operationen verwendet werden, werden ihre ganzzahligen Werte ( 1 und 0 für True und False ) verwendet, um ein ganzzahliges Ergebnis zurückzugeben:

True + False == 1 # 1 + 0 == 1
True * True  == 1 # 1 * 1 == 1

Zahlen

• int : Ganzzahl

  a = 2
  b = 100
  c = 123456789
  d = 38563846326424324
  

  Ganzzahlen in Python sind von beliebiger Größe.

  Hinweis: In älteren Versionen von Python war ein long Typ verfügbar, der sich von int . Die beiden wurden vereinheitlicht.

• float : Fließkommazahl; Die Genauigkeit hängt von der Implementierung und der Systemarchitektur ab. Bei CPython entspricht der float Datentyp einem C-Double.

  a = 2.0
  b = 100.e0
  c = 123456789.e1
  

• complex : Komplexe Zahlen

  a = 2 + 1j
  b = 100 + 10j
  

Die Operatoren < , <= , > und >= TypeError eine TypeError Exception aus, wenn ein Operand eine komplexe Zahl ist.

Zeichenketten

Sequenzen und Sammlungen

Python unterscheidet zwischen geordneten Sequenzen und ungeordneten Sammlungen (wie set und dict ).

• Zeichenfolgen ( str , bytes , unicode ) sind Sequenzen

• reversed : Eine umgekehrte Reihenfolge von str mit reversed Funktion

  a = reversed('hello')
  

• tuple : Eine geordnete Sammlung von n Werten eines beliebigen Typs ( n >= 0 ).

  a = (1, 2, 3)
  b = ('a', 1, 'python', (1, 2))
  b[2] = 'something else' # returns a TypeError
  

  Unterstützt die Indizierung; unveränderlich; hashable, wenn alle seine Mitglieder hashable sind

• list : Eine geordnete Sammlung von n Werten ( n >= 0 )

  a = [1, 2, 3]
  b = ['a', 1, 'python', (1, 2), [1, 2]]
  b[2] = 'something else' # allowed
  

  Nicht hashbar; veränderlich.

• set : Eine ungeordnete Sammlung eindeutiger Werte. Elemente müssen hashbar sein .

  a = {1, 2, 'a'}
  

• dict : Eine ungeordnete Sammlung eindeutiger Schlüssel-Wert-Paare. Schlüssel müssen hashbar sein .

  a = {1: 'one',
       2: 'two'}
  
  b = {'a': [1, 2, 3],
       'b': 'a string'}
  

Ein Objekt ist hashbar, wenn es einen Hashwert hat, der sich während seiner Lebensdauer niemals ändert (es benötigt eine __hash__() Methode) und kann mit anderen Objekten verglichen werden (es benötigt eine __eq__() Methode). Hashfähige Objekte, die Gleichheit vergleichen, müssen denselben Hashwert haben.

Eingebaute Konstanten

In Verbindung mit den integrierten Datentypen gibt es eine kleine Anzahl von eingebauten Konstanten im integrierten Namespace:

• True : Der wahre Wert des eingebauten bool
• False : Der False-Wert des integrierten Typs bool
• None : Ein Einzelobjekt, das signalisiert, dass ein Wert nicht vorhanden ist.
• Ellipsis oder ... : Wird in Core Python3 + überall und in Python2.7 + als Teil der Array-Notation verwendet. numpy und verwandte Pakete verwenden dies als Referenz für "alles einschließen" in Arrays.
• NotImplemented : Ein Singleton, der Python NotImplemented , dass eine spezielle Methode die bestimmten Argumente nicht unterstützt, und Python versucht Alternativen, falls verfügbar.

a = None # No value will be assigned. Any valid datatype can be assigned later

Testen des Variablentyps

In Python können wir den Datentyp eines Objekts überprüfen Sie die integrierte Funktion mit type .

a = '123'
print(type(a))
# Out: <class 'str'>
b = 123
print(type(b))
# Out: <class 'int'>

In Bedingungsanweisungen ist es möglich, den Datentyp mit einer isinstance zu testen. Es wird jedoch normalerweise nicht empfohlen, sich auf den Typ der Variablen zu verlassen.

i = 7
if isinstance(i, int):
    i += 1
elif isinstance(i, str):
    i = int(i)
    i += 1

Informationen zu den Unterschieden zwischen type() und isinstance() Sie unter: Unterschiede zwischen isinstance und type in Python

So testen Sie, ob etwas von NoneType :

x = None
if x is None:
    print('Not a surprise, I just defined x as None.')

Konvertierung zwischen Datentypen

Sie können eine explizite Datentypkonvertierung durchführen.

Zum Beispiel ist '123' vom Typ str und kann mit int Funktion in eine Ganzzahl umgewandelt werden.

a = '123'
b = int(a)

Die Konvertierung von einem Float-String wie '123.456' kann mit der float Funktion erfolgen.

a = '123.456'
b = float(a)
c = int(a)    # ValueError: invalid literal for int() with base 10: '123.456'
d = int(b)    # 123

Sie können auch Sequenz- oder Sammlungstypen konvertieren

a = 'hello'
list(a)  # ['h', 'e', 'l', 'l', 'o']
set(a)   # {'o', 'e', 'l', 'h'}
tuple(a) # ('h', 'e', 'l', 'l', 'o')

Expliziter Zeichenfolgentyp bei der Definition von Literalen

Mit einem Buchstaben vor den Anführungszeichen können Sie feststellen, welche Art von Zeichenfolge Sie definieren möchten.

• b'foo bar' : Ergebnisse bytes in Python 3 str in Python 2
• u'foo bar' : Ergebnisse str in Python 3, unicode in Python 2
• 'foo bar' : Ergebnisse str
• r'foo bar' : führt zu einer so genannten rohen Zeichenfolge, bei der das r'foo bar' Sonderzeichen nicht erforderlich ist. Während der Eingabe wird alles wörtlich genommen

normal  = 'foo\nbar'   # foo
                       # bar
escaped = 'foo\\nbar'  # foo\nbar   
raw     = r'foo\nbar'  # foo\nbar

Veränderliche und unveränderliche Datentypen

Ein Objekt wird als veränderlich bezeichnet, wenn es geändert werden kann. Wenn Sie beispielsweise eine Liste an eine Funktion übergeben, kann die Liste geändert werden:

def f(m):
    m.append(3)  # adds a number to the list. This is a mutation.

x = [1, 2]
f(x)
x == [1, 2]  # False now, since an item was added to the list

Ein Objekt wird als unveränderlich bezeichnet, wenn es in keiner Weise geändert werden kann. Zum Beispiel sind Ganzzahlen unveränderlich, da sie nicht geändert werden können:

def bar():
    x = (1, 2)
    g(x)
    x == (1, 2)  # Will always be True, since no function can change the object (1, 2)

Beachten Sie, dass Variablen selbst veränderbar sind, sodass wir die Variable x neu zuweisen können. Dies ändert jedoch nicht das Objekt, auf das x zuvor gezeigt hat. Es wurde nur x auf ein neues Objekt gesetzt.

Datentypen, deren Instanzen veränderlich sind, werden als veränderliche Datentypen bezeichnet und für unveränderliche Objekte und Datentypen gleichermaßen.

Beispiele für unveränderliche Datentypen:

• int , long , float , complex
• str
• bytes
• tuple
• frozenset

Beispiele für veränderliche Datentypen:

• bytearray
• list
• set
• dict

Eingebaute Module und Funktionen

Ein Modul ist eine Datei, die Python-Definitionen und Anweisungen enthält. Funktion ist ein Stück Code, der einige Logik ausführt.

>>> pow(2,3)    #8

Um die eingebaute Funktion in Python zu überprüfen, können wir dir(). Wenn Sie ohne Argument aufgerufen werden, geben Sie die Namen im aktuellen Bereich zurück. Andernfalls wird eine alphabetische Liste von Namen zurückgegeben, die (einige) das Attribut des angegebenen Objekts sowie die von ihm erreichbaren Attribute enthalten.

>>> dir(__builtins__)
[
    'ArithmeticError', 
    'AssertionError', 
    'AttributeError', 
    'BaseException', 
    'BufferError', 
    'BytesWarning', 
    'DeprecationWarning', 
    'EOFError', 
    'Ellipsis', 
    'EnvironmentError', 
    'Exception', 
    'False', 
    'FloatingPointError', 
    'FutureWarning', 
    'GeneratorExit', 
    'IOError', 
    'ImportError', 
    'ImportWarning', 
    'IndentationError', 
    'IndexError', 
    'KeyError', 
    'KeyboardInterrupt', 
    'LookupError', 
    'MemoryError', 
    'NameError', 
    'None', 
    'NotImplemented', 
    'NotImplementedError', 
    'OSError', 
    'OverflowError', 
    'PendingDeprecationWarning', 
    'ReferenceError', 
    'RuntimeError', 
    'RuntimeWarning', 
    'StandardError', 
    'StopIteration', 
    'SyntaxError', 
    'SyntaxWarning', 
    'SystemError', 
    'SystemExit', 
    'TabError', 
    'True', 
    'TypeError', 
    'UnboundLocalError', 
    'UnicodeDecodeError', 
    'UnicodeEncodeError', 
    'UnicodeError', 
    'UnicodeTranslateError', 
    'UnicodeWarning', 
    'UserWarning', 
    'ValueError', 
    'Warning', 
    'ZeroDivisionError', 
    '__debug__', 
    '__doc__', 
    '__import__', 
    '__name__', 
    '__package__', 
    'abs', 
    'all', 
    'any', 
    'apply', 
    'basestring', 
    'bin', 
    'bool', 
    'buffer', 
    'bytearray', 
    'bytes', 
    'callable', 
    'chr', 
    'classmethod', 
    'cmp', 
    'coerce', 
    'compile', 
    'complex', 
    'copyright', 
    'credits', 
    'delattr', 
    'dict', 
    'dir', 
    'divmod', 
    'enumerate', 
    'eval', 
    'execfile', 
    'exit', 
    'file', 
    'filter', 
    'float', 
    'format', 
    'frozenset', 
    'getattr', 
    'globals', 
    'hasattr', 
    'hash', 
    'help', 
    'hex', 
    'id', 
    'input', 
    'int', 
    'intern', 
    'isinstance', 
    'issubclass', 
    'iter', 
    'len', 
    'license', 
    'list', 
    'locals', 
    'long', 
    'map', 
    'max', 
    'memoryview', 
    'min', 
    'next', 
    'object', 
    'oct', 
    'open', 
    'ord', 
    'pow', 
    'print', 
    'property', 
    'quit', 
    'range', 
    'raw_input', 
    'reduce', 
    'reload', 
    'repr', 
    'reversed', 
    'round', 
    'set', 
    'setattr', 
    'slice', 
    'sorted', 
    'staticmethod', 
    'str', 
    'sum', 
    'super', 
    'tuple', 
    'type', 
    'unichr', 
    'unicode', 
    'vars', 
    'xrange', 
    'zip'
]

Um die Funktionalität einer beliebigen Funktion kennen, können wir in Funktion nutzen gebaut help .

>>> help(max)
Help on built-in function max in module __builtin__:
max(...)
    max(iterable[, key=func]) -> value
    max(a, b, c, ...[, key=func]) -> value
    With a single iterable argument, return its largest item.
    With two or more arguments, return the largest argument.

Eingebaute Module enthalten zusätzliche Funktionalitäten. Um beispielsweise Quadratwurzeln einer Zahl zu erhalten, müssen wir ein math hinzufügen.

>>> import math
>>> math.sqrt(16) # 4.0

Um alle Funktionen in einem Modul zu kennen, können wir die Funktionsliste einer Variablen zuweisen und dann die Variable drucken.

>>> import math
>>> dir(math)

   ['__doc__', '__name__', '__package__', 'acos', 'acosh', 
   'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 
   'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 
   'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 
   'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 
   'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 
   'tan', 'tanh', 'trunc']

Es scheint, dass __doc__ nützlich ist, um beispielsweise in Funktionen einige Dokumentation bereitzustellen

>>> math.__doc__
'This module is always available.  It provides access to the\nmathematical
 functions defined by the C standard.'

Neben Funktionen kann Dokumentation auch in Modulen bereitgestellt werden. Wenn Sie also eine Datei namens helloWorld.py wie helloWorld.py :

"""This is the module docstring."""

def sayHello():
    """This is the function docstring."""
    return 'Hello World'

Sie können auf die Dokumentstrings folgendermaßen zugreifen:

>>> import helloWorld
>>> helloWorld.__doc__
'This is the module docstring.'
>>> helloWorld.sayHello.__doc__
'This is the function docstring.'

• Für jeden benutzerdefinierten Typ können seine Attribute, die Attribute seiner Klasse und rekursiv die Attribute der Basisklassen seiner Klasse mit dir () abgerufen werden.

>>> class MyClassObject(object):
...     pass
... 
>>> dir(MyClassObject)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']

Jeder Datentyp kann einfach mit einer eingebauten Funktion namens str in String konvertiert werden. Diese Funktion wird standardmäßig aufgerufen, wenn ein Datentyp an den print

>>> str(123)    # "123"

Einrückung blockieren

Python verwendet Einrückungen zum Definieren von Steuerungs- und Schleifenkonstrukten. Dies trägt zur Lesbarkeit von Python bei, erfordert jedoch, dass der Programmierer der Verwendung von Leerzeichen große Aufmerksamkeit widmet. Die Fehlkalibrierung des Editors kann daher zu Code führen, der sich unerwartet verhält.

Python verwendet das Doppelpunkt - Zeichen ( : ) und Vertiefung zu zeigen , wo Codeblocks beginnen und enden (Wenn Sie aus einer anderen Sprache kommen, nicht zu verwechseln diese mit irgendwie mit dem zusammenhängt ternären Operator ). Das heißt, Blöcke in Python, wie z. B. Funktionen, Schleifen, if Klauseln und andere Konstrukte, haben keine Endekennungen. Alle Blöcke beginnen mit einem Doppelpunkt und enthalten dann die eingerückten Zeilen darunter.

Zum Beispiel:

def my_function():    # This is a function definition. Note the colon (:)
    a = 2             # This line belongs to the function because it's indented
    return a          # This line also belongs to the same function
print(my_function())  # This line is OUTSIDE the function block

oder

if a > b:             # If block starts here
    print(a)          # This is part of the if block
else:                 # else must be at the same level as if
    print(b)          # This line is part of the else block

Blöcke, die genau eine einzeilige Anweisung enthalten, können in dieselbe Zeile eingefügt werden, obwohl dieses Formular im Allgemeinen nicht als guter Stil gilt:

if a > b: print(a)
else: print(b)  

Der Versuch, dies mit mehr als einer einzelnen Anweisung zu tun, funktioniert nicht :

if x > y: y = x
    print(y) # IndentationError: unexpected indent

if x > y: while y != z: y -= 1  # SyntaxError: invalid syntax

Ein leerer Block verursacht einen IndentationError . Verwenden Sie pass (ein Befehl, der nichts tut), wenn Sie einen Block ohne Inhalt haben:

def will_be_implemented_later():
    pass

Leerzeichen vs. Tabs

Kurz gesagt: Verwenden Sie immer 4 Felder für die Einrückung.

Die ausschließliche Verwendung von Registerkarten ist möglich, PEP 8 , der Style-Guide für Python-Code, besagt, dass Leerzeichen bevorzugt werden.

Viele Editoren haben "Tabs to Spaces" -Konfiguration. Wenn Sie den Editor konfiguriert, sollte man zwischen den Tab - Zeichen ( ‚\ t‘) und der Tab - Taste unterscheiden.

• Die Tabulatorzeichen sollten zu zeigen , 8 Räume so konfiguriert werden, um die Sprachsemantik entsprechen - zumindest in den Fällen , wenn (versehentliche) gemischte Einrückung möglich ist. Editoren können das Tabulatorzeichen auch automatisch in Leerzeichen umwandeln.
• Es kann jedoch hilfreich sein, den Editor so zu konfigurieren, dass durch Drücken der Tabulatortaste 4 Leerzeichen anstelle eines Tabulatorzeichens eingefügt werden.

Python Quellcode mit einer Mischung aus tabs geschrieben und Räumen oder mit Nicht-Standard - Zahl der Einrückung Räume kann Pep8-konforme Verwendung gemacht werden autopep8 . (Eine weniger leistungsfähige Alternative ist bei den meisten Python-Installationen enthalten: reindent.py. )

Auflistungsarten

Es gibt eine Reihe von Auflistungstypen in Python. Während Typen wie int und str einen einzelnen Wert enthalten, enthalten Auflistungstypen mehrere Werte.

Listen

Der list ist wahrscheinlich der am häufigsten verwendete Auflistungstyp in Python. Trotz ihres Namens ähnelt eine Liste eher einem Array in anderen Sprachen, meistens JavaScript. In Python ist eine Liste lediglich eine geordnete Sammlung gültiger Python-Werte. Eine Liste kann erstellt werden, indem Werte, die durch Kommas getrennt sind, in eckige Klammern gesetzt werden:

int_list = [1, 2, 3]
string_list = ['abc', 'defghi']

Eine Liste kann leer sein:

empty_list = []

Die Elemente einer Liste sind nicht auf einen einzelnen Datentyp beschränkt. Dies ist sinnvoll, wenn Python eine dynamische Sprache ist:

mixed_list = [1, 'abc', True, 2.34, None]

Eine Liste kann eine andere Liste als Element enthalten:

nested_list = [['a', 'b', 'c'], [1, 2, 3]]

Auf die Elemente einer Liste kann über einen Index oder eine numerische Darstellung ihrer Position zugegriffen werden. Listen in Python sind nullindiziert, was bedeutet, dass das erste Element in der Liste den Index 0 hat, das zweite Element den Index 1 und so weiter:

names = ['Alice', 'Bob', 'Craig', 'Diana', 'Eric']
print(names[0]) # Alice
print(names[2]) # Craig

Indizes können auch negativ sein, dh ab dem Ende der Liste zählen ( -1 ist der Index des letzten Elements). Verwenden Sie also die Liste aus dem obigen Beispiel:

print(names[-1]) # Eric
print(names[-4]) # Bob

Listen sind veränderbar, sodass Sie die Werte in einer Liste ändern können:

names[0] = 'Ann'
print(names)
# Outputs ['Ann', 'Bob', 'Craig', 'Diana', 'Eric']

Außerdem können Sie Elemente zu einer Liste hinzufügen und / oder daraus entfernen:

Objekt mit L.append(object) an das Ende der Liste L.append(object) , gibt None .

names = ['Alice', 'Bob', 'Craig', 'Diana', 'Eric']
names.append("Sia")
print(names) 
# Outputs ['Alice', 'Bob', 'Craig', 'Diana', 'Eric', 'Sia']

Fügen Sie ein neues Element zur Liste an einem bestimmten Index hinzu. L.insert(index, object)

names.insert(1, "Nikki")
print(names)
# Outputs ['Alice', 'Nikki', 'Bob', 'Craig', 'Diana', 'Eric', 'Sia']

Entfernen Sie das erste Vorkommen eines Werts mit L.remove(value) None

names.remove("Bob")
print(names) # Outputs ['Alice', 'Nikki', 'Craig', 'Diana', 'Eric', 'Sia']

Rufen Sie den Index in der Liste des ersten Elements ab, dessen Wert x ist. Wenn kein solcher Artikel vorhanden ist, wird ein Fehler angezeigt.

name.index("Alice")
0

Länge der Liste zählen

len(names)
6

Zählen Sie das Vorkommen eines Elements in der Liste

a = [1, 1, 1, 2, 3, 4]
a.count(1)
3

Kehren Sie die Liste um

a.reverse()
[4, 3, 2, 1, 1, 1]
# or
a[::-1]
[4, 3, 2, 1, 1, 1]

Artikel mit Index L.pop([index]) der letzte Artikel) mit L.pop([index]) und den Artikel zurückgeben

names.pop() # Outputs 'Sia'

Sie können die Listenelemente wie folgt durchlaufen:

for element in my_list:
    print (element)

Tuples

Ein tuple ähnelt einer Liste mit der Ausnahme, dass es eine feste Länge und unveränderlich ist. Daher können die Werte im Tupel nicht geändert werden, und die Werte können nicht zum Tupel hinzugefügt oder daraus entfernt werden. Tupel werden im Allgemeinen für kleine Sammlungen von Werten verwendet, die nicht geändert werden müssen, z. B. eine IP-Adresse und einen Port. Tupel werden mit Klammern anstelle von eckigen Klammern dargestellt:

ip_address = ('10.20.30.40', 8080)

Die gleichen Indexierungsregeln für Listen gelten auch für Tupel. Tupel können auch verschachtelt sein und die Werte können alle gültigen gültigen Python-Werte sein.

Ein Tupel mit nur einem Member muss folgendermaßen definiert werden (beachten Sie das Komma):

one_member_tuple = ('Only member',)

oder

one_member_tuple = 'Only member',   # No brackets

oder einfach mit der tuple

one_member_tuple = tuple(['Only member'])

Wörterbücher

Ein dictionary in Python ist eine Sammlung von Schlüssel-Wert-Paaren. Das Wörterbuch ist von geschweiften Klammern umgeben. Jedes Paar wird durch ein Komma getrennt, und der Schlüssel und der Wert werden durch einen Doppelpunkt getrennt. Hier ist ein Beispiel:

state_capitals = {
    'Arkansas': 'Little Rock',
    'Colorado': 'Denver',
    'California': 'Sacramento', 
    'Georgia': 'Atlanta'
}

Um einen Wert zu erhalten, beziehen Sie sich auf seinen Schlüssel:

ca_capital = state_capitals['California']

Sie können auch alle Schlüssel in einem Wörterbuch abrufen und diese dann durchlaufen:

for k in state_capitals.keys():
    print('{} is the capital of {}'.format(state_capitals[k], k))

Wörterbücher ähneln stark der JSON-Syntax. Das native json Modul in der Python-Standardbibliothek kann zum Konvertieren zwischen JSON und Wörterbüchern verwendet werden.

einstellen

Ein set ist eine Sammlung von Elementen ohne Wiederholungen und ohne Einfügereihenfolge, aber sortierte Reihenfolge. Sie werden in Situationen verwendet, in denen es nur wichtig ist, dass einige Dinge zusammengruppiert werden und nicht in welcher Reihenfolge. Bei großen Datengruppen ist es viel schneller zu prüfen, ob ein Element in einer set ist oder nicht set als dasselbe für eine list .

Das Definieren eines set ist dem Definieren eines dictionary sehr ähnlich:

first_names = {'Adam', 'Beth', 'Charlie'}

Oder Sie können einen set mit einer vorhandenen list erstellen:

my_list = [1,2,3]
my_set = set(my_list)

Überprüfen Sie die Mitgliedschaft in der set mit in :

if name in first_names:
    print(name)

Sie können eine set genau wie eine Liste durchlaufen, aber denken Sie daran: Die Werte werden in einer beliebigen, von der Implementierung definierten Reihenfolge angezeigt.

defaultdict

Ein defaultdict ist ein Wörterbuch mit einem Standardwert für Schlüssel, sodass auf Schlüssel, für die kein expliziter Wert definiert wurde, fehlerfrei zugegriffen werden kann. defaultdict ist besonders nützlich, wenn es sich bei den Werten im Wörterbuch um Sammlungen (Listen, Diagramme usw.) handelt, die nicht jedes Mal initialisiert werden müssen, wenn ein neuer Schlüssel verwendet wird.

Ein defaultdict niemals einen KeyError aus. Für einen nicht vorhandenen Schlüssel wird der Standardwert zurückgegeben.

Betrachten Sie beispielsweise das folgende Wörterbuch

>>> state_capitals = {
    'Arkansas': 'Little Rock',
    'Colorado': 'Denver',
    'California': 'Sacramento', 
    'Georgia': 'Atlanta'
}

Wenn wir versuchen, auf einen nicht vorhandenen Schlüssel zuzugreifen, gibt Python einen Fehler wie folgt zurück

>>> state_capitals['Alabama']
Traceback (most recent call last):

  File "<ipython-input-61-236329695e6f>", line 1, in <module>
    state_capitals['Alabama']

KeyError: 'Alabama'

Versuchen wir es mit einem defaultdict . Es befindet sich im Kollektionsmodul.

>>> from collections import defaultdict
>>> state_capitals = defaultdict(lambda: 'Boston')

Wir haben hier einen Standardwert ( Boston ) festgelegt, falls der Schlüssel nicht vorhanden ist. Füllen Sie nun das Diktat wie zuvor:

>>> state_capitals['Arkansas'] = 'Little Rock'
>>> state_capitals['California'] = 'Sacramento'
>>> state_capitals['Colorado'] = 'Denver'
>>> state_capitals['Georgia'] = 'Atlanta'

Wenn wir versuchen, mit einem nicht vorhandenen Schlüssel auf das Diktat zuzugreifen, gibt Python den Standardwert zurück, z. B. Boston

>>> state_capitals['Alabama']
'Boston'

und gibt die erstellten Werte für einen vorhandenen Schlüssel wie ein normales dictionary

>>> state_capitals['Arkansas']
'Little Rock'

Hilfsprogramm

Python hat mehrere Funktionen, die in den Interpreter integriert sind. Wenn Sie Informationen zu Schlüsselwörtern, integrierten Funktionen, Modulen oder Themen erhalten möchten, öffnen Sie eine Python-Konsole und geben Sie Folgendes ein:

>>> help()

Sie erhalten Informationen, indem Sie die Schlüsselwörter direkt eingeben:

>>> help(help)

oder innerhalb des Dienstprogramms:

help> help

die eine Erklärung zeigen wird:

Help on _Helper in module _sitebuiltins object:

class _Helper(builtins.object)
 |  Define the builtin 'help'.
 |  
 |  This is a wrapper around pydoc.help that provides a helpful message
 |  when 'help' is typed at the Python interactive prompt.
 |  
 |  Calling help() at the Python prompt starts an interactive help session.
 |  Calling help(thing) prints help for the python object 'thing'.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, *args, **kwds)
 |  
 |  __repr__(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)

Sie können auch Unterklassen von Modulen anfordern:

help(pymysql.connections)

Sie können die Hilfe verwenden, um auf die Dokumentfolgen der verschiedenen importierten Module zuzugreifen. Versuchen Sie beispielsweise Folgendes:

>>> help(math)

und Sie erhalten einen Fehler

>>> import math
>>> help(math)

Nun erhalten Sie eine Liste der verfügbaren Methoden im Modul, jedoch erst, nachdem Sie es importiert haben.

Schließen Sie den Helfer mit quit

Ein Modul erstellen

Ein Modul ist eine importierbare Datei, die Definitionen und Anweisungen enthält.

Ein Modul kann durch Erstellen einer .py Datei erstellt werden.

# hello.py
def say_hello():
    print("Hello!")

Funktionen in einem Modul können durch Importieren des Moduls verwendet werden.

Für von Ihnen erstellte Module müssen sich diese im selben Verzeichnis befinden wie die Datei, in die Sie sie importieren. (Sie können sie jedoch auch mit den im Lieferumfang enthaltenen Modulen im Python-Verzeichnis lib ablegen, sollten aber möglichst vermieden werden.)

$ python
>>> import hello
>>> hello.say_hello()
=> "Hello!"

Module können von anderen Modulen importiert werden.

# greet.py
import hello
hello.say_hello()

Bestimmte Funktionen eines Moduls können importiert werden.

# greet.py
from hello import say_hello
say_hello()

Module können Aliasing sein.

# greet.py
import hello as ai
ai.say_hello()

Ein Modul kann ein eigenständiges ausführbares Skript sein.

# run_hello.py
if __name__ == '__main__':
    from hello import say_hello
    say_hello()

Starte es!

$ python run_hello.py
=> "Hello!"

Wenn sich das Modul in einem Verzeichnis befindet und von Python erkannt werden muss, sollte das Verzeichnis eine Datei mit dem Namen __init__.py .

String-Funktion - str () und repr ()

Es gibt zwei Funktionen, mit denen eine lesbare Darstellung eines Objekts erhalten werden kann.

repr(x) ruft x.__repr__() : eine Darstellung von x . eval konvertiert das Ergebnis dieser Funktion normalerweise zurück in das ursprüngliche Objekt.

str(x) ruft x.__str__() : Eine vom Menschen lesbare Zeichenfolge, die das Objekt beschreibt. Dies kann einige technische Details auslassen.

repr ()

Bei vielen Typen versucht diese Funktion, eine Zeichenfolge zurückzugeben, die ein Objekt mit demselben Wert ergibt, wenn es an eval() . Ansonsten handelt es sich bei der Darstellung um eine in spitze Klammern eingeschlossene Zeichenfolge, die den Namen des Objekttyps sowie zusätzliche Informationen enthält. Dies beinhaltet häufig den Namen und die Adresse des Objekts.

str ()

Bei Strings wird der String selbst zurückgegeben. Der Unterschied zwischen diesem und repr(object) besteht darin, dass str(object) nicht immer versucht, einen String zurückzugeben, der für eval() zulässig ist. Vielmehr ist es das Ziel, eine druckbare oder "lesbare" Zeichenfolge zurückzugeben. Wenn kein Argument angegeben ist, wird der leere String '' .

Beispiel 1:

s = """w'o"w"""
repr(s) # Output: '\'w\\\'o"w\''  
str(s)  # Output: 'w\'o"w'
eval(str(s)) == s  # Gives a SyntaxError 
eval(repr(s)) == s # Output: True

Beispiel 2

import datetime
today = datetime.datetime.now()
str(today)  # Output: '2016-09-15 06:58:46.915000'
repr(today) # Output: 'datetime.datetime(2016, 9, 15, 6, 58, 46, 915000)'

Beim Schreiben einer Klasse können Sie diese Methoden überschreiben, um zu tun, was Sie möchten:

class Represent(object):

    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):
        return "Represent(x={},y=\"{}\")".format(self.x, self.y)

    def __str__(self):
        return "Representing x as {} and y as {}".format(self.x, self.y)

Mit der obigen Klasse können wir die Ergebnisse sehen:

r = Represent(1, "Hopper")
print(r)  # prints __str__
print(r.__repr__)  # prints __repr__: '<bound method Represent.__repr__ of Represent(x=1,y="Hopper")>'
rep = r.__repr__()  # sets the execution of __repr__ to a new variable
print(rep)  # prints 'Represent(x=1,y="Hopper")'
r2 = eval(rep) # evaluates rep
print(r2)  # prints __str__ from new object
print(r2 == r)  # prints 'False' because they are different objects

Installation externer Module mit pip

pip ist dein Freund, wenn du ein Paket aus der Fülle von Auswahlmöglichkeiten im python package index (PyPI) installieren musst. pip ist bereits installiert, wenn Sie Python 2> = 2.7.9 oder Python 3> = 3.4 verwenden, das von python.org heruntergeladen wurde. Bei Computern mit Linux oder einem anderen * nix mit einem systemeigenen Paketmanager muss pip häufig manuell installiert werden.

Bei Instanzen, auf denen sowohl Python 2 als auch Python 3 installiert sind, bezieht sich pip häufig auf Python 2 und pip3 auf Python 3. Bei der Verwendung von pip werden nur Pakete für Python 2 installiert, und pip3 installiert nur Pakete für Python 3.

Paket suchen / installieren

Die Suche nach einem Paket ist so einfach wie das Tippen

$ pip search <query>
# Searches for packages whose name or summary contains <query>

Das Installieren eines Pakets ist so einfach wie das Eintippen (in einer Terminal- / Eingabeaufforderung, nicht im Python-Interpreter).

$ pip install [package_name]           # latest version of the package

$ pip install [package_name]==x.x.x    # specific version of the package

$ pip install '[package_name]>=x.x.x'  # minimum version of the package

Dabei ist xxx die Versionsnummer des Pakets, das Sie installieren möchten.

Wenn sich Ihr Server hinter einem Proxy befindet, können Sie das Paket mit dem folgenden Befehl installieren:

$ pip --proxy http://<server address>:<port> install

Installierte Pakete aktualisieren

Wenn neue Versionen installierter Pakete angezeigt werden, werden sie nicht automatisch auf Ihrem System installiert. Um einen Überblick darüber zu erhalten, welche Ihrer installierten Pakete veraltet sind, führen Sie Folgendes aus:

$ pip list --outdated

Um ein bestimmtes Paket zu aktualisieren, verwenden Sie

$ pip install [package_name] --upgrade

Das Aktualisieren aller veralteten Pakete ist keine Standardfunktion von pip .

Pip aufrüsten

Sie können Ihre vorhandene Pip-Installation mit den folgenden Befehlen aktualisieren

• Unter Linux oder Mac OS X:

  $ pip install -U pip
  

  Möglicherweise müssen Sie sudo with pip auf einigen Linux-Systemen verwenden

• Unter Windows:

  py -m pip install -U pip
  

  oder

  python -m pip install -U pip
  

Weitere Informationen zu pip finden Sie hier .

Installation von Python 2.7.x und 3.x

Hinweis : Die folgenden Anweisungen werden für Python 2.7 geschrieben (sofern nicht anders angegeben): Anweisungen für Python 3.x sind ähnlich.

WINDOWS

Laden Sie zunächst die neueste Version von Python 2.7 von der offiziellen Website ( https://www.python.org/downloads/) herunter. Die Version wird als MSI-Paket bereitgestellt. Um es manuell zu installieren, doppelklicken Sie einfach auf die Datei.

Standardmäßig wird Python in einem Verzeichnis installiert:

 C:\Python27\

Warnung: Die Installation ändert die Umgebungsvariable PATH nicht automatisch.

Angenommen, Ihre Python-Installation befindet sich in C: \ Python27, und fügen Sie dies zu Ihrem PFAD hinzu:

C:\Python27\;C:\Python27\Scripts\

Um zu prüfen, ob die Python-Installation gültig ist, schreiben Sie in cmd:

python --version

Python 2.x und 3.x Seite an Seite

So installieren und verwenden Sie Python 2.x und 3.x nebeneinander auf einem Windows-Computer:

1. Installieren Sie Python 2.x mit dem MSI-Installationsprogramm.

   • Stellen Sie sicher, dass Python für alle Benutzer installiert ist.
   • Optional: Fügen Sie Python zu PATH , damit Python 2.x von der Befehlszeile aus mit python .

2. Installieren Sie Python 3.x mit dem entsprechenden Installationsprogramm.

   • Stellen Sie erneut sicher, dass Python für alle Benutzer installiert ist.
   • Optional: Fügen Sie Python zu PATH , damit Python 3.x von der Befehlszeile aus mit python . Dies kann die PATH Einstellungen von Python 2.x außer Kraft setzen. Überprüfen Sie deshalb Ihren PATH und stellen Sie sicher, dass er nach Ihren Präferenzen konfiguriert ist.
   • Stellen Sie sicher, dass Sie den py launcher für alle Benutzer installieren.

Python 3 installiert das Python-Startprogramm, mit dem Python 2.x und Python 3.x austauschbar über die Befehlszeile gestartet werden können:

P:\>py -3
Python 3.6.1 (v3.6.1:69c0db5, Mar 21 2017, 17:54:52) [MSC v.1900 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

C:\>py -2
Python 2.7.13 (v2.7.13:a06454b1afa1, Dec 17 2016, 20:42:59) [MSC v.1500 32 Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

Um die entsprechende Version von pip für eine bestimmte Python-Version zu verwenden, verwenden Sie:

C:\>py -3 -m pip -V
pip 9.0.1 from C:\Python36\lib\site-packages (python 3.6)

C:\>py -2 -m pip -V
pip 9.0.1 from C:\Python27\lib\site-packages (python 2.7)

LINUX

Die neuesten Versionen von CentOS, Fedora, Redhat Enterprise (RHEL) und Ubuntu werden mit Python 2.7 geliefert.

Um Python 2.7 manuell unter Linux zu installieren, führen Sie im Terminal Folgendes aus:

wget --no-check-certificate https://www.python.org/ftp/python/2.7.X/Python-2.7.X.tgz
tar -xzf Python-2.7.X.tgz  
cd Python-2.7.X
./configure  
make  
sudo make install

Fügen Sie auch den Pfad des neuen Python in der Umgebungsvariable PATH hinzu. Wenn sich neuer Python in /root/python-2.7.X führen Sie den export PATH = $PATH:/root/python-2.7.X

Um zu prüfen, ob die Python-Installation ein gültiges Schreiben im Terminal ist:

python --version

Ubuntu (aus Quelle)

Wenn Sie Python 3.6 benötigen, können Sie es wie unten gezeigt von der Quelle installieren (Ubuntu 16.10 und 17.04 haben die Version 3.6 im universellen Repository). Die folgenden Schritte müssen für Ubuntu 16.04 und niedrigere Versionen befolgt werden:

sudo apt install build-essential checkinstall
sudo apt install libreadline-gplv2-dev libncursesw5-dev libssl-dev libsqlite3-dev tk-dev libgdbm-dev libc6-dev libbz2-dev
wget https://www.python.org/ftp/python/3.6.1/Python-3.6.1.tar.xz
tar xvf Python-3.6.1.tar.xz 
cd Python-3.6.1/
./configure --enable-optimizations
sudo make altinstall

Mac OS

Wir sprechen zwar davon, dass macOS mit Python 2.7.10 installiert ist, aber diese Version ist veraltet und gegenüber dem regulären Python geringfügig geändert.

Die mit OS X gelieferte Version von Python eignet sich hervorragend zum Lernen, nicht aber für die Entwicklung. Die mit OS X gelieferte Version ist möglicherweise nicht mehr aktuell als die offizielle Python-Version, die als stabile Produktionsversion gilt. ( Quelle )

Homebrew installieren:

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Installieren Sie Python 2.7:

brew install python

Verwenden Sie für Python 3.x stattdessen den Befehl brew install python3 .