Python-Kurzanleitung

Python ist eine interpretierte, interaktive und objektorientierte Skriptsprache auf hoher Ebene. Python ist so konzipiert, dass es gut lesbar ist. Es verwendet häufig englische Schlüsselwörter, wenn andere Sprachen Interpunktion verwenden, und es hat weniger syntaktische Konstruktionen als andere Sprachen.

• Python is Interpreted- Python wird zur Laufzeit vom Interpreter verarbeitet. Sie müssen Ihr Programm nicht kompilieren, bevor Sie es ausführen. Dies ähnelt PERL und PHP.

• Python is Interactive - Sie können tatsächlich an einer Python-Eingabeaufforderung sitzen und direkt mit dem Interpreter interagieren, um Ihre Programme zu schreiben.

• Python is Object-Oriented - Python unterstützt den objektorientierten Stil oder die Programmiertechnik, mit der Code in Objekten gekapselt wird.

• Python is a Beginner's Language - Python ist eine großartige Sprache für Programmierer für Anfänger und unterstützt die Entwicklung einer Vielzahl von Anwendungen, von einfacher Textverarbeitung über WWW-Browser bis hin zu Spielen.

Geschichte von Python

Python wurde von Guido van Rossum Ende der achtziger und Anfang der neunziger Jahre am Nationalen Forschungsinstitut für Mathematik und Informatik in den Niederlanden entwickelt.

Python ist von vielen anderen Sprachen abgeleitet, einschließlich ABC, Modula-3, C, C ++, Algol-68, SmallTalk und Unix-Shell und anderen Skriptsprachen.

Python ist urheberrechtlich geschützt. Wie Perl ist der Python-Quellcode jetzt unter der GNU General Public License (GPL) verfügbar.

Python wird jetzt von einem Kernentwicklungsteam des Instituts gewartet, obwohl Guido van Rossum immer noch eine wichtige Rolle bei der Steuerung seines Fortschritts spielt.

Python-Funktionen

Zu den Funktionen von Python gehören:

• Easy-to-learn- Python hat nur wenige Schlüsselwörter, eine einfache Struktur und eine klar definierte Syntax. Dadurch kann der Schüler die Sprache schnell lernen.

• Easy-to-read - Python-Code ist klarer definiert und für die Augen sichtbar.

• Easy-to-maintain - Pythons Quellcode ist ziemlich einfach zu pflegen.

• A broad standard library - Pythons Hauptbestandteil der Bibliothek ist sehr portabel und plattformübergreifend unter UNIX, Windows und Macintosh kompatibel.

• Interactive Mode - Python unterstützt einen interaktiven Modus, der das interaktive Testen und Debuggen von Codefragmenten ermöglicht.

• Portable - Python kann auf einer Vielzahl von Hardwareplattformen ausgeführt werden und verfügt auf allen Plattformen über dieselbe Schnittstelle.

• Extendable- Sie können dem Python-Interpreter Module auf niedriger Ebene hinzufügen. Mit diesen Modulen können Programmierer ihre Tools effizienter ergänzen oder anpassen.

• Databases - Python bietet Schnittstellen zu allen wichtigen kommerziellen Datenbanken.

• GUI Programming - Python unterstützt GUI-Anwendungen, die erstellt und auf viele Systemaufrufe, Bibliotheken und Windows-Systeme portiert werden können, z. B. Windows MFC, Macintosh und das X Window-System von Unix.

• Scalable - Python bietet eine bessere Struktur und Unterstützung für große Programme als Shell-Scripting.

Abgesehen von den oben genannten Funktionen hat Python eine große Liste guter Funktionen, einige sind unten aufgeführt -

• Es unterstützt funktionale und strukturierte Programmiermethoden sowie OOP.

• Es kann als Skriptsprache verwendet oder zum Erstellen großer Anwendungen zu Bytecode kompiliert werden.

• Es bietet dynamische Datentypen auf sehr hoher Ebene und unterstützt die dynamische Typprüfung.

• Es unterstützt die automatische Speicherbereinigung.

• Es kann problemlos in C, C ++, COM, ActiveX, CORBA und Java integriert werden.

Python ist auf einer Vielzahl von Plattformen verfügbar, einschließlich Linux und Mac OS X. Lassen Sie uns verstehen, wie Sie unsere Python-Umgebung einrichten.

Einrichtung der lokalen Umgebung

Öffnen Sie ein Terminalfenster und geben Sie "python" ein, um herauszufinden, ob es bereits installiert ist und welche Version installiert ist.

• Unix (Solaris, Linux, FreeBSD, AIX, HP / UX, SunOS, IRIX usw.)
• Gewinnen Sie 9x / NT / 2000
• Macintosh (Intel, PPC, 68K)
• OS/2
• DOS (mehrere Versionen)
• PalmOS
• Nokia Handys
• Windows CE
• Acorn / RISC OS
• BeOS
• Amiga
• VMS/OpenVMS
• QNX
• VxWorks
• Psion
• Python wurde auch auf die virtuellen Maschinen Java und .NET portiert

Python bekommen

Der aktuellste und aktuellste Quellcode, Binärdateien, Dokumentationen, Nachrichten usw. sind auf der offiziellen Website von Python verfügbar https://www.python.org/

Sie können die Python-Dokumentation von herunterladen https://www.python.org/doc/. Die Dokumentation ist in den Formaten HTML, PDF und PostScript verfügbar.

Python installieren

Die Python-Distribution ist für eine Vielzahl von Plattformen verfügbar. Sie müssen nur den für Ihre Plattform geltenden Binärcode herunterladen und Python installieren.

Wenn der Binärcode für Ihre Plattform nicht verfügbar ist, benötigen Sie einen C-Compiler, um den Quellcode manuell zu kompilieren. Das Kompilieren des Quellcodes bietet mehr Flexibilität bei der Auswahl der Funktionen, die Sie für Ihre Installation benötigen.

Hier ist eine kurze Übersicht über die Installation von Python auf verschiedenen Plattformen -

Unix- und Linux-Installation

Hier sind die einfachen Schritte zum Installieren von Python auf einem Unix / Linux-Computer.

• Öffnen Sie einen Webbrowser und gehen Sie zu https://www.python.org/downloads/.

• Folgen Sie dem Link, um den für Unix / Linux verfügbaren komprimierten Quellcode herunterzuladen.

• Dateien herunterladen und extrahieren.

• Bearbeiten der Modul- / Setup- Datei, wenn Sie einige Optionen anpassen möchten.

• Führen Sie das Skript ./configure aus

• make

• make install

Dadurch wird Python am Standardspeicherort / usr / local / bin und seine Bibliotheken unter / usr / local / lib / pythonXX installiert, wobei XX die Version von Python ist.

Windows-Installation

Hier sind die Schritte zum Installieren von Python auf einem Windows-Computer.

• Öffnen Sie einen Webbrowser und gehen Sie zu https://www.python.org/downloads/.

• Folgen Sie dem Link für die Windows-Installationsdatei python-XYZ.msi , wobei XYZ die Version ist, die Sie installieren müssen.

• Um dieses Installationsprogramm python-XYZ.msi verwenden zu können , muss das Windows-System Microsoft Installer 2.0 unterstützen. Speichern Sie die Installationsdatei auf Ihrem lokalen Computer und führen Sie sie aus, um herauszufinden, ob Ihr Computer MSI unterstützt.

• Führen Sie die heruntergeladene Datei aus. Dadurch wird der Python-Installationsassistent aufgerufen, der sehr einfach zu bedienen ist. Akzeptieren Sie einfach die Standardeinstellungen, warten Sie, bis die Installation abgeschlossen ist, und Sie sind fertig.

Macintosh-Installation

Auf neueren Macs ist Python installiert, es kann jedoch einige Jahre veraltet sein. Sehenhttp://www.python.org/download/mac/Anweisungen zum Abrufen der aktuellen Version sowie zusätzliche Tools zur Unterstützung der Entwicklung auf dem Mac. Für ältere Mac OS vor Mac OS X 10.3 (veröffentlicht 2003) ist MacPython verfügbar.

Jack Jansen pflegt es und Sie können auf seiner Website uneingeschränkt auf die gesamte Dokumentation zugreifen - http://www.cwi.nl/~jack/macpython.html. Hier finden Sie vollständige Installationsdetails für die Installation unter Mac OS.

PATH einrichten

Programme und andere ausführbare Dateien können sich in vielen Verzeichnissen befinden. Daher bieten Betriebssysteme einen Suchpfad, in dem die Verzeichnisse aufgelistet sind, in denen das Betriebssystem nach ausführbaren Dateien sucht.

Der Pfad wird in einer Umgebungsvariablen gespeichert, bei der es sich um eine benannte Zeichenfolge handelt, die vom Betriebssystem verwaltet wird. Diese Variable enthält Informationen, die der Befehlsshell und anderen Programmen zur Verfügung stehen.

Das path Die Variable wird unter Unix als PATH oder unter Windows als Path bezeichnet (bei Unix wird zwischen Groß- und Kleinschreibung unterschieden; Windows nicht).

Unter Mac OS übernimmt das Installationsprogramm die Pfaddetails. Um den Python-Interpreter von einem bestimmten Verzeichnis aus aufzurufen, müssen Sie das Python-Verzeichnis zu Ihrem Pfad hinzufügen.

Pfad unter Unix / Linux festlegen

So fügen Sie das Python-Verzeichnis dem Pfad für eine bestimmte Sitzung unter Unix hinzu:

• In the csh shell - Geben Sie setenv PATH "$ PATH: / usr / local / bin / python" ein und drücken Sie die Eingabetaste.

• In the bash shell (Linux) - Geben Sie export PATH = "$ PATH: / usr / local / bin / python" ein und drücken Sie die Eingabetaste.

• In the sh or ksh shell - Geben Sie PATH = "$ PATH: / usr / local / bin / python" ein und drücken Sie die Eingabetaste.

• Note - / usr / local / bin / python ist der Pfad des Python-Verzeichnisses

Pfad unter Windows einstellen

So fügen Sie das Python-Verzeichnis dem Pfad für eine bestimmte Sitzung in Windows hinzu:

At the command prompt - Geben Sie path% path%; C: \ Python ein und drücken Sie die Eingabetaste.

Note - C: \ Python ist der Pfad des Python-Verzeichnisses

Python-Umgebungsvariablen

Hier sind wichtige Umgebungsvariablen, die von Python erkannt werden können:

Sr.Nr.	Variable & Beschreibung
1	PYTHONPATH Es hat eine ähnliche Rolle wie PATH. Diese Variable teilt dem Python-Interpreter mit, wo sich die in ein Programm importierten Moduldateien befinden sollen. Es sollte das Python-Quellbibliotheksverzeichnis und die Verzeichnisse enthalten, die Python-Quellcode enthalten. PYTHONPATH wird manchmal vom Python-Installationsprogramm voreingestellt.
2	PYTHONSTARTUP Es enthält den Pfad einer Initialisierungsdatei, die Python-Quellcode enthält. Es wird jedes Mal ausgeführt, wenn Sie den Interpreter starten. Es heißt unter Unix .pythonrc.py und enthält Befehle zum Laden von Dienstprogrammen oder zum Ändern von PYTHONPATH.
3	PYTHONCASEOK Es wird in Windows verwendet, um Python anzuweisen, die erste Übereinstimmung ohne Berücksichtigung der Groß- und Kleinschreibung in einer Importanweisung zu finden. Setzen Sie diese Variable auf einen beliebigen Wert, um sie zu aktivieren.
4	PYTHONHOME Es ist ein alternativer Modul-Suchpfad. Es ist normalerweise in die Verzeichnisse PYTHONSTARTUP oder PYTHONPATH eingebettet, um das Wechseln der Modulbibliotheken zu vereinfachen.

Python ausführen

Es gibt drei verschiedene Möglichkeiten, Python zu starten:

Interaktiver Dolmetscher

Sie können Python unter Unix, DOS oder einem anderen System starten, das Ihnen einen Befehlszeileninterpreter oder ein Shell-Fenster bietet.

Eingeben python die Kommandozeile.

Starten Sie die Codierung sofort im interaktiven Interpreter.

$python # Unix/Linux
or
python% # Unix/Linux
or
C:> python # Windows/DOS

Hier ist die Liste aller verfügbaren Befehlszeilenoptionen -

Sr.Nr.	Option & Beschreibung
1	-d Es bietet Debug-Ausgabe.
2	-O Es generiert einen optimierten Bytecode (was zu .pyo-Dateien führt).
3	-S Führen Sie keine Importsite aus, um beim Start nach Python-Pfaden zu suchen.
4	-v ausführliche Ausgabe (detaillierte Ablaufverfolgung bei Importanweisungen).
5	-X Deaktivieren Sie klassenbasierte integrierte Ausnahmen (verwenden Sie einfach Zeichenfolgen). veraltet ab Version 1.6.
6	-c cmd Führen Sie das als cmd-Zeichenfolge gesendete Python-Skript aus
7	file Führen Sie das Python-Skript aus der angegebenen Datei aus

Skript über die Befehlszeile

Ein Python-Skript kann über die Befehlszeile ausgeführt werden, indem der Interpreter in Ihrer Anwendung wie folgt aufgerufen wird:

$python script.py # Unix/Linux

or

python% script.py # Unix/Linux

or 

C: >python script.py # Windows/DOS

Note - Stellen Sie sicher, dass der Dateiberechtigungsmodus die Ausführung ermöglicht.

Integrierte Entwicklungsumgebung

Sie können Python auch in einer grafischen Benutzeroberfläche (GUI) ausführen, wenn auf Ihrem System eine GUI-Anwendung vorhanden ist, die Python unterstützt.

• Unix - IDLE ist die allererste Unix-IDE für Python.

• Windows - PythonWin ist die erste Windows-Oberfläche für Python und eine IDE mit einer GUI.

• Macintosh - Die Macintosh-Version von Python ist zusammen mit der IDLE-IDE auf der Hauptwebsite verfügbar und kann entweder als MacBinary- oder BinHex-Datei heruntergeladen werden.

Wenn Sie die Umgebung nicht ordnungsgemäß einrichten können, können Sie sich an Ihren Systemadministrator wenden. Stellen Sie sicher, dass die Python-Umgebung ordnungsgemäß eingerichtet ist und einwandfrei funktioniert.

Note - Alle in den folgenden Kapiteln aufgeführten Beispiele werden mit der Python 2.4.3-Version ausgeführt, die unter CentOS Linux verfügbar ist.

Wir haben die Python-Programmierumgebung bereits online eingerichtet, sodass Sie alle verfügbaren Beispiele gleichzeitig online ausführen können, wenn Sie Theorie lernen. Sie können jedes Beispiel ändern und online ausführen.

Die Python-Sprache hat viele Ähnlichkeiten mit Perl, C und Java. Es gibt jedoch einige deutliche Unterschiede zwischen den Sprachen.

Erstes Python-Programm

Lassen Sie uns Programme in verschiedenen Programmiermodi ausführen.

Programmierung im interaktiven Modus

Wenn Sie den Interpreter aufrufen, ohne eine Skriptdatei als Parameter zu übergeben, wird die folgende Eingabeaufforderung angezeigt:

$ python
Python 2.4.3 (#1, Nov 11 2010, 13:34:43)
[GCC 4.1.2 20080704 (Red Hat 4.1.2-48)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

Geben Sie den folgenden Text an der Python-Eingabeaufforderung ein und drücken Sie die Eingabetaste -

>>> print "Hello, Python!"

Wenn Sie eine neue Version von Python ausführen, müssen Sie die print-Anweisung in Klammern wie in verwenden print ("Hello, Python!");. In Python Version 2.4.3 führt dies jedoch zu folgendem Ergebnis:

Hello, Python!

Skriptmodus-Programmierung

Das Aufrufen des Interpreters mit einem Skriptparameter beginnt mit der Ausführung des Skripts und wird fortgesetzt, bis das Skript beendet ist. Wenn das Skript fertig ist, ist der Interpreter nicht mehr aktiv.

Schreiben wir ein einfaches Python-Programm in ein Skript. Python-Dateien haben die Erweiterung.py. Geben Sie den folgenden Quellcode in eine test.py-Datei ein:

print "Hello, Python!"

Wir gehen davon aus, dass Sie den Python-Interpreter in der PATH-Variablen festgelegt haben. Versuchen Sie nun, dieses Programm wie folgt auszuführen:

$ python test.py

Dies ergibt das folgende Ergebnis:

Hello, Python!

Versuchen wir einen anderen Weg, um ein Python-Skript auszuführen. Hier ist die geänderte Datei test.py -

#!/usr/bin/python

print "Hello, Python!"

Wir gehen davon aus, dass Sie den Python-Interpreter im Verzeichnis / usr / bin verfügbar haben. Versuchen Sie nun, dieses Programm wie folgt auszuführen:

$ chmod +x test.py     # This is to make file executable
$./test.py

Dies ergibt das folgende Ergebnis:

Hello, Python!

Python-Bezeichner

Ein Python-Bezeichner ist ein Name, mit dem eine Variable, Funktion, Klasse, ein Modul oder ein anderes Objekt identifiziert wird. Ein Bezeichner beginnt mit einem Buchstaben A bis Z oder a bis z oder einem Unterstrich (_), gefolgt von null oder mehr Buchstaben, Unterstrichen und Ziffern (0 bis 9).

Python erlaubt keine Interpunktionszeichen wie @, $ und% in Bezeichnern. Python ist eine Programmiersprache, bei der zwischen Groß- und Kleinschreibung unterschieden wird. So,Manpower und manpower sind zwei verschiedene Bezeichner in Python.

Hier sind Namenskonventionen für Python-Bezeichner:

• Klassennamen beginnen mit einem Großbuchstaben. Alle anderen Bezeichner beginnen mit einem Kleinbuchstaben.

• Das Starten eines Bezeichners mit einem einzelnen führenden Unterstrich zeigt an, dass der Bezeichner privat ist.

• Das Starten eines Bezeichners mit zwei führenden Unterstrichen zeigt einen stark privaten Bezeichner an.

• Wenn der Bezeichner auch mit zwei nachgestellten Unterstrichen endet, ist der Bezeichner ein sprachdefinierter Sondername.

Reservierte Wörter

Die folgende Liste zeigt die Python-Schlüsselwörter. Dies sind reservierte Wörter, und Sie können sie nicht als Konstante, Variable oder andere Bezeichnernamen verwenden. Alle Python-Schlüsselwörter enthalten nur Kleinbuchstaben.

und	exec	nicht
behaupten	schließlich	oder
Unterbrechung	zum	bestehen
Klasse	von	drucken
fortsetzen	global	erziehen
def	wenn	Rückkehr
del	importieren	Versuchen
elif	im	während
sonst	ist	mit
außer	Lambda	Ausbeute

Linien und Einrückungen

Python bietet keine geschweiften Klammern, um Codeblöcke für Klassen- und Funktionsdefinitionen oder die Flusskontrolle anzugeben. Codeblöcke werden durch Zeileneinrückungen gekennzeichnet, die streng erzwungen werden.

Die Anzahl der Leerzeichen in der Einrückung ist variabel, aber alle Anweisungen innerhalb des Blocks müssen gleich viel eingerückt werden. Zum Beispiel -

if True:
   print "True"
else:
   print "False"

Der folgende Block erzeugt jedoch einen Fehler -

if True:
print "Answer"
print "True"
else:
print "Answer"
print "False"

Somit würden in Python alle durchgehenden Linien, die mit der gleichen Anzahl von Leerzeichen eingerückt sind, einen Block bilden. Das folgende Beispiel enthält verschiedene Anweisungsblöcke -

Note- Versuchen Sie zu diesem Zeitpunkt nicht, die Logik zu verstehen. Stellen Sie einfach sicher, dass Sie verschiedene Blöcke verstanden haben, auch wenn sie keine geschweiften Klammern haben.

#!/usr/bin/python

import sys

try:
   # open file stream
   file = open(file_name, "w")
except IOError:
   print "There was an error writing to", file_name
   sys.exit()
print "Enter '", file_finish,
print "' When finished"
while file_text != file_finish:
   file_text = raw_input("Enter text: ")
   if file_text == file_finish:
      # close the file
      file.close
      break
   file.write(file_text)
   file.write("\n")
file.close()
file_name = raw_input("Enter filename: ")
if len(file_name) == 0:
   print "Next time please enter something"
   sys.exit()
try:
   file = open(file_name, "r")
except IOError:
   print "There was an error reading file"
   sys.exit()
file_text = file.read()
file.close()
print file_text

Mehrzeilige Anweisungen

Anweisungen in Python enden normalerweise mit einer neuen Zeile. Python erlaubt jedoch die Verwendung des Zeilenfortsetzungszeichens (\), um anzugeben, dass die Zeile fortgesetzt werden soll. Zum Beispiel -

total = item_one + \
        item_two + \
        item_three

Anweisungen in den Klammern [], {} oder () müssen nicht das Zeilenfortsetzungszeichen verwenden. Zum Beispiel -

days = ['Monday', 'Tuesday', 'Wednesday',
        'Thursday', 'Friday']

Zitat in Python

Python akzeptiert einfache ('), doppelte (") und dreifache (' '' oder" "") Anführungszeichen, um Zeichenfolgenliterale zu kennzeichnen, sofern dieselbe Art von Anführungszeichen die Zeichenfolge beginnt und beendet.

Die dreifachen Anführungszeichen werden verwendet, um die Zeichenfolge über mehrere Zeilen zu verteilen. Zum Beispiel sind alle folgenden legal -

word = 'word'
sentence = "This is a sentence."
paragraph = """This is a paragraph. It is
made up of multiple lines and sentences."""

Kommentare in Python

Ein Hash-Zeichen (#), das sich nicht in einem String-Literal befindet, beginnt einen Kommentar. Alle Zeichen nach dem # und bis zum Ende der physischen Zeile sind Teil des Kommentars und werden vom Python-Interpreter ignoriert.

#!/usr/bin/python

# First comment
print "Hello, Python!" # second comment

Dies ergibt das folgende Ergebnis:

Hello, Python!

Sie können nach einer Anweisung oder einem Ausdruck einen Kommentar in dieselbe Zeile eingeben.

name = "Madisetti" # This is again comment

Sie können mehrere Zeilen wie folgt kommentieren:

# This is a comment.
# This is a comment, too.
# This is a comment, too.
# I said that already.

Leerzeilen verwenden

Eine Zeile, die nur Leerzeichen enthält, möglicherweise mit einem Kommentar, wird als Leerzeile bezeichnet, und Python ignoriert sie vollständig.

In einer interaktiven Interpretersitzung müssen Sie eine leere physische Zeile eingeben, um eine mehrzeilige Anweisung zu beenden.

Warten auf den Benutzer

In der folgenden Zeile des Programms wird die Eingabeaufforderung mit der Anweisung "Drücken Sie die Eingabetaste zum Beenden" angezeigt und wartet darauf, dass der Benutzer Maßnahmen ergreift.

#!/usr/bin/python

raw_input("\n\nPress the enter key to exit.")

Hier wird "\ n \ n" verwendet, um zwei neue Zeilen zu erstellen, bevor die tatsächliche Zeile angezeigt wird. Sobald der Benutzer die Taste drückt, endet das Programm. Dies ist ein guter Trick, um ein Konsolenfenster geöffnet zu halten, bis der Benutzer mit einer Anwendung fertig ist.

Mehrere Anweisungen in einer einzelnen Zeile

Das Semikolon (;) erlaubt mehrere Anweisungen in einer Zeile, da keine der Anweisungen einen neuen Codeblock startet. Hier ist ein Beispielausschnitt mit dem Semikolon -

import sys; x = 'foo'; sys.stdout.write(x + '\n')

Mehrere Anweisungsgruppen als Suiten

Eine Gruppe einzelner Anweisungen, die einen einzelnen Codeblock bilden, wird aufgerufen suitesin Python. Zusammengesetzte oder komplexe Anweisungen, z. B. if, while, def und class, erfordern eine Kopfzeile und eine Suite.

Kopfzeilen beginnen die Anweisung (mit dem Schlüsselwort) und enden mit einem Doppelpunkt (:) und werden von einer oder mehreren Zeilen gefolgt, aus denen die Suite besteht. Zum Beispiel -

if expression : 
   suite
elif expression : 
   suite 
else : 
   suite

Kommandozeilenargumente

Viele Programme können ausgeführt werden, um Ihnen einige grundlegende Informationen darüber zu geben, wie sie ausgeführt werden sollen. Mit Python können Sie dies mit -h - tun.

$ python -h
usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...
Options and arguments (and corresponding environment variables):
-c cmd : program passed in as string (terminates option list)
-d     : debug output from parser (also PYTHONDEBUG=x)
-E     : ignore environment variables (such as PYTHONPATH)
-h     : print this help message and exit

[ etc. ]

Sie können Ihr Skript auch so programmieren, dass es verschiedene Optionen akzeptiert. Befehlszeilenargumente sind ein fortgeschrittenes Thema und sollten etwas später untersucht werden, sobald Sie die restlichen Python-Konzepte durchlaufen haben.

Variablen sind nichts anderes als reservierte Speicherplätze zum Speichern von Werten. Dies bedeutet, dass Sie beim Erstellen einer Variablen Speicherplatz im Speicher reservieren.

Basierend auf dem Datentyp einer Variablen weist der Interpreter Speicher zu und entscheidet, was im reservierten Speicher gespeichert werden kann. Durch Zuweisen verschiedener Datentypen zu Variablen können Sie daher Ganzzahlen, Dezimalstellen oder Zeichen in diesen Variablen speichern.

Variablen Werte zuweisen

Python-Variablen benötigen keine explizite Deklaration, um Speicherplatz zu reservieren. Die Deklaration erfolgt automatisch, wenn Sie einer Variablen einen Wert zuweisen. Das Gleichheitszeichen (=) wird verwendet, um Variablen Werte zuzuweisen.

Der Operand links vom Operator = ist der Name der Variablen und der Operand rechts vom Operator = ist der in der Variablen gespeicherte Wert. Zum Beispiel -

#!/usr/bin/python

counter = 100          # An integer assignment
miles   = 1000.0       # A floating point
name    = "John"       # A string

print counter
print miles
print name

Hier sind 100, 1000.0 und "John" die Werte, die den Variablen " Zähler" , " Meilen" und " Name " zugewiesen sind. Dies ergibt das folgende Ergebnis:

100
1000.0
John

Mehrfachzuweisung

Mit Python können Sie mehreren Variablen gleichzeitig einen einzelnen Wert zuweisen. Zum Beispiel -

a = b = c = 1

Hier wird ein ganzzahliges Objekt mit dem Wert 1 erstellt und alle drei Variablen demselben Speicherort zugewiesen. Sie können auch mehreren Variablen mehrere Objekte zuweisen. Zum Beispiel -

a,b,c = 1,2,"john"

Hier werden den Variablen a und b zwei ganzzahlige Objekte mit den Werten 1 und 2 zugewiesen, und der Variablen c wird ein String-Objekt mit dem Wert "john" zugewiesen.

Standarddatentypen

Es gibt viele Arten von Daten, die im Speicher gespeichert sind. Beispielsweise wird das Alter einer Person als numerischer Wert und ihre Adresse als alphanumerische Zeichen gespeichert. Python verfügt über verschiedene Standarddatentypen, mit denen die für sie möglichen Vorgänge und die Speichermethode für jeden von ihnen definiert werden.

Python hat fünf Standarddatentypen -

• Numbers
• String
• List
• Tuple
• Dictionary

Python-Nummern

Zahlendatentypen speichern numerische Werte. Zahlenobjekte werden erstellt, wenn Sie ihnen einen Wert zuweisen. Zum Beispiel -

var1 = 1
var2 = 10

Sie können den Verweis auf ein Zahlenobjekt auch mithilfe der del-Anweisung löschen. Die Syntax der del-Anweisung lautet -

del var1[,var2[,var3[....,varN]]]]

Sie können ein einzelnes Objekt oder mehrere Objekte mithilfe der del-Anweisung löschen. Zum Beispiel -

del var
del var_a, var_b

Python unterstützt vier verschiedene numerische Typen -

• int (vorzeichenbehaftete Ganzzahlen)
• long (lange ganze Zahlen, sie können auch oktal und hexadezimal dargestellt werden)
• float (Gleitkomma-Realwerte)
• komplex (komplexe Zahlen)

Beispiele

Hier einige Beispiele für Zahlen -

int	lange	schweben	Komplex
10	51924361L	0.0	3.14j
100	-0x19323L	15.20	45.j.
-786	0122L	-21,9	9.322e-36j
080	0xDEFABCECBDAECBFBAEl	32,3 + e18	.876j
-0490	535633629843L	-90.	-.6545 + 0J
-0x260	-052318172735L	-32,54e100	3e + 26J
0x69	-4721885298529L	70,2-E12	4,53e-7j

• In Python können Sie Kleinbuchstaben l mit Long verwenden. Es wird jedoch empfohlen, nur Großbuchstaben L zu verwenden, um Verwechslungen mit der Zahl 1 zu vermeiden. Python zeigt lange Ganzzahlen mit Großbuchstaben L an.

• Eine komplexe Zahl besteht aus einem geordneten Paar von reellen Gleitkommazahlen, die mit x + yj bezeichnet sind, wobei x und y die reellen Zahlen und j die imaginäre Einheit sind.

Python-Strings

Zeichenfolgen in Python werden als zusammenhängende Zeichensätze in Anführungszeichen identifiziert. Python erlaubt entweder Paare von einfachen oder doppelten Anführungszeichen. Teilmengen von Zeichenfolgen können mit dem Slice-Operator ([] und [:]) erstellt werden, wobei die Indizes am Anfang der Zeichenfolge bei 0 beginnen und sich am Ende von -1 abarbeiten.

Das Pluszeichen (+) ist der Zeichenfolgenverkettungsoperator und das Sternchen (*) ist der Wiederholungsoperator. Zum Beispiel -

#!/usr/bin/python

str = 'Hello World!'

print str          # Prints complete string
print str[0]       # Prints first character of the string
print str[2:5]     # Prints characters starting from 3rd to 5th
print str[2:]      # Prints string starting from 3rd character
print str * 2      # Prints string two times
print str + "TEST" # Prints concatenated string

Dies führt zu folgendem Ergebnis:

Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST

Python-Listen

Listen sind die vielseitigsten zusammengesetzten Datentypen von Python. Eine Liste enthält durch Kommas getrennte und in eckige Klammern ([]) eingeschlossene Elemente. In gewissem Maße ähneln Listen Arrays in C. Ein Unterschied besteht darin, dass alle zu einer Liste gehörenden Elemente unterschiedlichen Datentyps haben können.

Auf die in einer Liste gespeicherten Werte kann mit dem Slice-Operator ([] und [:]) zugegriffen werden, wobei die Indizes am Anfang der Liste bei 0 beginnen und bis zum Ende -1 arbeiten. Das Pluszeichen (+) ist der Listenverkettungsoperator und das Sternchen (*) ist der Wiederholungsoperator. Zum Beispiel -

#!/usr/bin/python

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']

print list          # Prints complete list
print list[0]       # Prints first element of the list
print list[1:3]     # Prints elements starting from 2nd till 3rd 
print list[2:]      # Prints elements starting from 3rd element
print tinylist * 2  # Prints list two times
print list + tinylist # Prints concatenated lists

Dies führt zu folgendem Ergebnis:

['abcd', 786, 2.23, 'john', 70.2]
abcd
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['abcd', 786, 2.23, 'john', 70.2, 123, 'john']

Python-Tupel

Ein Tupel ist ein anderer Sequenzdatentyp, der der Liste ähnlich ist. Ein Tupel besteht aus mehreren durch Kommas getrennten Werten. Im Gegensatz zu Listen sind Tupel jedoch in Klammern eingeschlossen.

Die Hauptunterschiede zwischen Listen und Tupeln sind: Listen sind in Klammern ([]) eingeschlossen und ihre Elemente und Größe können geändert werden, während Tupel in Klammern (()) eingeschlossen und nicht aktualisiert werden können. Tupel können als gedacht werdenread-onlyListen. Zum Beispiel -

#!/usr/bin/python

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2  )
tinytuple = (123, 'john')

print tuple               # Prints the complete tuple
print tuple[0]            # Prints first element of the tuple
print tuple[1:3]          # Prints elements of the tuple starting from 2nd till 3rd 
print tuple[2:]           # Prints elements of the tuple starting from 3rd element
print tinytuple * 2       # Prints the contents of the tuple twice
print tuple + tinytuple   # Prints concatenated tuples

Dies führt zu folgendem Ergebnis:

('abcd', 786, 2.23, 'john', 70.2)
abcd
(786, 2.23)
(2.23, 'john', 70.2)
(123, 'john', 123, 'john')
('abcd', 786, 2.23, 'john', 70.2, 123, 'john')

Der folgende Code ist mit Tupel ungültig, da wir versucht haben, ein Tupel zu aktualisieren, was nicht zulässig ist. Ähnliches gilt für Listen -

#!/usr/bin/python

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2  )
list = [ 'abcd', 786 , 2.23, 'john', 70.2  ]
tuple[2] = 1000    # Invalid syntax with tuple
list[2] = 1000     # Valid syntax with list

Python-Wörterbuch

Pythons Wörterbücher sind eine Art Hash-Tabellentyp. Sie funktionieren wie assoziative Arrays oder Hashes in Perl und bestehen aus Schlüssel-Wert-Paaren. Ein Wörterbuchschlüssel kann fast jeder Python-Typ sein, besteht jedoch normalerweise aus Zahlen oder Zeichenfolgen. Werte können dagegen ein beliebiges Python-Objekt sein.

Wörterbücher werden von geschweiften Klammern ({}) eingeschlossen, und Werte können mit eckigen Klammern ([]) zugewiesen und aufgerufen werden. Zum Beispiel -

#!/usr/bin/python

dict = {}
dict['one'] = "This is one"
dict[2]     = "This is two"

tinydict = {'name': 'john','code':6734, 'dept': 'sales'}


print dict['one']       # Prints value for 'one' key
print dict[2]           # Prints value for 2 key
print tinydict          # Prints complete dictionary
print tinydict.keys()   # Prints all the keys
print tinydict.values() # Prints all the values

Dies führt zu folgendem Ergebnis:

This is one
This is two
{'dept': 'sales', 'code': 6734, 'name': 'john'}
['dept', 'code', 'name']
['sales', 6734, 'john']

Wörterbücher haben keinen Ordnungsbegriff zwischen Elementen. Es ist falsch zu sagen, dass die Elemente "außer Betrieb" sind; Sie sind einfach ungeordnet.

Datentypkonvertierung

Manchmal müssen Sie möglicherweise Konvertierungen zwischen den integrierten Typen durchführen. Zum Konvertieren zwischen Typen verwenden Sie einfach den Typnamen als Funktion.

Es gibt mehrere integrierte Funktionen, um die Konvertierung von einem Datentyp in einen anderen durchzuführen. Diese Funktionen geben ein neues Objekt zurück, das den konvertierten Wert darstellt.

Sr.Nr.	Bedienungsanleitung
1	int(x [,base]) Konvertiert x in eine Ganzzahl. base gibt die Basis an, wenn x eine Zeichenfolge ist.
2	long(x [,base] ) Konvertiert x in eine lange Ganzzahl. base gibt die Basis an, wenn x eine Zeichenfolge ist.
3	float(x) Konvertiert x in eine Gleitkommazahl.
4	complex(real [,imag]) Erstellt eine komplexe Zahl.
5	str(x) Konvertiert das Objekt x in eine Zeichenfolgendarstellung.
6	repr(x) Konvertiert das Objekt x in eine Ausdruckszeichenfolge.
7	eval(str) Wertet eine Zeichenfolge aus und gibt ein Objekt zurück.
8	tuple(s) Konvertiert s in ein Tupel.
9	list(s) Konvertiert s in eine Liste.
10	set(s) Konvertiert s in einen Satz.
11	dict(d) Erstellt ein Wörterbuch. d muss eine Folge von (Schlüssel-, Wert-) Tupeln sein.
12	frozenset(s) Konvertiert s in ein eingefrorenes Set.
13	chr(x) Konvertiert eine Ganzzahl in ein Zeichen.
14	unichr(x) Konvertiert eine Ganzzahl in ein Unicode-Zeichen.
15	ord(x) Konvertiert ein einzelnes Zeichen in seinen ganzzahligen Wert.
16	hex(x) Konvertiert eine Ganzzahl in eine hexadezimale Zeichenfolge.
17	oct(x) Konvertiert eine Ganzzahl in eine Oktalzeichenfolge.

Operatoren sind die Konstrukte, die den Wert von Operanden manipulieren können.

Betrachten Sie den Ausdruck 4 + 5 = 9. Hier werden 4 und 5 Operanden und + Operator genannt.

Arten von Betreibern

Die Python-Sprache unterstützt die folgenden Arten von Operatoren.

• Rechenzeichen
• Vergleichsoperatoren (relationale Operatoren)
• Zuweisungsoperatoren
• Logische Operatoren
• Bitweise Operatoren
• Mitgliederbetreiber
• Identitätsoperatoren

Lassen Sie uns alle Operatoren einzeln betrachten.

Python-Arithmetikoperatoren

Angenommen, Variable a hält 10 und Variable b hält 20, dann -

[ Beispiel zeigen ]

Operator	Beschreibung	Beispiel
+ Ergänzung	Fügt Werte auf beiden Seiten des Operators hinzu.	a + b = 30
- Subtraktion	Subtrahiert den rechten Operanden vom linken Operanden.	a - b = -10
* Multiplikation	Multipliziert Werte auf beiden Seiten des Operators	a * b = 200
/ Teilung	Teilt den linken Operanden durch den rechten Operanden	b / a = 2
% Modul	Teilt den linken Operanden durch den rechten Operanden und gibt den Rest zurück	b% a = 0
** Exponent	Führt eine Exponentialberechnung (Leistungsberechnung) für Operatoren durch	a ** b = 10 hoch 20
// //	Floor Division - Die Division von Operanden, bei der das Ergebnis der Quotient ist, bei dem die Ziffern nach dem Dezimalpunkt entfernt werden. Wenn jedoch einer der Operanden negativ ist, ist das Ergebnis bodenständig, dh von Null weggerundet (in Richtung negative Unendlichkeit) -	9 // 2 = 4 und 9,0 // 2,0 = 4,0, -11 // 3 = -4, -11,0 // 3 = -4,0

Python-Vergleichsoperatoren

Diese Operatoren vergleichen die Werte auf beiden Seiten und bestimmen die Beziehung zwischen ihnen. Sie werden auch als relationale Operatoren bezeichnet.

Angenommen, Variable a hält 10 und Variable b hält 20, dann -

[ Beispiel zeigen ]

Operator	Beschreibung	Beispiel
==	Wenn die Werte von zwei Operanden gleich sind, wird die Bedingung wahr.	(a == b) ist nicht wahr.
! =	Wenn die Werte von zwei Operanden nicht gleich sind, wird die Bedingung wahr.	(a! = b) ist wahr.
<>	Wenn die Werte von zwei Operanden nicht gleich sind, wird die Bedingung wahr.	(a <> b) ist wahr. Dies ähnelt dem Operator! =.
>	Wenn der Wert des linken Operanden größer als der Wert des rechten Operanden ist, wird die Bedingung wahr.	(a> b) ist nicht wahr.
<	Wenn der Wert des linken Operanden kleiner als der Wert des rechten Operanden ist, wird die Bedingung wahr.	(a <b) ist wahr.
> =	Wenn der Wert des linken Operanden größer oder gleich dem Wert des rechten Operanden ist, wird die Bedingung wahr.	(a> = b) ist nicht wahr.
<=	Wenn der Wert des linken Operanden kleiner oder gleich dem Wert des rechten Operanden ist, wird die Bedingung wahr.	(a <= b) ist wahr.

Python-Zuweisungsoperatoren

Angenommen, Variable a hält 10 und Variable b hält 20, dann -

[ Beispiel zeigen ]

Operator	Beschreibung	Beispiel
=	Weist dem linken Operanden Werte von Operanden auf der rechten Seite zu	c = a + b assigns value of a + b into c
+= Add AND	It adds right operand to the left operand and assign the result to left operand	c += a is equivalent to c = c + a
-= Subtract AND	It subtracts right operand from the left operand and assign the result to left operand	c -= a is equivalent to c = c - a
*= Multiply AND	It multiplies right operand with the left operand and assign the result to left operand	c *= a is equivalent to c = c * a
/= Divide AND	It divides left operand with the right operand and assign the result to left operand	c /= a is equivalent to c = c / a
%= Modulus AND	It takes modulus using two operands and assign the result to left operand	c %= a is equivalent to c = c % a
**= Exponent AND	Performs exponential (power) calculation on operators and assign value to the left operand	c **= a is equivalent to c = c ** a
//= Floor Division	It performs floor division on operators and assign value to the left operand	c //= a is equivalent to c = c // a

Python Bitwise Operators

Bitwise operator works on bits and performs bit by bit operation. Assume if a = 60; and b = 13; Now in the binary format their values will be 0011 1100 and 0000 1101 respectively. Following table lists out the bitwise operators supported by Python language with an example each in those, we use the above two variables (a and b) as operands −

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

There are following Bitwise operators supported by Python language

[ Show Example ]

Operator	Description	Example
& Binary AND	Operator copies a bit to the result if it exists in both operands	(a & b) (means 0000 1100)
| Binary OR	It copies a bit if it exists in either operand.	(a | b) = 61 (means 0011 1101)
^ Binary XOR	It copies the bit if it is set in one operand but not both.	(a ^ b) = 49 (means 0011 0001)
~ Binary Ones Complement	It is unary and has the effect of 'flipping' bits.	(~a ) = -61 (means 1100 0011 in 2's complement form due to a signed binary number.
<< Binary Left Shift	The left operands value is moved left by the number of bits specified by the right operand.	a << 2 = 240 (means 1111 0000)
>> Binary Right Shift	The left operands value is moved right by the number of bits specified by the right operand.	a >> 2 = 15 (means 0000 1111)

Python Logical Operators

There are following logical operators supported by Python language. Assume variable a holds 10 and variable b holds 20 then

[ Show Example ]

Operator	Description	Example
and Logical AND	If both the operands are true then condition becomes true.	(a and b) is true.
or Logical OR	If any of the two operands are non-zero then condition becomes true.	(a or b) is true.
not Logical NOT	Used to reverse the logical state of its operand.	Not(a and b) is false.

Python Membership Operators

Python’s membership operators test for membership in a sequence, such as strings, lists, or tuples. There are two membership operators as explained below −

[ Show Example ]

Operator	Description	Example
in	Evaluates to true if it finds a variable in the specified sequence and false otherwise.	x in y, here in results in a 1 if x is a member of sequence y.
not in	Evaluates to true if it does not finds a variable in the specified sequence and false otherwise.	x not in y, here not in results in a 1 if x is not a member of sequence y.

Python Identity Operators

Identity operators compare the memory locations of two objects. There are two Identity operators explained below −

[ Show Example ]

Operator	Description	Example
is	Evaluates to true if the variables on either side of the operator point to the same object and false otherwise.	x is y, here is results in 1 if id(x) equals id(y).
is not	Evaluates to false if the variables on either side of the operator point to the same object and true otherwise.	x is not y, here is not results in 1 if id(x) is not equal to id(y).

Python Operators Precedence

The following table lists all operators from highest precedence to lowest.

[ Show Example ]

Sr.No.	Operator & Description
1	** Exponentiation (raise to the power)
2	~ + - Complement, unary plus and minus (method names for the last two are +@ and -@)
3	* / % // Multiply, divide, modulo and floor division
4	+ - Addition and subtraction
5	>> << Right and left bitwise shift
6	& Bitwise 'AND'
7	^ | Bitwise exclusive `OR' and regular `OR'
8	<= < > >= Comparison operators
9	<> == != Equality operators
10	= %= /= //= -= += *= **= Assignment operators
11	is is not Identity operators
12	in not in Membership operators
13	not or and Logical operators

Decision making is anticipation of conditions occurring while execution of the program and specifying actions taken according to the conditions.

Decision structures evaluate multiple expressions which produce TRUE or FALSE as outcome. You need to determine which action to take and which statements to execute if outcome is TRUE or FALSE otherwise.

Following is the general form of a typical decision making structure found in most of the programming languages −

Python programming language assumes any non-zero and non-null values as TRUE, and if it is either zero or null, then it is assumed as FALSE value.

Python programming language provides following types of decision making statements. Click the following links to check their detail.

Sr.No.	Statement & Description
1	if statements An if statement consists of a boolean expression followed by one or more statements.
2	if...else statements An if statement can be followed by an optional else statement, which executes when the boolean expression is FALSE.
3	nested if statements You can use one if or else if statement inside another if or else if statement(s).

Let us go through each decision making briefly −

Single Statement Suites

If the suite of an if clause consists only of a single line, it may go on the same line as the header statement.

Here is an example of a one-line if clause −

#!/usr/bin/python

var = 100
if ( var == 100 ) : print "Value of expression is 100"
print "Good bye!"

When the above code is executed, it produces the following result −

Value of expression is 100
Good bye!

In general, statements are executed sequentially: The first statement in a function is executed first, followed by the second, and so on. There may be a situation when you need to execute a block of code several number of times.

Programming languages provide various control structures that allow for more complicated execution paths.

A loop statement allows us to execute a statement or group of statements multiple times. The following diagram illustrates a loop statement −

Python programming language provides following types of loops to handle looping requirements.

Sr.No.	Loop Type & Description
1	while loop Repeats a statement or group of statements while a given condition is TRUE. It tests the condition before executing the loop body.
2	for loop Executes a sequence of statements multiple times and abbreviates the code that manages the loop variable.
3	nested loops You can use one or more loop inside any another while, for or do..while loop.

Loop Control Statements

Loop control statements change execution from its normal sequence. When execution leaves a scope, all automatic objects that were created in that scope are destroyed.

Python supports the following control statements. Click the following links to check their detail.

Let us go through the loop control statements briefly

Sr.No.	Control Statement & Description
1	break statement Terminates the loop statement and transfers execution to the statement immediately following the loop.
2	continue statement Causes the loop to skip the remainder of its body and immediately retest its condition prior to reiterating.
3	pass statement The pass statement in Python is used when a statement is required syntactically but you do not want any command or code to execute.

Number data types store numeric values. They are immutable data types, means that changing the value of a number data type results in a newly allocated object.

Number objects are created when you assign a value to them. For example −

var1 = 1
var2 = 10

Sie können den Verweis auf ein Zahlenobjekt auch mit der Taste löschen delErklärung. Die Syntax der del-Anweisung lautet -

del var1[,var2[,var3[....,varN]]]]

Sie können ein einzelnes Objekt oder mehrere Objekte mit der Taste löschen delErklärung. Zum Beispiel -

del var
del var_a, var_b

Python unterstützt vier verschiedene numerische Typen -

• int (signed integers) - Sie werden oft nur als Ganzzahlen oder Ints bezeichnet, sind positive oder negative ganze Zahlen ohne Dezimalpunkt.

• long (long integers ) - Auch Longs genannt, sind sie Ganzzahlen von unbegrenzter Größe, die wie Ganzzahlen geschrieben sind und von einem Groß- oder Kleinbuchstaben L gefolgt werden.

• float (floating point real values)- Auch Floats genannt, stellen sie reelle Zahlen dar und werden mit einem Dezimalpunkt geschrieben, der den ganzzahligen und den gebrochenen Teil teilt. Floats können auch in wissenschaftlicher Notation sein, wobei E oder e die Potenz von 10 angeben (2,5e2 = 2,5 x 10 ² = 250).

• complex (complex numbers)- haben die Form a + bJ, wobei a und b Floats sind und J (oder j) die Quadratwurzel von -1 darstellt (was eine imaginäre Zahl ist). Der Realteil der Zahl ist a und der Imaginärteil ist b. Komplexe Zahlen werden in der Python-Programmierung nicht häufig verwendet.

Beispiele

Hier sind einige Beispiele für Zahlen

int	lange	schweben	Komplex
10	51924361L	0.0	3.14j
100	-0x19323L	15.20	45.j.
-786	0122L	-21,9	9.322e-36j
080	0xDEFABCECBDAECBFBAEL	32,3 + e18	.876j
-0490	535633629843L	-90.	-.6545 + 0J
-0x260	-052318172735L	-32,54e100	3e + 26J
0x69	-4721885298529L	70,2-E12	4,53e-7j

• Mit Python können Sie ein Kleinbuchstaben L mit einem langen L verwenden. Es wird jedoch empfohlen, nur ein Großbuchstaben L zu verwenden, um Verwechslungen mit der Zahl 1 zu vermeiden. Python zeigt lange Ganzzahlen mit einem Großbuchstaben L an.

• Eine komplexe Zahl besteht aus einem geordneten Paar von reellen Gleitkommazahlen, die mit a + bj bezeichnet sind, wobei a der Realteil und b der Imaginärteil der komplexen Zahl ist.

Konvertierung des Zahlentyps

Python konvertiert Zahlen intern in einem Ausdruck, der gemischte Typen enthält, in einen gemeinsamen Typ zur Auswertung. Manchmal müssen Sie jedoch eine Zahl explizit von einem Typ zum anderen zwingen, um die Anforderungen eines Operators oder Funktionsparameters zu erfüllen.

• Art int(x) x in eine einfache Ganzzahl konvertieren.

• Art long(x) um x in eine lange ganze Zahl umzuwandeln.

• Art float(x) um x in eine Gleitkommazahl umzuwandeln.

• Art complex(x) x in eine komplexe Zahl mit Realteil x und Imaginärteil Null umwandeln.

• Art complex(x, y)x und y in eine komplexe Zahl mit Realteil x und Imaginärteil y umwandeln. x und y sind numerische Ausdrücke

Mathematische Funktionen

Python enthält die folgenden Funktionen, die mathematische Berechnungen durchführen.

Sr.Nr.	Funktion & Rückgabe (Beschreibung)
1	abs (x) Der absolute Wert von x: der (positive) Abstand zwischen x und Null.
2	Decke (x) Die Decke von x: die kleinste ganze Zahl nicht weniger als x
3	cmp (x, y) -1 wenn x <y, 0 wenn x == y oder 1 wenn x> y
4	exp (x) Das Exponential von x: e x
5	Fabs (x) Der absolute Wert von x.
6	Boden (x) Der Boden von x: die größte ganze Zahl, die nicht größer als x ist
7	log (x) Der natürliche Logarithmus von x für x> 0
8	log10 (x) Der Basis-10-Logarithmus von x für x> 0.
9	max (x1, x2, ...) Das größte seiner Argumente: der Wert, der der positiven Unendlichkeit am nächsten kommt
10	min (x1, x2, ...) Das kleinste seiner Argumente: der Wert, der der negativen Unendlichkeit am nächsten kommt
11	modf (x) Die gebrochenen und ganzzahligen Teile von x in einem Tupel mit zwei Elementen. Beide Teile haben das gleiche Vorzeichen wie x. Der ganzzahlige Teil wird als Float zurückgegeben.
12	pow (x, y) Der Wert von x ** y.
13	rund (x [, n]) xvom Dezimalpunkt auf n Stellen gerundet. Python rundet als Tie-Breaker von Null ab: Runde (0,5) ist 1,0 und Runde (-0,5) ist -1,0.
14	sqrt (x) Die Quadratwurzel von x für x> 0

Zufallszahlenfunktionen

Zufallszahlen werden für Spiele, Simulationen, Tests, Sicherheits- und Datenschutzanwendungen verwendet. Python enthält die folgenden Funktionen, die häufig verwendet werden.

Sr.Nr.	Bedienungsanleitung
1	Wahl (seq) Ein zufälliges Element aus einer Liste, einem Tupel oder einer Zeichenfolge.
2	randrange ([start,] stop [, step]) Ein zufällig ausgewähltes Element aus dem Bereich (Start, Stopp, Schritt)
3	zufällig() Ein zufälliger Float r, so dass 0 kleiner oder gleich r ist und r kleiner als 1 ist
4	Samen ([x]) Legt den ganzzahligen Startwert fest, der beim Generieren von Zufallszahlen verwendet wird. Rufen Sie diese Funktion auf, bevor Sie eine andere zufällige Modulfunktion aufrufen. Gibt keine zurück.
5	mischen (lst) Randomisiert die Elemente einer Liste an Ort und Stelle. Gibt keine zurück.
6	Uniform (x, y) Ein zufälliger Float r, so dass x kleiner oder gleich r ist und r kleiner als y ist

Trigonometrische Funktionen

Python enthält die folgenden Funktionen, die trigonometrische Berechnungen durchführen.

Sr.Nr.	Bedienungsanleitung
1	acos (x) Geben Sie den Bogenkosinus von x im Bogenmaß zurück.
2	asin (x) Geben Sie den Bogensinus von x im Bogenmaß zurück.
3	atan (x) Geben Sie den Bogentangens von x im Bogenmaß zurück.
4	atan2 (y, x) Geben Sie atan (y / x) im Bogenmaß zurück.
5	cos (x) Geben Sie den Kosinus von x Bogenmaß zurück.
6	Hypot (x, y) Geben Sie die euklidische Norm sqrt (x * x + y * y) zurück.
7	Sünde (x) Geben Sie den Sinus von x Bogenmaß zurück.
8	tan (x) Geben Sie die Tangente von x Bogenmaß zurück.
9	Grad (x) Konvertiert den Winkel x vom Bogenmaß in Grad.
10	Bogenmaß (x) Konvertiert den Winkel x von Grad in Bogenmaß.

Mathematische Konstanten

Das Modul definiert auch zwei mathematische Konstanten -

Sr.Nr.	Konstanten & Beschreibung
1	pi Die mathematische Konstante pi.
2	e Die mathematische Konstante e.

Strings gehören zu den beliebtesten Typen in Python. Wir können sie einfach erstellen, indem wir Zeichen in Anführungszeichen setzen. Python behandelt einfache Anführungszeichen genauso wie doppelte Anführungszeichen. Das Erstellen von Zeichenfolgen ist so einfach wie das Zuweisen eines Werts zu einer Variablen. Zum Beispiel -

var1 = 'Hello World!'
var2 = "Python Programming"

Zugriff auf Werte in Zeichenfolgen

Python unterstützt keinen Zeichentyp. Diese werden als Zeichenfolgen der Länge eins behandelt und daher auch als Teilzeichenfolge betrachtet.

Um auf Teilzeichenfolgen zuzugreifen, verwenden Sie die eckigen Klammern zum Schneiden zusammen mit dem Index oder den Indizes, um Ihre Teilzeichenfolge zu erhalten. Zum Beispiel -

#!/usr/bin/python

var1 = 'Hello World!'
var2 = "Python Programming"

print "var1[0]: ", var1[0]
print "var2[1:5]: ", var2[1:5]

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

var1[0]:  H
var2[1:5]:  ytho

Strings aktualisieren

Sie können eine vorhandene Zeichenfolge "aktualisieren", indem Sie einer anderen Zeichenfolge eine Variable (erneut) zuweisen. Der neue Wert kann mit seinem vorherigen Wert oder mit einer völlig anderen Zeichenfolge verknüpft werden. Zum Beispiel -

#!/usr/bin/python

var1 = 'Hello World!'
print "Updated String :- ", var1[:6] + 'Python'

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Updated String :-  Hello Python

Escape-Charaktere

Die folgende Tabelle enthält eine Liste von Escape- oder nicht druckbaren Zeichen, die mit Backslash-Notation dargestellt werden können.

Ein Escape-Zeichen wird interpretiert. sowohl in einfachen als auch in doppelten Anführungszeichen.

Backslash-Notation	Hexadezimalzeichen	Beschreibung
\ein	0x07	Glocke oder Alarm
\ b	0x08	Rücktaste
\ cx		Control-x
\ Cx		Control-x
\ e	0x1b	Flucht
\ f	0x0c	Formfeed
\ M- \ Cx		Meta-Control-x
\ n	0x0a	Neue Zeile
\ nnn		Oktalschreibweise, wobei n im Bereich von 0,7 liegt
\ r	0x0d	Wagenrücklauf
\ s	0x20	Raum
\ t	0x09	Tab
\ v	0x0b	Vertikale Registerkarte
\ x		Zeichen x
\ xnn		Hexadezimale Notation, wobei n im Bereich von 0,9, af oder AF liegt

String Special Operators

Stringvariable annehmen a hält 'Hallo' und variabel b hält 'Python', dann -

Operator	Beschreibung	Beispiel
+	Verkettung - Fügt Werte auf beiden Seiten des Operators hinzu	a + b gibt HelloPython
* *	Wiederholung - Erstellt neue Zeichenfolgen und verkettet mehrere Kopien derselben Zeichenfolge	a * 2 gibt -HalloHallo
[]	Slice - Gibt den Charakter aus dem angegebenen Index an	a [1] ergibt e
[:]	Range Slice - Gibt die Zeichen aus dem angegebenen Bereich an	a [1: 4] ergibt ell
im	Mitgliedschaft - Gibt true zurück, wenn in der angegebenen Zeichenfolge ein Zeichen vorhanden ist	H in a wird 1 geben
nicht in	Mitgliedschaft - Gibt true zurück, wenn in der angegebenen Zeichenfolge kein Zeichen vorhanden ist	M nicht in einem wird 1 geben
r / R.	Raw String - Unterdrückt die tatsächliche Bedeutung von Escape-Zeichen. Die Syntax für rohe Zeichenfolgen ist genau die gleiche wie für normale Zeichenfolgen, mit Ausnahme des Operators für rohe Zeichenfolgen, dem Buchstaben "r", der vor den Anführungszeichen steht. Das "r" kann Kleinbuchstaben (r) oder Großbuchstaben (R) sein und muss unmittelbar vor dem ersten Anführungszeichen stehen.	print r '\ n' druckt \ n und druckt R '\ n'prints \ n
%.	Formatieren - Führt die Formatierung von Zeichenfolgen durch	Siehe im nächsten Abschnitt

Zeichenfolgenformatierungsoperator

Eine der coolsten Funktionen von Python ist der String-Format-Operator%. Dieser Operator ist nur für Zeichenfolgen verfügbar und gleicht das Paket mit Funktionen aus der printf () -Familie von C aus. Das Folgende ist ein einfaches Beispiel -

#!/usr/bin/python

print "My name is %s and weight is %d kg!" % ('Zara', 21)

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

My name is Zara and weight is 21 kg!

Hier ist die Liste der vollständigen Symbole, die zusammen mit% - verwendet werden können.

Symbol formatieren	Umwandlung
% c	Charakter
% s	Zeichenfolgenkonvertierung über str () vor der Formatierung
%ich	vorzeichenbehaftete Dezimalzahl
% d	vorzeichenbehaftete Dezimalzahl
% u	vorzeichenlose Dezimalzahl
%Ö	oktale Ganzzahl
% x	hexadezimale Ganzzahl (Kleinbuchstaben)
% X.	hexadezimale Ganzzahl (Großbuchstaben)
% e	Exponentialschreibweise (mit Kleinbuchstaben 'e')
% E.	Exponentialschreibweise (mit Großbuchstaben 'E')
% f	reelle Gleitkommazahl
%G	der kürzere von% f und% e
%G	der kürzere von% f und% E.

Weitere unterstützte Symbole und Funktionen sind in der folgenden Tabelle aufgeführt:

Symbol	Funktionalität
* *	Argument gibt Breite oder Genauigkeit an
- -	linke Rechtfertigung
+	Zeigen Sie das Schild an
<sp>	Lassen Sie ein Leerzeichen vor einer positiven Zahl
#	Fügen Sie die oktale führende Null ('0') oder die hexadezimale führende '0x' oder '0X' hinzu, je nachdem, ob 'x' oder 'X' verwendet wurden.
0	Pad von links mit Nullen (anstelle von Leerzeichen)
%.	'%%' hinterlässt ein einzelnes Literal '%'
(var)	Zuordnungsvariable (Wörterbuchargumente)
mn	m ist die minimale Gesamtbreite und n ist die Anzahl der nach dem Dezimalpunkt anzuzeigenden Stellen (falls zutreffend).

Dreifache Zitate

Pythons dreifache Anführungszeichen helfen, indem sie es Strings ermöglichen, mehrere Zeilen zu überspannen, einschließlich wörtlicher NEWLINEs, TABs und anderer Sonderzeichen.

Die Syntax für dreifache Anführungszeichen besteht aus drei aufeinander folgenden single or double Zitate.

#!/usr/bin/python

para_str = """this is a long string that is made up of
several lines and non-printable characters such as
TAB ( \t ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like
this within the brackets [ \n ], or just a NEWLINE within
the variable assignment will also show up.
"""
print para_str

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt. Beachten Sie, wie jedes einzelne Sonderzeichen bis zur letzten NEWLINE am Ende der Zeichenfolge zwischen "up" in seine gedruckte Form konvertiert wurde. und schließende dreifache Anführungszeichen. Beachten Sie auch, dass NEWLINEs entweder mit einem expliziten Wagenrücklauf am Ende einer Zeile oder mit dem Escape-Code (\ n) - auftreten.

this is a long string that is made up of
several lines and non-printable characters such as
TAB (    ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like
this within the brackets [
 ], or just a NEWLINE within
the variable assignment will also show up.

Rohe Zeichenfolgen behandeln den Backslash überhaupt nicht als Sonderzeichen. Jedes Zeichen, das Sie in eine rohe Zeichenfolge einfügen, bleibt so, wie Sie es geschrieben haben -

#!/usr/bin/python

print 'C:\\nowhere'

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

C:\nowhere

Lassen Sie uns nun den rohen String verwenden. Wir würden Ausdruck in setzenr'expression' wie folgt -

#!/usr/bin/python

print r'C:\\nowhere'

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

C:\\nowhere

Unicode-Zeichenfolge

Normale Zeichenfolgen in Python werden intern als 8-Bit-ASCII gespeichert, während Unicode-Zeichenfolgen als 16-Bit-Unicode gespeichert werden. Dies ermöglicht einen vielfältigeren Zeichensatz, einschließlich Sonderzeichen aus den meisten Sprachen der Welt. Ich werde meine Behandlung von Unicode-Zeichenfolgen auf Folgendes beschränken:

#!/usr/bin/python

print u'Hello, world!'

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Hello, world!

Wie Sie sehen können, verwenden Unicode-Zeichenfolgen das Präfix u, ebenso wie rohe Zeichenfolgen das Präfix r.

Integrierte String-Methoden

Python enthält die folgenden integrierten Methoden zum Bearbeiten von Zeichenfolgen:

Sr.Nr.	Methoden mit Beschreibung
1	profitieren() Großschreibung des ersten Buchstabens
2	Mitte (Breite, Füllcharakter) Gibt eine mit Leerzeichen aufgefüllte Zeichenfolge zurück, wobei die ursprüngliche Zeichenfolge auf insgesamt Spalten mit der Breite zentriert ist.
3	count (str, beg = 0, end = len (string)) Zählt, wie oft str in einem String oder in einem String-String vorkommt, wenn der Startindexbeginn und das Endindexende angegeben sind.
4	decodieren (Kodierung = 'UTF-8', Fehler = 'streng') Dekodiert die Zeichenfolge mit dem für die Codierung registrierten Codec. Die Codierung ist standardmäßig die Standard-Zeichenfolgencodierung.
5	encode (encoding = 'UTF-8', error = 'strict') Gibt die codierte String-Version des Strings zurück. Bei einem Fehler wird standardmäßig ein ValueError ausgelöst, es sei denn, Fehler werden mit "Ignorieren" oder "Ersetzen" angegeben.
6	Enden mit (Suffix, beg = 0, end = len (Zeichenfolge)) Legt fest, ob ein String oder ein Teilstring des Strings (wenn Startindexbeginn und Endindexende angegeben sind) mit dem Suffix endet. Gibt in diesem Fall true und andernfalls false zurück.
7	expandtabs (tabsize = 8) Erweitert Registerkarten in Zeichenfolgen auf mehrere Leerzeichen. Der Standardwert beträgt 8 Leerzeichen pro Registerkarte, wenn keine Registerkartengröße angegeben ist.
8	find (str, beg = 0 end = len (string)) Bestimmen Sie, ob str in einem String oder in einem Teilstring eines Strings vorkommt, wenn der Startindexbeginn und das Endindexende den Rückgabeindex erhalten, falls gefunden, und andernfalls -1.
9	Index (str, beg = 0, end = len (string)) Entspricht find (), löst jedoch eine Ausnahme aus, wenn str nicht gefunden wird.
10	isalnum () Gibt true zurück, wenn die Zeichenfolge mindestens 1 Zeichen enthält und alle Zeichen alphanumerisch und andernfalls false sind.
11	isalpha () Gibt true zurück, wenn die Zeichenfolge mindestens 1 Zeichen enthält und alle Zeichen alphabetisch und ansonsten false sind.
12	isdigit () Gibt true zurück, wenn der String nur Ziffern enthält, andernfalls false.
13	ist tiefer() Gibt true zurück, wenn die Zeichenfolge mindestens 1 Großbuchstaben enthält und alle Großbuchstaben in Kleinbuchstaben und andernfalls false sind.
14	isnumerisch () Gibt true zurück, wenn eine Unicode-Zeichenfolge nur numerische Zeichen enthält, andernfalls false.
15	isspace () Gibt true zurück, wenn der String nur Leerzeichen enthält, andernfalls false.
16	istitle () Gibt true zurück, wenn die Zeichenfolge ordnungsgemäß "titlecased" ist, andernfalls false.
17	isupper () Gibt true zurück, wenn die Zeichenfolge mindestens ein Großbuchstaben enthält und alle Großbuchstaben in Großbuchstaben und andernfalls false sind.
18	join (seq) Fügt (verkettet) die Zeichenfolgendarstellungen von Elementen in der folgenden Sequenz zu einer Zeichenfolge mit Trennzeichen zusammen.
19	len (string) Gibt die Länge der Zeichenfolge zurück
20	ljust (width [, fillchar]) Gibt eine mit Leerzeichen aufgefüllte Zeichenfolge zurück, wobei die ursprüngliche Zeichenfolge linksbündig auf insgesamt Spalten mit Breite ausgerichtet ist.
21	niedriger() Konvertiert alle Großbuchstaben in Zeichenfolgen in Kleinbuchstaben.
22	lstrip () Entfernt alle führenden Leerzeichen in der Zeichenfolge.
23	maketrans () Gibt eine Übersetzungstabelle zurück, die in der Übersetzungsfunktion verwendet werden soll.
24	max (str) Gibt das maximale alphabetische Zeichen aus der Zeichenfolge str zurück.
25	min (str) Gibt das minimale alphabetische Zeichen aus der Zeichenfolge str zurück.
26	ersetzen (alt, neu [, max]) Ersetzt alle alten Vorkommen in der Zeichenfolge durch neue oder höchstens maximale Vorkommen, wenn max angegeben ist.
27	rfind (str, beg = 0, end = len (string)) Wie find (), jedoch in einer Zeichenfolge rückwärts suchen.
28	rindex (str, beg = 0, end = len (string)) Wie index (), jedoch in Zeichenfolge rückwärts suchen.
29	rjust (width, [, fillchar]) Gibt eine mit Leerzeichen aufgefüllte Zeichenfolge zurück, wobei die ursprüngliche Zeichenfolge rechtsbündig auf insgesamt Spalten mit Breite ausgerichtet ist.
30	rstrip () Entfernt alle nachgestellten Leerzeichen der Zeichenfolge.
31	split (str = "", num = string.count (str)) Teilt die Zeichenfolge nach dem Trennzeichen str (Leerzeichen, falls nicht angegeben) und gibt eine Liste der Teilzeichenfolgen zurück. Wenn angegeben, in höchstens eine Anzahl von Teilzeichenfolgen aufteilen.
32	Splitlines (num = string.count ('\ n')) Teilt die Zeichenfolge aller (oder num) NEWLINEs und gibt eine Liste jeder Zeile mit entfernten NEWLINEs zurück.
33	Start mit (str, beg = 0, end = len (string)) Legt fest, ob eine Zeichenfolge oder eine Teilzeichenfolge der Zeichenfolge (wenn Startindexbeginn und Endindexende angegeben sind) mit Teilzeichenfolge str beginnt. Gibt in diesem Fall true und andernfalls false zurück.
34	Streifen ([Zeichen]) Führt sowohl lstrip () als auch rstrip () für einen String aus.
35	Swapcase () Kehrt die Groß- und Kleinschreibung für alle Buchstaben in der Zeichenfolge um.
36	Titel() Gibt die "titlecased" -Version der Zeichenfolge zurück, dh alle Wörter beginnen mit Großbuchstaben und der Rest ist in Kleinbuchstaben.
37	übersetzen (Tabelle, deletechars = "") Übersetzt die Zeichenfolge gemäß der Übersetzungstabelle str (256 Zeichen) und entfernt die Zeichen in der del-Zeichenfolge.
38	Oberer, höher() Konvertiert Kleinbuchstaben in Zeichenfolgen in Großbuchstaben.
39	zfill (Breite) Gibt die ursprüngliche Zeichenfolge zurück, die mit Nullen auf insgesamt Breite Zeichen aufgefüllt ist. zfill () ist für Zahlen vorgesehen und behält jedes vorgegebene Vorzeichen (weniger als eine Null).
40	isdecimal () Gibt true zurück, wenn eine Unicode-Zeichenfolge nur Dezimalzeichen enthält, andernfalls false.

Die grundlegendste Datenstruktur in Python ist die sequence. Jedem Element einer Sequenz wird eine Nummer zugewiesen - seine Position oder sein Index. Der erste Index ist Null, der zweite Index ist Eins und so weiter.

Python hat sechs integrierte Arten von Sequenzen, aber die häufigsten sind Listen und Tupel, die wir in diesem Tutorial sehen würden.

Es gibt bestimmte Dinge, die Sie mit allen Sequenztypen tun können. Diese Vorgänge umfassen das Indizieren, Schneiden, Hinzufügen, Multiplizieren und Überprüfen der Mitgliedschaft. Darüber hinaus verfügt Python über integrierte Funktionen zum Ermitteln der Länge einer Sequenz und zum Ermitteln der größten und kleinsten Elemente.

Python-Listen

Die Liste ist ein äußerst vielseitiger Datentyp, der in Python verfügbar ist und als Liste von durch Kommas getrennten Werten (Elementen) in eckigen Klammern geschrieben werden kann. Wichtig an einer Liste ist, dass Elemente in einer Liste nicht vom gleichen Typ sein müssen.

Das Erstellen einer Liste ist so einfach wie das Einfügen verschiedener durch Kommas getrennter Werte in eckige Klammern. Zum Beispiel -

list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"]

Ähnlich wie bei Zeichenfolgenindizes beginnen Listenindizes bei 0, und Listen können in Scheiben geschnitten, verkettet usw. werden.

Zugriff auf Werte in Listen

Um auf Werte in Listen zuzugreifen, verwenden Sie die eckigen Klammern zum Schneiden zusammen mit dem Index oder den Indizes, um den an diesem Index verfügbaren Wert zu erhalten. Zum Beispiel -

#!/usr/bin/python

list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];
print "list1[0]: ", list1[0]
print "list2[1:5]: ", list2[1:5]

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

list1[0]:  physics
list2[1:5]:  [2, 3, 4, 5]

Listen aktualisieren

Sie können einzelne oder mehrere Elemente von Listen aktualisieren, indem Sie das Slice auf der linken Seite des Zuweisungsoperators angeben, und Sie können Elemente in einer Liste mit der Methode append () hinzufügen. Zum Beispiel -

#!/usr/bin/python

list = ['physics', 'chemistry', 1997, 2000];
print "Value available at index 2 : "
print list[2]
list[2] = 2001;
print "New value available at index 2 : "
print list[2]

Note - Die Methode append () wird im folgenden Abschnitt erläutert.

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Value available at index 2 :
1997
New value available at index 2 :
2001

Listenelemente löschen

Um ein Listenelement zu entfernen, können Sie entweder die del-Anweisung verwenden, wenn Sie genau wissen, welche Elemente Sie löschen, oder die remove () -Methode, wenn Sie nicht wissen. Zum Beispiel -

#!/usr/bin/python

list1 = ['physics', 'chemistry', 1997, 2000];
print list1
del list1[2];
print "After deleting value at index 2 : "
print list1

Wenn der obige Code ausgeführt wird, erzeugt er folgendes Ergebnis:

['physics', 'chemistry', 1997, 2000]
After deleting value at index 2 :
['physics', 'chemistry', 2000]

Note - Die Methode remove () wird im folgenden Abschnitt erläutert.

Grundlegende Listenoperationen

Listen reagieren auf die Operatoren + und * ähnlich wie Zeichenfolgen. Sie bedeuten auch hier Verkettung und Wiederholung, außer dass das Ergebnis eine neue Liste ist, keine Zeichenfolge.

Tatsächlich reagieren Listen auf alle allgemeinen Sequenzoperationen, die wir im vorherigen Kapitel für Zeichenfolgen verwendet haben.

Python-Ausdruck	Ergebnisse	Beschreibung
len ([1, 2, 3])	3	Länge
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	Verkettung
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	Wiederholung
3 in [1, 2, 3]	Wahr	Mitgliedschaft
für x in [1, 2, 3]: drucke x,	1 2 3	Wiederholung

Indizieren, Schneiden und Matrizen

Da Listen Sequenzen sind, funktionieren Indizieren und Schneiden für Listen genauso wie für Zeichenfolgen.

Angenommen, folgende Eingabe -

L = ['spam', 'Spam', 'SPAM!']

Python-Ausdruck	Ergebnisse	Beschreibung
L [2]	SPAM!	Offsets beginnen bei Null
L [-2]	Spam	Negativ: von rechts zählen
L [1:]	['Spam', 'SPAM!']	Das Schneiden holt Abschnitte

Integrierte Listenfunktionen und -methoden

Python enthält die folgenden Listenfunktionen:

Sr.Nr.	Funktion mit Beschreibung
1	cmp (Liste1, Liste2) Vergleicht Elemente beider Listen.
2	len (Liste) Gibt die Gesamtlänge der Liste an.
3	max (Liste) Gibt ein Element aus der Liste mit dem Maximalwert zurück.
4	min (Liste) Gibt ein Element aus der Liste mit dem Mindestwert zurück.
5	Liste (seq) Konvertiert ein Tupel in eine Liste.

Python enthält die folgenden Listenmethoden

Sr.Nr.	Methoden mit Beschreibung
1	list.append (obj) Hängt das Objekt obj an die Liste an
2	list.count (obj) Gibt die Anzahl zurück, wie oft obj in der Liste vorkommt
3	list.extend (seq) Hängt den Inhalt von seq an die Liste an
4	list.index (obj) Gibt den niedrigsten Index in der Liste zurück, der obj angezeigt wird
5	list.insert (index, obj) Fügt das Objekt obj am Offset-Index in die Liste ein
6	list.pop (obj = list [-1]) Entfernt das letzte Objekt oder Objekt und gibt es aus der Liste zurück
7	list.remove (obj) Entfernt das Objekt obj aus der Liste
8	list.reverse () Kehrt Objekte der Liste um
9	list.sort ([func]) Sortiert Objekte der Liste, verwenden Sie die Vergleichsfunktion, falls angegeben

Ein Tupel ist eine unveränderliche Folge von Python-Objekten. Tupel sind Sequenzen, genau wie Listen. Die Unterschiede zwischen Tupeln und Listen bestehen darin, dass die Tupel im Gegensatz zu Listen nicht geändert werden können und Tupel Klammern verwenden, während Listen eckige Klammern verwenden.

Das Erstellen eines Tupels ist so einfach wie das Einfügen verschiedener durch Kommas getrennter Werte. Optional können Sie diese durch Kommas getrennten Werte auch in Klammern setzen. Zum Beispiel -

tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";

Das leere Tupel wird als zwei Klammern geschrieben, die nichts enthalten -

tup1 = ();

Um ein Tupel mit einem einzelnen Wert zu schreiben, müssen Sie ein Komma einfügen, obwohl es nur einen Wert gibt -

tup1 = (50,);

Wie String-Indizes beginnen Tupel-Indizes bei 0 und können in Scheiben geschnitten, verkettet usw. werden.

Zugriff auf Werte in Tupeln

Um auf Werte in Tupel zuzugreifen, verwenden Sie die eckigen Klammern zum Schneiden zusammen mit dem Index oder den Indizes, um den an diesem Index verfügbaren Wert zu erhalten. Zum Beispiel -

#!/usr/bin/python

tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5, 6, 7 );
print "tup1[0]: ", tup1[0];
print "tup2[1:5]: ", tup2[1:5];

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

tup1[0]:  physics
tup2[1:5]:  [2, 3, 4, 5]

Tupel aktualisieren

Tupel sind unveränderlich, dh Sie können die Werte von Tupelelementen nicht aktualisieren oder ändern. Sie können Teile vorhandener Tupel verwenden, um neue Tupel zu erstellen, wie das folgende Beispiel zeigt:

#!/usr/bin/python

tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');

# Following action is not valid for tuples
# tup1[0] = 100;

# So let's create a new tuple as follows
tup3 = tup1 + tup2;
print tup3;

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

(12, 34.56, 'abc', 'xyz')

Tupelelemente löschen

Das Entfernen einzelner Tupelelemente ist nicht möglich. Es ist natürlich nichts Falsches daran, ein weiteres Tupel mit den unerwünschten Elementen zusammenzustellen, die weggeworfen wurden.

Um ein ganzes Tupel explizit zu entfernen, verwenden Sie einfach das delErklärung. Zum Beispiel -

#!/usr/bin/python

tup = ('physics', 'chemistry', 1997, 2000);
print tup;
del tup;
print "After deleting tup : ";
print tup;

Dies führt zu folgendem Ergebnis. Beachten Sie eine Ausnahme, die ausgelöst wird, weil nachdel tup Tupel existiert nicht mehr -

('physics', 'chemistry', 1997, 2000)
After deleting tup :
Traceback (most recent call last):
   File "test.py", line 9, in <module>
      print tup;
NameError: name 'tup' is not defined

Grundlegende Tupeloperationen

Tupel reagieren auf die Operatoren + und * ähnlich wie Zeichenfolgen. Sie bedeuten auch hier Verkettung und Wiederholung, außer dass das Ergebnis ein neues Tupel und keine Zeichenfolge ist.

Tatsächlich reagieren Tupel auf alle allgemeinen Sequenzoperationen, die wir im vorherigen Kapitel für Zeichenfolgen verwendet haben.

Python-Ausdruck	Ergebnisse	Beschreibung
len ((1, 2, 3))	3	Länge
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	Verkettung
('Hi!') * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	Wiederholung
3 in (1, 2, 3)	Wahr	Mitgliedschaft
für x in (1, 2, 3): drucke x,	1 2 3	Wiederholung

Indizieren, Schneiden und Matrizen

Da Tupel Sequenzen sind, funktionieren Indizieren und Schneiden für Tupel genauso wie für Zeichenfolgen. Angenommen, folgende Eingabe -

L = ('spam', 'Spam', 'SPAM!')

 

Python-Ausdruck	Ergebnisse	Beschreibung
L [2]	'SPAM!'	Offsets beginnen bei Null
L [-2]	'Spam'	Negativ: von rechts zählen
L [1:]	['Spam', 'SPAM!']	Das Schneiden holt Abschnitte

Keine umschließenden Begrenzer

Jeder Satz mehrerer Objekte, die durch Kommas getrennt sind und ohne identifizierende Symbole geschrieben wurden, dh Klammern für Listen, Klammern für Tupel usw., verwendet standardmäßig Tupel, wie in diesen kurzen Beispielen angegeben.

#!/usr/bin/python

print 'abc', -4.24e93, 18+6.6j, 'xyz';
x, y = 1, 2;
print "Value of x , y : ", x,y;

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

abc -4.24e+93 (18+6.6j) xyz
Value of x , y : 1 2

Eingebaute Tupelfunktionen

Python enthält die folgenden Tupelfunktionen:

Sr.Nr.	Funktion mit Beschreibung
1	cmp (tuple1, tuple2) Vergleicht Elemente beider Tupel.
2	len (Tupel) Gibt die Gesamtlänge des Tupels an.
3	max (Tupel) Gibt ein Element aus dem Tupel mit dem Maximalwert zurück.
4	min (Tupel) Gibt ein Element aus dem Tupel mit dem Mindestwert zurück.
5	Tupel (seq) Konvertiert eine Liste in Tupel.

Jeder Schlüssel ist durch einen Doppelpunkt (:) von seinem Wert getrennt, die Elemente sind durch Kommas getrennt und das Ganze ist in geschweiften Klammern eingeschlossen. Ein leeres Wörterbuch ohne Elemente wird mit nur zwei geschweiften Klammern wie folgt geschrieben: {}.

Schlüssel sind innerhalb eines Wörterbuchs eindeutig, Werte jedoch möglicherweise nicht. Die Werte eines Wörterbuchs können von einem beliebigen Typ sein, die Schlüssel müssen jedoch von einem unveränderlichen Datentyp sein, z. B. Zeichenfolgen, Zahlen oder Tupel.

Zugriff auf Werte im Wörterbuch

Um auf Wörterbuchelemente zuzugreifen, können Sie die bekannten eckigen Klammern zusammen mit dem Schlüssel verwenden, um dessen Wert zu erhalten. Das Folgende ist ein einfaches Beispiel -

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print "dict['Name']: ", dict['Name']
print "dict['Age']: ", dict['Age']

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

dict['Name']:  Zara
dict['Age']:  7

Wenn wir versuchen, mit einem Schlüssel, der nicht Teil des Wörterbuchs ist, auf ein Datenelement zuzugreifen, wird folgende Fehlermeldung angezeigt:

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print "dict['Alice']: ", dict['Alice']

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

dict['Alice']:
Traceback (most recent call last):
   File "test.py", line 4, in <module>
      print "dict['Alice']: ", dict['Alice'];
KeyError: 'Alice'

Wörterbuch aktualisieren

Sie können ein Wörterbuch aktualisieren, indem Sie einen neuen Eintrag oder ein Schlüssel-Wert-Paar hinzufügen, einen vorhandenen Eintrag ändern oder einen vorhandenen Eintrag löschen, wie unten im einfachen Beispiel gezeigt.

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
dict['Age'] = 8; # update existing entry
dict['School'] = "DPS School"; # Add new entry

print "dict['Age']: ", dict['Age']
print "dict['School']: ", dict['School']

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

dict['Age']:  8
dict['School']:  DPS School

Wörterbuchelemente löschen

Sie können entweder einzelne Wörterbuchelemente entfernen oder den gesamten Inhalt eines Wörterbuchs löschen. Sie können auch das gesamte Wörterbuch in einem einzigen Vorgang löschen.

Um ein gesamtes Wörterbuch explizit zu entfernen, verwenden Sie einfach die delErklärung. Das Folgende ist ein einfaches Beispiel -

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
del dict['Name']; # remove entry with key 'Name'
dict.clear();     # remove all entries in dict
del dict ;        # delete entire dictionary

print "dict['Age']: ", dict['Age']
print "dict['School']: ", dict['School']

Dies führt zu folgendem Ergebnis. Beachten Sie, dass eine Ausnahme ausgelöst wird, weil nachdel dict Wörterbuch existiert nicht mehr -

dict['Age']:
Traceback (most recent call last):
   File "test.py", line 8, in <module>
      print "dict['Age']: ", dict['Age'];
TypeError: 'type' object is unsubscriptable

Note Die Methode del () wird im folgenden Abschnitt erläutert.

Eigenschaften von Wörterbuchschlüsseln

Wörterbuchwerte unterliegen keinen Einschränkungen. Dies können beliebige Python-Objekte sein, entweder Standardobjekte oder benutzerdefinierte Objekte. Gleiches gilt jedoch nicht für die Schlüssel.

Bei Wörterbuchschlüsseln sind zwei wichtige Punkte zu beachten:

(a)Mehr als ein Eintrag pro Schlüssel nicht erlaubt. Dies bedeutet, dass kein doppelter Schlüssel zulässig ist. Wenn während der Zuweisung doppelte Schlüssel gefunden werden, gewinnt die letzte Zuweisung. Zum Beispiel -

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'}
print "dict['Name']: ", dict['Name']

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

dict['Name']:  Manni

(b)Schlüssel müssen unveränderlich sein. Das heißt, Sie können Zeichenfolgen, Zahlen oder Tupel als Wörterbuchschlüssel verwenden, aber so etwas wie ['Schlüssel'] ist nicht zulässig. Das Folgende ist ein einfaches Beispiel -

#!/usr/bin/python

dict = {['Name']: 'Zara', 'Age': 7}
print "dict['Name']: ", dict['Name']

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Traceback (most recent call last):
   File "test.py", line 3, in <module>
      dict = {['Name']: 'Zara', 'Age': 7};
TypeError: unhashable type: 'list'

Integrierte Wörterbuchfunktionen und -methoden

Python enthält die folgenden Wörterbuchfunktionen:

Sr.Nr.	Funktion mit Beschreibung
1	cmp (dict1, dict2) Vergleicht Elemente beider Diktate.
2	len (dikt) Gibt die Gesamtlänge des Wörterbuchs an. Dies entspricht der Anzahl der Elemente im Wörterbuch.
3	str (dikt) Erzeugt eine druckbare Zeichenfolgendarstellung eines Wörterbuchs
4	Typ (Variable) Gibt den Typ der übergebenen Variablen zurück. Wenn die übergebene Variable ein Wörterbuch ist, wird ein Wörterbuchtyp zurückgegeben.

Python enthält die folgenden Wörterbuchmethoden:

Sr.Nr.	Methoden mit Beschreibung
1	dict.clear () Entfernt alle Elemente des Wörterbuch- Diktats
2	dict.copy () Gibt eine flache Kopie des Wörterbuchs dikt zurück
3	dict.fromkeys () Erstellen Sie ein neues Wörterbuch mit Schlüsseln aus seq und Werten, die auf value gesetzt sind .
4	dict.get (Schlüssel, Standard = Keine) Für Schlüssel Schlüssel, gibt Wert oder Standard , wenn Schlüssel nicht im Wörterbuch
5	dict.has_key (Schlüssel) Gibt true zurück, wenn das Wörterbuch dikt eingegeben wurde , andernfalls false
6	dict.items () Gibt eine Liste der Tupelpaare von dict (Schlüssel, Wert) zurück
7	dict.keys () Gibt eine Liste der Schlüssel des Wörterbuchs zurück
8	dict.setdefault (Schlüssel, Standard = Keine) Ähnlich wie get (), setzt jedoch dict [key] = default, wenn key noch nicht in dict enthalten ist
9	dict.update (dict2) Fügt Wörterbuch dict2 ‚s Schlüsselwerte - Paare zu dict
10	dict.values ​​() Gibt eine Liste der Werte des Wörterbuchs dikt zurück

Ein Python-Programm kann Datum und Uhrzeit auf verschiedene Arten verarbeiten. Das Konvertieren zwischen Datumsformaten ist eine häufige Aufgabe für Computer. Die Zeit- und Kalendermodule von Python helfen bei der Verfolgung von Datum und Uhrzeit.

Was ist Zecke?

Zeitintervalle sind Gleitkommazahlen in Einheiten von Sekunden. Bestimmte Zeitpunkte werden seit dem 1. Januar 1970 (Epoche) um 00:00:00 Uhr in Sekunden ausgedrückt.

Es gibt eine beliebte timeIn Python verfügbares Modul, das Funktionen zum Arbeiten mit Zeiten und zum Konvertieren zwischen Darstellungen bietet. Die Funktion time.time () gibt die aktuelle Systemzeit in Ticks seit 00:00:00 Uhr 1. Januar 1970 (Epoche) zurück.

Beispiel

#!/usr/bin/python
import time;  # This is required to include time module.

ticks = time.time()
print "Number of ticks since 12:00am, January 1, 1970:", ticks

Dies würde zu einem Ergebnis führen, das wie folgt lautet:

Number of ticks since 12:00am, January 1, 1970: 7186862.73399

Datumsarithmetik ist einfach mit Zecken zu tun. Daten vor der Epoche können in dieser Form jedoch nicht dargestellt werden. Daten in ferner Zukunft können auch nicht so dargestellt werden - der Grenzwert liegt irgendwann im Jahr 2038 für UNIX und Windows.

Was ist TimeTuple?

Viele der Zeitfunktionen von Python behandeln die Zeit als Tupel mit 9 Zahlen, wie unten gezeigt -

Index	Feld	Werte
0	4-stelliges Jahr	2008
1	Monat	1 bis 12
2	Tag	1 bis 31
3	Stunde	0 bis 23
4	Minute	0 bis 59
5	Zweite	0 bis 61 (60 oder 61 sind Schaltsekunden)
6	Wochentag	0 bis 6 (0 ist Montag)
7	Tag des Jahres	1 bis 366 (julianischer Tag)
8	Sommerzeit	-1, 0, 1, -1 bedeutet, dass die Bibliothek die Sommerzeit bestimmt

Das obige Tupel entspricht struct_timeStruktur. Diese Struktur hat folgende Attribute:

Index	Attribute	Werte
0	tm_year	2008
1	tm_mon	1 bis 12
2	tm_mday	1 bis 31
3	tm_hour	0 bis 23
4	tm_min	0 bis 59
5	tm_sec	0 bis 61 (60 oder 61 sind Schaltsekunden)
6	tm_wday	0 bis 6 (0 ist Montag)
7	tm_yday	1 bis 366 (julianischer Tag)
8	tm_isdst	-1, 0, 1, -1 bedeutet, dass die Bibliothek die Sommerzeit bestimmt

Aktuelle Zeit abrufen

Übergeben Sie den Gleitkommawert an eine Funktion (z. B. Ortszeit), die ein Zeittupel mit allen neun gültigen Elementen zurückgibt, um einen Zeitpunkt aus einer Sekunde seit dem Gleitkommawert der Epoche in ein Zeittupel zu übersetzen.

#!/usr/bin/python
import time;

localtime = time.localtime(time.time())
print "Local current time :", localtime

Dies würde das folgende Ergebnis erzeugen, das in jeder anderen vorzeigbaren Form formatiert werden könnte -

Local current time : time.struct_time(tm_year=2013, tm_mon=7, 
tm_mday=17, tm_hour=21, tm_min=26, tm_sec=3, tm_wday=2, tm_yday=198, tm_isdst=0)

Formatierte Zeit abrufen

Sie können jederzeit gemäß Ihren Anforderungen formatieren, aber die einfache Methode, um Zeit in lesbarem Format zu erhalten, ist asctime () -

#!/usr/bin/python
import time;

localtime = time.asctime( time.localtime(time.time()) )
print "Local current time :", localtime

Dies würde das folgende Ergebnis erzeugen -

Local current time : Tue Jan 13 10:17:09 2009

Kalender für einen Monat abrufen

Das Kalendermodul bietet eine breite Palette von Methoden zum Spielen mit Jahres- und Monatskalendern. Hier drucken wir einen Kalender für einen bestimmten Monat (Januar 2008) -

#!/usr/bin/python
import calendar

cal = calendar.month(2008, 1)
print "Here is the calendar:"
print cal

Dies würde das folgende Ergebnis erzeugen -

Here is the calendar:
   January 2008
Mo Tu We Th Fr Sa Su
    1  2  3  4  5  6
 7  8  9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30 31

Die Zeit - Modul

Es gibt eine beliebte timeIn Python verfügbares Modul, das Funktionen zum Arbeiten mit Zeiten und zum Konvertieren zwischen Darstellungen bietet. Hier ist die Liste aller verfügbaren Methoden -

Sr.Nr.	Funktion mit Beschreibung
1	time.altzone Der Versatz der lokalen Sommerzeitzone in Sekunden westlich von UTC, falls definiert. Dies ist negativ, wenn die lokale Sommerzeitzone östlich von UTC liegt (wie in Westeuropa, einschließlich Großbritannien). Verwenden Sie diese Option nur, wenn das Tageslicht ungleich Null ist.
2	time.asctime ([tupletime]) Akzeptiert ein Zeittupel und gibt eine lesbare Zeichenfolge mit 24 Zeichen zurück, z. B. "Di, 11. Dezember, 18:07:14 2008".
3	Zeit Uhr( ) Gibt die aktuelle CPU-Zeit als Gleitkommazahl von Sekunden zurück. Um die Berechnungskosten verschiedener Ansätze zu messen, ist der Wert von time.clock nützlicher als der von time.time ().
4	time.ctime ([secs]) Wie asctime (localtime (secs)) und ohne Argumente ist wie asctime ()
5	time.gmtime ([secs]) Akzeptiert einen in Sekunden seit der Epoche ausgedrückten Moment und gibt ein Zeittupel t mit der UTC-Zeit zurück. Hinweis: t.tm_isdst ist immer 0
6	time.localtime ([secs]) Akzeptiert einen in Sekunden seit der Epoche ausgedrückten Zeitpunkt und gibt ein Zeittupel t mit der Ortszeit zurück (t.tm_isdst ist 0 oder 1, abhängig davon, ob die Sommerzeit nach lokalen Regeln für Sofortsekunden gilt).
7	time.mktime (tupletime) Akzeptiert einen Moment, der als Zeittupel in der Ortszeit ausgedrückt wird, und gibt einen Gleitkommawert zurück, wobei der Moment in Sekunden seit der Epoche ausgedrückt wird.
8	time.sleep (secs) Hält den aufrufenden Thread für Sekunden an.
9	time.strftime (fmt [, tupletime]) Akzeptiert einen als Zeittupel in der Ortszeit ausgedrückten Zeitpunkt und gibt eine Zeichenfolge zurück, die den durch die Zeichenfolge fmt angegebenen Zeitpunkt darstellt.
10	time.strptime (str, fmt = '% a% b% d% H:% M:% S% Y') Analysiert str gemäß der Formatzeichenfolge fmt und gibt den Moment im Zeittupelformat zurück.
11	Zeit Zeit( ) Gibt den aktuellen Zeitpunkt zurück, eine Gleitkommazahl von Sekunden seit der Epoche.
12	time.tzset () Setzt die von den Bibliotheksroutinen verwendeten Zeitkonvertierungsregeln zurück. Die Umgebungsvariable TZ gibt an, wie dies gemacht wird.

Lassen Sie uns kurz die Funktionen durchgehen -

Für das Zeitmodul stehen zwei wichtige Attribute zur Verfügung:

Sr.Nr.	Attribut mit Beschreibung
1	time.timezone Das Attribut time.timezone ist der Versatz in Sekunden der lokalen Zeitzone (ohne Sommerzeit) von UTC (> 0 in Amerika; <= 0 in den meisten Teilen Europas, Asiens, Afrikas).
2	time.tzname Das Attribut time.tzname ist ein Paar von vom Gebietsschema abhängigen Zeichenfolgen, bei denen es sich um die Namen der lokalen Zeitzone ohne bzw. mit Sommerzeit handelt.

Das Kalendermodul

Das Kalendermodul bietet kalenderbezogene Funktionen, einschließlich Funktionen zum Drucken eines Textkalenders für einen bestimmten Monat oder ein bestimmtes Jahr.

Standardmäßig verwendet der Kalender Montag als ersten Tag der Woche und Sonntag als letzten. Um dies zu ändern, rufen Sie die Funktion calendar.setfirstweekday () auf.

Here is a list of functions available with the calendar module −

Sr.No.	Function with Description
1	calendar.calendar(year,w=2,l=1,c=6) Returns a multiline string with a calendar for year year formatted into three columns separated by c spaces. w is the width in characters of each date; each line has length 21*w+18+2*c. l is the number of lines for each week.
2	calendar.firstweekday( ) Returns the current setting for the weekday that starts each week. By default, when calendar is first imported, this is 0, meaning Monday.
3	calendar.isleap(year) Returns True if year is a leap year; otherwise, False.
4	calendar.leapdays(y1,y2) Returns the total number of leap days in the years within range(y1,y2).
5	calendar.month(year,month,w=2,l=1) Returns a multiline string with a calendar for month month of year year, one line per week plus two header lines. w is the width in characters of each date; each line has length 7*w+6. l is the number of lines for each week.
6	calendar.monthcalendar(year,month) Returns a list of lists of ints. Each sublist denotes a week. Days outside month month of year year are set to 0; days within the month are set to their day-of-month, 1 and up.
7	calendar.monthrange(year,month) Returns two integers. The first one is the code of the weekday for the first day of the month month in year year; the second one is the number of days in the month. Weekday codes are 0 (Monday) to 6 (Sunday); month numbers are 1 to 12.
8	calendar.prcal(year,w=2,l=1,c=6) Like print calendar.calendar(year,w,l,c).
9	calendar.prmonth(year,month,w=2,l=1) Like print calendar.month(year,month,w,l).
10	calendar.setfirstweekday(weekday) Sets the first day of each week to weekday code weekday. Weekday codes are 0 (Monday) to 6 (Sunday).
11	calendar.timegm(tupletime) The inverse of time.gmtime: accepts a time instant in time-tuple form and returns the same instant as a floating-point number of seconds since the epoch.
12	calendar.weekday(year,month,day) Returns the weekday code for the given date. Weekday codes are 0 (Monday) to 6 (Sunday); month numbers are 1 (January) to 12 (December).

Other Modules & Functions

If you are interested, then here you would find a list of other important modules and functions to play with date & time in Python −

• The datetime Module

• The pytz Module

• The dateutil Module

Eine Funktion ist ein Block aus organisiertem, wiederverwendbarem Code, mit dem eine einzelne verwandte Aktion ausgeführt wird. Funktionen bieten eine bessere Modularität für Ihre Anwendung und einen hohen Grad an Wiederverwendung von Code.

Wie Sie bereits wissen, bietet Python viele integrierte Funktionen wie print () usw. Sie können jedoch auch eigene Funktionen erstellen. Diese Funktionen werden als benutzerdefinierte Funktionen bezeichnet.

Funktion definieren

Sie können Funktionen definieren, um die erforderliche Funktionalität bereitzustellen. Hier sind einfache Regeln zum Definieren einer Funktion in Python.

• Funktionsbausteine ​​beginnen mit dem Schlüsselwort def gefolgt vom Funktionsnamen und den Klammern (()).

• Alle Eingabeparameter oder Argumente sollten in diese Klammern gesetzt werden. Sie können auch Parameter in diesen Klammern definieren.

• Die erste Anweisung einer Funktion kann eine optionale Anweisung sein - die Dokumentationszeichenfolge der Funktion oder der Dokumentzeichenfolge .

• Der Codeblock in jeder Funktion beginnt mit einem Doppelpunkt (:) und wird eingerückt.

• Die Anweisung return [Ausdruck] beendet eine Funktion und gibt optional einen Ausdruck an den Aufrufer zurück. Eine return-Anweisung ohne Argumente ist dasselbe wie return None.

Syntax

def functionname( parameters ):
   "function_docstring"
   function_suite
   return [expression]

Standardmäßig haben Parameter ein Positionsverhalten, und Sie müssen sie in derselben Reihenfolge informieren, in der sie definiert wurden.

Beispiel

Die folgende Funktion verwendet eine Zeichenfolge als Eingabeparameter und druckt sie auf dem Standardbildschirm aus.

def printme( str ):
   "This prints a passed string into this function"
   print str
   return

Eine Funktion aufrufen

Das Definieren einer Funktion gibt ihr nur einen Namen, gibt die Parameter an, die in die Funktion aufgenommen werden sollen, und strukturiert die Codeblöcke.

Sobald die Grundstruktur einer Funktion fertiggestellt ist, können Sie sie ausführen, indem Sie sie von einer anderen Funktion oder direkt von der Python-Eingabeaufforderung aus aufrufen. Das folgende Beispiel ruft die Funktion printme () auf -

#!/usr/bin/python

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print str
   return;

# Now you can call printme function
printme("I'm first call to user defined function!")
printme("Again second call to the same function")

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

I'm first call to user defined function!
Again second call to the same function

Als Referenz gegen Wert übergeben

Alle Parameter (Argumente) in der Python-Sprache werden als Referenz übergeben. Wenn Sie ändern, worauf sich ein Parameter innerhalb einer Funktion bezieht, wird die Änderung auch in der aufrufenden Funktion wiedergegeben. Zum Beispiel -

#!/usr/bin/python

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist.append([1,2,3,4]);
   print "Values inside the function: ", mylist
   return

# Now you can call changeme function
mylist = [10,20,30];
changeme( mylist );
print "Values outside the function: ", mylist

Hier behalten wir die Referenz des übergebenen Objekts bei und hängen Werte an dasselbe Objekt an. Dies würde also zu folgendem Ergebnis führen:

Values inside the function:  [10, 20, 30, [1, 2, 3, 4]]
Values outside the function:  [10, 20, 30, [1, 2, 3, 4]]

Es gibt noch ein weiteres Beispiel, bei dem Argumente als Referenz übergeben werden und die Referenz innerhalb der aufgerufenen Funktion überschrieben wird.

#!/usr/bin/python

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist = [1,2,3,4]; # This would assig new reference in mylist
   print "Values inside the function: ", mylist
   return

# Now you can call changeme function
mylist = [10,20,30];
changeme( mylist );
print "Values outside the function: ", mylist

Der Parameter mylist ist lokal für das Funktionsänderungsprogramm. Das Ändern der Mylist innerhalb der Funktion wirkt sich nicht auf die Mylist aus . Die Funktion erreicht nichts und würde schließlich das folgende Ergebnis erzeugen -

Values inside the function:  [1, 2, 3, 4]
Values outside the function:  [10, 20, 30]

Funktionsargumente

Sie können eine Funktion aufrufen, indem Sie die folgenden Arten von formalen Argumenten verwenden:

• Erforderliche Argumente
• Schlüsselwortargumente
• Standardargumente
• Argumente variabler Länge

Erforderliche Argumente

Erforderliche Argumente sind die Argumente, die in der richtigen Positionsreihenfolge an eine Funktion übergeben werden. Hier sollte die Anzahl der Argumente im Funktionsaufruf genau mit der Funktionsdefinition übereinstimmen.

Um die Funktion printme () aufzurufen , müssen Sie auf jeden Fall ein Argument übergeben, da sonst ein Syntaxfehler wie folgt ausgegeben wird:

#!/usr/bin/python

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print str
   return;

# Now you can call printme function
printme()

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Traceback (most recent call last):
   File "test.py", line 11, in <module>
      printme();
TypeError: printme() takes exactly 1 argument (0 given)

Schlüsselwortargumente

Schlüsselwortargumente beziehen sich auf die Funktionsaufrufe. Wenn Sie in einem Funktionsaufruf Schlüsselwortargumente verwenden, identifiziert der Aufrufer die Argumente anhand des Parameternamens.

Auf diese Weise können Sie Argumente überspringen oder nicht in der richtigen Reihenfolge platzieren, da der Python-Interpreter die angegebenen Schlüsselwörter verwenden kann, um die Werte mit Parametern abzugleichen. Sie können die Funktion printme () auch auf folgende Weise mit Schlüsselwörtern aufrufen :

#!/usr/bin/python

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print str
   return;

# Now you can call printme function
printme( str = "My string")

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

My string

Das folgende Beispiel gibt ein klareres Bild. Beachten Sie, dass die Reihenfolge der Parameter keine Rolle spielt.

#!/usr/bin/python

# Function definition is here
def printinfo( name, age ):
   "This prints a passed info into this function"
   print "Name: ", name
   print "Age ", age
   return;

# Now you can call printinfo function
printinfo( age=50, name="miki" )

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Name:  miki
Age  50

Standardargumente

Ein Standardargument ist ein Argument, das einen Standardwert annimmt, wenn im Funktionsaufruf für dieses Argument kein Wert angegeben wird. Das folgende Beispiel gibt eine Vorstellung von Standardargumenten. Es gibt das Standardalter aus, wenn es nicht übergeben wird.

#!/usr/bin/python

# Function definition is here
def printinfo( name, age = 35 ):
   "This prints a passed info into this function"
   print "Name: ", name
   print "Age ", age
   return;

# Now you can call printinfo function
printinfo( age=50, name="miki" )
printinfo( name="miki" )

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Name:  miki
Age  50
Name:  miki
Age  35

Argumente variabler Länge

Möglicherweise müssen Sie eine Funktion für mehr Argumente verarbeiten, als Sie beim Definieren der Funktion angegeben haben. Diese Argumente werden als Argumente variabler Länge bezeichnet und in der Funktionsdefinition im Gegensatz zu erforderlichen und Standardargumenten nicht benannt.

Die Syntax für eine Funktion mit Variablenargumenten ohne Schlüsselwort lautet:

def functionname([formal_args,] *var_args_tuple ):
   "function_docstring"
   function_suite
   return [expression]

Vor dem Variablennamen steht ein Sternchen (*), der die Werte aller Nicht-Schlüsselwort-Variablenargumente enthält. Dieses Tupel bleibt leer, wenn während des Funktionsaufrufs keine zusätzlichen Argumente angegeben werden. Das Folgende ist ein einfaches Beispiel -

#!/usr/bin/python

# Function definition is here
def printinfo( arg1, *vartuple ):
   "This prints a variable passed arguments"
   print "Output is: "
   print arg1
   for var in vartuple:
      print var
   return;

# Now you can call printinfo function
printinfo( 10 )
printinfo( 70, 60, 50 )

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Output is:
10
Output is:
70
60
50

Die anonymen Funktionen

Diese Funktionen werden anonym genannt, da sie nicht standardmäßig mit dem Schlüsselwort def deklariert werden. Mit dem Schlüsselwort lambda können Sie kleine anonyme Funktionen erstellen.

• Lambda-Formulare können beliebig viele Argumente annehmen, geben jedoch nur einen Wert in Form eines Ausdrucks zurück. Sie können keine Befehle oder mehrere Ausdrücke enthalten.

• Eine anonyme Funktion kann kein direkter Aufruf zum Drucken sein, da Lambda einen Ausdruck erfordert

• Lambda-Funktionen haben einen eigenen lokalen Namespace und können nicht auf andere Variablen als die in ihrer Parameterliste und die im globalen Namespace zugreifen.

• Obwohl es den Anschein hat, dass Lambdas eine einzeilige Version einer Funktion sind, entsprechen sie nicht den Inline-Anweisungen in C oder C ++, deren Zweck darin besteht, die Funktionsstapelzuweisung während des Aufrufs aus Leistungsgründen zu übergeben.

Syntax

Die Syntax von Lambda- Funktionen enthält nur eine einzige Anweisung:

lambda [arg1 [,arg2,.....argn]]:expression

Das folgende Beispiel zeigt, wie die Lambda- Funktionsform funktioniert:

#!/usr/bin/python

# Function definition is here
sum = lambda arg1, arg2: arg1 + arg2;

# Now you can call sum as a function
print "Value of total : ", sum( 10, 20 )
print "Value of total : ", sum( 20, 20 )

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Value of total :  30
Value of total :  40

Die Rückkehr Statement

Die Anweisung return [Ausdruck] beendet eine Funktion und gibt optional einen Ausdruck an den Aufrufer zurück. Eine return-Anweisung ohne Argumente ist dasselbe wie return None.

Alle obigen Beispiele geben keinen Wert zurück. Sie können einen Wert von einer Funktion wie folgt zurückgeben:

#!/usr/bin/python

# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2
   print "Inside the function : ", total
   return total;

# Now you can call sum function
total = sum( 10, 20 );
print "Outside the function : ", total

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Inside the function :  30
Outside the function :  30

Umfang der Variablen

Auf alle Variablen in einem Programm kann möglicherweise nicht an allen Stellen in diesem Programm zugegriffen werden. Dies hängt davon ab, wo Sie eine Variable deklariert haben.

Der Umfang einer Variablen bestimmt den Teil des Programms, in dem Sie auf eine bestimmte Kennung zugreifen können. In Python gibt es zwei grundlegende Bereiche von Variablen:

• Globale Variablen
• Lokale Variablen

Globale vs. lokale Variablen

Variablen, die innerhalb eines Funktionskörpers definiert sind, haben einen lokalen Bereich, und solche, die außerhalb definiert sind, haben einen globalen Bereich.

Dies bedeutet, dass auf lokale Variablen nur innerhalb der Funktion zugegriffen werden kann, in der sie deklariert sind, während auf globale Variablen von allen Funktionen im gesamten Programmkörper zugegriffen werden kann. Wenn Sie eine Funktion aufrufen, werden die darin deklarierten Variablen in den Gültigkeitsbereich gebracht. Das Folgende ist ein einfaches Beispiel -

#!/usr/bin/python

total = 0; # This is global variable.
# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2; # Here total is local variable.
   print "Inside the function local total : ", total
   return total;

# Now you can call sum function
sum( 10, 20 );
print "Outside the function global total : ", total

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Inside the function local total :  30
Outside the function global total :  0

Mit einem Modul können Sie Ihren Python-Code logisch organisieren. Das Gruppieren von verwandtem Code in einem Modul erleichtert das Verständnis und die Verwendung des Codes. Ein Modul ist ein Python-Objekt mit willkürlich benannten Attributen, die Sie binden und referenzieren können.

Ein Modul ist einfach eine Datei, die aus Python-Code besteht. Ein Modul kann Funktionen, Klassen und Variablen definieren. Ein Modul kann auch ausführbaren Code enthalten.

Beispiel

Der Python-Code für ein Modul mit dem Namen aname befindet sich normalerweise in einer Datei mit dem Namen aname.py . Hier ist ein Beispiel für ein einfaches Modul, support.py

def print_func( par ):
   print "Hello : ", par
   return

Die Einfuhrerklärung

Sie können jede Python-Quelldatei als Modul verwenden, indem Sie eine Importanweisung in einer anderen Python-Quelldatei ausführen. Der Import hat die folgende Syntax:

import module1[, module2[,... moduleN]

Wenn der Interpreter auf eine Importanweisung stößt, importiert er das Modul, wenn das Modul im Suchpfad vorhanden ist. Ein Suchpfad ist eine Liste von Verzeichnissen, die der Interpreter vor dem Importieren eines Moduls durchsucht. Um beispielsweise das Modul support.py zu importieren, müssen Sie den folgenden Befehl oben im Skript einfügen:

#!/usr/bin/python

# Import module support
import support

# Now you can call defined function that module as follows
support.print_func("Zara")

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Hello : Zara

Ein Modul wird nur einmal geladen, unabhängig davon, wie oft es importiert wird. Dies verhindert, dass die Modulausführung bei mehreren Importen immer wieder erfolgt.

Die from ... import Anweisung

Mit der from- Anweisung von Python können Sie bestimmte Attribute aus einem Modul in den aktuellen Namespace importieren. Der from ... -Import hat die folgende Syntax:

from modname import name1[, name2[, ... nameN]]

Verwenden Sie beispielsweise die folgende Anweisung, um die Funktion fibonacci aus dem Modul fib zu importieren:

from fib import fibonacci

Diese Anweisung importiert nicht das gesamte Modul fib in den aktuellen Namespace. Es wird lediglich das Element Fibonacci aus dem Modul Fib in die globale Symboltabelle des importierenden Moduls eingefügt.

Die from ... import * -Anweisung

Es ist auch möglich, alle Namen aus einem Modul in den aktuellen Namespace zu importieren, indem Sie die folgende import-Anweisung verwenden:

from modname import *

Dies bietet eine einfache Möglichkeit, alle Elemente aus einem Modul in den aktuellen Namespace zu importieren. Diese Aussage sollte jedoch sparsam verwendet werden.

Module suchen

Wenn Sie ein Modul importieren, sucht der Python-Interpreter in den folgenden Sequenzen nach dem Modul:

• Das aktuelle Verzeichnis.

• Wenn das Modul nicht gefunden wird, durchsucht Python jedes Verzeichnis in der Shell-Variablen PYTHONPATH.

• Wenn alles andere fehlschlägt, überprüft Python den Standardpfad. Unter UNIX lautet dieser Standardpfad normalerweise / usr / local / lib / python /.

Der Modul-Suchpfad wird im Systemmodul sys als gespeichert sys.pathVariable. Die Variable sys.path enthält das aktuelle Verzeichnis PYTHONPATH und den installationsabhängigen Standard.

Die PYTHONPATH- Variable

Der PYTHONPATH ist eine Umgebungsvariable, die aus einer Liste von Verzeichnissen besteht. Die Syntax von PYTHONPATH entspricht der der Shell-Variablen PATH.

Hier ist ein typischer PYTHONPATH von einem Windows-System -

set PYTHONPATH = c:\python20\lib;

Und hier ist ein typischer PYTHONPATH von einem UNIX-System -

set PYTHONPATH = /usr/local/lib/python

Namespaces und Scoping

Variablen sind Namen (Bezeichner), die Objekten zugeordnet sind. Ein Namespace ist ein Wörterbuch mit Variablennamen (Schlüsseln) und den entsprechenden Objekten (Werten).

Eine Python-Anweisung kann auf Variablen in einem lokalen Namespace und im globalen Namespace zugreifen . Wenn eine lokale und eine globale Variable denselben Namen haben, schattiert die lokale Variable die globale Variable.

Jede Funktion hat einen eigenen lokalen Namespace. Klassenmethoden folgen der gleichen Gültigkeitsregel wie gewöhnliche Funktionen.

Python macht fundierte Vermutungen darüber, ob Variablen lokal oder global sind. Es wird davon ausgegangen, dass jede Variable, der in einer Funktion ein Wert zugewiesen wurde, lokal ist.

Um einer globalen Variablen innerhalb einer Funktion einen Wert zuzuweisen, müssen Sie daher zuerst die globale Anweisung verwenden.

Die Anweisung global VarName teilt Python mit, dass VarName eine globale Variable ist. Python beendet die Suche im lokalen Namespace nach der Variablen.

Zum Beispiel definieren wir eine Variable Money im globalen Namespace. Innerhalb der Funktion Money weisen wir Money einen Wert zu, daher nimmt Python Money als lokale Variable an. Wir haben jedoch vor dem Festlegen auf den Wert der lokalen Variablen Money zugegriffen , sodass ein UnboundLocalError das Ergebnis ist. Das Nichtkommentieren der globalen Anweisung behebt das Problem.

#!/usr/bin/python

Money = 2000
def AddMoney():
   # Uncomment the following line to fix the code:
   # global Money
   Money = Money + 1

print Money
AddMoney()
print Money

Die dir () Funktion

Die integrierte Funktion dir () gibt eine sortierte Liste von Zeichenfolgen zurück, die die von einem Modul definierten Namen enthalten.

Die Liste enthält die Namen aller Module, Variablen und Funktionen, die in einem Modul definiert sind. Das Folgende ist ein einfaches Beispiel -

#!/usr/bin/python

# Import built-in module math
import math

content = dir(math)
print content

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan', 
'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 
'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',
'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 
'sqrt', 'tan', 'tanh']

Hier ist die spezielle Zeichenfolgenvariable __name__ der Name des Moduls und __file__ der Dateiname, aus dem das Modul geladen wurde.

Die Globals () und Einheimischen () Funktionen

Die Globals () und Einheimischen () Funktionen können verwendet werden , um die Namen in dem globalen und lokalen Namensraum zurückzukehren je nach Standort , von wo aus sie aufgerufen werden.

Wenn local () innerhalb einer Funktion aufgerufen wird, werden alle Namen zurückgegeben, auf die von dieser Funktion aus lokal zugegriffen werden kann.

Wenn globals () innerhalb einer Funktion aufgerufen wird, werden alle Namen zurückgegeben, auf die von dieser Funktion aus global zugegriffen werden kann.

Der Rückgabetyp dieser beiden Funktionen ist Dictionary. Daher können Namen mit der Funktion keys () extrahiert werden.

Die Funktion reload ()

Wenn das Modul in ein Skript importiert wird, wird der Code im obersten Teil eines Moduls nur einmal ausgeführt.

Wenn Sie den Code der obersten Ebene in einem Modul erneut ausführen möchten, können Sie daher die Funktion reload () verwenden. Die Funktion reload () importiert ein zuvor importiertes Modul erneut. Die Syntax der Funktion reload () lautet:

reload(module_name)

Hier ist Modulname der Name des Moduls, das Sie neu laden möchten, und nicht die Zeichenfolge, die den Modulnamen enthält. Um beispielsweise das Hallo- Modul neu zu laden , gehen Sie wie folgt vor:

reload(hello)

Pakete in Python

Ein Paket ist eine hierarchische Dateiverzeichnisstruktur, die eine einzelne Python-Anwendungsumgebung definiert, die aus Modulen und Unterpaketen und Unterunterpaketen usw. besteht.

Betrachten Sie eine Datei Pots.py, die im Telefonverzeichnis verfügbar ist . Diese Datei enthält die folgende Zeile des Quellcodes:

#!/usr/bin/python

def Pots():
   print "I'm Pots Phone"

In ähnlicher Weise haben wir zwei weitere Dateien mit unterschiedlichen Funktionen mit demselben Namen wie oben -

• Telefon / Isdn.py- Datei mit der Funktion Isdn ()

• Telefon / G3.py- Datei mit der Funktion G3 ()

Erstellen Sie jetzt eine weitere Datei __init__.py im Telefonverzeichnis -

• Phone/__init__.py

Um alle Ihre Funktionen verfügbar zu machen, wenn Sie Phone importiert haben, müssen Sie explizite Importanweisungen wie folgt in __init__.py einfügen:

from Pots import Pots
from Isdn import Isdn
from G3 import G3

Nachdem Sie diese Zeilen zu __init__.py hinzugefügt haben, stehen Ihnen beim Importieren des Telefonpakets alle diese Klassen zur Verfügung.

#!/usr/bin/python

# Now import your Phone Package.
import Phone

Phone.Pots()
Phone.Isdn()
Phone.G3()

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

I'm Pots Phone
I'm 3G Phone
I'm ISDN Phone

Im obigen Beispiel haben wir ein Beispiel für eine einzelne Funktion in jeder Datei genommen, aber Sie können mehrere Funktionen in Ihren Dateien behalten. Sie können in diesen Dateien auch verschiedene Python-Klassen definieren und dann Ihre Pakete aus diesen Klassen erstellen.

Dieses Kapitel behandelt alle grundlegenden E / A-Funktionen, die in Python verfügbar sind. Weitere Funktionen finden Sie in der Standard-Python-Dokumentation.

Drucken auf dem Bildschirm

Der einfachste Weg, eine Ausgabe zu erzeugen, ist die Verwendung der print- Anweisung, bei der Sie null oder mehr durch Kommas getrennte Ausdrücke übergeben können. Diese Funktion konvertiert die von Ihnen übergebenen Ausdrücke in eine Zeichenfolge und schreibt das Ergebnis wie folgt in die Standardausgabe:

#!/usr/bin/python

print "Python is really a great language,", "isn't it?"

Dies führt auf Ihrem Standardbildschirm zu folgendem Ergebnis:

Python is really a great language, isn't it?

Tastatureingabe lesen

Python bietet zwei integrierte Funktionen zum Lesen einer Textzeile aus der Standardeingabe, die standardmäßig über die Tastatur erfolgt. Diese Funktionen sind -

• raw_input
• input

Die Funktion raw_input

Die Funktion raw_input ([Eingabeaufforderung]) liest eine Zeile aus der Standardeingabe und gibt sie als Zeichenfolge zurück (wobei die nachfolgende neue Zeile entfernt wird).

#!/usr/bin/python

str = raw_input("Enter your input: ")
print "Received input is : ", str

Dadurch werden Sie aufgefordert, eine beliebige Zeichenfolge einzugeben, und es wird dieselbe Zeichenfolge auf dem Bildschirm angezeigt. Wenn ich "Hello Python!" Eingegeben habe, ist die Ausgabe wie folgt:

Enter your input: Hello Python
Received input is :  Hello Python

Die Eingabefunktion

Die Eingabefunktion ([Eingabeaufforderung]) entspricht raw_input, außer dass davon ausgegangen wird, dass die Eingabe ein gültiger Python-Ausdruck ist, und das ausgewertete Ergebnis an Sie zurückgibt.

#!/usr/bin/python

str = input("Enter your input: ")
print "Received input is : ", str

Dies würde das folgende Ergebnis gegen die eingegebene Eingabe erzeugen -

Enter your input: [x*5 for x in range(2,10,2)]
Recieved input is :  [10, 20, 30, 40]

Dateien öffnen und schließen

Bis jetzt haben Sie die Standardeingabe und -ausgabe gelesen und geschrieben. Nun werden wir sehen, wie tatsächliche Datendateien verwendet werden.

Python bietet grundlegende Funktionen und Methoden, die zum standardmäßigen Bearbeiten von Dateien erforderlich sind. Sie können den größten Teil der Dateimanipulation mit a ausführenfile Objekt.

Die offene Funktion

Bevor Sie eine Datei lesen oder schreiben können, müssen Sie sie mit der in Python integrierten Funktion open () öffnen . Diese Funktion erstellt einefile Objekt, das verwendet wird, um andere damit verbundene Unterstützungsmethoden aufzurufen.

Syntax

file object = open(file_name [, access_mode][, buffering])

Hier sind Parameterdetails -

• file_name - Das Argument file_name ist ein Zeichenfolgenwert, der den Namen der Datei enthält, auf die Sie zugreifen möchten.

• access_mode- Der access_mode bestimmt den Modus, in dem die Datei geöffnet werden muss, dh lesen, schreiben, anhängen usw. Eine vollständige Liste möglicher Werte finden Sie unten in der Tabelle. Dies ist ein optionaler Parameter und der Standard-Dateizugriffsmodus ist read (r).

• buffering- Wenn der Pufferwert auf 0 gesetzt ist, findet keine Pufferung statt. Wenn der Pufferwert 1 ist, wird beim Zugriff auf eine Datei eine Zeilenpufferung durchgeführt. Wenn Sie den Pufferwert als Ganzzahl größer als 1 angeben, wird die Pufferaktion mit der angegebenen Puffergröße ausgeführt. Wenn negativ, ist die Puffergröße der Systemstandard (Standardverhalten).

Hier ist eine Liste der verschiedenen Modi zum Öffnen einer Datei -

Sr.Nr.	Modi & Beschreibung
1	r Öffnet eine Datei nur zum Lesen. Der Dateizeiger befindet sich am Anfang der Datei. Dies ist der Standardmodus.
2	rb Öffnet eine Datei zum Lesen nur im Binärformat. Der Dateizeiger befindet sich am Anfang der Datei. Dies ist der Standardmodus.
3	r+ Öffnet eine Datei zum Lesen und Schreiben. Der Dateizeiger am Anfang der Datei.
4	rb+ Öffnet eine Datei zum Lesen und Schreiben im Binärformat. Der Dateizeiger am Anfang der Datei.
5	w Öffnet eine Datei nur zum Schreiben. Überschreibt die Datei, wenn die Datei vorhanden ist. Wenn die Datei nicht vorhanden ist, wird eine neue Datei zum Schreiben erstellt.
6	wb Öffnet eine Datei zum Schreiben nur im Binärformat. Überschreibt die Datei, wenn die Datei vorhanden ist. Wenn die Datei nicht vorhanden ist, wird eine neue Datei zum Schreiben erstellt.
7	w+ Öffnet eine Datei zum Schreiben und Lesen. Überschreibt die vorhandene Datei, wenn die Datei vorhanden ist. Wenn die Datei nicht vorhanden ist, wird eine neue Datei zum Lesen und Schreiben erstellt.
8	wb+ Öffnet eine Datei zum Schreiben und Lesen im Binärformat. Überschreibt die vorhandene Datei, wenn die Datei vorhanden ist. Wenn die Datei nicht vorhanden ist, wird eine neue Datei zum Lesen und Schreiben erstellt.
9	a Öffnet eine Datei zum Anhängen. Der Dateizeiger befindet sich am Ende der Datei, wenn die Datei vorhanden ist. Das heißt, die Datei befindet sich im Anhänge-Modus. Wenn die Datei nicht vorhanden ist, wird eine neue Datei zum Schreiben erstellt.
10	ab Öffnet eine Datei zum Anhängen im Binärformat. Der Dateizeiger befindet sich am Ende der Datei, wenn die Datei vorhanden ist. Das heißt, die Datei befindet sich im Anhänge-Modus. Wenn die Datei nicht vorhanden ist, wird eine neue Datei zum Schreiben erstellt.
11	a+ Öffnet eine Datei zum Anhängen und Lesen. Der Dateizeiger befindet sich am Ende der Datei, wenn die Datei vorhanden ist. Die Datei wird im Anhänge-Modus geöffnet. Wenn die Datei nicht vorhanden ist, wird eine neue Datei zum Lesen und Schreiben erstellt.
12	ab+ Öffnet eine Datei zum Anhängen und Lesen im Binärformat. Der Dateizeiger befindet sich am Ende der Datei, wenn die Datei vorhanden ist. Die Datei wird im Anhänge-Modus geöffnet. Wenn die Datei nicht vorhanden ist, wird eine neue Datei zum Lesen und Schreiben erstellt.

Die Datei Objektattribute

Sobald eine Datei geöffnet ist und Sie ein Dateiobjekt haben , können Sie verschiedene Informationen zu dieser Datei abrufen.

Hier ist eine Liste aller Attribute, die sich auf das Dateiobjekt beziehen -

Sr.Nr.	Attribut & Beschreibung
1	file.closed Gibt true zurück, wenn die Datei geschlossen ist, andernfalls false.
2	file.mode Gibt den Zugriffsmodus zurück, mit dem die Datei geöffnet wurde.
3	file.name Gibt den Namen der Datei zurück.
4	file.softspace Gibt false zurück, wenn beim Drucken explizit Speicherplatz erforderlich ist, andernfalls true.

Beispiel

#!/usr/bin/python

# Open a file
fo = open("foo.txt", "wb")
print "Name of the file: ", fo.name
print "Closed or not : ", fo.closed
print "Opening mode : ", fo.mode
print "Softspace flag : ", fo.softspace

Dies ergibt das folgende Ergebnis:

Name of the file:  foo.txt
Closed or not :  False
Opening mode :  wb
Softspace flag :  0

Die Methode close ()

Die Methode close () eines Dateiobjekts löscht alle ungeschriebenen Informationen und schließt das Dateiobjekt. Danach kann nicht mehr geschrieben werden.

Python schließt eine Datei automatisch, wenn das Referenzobjekt einer Datei einer anderen Datei zugewiesen wird. Es wird empfohlen, die Methode close () zum Schließen einer Datei zu verwenden.

Syntax

fileObject.close()

Beispiel

#!/usr/bin/python

# Open a file
fo = open("foo.txt", "wb")
print "Name of the file: ", fo.name

# Close opend file
fo.close()

Dies ergibt das folgende Ergebnis:

Name of the file:  foo.txt

Dateien lesen und schreiben

Das Dateiobjekt bietet eine Reihe von Zugriffsmethoden, um unser Leben zu erleichtern. Wir würden sehen, wie man read () - und write () -Methoden verwendet, um Dateien zu lesen und zu schreiben.

Die write () -Methode

Die write () -Methode schreibt eine beliebige Zeichenfolge in eine geöffnete Datei. Es ist wichtig zu beachten, dass Python-Zeichenfolgen Binärdaten und nicht nur Text enthalten können.

Die write () -Methode fügt am Ende der Zeichenfolge kein Zeilenumbruchzeichen ('\ n') hinzu -

Syntax

fileObject.write(string)

Übergebener Parameter ist hier der Inhalt, der in die geöffnete Datei geschrieben werden soll.

Beispiel

#!/usr/bin/python

# Open a file
fo = open("foo.txt", "wb")
fo.write( "Python is a great language.\nYeah its great!!\n")

# Close opend file
fo.close()

Die obige Methode würde eine foo.txt- Datei erstellen und bestimmten Inhalt in diese Datei schreiben und schließlich diese Datei schließen. Wenn Sie diese Datei öffnen würden, hätte sie folgenden Inhalt.

Python is a great language.
Yeah its great!!

Die read () -Methode

Die read () -Methode liest eine Zeichenfolge aus einer geöffneten Datei. Es ist wichtig zu beachten, dass Python-Strings Binärdaten enthalten können. abgesehen von Textdaten.

Syntax

fileObject.read([count])

Hier ist der übergebene Parameter die Anzahl der Bytes, die aus der geöffneten Datei gelesen werden sollen. Diese Methode beginnt mit dem Lesen am Anfang der Datei. Wenn die Anzahl fehlt, versucht sie, so viel wie möglich zu lesen, möglicherweise bis zum Ende der Datei.

Beispiel

Nehmen wir eine Datei foo.txt , die wir oben erstellt haben.

#!/usr/bin/python

# Open a file
fo = open("foo.txt", "r+")
str = fo.read(10);
print "Read String is : ", str
# Close opend file
fo.close()

Dies ergibt das folgende Ergebnis:

Read String is :  Python is

Dateipositionen

Die Methode tell () zeigt Ihnen die aktuelle Position in der Datei an. Mit anderen Worten, das nächste Lesen oder Schreiben erfolgt mit so vielen Bytes ab dem Anfang der Datei.

Die Suchmethode (Offset [, von]) ändert die aktuelle Dateiposition. Das Offset- Argument gibt die Anzahl der zu verschiebenden Bytes an. Das Argument from gibt die Referenzposition an, von der aus die Bytes verschoben werden sollen.

Wenn from auf 0 gesetzt ist, bedeutet dies, dass der Anfang der Datei als Referenzposition verwendet wird, und 1 bedeutet, dass die aktuelle Position als Referenzposition verwendet wird. Wenn sie auf 2 gesetzt ist, wird das Ende der Datei als Referenzposition verwendet .

Beispiel

Nehmen wir eine Datei foo.txt , die wir oben erstellt haben.

#!/usr/bin/python

# Open a file
fo = open("foo.txt", "r+")
str = fo.read(10)
print "Read String is : ", str

# Check current position
position = fo.tell()
print "Current file position : ", position

# Reposition pointer at the beginning once again
position = fo.seek(0, 0);
str = fo.read(10)
print "Again read String is : ", str
# Close opend file
fo.close()

Dies ergibt das folgende Ergebnis:

Read String is :  Python is
Current file position :  10
Again read String is :  Python is

Dateien umbenennen und löschen

Python os Das Modul bietet Methoden, mit denen Sie Dateiverarbeitungsvorgänge ausführen können, z. B. das Umbenennen und Löschen von Dateien.

Um dieses Modul zu verwenden, müssen Sie es zuerst importieren und können dann alle zugehörigen Funktionen aufrufen.

Die Methode rename ()

Die Methode rename () akzeptiert zwei Argumente, den aktuellen Dateinamen und den neuen Dateinamen.

Syntax

os.rename(current_file_name, new_file_name)

Beispiel

Es folgt das Beispiel zum Umbenennen einer vorhandenen Datei test1.txt -

#!/usr/bin/python
import os

# Rename a file from test1.txt to test2.txt
os.rename( "test1.txt", "test2.txt" )

Die Methode remove ()

Mit der Methode remove () können Sie Dateien löschen, indem Sie den Namen der zu löschenden Datei als Argument angeben.

Syntax

os.remove(file_name)

Beispiel

Es folgt das Beispiel zum Löschen einer vorhandenen Datei test2.txt -

#!/usr/bin/python
import os

# Delete file test2.txt
os.remove("text2.txt")

Verzeichnisse in Python

Alle Dateien sind in verschiedenen Verzeichnissen enthalten, und Python hat auch keine Probleme damit. Dasos Das Modul verfügt über verschiedene Methoden, mit denen Sie Verzeichnisse erstellen, entfernen und ändern können.

Die Mkdir () Methode

Sie können die mkdir () -Methode von verwendenosModul zum Erstellen von Verzeichnissen im aktuellen Verzeichnis. Sie müssen dieser Methode ein Argument geben, das den Namen des zu erstellenden Verzeichnisses enthält.

Syntax

os.mkdir("newdir")

Beispiel

Im Anschluss an das Beispiel ein Verzeichnis erstellen Test im aktuellen Verzeichnis -

#!/usr/bin/python
import os

# Create a directory "test"
os.mkdir("test")

Die chdir () -Methode

Mit der Methode chdir () können Sie das aktuelle Verzeichnis ändern. Die Methode chdir () verwendet ein Argument. Dies ist der Name des Verzeichnisses, aus dem Sie das aktuelle Verzeichnis erstellen möchten.

Syntax

os.chdir("newdir")

Beispiel

Das folgende Beispiel zeigt das Verzeichnis "/ home / newdir":

#!/usr/bin/python
import os

# Changing a directory to "/home/newdir"
os.chdir("/home/newdir")

Die Methode getcwd ()

Die Methode getcwd () zeigt das aktuelle Arbeitsverzeichnis an.

Syntax

os.getcwd()

Beispiel

Das folgende Beispiel gibt das aktuelle Verzeichnis an:

#!/usr/bin/python
import os

# This would give location of the current directory
os.getcwd()

Die rmdir () -Methode

Die Methode rmdir () löscht das Verzeichnis, das in der Methode als Argument übergeben wird.

Vor dem Entfernen eines Verzeichnisses sollten alle darin enthaltenen Inhalte entfernt werden.

Syntax

os.rmdir('dirname')

Beispiel

Im Folgenden finden Sie ein Beispiel zum Entfernen des Verzeichnisses "/ tmp / test". Es ist erforderlich, den vollständig qualifizierten Namen des Verzeichnisses anzugeben, da sonst im aktuellen Verzeichnis nach diesem Verzeichnis gesucht wird.

#!/usr/bin/python
import os

# This would  remove "/tmp/test"  directory.
os.rmdir( "/tmp/test"  )

Datei- und verzeichnisbezogene Methoden

Es gibt drei wichtige Quellen, die eine Vielzahl von Dienstprogrammmethoden zum Behandeln und Bearbeiten von Dateien und Verzeichnissen unter Windows- und Unix-Betriebssystemen bereitstellen. Sie sind wie folgt -

• Dateiobjektmethoden : Das Dateiobjekt bietet Funktionen zum Bearbeiten von Dateien.

• OS-Objektmethoden : Hier finden Sie Methoden zum Verarbeiten von Dateien sowie Verzeichnissen.

Python bietet zwei sehr wichtige Funktionen, um unerwartete Fehler in Ihren Python-Programmen zu behandeln und ihnen Debugging-Funktionen hinzuzufügen:

• Exception Handling- Dies wird in diesem Tutorial behandelt. Hier ist eine Liste der in Python verfügbaren Standardausnahmen : Standardausnahmen .

• Assertions- Dies wird im Assertions in Python- Tutorial behandelt.

Liste der Standardausnahmen -

Sr.Nr.	Ausnahme Name & Beschreibung
1	Exception Basisklasse für alle Ausnahmen
2	StopIteration Wird ausgelöst, wenn die next () -Methode eines Iterators nicht auf ein Objekt zeigt.
3	SystemExit Wird durch die Funktion sys.exit () ausgelöst.
4	StandardError Basisklasse für alle integrierten Ausnahmen außer StopIteration und SystemExit.
5	ArithmeticError Basisklasse für alle Fehler, die bei der numerischen Berechnung auftreten.
6	OverflowError Wird ausgelöst, wenn eine Berechnung die maximale Grenze für einen numerischen Typ überschreitet.
7	FloatingPointError Wird ausgelöst, wenn eine Gleitkommaberechnung fehlschlägt.
8	ZeroDivisionError Wird ausgelöst, wenn für alle numerischen Typen eine Division oder ein Modulo durch Null erfolgt.
9	AssertionError Wird ausgelöst, wenn die Assert-Anweisung fehlschlägt.
10	AttributeError Wird ausgelöst, wenn die Attributreferenz oder -zuweisung fehlschlägt.
11	EOFError Wird ausgelöst, wenn weder von der Funktion raw_input () noch von input () eine Eingabe erfolgt und das Dateiende erreicht ist.
12	ImportError Wird ausgelöst, wenn eine Importanweisung fehlschlägt.
13	KeyboardInterrupt Wird ausgelöst, wenn der Benutzer die Programmausführung unterbricht, normalerweise durch Drücken von Strg + c.
14	LookupError Basisklasse für alle Suchfehler.
15	IndexError Wird ausgelöst, wenn in einer Sequenz kein Index gefunden wird.
16	KeyError Wird ausgelöst, wenn der angegebene Schlüssel nicht im Wörterbuch gefunden wird.
17	NameError Wird ausgelöst, wenn im lokalen oder globalen Namespace kein Bezeichner gefunden wird.
18	UnboundLocalError Wird ausgelöst, wenn versucht wird, auf eine lokale Variable in einer Funktion oder Methode zuzugreifen, ihr jedoch kein Wert zugewiesen wurde.
19	EnvironmentError Basisklasse für alle Ausnahmen, die außerhalb der Python-Umgebung auftreten.
20	IOError Wird ausgelöst, wenn eine Eingabe- / Ausgabeoperation fehlschlägt, z. B. die print-Anweisung oder die open () -Funktion, wenn versucht wird, eine nicht vorhandene Datei zu öffnen.
21	IOError Wird für betriebssystembezogene Fehler ausgelöst.
22	SyntaxError Wird ausgelöst, wenn ein Fehler in der Python-Syntax vorliegt.
23	IndentationError Wird ausgelöst, wenn die Einrückung nicht richtig angegeben ist.
24	SystemError Wird ausgelöst, wenn der Interpreter ein internes Problem findet, dieser Fehler jedoch auftritt. Der Python-Interpreter wird nicht beendet.
25	SystemExit Wird ausgelöst, wenn der Python-Interpreter mithilfe der Funktion sys.exit () beendet wird. Wenn dies nicht im Code behandelt wird, wird der Interpreter beendet.
26	TypeError Wird ausgelöst, wenn eine Operation oder Funktion versucht wird, die für den angegebenen Datentyp ungültig ist.
27	ValueError Wird ausgelöst, wenn die integrierte Funktion für einen Datentyp den gültigen Argumenttyp hat, für die Argumente jedoch ungültige Werte angegeben sind.
28	RuntimeError Wird ausgelöst, wenn ein generierter Fehler keiner Kategorie zugeordnet werden kann.
29	NotImplementedError Wird ausgelöst, wenn eine abstrakte Methode, die in einer geerbten Klasse implementiert werden muss, nicht tatsächlich implementiert ist.

Behauptungen in Python

Eine Behauptung ist eine Überprüfung der geistigen Gesundheit, die Sie ein- oder ausschalten können, wenn Sie mit dem Testen des Programms fertig sind.

Der einfachste Weg, an eine Behauptung zu denken, besteht darin, sie mit einer zu vergleichen raise-ifAussage (oder genauer gesagt, eine Raise-If-Not-Aussage). Ein Ausdruck wird getestet, und wenn das Ergebnis falsch ist, wird eine Ausnahme ausgelöst.

Assertions werden von der assert-Anweisung ausgeführt, dem neuesten Schlüsselwort für Python, das in Version 1.5 eingeführt wurde.

Programmierer platzieren häufig Zusicherungen am Anfang einer Funktion, um nach gültigen Eingaben zu suchen, und nach einem Funktionsaufruf, um nach gültigen Ausgaben zu suchen.

Die Assert- Erklärung

Wenn Python auf eine assert-Anweisung stößt, wertet es den zugehörigen Ausdruck aus, was hoffentlich wahr ist. Wenn der Ausdruck falsch ist, löst Python eine AssertionError- Ausnahme aus.

Die Syntax für assert lautet -

assert Expression[, Arguments]

Wenn die Zusicherung fehlschlägt, verwendet Python ArgumentExpression als Argument für den AssertionError. AssertionError-Ausnahmen können wie jede andere Ausnahme mit der try-exception-Anweisung abgefangen und behandelt werden. Wenn sie jedoch nicht behandelt werden, wird das Programm beendet und ein Traceback erstellt.

Beispiel

Hier ist eine Funktion, die eine Temperatur von Grad Kelvin in Grad Fahrenheit umwandelt. Da null Grad Kelvin so kalt ist wie es nur geht, wird die Funktion beendet, wenn eine negative Temperatur festgestellt wird -

#!/usr/bin/python
def KelvinToFahrenheit(Temperature):
   assert (Temperature >= 0),"Colder than absolute zero!"
   return ((Temperature-273)*1.8)+32
print KelvinToFahrenheit(273)
print int(KelvinToFahrenheit(505.78))
print KelvinToFahrenheit(-5)

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

32.0
451
Traceback (most recent call last):
File "test.py", line 9, in <module>
print KelvinToFahrenheit(-5)
File "test.py", line 4, in KelvinToFahrenheit
assert (Temperature >= 0),"Colder than absolute zero!"
AssertionError: Colder than absolute zero!

Was ist eine Ausnahme?

Eine Ausnahme ist ein Ereignis, das während der Ausführung eines Programms auftritt und den normalen Ablauf der Programmanweisungen stört. Wenn ein Python-Skript auf eine Situation stößt, die es nicht bewältigen kann, wird im Allgemeinen eine Ausnahme ausgelöst. Eine Ausnahme ist ein Python-Objekt, das einen Fehler darstellt.

Wenn ein Python-Skript eine Ausnahme auslöst, muss es die Ausnahme entweder sofort behandeln, andernfalls wird es beendet und beendet.

Behandlung einer Ausnahme

Wenn Sie verdächtigen Code haben, der eine Ausnahme auslösen kann, können Sie Ihr Programm verteidigen, indem Sie den verdächtigen Code in a einfügentry:Block. Fügen Sie nach dem try: -Block ein einexcept: Anweisung, gefolgt von einem Codeblock, der das Problem so elegant wie möglich behandelt.

Syntax

Hier ist eine einfache Syntax von try .... außer ... else- Blöcken -

try:
   You do your operations here;
   ......................
except ExceptionI:
   If there is ExceptionI, then execute this block.
except ExceptionII:
   If there is ExceptionII, then execute this block.
   ......................
else:
   If there is no exception then execute this block.

Hier sind einige wichtige Punkte zur oben genannten Syntax:

• Eine einzelne try-Anweisung kann mehrere Ausnahmen enthalten. Dies ist nützlich, wenn der try-Block Anweisungen enthält, die verschiedene Arten von Ausnahmen auslösen können.

• Sie können auch eine generische Ausnahmeklausel angeben, die jede Ausnahme behandelt.

• Nach den Ausnahmeklauseln können Sie eine else-Klausel einfügen. Der Code im else-Block wird ausgeführt, wenn der Code im try: -Block keine Ausnahme auslöst.

• Der else-Block ist ein guter Ort für Code, der den Schutz von try: block nicht benötigt.

Beispiel

In diesem Beispiel wird eine Datei geöffnet, der Inhalt in die Datei, geschrieben und ordnungsgemäß ausgegeben, da überhaupt kein Problem vorliegt.

#!/usr/bin/python

try:
   fh = open("testfile", "w")
   fh.write("This is my test file for exception handling!!")
except IOError:
   print "Error: can\'t find file or read data"
else:
   print "Written content in the file successfully"
   fh.close()

Dies ergibt das folgende Ergebnis:

Written content in the file successfully

Beispiel

In diesem Beispiel wird versucht, eine Datei zu öffnen, für die Sie keine Schreibberechtigung haben. Daher wird eine Ausnahme ausgelöst.

#!/usr/bin/python

try:
   fh = open("testfile", "r")
   fh.write("This is my test file for exception handling!!")
except IOError:
   print "Error: can\'t find file or read data"
else:
   print "Written content in the file successfully"

Dies ergibt das folgende Ergebnis:

Error: can't find file or read data

Die Ausnahmeklausel ohne Ausnahmen

Sie können auch die Ausnahme-Anweisung ohne Ausnahmen verwenden, die wie folgt definiert sind:

try:
   You do your operations here;
   ......................
except:
   If there is any exception, then execute this block.
   ......................
else:
   If there is no exception then execute this block.

Diese Art von a try-exceptAnweisung fängt alle auftretenden Ausnahmen ab. Die Verwendung dieser Art von Try-Except-Anweisung wird jedoch nicht als gute Programmierpraxis angesehen, da sie alle Ausnahmen abfängt, den Programmierer jedoch nicht dazu veranlasst, die Hauptursache des möglicherweise auftretenden Problems zu identifizieren.

Die Ausnahmeklausel mit mehreren Ausnahmen

Sie können dieselbe Ausnahme- Anweisung auch verwenden, um mehrere Ausnahmen wie folgt zu behandeln:

try:
   You do your operations here;
   ......................
except(Exception1[, Exception2[,...ExceptionN]]]):
   If there is any exception from the given exception list, 
   then execute this block.
   ......................
else:
   If there is no exception then execute this block.

Die Try-finally-Klausel

Sie können eine verwenden finally: Block zusammen mit einem try:Block. Der finally-Block ist ein Ort, an dem Code eingefügt werden kann, der ausgeführt werden muss, unabhängig davon, ob der try-Block eine Ausnahme ausgelöst hat oder nicht. Die Syntax der try-finally-Anweisung lautet:

try:
   You do your operations here;
   ......................
   Due to any exception, this may be skipped.
finally:
   This would always be executed.
   ......................

Sie können die else- Klausel nicht zusammen mit einer finally-Klausel verwenden.

Beispiel

#!/usr/bin/python

try:
   fh = open("testfile", "w")
   fh.write("This is my test file for exception handling!!")
finally:
   print "Error: can\'t find file or read data"

Wenn Sie nicht berechtigt sind, die Datei im Schreibmodus zu öffnen, führt dies zu folgendem Ergebnis:

Error: can't find file or read data

Das gleiche Beispiel kann wie folgt sauberer geschrieben werden:

#!/usr/bin/python

try:
   fh = open("testfile", "w")
   try:
      fh.write("This is my test file for exception handling!!")
   finally:
      print "Going to close the file"
      fh.close()
except IOError:
   print "Error: can\'t find file or read data"

Wenn im try- Block eine Ausnahme ausgelöst wird , wird die Ausführung sofort an den finally- Block übergeben. Nachdem alle Anweisungen im finally- Block ausgeführt wurden, wird die Ausnahme erneut ausgelöst und in den Except- Anweisungen behandelt, sofern sie in der nächsthöheren Ebene der try-Except- Anweisung vorhanden sind.

Argument einer Ausnahme

Eine Ausnahme kann ein Argument haben , bei dem es sich um einen Wert handelt, der zusätzliche Informationen zum Problem enthält. Der Inhalt des Arguments variiert ausnahmsweise. Sie erfassen das Argument einer Ausnahme, indem Sie eine Variable in der Ausnahmeklausel wie folgt angeben:

try:
   You do your operations here;
   ......................
except ExceptionType, Argument:
   You can print value of Argument here...

Wenn Sie den Code schreiben, um eine einzelne Ausnahme zu behandeln, kann eine Variable dem Namen der Ausnahme in der Ausnahme-Anweisung folgen. Wenn Sie mehrere Ausnahmen abfangen, kann eine Variable dem Tupel der Ausnahme folgen.

Diese Variable erhält den Wert der Ausnahme, der hauptsächlich die Ursache der Ausnahme enthält. Die Variable kann einen einzelnen Wert oder mehrere Werte in Form eines Tupels erhalten. Dieses Tupel enthält normalerweise die Fehlerzeichenfolge, die Fehlernummer und eine Fehlerstelle.

Beispiel

Das Folgende ist ein Beispiel für eine einzelne Ausnahme -

#!/usr/bin/python

# Define a function here.
def temp_convert(var):
   try:
      return int(var)
   except ValueError, Argument:
      print "The argument does not contain numbers\n", Argument

# Call above function here.
temp_convert("xyz");

Dies ergibt das folgende Ergebnis:

The argument does not contain numbers
invalid literal for int() with base 10: 'xyz'

Ausnahmen auslösen

Sie können Ausnahmen auf verschiedene Arten auslösen, indem Sie die Raise-Anweisung verwenden. Die allgemeine Syntax für dieraise Aussage ist wie folgt.

Syntax

raise [Exception [, args [, traceback]]]

Hier ist Exception der Ausnahmetyp (z. B. NameError) und argument ist ein Wert für das Exception-Argument. Das Argument ist optional. Wenn nicht angegeben, lautet das Ausnahmeargument None.

Das letzte Argument, Traceback, ist ebenfalls optional (und wird in der Praxis nur selten verwendet). Falls vorhanden, handelt es sich um das für die Ausnahme verwendete Traceback-Objekt.

Beispiel

Eine Ausnahme kann eine Zeichenfolge, eine Klasse oder ein Objekt sein. Die meisten Ausnahmen, die der Python-Kern auslöst, sind Klassen mit einem Argument, das eine Instanz der Klasse ist. Das Definieren neuer Ausnahmen ist recht einfach und kann wie folgt erfolgen:

def functionName( level ):
   if level < 1:
      raise "Invalid level!", level
      # The code below to this would not be executed
      # if we raise the exception

Note:Um eine Ausnahme abzufangen, muss sich eine "Ausnahme" -Klausel auf dieselbe Ausnahme beziehen, die entweder als Klassenobjekt oder als einfache Zeichenfolge ausgelöst wird. Um beispielsweise die obige Ausnahme zu erfassen, müssen wir die Ausnahmeklausel wie folgt schreiben:

try:
   Business Logic here...
except "Invalid level!":
   Exception handling here...
else:
   Rest of the code here...

Benutzerdefinierte Ausnahmen

Mit Python können Sie auch eigene Ausnahmen erstellen, indem Sie Klassen aus den integrierten Standardausnahmen ableiten.

Hier ist ein Beispiel für RuntimeError . Hier wird eine Klasse erstellt, die von RuntimeError untergeordnet ist . Dies ist nützlich, wenn Sie spezifischere Informationen anzeigen müssen, wenn eine Ausnahme abgefangen wird.

Im try-Block wird die benutzerdefinierte Ausnahme ausgelöst und im Ausnahmeblock abgefangen. Mit der Variablen e wird eine Instanz der Klasse Networkerror erstellt .

class Networkerror(RuntimeError):
   def __init__(self, arg):
      self.args = arg

Sobald Sie die obige Klasse definiert haben, können Sie die Ausnahme wie folgt auslösen:

try:
   raise Networkerror("Bad hostname")
except Networkerror,e:
   print e.args

Python ist seit seiner Existenz eine objektorientierte Sprache. Aus diesem Grund ist das Erstellen und Verwenden von Klassen und Objekten ausgesprochen einfach. Dieses Kapitel hilft Ihnen, ein Experte für die objektorientierte Programmierunterstützung von Python zu werden.

Wenn Sie noch keine Erfahrung mit objektorientierter Programmierung (OO) haben, können Sie einen Einführungskurs oder zumindest ein Tutorial konsultieren, um die grundlegenden Konzepte zu verstehen.

Hier ist jedoch eine kleine Einführung in die objektorientierte Programmierung (OOP), um Sie auf den neuesten Stand zu bringen -

Übersicht über die OOP-Terminologie

• Class- Ein benutzerdefinierter Prototyp für ein Objekt, der eine Reihe von Attributen definiert, die jedes Objekt der Klasse charakterisieren. Die Attribute sind Datenelemente (Klassenvariablen und Instanzvariablen) und Methoden, auf die über die Punktnotation zugegriffen wird.

• Class variable- Eine Variable, die von allen Instanzen einer Klasse gemeinsam genutzt wird. Klassenvariablen werden innerhalb einer Klasse, jedoch außerhalb einer der Methoden der Klasse definiert. Klassenvariablen werden nicht so häufig verwendet wie Instanzvariablen.

• Data member - Eine Klassenvariable oder Instanzvariable, die Daten enthält, die einer Klasse und ihren Objekten zugeordnet sind.

• Function overloading- Die Zuordnung von mehr als einem Verhalten zu einer bestimmten Funktion. Die ausgeführte Operation hängt von den beteiligten Objekttypen oder Argumenten ab.

• Instance variable - Eine Variable, die innerhalb einer Methode definiert ist und nur zur aktuellen Instanz einer Klasse gehört.

• Inheritance - Die Übertragung der Merkmale einer Klasse auf andere daraus abgeleitete Klassen.

• Instance- Ein einzelnes Objekt einer bestimmten Klasse. Ein Objektobjekt, das beispielsweise zu einer Klasse Circle gehört, ist eine Instanz der Klasse Circle.

• Instantiation - Die Erstellung einer Instanz einer Klasse.

• Method - Eine spezielle Art von Funktion, die in einer Klassendefinition definiert ist.

• Object- Eine eindeutige Instanz einer Datenstruktur, die durch ihre Klasse definiert ist. Ein Objekt umfasst sowohl Datenelemente (Klassenvariablen und Instanzvariablen) als auch Methoden.

• Operator overloading - Die Zuordnung von mehr als einer Funktion zu einem bestimmten Bediener.

Klassen erstellen

Die Klassenanweisung erstellt eine neue Klassendefinition. Der Name der Klasse folgt unmittelbar auf die Schlüsselwortklasse , gefolgt von einem Doppelpunkt wie folgt:

class ClassName:
   'Optional class documentation string'
   class_suite

• Die Klasse verfügt über eine Dokumentationszeichenfolge, auf die über ClassName .__ doc__ zugegriffen werden kann .

• Die class_suite besteht aus allen Komponentenanweisungen, die Klassenmitglieder, Datenattribute und Funktionen definieren.

Beispiel

Es folgt das Beispiel einer einfachen Python-Klasse -

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

• Die Variable empCount ist eine Klassenvariable, deren Wert von allen Instanzen dieser Klasse gemeinsam genutzt wird. Auf diese kann als Employee.empCount innerhalb oder außerhalb der Klasse zugegriffen werden .

• Die erste Methode __init __ () ist eine spezielle Methode, die als Klassenkonstruktor oder Initialisierungsmethode bezeichnet wird und von Python aufgerufen wird, wenn Sie eine neue Instanz dieser Klasse erstellen.

• Sie deklarieren andere Klassenmethoden wie normale Funktionen mit der Ausnahme, dass das erste Argument für jede Methode self ist . Python fügt das Selbst Argument für Sie in die Liste; Sie müssen es nicht einschließen, wenn Sie die Methoden aufrufen.

Instanzobjekte erstellen

Um Instanzen einer Klasse zu erstellen, rufen Sie die Klasse mit dem Klassennamen auf und übergeben die Argumente, die die Methode __init__ akzeptiert.

"This would create first object of Employee class"
emp1 = Employee("Zara", 2000)
"This would create second object of Employee class"
emp2 = Employee("Manni", 5000)

Zugriff auf Attribute

Sie greifen auf die Objektattribute mit dem Punktoperator mit Objekt zu. Auf die Klassenvariable wird wie folgt zugegriffen:

emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

Nun alle Konzepte zusammenfügen -

#!/usr/bin/python

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

"This would create first object of Employee class"
emp1 = Employee("Zara", 2000)
"This would create second object of Employee class"
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Name :  Zara ,Salary:  2000
Name :  Manni ,Salary:  5000
Total Employee 2

Sie können jederzeit Attribute von Klassen und Objekten hinzufügen, entfernen oder ändern.

emp1.age = 7  # Add an 'age' attribute.
emp1.age = 8  # Modify 'age' attribute.
del emp1.age  # Delete 'age' attribute.

Anstatt die normalen Anweisungen für den Zugriff auf Attribute zu verwenden, können Sie die folgenden Funktionen verwenden:

• Das getattr(obj, name[, default]) - um auf das Attribut des Objekts zuzugreifen.

• Das hasattr(obj,name) - um zu überprüfen, ob ein Attribut vorhanden ist oder nicht.

• Das setattr(obj,name,value)- um ein Attribut festzulegen. Wenn das Attribut nicht vorhanden ist, wird es erstellt.

• Das delattr(obj, name) - um ein Attribut zu löschen.

hasattr(emp1, 'age')    # Returns true if 'age' attribute exists
getattr(emp1, 'age')    # Returns value of 'age' attribute
setattr(emp1, 'age', 8) # Set attribute 'age' at 8
delattr(empl, 'age')    # Delete attribute 'age'

Integrierte Klassenattribute

Jede Python-Klasse folgt weiterhin den integrierten Attributen und kann wie jedes andere Attribut mit dem Punktoperator aufgerufen werden.

• __dict__ - Wörterbuch mit dem Namespace der Klasse.

• __doc__ - Klassendokumentationszeichenfolge oder keine, falls nicht definiert.

• __name__ - Klassenname.

• __module__- Modulname, in dem die Klasse definiert ist. Dieses Attribut ist im interaktiven Modus "__main__".

• __bases__ - Ein möglicherweise leeres Tupel, das die Basisklassen in der Reihenfolge ihres Auftretens in der Basisklassenliste enthält.

Lassen Sie uns für die obige Klasse versuchen, auf alle diese Attribute zuzugreifen -

#!/usr/bin/python

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

print "Employee.__doc__:", Employee.__doc__
print "Employee.__name__:", Employee.__name__
print "Employee.__module__:", Employee.__module__
print "Employee.__bases__:", Employee.__bases__
print "Employee.__dict__:", Employee.__dict__

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Employee.__doc__: Common base class for all employees
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: ()
Employee.__dict__: {'__module__': '__main__', 'displayCount':
<function displayCount at 0xb7c84994>, 'empCount': 2, 
'displayEmployee': <function displayEmployee at 0xb7c8441c>, 
'__doc__': 'Common base class for all employees', 
'__init__': <function __init__ at 0xb7c846bc>}

Objekte zerstören (Garbage Collection)

Python löscht nicht benötigte Objekte (integrierte Typen oder Klasseninstanzen) automatisch, um den Speicherplatz freizugeben. Der Prozess, mit dem Python Speicherblöcke, die nicht mehr verwendet werden, regelmäßig zurückfordert, wird als Garbage Collection bezeichnet.

Der Garbage Collector von Python wird während der Programmausführung ausgeführt und ausgelöst, wenn der Referenzzähler eines Objekts Null erreicht. Die Referenzanzahl eines Objekts ändert sich, wenn sich die Anzahl der Aliase ändert, die darauf verweisen.

Die Referenzanzahl eines Objekts erhöht sich, wenn ihm ein neuer Name zugewiesen oder in einem Container (Liste, Tupel oder Wörterbuch) abgelegt wird. Die Referenzanzahl des Objekts nimmt ab, wenn es mit del gelöscht wird , seine Referenz neu zugewiesen wird oder seine Referenz den Gültigkeitsbereich verlässt. Wenn der Referenzzähler eines Objekts Null erreicht, sammelt Python ihn automatisch.

a = 40      # Create object <40>
b = a       # Increase ref. count  of <40> 
c = [b]     # Increase ref. count  of <40> 

del a       # Decrease ref. count  of <40>
b = 100     # Decrease ref. count  of <40> 
c[0] = -1   # Decrease ref. count  of <40>

Normalerweise werden Sie nicht bemerken, wenn der Garbage Collector eine verwaiste Instanz zerstört und ihren Speicherplatz zurückerobert. Eine Klasse kann jedoch die spezielle Methode __del __ () implementieren , die als Destruktor bezeichnet wird und aufgerufen wird, wenn die Instanz zerstört werden soll. Diese Methode kann verwendet werden, um alle von einer Instanz verwendeten Nicht-Speicherressourcen zu bereinigen.

Beispiel

Dieser __del __ () - Destruktor gibt den Klassennamen einer Instanz aus, die zerstört werden soll.

#!/usr/bin/python

class Point:
   def __init__( self, x=0, y=0):
      self.x = x
      self.y = y
   def __del__(self):
      class_name = self.__class__.__name__
      print class_name, "destroyed"

pt1 = Point()
pt2 = pt1
pt3 = pt1
print id(pt1), id(pt2), id(pt3) # prints the ids of the obejcts
del pt1
del pt2
del pt3

Wenn der obige Code ausgeführt wird, erzeugt er folgendes Ergebnis:

3083401324 3083401324 3083401324
Point destroyed

Note- Idealerweise sollten Sie Ihre Klassen in einer separaten Datei definieren und sie dann mithilfe der import- Anweisung in Ihre Hauptprogrammdatei importieren .

Klassenvererbung

Anstatt von vorne zu beginnen, können Sie eine Klasse erstellen, indem Sie sie von einer bereits vorhandenen Klasse ableiten, indem Sie die übergeordnete Klasse in Klammern nach dem neuen Klassennamen auflisten.

Die untergeordnete Klasse erbt die Attribute ihrer übergeordneten Klasse, und Sie können diese Attribute so verwenden, als ob sie in der untergeordneten Klasse definiert wären. Eine untergeordnete Klasse kann auch Datenelemente und Methoden des übergeordneten Elements überschreiben.

Syntax

Abgeleitete Klassen werden ähnlich wie ihre übergeordnete Klasse deklariert. Nach dem Klassennamen wird jedoch eine Liste der Basisklassen angezeigt, von denen geerbt werden soll.

class SubClassName (ParentClass1[, ParentClass2, ...]):
   'Optional class documentation string'
   class_suite

Beispiel

#!/usr/bin/python

class Parent:        # define parent class
   parentAttr = 100
   def __init__(self):
      print "Calling parent constructor"

   def parentMethod(self):
      print 'Calling parent method'

   def setAttr(self, attr):
      Parent.parentAttr = attr

   def getAttr(self):
      print "Parent attribute :", Parent.parentAttr

class Child(Parent): # define child class
   def __init__(self):
      print "Calling child constructor"

   def childMethod(self):
      print 'Calling child method'

c = Child()          # instance of child
c.childMethod()      # child calls its method
c.parentMethod()     # calls parent's method
c.setAttr(200)       # again call parent's method
c.getAttr()          # again call parent's method

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Calling child constructor
Calling child method
Calling parent method
Parent attribute : 200

Auf ähnliche Weise können Sie eine Klasse aus mehreren übergeordneten Klassen wie folgt steuern:

class A:        # define your class A
.....

class B:         # define your class B
.....

class C(A, B):   # subclass of A and B
.....

Mit den Funktionen issubclass () oder isinstance () können Sie die Beziehungen zweier Klassen und Instanzen überprüfen.

• Das issubclass(sub, sup) Die boolesche Funktion gibt true zurück, wenn die angegebene Unterklasse sub ist in der Tat eine Unterklasse der Oberklasse sup.

• Das isinstance(obj, Class)Die boolesche Funktion gibt true zurück, wenn obj eine Instanz der Klasse Class oder eine Instanz einer Unterklasse der Klasse ist

Methoden überschreiben

Sie können Ihre übergeordneten Klassenmethoden jederzeit überschreiben. Ein Grund für das Überschreiben der übergeordneten Methoden besteht darin, dass Sie möglicherweise spezielle oder andere Funktionen in Ihrer Unterklasse wünschen.

Beispiel

#!/usr/bin/python

class Parent:        # define parent class
   def myMethod(self):
      print 'Calling parent method'

class Child(Parent): # define child class
   def myMethod(self):
      print 'Calling child method'

c = Child()          # instance of child
c.myMethod()         # child calls overridden method

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Calling child method

Basisüberladungsmethoden

In der folgenden Tabelle sind einige allgemeine Funktionen aufgeführt, die Sie in Ihren eigenen Klassen überschreiben können.

Sr.Nr.	Methode, Beschreibung & Beispielaufruf
1	__init__ ( self [,args...] ) Konstruktor (mit optionalen Argumenten) Beispielaufruf: obj = className (args)
2	__del__( self ) Destruktor, löscht ein Objekt Beispielanruf: del obj
3	__repr__( self ) Auswertbare Zeichenfolgendarstellung Beispielanruf: repr (obj)
4	__str__( self ) Druckbare Zeichenfolgendarstellung Beispielaufruf: str (obj)
5	__cmp__ ( self, x ) Objektvergleich Beispielaufruf: cmp (obj, x)

Überladen von Operatoren

Angenommen, Sie haben eine Vektorklasse erstellt, um zweidimensionale Vektoren darzustellen. Was passiert, wenn Sie sie mit dem Plus-Operator hinzufügen? Höchstwahrscheinlich wird Python dich anschreien.

Sie können jedoch die __add__ -Methode in Ihrer Klasse definieren, um eine Vektoraddition durchzuführen, und dann würde sich der Plus-Operator erwartungsgemäß verhalten -

Beispiel

#!/usr/bin/python

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b

   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print v1 + v2

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Vector(7,8)

Ausblenden von Daten

Die Attribute eines Objekts können außerhalb der Klassendefinition sichtbar sein oder nicht. Sie müssen Attribute mit einem doppelten Unterstrich benennen, und diese Attribute sind dann für Außenstehende nicht direkt sichtbar.

Beispiel

#!/usr/bin/python

class JustCounter:
   __secretCount = 0
  
   def count(self):
      self.__secretCount += 1
      print self.__secretCount

counter = JustCounter()
counter.count()
counter.count()
print counter.__secretCount

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

1
2
Traceback (most recent call last):
   File "test.py", line 12, in <module>
      print counter.__secretCount
AttributeError: JustCounter instance has no attribute '__secretCount'

Python schützt diese Mitglieder, indem der Name intern so geändert wird, dass er den Klassennamen enthält. Sie können auf Attribute wie object._className__attrName zugreifen . Wenn Sie Ihre letzte Zeile wie folgt ersetzen würden, dann funktioniert es für Sie -

.........................
print counter._JustCounter__secretCount

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

1
2
2

Ein regulärer Ausdruck ist eine spezielle Folge von Zeichen, mit deren Hilfe Sie andere Zeichenfolgen oder Sätze von Zeichenfolgen mithilfe einer speziellen Syntax in einem Muster abgleichen oder finden können. Reguläre Ausdrücke sind in der UNIX-Welt weit verbreitet.

Das Modul rebietet volle Unterstützung für Perl-ähnliche reguläre Ausdrücke in Python. Das Modul re löst die Ausnahme re.error aus, wenn beim Kompilieren oder Verwenden eines regulären Ausdrucks ein Fehler auftritt.

Wir würden zwei wichtige Funktionen behandeln, die zur Behandlung regulärer Ausdrücke verwendet werden. Aber eine kleine Sache zuerst: Es gibt verschiedene Zeichen, die eine besondere Bedeutung haben würden, wenn sie im regulären Ausdruck verwendet werden. Um Verwirrung beim Umgang mit regulären Ausdrücken zu vermeiden, verwenden wir Raw Strings asr'expression'.

Die Match- Funktion

Diese Funktion versucht, das RE- Muster mit den Zeichenfolgen mit optionalen Flags abzugleichen .

Hier ist die Syntax für diese Funktion -

re.match(pattern, string, flags=0)

Hier ist die Beschreibung der Parameter -

Sr.Nr.	Parameter & Beschreibung
1	pattern Dies ist der reguläre Ausdruck, der abgeglichen werden soll.
2	string Dies ist die Zeichenfolge, nach der gesucht wird, um mit dem Muster am Anfang der Zeichenfolge übereinzustimmen.
3	flags Sie können verschiedene Flags mit bitweisem ODER (|) angeben. Dies sind Modifikatoren, die in der folgenden Tabelle aufgeführt sind.

Die Funktion re.match gibt a zurückmatch Objekt auf Erfolg, Nonebei Ausfall. Wir verwenden die Funktion group (num) oder groups () vonmatch Objekt, um einen übereinstimmenden Ausdruck zu erhalten.

Sr.Nr.	Match Object Method & Description
1	group(num=0) Diese Methode gibt die gesamte Übereinstimmung (oder eine bestimmte Untergruppennummer) zurück.
2	groups() Diese Methode gibt alle übereinstimmenden Untergruppen in einem Tupel zurück (leer, wenn keine vorhanden waren).

Beispiel

#!/usr/bin/python
import re

line = "Cats are smarter than dogs"

matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)

if matchObj:
   print "matchObj.group() : ", matchObj.group()
   print "matchObj.group(1) : ", matchObj.group(1)
   print "matchObj.group(2) : ", matchObj.group(2)
else:
   print "No match!!"

Wenn der obige Code ausgeführt wird, erzeugt er folgendes Ergebnis:

matchObj.group() :  Cats are smarter than dogs
matchObj.group(1) :  Cats
matchObj.group(2) :  smarter

Die Suche Funktion

Diese Funktion sucht nach dem ersten Auftreten eines RE- Musters innerhalb einer Zeichenfolge mit optionalen Flags .

Hier ist die Syntax für diese Funktion -

re.search(pattern, string, flags=0)

Hier ist die Beschreibung der Parameter -

Sr.Nr.	Parameter & Beschreibung
1	pattern Dies ist der reguläre Ausdruck, der abgeglichen werden soll.
2	string Dies ist die Zeichenfolge, die gesucht wird, um mit dem Muster an einer beliebigen Stelle in der Zeichenfolge übereinzustimmen.
3	flags Sie können verschiedene Flags mit bitweisem ODER (|) angeben. Dies sind Modifikatoren, die in der folgenden Tabelle aufgeführt sind.

Die Forschungsfunktion gibt a zurückmatch Objekt auf Erfolg, nonebei Ausfall. Wir verwenden die Funktion group (num) oder groups () vonmatch Objekt, um einen übereinstimmenden Ausdruck zu erhalten.

Sr.Nr.	Übereinstimmende Objektmethoden und Beschreibung
1	group(num=0) Diese Methode gibt die gesamte Übereinstimmung (oder eine bestimmte Untergruppennummer) zurück.
2	groups() Diese Methode gibt alle übereinstimmenden Untergruppen in einem Tupel zurück (leer, wenn keine vorhanden waren).

Beispiel

#!/usr/bin/python
import re

line = "Cats are smarter than dogs";

searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)

if searchObj:
   print "searchObj.group() : ", searchObj.group()
   print "searchObj.group(1) : ", searchObj.group(1)
   print "searchObj.group(2) : ", searchObj.group(2)
else:
   print "Nothing found!!"

Wenn der obige Code ausgeführt wird, erzeugt er folgendes Ergebnis:

searchObj.group() :  Cats are smarter than dogs
searchObj.group(1) :  Cats
searchObj.group(2) :  smarter

Matching versus Suche

Python bietet zwei verschiedene primitive Operationen an, die auf regulären Ausdrücken basieren: match sucht nur am Anfang der Zeichenfolge nach einer Übereinstimmung, während search sucht an einer beliebigen Stelle in der Zeichenfolge nach einer Übereinstimmung (dies ist standardmäßig bei Perl der Fall).

Beispiel

#!/usr/bin/python
import re

line = "Cats are smarter than dogs";

matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
   print "match --> matchObj.group() : ", matchObj.group()
else:
   print "No match!!"

searchObj = re.search( r'dogs', line, re.M|re.I)
if searchObj:
   print "search --> searchObj.group() : ", searchObj.group()
else:
   print "Nothing found!!"

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

No match!!
search --> searchObj.group() :  dogs

Suchen und ersetzen

Eins der wichtigsten re Methoden, die reguläre Ausdrücke verwenden, ist sub.

Syntax

re.sub(pattern, repl, string, max=0)

Diese Methode ersetzt alle Vorkommen des RE- Musters in der Zeichenfolge durch repl und ersetzt alle Vorkommen, sofern nicht max angegeben . Diese Methode gibt eine geänderte Zeichenfolge zurück.

Beispiel

#!/usr/bin/python
import re

phone = "2004-959-559 # This is Phone Number"

# Delete Python-style comments
num = re.sub(r'#.*$', "", phone)
print "Phone Num : ", num

# Remove anything other than digits
num = re.sub(r'\D', "", phone)    
print "Phone Num : ", num

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Phone Num :  2004-959-559
Phone Num :  2004959559

Modifikatoren für reguläre Ausdrücke: Optionsflags

Literale für reguläre Ausdrücke können einen optionalen Modifikator enthalten, um verschiedene Aspekte des Abgleichs zu steuern. Die Modifikatoren werden als optionales Flag angegeben. Sie können mehrere Modifikatoren mit exklusivem ODER (|) bereitstellen, wie zuvor gezeigt, und können durch eines dieser Elemente dargestellt werden:

Sr.Nr.	Modifikator & Beschreibung
1	re.I Führt einen Matching ohne Berücksichtigung der Groß- und Kleinschreibung durch.
2	re.L Interpretiert Wörter gemäß dem aktuellen Gebietsschema. Diese Interpretation betrifft die alphabetische Gruppe (\ w und \ W) sowie das Wortgrenzenverhalten (\ b und \ B).
3	re.M Lässt $ mit dem Ende einer Zeile übereinstimmen (nicht nur mit dem Ende der Zeichenfolge) und ^ mit dem Anfang einer beliebigen Zeile (nicht nur mit dem Anfang der Zeichenfolge) übereinstimmen.
4	re.S Passt einen Punkt (Punkt) zu einem beliebigen Zeichen, einschließlich einer neuen Zeile.
5	re.U Interpretiert Buchstaben gemäß dem Unicode-Zeichensatz. Dieses Flag beeinflusst das Verhalten von \ w, \ W, \ b, \ B.
6	re.X Ermöglicht die "niedlichere" Syntax regulärer Ausdrücke. Leerzeichen werden ignoriert (außer innerhalb eines Satzes [] oder wenn sie durch einen Backslash maskiert werden) und nicht entkoppeltes # als Kommentarmarker behandelt.

Muster für reguläre Ausdrücke

Mit Ausnahme von Steuerzeichen, (+ ? . * ^ $ ( ) [ ] { } | \)Alle Charaktere stimmen überein. Sie können einem Steuerzeichen entkommen, indem Sie ihm einen Backslash voranstellen.

In der folgenden Tabelle ist die Syntax für reguläre Ausdrücke aufgeführt, die in Python verfügbar ist.

Sr.Nr.	Muster & Beschreibung
1	^ Entspricht dem Zeilenanfang.
2	$ Entspricht dem Zeilenende.
3	. Entspricht einem einzelnen Zeichen außer Zeilenumbruch. Mit der Option m kann auch der Zeilenumbruch abgeglichen werden.
4	[...] Entspricht einem einzelnen Zeichen in Klammern.
5	[^...] Entspricht einem einzelnen Zeichen, das nicht in Klammern steht
6	re* Entspricht 0 oder mehr Vorkommen des vorhergehenden Ausdrucks.
7	re+ Entspricht 1 oder mehr Vorkommen des vorhergehenden Ausdrucks.
8	re? Entspricht 0 oder 1 Vorkommen des vorhergehenden Ausdrucks.
9	re{ n} Entspricht genau n Vorkommen des vorhergehenden Ausdrucks.
10	re{ n,} Entspricht n oder mehr Vorkommen des vorhergehenden Ausdrucks.
11	re{ n, m} Entspricht mindestens n und höchstens m Vorkommen des vorhergehenden Ausdrucks.
12	a| b Entspricht entweder a oder b.
13	(re) Gruppiert reguläre Ausdrücke und merkt sich übereinstimmenden Text.
14	(?imx) Schaltet vorübergehend die Optionen i, m oder x innerhalb eines regulären Ausdrucks um. In Klammern ist nur dieser Bereich betroffen.
15	(?-imx) Schaltet die Optionen i, m oder x innerhalb eines regulären Ausdrucks vorübergehend aus. In Klammern ist nur dieser Bereich betroffen.
16	(?: re) Gruppiert reguläre Ausdrücke, ohne sich an übereinstimmenden Text zu erinnern.
17	(?imx: re) Schaltet vorübergehend die Optionen i, m oder x in Klammern um.
18	(?-imx: re) Schaltet die Optionen i, m oder x vorübergehend in Klammern aus.
19	(?#...) Kommentar.
20	(?= re) Gibt die Position anhand eines Musters an. Hat keine Reichweite.
21	(?! re) Gibt die Position mithilfe der Musterverneinung an. Hat keine Reichweite.
22	(?> re) Entspricht einem unabhängigen Muster ohne Rückverfolgung.
23	\w Entspricht Wortzeichen.
24	\W Entspricht Nichtwortzeichen.
25	\s Entspricht dem Leerzeichen. Entspricht [\ t \ n \ r \ f].
26	\S Entspricht Nicht-Leerzeichen.
27	\d Entspricht den Ziffern. Entspricht [0-9].
28	\D Entspricht nicht-stelligen.
29	\A Entspricht dem Stringanfang.
30	\Z Entspricht dem Ende der Zeichenfolge. Wenn eine neue Zeile vorhanden ist, stimmt sie kurz vor der neuen Zeile überein.
31	\z Entspricht dem Ende der Zeichenfolge.
32	\G Spielpunkt, an dem das letzte Spiel beendet wurde.
33	\b Entspricht den Wortgrenzen außerhalb der Klammern. Entspricht der Rücktaste (0x08) in Klammern.
34	\B Entspricht Nichtwortgrenzen.
35	\n, \t, etc. Entspricht Zeilenumbrüchen, Wagenrückläufen, Tabulatoren usw.
36	\1...\9 Entspricht dem n-ten gruppierten Unterausdruck.
37	\10 Entspricht dem n-ten gruppierten Unterausdruck, wenn er bereits übereinstimmt. Ansonsten bezieht sich auf die oktale Darstellung eines Zeichencodes.

Beispiele für reguläre Ausdrücke

Wörtliche Zeichen

Sr.Nr.	Beispiel & Beschreibung
1	python Match "Python".

Zeichenklassen

Sr.Nr.	Beispiel & Beschreibung
1	[Pp]ython Entspricht "Python" oder "Python"
2	rub[ye] Match "Rubin" oder "Rube"
3	[aeiou] Passen Sie einen beliebigen Kleinbuchstaben an
4	[0-9] Entspricht einer beliebigen Ziffer. das gleiche wie [0123456789]
5	[a-z] Passen Sie einen beliebigen ASCII-Kleinbuchstaben an
6	[A-Z] Passen Sie einen beliebigen ASCII-Großbuchstaben an
7	[a-zA-Z0-9] Passen Sie zu einem der oben genannten Punkte
8	[^aeiou] Passen Sie etwas anderes als einen Kleinbuchstaben an
9	[^0-9] Ordnen Sie etwas anderes als eine Ziffer zu

Sonderzeichenklassen

Sr.Nr.	Beispiel & Beschreibung
1	. Entspricht einem beliebigen Zeichen außer Newline
2	\d Entspricht einer Ziffer: [0-9]
3	\D Entspricht einer nichtstelligen Zahl: [^ 0-9]
4	\s Entspricht einem Leerzeichen: [\ t \ r \ n \ f]
5	\S Nicht-Leerzeichen abgleichen: [^ \ t \ r \ n \ f]
6	\w Entspricht einem einzelnen Wortzeichen: [A-Za-z0-9_]
7	\W Entspricht einem Nichtwortzeichen: [^ A-Za-z0-9_]

Wiederholungsfälle

Sr.Nr.	Beispiel & Beschreibung
1	ruby? Match "rub" oder "ruby": das y ist optional
2	ruby* Match "rub" plus 0 oder mehr ys
3	ruby+ Match "rub" plus 1 oder mehr ys
4	\d{3} Passen Sie genau 3 Ziffern an
5	\d{3,} Entspricht 3 oder mehr Ziffern
6	\d{3,5} Passen Sie 3, 4 oder 5 Ziffern an

Nongreedy Wiederholung

Dies entspricht der geringsten Anzahl von Wiederholungen -

Sr.Nr.	Beispiel & Beschreibung
1	<.*> Gierige Wiederholung: Entspricht "<python> perl>"
2	<.*?> Nongreedy: Entspricht "<python>" in "<python> perl>"

Gruppieren mit Klammern

Sr.Nr.	Beispiel & Beschreibung
1	\D\d+ Keine Gruppe: + wiederholt \ d
2	(\D\d)+ Gruppiert: + wiederholt \ D \ d Paar
3	([Pp]ython(, )?)+ Match "Python", "Python, Python, Python" usw.

Rückreferenzen

Dies entspricht wieder einer zuvor übereinstimmenden Gruppe -

Sr.Nr.	Beispiel & Beschreibung
1	([Pp])ython&\1ails Passen Sie Python & Eimer oder Python & Eimer an
2	(['"])[^\1]*\1 Einfache oder doppelte Zeichenfolge. \ 1 stimmt mit der 1. Gruppe überein. \ 2 stimmt mit der 2. Gruppe überein usw.

Alternativen

Sr.Nr.	Beispiel & Beschreibung
1	python|perl Match "Python" oder "Perl"
2	rub(y|le)) Match "Rubin" oder "Rubel"
3	Python(!+|\?) "Python" gefolgt von einem oder mehreren! oder einer?

Anker

Dies muss die Übereinstimmungsposition angeben.

Sr.Nr.	Beispiel & Beschreibung
1	^Python Passen Sie "Python" am Anfang eines Strings oder einer internen Zeile an
2	Python$ Entspricht "Python" am Ende einer Zeichenfolge oder Zeile
3	\APython Entspricht "Python" am Anfang einer Zeichenfolge
4	Python\Z Entspricht "Python" am Ende eines Strings
5	\bPython\b Passen Sie "Python" an einer Wortgrenze an
6	\brub\B \ B ist eine Nichtwortgrenze: Entspricht "rub" in "rube" und "ruby", aber nicht allein
7	Python(?=!) Entspricht "Python", wenn ein Ausrufezeichen folgt.
8	Python(?!!) Entspricht "Python", wenn kein Ausrufezeichen folgt.

Spezielle Syntax mit Klammern

Sr.Nr.	Beispiel & Beschreibung
1	R(?#comment) Entspricht "R". Der Rest ist ein Kommentar
2	R(?i)uby Groß- und Kleinschreibung wird nicht berücksichtigt, während "uby"
3	R(?i:uby) Das gleiche wie oben
4	rub(?:y|le)) Nur gruppieren, ohne \ 1 Rückreferenz zu erstellen

Das Common Gateway Interface (CGI) ist eine Reihe von Standards, die definieren, wie Informationen zwischen dem Webserver und einem benutzerdefinierten Skript ausgetauscht werden. Die CGI-Spezifikationen werden derzeit von der NCSA verwaltet.

Was ist CGI?

• Das Common Gateway Interface (CGI) ist ein Standard für externe Gateway-Programme zur Schnittstelle mit Informationsservern wie HTTP-Servern.

• Die aktuelle Version ist CGI / 1.1 und CGI / 1.2 ist in Bearbeitung.

Surfen im Internet

Um das Konzept von CGI zu verstehen, lassen Sie uns sehen, was passiert, wenn wir auf einen Hyperlink klicken, um eine bestimmte Webseite oder URL zu durchsuchen.

• Ihr Browser kontaktiert den HTTP-Webserver und fordert die URL an, dh den Dateinamen.

• Der Webserver analysiert die URL und sucht nach dem Dateinamen. Wenn diese Datei gefunden wird, wird sie an den Browser zurückgesendet. Andernfalls wird eine Fehlermeldung gesendet, die angibt, dass Sie eine falsche Datei angefordert haben.

• Der Webbrowser nimmt die Antwort vom Webserver entgegen und zeigt entweder die empfangene Datei oder die Fehlermeldung an.

Es ist jedoch möglich, den HTTP-Server so einzurichten, dass diese Datei nicht zurückgesendet wird, wenn eine Datei in einem bestimmten Verzeichnis angefordert wird. Stattdessen wird es als Programm ausgeführt, und alles, was dieses Programm ausgibt, wird zur Anzeige durch Ihren Browser zurückgesendet. Diese Funktion wird als Common Gateway Interface oder CGI bezeichnet, und die Programme werden als CGI-Skripte bezeichnet. Diese CGI-Programme können ein Python-Skript, ein PERL-Skript, ein Shell-Skript, ein C- oder C ++ - Programm usw. sein.

CGI-Architekturdiagramm

Unterstützung und Konfiguration von Webservern

Bevor Sie mit der CGI-Programmierung fortfahren, stellen Sie sicher, dass Ihr Webserver CGI unterstützt und für die Verarbeitung von CGI-Programmen konfiguriert ist. Alle vom HTTP-Server auszuführenden CGI-Programme werden in einem vorkonfigurierten Verzeichnis gespeichert. Dieses Verzeichnis heißt CGI-Verzeichnis und wird üblicherweise als / var / www / cgi-bin bezeichnet. Konventionell haben CGI-Dateien die Erweiterung als.cgi, Sie können Ihre Dateien jedoch mit der Python-Erweiterung behalten .py auch.

Standardmäßig ist der Linux-Server so konfiguriert, dass nur die Skripts im Verzeichnis cgi-bin in / var / www ausgeführt werden. Wenn Sie ein anderes Verzeichnis zum Ausführen Ihrer CGI-Skripte angeben möchten, kommentieren Sie die folgenden Zeilen in der Datei httpd.conf:

<Directory "/var/www/cgi-bin">
   AllowOverride None
   Options ExecCGI
   Order allow,deny
   Allow from all
</Directory>

<Directory "/var/www/cgi-bin">
Options All
</Directory>

Hier gehen wir davon aus, dass Sie den Webserver erfolgreich eingerichtet haben und jedes andere CGI-Programm wie Perl oder Shell usw. ausführen können.

Erstes CGI-Programm

Hier ist ein einfacher Link, der mit einem CGI-Skript namens hello.py verknüpft ist . Diese Datei befindet sich im Verzeichnis / var / www / cgi-bin und enthält folgenden Inhalt. Stellen Sie vor dem Ausführen Ihres CGI-Programms sicher, dass Sie den Dateimodus mit verwendenchmod 755 hello.py UNIX-Befehl, um die Datei ausführbar zu machen.

#!/usr/bin/python

print "Content-type:text/html\r\n\r\n"
print '<html>'
print '<head>'
print '<title>Hello World - First CGI Program</title>'
print '</head>'
print '<body>'
print '<h2>Hello World! This is my first CGI program</h2>'
print '</body>'
print '</html>'

Wenn Sie auf hello.py klicken, wird die folgende Ausgabe erstellt:

Hallo Welt! Dies ist mein erstes CGI-Programm

Dieses hello.py-Skript ist ein einfaches Python-Skript, das seine Ausgabe in die STDOUT-Datei, dh in den Bildschirm, schreibt. Es gibt eine wichtige und zusätzliche Funktion, nämlich die erste zu druckende ZeileContent-type:text/html\r\n\r\n. Diese Zeile wird an den Browser zurückgesendet und gibt den Inhaltstyp an, der auf dem Browserbildschirm angezeigt werden soll.

Inzwischen müssen Sie das Grundkonzept von CGI verstanden haben und können mit Python viele komplizierte CGI-Programme schreiben. Dieses Skript kann mit jedem anderen externen System interagieren, um auch Informationen wie RDBMS auszutauschen.

HTTP-Header

Die Linie Content-type:text/html\r\n\r\nist Teil des HTTP-Headers, der an den Browser gesendet wird, um den Inhalt zu verstehen. Der gesamte HTTP-Header hat die folgende Form:

HTTP Field Name: Field Content

For Example
Content-type: text/html\r\n\r\n

Es gibt nur wenige andere wichtige HTTP-Header, die Sie häufig in Ihrer CGI-Programmierung verwenden.

Sr.Nr.	Header & Beschreibung
1	Content-type: Eine MIME-Zeichenfolge, die das Format der zurückgegebenen Datei definiert. Beispiel ist Inhaltstyp: text / html
2	Expires: Date Das Datum, an dem die Informationen ungültig werden. Es wird vom Browser verwendet, um zu entscheiden, wann eine Seite aktualisiert werden muss. Eine gültige Datumszeichenfolge hat das Format 01. Januar 1998, 12:00:00 GMT.
3	Location: URL Die URL, die anstelle der angeforderten URL zurückgegeben wird. In diesem Feld können Sie eine Anforderung an eine beliebige Datei umleiten.
4	Last-modified: Date Das Datum der letzten Änderung der Ressource.
5	Content-length: N Die Länge der zurückgegebenen Daten in Byte. Der Browser verwendet diesen Wert, um die geschätzte Downloadzeit für eine Datei anzugeben.
6	Set-Cookie: String Setzen Sie das Cookie, das durch die Zeichenfolge geleitet wird

CGI-Umgebungsvariablen

Alle CGI-Programme haben Zugriff auf die folgenden Umgebungsvariablen. Diese Variablen spielen beim Schreiben eines CGI-Programms eine wichtige Rolle.

Sr.Nr.	Variablenname & Beschreibung
1	CONTENT_TYPE Der Datentyp des Inhalts. Wird verwendet, wenn der Client angehängte Inhalte an den Server sendet. Zum Beispiel das Hochladen von Dateien.
2	CONTENT_LENGTH Die Länge der Abfrageinformationen. Es ist nur für POST-Anfragen verfügbar.
3	HTTP_COOKIE Gibt die gesetzten Cookies in Form eines Schlüssel-Wert-Paares zurück.
4	HTTP_USER_AGENT Das Feld User-Agent-Anforderungsheader enthält Informationen zu dem Benutzeragenten, von dem die Anforderung stammt. Es ist der Name des Webbrowsers.
5	PATH_INFO Der Pfad für das CGI-Skript.
6	QUERY_STRING Die URL-codierten Informationen, die mit der GET-Methodenanforderung gesendet werden.
7	REMOTE_ADDR Die IP-Adresse des Remote-Hosts, der die Anforderung stellt. Dies ist nützlich für die Protokollierung oder zur Authentifizierung.
8	REMOTE_HOST Der vollständig qualifizierte Name des Hosts, der die Anforderung stellt. Wenn diese Informationen nicht verfügbar sind, kann REMOTE_ADDR verwendet werden, um die IR-Adresse abzurufen.
9	REQUEST_METHOD Die Methode, mit der die Anforderung gestellt wurde. Die gebräuchlichsten Methoden sind GET und POST.
10	SCRIPT_FILENAME Der vollständige Pfad zum CGI-Skript.
11	SCRIPT_NAME Der Name des CGI-Skripts.
12	SERVER_NAME Der Hostname oder die IP-Adresse des Servers
13	SERVER_SOFTWARE Der Name und die Version der Software, die auf dem Server ausgeführt wird.

Hier ist ein kleines CGI-Programm, um alle CGI-Variablen aufzulisten. Klicken Sie auf diesen Link, um das Ergebnis Get Environment anzuzeigen

#!/usr/bin/python

import os

print "Content-type: text/html\r\n\r\n";
print "<font size=+1>Environment</font><\br>";
for param in os.environ.keys():
   print "<b>%20s</b>: %s<\br>" % (param, os.environ[param])

GET- und POST-Methoden

Sie müssen auf viele Situationen gestoßen sein, in denen Sie einige Informationen von Ihrem Browser an den Webserver und letztendlich an Ihr CGI-Programm übergeben müssen. Am häufigsten verwendet der Browser zwei Methoden, um diese Informationen an den Webserver weiterzugeben. Diese Methoden sind GET-Methode und POST-Methode.

Übergabe von Informationen mit der GET-Methode

Die GET-Methode sendet die codierten Benutzerinformationen, die an die Seitenanforderung angehängt sind. Die Seite und die verschlüsselten Informationen werden durch das? Zeichen wie folgt -

http://www.test.com/cgi-bin/hello.py?key1=value1&key2=value2

Die GET-Methode ist die Standardmethode zum Übergeben von Informationen vom Browser an den Webserver und erzeugt eine lange Zeichenfolge, die im Feld Speicherort: Ihres Browsers angezeigt wird. Verwenden Sie niemals die GET-Methode, wenn Sie ein Kennwort oder andere vertrauliche Informationen haben, die an den Server übergeben werden sollen. Die GET-Methode hat eine Größenbeschränkung: In einer Anforderungszeichenfolge können nur 1024 Zeichen gesendet werden. Die GET-Methode sendet Informationen mithilfe des QUERY_STRING-Headers und ist in Ihrem CGI-Programm über die Umgebungsvariable QUERY_STRING zugänglich.

Sie können Informationen übergeben, indem Sie einfach Schlüssel- und Wertepaare zusammen mit einer beliebigen URL verketten, oder Sie können HTML-Tags <FORM> verwenden, um Informationen mithilfe der GET-Methode zu übergeben.

Einfaches URL-Beispiel: Get-Methode

Hier ist eine einfache URL, die mithilfe der GET-Methode zwei Werte an das Programm hello_get.py übergibt.

/cgi-bin/hello_get.py?first_name=ZARA&last_name=ALI

Drunter ist hello_get.pySkript für die Eingabe durch den Webbrowser. Wir werden verwendencgi Modul, das den Zugriff auf übergebene Informationen sehr einfach macht -

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
first_name = form.getvalue('first_name')
last_name  = form.getvalue('last_name')

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Hello - Second CGI Program</title>"
print "</head>"
print "<body>"
print "<h2>Hello %s %s</h2>" % (first_name, last_name)
print "</body>"
print "</html>"

Dies würde das folgende Ergebnis erzeugen -

Hallo ZARA ALI

Einfaches FORMULAR Beispiel: GET-Methode

In diesem Beispiel werden zwei Werte mit HTML FORM und der Schaltfläche "Senden" übergeben. Wir verwenden dasselbe CGI-Skript hello_get.py, um diese Eingabe zu verarbeiten.

<form action = "/cgi-bin/hello_get.py" method = "get">
First Name: <input type = "text" name = "first_name">  <br />

Last Name: <input type = "text" name = "last_name" />
<input type = "submit" value = "Submit" />
</form>

Hier ist die tatsächliche Ausgabe des obigen Formulars. Geben Sie den Vor- und Nachnamen ein und klicken Sie auf die Schaltfläche "Senden", um das Ergebnis anzuzeigen.

Weitergabe von Informationen mithilfe der POST-Methode

Eine allgemein zuverlässigere Methode zum Übergeben von Informationen an ein CGI-Programm ist die POST-Methode. Dadurch werden die Informationen genauso verpackt wie bei GET-Methoden, jedoch nicht als Textzeichenfolge nach einem? In der URL wird es als separate Nachricht gesendet. Diese Nachricht wird in Form der Standardeingabe in das CGI-Skript eingegeben.

Unten finden Sie dasselbe Skript hello_get.py, das sowohl die GET- als auch die POST-Methode behandelt.

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
first_name = form.getvalue('first_name')
last_name  = form.getvalue('last_name')

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Hello - Second CGI Program</title>"
print "</head>"
print "<body>"
print "<h2>Hello %s %s</h2>" % (first_name, last_name)
print "</body>"
print "</html>"

Nehmen wir noch einmal das gleiche Beispiel wie oben, bei dem zwei Werte mit HTML FORM und der Schaltfläche "Senden" übergeben werden. Wir verwenden dasselbe CGI-Skript hello_get.py, um diese Eingabe zu verarbeiten.

<form action = "/cgi-bin/hello_get.py" method = "post">
First Name: <input type = "text" name = "first_name"><br />
Last Name: <input type = "text" name = "last_name" />

<input type = "submit" value = "Submit" />
</form>

Hier ist die tatsächliche Ausgabe des obigen Formulars. Sie geben Vor- und Nachnamen ein und klicken dann auf die Schaltfläche Senden, um das Ergebnis anzuzeigen.

Übergeben von Checkbox-Daten an das CGI-Programm

Kontrollkästchen werden verwendet, wenn mehr als eine Option ausgewählt werden muss.

Hier ist ein Beispiel für einen HTML-Code für ein Formular mit zwei Kontrollkästchen:

<form action = "/cgi-bin/checkbox.cgi" method = "POST" target = "_blank">
<input type = "checkbox" name = "maths" value = "on" /> Maths
<input type = "checkbox" name = "physics" value = "on" /> Physics
<input type = "submit" value = "Select Subject" />
</form>

Das Ergebnis dieses Codes ist das folgende Formular:

Unten finden Sie das Skript checkbox.cgi, mit dem die vom Webbrowser für die Schaltfläche mit den Kontrollkästchen eingegebenen Daten verarbeitet werden.

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
if form.getvalue('maths'):
   math_flag = "ON"
else:
   math_flag = "OFF"

if form.getvalue('physics'):
   physics_flag = "ON"
else:
   physics_flag = "OFF"

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Checkbox - Third CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> CheckBox Maths is : %s</h2>" % math_flag
print "<h2> CheckBox Physics is : %s</h2>" % physics_flag
print "</body>"
print "</html>"

Weitergabe von Optionsfelddaten an das CGI-Programm

Optionsfelder werden verwendet, wenn nur eine Option ausgewählt werden muss.

Hier ist ein Beispiel für einen HTML-Code für ein Formular mit zwei Optionsfeldern:

<form action = "/cgi-bin/radiobutton.py" method = "post" target = "_blank">
<input type = "radio" name = "subject" value = "maths" /> Maths
<input type = "radio" name = "subject" value = "physics" /> Physics
<input type = "submit" value = "Select Subject" />
</form>

Das Ergebnis dieses Codes ist das folgende Formular:

Unten finden Sie das Skript radiobutton.py, mit dem Eingaben des Webbrowsers für das Optionsfeld verarbeitet werden können.

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
if form.getvalue('subject'):
   subject = form.getvalue('subject')
else:
   subject = "Not set"

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Radio - Fourth CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> Selected Subject is %s</h2>" % subject
print "</body>"
print "</html>"

Übergeben von Textbereichsdaten an das CGI-Programm

Das TEXTAREA-Element wird verwendet, wenn mehrzeiliger Text an das CGI-Programm übergeben werden muss.

Hier ist ein Beispiel für einen HTML-Code für ein Formular mit einer TEXTAREA-Box:

<form action = "/cgi-bin/textarea.py" method = "post" target = "_blank">
<textarea name = "textcontent" cols = "40" rows = "4">
Type your text here...
</textarea>
<input type = "submit" value = "Submit" />
</form>

Das Ergebnis dieses Codes ist das folgende Formular:

Unten finden Sie das Skript textarea.cgi für die Eingabe durch den Webbrowser.

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
if form.getvalue('textcontent'):
   text_content = form.getvalue('textcontent')
else:
   text_content = "Not entered"

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>";
print "<title>Text Area - Fifth CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> Entered Text Content is %s</h2>" % text_content
print "</body>"

Übergeben von Dropdown-Box-Daten an das CGI-Programm

Dropdown-Box wird verwendet, wenn viele Optionen verfügbar sind, aber nur eine oder zwei ausgewählt werden.

Hier ist ein Beispiel für einen HTML-Code für ein Formular mit einem Dropdown-Feld:

<form action = "/cgi-bin/dropdown.py" method = "post" target = "_blank">
<select name = "dropdown">
<option value = "Maths" selected>Maths</option>
<option value = "Physics">Physics</option>
</select>
<input type = "submit" value = "Submit"/>
</form>

Das Ergebnis dieses Codes ist das folgende Formular:

Unten finden Sie das Skript dropdown.py für die Eingabe durch den Webbrowser.

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
if form.getvalue('dropdown'):
   subject = form.getvalue('dropdown')
else:
   subject = "Not entered"

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Dropdown Box - Sixth CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> Selected Subject is %s</h2>" % subject
print "</body>"
print "</html>"

Verwenden von Cookies in CGI

Das HTTP-Protokoll ist ein zustandsloses Protokoll. Für eine kommerzielle Website ist es erforderlich, Sitzungsinformationen zwischen verschiedenen Seiten zu verwalten. Beispielsweise endet eine Benutzerregistrierung nach Abschluss vieler Seiten. Wie kann ich die Sitzungsinformationen des Benutzers auf allen Webseiten verwalten?

In vielen Situationen ist die Verwendung von Cookies die effizienteste Methode, um Einstellungen, Einkäufe, Provisionen und andere Informationen zu speichern und zu verfolgen, die für eine bessere Besuchererfahrung oder Site-Statistiken erforderlich sind.

Wie es funktioniert?

Ihr Server sendet einige Daten in Form eines Cookies an den Browser des Besuchers. Der Browser akzeptiert möglicherweise das Cookie. In diesem Fall wird es als Nur-Text-Datensatz auf der Festplatte des Besuchers gespeichert. Wenn der Besucher nun auf einer anderen Seite Ihrer Website ankommt, kann das Cookie abgerufen werden. Nach dem Abrufen weiß Ihr Server, was gespeichert wurde.

Cookies sind ein Nur-Text-Datensatz mit 5 Feldern variabler Länge.

• Expires- Das Datum, an dem der Cookie abläuft. Wenn dies leer ist, läuft das Cookie ab, wenn der Besucher den Browser verlässt.

• Domain - Der Domainname Ihrer Site.

• Path- Der Pfad zu dem Verzeichnis oder der Webseite, in dem das Cookie gesetzt wird. Dies kann leer sein, wenn Sie das Cookie aus einem beliebigen Verzeichnis oder einer beliebigen Seite abrufen möchten.

• Secure- Wenn dieses Feld das Wort "sicher" enthält, kann das Cookie nur mit einem sicheren Server abgerufen werden. Wenn dieses Feld leer ist, besteht keine solche Einschränkung.

• Name=Value - Cookies werden in Form von Schlüssel- und Wertepaaren gesetzt und abgerufen.

Cookies einrichten

Es ist sehr einfach, Cookies an den Browser zu senden. Diese Cookies werden zusammen mit dem HTTP-Header an das Feld Inhaltstyp gesendet. Angenommen, Sie möchten Benutzer-ID und Kennwort als Cookies festlegen. Das Setzen der Cookies erfolgt wie folgt:

#!/usr/bin/python

print "Set-Cookie:UserID = XYZ;\r\n"
print "Set-Cookie:Password = XYZ123;\r\n"
print "Set-Cookie:Expires = Tuesday, 31-Dec-2007 23:12:40 GMT";\r\n"
print "Set-Cookie:Domain = www.tutorialspoint.com;\r\n"
print "Set-Cookie:Path = /perl;\n"
print "Content-type:text/html\r\n\r\n"
...........Rest of the HTML Content....

In diesem Beispiel müssen Sie verstanden haben, wie Cookies gesetzt werden. Wir gebrauchenSet-Cookie HTTP-Header zum Setzen von Cookies.

Es ist optional, Cookie-Attribute wie Expires, Domain und Path festzulegen. Es ist bemerkenswert, dass Cookies gesetzt werden, bevor eine magische Linie gesendet wird"Content-type:text/html\r\n\r\n.

Cookies abrufen

Es ist sehr einfach, alle gesetzten Cookies abzurufen. Cookies werden in der CGI-Umgebungsvariablen HTTP_COOKIE gespeichert und haben die folgende Form:

key1 = value1;key2 = value2;key3 = value3....

Hier ist ein Beispiel zum Abrufen von Cookies.

#!/usr/bin/python

# Import modules for CGI handling 
from os import environ
import cgi, cgitb

if environ.has_key('HTTP_COOKIE'):
   for cookie in map(strip, split(environ['HTTP_COOKIE'], ';')):
      (key, value ) = split(cookie, '=');
      if key == "UserID":
         user_id = value

      if key == "Password":
         password = value

print "User ID  = %s" % user_id
print "Password = %s" % password

Dies führt zu folgendem Ergebnis für die durch das obige Skript gesetzten Cookies:

User ID = XYZ
Password = XYZ123

Beispiel für das Hochladen von Dateien

Um eine Datei hochzuladen, muss für das HTML-Formular das Attribut enctype auf gesetzt sein multipart/form-data. Das Eingabe-Tag mit dem Dateityp erstellt eine Schaltfläche "Durchsuchen".

<html>
<body>
   <form enctype = "multipart/form-data" 
                     action = "save_file.py" method = "post">
   <p>File: <input type = "file" name = "filename" /></p>
   <p><input type = "submit" value = "Upload" /></p>
   </form>
</body>
</html>

Das Ergebnis dieses Codes ist das folgende Formular:

Das obige Beispiel wurde absichtlich deaktiviert, um Personen zu speichern, die Dateien auf unseren Server hochladen. Sie können jedoch den obigen Code mit Ihrem Server ausprobieren.

Hier ist das Skript save_file.py zum Hochladen von Dateien -

#!/usr/bin/python

import cgi, os
import cgitb; cgitb.enable()

form = cgi.FieldStorage()

# Get filename here.
fileitem = form['filename']

# Test if the file was uploaded
if fileitem.filename:
   # strip leading path from file name to avoid 
   # directory traversal attacks
   fn = os.path.basename(fileitem.filename)
   open('/tmp/' + fn, 'wb').write(fileitem.file.read())

   message = 'The file "' + fn + '" was uploaded successfully'
   
else:
   message = 'No file was uploaded'
   
print """\
Content-Type: text/html\n
<html>
<body>
   <p>%s</p>
</body>
</html>
""" % (message,)

Wenn Sie das obige Skript unter Unix / Linux ausführen, müssen Sie darauf achten, das Dateitrennzeichen wie folgt zu ersetzen. Andernfalls sollte die Anweisung open () auf Ihrem Windows-Computer einwandfrei funktionieren.

fn = os.path.basename(fileitem.filename.replace("\\", "/" ))

Wie rufe ich ein Dialogfeld "Dateidownload" auf?

Manchmal ist es erwünscht, dass Sie eine Option angeben möchten, bei der ein Benutzer auf einen Link klicken kann, und dem Benutzer ein Dialogfeld "Dateidownload" angezeigt wird, anstatt den tatsächlichen Inhalt anzuzeigen. Dies ist sehr einfach und kann über den HTTP-Header erreicht werden. Dieser HTTP-Header unterscheidet sich von dem im vorherigen Abschnitt erwähnten Header.

Zum Beispiel, wenn Sie eine machen möchten FileName Datei von einem bestimmten Link herunterladbar, dann ist ihre Syntax wie folgt -

#!/usr/bin/python

# HTTP Header
print "Content-Type:application/octet-stream; name = \"FileName\"\r\n";
print "Content-Disposition: attachment; filename = \"FileName\"\r\n\n";

# Actual File Content will go here.
fo = open("foo.txt", "rb")

str = fo.read();
print str

# Close opend file
fo.close()

Ich hoffe, Ihnen hat dieses Tutorial gefallen. Wenn ja, senden Sie mir bitte Ihr Feedback an: Kontaktieren Sie uns

Der Python-Standard für Datenbankschnittstellen ist die Python-DB-API. Die meisten Python-Datenbankschnittstellen entsprechen diesem Standard.

Sie können die richtige Datenbank für Ihre Anwendung auswählen. Die Python-Datenbank-API unterstützt eine Vielzahl von Datenbankservern wie -

• GadFly
• mSQL
• MySQL
• PostgreSQL
• Microsoft SQL Server 2000
• Informix
• Interbase
• Oracle
• Sybase

Hier ist die Liste der verfügbaren Python-Datenbankschnittstellen: Python-Datenbankschnittstellen und APIs . Sie müssen für jede Datenbank, auf die Sie zugreifen müssen, ein separates DB-API-Modul herunterladen. Wenn Sie beispielsweise sowohl auf eine Oracle-Datenbank als auch auf eine MySQL-Datenbank zugreifen müssen, müssen Sie sowohl das Oracle- als auch das MySQL-Datenbankmodul herunterladen.

Die DB-API bietet einen Mindeststandard für die Arbeit mit Datenbanken unter Verwendung von Python-Strukturen und -Syntax, wo immer dies möglich ist. Diese API enthält Folgendes:

• API-Modul importieren.
• Herstellen einer Verbindung mit der Datenbank.
• Ausgabe von SQL-Anweisungen und gespeicherten Prozeduren.
• Verbindung schließen

Wir würden alle Konzepte mit MySQL lernen, also lassen Sie uns über das MySQLdb-Modul sprechen.

Was ist MySQLdb?

MySQLdb ist eine Schnittstelle zum Herstellen einer Verbindung zu einem MySQL-Datenbankserver von Python. Es implementiert die Python-Datenbank-API v2.0 und basiert auf der MySQL C-API.

Wie installiere ich MySQLdb?

Bevor Sie fortfahren, stellen Sie sicher, dass MySQLdb auf Ihrem Computer installiert ist. Geben Sie einfach Folgendes in Ihr Python-Skript ein und führen Sie es aus:

#!/usr/bin/python

import MySQLdb

Wenn das folgende Ergebnis angezeigt wird, bedeutet dies, dass das MySQLdb-Modul nicht installiert ist.

Traceback (most recent call last):
   File "test.py", line 3, in <module>
      import MySQLdb
ImportError: No module named MySQLdb

Verwenden Sie den folgenden Befehl, um das MySQLdb-Modul zu installieren:

For Ubuntu, use the following command -
$ sudo apt-get install python-pip python-dev libmysqlclient-dev For Fedora, use the following command - $ sudo dnf install python python-devel mysql-devel redhat-rpm-config gcc
For Python command prompt, use the following command -
pip install MySQL-python

Note - Stellen Sie sicher, dass Sie über die Root-Berechtigung zur Installation des obigen Moduls verfügen.

Datenbankverbindung

Stellen Sie vor dem Herstellen einer Verbindung zu einer MySQL-Datenbank Folgendes sicher:

• Sie haben eine Datenbank TESTDB erstellt.

• Sie haben in TESTDB eine Tabelle EMPLOYEE erstellt.

• Diese Tabelle enthält die Felder FIRST_NAME, LAST_NAME, AGE, SEX und INCOME.

• Die Benutzer-ID "testuser" und das Kennwort "test123" sind für den Zugriff auf TESTDB festgelegt.

• Das Python-Modul MySQLdb ist ordnungsgemäß auf Ihrem Computer installiert.

• Sie haben das MySQL-Tutorial durchgearbeitet, um die MySQL-Grundlagen zu verstehen .

Beispiel

Das folgende Beispiel zeigt die Verbindung mit der MySQL-Datenbank "TESTDB".

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# execute SQL query using execute() method.
cursor.execute("SELECT VERSION()")

# Fetch a single row using fetchone() method.
data = cursor.fetchone()
print "Database version : %s " % data

# disconnect from server
db.close()

Während dieses Skripts ausgeführt wird, wird auf meinem Linux-Computer das folgende Ergebnis erzielt.

Database version : 5.0.45

Wenn eine Verbindung mit der Datenquelle hergestellt wird, wird ein Verbindungsobjekt zurückgegeben und in gespeichert db zur weiteren Verwendung, sonst dbist auf Keine gesetzt. Nächster,db Objekt wird verwendet, um ein zu erstellen cursorObjekt, das wiederum zum Ausführen von SQL-Abfragen verwendet wird. Schließlich wird vor dem Herauskommen sichergestellt, dass die Datenbankverbindung geschlossen und Ressourcen freigegeben werden.

Erstellen einer Datenbanktabelle

Sobald eine Datenbankverbindung hergestellt ist, können wir mithilfe von Tabellen oder Datensätzen in die Datenbanktabellen erstellen execute Methode des erstellten Cursors.

Beispiel

Lassen Sie uns die Datenbanktabelle EMPLOYEE erstellen -

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Drop table if it already exist using execute() method.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

# Create table as per requirement
sql = """CREATE TABLE EMPLOYEE (
         FIRST_NAME  CHAR(20) NOT NULL,
         LAST_NAME  CHAR(20),
         AGE INT,  
         SEX CHAR(1),
         INCOME FLOAT )"""

cursor.execute(sql)

# disconnect from server
db.close()

INSERT-Betrieb

Dies ist erforderlich, wenn Sie Ihre Datensätze in einer Datenbanktabelle erstellen möchten.

Beispiel

Im folgenden Beispiel wird die SQL INSERT- Anweisung ausgeführt, um einen Datensatz in der EMPLOYEE-Tabelle zu erstellen.

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to INSERT a record into the database.
sql = """INSERT INTO EMPLOYEE(FIRST_NAME,
         LAST_NAME, AGE, SEX, INCOME)
         VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

Das obige Beispiel kann wie folgt geschrieben werden, um SQL-Abfragen dynamisch zu erstellen:

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to INSERT a record into the database.
sql = "INSERT INTO EMPLOYEE(FIRST_NAME, \
       LAST_NAME, AGE, SEX, INCOME) \
       VALUES ('%s', '%s', '%d', '%c', '%d' )" % \
       ('Mac', 'Mohan', 20, 'M', 2000)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

Beispiel

Das folgende Codesegment ist eine andere Form der Ausführung, bei der Sie Parameter direkt übergeben können -

..................................
user_id = "test123"
password = "password"

con.execute('insert into Login values("%s", "%s")' % \
             (user_id, password))
..................................

LESEN Betrieb

READ Operation für eine beliebige Datenbank bedeutet, einige nützliche Informationen aus der Datenbank abzurufen.

Sobald unsere Datenbankverbindung hergestellt ist, können Sie eine Abfrage in dieser Datenbank durchführen. Sie können entweder verwendenfetchone() Methode zum Abrufen eines einzelnen Datensatzes oder fetchall() Methode zum Abrufen mehrerer Werte aus einer Datenbanktabelle.

• fetchone()- Es ruft die nächste Zeile einer Abfrageergebnismenge ab. Eine Ergebnismenge ist ein Objekt, das zurückgegeben wird, wenn ein Cursorobjekt zum Abfragen einer Tabelle verwendet wird.

• fetchall()- Es werden alle Zeilen in einer Ergebnismenge abgerufen. Wenn bereits einige Zeilen aus der Ergebnismenge extrahiert wurden, werden die verbleibenden Zeilen aus der Ergebnismenge abgerufen.

• rowcount - Dies ist ein schreibgeschütztes Attribut und gibt die Anzahl der Zeilen zurück, die von einer execute () -Methode betroffen waren.

Beispiel

Das folgende Verfahren fragt alle Datensätze aus der EMPLOYEE-Tabelle mit einem Gehalt von mehr als 1000 ab.

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

sql = "SELECT * FROM EMPLOYEE \
       WHERE INCOME > '%d'" % (1000)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Fetch all the rows in a list of lists.
   results = cursor.fetchall()
   for row in results:
      fname = row[0]
      lname = row[1]
      age = row[2]
      sex = row[3]
      income = row[4]
      # Now print fetched result
      print "fname=%s,lname=%s,age=%d,sex=%s,income=%d" % \
             (fname, lname, age, sex, income )
except:
   print "Error: unable to fecth data"

# disconnect from server
db.close()

Dies führt zu folgendem Ergebnis:

fname=Mac, lname=Mohan, age=20, sex=M, income=2000

Vorgang aktualisieren

UPDATE Operation für eine beliebige Datenbank bedeutet, einen oder mehrere Datensätze zu aktualisieren, die bereits in der Datenbank verfügbar sind.

Das folgende Verfahren aktualisiert alle Datensätze mit SEX als 'M'. Hier erhöhen wir das ALTER aller Männchen um ein Jahr.

Beispiel

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to UPDATE required records
sql = "UPDATE EMPLOYEE SET AGE = AGE + 1
                          WHERE SEX = '%c'" % ('M')
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

DELETE-Betrieb

Der Vorgang LÖSCHEN ist erforderlich, wenn Sie einige Datensätze aus Ihrer Datenbank löschen möchten. Im Folgenden wird beschrieben, wie Sie alle Datensätze von EMPLOYEE löschen, wenn das Alter mehr als 20 Jahre beträgt.

Beispiel

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to DELETE required records
sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (20)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

Transaktionen durchführen

Transaktionen sind ein Mechanismus, der die Datenkonsistenz gewährleistet. Transaktionen haben die folgenden vier Eigenschaften:

• Atomicity - Entweder wird eine Transaktion abgeschlossen oder es passiert überhaupt nichts.

• Consistency - Eine Transaktion muss in einem konsistenten Zustand beginnen und das System in einem konsistenten Zustand belassen.

• Isolation - Zwischenergebnisse einer Transaktion sind außerhalb der aktuellen Transaktion nicht sichtbar.

• Durability - Sobald eine Transaktion festgeschrieben wurde, bleiben die Auswirkungen auch nach einem Systemausfall bestehen.

Die Python DB API 2.0 bietet zwei Methoden zum Festschreiben oder Zurücksetzen einer Transaktion.

Beispiel

Sie wissen bereits, wie Sie Transaktionen implementieren. Hier ist wieder ein ähnliches Beispiel -

# Prepare SQL query to DELETE required records
sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (20)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

COMMIT-Betrieb

Commit ist die Operation, die der Datenbank ein grünes Signal gibt, um die Änderungen abzuschließen. Nach dieser Operation kann keine Änderung zurückgesetzt werden.

Hier ist ein einfaches Beispiel zum Aufrufen commit Methode.

db.commit()

ROLLBACK-Betrieb

Wenn Sie mit einer oder mehreren Änderungen nicht zufrieden sind und diese Änderungen vollständig zurücksetzen möchten, verwenden Sie rollback() Methode.

Hier ist ein einfaches Beispiel zum Aufrufen rollback() Methode.

db.rollback()

Datenbank trennen

Verwenden Sie die Methode close (), um die Datenbankverbindung zu trennen.

db.close()

Wenn die Verbindung zu einer Datenbank vom Benutzer mit der Methode close () geschlossen wird, werden alle ausstehenden Transaktionen von der Datenbank zurückgesetzt. Anstatt jedoch von den Implementierungsdetails der DB-Ebene abhängig zu sein, ist es besser, wenn Ihre Anwendung Commit oder Rollback explizit aufruft.

Fehler behandeln

Es gibt viele Fehlerquellen. Einige Beispiele sind ein Syntaxfehler in einer ausgeführten SQL-Anweisung, ein Verbindungsfehler oder das Aufrufen der Abrufmethode für ein bereits abgebrochenes oder abgeschlossenes Anweisungshandle.

Die DB-API definiert eine Reihe von Fehlern, die in jedem Datenbankmodul vorhanden sein müssen. In der folgenden Tabelle sind diese Ausnahmen aufgeführt.

Sr.Nr.	Ausnahme & Beschreibung
1	Warning Wird für nicht schwerwiegende Probleme verwendet. Muss StandardError unterordnen.
2	Error Basisklasse für Fehler. Muss StandardError unterordnen.
3	InterfaceError Wird für Fehler im Datenbankmodul verwendet, nicht in der Datenbank selbst. Muss Fehler der Unterklasse.
4	DatabaseError Wird für Fehler in der Datenbank verwendet. Muss Fehler der Unterklasse.
5	DataError Unterklasse von DatabaseError, die auf Fehler in den Daten verweist.
6	OperationalError Unterklasse von DatabaseError, die auf Fehler wie den Verlust einer Verbindung zur Datenbank verweist. Diese Fehler liegen im Allgemeinen außerhalb der Kontrolle des Python-Scripters.
7	IntegrityError Unterklasse von DatabaseError für Situationen, die die relationale Integrität beeinträchtigen würden, z. B. Eindeutigkeitsbeschränkungen oder Fremdschlüssel.
8	InternalError Unterklasse von DatabaseError, die sich auf Fehler innerhalb des Datenbankmoduls bezieht, z. B. einen Cursor, der nicht mehr aktiv ist.
9	ProgrammingError Unterklasse von DatabaseError, die sich auf Fehler wie einen falschen Tabellennamen und andere Dinge bezieht, die Ihnen sicher angelastet werden können.
10	NotSupportedError Unterklasse von DatabaseError, die sich auf den Versuch bezieht, nicht unterstützte Funktionen aufzurufen.

Ihre Python-Skripte sollten diese Fehler behandeln. Bevor Sie jedoch eine der oben genannten Ausnahmen verwenden, stellen Sie sicher, dass Ihre MySQLdb diese Ausnahme unterstützt. Weitere Informationen dazu erhalten Sie in der DB API 2.0-Spezifikation.

Python bietet zwei Zugriffsebenen auf Netzwerkdienste. Auf niedriger Ebene können Sie auf die grundlegende Socket-Unterstützung des zugrunde liegenden Betriebssystems zugreifen, mit der Sie Clients und Server sowohl für verbindungsorientierte als auch für verbindungslose Protokolle implementieren können.

Python verfügt auch über Bibliotheken, die übergeordneten Zugriff auf bestimmte Netzwerkprotokolle auf Anwendungsebene wie FTP, HTTP usw. bieten.

In diesem Kapitel erfahren Sie mehr über das bekannteste Konzept in Networking - Socket Programming.

Was sind Steckdosen?

Sockets sind die Endpunkte eines bidirektionalen Kommunikationskanals. Sockets können innerhalb eines Prozesses, zwischen Prozessen auf demselben Computer oder zwischen Prozessen auf verschiedenen Kontinenten kommunizieren.

Sockets können über verschiedene Kanaltypen implementiert werden: Unix-Domain-Sockets, TCP, UDP usw. Die Socket- Bibliothek bietet spezifische Klassen für die Abwicklung der allgemeinen Transporte sowie eine generische Schnittstelle für die Abwicklung des Restes.

Steckdosen haben ihren eigenen Wortschatz -

Sr.Nr.	Begriff & Beschreibung
1	Domain Die Protokollfamilie, die als Transportmechanismus verwendet wird. Diese Werte sind Konstanten wie AF_INET, PF_INET, PF_UNIX, PF_X25 usw.
2	type Die Art der Kommunikation zwischen den beiden Endpunkten, normalerweise SOCK_STREAM für verbindungsorientierte Protokolle und SOCK_DGRAM für verbindungslose Protokolle.
3	protocol Typischerweise Null, kann dies verwendet werden, um eine Variante eines Protokolls innerhalb einer Domäne und eines Typs zu identifizieren.
4	hostname Die Kennung einer Netzwerkschnittstelle - Eine Zeichenfolge, die ein Hostname, eine gepunktete Quad-Adresse oder eine IPV6-Adresse in Doppelpunkt- (und möglicherweise Punkt-) Schreibweise sein kann Eine Zeichenfolge "<broadcast>", die eine INADDR_BROADCAST-Adresse angibt. Eine Zeichenfolge mit der Länge Null, die INADDR_ANY oder angibt Eine Ganzzahl, die als Binäradresse in der Reihenfolge der Hostbytes interpretiert wird.
5	port Jeder Server wartet auf Clients, die einen oder mehrere Ports anrufen. Ein Port kann eine Fixnum-Portnummer, eine Zeichenfolge mit einer Portnummer oder der Name eines Dienstes sein.

Das Socket - Modul

Um einen Socket zu erstellen, müssen Sie die Funktion socket.socket () verwenden, die im Socket- Modul verfügbar ist und die allgemeine Syntax hat:

s = socket.socket (socket_family, socket_type, protocol=0)

Hier ist die Beschreibung der Parameter -

• socket_family - Dies ist entweder AF_UNIX oder AF_INET, wie zuvor erläutert.

• socket_type - Dies ist entweder SOCK_STREAM oder SOCK_DGRAM.

• protocol - Dies wird normalerweise weggelassen und ist standardmäßig 0.

Sobald Sie ein Socket- Objekt haben, können Sie die erforderlichen Funktionen verwenden, um Ihr Client- oder Serverprogramm zu erstellen. Es folgt die Liste der erforderlichen Funktionen -

Server-Socket-Methoden

Sr.Nr.	Methode & Beschreibung
1	s.bind() Diese Methode bindet die Adresse (Hostname, Portnummernpaar) an den Socket.
2	s.listen() Diese Methode richtet den TCP-Listener ein und startet ihn.
3	s.accept() Diese akzeptieren passiv die TCP-Client-Verbindung und warten, bis die Verbindung eintrifft (Blockierung).

Client-Socket-Methoden

Sr.Nr.	Methode & Beschreibung
1	s.connect() Diese Methode initiiert aktiv die TCP-Serververbindung.

Allgemeine Socket-Methoden

Sr.Nr.	Methode & Beschreibung
1	s.recv() Diese Methode empfängt eine TCP-Nachricht
2	s.send() Diese Methode überträgt eine TCP-Nachricht
3	s.recvfrom() Diese Methode empfängt eine UDP-Nachricht
4	s.sendto() Diese Methode überträgt UDP-Nachrichten
5	s.close() Diese Methode schließt den Socket
6	socket.gethostname() Gibt den Hostnamen zurück.

Ein einfacher Server

Zum Schreiben von Internet-Servern verwenden wir die socketFunktion im Socket-Modul verfügbar, um ein Socket-Objekt zu erstellen. Ein Socket-Objekt wird dann verwendet, um andere Funktionen zum Einrichten eines Socket-Servers aufzurufen.

Ruf jetzt an bind(hostname, port)Funktion zum Angeben eines Ports für Ihren Dienst auf dem angegebenen Host.

Rufen Sie als Nächstes die accept- Methode des zurückgegebenen Objekts auf. Diese Methode wartet, bis ein Client eine Verbindung zu dem von Ihnen angegebenen Port herstellt, und gibt dann ein Verbindungsobjekt zurück , das die Verbindung zu diesem Client darstellt.

#!/usr/bin/python           # This is server.py file

import socket               # Import socket module

s = socket.socket()         # Create a socket object
host = socket.gethostname() # Get local machine name
port = 12345                # Reserve a port for your service.
s.bind((host, port))        # Bind to the port

s.listen(5)                 # Now wait for client connection.
while True:
   c, addr = s.accept()     # Establish connection with client.
   print 'Got connection from', addr
   c.send('Thank you for connecting')
   c.close()                # Close the connection

Ein einfacher Client

Schreiben wir ein sehr einfaches Client-Programm, das eine Verbindung zu einem bestimmten Port 12345 und einem bestimmten Host herstellt. Dies ist sehr einfach, um einen Socket-Client mit der Socket- Modul-Funktion von Python zu erstellen .

Das socket.connect(hosname, port )Öffnet eine TCP-Verbindung zum Hostnamen am Port . Sobald Sie einen Socket geöffnet haben, können Sie wie jedes E / A-Objekt daraus lesen. Wenn Sie fertig sind, denken Sie daran, es zu schließen, als würden Sie eine Datei schließen.

Der folgende Code ist ein sehr einfacher Client, der eine Verbindung zu einem bestimmten Host und Port herstellt, alle verfügbaren Daten vom Socket liest und dann beendet -

#!/usr/bin/python           # This is client.py file

import socket               # Import socket module

s = socket.socket()         # Create a socket object
host = socket.gethostname() # Get local machine name
port = 12345                # Reserve a port for your service.

s.connect((host, port))
print s.recv(1024)
s.close()                  # Close the socket when done

Führen Sie nun diese server.py im Hintergrund und dann über client.py aus, um das Ergebnis anzuzeigen.

# Following would start a server in background.
$ python server.py & # Once server is started run client as follows: $ python client.py

Dies würde folgendes Ergebnis liefern -

Got connection from ('127.0.0.1', 48437)
Thank you for connecting

Python-Internetmodule

Eine Liste einiger wichtiger Module in der Python-Netzwerk- / Internetprogrammierung.

Protokoll	Gemeinsame Funktion	Port Nr	Python-Modul
HTTP	Webseiten	80	httplib, urllib, xmlrpclib
NNTP	Usenet-Nachrichten	119	nntplib
FTP	Dateiübertragungen	20	ftplib, urllib
SMTP	Email schicken	25	smtplib
POP3	E-Mail abrufen	110	Poplib
IMAP4	E-Mail abrufen	143	imaplib
Telnet	Befehlszeilen	23	Telnetlib
Gopher	Dokumentübertragungen	70	Gopherlib, Urllib

Bitte überprüfen Sie alle oben genannten Bibliotheken, um mit den Protokollen FTP, SMTP, POP und IMAP zu arbeiten.

Weitere Lesungen

Dies war ein schneller Einstieg in die Socket-Programmierung. Es ist ein großes Thema. Es wird empfohlen, über den folgenden Link weitere Details zu erfahren:

• Unix-Socket-Programmierung .

• Python Socket Library und Module .

Das Simple Mail Transfer Protocol (SMTP) ist ein Protokoll, das das Senden von E-Mails und das Weiterleiten von E-Mails zwischen Mailservern übernimmt.

Python bietet smtplib Modul, das ein SMTP-Client-Sitzungsobjekt definiert, mit dem E-Mails mit einem SMTP- oder ESMTP-Listener-Daemon an jeden Internetcomputer gesendet werden können.

Hier ist eine einfache Syntax zum Erstellen eines SMTP-Objekts, mit dem später eine E-Mail gesendet werden kann:

import smtplib

smtpObj = smtplib.SMTP( [host [, port [, local_hostname]]] )

Hier ist das Detail der Parameter -

• host- Dies ist der Host, auf dem Ihr SMTP-Server ausgeführt wird. Sie können die IP-Adresse des Hosts oder einen Domainnamen wie tutorialspoint.com angeben. Dies ist ein optionales Argument.

• port- Wenn Sie ein Host- Argument angeben, müssen Sie einen Port angeben, an dem der SMTP-Server empfangsbereit ist. Normalerweise ist dieser Port 25.

• local_hostname- Wenn Ihr SMTP-Server auf Ihrem lokalen Computer ausgeführt wird, können Sie ab dieser Option nur localhost angeben .

Ein SMTP-Objekt hat eine Instanzmethode namens sendmail, die normalerweise zum Versenden einer Nachricht verwendet wird. Es werden drei Parameter benötigt -

• Der Absender - Eine Zeichenfolge mit der Adresse des Absenders.

• Die Empfänger - Eine Liste von Zeichenfolgen, eine für jeden Empfänger.

• Die Nachricht - Eine Nachricht als Zeichenfolge, die wie in den verschiedenen RFCs angegeben formatiert ist.

Beispiel

Hier ist eine einfache Möglichkeit, eine E-Mail mit dem Python-Skript zu senden. Probieren Sie es einmal aus -

#!/usr/bin/python

import smtplib

sender = '[email protected]'
receivers = ['[email protected]']

message = """From: From Person <[email protected]>
To: To Person <[email protected]>
Subject: SMTP e-mail test

This is a test e-mail message.
"""

try:
   smtpObj = smtplib.SMTP('localhost')
   smtpObj.sendmail(sender, receivers, message)         
   print "Successfully sent email"
except SMTPException:
   print "Error: unable to send email"

Hier haben Sie eine einfache E-Mail mit einem dreifachen Anführungszeichen in die Nachricht eingefügt und dabei darauf geachtet, die Überschriften korrekt zu formatieren. Eine E-Mail erfordert aFrom, To, und Subject Kopfzeile, durch eine Leerzeile vom Text der E-Mail getrennt.

Zum Senden der E-Mail verwenden Sie smtpObj , um eine Verbindung zum SMTP-Server auf dem lokalen Computer herzustellen , und verwenden dann die sendmail- Methode zusammen mit der Nachricht, der Absenderadresse und der Zieladresse als Parameter (obwohl sich die Absender- und Absenderadressen innerhalb des e befinden -mail selbst, diese werden nicht immer zum Weiterleiten von E-Mails verwendet).

Wenn Sie auf Ihrem lokalen Computer keinen SMTP-Server ausführen , können Sie mit dem smtplib- Client mit einem Remote-SMTP-Server kommunizieren. Sofern Sie keinen Webmail-Dienst (wie Hotmail oder Yahoo! Mail) verwenden, muss Ihr E-Mail-Anbieter Ihnen die Details des Postausgangsservers zur Verfügung gestellt haben, die Sie wie folgt bereitstellen können:

smtplib.SMTP('mail.your-domain.com', 25)

Senden einer HTML-E-Mail mit Python

Wenn Sie eine Textnachricht mit Python senden, wird der gesamte Inhalt als einfacher Text behandelt. Selbst wenn Sie HTML-Tags in eine Textnachricht aufnehmen, wird diese als einfacher Text angezeigt und HTML-Tags werden nicht gemäß der HTML-Syntax formatiert. Python bietet jedoch die Möglichkeit, eine HTML-Nachricht als tatsächliche HTML-Nachricht zu senden.

Beim Senden einer E-Mail-Nachricht können Sie eine Mime-Version, einen Inhaltstyp und einen Zeichensatz angeben, um eine HTML-E-Mail zu senden.

Beispiel

Es folgt das Beispiel zum Senden von HTML-Inhalten als E-Mail. Probieren Sie es einmal aus -

#!/usr/bin/python

import smtplib

message = """From: From Person <[email protected]>
To: To Person <[email protected]>
MIME-Version: 1.0
Content-type: text/html
Subject: SMTP HTML e-mail test

This is an e-mail message to be sent in HTML format

<b>This is HTML message.</b>
<h1>This is headline.</h1>
"""

try:
   smtpObj = smtplib.SMTP('localhost')
   smtpObj.sendmail(sender, receivers, message)         
   print "Successfully sent email"
except SMTPException:
   print "Error: unable to send email"

Anhänge als E-Mail senden

Um eine E-Mail mit gemischtem Inhalt zu senden, muss festgelegt werden Content-type Header zu multipart/mixed. Anschließend können Text- und Anhangsabschnitte innerhalb von angegeben werdenboundaries.

Eine Grenze wird mit zwei Bindestrichen gefolgt von einer eindeutigen Nummer gestartet, die nicht im Nachrichtenteil der E-Mail erscheinen kann. Eine letzte Grenze, die den letzten Abschnitt der E-Mail angibt, muss ebenfalls mit zwei Bindestrichen enden.

Angehängte Dateien sollten mit dem verschlüsselt werden pack("m") Funktion, um vor der Übertragung eine Base64-Codierung zu haben.

Beispiel

Das folgende Beispiel sendet eine Datei /tmp/test.txtals Anhang. Probieren Sie es einmal aus -

#!/usr/bin/python

import smtplib
import base64

filename = "/tmp/test.txt"

# Read a file and encode it into base64 format
fo = open(filename, "rb")
filecontent = fo.read()
encodedcontent = base64.b64encode(filecontent)  # base64

sender = '[email protected]'
reciever = '[email protected]'

marker = "AUNIQUEMARKER"

body ="""
This is a test email to send an attachement.
"""
# Define the main headers.
part1 = """From: From Person <[email protected]>
To: To Person <[email protected]>
Subject: Sending Attachement
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary=%s
--%s
""" % (marker, marker)

# Define the message action
part2 = """Content-Type: text/plain
Content-Transfer-Encoding:8bit

%s
--%s
""" % (body,marker)

# Define the attachment section
part3 = """Content-Type: multipart/mixed; name=\"%s\"
Content-Transfer-Encoding:base64
Content-Disposition: attachment; filename=%s

%s
--%s--
""" %(filename, filename, encodedcontent, marker)
message = part1 + part2 + part3

try:
   smtpObj = smtplib.SMTP('localhost')
   smtpObj.sendmail(sender, reciever, message)
   print "Successfully sent email"
except Exception:
   print "Error: unable to send email"

Das Ausführen mehrerer Threads ähnelt dem gleichzeitigen Ausführen mehrerer verschiedener Programme, bietet jedoch die folgenden Vorteile:

• Mehrere Threads innerhalb eines Prozesses teilen sich den gleichen Datenraum mit dem Hauptthread und können daher einfacher Informationen austauschen oder miteinander kommunizieren, als wenn es sich um separate Prozesse handeln würde.

• Threads werden manchmal als leichte Prozesse bezeichnet und erfordern nicht viel Speicheraufwand. Sie sind billiger als Prozesse.

Ein Thread hat einen Anfang, eine Ausführungssequenz und eine Schlussfolgerung. Es verfügt über einen Anweisungszeiger, der verfolgt, wo in seinem Kontext es gerade ausgeführt wird.

• Es kann vorbelegt (unterbrochen) werden

• Es kann vorübergehend angehalten werden (auch als Ruhezustand bezeichnet), während andere Threads ausgeführt werden - dies wird als Nachgeben bezeichnet.

Einen neuen Thread starten

Um einen anderen Thread zu erzeugen, müssen Sie die folgende im Thread- Modul verfügbare Methode aufrufen :

thread.start_new_thread ( function, args[, kwargs] )

Dieser Methodenaufruf ermöglicht eine schnelle und effiziente Möglichkeit, neue Threads unter Linux und Windows zu erstellen.

Der Methodenaufruf wird sofort zurückgegeben und der untergeordnete Thread startet und ruft die Funktion mit der übergebenen Liste von Argumenten auf . Wenn die Funktion zurückkehrt, wird der Thread beendet.

Hier ist args ein Tupel von Argumenten; Verwenden Sie ein leeres Tupel, um die Funktion aufzurufen, ohne Argumente zu übergeben. kwargs ist ein optionales Wörterbuch mit Schlüsselwortargumenten.

Beispiel

#!/usr/bin/python

import thread
import time

# Define a function for the thread
def print_time( threadName, delay):
   count = 0
   while count < 5:
      time.sleep(delay)
      count += 1
      print "%s: %s" % ( threadName, time.ctime(time.time()) )

# Create two threads as follows
try:
   thread.start_new_thread( print_time, ("Thread-1", 2, ) )
   thread.start_new_thread( print_time, ("Thread-2", 4, ) )
except:
   print "Error: unable to start thread"

while 1:
   pass

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Thread-1: Thu Jan 22 15:42:17 2009
Thread-1: Thu Jan 22 15:42:19 2009
Thread-2: Thu Jan 22 15:42:19 2009
Thread-1: Thu Jan 22 15:42:21 2009
Thread-2: Thu Jan 22 15:42:23 2009
Thread-1: Thu Jan 22 15:42:23 2009
Thread-1: Thu Jan 22 15:42:25 2009
Thread-2: Thu Jan 22 15:42:27 2009
Thread-2: Thu Jan 22 15:42:31 2009
Thread-2: Thu Jan 22 15:42:35 2009

Es ist zwar sehr effektiv für Low-Level-Threading, aber das Thread- Modul ist im Vergleich zum neueren Threading-Modul sehr begrenzt.

Das Threading- Modul

Das neuere Threading-Modul in Python 2.4 bietet eine viel leistungsfähigere Unterstützung auf hoher Ebene für Threads als das im vorherigen Abschnitt beschriebene Thread-Modul.

Das Einfädeln Modul aussetzt alle Methoden des Fadenmoduls und bietet einige zusätzliche Methoden -

• threading.activeCount() - Gibt die Anzahl der aktiven Thread-Objekte zurück.

• threading.currentThread() - Gibt die Anzahl der Thread-Objekte im Thread-Steuerelement des Aufrufers zurück.

• threading.enumerate() - Gibt eine Liste aller aktuell aktiven Thread-Objekte zurück.

Zusätzlich zu den Methoden verfügt das Threading-Modul über die Thread- Klasse, die das Threading implementiert. Die von der Thread- Klasse bereitgestellten Methoden lauten wie folgt:

• run() - Die run () -Methode ist der Einstiegspunkt für einen Thread.

• start() - Die Methode start () startet einen Thread durch Aufrufen der Methode run.

• join([time]) - Join () wartet auf das Beenden von Threads.

• isAlive() - Die Methode isAlive () prüft, ob noch ein Thread ausgeführt wird.

• getName() - Die Methode getName () gibt den Namen eines Threads zurück.

• setName() - Die Methode setName () legt den Namen eines Threads fest.

Thread mit Threading- Modul erstellen

Um einen neuen Thread mit dem Threading-Modul zu implementieren, müssen Sie Folgendes tun:

• Definieren Sie eine neue Unterklasse der Thread- Klasse.

• Überschreiben der __init __ (self [, args]) Verfahren zusätzliche Argumente hinzuzufügen.

• Überschreiben Sie dann die Methode run (self [, args]), um zu implementieren, was der Thread beim Starten tun soll.

Nachdem Sie die neue Thread- Unterklasse erstellt haben, können Sie eine Instanz davon erstellen und dann einen neuen Thread starten , indem Sie start () aufrufen , das wiederum die Methode run () aufruft .

Beispiel

#!/usr/bin/python

import threading
import time

exitFlag = 0

class myThread (threading.Thread):
   def __init__(self, threadID, name, counter):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.counter = counter
   def run(self):
      print "Starting " + self.name
      print_time(self.name, self.counter, 5)
      print "Exiting " + self.name

def print_time(threadName, counter, delay):
   while counter:
      if exitFlag:
         threadName.exit()
      time.sleep(delay)
      print "%s: %s" % (threadName, time.ctime(time.time()))
      counter -= 1

# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# Start new Threads
thread1.start()
thread2.start()

print "Exiting Main Thread"

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Starting Thread-1
Starting Thread-2
Exiting Main Thread
Thread-1: Thu Mar 21 09:10:03 2013
Thread-1: Thu Mar 21 09:10:04 2013
Thread-2: Thu Mar 21 09:10:04 2013
Thread-1: Thu Mar 21 09:10:05 2013
Thread-1: Thu Mar 21 09:10:06 2013
Thread-2: Thu Mar 21 09:10:06 2013
Thread-1: Thu Mar 21 09:10:07 2013
Exiting Thread-1
Thread-2: Thu Mar 21 09:10:08 2013
Thread-2: Thu Mar 21 09:10:10 2013
Thread-2: Thu Mar 21 09:10:12 2013
Exiting Thread-2

Threads synchronisieren

Das mit Python gelieferte Threading-Modul enthält einen einfach zu implementierenden Sperrmechanismus, mit dem Sie Threads synchronisieren können. Eine neue Sperre wird durch Aufrufen der Lock () -Methode erstellt, die die neue Sperre zurückgibt.

Die Erfassungsmethode (Blockierungsmethode) des neuen Sperrobjekts wird verwendet, um zu erzwingen, dass Threads synchron ausgeführt werden. Mit dem optionalen Blockierungsparameter können Sie steuern, ob der Thread darauf wartet, die Sperre zu erhalten.

Wenn das Blockieren auf 0 gesetzt ist, kehrt der Thread sofort mit einem 0-Wert zurück, wenn die Sperre nicht erfasst werden kann, und mit einer 1, wenn die Sperre erworben wurde. Wenn die Blockierung auf 1 gesetzt ist, blockiert der Thread und wartet, bis die Sperre aufgehoben wird.

Die release () -Methode des neuen Sperrobjekts wird verwendet, um die Sperre aufzuheben, wenn sie nicht mehr benötigt wird.

Beispiel

#!/usr/bin/python

import threading
import time

class myThread (threading.Thread):
   def __init__(self, threadID, name, counter):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.counter = counter
   def run(self):
      print "Starting " + self.name
      # Get lock to synchronize threads
      threadLock.acquire()
      print_time(self.name, self.counter, 3)
      # Free lock to release next thread
      threadLock.release()

def print_time(threadName, delay, counter):
   while counter:
      time.sleep(delay)
      print "%s: %s" % (threadName, time.ctime(time.time()))
      counter -= 1

threadLock = threading.Lock()
threads = []

# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# Start new Threads
thread1.start()
thread2.start()

# Add threads to thread list
threads.append(thread1)
threads.append(thread2)

# Wait for all threads to complete
for t in threads:
    t.join()
print "Exiting Main Thread"

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Starting Thread-1
Starting Thread-2
Thread-1: Thu Mar 21 09:11:28 2013
Thread-1: Thu Mar 21 09:11:29 2013
Thread-1: Thu Mar 21 09:11:30 2013
Thread-2: Thu Mar 21 09:11:32 2013
Thread-2: Thu Mar 21 09:11:34 2013
Thread-2: Thu Mar 21 09:11:36 2013
Exiting Main Thread

Multithread-Prioritätswarteschlange

Mit dem Warteschlangenmodul können Sie ein neues Warteschlangenobjekt erstellen, das eine bestimmte Anzahl von Elementen enthalten kann. Es gibt folgende Methoden zur Steuerung der Warteschlange:

• get() - Mit get () wird ein Element aus der Warteschlange entfernt und zurückgegeben.

• put() - Der Put fügt einer Warteschlange ein Element hinzu.

• qsize() - qsize () gibt die Anzahl der Elemente zurück, die sich derzeit in der Warteschlange befinden.

• empty()- Das empty () gibt True zurück, wenn die Warteschlange leer ist. sonst falsch.

• full()- full () gibt True zurück, wenn die Warteschlange voll ist. sonst falsch.

Beispiel

#!/usr/bin/python

import Queue
import threading
import time

exitFlag = 0

class myThread (threading.Thread):
   def __init__(self, threadID, name, q):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.q = q
   def run(self):
      print "Starting " + self.name
      process_data(self.name, self.q)
      print "Exiting " + self.name

def process_data(threadName, q):
   while not exitFlag:
      queueLock.acquire()
         if not workQueue.empty():
            data = q.get()
            queueLock.release()
            print "%s processing %s" % (threadName, data)
         else:
            queueLock.release()
         time.sleep(1)

threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three", "Four", "Five"]
queueLock = threading.Lock()
workQueue = Queue.Queue(10)
threads = []
threadID = 1

# Create new threads
for tName in threadList:
   thread = myThread(threadID, tName, workQueue)
   thread.start()
   threads.append(thread)
   threadID += 1

# Fill the queue
queueLock.acquire()
for word in nameList:
   workQueue.put(word)
queueLock.release()

# Wait for queue to empty
while not workQueue.empty():
   pass

# Notify threads it's time to exit
exitFlag = 1

# Wait for all threads to complete
for t in threads:
   t.join()
print "Exiting Main Thread"

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Starting Thread-1
Starting Thread-2
Starting Thread-3
Thread-1 processing One
Thread-2 processing Two
Thread-3 processing Three
Thread-1 processing Four
Thread-2 processing Five
Exiting Thread-3
Exiting Thread-1
Exiting Thread-2
Exiting Main Thread

XML ist eine tragbare Open-Source-Sprache, mit der Programmierer Anwendungen entwickeln können, die von anderen Anwendungen gelesen werden können, unabhängig vom Betriebssystem und / oder der Entwicklungssprache.

Was ist XML?

Die Extensible Markup Language (XML) ist eine Markup-Sprache, die HTML oder SGML sehr ähnlich ist. Dies wird vom World Wide Web Consortium empfohlen und ist als offener Standard verfügbar.

XML ist äußerst nützlich, um kleine bis mittlere Datenmengen zu verfolgen, ohne ein SQL-basiertes Backbone zu benötigen.

XML-Parser-Architekturen und APIs

Die Python-Standardbibliothek bietet einen minimalen, aber nützlichen Satz von Schnittstellen für die Arbeit mit XML.

Die beiden grundlegendsten und am weitesten verbreiteten APIs für XML-Daten sind die SAX- und DOM-Schnittstellen.

• Simple API for XML (SAX)- Hier registrieren Sie Rückrufe für Ereignisse von Interesse und lassen den Parser das Dokument durchlaufen. Dies ist nützlich, wenn Ihre Dokumente groß sind oder Sie über Speicherbeschränkungen verfügen. Sie analysiert die Datei beim Lesen von der Festplatte und die gesamte Datei wird niemals im Speicher gespeichert.

• Document Object Model (DOM) API - Dies ist eine Empfehlung des World Wide Web Consortium, bei der die gesamte Datei in den Speicher eingelesen und in einer hierarchischen (baumbasierten) Form gespeichert wird, um alle Funktionen eines XML-Dokuments darzustellen.

SAX kann Informationen offensichtlich nicht so schnell verarbeiten wie DOM, wenn mit großen Dateien gearbeitet wird. Auf der anderen Seite kann die ausschließliche Verwendung von DOM Ihre Ressourcen wirklich zerstören, insbesondere wenn es für viele kleine Dateien verwendet wird.

SAX ist schreibgeschützt, während DOM Änderungen an der XML-Datei zulässt. Da sich diese beiden unterschiedlichen APIs buchstäblich ergänzen, gibt es keinen Grund, warum Sie sie nicht beide für große Projekte verwenden können.

Verwenden Sie für alle unsere XML-Codebeispiele eine einfache XML-Datei movies.xml als Eingabe -

<collection shelf="New Arrivals">
<movie title="Enemy Behind">
   <type>War, Thriller</type>
   <format>DVD</format>
   <year>2003</year>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Talk about a US-Japan war</description>
</movie>
<movie title="Transformers">
   <type>Anime, Science Fiction</type>
   <format>DVD</format>
   <year>1989</year>
   <rating>R</rating>
   <stars>8</stars>
   <description>A schientific fiction</description>
</movie>
   <movie title="Trigun">
   <type>Anime, Action</type>
   <format>DVD</format>
   <episodes>4</episodes>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Vash the Stampede!</description>
</movie>
<movie title="Ishtar">
   <type>Comedy</type>
   <format>VHS</format>
   <rating>PG</rating>
   <stars>2</stars>
   <description>Viewable boredom</description>
</movie>
</collection>

XML mit SAX-APIs analysieren

SAX ist eine Standardschnittstelle für ereignisgesteuertes XML-Parsing. Für das Parsen von XML mit SAX müssen Sie im Allgemeinen Ihren eigenen ContentHandler erstellen, indem Sie xml.sax.ContentHandler unterklassifizieren.

Ihr ContentHandler verwaltet die bestimmten Tags und Attribute Ihrer XML- Version (en). Ein ContentHandler-Objekt bietet Methoden zum Behandeln verschiedener Analyseereignisse. Sein besitzender Parser ruft ContentHandler-Methoden auf, während er die XML-Datei analysiert.

Die Methoden startDocument und endDocument werden am Anfang und am Ende der XML-Datei aufgerufen. Die Methodenzeichen (Text) werden über den Parametertext Zeichendaten der XML-Datei übergeben.

Der ContentHandler wird am Anfang und Ende jedes Elements aufgerufen. Befindet sich der Parser nicht im Namespace-Modus, werden die Methoden startElement (Tag, Attribute) und endElement (Tag) aufgerufen. Andernfalls werden die entsprechenden Methoden startElementNS und endElementNS aufgerufen. Hier ist Tag das Element-Tag und Attribute ein Attributes-Objekt.

Hier sind andere wichtige Methoden, die Sie verstehen sollten, bevor Sie fortfahren:

Die make_parser- Methode

Die folgende Methode erstellt ein neues Parserobjekt und gibt es zurück. Das erstellte Parserobjekt ist vom ersten Parsertyp, den das System findet.

xml.sax.make_parser( [parser_list] )

Hier ist das Detail der Parameter -

• parser_list - Das optionale Argument, das aus einer Liste der zu verwendenden Parser besteht, die alle die Methode make_parser implementieren müssen.

Das Parse - Verfahren

Die folgende Methode erstellt einen SAX-Parser und verwendet ihn zum Parsen eines Dokuments.

xml.sax.parse( xmlfile, contenthandler[, errorhandler])

Hier ist das Detail der Parameter -

• xmlfile - Dies ist der Name der XML-Datei, aus der gelesen werden soll.

• contenthandler - Dies muss ein ContentHandler-Objekt sein.

• errorhandler - Wenn angegeben, muss errorhandler ein SAX ErrorHandler-Objekt sein.

Die parseString- Methode

Es gibt noch eine weitere Methode, um einen SAX-Parser zu erstellen und den angegebenen zu analysieren XML string.

xml.sax.parseString(xmlstring, contenthandler[, errorhandler])

Hier ist das Detail der Parameter -

• xmlstring - Dies ist der Name der XML-Zeichenfolge, aus der gelesen werden soll.

• contenthandler - Dies muss ein ContentHandler-Objekt sein.

• errorhandler - Wenn angegeben, muss errorhandler ein SAX ErrorHandler-Objekt sein.

Beispiel

#!/usr/bin/python

import xml.sax

class MovieHandler( xml.sax.ContentHandler ):
   def __init__(self):
      self.CurrentData = ""
      self.type = ""
      self.format = ""
      self.year = ""
      self.rating = ""
      self.stars = ""
      self.description = ""

   # Call when an element starts
   def startElement(self, tag, attributes):
      self.CurrentData = tag
      if tag == "movie":
         print "*****Movie*****"
         title = attributes["title"]
         print "Title:", title

   # Call when an elements ends
   def endElement(self, tag):
      if self.CurrentData == "type":
         print "Type:", self.type
      elif self.CurrentData == "format":
         print "Format:", self.format
      elif self.CurrentData == "year":
         print "Year:", self.year
      elif self.CurrentData == "rating":
         print "Rating:", self.rating
      elif self.CurrentData == "stars":
         print "Stars:", self.stars
      elif self.CurrentData == "description":
         print "Description:", self.description
      self.CurrentData = ""

   # Call when a character is read
   def characters(self, content):
      if self.CurrentData == "type":
         self.type = content
      elif self.CurrentData == "format":
         self.format = content
      elif self.CurrentData == "year":
         self.year = content
      elif self.CurrentData == "rating":
         self.rating = content
      elif self.CurrentData == "stars":
         self.stars = content
      elif self.CurrentData == "description":
         self.description = content
  
if ( __name__ == "__main__"):
   
   # create an XMLReader
   parser = xml.sax.make_parser()
   # turn off namepsaces
   parser.setFeature(xml.sax.handler.feature_namespaces, 0)

   # override the default ContextHandler
   Handler = MovieHandler()
   parser.setContentHandler( Handler )
   
   parser.parse("movies.xml")

Dies würde folgendes Ergebnis liefern -

*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Year: 2003
Rating: PG
Stars: 10
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Year: 1989
Rating: R
Stars: 8
Description: A schientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Stars: 10
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Stars: 2
Description: Viewable boredom

Ausführliche Informationen zur SAX-API-Dokumentation finden Sie in den Standard- Python-SAX-APIs .

Analysieren von XML mit DOM-APIs

Das Document Object Model ("DOM") ist eine sprachübergreifende API des World Wide Web Consortium (W3C) für den Zugriff auf und die Änderung von XML-Dokumenten.

Das DOM ist äußerst nützlich für Anwendungen mit wahlfreiem Zugriff. Mit SAX können Sie jeweils nur ein Bit des Dokuments anzeigen. Wenn Sie sich ein SAX-Element ansehen, haben Sie keinen Zugriff auf ein anderes.

Hier ist der einfachste Weg, um ein XML-Dokument schnell zu laden und ein Minidom-Objekt mit dem Modul xml.dom zu erstellen. Das Minidom-Objekt bietet eine einfache Parser-Methode, mit der schnell ein DOM-Baum aus der XML-Datei erstellt wird.

Die Beispielphrase ruft die Analysefunktion (Datei [, Parser]) des Minidom-Objekts auf, um die von der Datei angegebene XML-Datei in ein DOM-Baumobjekt zu analysieren.

#!/usr/bin/python

from xml.dom.minidom import parse
import xml.dom.minidom

# Open XML document using minidom parser
DOMTree = xml.dom.minidom.parse("movies.xml")
collection = DOMTree.documentElement
if collection.hasAttribute("shelf"):
   print "Root element : %s" % collection.getAttribute("shelf")

# Get all the movies in the collection
movies = collection.getElementsByTagName("movie")

# Print detail of each movie.
for movie in movies:
   print "*****Movie*****"
   if movie.hasAttribute("title"):
      print "Title: %s" % movie.getAttribute("title")

   type = movie.getElementsByTagName('type')[0]
   print "Type: %s" % type.childNodes[0].data
   format = movie.getElementsByTagName('format')[0]
   print "Format: %s" % format.childNodes[0].data
   rating = movie.getElementsByTagName('rating')[0]
   print "Rating: %s" % rating.childNodes[0].data
   description = movie.getElementsByTagName('description')[0]
   print "Description: %s" % description.childNodes[0].data

Dies würde das folgende Ergebnis erzeugen -

Root element : New Arrivals
*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Rating: PG
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Rating: R
Description: A schientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Description: Viewable boredom

Ausführliche Informationen zur DOM-API-Dokumentation finden Sie in den Standard- Python-DOM-APIs .

Python bietet verschiedene Optionen für die Entwicklung grafischer Benutzeroberflächen (GUIs). Die wichtigsten sind unten aufgeführt.

• Tkinter- Tkinter ist die Python-Schnittstelle zum mit Python gelieferten Tk-GUI-Toolkit. Wir würden diese Option in diesem Kapitel betrachten.

• wxPython - Dies ist eine Open-Source-Python-Schnittstelle für wxWindows http://wxpython.org.

• JPython - JPython ist ein Python-Port für Java, über den Python-Skripte nahtlos auf Java-Klassenbibliotheken auf dem lokalen Computer zugreifen können http://www.jython.org.

Es gibt viele andere Schnittstellen, die Sie im Internet finden können.

Tkinter-Programmierung

Tkinter ist die Standard-GUI-Bibliothek für Python. In Kombination mit Tkinter bietet Python eine schnelle und einfache Möglichkeit, GUI-Anwendungen zu erstellen. Tkinter bietet eine leistungsstarke objektorientierte Schnittstelle zum Tk-GUI-Toolkit.

Das Erstellen einer GUI-Anwendung mit Tkinter ist eine einfache Aufgabe. Sie müssen lediglich die folgenden Schritte ausführen:

• Importieren Sie das Tkinter- Modul.

• Erstellen Sie das Hauptfenster der GUI-Anwendung.

• Fügen Sie der GUI-Anwendung eines oder mehrere der oben genannten Widgets hinzu.

• Geben Sie die Hauptereignisschleife ein, um Maßnahmen gegen jedes vom Benutzer ausgelöste Ereignis zu ergreifen.

Beispiel

#!/usr/bin/python

import Tkinter
top = Tkinter.Tk()
# Code to add widgets will go here...
top.mainloop()

Dies würde ein folgendes Fenster erstellen -

Tkinter Widgets

Tkinter bietet verschiedene Steuerelemente wie Schaltflächen, Beschriftungen und Textfelder, die in einer GUI-Anwendung verwendet werden. Diese Steuerelemente werden üblicherweise als Widgets bezeichnet.

Derzeit gibt es in Tkinter 15 Arten von Widgets. Wir präsentieren diese Widgets sowie eine kurze Beschreibung in der folgenden Tabelle -

Sr.Nr.	Betreiber & Beschreibung
1	Taste Das Schaltflächen-Widget wird verwendet, um Schaltflächen in Ihrer Anwendung anzuzeigen.
2	Segeltuch Das Canvas-Widget wird zum Zeichnen von Formen wie Linien, Ovalen, Polygonen und Rechtecken in Ihrer Anwendung verwendet.
3	Checkbutton Das Checkbutton-Widget wird verwendet, um eine Reihe von Optionen als Kontrollkästchen anzuzeigen. Der Benutzer kann mehrere Optionen gleichzeitig auswählen.
4	Eintrag Das Eingabe-Widget wird verwendet, um ein einzeiliges Textfeld zum Akzeptieren von Werten von einem Benutzer anzuzeigen.
5	Rahmen Das Frame-Widget wird als Container-Widget verwendet, um andere Widgets zu organisieren.
6	Etikette Das Label-Widget wird verwendet, um eine einzeilige Beschriftung für andere Widgets bereitzustellen. Es kann auch Bilder enthalten.
7	Listbox Das Listbox-Widget wird verwendet, um einem Benutzer eine Liste mit Optionen bereitzustellen.
8	Menütaste Das Menubutton-Widget wird verwendet, um Menüs in Ihrer Anwendung anzuzeigen.
9	Speisekarte Das Menü-Widget wird verwendet, um einem Benutzer verschiedene Befehle bereitzustellen. Diese Befehle sind in Menubutton enthalten.
10	Botschaft Das Nachrichten-Widget wird verwendet, um mehrzeilige Textfelder zum Akzeptieren von Werten von einem Benutzer anzuzeigen.
11	Radio knopf Das Radiobutton-Widget wird verwendet, um eine Reihe von Optionen als Optionsfelder anzuzeigen. Der Benutzer kann jeweils nur eine Option auswählen.
12	Rahmen Das Skalierungs-Widget wird verwendet, um ein Schieberegler-Widget bereitzustellen.
13	Scrollleiste Das Bildlaufleisten-Widget wird verwendet, um verschiedenen Widgets, z. B. Listenfeldern, Bildlauffunktionen hinzuzufügen.
14	Text Das Text-Widget wird verwendet, um Text in mehreren Zeilen anzuzeigen.
15	Höchststufe Das Toplevel-Widget wird verwendet, um einen separaten Fenstercontainer bereitzustellen.
16	Spinbox Das Spinbox-Widget ist eine Variante des Standard-Tkinter-Eintrags-Widgets, mit dem aus einer festen Anzahl von Werten ausgewählt werden kann.
17	PanedWindow Ein PanedWindow ist ein Container-Widget, das eine beliebige Anzahl von horizontal oder vertikal angeordneten Fenstern enthalten kann.
18	LabelFrame Ein Labelframe ist ein einfaches Container-Widget. Sein Hauptzweck ist es, als Abstandshalter oder Container für komplexe Fensterlayouts zu fungieren.
19	tkMessageBox Dieses Modul wird verwendet, um Meldungsfelder in Ihren Anwendungen anzuzeigen.

Lassen Sie uns diese Widgets im Detail studieren -

Standardattribute

Lassen Sie uns einen Blick darauf werfen, wie einige ihrer gemeinsamen Attribute wie Größen, Farben und Schriftarten angegeben werden.

• Dimensions

• Colors

• Fonts

• Anchors

• Reliefstile

• Bitmaps

• Cursors

Lassen Sie uns sie kurz studieren -

Geometriemanagement

Alle Tkinter-Widgets haben Zugriff auf bestimmte Methoden zur Geometrieverwaltung, mit denen Widgets im gesamten übergeordneten Widget-Bereich organisiert werden. Tkinter macht die folgenden Geometrie-Manager-Klassen verfügbar: Packen, Gitter und Ort.

• Die pack () -Methode - Dieser Geometrie-Manager organisiert Widgets in Blöcken, bevor sie im übergeordneten Widget platziert werden.

• Die Methode grid () - Dieser Geometriemanager organisiert Widgets in einer tabellenartigen Struktur im übergeordneten Widget.

• Die place () -Methode - Dieser Geometrie-Manager organisiert Widgets, indem er sie an einer bestimmten Position im übergeordneten Widget platziert.

Lassen Sie uns die Methoden des Geometriemanagements kurz untersuchen -

Jeder Code, den Sie mit einer kompilierten Sprache wie C, C ++ oder Java schreiben, kann in ein anderes Python-Skript integriert oder importiert werden. Dieser Code wird als "Erweiterung" betrachtet.

Ein Python-Erweiterungsmodul ist nichts anderes als eine normale C-Bibliothek. Auf Unix-Computern enden diese Bibliotheken normalerweise mit.so(für gemeinsam genutztes Objekt). Auf Windows-Computern sehen Sie normalerweise.dll (für dynamisch verknüpfte Bibliothek).

Voraussetzungen für das Schreiben von Erweiterungen

Um mit dem Schreiben Ihrer Erweiterung zu beginnen, benötigen Sie die Python-Header-Dateien.

• Auf Unix-Computern erfordert dies normalerweise die Installation eines entwicklerspezifischen Pakets wie python2.5-dev .

• Windows-Benutzer erhalten diese Header als Teil des Pakets, wenn sie das binäre Python-Installationsprogramm verwenden.

Außerdem wird davon ausgegangen, dass Sie über gute Kenntnisse in C oder C ++ verfügen, um eine Python-Erweiterung mithilfe der C-Programmierung schreiben zu können.

Schauen Sie sich zuerst eine Python-Erweiterung an

Für Ihren ersten Blick auf ein Python-Erweiterungsmodul müssen Sie Ihren Code in vier Teile gruppieren:

• Die Header-Datei Python.h .

• Die C-Funktionen, die Sie als Schnittstelle Ihres Moduls verfügbar machen möchten.

• Eine Tabelle, in der die Namen Ihrer Funktionen als Python-Entwickler den C-Funktionen im Erweiterungsmodul zugeordnet sind.

• Eine Initialisierungsfunktion.

Die Header-Datei Python.h

Sie müssen die Python.h- Headerdatei in Ihre C-Quelldatei aufnehmen, damit Sie auf die interne Python-API zugreifen können, mit der Sie Ihr Modul in den Interpreter einbinden .

Stellen Sie sicher, dass Sie Python.h vor allen anderen Headern einfügen, die Sie möglicherweise benötigen. Sie müssen den Includes mit den Funktionen folgen, die Sie von Python aus aufrufen möchten.

Die C-Funktionen

Die Signaturen der C-Implementierung Ihrer Funktionen haben immer eine der folgenden drei Formen:

static PyObject *MyFunction( PyObject *self, PyObject *args );

static PyObject *MyFunctionWithKeywords(PyObject *self,
                                 PyObject *args,
                                 PyObject *kw);

static PyObject *MyFunctionWithNoArgs( PyObject *self );

Jede der vorhergehenden Deklarationen gibt ein Python-Objekt zurück. In Python gibt es keine void- Funktion wie in C. Wenn Sie nicht möchten, dass Ihre Funktionen einen Wert zurückgeben, geben Sie das C-Äquivalent von Python zurückNoneWert. Die Python-Header definieren ein Makro, Py_RETURN_NONE, das dies für uns erledigt.

Die Namen Ihrer C-Funktionen können beliebig sein, da sie außerhalb des Erweiterungsmoduls nie angezeigt werden. Sie sind als statische Funktion definiert .

Ihre C-Funktionen werden normalerweise benannt, indem Sie das Python-Modul und die Funktionsnamen miteinander kombinieren, wie hier gezeigt -

static PyObject *module_func(PyObject *self, PyObject *args) {
   /* Do your stuff here. */
   Py_RETURN_NONE;
}

Dies ist eine Python-Funktion namens func innerhalb des Modulmoduls . Sie werden Zeiger auf Ihre C-Funktionen in die Methodentabelle für das Modul einfügen, das normalerweise als nächstes in Ihrem Quellcode enthalten ist.

Die Methodenzuordnungstabelle

Diese Methodentabelle ist ein einfaches Array von PyMethodDef-Strukturen. Diese Struktur sieht ungefähr so ​​aus -

struct PyMethodDef {
   char *ml_name;
   PyCFunction ml_meth;
   int ml_flags;
   char *ml_doc;
};

Hier ist die Beschreibung der Mitglieder dieser Struktur -

• ml_name - Dies ist der Name der Funktion, die der Python-Interpreter anzeigt, wenn er in Python-Programmen verwendet wird.

• ml_meth - Dies muss die Adresse einer Funktion sein, die eine der im vorherigen Abschnitt beschriebenen Signaturen hat.

• ml_flags - Dies teilt dem Interpreter mit, welche der drei Signaturen ml_meth verwendet.

  • Dieses Flag hat normalerweise den Wert METH_VARARGS.

  • Dieses Flag kann mit METH_KEYWORDS bitweise ODER verknüpft werden, wenn Sie Schlüsselwortargumente in Ihre Funktion aufnehmen möchten.

  • Dies kann auch den Wert METH_NOARGS haben, der angibt, dass Sie keine Argumente akzeptieren möchten.

• ml_doc - Dies ist die Dokumentzeichenfolge für die Funktion, die NULL sein kann, wenn Sie keine Lust haben, eine zu schreiben.

Diese Tabelle muss mit einem Sentinel abgeschlossen werden, der aus NULL- und 0-Werten für die entsprechenden Mitglieder besteht.

Beispiel

Für die oben definierte Funktion haben wir folgende Methodenzuordnungstabelle:

static PyMethodDef module_methods[] = {
   { "func", (PyCFunction)module_func, METH_NOARGS, NULL },
   { NULL, NULL, 0, NULL }
};

Die Initialisierungsfunktion

Der letzte Teil Ihres Erweiterungsmoduls ist die Initialisierungsfunktion. Diese Funktion wird vom Python-Interpreter beim Laden des Moduls aufgerufen. Es ist erforderlich, dass die Funktion benannt wirdinitModule, wobei Modul der Name des Moduls ist.

Die Initialisierungsfunktion muss aus der Bibliothek exportiert werden, die Sie erstellen möchten. Die Python-Header definieren PyMODINIT_FUNC so, dass sie die entsprechenden Beschwörungsformeln für die jeweilige Umgebung enthalten, in der wir kompilieren. Alles was Sie tun müssen, ist es beim Definieren der Funktion zu verwenden.

Ihre C-Initialisierungsfunktion hat im Allgemeinen die folgende Gesamtstruktur:

PyMODINIT_FUNC initModule() {
   Py_InitModule3(func, module_methods, "docstring...");
}

Hier ist die Beschreibung der Py_InitModule3- Funktion -

• func - Dies ist die zu exportierende Funktion.

• module_methods - Dies ist der oben definierte Name der Zuordnungstabelle.

• docstring - Dies ist der Kommentar, den Sie in Ihrer Erweiterung abgeben möchten.

Alles zusammen sieht folgendermaßen aus:

#include <Python.h>

static PyObject *module_func(PyObject *self, PyObject *args) {
   /* Do your stuff here. */
   Py_RETURN_NONE;
}

static PyMethodDef module_methods[] = {
   { "func", (PyCFunction)module_func, METH_NOARGS, NULL },
   { NULL, NULL, 0, NULL }
};

PyMODINIT_FUNC initModule() {
   Py_InitModule3(func, module_methods, "docstring...");
}

Beispiel

Ein einfaches Beispiel, das alle oben genannten Konzepte verwendet -

#include <Python.h>

static PyObject* helloworld(PyObject* self) {
   return Py_BuildValue("s", "Hello, Python extensions!!");
}

static char helloworld_docs[] =
   "helloworld( ): Any message you want to put here!!\n";

static PyMethodDef helloworld_funcs[] = {
   {"helloworld", (PyCFunction)helloworld, 
      METH_NOARGS, helloworld_docs},
      {NULL}
};

void inithelloworld(void) {
   Py_InitModule3("helloworld", helloworld_funcs,
                  "Extension module example!");
}

Hier wird die Py_BuildValue- Funktion verwendet, um einen Python-Wert zu erstellen. Speichern Sie den obigen Code in der Datei hello.c. Wir würden sehen, wie dieses Modul kompiliert und installiert wird, das aus dem Python-Skript aufgerufen wird.

Erstellen und Installieren von Erweiterungen

Das distutils- Paket macht es sehr einfach, Python-Module, sowohl reine Python- als auch Erweiterungsmodule, auf standardmäßige Weise zu verteilen. Module werden in Quellform verteilt und über ein Setup-Skript namens setup.py wie folgt erstellt und installiert .

Für das obige Modul müssen Sie das folgende Skript setup.py vorbereiten:

from distutils.core import setup, Extension
setup(name='helloworld', version='1.0',  \
      ext_modules=[Extension('helloworld', ['hello.c'])])

Verwenden Sie nun den folgenden Befehl, der alle erforderlichen Kompilierungs- und Verknüpfungsschritte mit den richtigen Compiler- und Linkerbefehlen und -flags ausführt, und kopieren Sie die resultierende dynamische Bibliothek in ein geeignetes Verzeichnis:

$ python setup.py install

Auf Unix-basierten Systemen müssen Sie diesen Befehl höchstwahrscheinlich als root ausführen, um die Berechtigung zum Schreiben in das Site-Packages-Verzeichnis zu haben. Dies ist unter Windows normalerweise kein Problem.

Erweiterungen importieren

Sobald Sie Ihre Erweiterung installiert haben, können Sie diese Erweiterung wie folgt in Ihr Python-Skript importieren und aufrufen:

#!/usr/bin/python
import helloworld

print helloworld.helloworld()

Dies würde das folgende Ergebnis erzeugen -

Hello, Python extensions!!

Funktionsparameter übergeben

Da Sie höchstwahrscheinlich Funktionen definieren möchten, die Argumente akzeptieren, können Sie eine der anderen Signaturen für Ihre C-Funktionen verwenden. Die folgende Funktion, die eine bestimmte Anzahl von Parametern akzeptiert, würde beispielsweise folgendermaßen definiert:

static PyObject *module_func(PyObject *self, PyObject *args) {
   /* Parse args and do something interesting here. */
   Py_RETURN_NONE;
}

Die Methodentabelle mit einem Eintrag für die neue Funktion würde folgendermaßen aussehen:

static PyMethodDef module_methods[] = {
   { "func", (PyCFunction)module_func, METH_NOARGS, NULL },
   { "func", module_func, METH_VARARGS, NULL },
   { NULL, NULL, 0, NULL }
};

Mit der API- Funktion PyArg_ParseTuple können Sie die Argumente aus dem einen PyObject-Zeiger extrahieren, der an Ihre C-Funktion übergeben wurde.

Das erste Argument für PyArg_ParseTuple ist das Argument args. Dies ist das Objekt, das Sie analysieren werden . Das zweite Argument ist eine Formatzeichenfolge, die die Argumente so beschreibt, wie Sie sie erwarten. Jedes Argument wird wie folgt durch ein oder mehrere Zeichen in der Formatzeichenfolge dargestellt.

static PyObject *module_func(PyObject *self, PyObject *args) {
   int i;
   double d;
   char *s;

   if (!PyArg_ParseTuple(args, "ids", &i, &d, &s)) {
      return NULL;
   }
   
   /* Do something interesting here. */
   Py_RETURN_NONE;
}

Wenn Sie die neue Version Ihres Moduls kompilieren und importieren, können Sie die neue Funktion mit einer beliebigen Anzahl von Argumenten eines beliebigen Typs aufrufen.

module.func(1, s="three", d=2.0)
module.func(i=1, d=2.0, s="three")
module.func(s="three", d=2.0, i=1)

Sie können sich wahrscheinlich noch mehr Variationen einfallen lassen.

Die PyArg_ParseTuple- Funktion

Hier ist die Standardsignatur für PyArg_ParseTuple Funktion -

int PyArg_ParseTuple(PyObject* tuple,char* format,...)

Diese Funktion gibt 0 für Fehler und einen Wert ungleich 0 für Erfolg zurück. Tupel ist das PyObject *, das das zweite Argument der C-Funktion war. Hier ist das Format eine C-Zeichenfolge, die obligatorische und optionale Argumente beschreibt.

Hier ist eine Liste der Formatcodes für PyArg_ParseTuple Funktion -

Code	Typ C.	Bedeutung
c	verkohlen	Eine Python-Zeichenfolge der Länge 1 wird zu einem C-Zeichen.
d	doppelt	Ein Python-Float wird zu einem C-Double.
f	schweben	Ein Python-Float wird zu einem C-Float.
ich	int	Ein Python-Int wird zu einem C-Int.
l	lange	Ein Python-Int wird zu einem C-Long.
L.	lang Lang	Ein Python-Int wird zu einem C-Long-Long
Ö	PyObject *	Ruft einen nicht NULL ausgeliehenen Verweis auf das Python-Argument ab.
s	verkohlen*	Python-String ohne eingebettete Nullen in C char *.
s #	char * + int	Beliebige Python-Zeichenfolge mit C-Adresse und Länge.
t #	char * + int	Schreibgeschützter Einzelsegmentpuffer auf C-Adresse und Länge.
u	Py_UNICODE *	Python Unicode ohne eingebettete Nullen für C.
u #	Py_UNICODE * + int	Beliebige Python Unicode C-Adresse und -Länge.
w #	char * + int	Lesen / Schreiben eines Einzelsegmentpuffers auf C-Adresse und Länge.
z	verkohlen*	Akzeptiert wie s auch None (setzt C char * auf NULL).
z #	char * + int	Akzeptiert wie s # auch None (setzt C char * auf NULL).
(...)	gemäß ...	Eine Python-Sequenz wird als ein Argument pro Element behandelt.
|		Die folgenden Argumente sind optional.
::		Formatieren Sie das Ende, gefolgt vom Funktionsnamen für Fehlermeldungen.
;;		Formatieren Sie das Ende, gefolgt vom gesamten Text der Fehlermeldung.

Werte zurückgeben

Py_BuildValue nimmt eine Formatzeichenfolge an, ähnlich wie PyArg_ParseTuple . Anstatt die Adressen der Werte zu übergeben, die Sie erstellen, übergeben Sie die tatsächlichen Werte. Hier ist ein Beispiel, das zeigt, wie eine Add-Funktion implementiert wird:

static PyObject *foo_add(PyObject *self, PyObject *args) {
   int a;
   int b;

   if (!PyArg_ParseTuple(args, "ii", &a, &b)) {
      return NULL;
   }
   return Py_BuildValue("i", a + b);
}

So würde es aussehen, wenn es in Python implementiert würde -

def add(a, b):
   return (a + b)

Sie können zwei Werte von Ihrer Funktion wie folgt zurückgeben. Dies wird mithilfe einer Liste in Python behoben.

static PyObject *foo_add_subtract(PyObject *self, PyObject *args) {
   int a;
   int b;

   if (!PyArg_ParseTuple(args, "ii", &a, &b)) {
      return NULL;
   }
   return Py_BuildValue("ii", a + b, a - b);
}

So würde es aussehen, wenn es in Python implementiert würde -

def add_subtract(a, b):
   return (a + b, a - b)

Die Py_BuildValue- Funktion

Hier ist die Standardsignatur für Py_BuildValue Funktion -

PyObject* Py_BuildValue(char* format,...)

Hier ist das Format eine C-Zeichenfolge, die das zu erstellende Python-Objekt beschreibt. Die folgenden Argumente von Py_BuildValue sind C-Werte, aus denen das Ergebnis erstellt wird. Das PyObject * -Ergebnis ist eine neue Referenz.

In der folgenden Tabelle sind die häufig verwendeten Codezeichenfolgen aufgeführt, von denen null oder mehr im Zeichenfolgenformat verknüpft sind.

Code	Typ C.	Bedeutung
c	verkohlen	AC char wird zu einer Python-Zeichenfolge mit der Länge 1.
d	doppelt	AC Double wird zu einem Python-Float.
f	schweben	AC float wird zu einem Python float.
ich	int	AC int wird zu Python int.
l	lange	AC wird lange zu einem Python-Int.
N.	PyObject *	Übergibt ein Python-Objekt und stiehlt eine Referenz.
Ö	PyObject *	Übergibt ein Python-Objekt und ERHÖHT es wie gewohnt.
Ö&	konvertieren + nichtig *	Willkürliche Umwandlung
s	verkohlen*	C 0-terminiertes Zeichen * für Python-Zeichenfolge oder NULL für Keine.
s #	char * + int	C char * und Länge zu Python-String oder NULL zu None.
u	Py_UNICODE *	C-weite, nullterminierte Zeichenfolge für Python Unicode oder NULL für Keine.
u #	Py_UNICODE * + int	C-weite Zeichenfolge und Länge zu Python Unicode oder NULL zu Keine.
w #	char * + int	Lesen / Schreiben eines Einzelsegmentpuffers auf C-Adresse und Länge.
z	verkohlen*	Akzeptiert wie s auch None (setzt C char * auf NULL).
z #	char * + int	Akzeptiert wie s # auch None (setzt C char * auf NULL).
(...)	gemäß ...	Erstellt ein Python-Tupel aus C-Werten.
[...]	gemäß ...	Erstellt eine Python-Liste aus C-Werten.
{...}	gemäß ...	Erstellt ein Python-Wörterbuch aus C-Werten, alternierenden Schlüsseln und Werten.

Code {...} erstellt Wörterbücher aus einer geraden Anzahl von C-Werten, abwechselnd Schlüsseln und Werten. Zum Beispiel gibt Py_BuildValue ("{issi}", 23, "zig", "zag", 42) ein Wörterbuch wie Pythons {23: 'zig', 'zag': 42} zurück.