Python 3 - Kurzanleitung
Das __future__ Modul
Python 3.x führte einige Python 2-inkompatible Schlüsselwörter und Funktionen ein, die über das integrierte Modul __future__ in Python 2 importiert werden können. Es wird empfohlen, __future__ -Importe zu verwenden, wenn Sie die Python 3.x-Unterstützung für Ihren Code planen.
Wenn Sie beispielsweise das ganzzahlige Teilungsverhalten von Python 3.x in Python 2 möchten, fügen Sie die folgende Importanweisung hinzu.
from __future__ import division
Die Druckfunktion
Die bemerkenswerteste und bekannteste Änderung in Python 3 ist, wie die printFunktion wird verwendet. Die Verwendung von Klammern () mit Druckfunktion ist jetzt obligatorisch. In Python 2 war dies optional.
print "Hello World" #is acceptable in Python 2
print ("Hello World") # in Python 3, print must be followed by ()
Die Funktion print () fügt standardmäßig am Ende eine neue Zeile ein. In Python 2 kann es unterdrückt werden, indem am Ende ',' gesetzt wird. In Python 3 hängt "end = ''" Leerzeichen anstelle von Zeilenumbrüchen an.
print x, # Trailing comma suppresses newline in Python 2
print(x, end=" ") # Appends a space instead of a newline in Python 3
Eingabe von der Tastatur lesen
Python 2 verfügt über zwei Versionen von Eingabefunktionen: input() und raw_input(). Die Funktion input () behandelt die empfangenen Daten als Zeichenfolge, wenn sie in Anführungszeichen '' oder "" enthalten sind, andernfalls werden die Daten als Zahl behandelt.
In Python 3 ist die Funktion raw_input () veraltet. Ferner werden die empfangenen Daten immer als Zeichenfolge behandelt.
In Python 2
>>> x = input('something:')
something:10 #entered data is treated as number
>>> x
10
>>> x = input('something:')
something:'10' #entered data is treated as string
>>> x
'10'
>>> x = raw_input("something:")
something:10 #entered data is treated as string even without ''
>>> x
'10'
>>> x = raw_input("something:")
something:'10' #entered data treated as string including ''
>>> x
"'10'"
In Python 3
>>> x = input("something:")
something:10
>>> x
'10'
>>> x = input("something:")
something:'10' #entered data treated as string with or without ''
>>> x
"'10'"
>>> x = raw_input("something:") # will result NameError
Traceback (most recent call last):
File "<pyshell#3>", line 1, in
<module>
x = raw_input("something:")
NameError: name 'raw_input' is not defined
Integer Division
In Python 2 wird das Ergebnis der Division zweier Ganzzahlen auf die nächste Ganzzahl gerundet. Infolgedessen zeigt 3/2 1. Um eine Gleitkommadivision zu erhalten, muss der Zähler oder Nenner explizit als Gleitkomma verwendet werden. Daher ergibt entweder 3.0 / 2 oder 3 / 2.0 oder 3.0 / 2.0 1.5
Python 3 wertet 3/2 standardmäßig mit 1,5 aus, was für neue Programmierer intuitiver ist.
Unicode-Darstellung
In Python 2 müssen Sie einen String mit au markieren, wenn Sie ihn als Unicode speichern möchten.
Python 3 speichert Zeichenfolgen standardmäßig als Unicode. Wir haben Unicode-Zeichenfolgen (utf-8) und 2-Byte-Klassen: Byte- und Byte-Arrays.
xrange () Funktion entfernt
In Python 2 gibt range () eine Liste zurück, und xrange () gibt ein Objekt zurück, das die Elemente im Bereich nur bei Bedarf generiert, wodurch Speicherplatz gespart wird.
In Python 3 wird die Funktion range () entfernt und xrange () wurde in range () umbenannt. Darüber hinaus unterstützt das range () -Objekt das Slicing in Python 3.2 und höher.
Ausnahme auslösen
Python 2 akzeptiert beide Notationen, die 'alte' und die 'neue' Syntax. Python 3 löst einen SyntaxError aus, wenn wir das Ausnahmeargument nicht in Klammern setzen.
raise IOError, "file error" #This is accepted in Python 2
raise IOError("file error") #This is also accepted in Python 2
raise IOError, "file error" #syntax error is raised in Python 3
raise IOError("file error") #this is the recommended syntax in Python 3
Argumente in Ausnahmen
In Python 3 sollten Argumente für eine Ausnahme mit dem Schlüsselwort 'as' deklariert werden.
except Myerror, err: # In Python2
except Myerror as err: #In Python 3
next () Funktion und .next () Methode
In Python 2 ist next () als Methode des Generatorobjekts zulässig. In Python 2 wird auch die Funktion next () zum Iterieren über das Generatorobjekt akzeptiert. In Python 3 wird jedoch next (0 als Generatormethode eingestellt und AttributeError ausgelöst.
gen = (letter for letter in 'Hello World') # creates generator object
next(my_generator) #allowed in Python 2 and Python 3
my_generator.next() #allowed in Python 2. raises AttributeError in Python 3
2to3 Dienstprogramm
Zusammen mit dem Python 3-Interpreter wird das Skript 2to3.py normalerweise im Ordner tools / scripts installiert. Es liest Python 2.x-Quellcode und wendet eine Reihe von Fixern an, um ihn in einen gültigen Python 3.x-Code umzuwandeln.
Here is a sample Python 2 code (area.py):
def area(x,y = 3.14):
a = y*x*x
print a
return a
a = area(10)
print "area",a
To convert into Python 3 version:
$2to3 -w area.py
Converted code :
def area(x,y = 3.14): # formal parameters
a = y*x*x
print (a)
return a
a = area(10)
print("area",a)
Python ist eine interpretierte, interaktive und objektorientierte Skriptsprache auf hoher Ebene. Python ist so konzipiert, dass es gut lesbar ist. Es werden häufig englische Schlüsselwörter verwendet, während in den anderen Sprachen Satzzeichen verwendet werden. 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 1.0 wurde im November 1994 veröffentlicht. Im Jahr 2000 wurde Python 2.0 veröffentlicht. Python 2.7.11 ist die neueste Ausgabe von Python 2.
In der Zwischenzeit wurde Python 3.0 im Jahr 2008 veröffentlicht. Python 3 ist nicht abwärtskompatibel mit Python 2. Der Schwerpunkt in Python 3 lag auf der Entfernung doppelter Programmierkonstrukte und -module, sodass "es eines geben sollte - und vorzugsweise nur eines -. offensichtlicher Weg, es zu tun. " Python 3.5.1 ist die neueste Version von Python 3.
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. Dies ermöglicht es einem Schüler, die Sprache schnell zu 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 verfügt Python über eine große Liste guter Funktionen. A, 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 3 ist für Windows, Mac OS und die meisten Varianten des Linux-Betriebssystems verfügbar. Obwohl Python 2 für viele andere Betriebssysteme verfügbar ist, wurde die Python 3-Unterstützung entweder nicht für sie verfügbar gemacht oder eingestellt.
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.
Python bekommen
Windows-Plattform
Auf dieser Download-Seite finden Sie Binärdateien der neuesten Version von Python 3 (Python 3.5.1)
Die folgenden verschiedenen Installationsoptionen stehen zur Verfügung.
- Windows x86-64 einbettbare Zip-Datei
- Ausführbares Windows x86-64-Installationsprogramm
- Webbasiertes Windows x86-64-Installationsprogramm
- Windows x86 einbettbare Zip-Datei
- Ausführbares Windows x86-Installationsprogramm
- Webbasiertes Windows x86-Installationsprogramm
Note- Für die Installation von Python 3.5.1 sind Windows 7 mit SP1 Mindestanforderungen an das Betriebssystem. Für die Versionen 3.0 bis 3.4.x ist Windows XP akzeptabel.
Linux-Plattform
Verschiedene Linux-Varianten verwenden unterschiedliche Paketmanager für die Installation neuer Pakete.
Unter Ubuntu Linux wird Python 3 mit dem folgenden Befehl vom Terminal installiert.
$sudo apt-get install python3-minimal
Installation von der Quelle
Laden Sie Gzipped Source Tarball von Pythons Download-URL herunter - https://www.python.org/ftp/python/3.5.1/Python-3.5.1.tgz
Extract the tarball
tar xvfz Python-3.5.1.tgz
Configure and Install:
cd Python-3.5.1
./configure --prefix = /opt/python3.5.1
make
sudo make install
Mac OS
Laden Sie Mac OS-Installationsprogramme von dieser URL herunter - https://www.python.org/downloads/mac-osx/
- 64-Bit / 32-Bit-Installationsprogramm für Mac OS X - python-3.5.1-macosx10.6.pkg
- 32-Bit-i386 / PPC-Installationsprogramm für Mac OS X - python-3.5.1-macosx10.5.pkg
Doppelklicken Sie auf diese Paketdatei und befolgen Sie die Anweisungen des Assistenten zur Installation.
Der aktuellste und aktuellste Quellcode, Binärdateien, Dokumentationen, Nachrichten usw. sind auf der offiziellen Website von Python verfügbar -
Python Official Website - - https://www.python.org/
Sie können die Python-Dokumentation von der folgenden Site herunterladen. Die Dokumentation ist in den Formaten HTML, PDF und PostScript verfügbar.
Python Documentation Website- www.python.org/doc/
PATH einrichten
Programme und andere ausführbare Dateien können sich in vielen Verzeichnissen befinden. Daher bieten die Betriebssysteme einen Suchpfad, in dem die Verzeichnisse aufgelistet sind, in denen nach ausführbaren Dateien gesucht wird.
Die wichtigen Merkmale sind -
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.
Die Pfadvariable heißt PATH unter Unix oder Path in Windows (Unix unterscheidet zwischen Groß- und Kleinschreibung; 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 / python3" ein und drücken Sie die Eingabetaste.
In the bash shell (Linux) - Geben Sie export PYTHONPATH = / usr / local / bin / python3.4 ein und drücken Sie die Eingabetaste.
In the sh or ksh shell - Geben Sie PATH = "$ PATH: / usr / local / bin / python3" ein und drücken Sie die Eingabetaste.
Note - / usr / local / bin / python3 ist der Pfad des Python-Verzeichnisses.
Pfad unter Windows festlegen
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 -
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 Debug-Ausgabe bereitstellen |
2 | -O Optimierten Bytecode generieren (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 in der Befehlszeile ausgeführt werden, indem der Interpreter in Ihrer Anwendung aufgerufen wird (siehe folgendes Beispiel).
$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 die Hilfe Ihres Systemadministrators in Anspruch nehmen. 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 3.4.1-Version ausgeführt, die unter Windows 7 und Ubuntu Linux verfügbar ist.
Wir haben die Python-Programmierumgebung bereits online eingerichtet, sodass Sie alle verfügbaren Beispiele online ausführen können, während 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 die 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 3.3.2 (default, Dec 10 2013, 11:35:01)
[GCC 4.6.3] on Linux
Type "help", "copyright", "credits", or "license" for more information.
>>>
On Windows:
Python 3.4.3 (v3.4.3:9b73f1c3e601, Feb 24 2015, 22:43:06) [MSC v.1600 32 bit (Intel)] on win32
Type "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 die ältere Version von Python (Python 2.x) ausführen, verwenden Sie Klammern als inprintFunktion ist optional. Dies ergibt das folgende 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 eingestellt haben PATHVariable. Versuchen Sie nun, dieses Programm wie folgt auszuführen:
On Linux
$ python test.py
Dies ergibt das folgende Ergebnis:
Hello, Python!
On Windows
C:\Python34>Python test.py
Dies ergibt das folgende Ergebnis:
Hello, Python!
Versuchen wir einen anderen Weg, um ein Python-Skript unter Linux auszuführen. Hier ist die geänderte Datei test.py -
#!/usr/bin/python3
print ("Hello, Python!")
Wir gehen davon aus, dass im Verzeichnis / usr / bin ein Python-Interpreter verfügbar ist. 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 starken 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 Konstanten oder Variablen oder andere Bezeichnernamen verwenden. Alle Python-Schlüsselwörter enthalten nur Kleinbuchstaben.
und | exec | nicht |
wie | schließlich | oder |
behaupten | zum | bestehen |
Unterbrechung | von | |
Klasse | global | erziehen |
fortsetzen | wenn | Rückkehr |
def | importieren | Versuchen |
del | im | während |
elif | ist | mit |
sonst | Lambda | Ausbeute |
außer |
Linien und Einrückungen
Python verwendet 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 die verschiedenen Blöcke verstanden haben, auch wenn sie keine geschweiften Klammern haben.
#!/usr/bin/python3
import sys
file_finish = "end"
file_text = ""
contents=[]
file_name=input("Enter filename: ")
if len(file_name) == 0:
print("Please enter filename")
sys.exit()
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 = input("Enter text: ")
contents.append(file_text)
if file_text == file_finish:
# close the file
file.close()
break
print(contents)
data = ' '.join([str(elem) for elem in contents])
print(data)
file.write(data)
file.close()
file_name = 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
Die in den Klammern [], {} oder () enthaltenen Anweisungen 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 Zeichenfolgenliteral befindet, ist der Anfang eines Kommentars. Alle Zeichen nach dem # bis zum Ende der physischen Zeile sind Teil des Kommentars und werden vom Python-Interpreter ignoriert.
#!/usr/bin/python3
# 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
Python verfügt nicht über eine mehrzeilige Kommentarfunktion. Sie müssen jede Zeile einzeln 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 werden die Eingabeaufforderung und die Anweisung "Drücken Sie die Eingabetaste zum Beenden" angezeigt. Anschließend wird darauf gewartet, dass der Benutzer Maßnahmen ergreift.
#!/usr/bin/python3
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 einzelnen Zeile, da keine Anweisung einen neuen Codeblock startet. Hier ist ein Beispielausschnitt mit dem Semikolon -
import sys; x = 'foo'; sys.stdout.write(x + '\n')
Mehrere Anweisungsgruppen als Suiten
Es werden Gruppen einzelner Anweisungen aufgerufen, die einen einzelnen Codeblock bilden 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. Python ermöglicht es Ihnen, dies mit - zu tunh - -
$ 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 erweitertes Thema. Lass es uns verstehen.
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 unterschiedlicher Datentypen zu den 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/python3
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 werden 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 mit der Taste löschen delErklärung. Die Syntax derdel Aussage ist -
del var1[,var2[,var3[....,varN]]]]
Sie können ein einzelnes Objekt oder mehrere Objekte mit der Taste löschen del Erklärung.
Zum Beispiel -
del var
del var_a, var_b
Python unterstützt drei verschiedene numerische Typen:
- int (vorzeichenbehaftete Ganzzahlen)
- float (Gleitkomma-Realwerte)
- komplex (komplexe Zahlen)
Alle Ganzzahlen in Python3 werden als lange Ganzzahlen dargestellt. Daher gibt es keinen separaten Nummerntyp so lange.
Beispiele
Hier einige Beispiele für Zahlen -
int | schweben | Komplex |
---|---|---|
10 | 0.0 | 3.14j |
100 | 15.20 | 45.j. |
-786 | -21,9 | 9.322e-36j |
080 | 32,3 + e18 | .876j |
-0490 | -90. | -.6545 + 0J |
-0x260 | -32,54e100 | 3e + 26J |
0x69 | 70,2-E12 | 4,53e-7j |
Eine komplexe Zahl besteht aus einem geordneten Paar von reellen Gleitkommazahlen, die mit x + yj bezeichnet sind, wobei x und y reelle Zahlen sind und j die imaginäre Einheit ist.
Python-Strings
Zeichenfolgen in Python werden als zusammenhängende Zeichensätze in Anführungszeichen identifiziert. Python erlaubt entweder einfache oder doppelte 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 von -1 bis zum Ende durcharbeiten.
Das Pluszeichen (+) ist der Zeichenfolgenverkettungsoperator und das Sternchen (*) ist der Wiederholungsoperator. Zum Beispiel -
#!/usr/bin/python3
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. Einer der Unterschiede 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/python3
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 ergibt das folgende Ergebnis:
['abcd', 786, 2.23, 'john', 70.200000000000003]
abcd
[786, 2.23]
[2.23, 'john', 70.200000000000003]
[123, 'john', 123, 'john']
['abcd', 786, 2.23, 'john', 70.200000000000003, 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.
Der Hauptunterschied zwischen Listen und Tupeln besteht darin, dass Listen in Klammern ([]) eingeschlossen sind und ihre Elemente und Größe geändert werden können, während Tupel in Klammern (()) eingeschlossen und nicht aktualisiert werden können. Tupel können als gedacht werdenread-onlyListen. Zum Beispiel -
#!/usr/bin/python3
tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
print (tuple) # Prints complete tuple
print (tuple[0]) # Prints first element of the tuple
print (tuple[1:3]) # Prints elements starting from 2nd till 3rd
print (tuple[2:]) # Prints elements starting from 3rd element
print (tinytuple * 2) # Prints tuple two times
print (tuple + tinytuple) # Prints concatenated tuple
Dies ergibt das folgende Ergebnis:
('abcd', 786, 2.23, 'john', 70.200000000000003)
abcd
(786, 2.23)
(2.23, 'john', 70.200000000000003)
(123, 'john', 123, 'john')
('abcd', 786, 2.23, 'john', 70.200000000000003, 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/python3
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-Tabelle. 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/python3
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 ergibt das folgende Ergebnis:
This is one
This is two
{'name': 'john', 'dept': 'sales', 'code': 6734}
dict_keys(['name', 'dept', 'code'])
dict_values(['john', 'sales', 6734])
Wörterbücher haben keinen Ordnungsbegriff unter den 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. Um zwischen Typen zu konvertieren, verwenden Sie einfach die 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. Die Basis gibt die Basis an, wenn x eine Zeichenfolge ist. |
2 | float(x) Konvertiert x in eine Gleitkommazahl. |
3 | complex(real [,imag]) Erstellt eine komplexe Zahl. |
4 | str(x) Konvertiert das Objekt x in eine Zeichenfolgendarstellung. |
5 | repr(x) Konvertiert das Objekt x in eine Ausdruckszeichenfolge. |
6 | eval(str) Wertet eine Zeichenfolge aus und gibt ein Objekt zurück. |
7 | tuple(s) Konvertiert s in ein Tupel. |
8 | list(s) Konvertiert s in eine Liste. |
9 | set(s) Konvertiert s in einen Satz. |
10 | dict(d) Erstellt ein Wörterbuch. d muss eine Folge von (Schlüssel-, Wert-) Tupeln sein. |
11 | frozenset(s) Konvertiert s in ein eingefrorenes Set. |
12 | chr(x) Konvertiert eine Ganzzahl in ein Zeichen. |
13 | unichr(x) Konvertiert eine Ganzzahl in ein Unicode-Zeichen. |
14 | ord(x) Konvertiert ein einzelnes Zeichen in seinen ganzzahligen Wert. |
15 | hex(x) Konvertiert eine Ganzzahl in eine hexadezimale Zeichenfolge. |
16 | 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 als Operanden und + als Operator bezeichnet.
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
Schauen wir uns alle Operatoren einzeln an.
Python-Arithmetikoperatoren
Variable annehmen a hält den Wert 10 und variabel b hält den Wert 21, dann -
Beispiel zeigen
Operator | Beschreibung | Beispiel |
---|---|---|
+ Ergänzung | Fügt Werte auf beiden Seiten des Operators hinzu. | a + b = 31 |
- Subtraktion | Subtrahiert den rechten Operanden vom linken Operanden. | a - b = -11 |
* Multiplikation | Multipliziert Werte auf beiden Seiten des Operators | a * b = 210 |
/ Teilung | Teilt den linken Operanden durch den rechten Operanden | b / a = 2,1 |
% Modul | Teilt den linken Operanden durch den rechten Operanden und gibt den Rest zurück | b% a = 1 |
** 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.
Variable annehmen a hält den Wert 10 und variabel b hält den Wert 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 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
Variable annehmen a hält den Wert 10 und variabel b hält den Wert 20, dann -
Beispiel zeigen
Operator | Beschreibung | Beispiel |
---|---|---|
= | Weist dem linken Operanden Werte von Operanden auf der rechten Seite zu | c = a + b weist c den Wert von a + b zu |
+ = UND hinzufügen | Es fügt dem linken Operanden den rechten Operanden hinzu und weist das Ergebnis dem linken Operanden zu | c + = a entspricht c = c + a |
- = UND subtrahieren | Es subtrahiert den rechten Operanden vom linken Operanden und weist das Ergebnis dem linken Operanden zu | c - = a entspricht c = c - a |
* = UND multiplizieren | Es multipliziert den rechten Operanden mit dem linken Operanden und weist das Ergebnis dem linken Operanden zu | c * = a entspricht c = c * a |
/ = UND teilen | Es teilt den linken Operanden mit dem rechten Operanden und weist das Ergebnis dem linken Operanden zu | c / = a entspricht c = c / ac / = a entspricht c = c / a |
% = Modul UND | Es nimmt den Modul mit zwei Operanden und ordnet das Ergebnis dem linken Operanden zu | c% = a entspricht c = c% a |
** = Exponent AND | Führt eine Exponentialberechnung (Leistungsberechnung) für Operatoren durch und weist dem linken Operanden einen Wert zu | c ** = a entspricht c = c ** a |
// = Floor Division | Es führt eine Floor-Division für Operatoren durch und weist dem linken Operanden einen Wert zu | c // = a entspricht c = c // a |
Bitweise Python-Operatoren
Der bitweise Operator arbeitet mit Bits und führt eine bitweise Operation durch. Angenommen, a = 60; und b = 13; Jetzt im Binärformat werden sie wie folgt sein:
a = 0011 1100
b = 0000 1101
-----------------
a & b = 0000 1100
a | b = 0011 1101
a ^ b = 0011 0001
~ a = 1100 0011
Die in Python integrierte Funktion bin () kann verwendet werden, um eine binäre Darstellung einer Ganzzahl zu erhalten.
Die folgenden bitweisen Operatoren werden von der Python-Sprache unterstützt:
Beispiel zeigen
Operator | Beschreibung | Beispiel |
---|---|---|
& Binär UND | Der Operator kopiert ein Bit in das Ergebnis, wenn es in beiden Operanden vorhanden ist | (a & b) (bedeutet 0000 1100) |
| Binär ODER | Es kopiert ein bisschen, wenn es in einem der Operanden vorhanden ist. | (a | b) = 61 (bedeutet 0011 1101) |
^ Binäres XOR | Es kopiert das Bit, wenn es in einem Operanden gesetzt ist, aber nicht in beiden. | (a ^ b) = 49 (bedeutet 0011 0001) |
~ Binäre Ergänzung | Es ist unär und hat den Effekt, dass Bits "umgedreht" werden. | (~ a) = -61 (bedeutet 1100 0011 in 2er-Komplementform aufgrund einer vorzeichenbehafteten Binärzahl. |
<< Binäre Linksverschiebung | Der Wert des linken Operanden wird um die vom rechten Operanden angegebene Anzahl von Bits nach links verschoben. | a << 2 = 240 (bedeutet 1111 0000) |
>> Binäre Rechtsverschiebung | Der Wert des linken Operanden wird um die vom rechten Operanden angegebene Anzahl von Bits nach rechts verschoben. | a >> 2 = 15 (bedeutet 0000 1111) |
Logische Python-Operatoren
Die folgenden logischen Operatoren werden von der Python-Sprache unterstützt. Variable annehmena hält True und variabel b hält dann Falsch -
Beispiel zeigen
Operator | Beschreibung | Beispiel |
---|---|---|
und logisches UND | Wenn beide Operanden wahr sind, wird die Bedingung wahr. | (a und b) ist falsch. |
oder logisches ODER | Wenn einer der beiden Operanden ungleich Null ist, wird die Bedingung wahr. | (a oder b) ist wahr. |
nicht logisch NICHT | Wird verwendet, um den logischen Zustand seines Operanden umzukehren. | Nicht (a und b) ist wahr. |
Python-Mitgliedschaftsoperatoren
Die Mitgliedschaftsoperatoren von Python testen die Mitgliedschaft in einer Sequenz wie Zeichenfolgen, Listen oder Tupeln. Es gibt zwei Mitgliederbetreiber, wie unten erläutert -
Beispiel zeigen
Operator | Beschreibung | Beispiel |
---|---|---|
im | Wird als wahr ausgewertet, wenn eine Variable in der angegebenen Reihenfolge gefunden wird, andernfalls als falsch. | x in y, hier ergibt sich eine 1, wenn x ein Mitglied der Sequenz y ist. |
nicht in | Wird als wahr ausgewertet, wenn keine Variable in der angegebenen Reihenfolge gefunden wird, andernfalls als falsch. | x nicht in y, hier nicht in ergibt eine 1, wenn x kein Mitglied der Sequenz y ist. |
Python-Identitätsoperatoren
Identitätsoperatoren vergleichen die Speicherorte zweier Objekte. Es gibt zwei Identitätsoperatoren, wie unten erläutert -
Beispiel zeigen
Operator | Beschreibung | Beispiel |
---|---|---|
ist | Wird als wahr ausgewertet, wenn die Variablen auf beiden Seiten des Operators auf dasselbe Objekt verweisen, andernfalls als falsch. | x ist hier y is ergibt 1, wenn id (x) gleich id (y) ist. |
ist nicht | Wird als falsch ausgewertet, wenn die Variablen auf beiden Seiten des Operators auf dasselbe Objekt verweisen, andernfalls als wahr. | x ist hier nicht y is not ergibt 1, wenn id (x) nicht gleich id (y) ist. |
Vorrang der Python-Operatoren
In der folgenden Tabelle sind alle Operatoren von der höchsten bis zur niedrigsten Priorität aufgeführt.
Beispiel zeigen
Sr.Nr. | Betreiber & Beschreibung |
---|---|
1 | ** Potenzierung (zur Macht erheben) |
2 | ~ + - Komplement, unäres Plus und Minus (Methodennamen für die letzten beiden sind + @ und - @) |
3 | * / % // Multiplizieren, dividieren, modulo und Bodenteilung |
4 | + - Addition und Subtraktion |
5 | >> << Bitweise Verschiebung nach rechts und links |
6 | & Bitweises 'UND' |
7 | ^ | Bitweises exklusives ODER und reguläres ODER |
8 | <= < > >= Vergleichsoperatoren |
9 | <> == != Gleichheitsoperatoren |
10 | = %= /= //= -= += *= **= Zuweisungsoperatoren |
11 | is is not Identitätsoperatoren |
12 | in not in Mitgliederbetreiber |
13 | not or and Logische Operatoren |
Entscheidungsfindung ist die Antizipation von Bedingungen, die während der Ausführung eines Programms auftreten, und spezifizierter Maßnahmen, die gemäß den Bedingungen ergriffen werden.
Entscheidungsstrukturen werten mehrere Ausdrücke aus, die als Ergebnis WAHR oder FALSCH ergeben. Sie müssen festlegen, welche Aktion ausgeführt und welche Anweisungen ausgeführt werden sollen, wenn das Ergebnis andernfalls WAHR oder FALSCH ist.
Es folgt die allgemeine Form einer typischen Entscheidungsstruktur, die in den meisten Programmiersprachen zu finden ist:
Die Programmiersprache Python setzt jede voraus non-zero und non-null Werte wie TRUE und alle zero oder null values als FALSE-Wert.
Die Programmiersprache Python bietet die folgenden Arten von Entscheidungsbefehlen.
Sr.Nr. | Aussage & Beschreibung |
---|---|
1 | if-Anweisungen Ein if statement besteht aus einem booleschen Ausdruck, gefolgt von einer oder mehreren Anweisungen. |
2 | if ... else-Anweisungen Ein if statement kann von einem optionalen gefolgt werden else statement, wird ausgeführt, wenn der boolesche Ausdruck FALSE ist. |
3 | verschachtelte if-Anweisungen Sie können eine verwenden if oder else if Aussage in einem anderen if oder else if Aussage (n). |
Lassen Sie uns jede Entscheidungserklärung schnell durchgehen.
Single Statement Suites
Wenn die Suite eines if Klausel besteht nur aus einer einzelnen Zeile, sie kann in derselben Zeile wie die Header-Anweisung stehen.
Beispiel
Hier ist ein Beispiel für eine one-line if Klausel -
#!/usr/bin/python3
var = 100
if ( var == 100 ) : print ("Value of expression is 100")
print ("Good bye!")
Ausgabe
Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:
Value of expression is 100
Good bye!
Im Allgemeinen werden Anweisungen nacheinander ausgeführt - Die erste Anweisung in einer Funktion wird zuerst ausgeführt, gefolgt von der zweiten usw. Es kann vorkommen, dass Sie einen Codeblock mehrmals ausführen müssen.
Programmiersprachen bieten verschiedene Steuerungsstrukturen, die kompliziertere Ausführungspfade ermöglichen.
Mit einer Schleifenanweisung können wir eine Anweisung oder eine Gruppe von Anweisungen mehrmals ausführen. Das folgende Diagramm zeigt eine Schleifenanweisung -
Die Programmiersprache Python bietet die folgenden Arten von Schleifen, um die Schleifenanforderungen zu erfüllen.
Sr.Nr. | Schleifentyp & Beschreibung |
---|---|
1 | while-Schleife Wiederholt eine Anweisung oder eine Gruppe von Anweisungen, während eine bestimmte Bedingung WAHR ist. Es testet die Bedingung, bevor der Schleifenkörper ausgeführt wird. |
2 | für Schleife Führt eine Folge von Anweisungen mehrmals aus und verkürzt den Code, der die Schleifenvariable verwaltet. |
3 | verschachtelte Schleifen Sie können eine oder mehrere Schleifen in einer anderen während oder für eine Schleife verwenden. |
Schleifensteuerungsanweisungen
Die Loop-Steueranweisungen ändern die Ausführung von ihrer normalen Reihenfolge. Wenn die Ausführung einen Bereich verlässt, werden alle automatischen Objekte, die in diesem Bereich erstellt wurden, zerstört.
Python unterstützt die folgenden Steueranweisungen.
Sr.Nr. | Steueranweisung & Beschreibung |
---|---|
1 | break-Anweisung Beendet die Schleifenanweisung und überträgt die Ausführung an die Anweisung unmittelbar nach der Schleife. |
2 | Aussage fortsetzen Bewirkt, dass die Schleife den Rest ihres Körpers überspringt und ihren Zustand sofort erneut testet, bevor sie wiederholt wird. |
3 | pass-Anweisung Die pass-Anweisung in Python wird verwendet, wenn eine Anweisung syntaktisch erforderlich ist, Sie jedoch keinen Befehl oder Code ausführen möchten. |
Lassen Sie uns die Schleifensteuerungsanweisungen kurz durchgehen.
Iterator und Generator
Iteratorist ein Objekt, mit dem ein Programmierer unabhängig von seiner spezifischen Implementierung alle Elemente einer Sammlung durchlaufen kann. In Python implementiert ein Iteratorobjekt zwei Methoden:iter() und next().
String-, Listen- oder Tupelobjekte können zum Erstellen eines Iterators verwendet werden.
list = [1,2,3,4]
it = iter(list) # this builds an iterator object
print (next(it)) #prints next available element in iterator
Iterator object can be traversed using regular for statement
!usr/bin/python3
for x in it:
print (x, end=" ")
or using next() function
while True:
try:
print (next(it))
except StopIteration:
sys.exit() #you have to import sys module for this
EIN generator ist eine Funktion, die eine Folge von Werten unter Verwendung der Ertragsmethode erzeugt oder ergibt.
Wenn eine Generatorfunktion aufgerufen wird, gibt sie ein Generatorobjekt zurück, ohne mit der Ausführung der Funktion zu beginnen. Wenn die next () -Methode zum ersten Mal aufgerufen wird, beginnt die Ausführung der Funktion, bis sie die Yield-Anweisung erreicht, die den Yield-Wert zurückgibt. Der Ertrag behält den Überblick, dh er merkt sich die letzte Ausführung und der zweite next () -Aufruf wird vom vorherigen Wert fortgesetzt.
Beispiel
Das folgende Beispiel definiert einen Generator, der einen Iterator für alle Fibonacci-Zahlen generiert.
#!usr/bin/python3
import sys
def fibonacci(n): #generator function
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
counter += 1
f = fibonacci(5) #f is iterator object
while True:
try:
print (next(f), end=" ")
except StopIteration:
sys.exit()
Zahlendatentypen speichern numerische Werte. Sie sind unveränderliche Datentypen. Das heißt, das Ändern des Werts eines Zahlendatentyps führt zu einem neu zugewiesenen Objekt.
Zahlenobjekte werden erstellt, wenn Sie ihnen einen Wert zuweisen. Zum Beispiel -
var1 = 1
var2 = 10
Sie können den Verweis auf ein Zahlenobjekt auch mit der Taste löschen delErklärung. Die Syntax derdel Aussage ist -
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 verschiedene numerische Typen -
int (signed integers) - Sie werden oft nur ganze Zahlen oder genannt ints. Es sind positive oder negative ganze Zahlen ohne Dezimalpunkt. Ganzzahlen in Python 3 sind unbegrenzt groß. Python 2 hat zwei ganzzahlige Typen - int und long. Es gibt kein 'long integer'in Python 3 nicht mehr.
float (floating point real values)- Auch Floats genannt, stellen sie reelle Zahlen dar und werden mit einem Dezimalpunkt geschrieben, der die Ganzzahl und die Bruchteile teilt. Floats können auch in wissenschaftlicher Notation sein, wobei E oder e die Potenz von 10 angeben (2,5e2 = 2,5 x 10 2 = 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.
Es ist möglich, eine Ganzzahl in hexadezimaler oder oktaler Form darzustellen
>>> number = 0xA0F #Hexa-decimal
>>> number
2575
>>> number = 0o37 #Octal
>>> number
31
Beispiele
Hier sind einige Beispiele für Zahlen.
int | schweben | Komplex |
---|---|---|
10 | 0.0 | 3.14j |
100 | 15.20 | 45.j. |
-786 | -21,9 | 9.322e-36j |
080 | 32,3 + e18 | .876j |
-0490 | -90. | -.6545 + 0J |
-0 × 260 | -32,54e100 | 3e + 26J |
0 × 69 | 70,2-E12 | 4,53e-7j |
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 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. Deprecated in Python 3. Verwenden Sie stattdessen return (x>y)-(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/python3
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/python3
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/python3
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.
Sr.Nr. | Symbol & Konvertierung formatieren |
---|---|
1 | %c Charakter |
2 | %s Zeichenfolgenkonvertierung über str () vor der Formatierung |
3 | %i vorzeichenbehaftete Dezimalzahl |
4 | %d vorzeichenbehaftete Dezimalzahl |
5 | %u vorzeichenlose Dezimalzahl |
6 | %o oktale Ganzzahl |
7 | %x hexadezimale Ganzzahl (Kleinbuchstaben) |
8 | %X hexadezimale Ganzzahl (Großbuchstaben) |
9 | %e Exponentialschreibweise (mit Kleinbuchstaben 'e') |
10 | %E Exponentialschreibweise (mit Großbuchstaben 'E') |
11 | %f reelle Gleitkommazahl |
12 | %g der kürzere von% f und% e |
13 | %G der kürzere von% f und% E. |
Weitere unterstützte Symbole und Funktionen sind in der folgenden Tabelle aufgeführt:
Sr.Nr. | Symbol & Funktionalität |
---|---|
1 | * Argument gibt Breite oder Genauigkeit an |
2 | - linke Rechtfertigung |
3 | + Zeigen Sie das Schild an |
4 | <sp> Lassen Sie ein Leerzeichen vor einer positiven Zahl |
5 | # 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. |
6 | 0 Pad von links mit Nullen (anstelle von Leerzeichen) |
7 | % '%%' hinterlässt ein einzelnes Literal '%' |
8 | (var) Zuordnungsvariable (Wörterbuchargumente) |
9 | m.n. 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/python3
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/python3
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/python3
print (r'C:\\nowhere')
Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:
C:\\nowhere
Unicode-Zeichenfolge
In Python 3 werden alle Zeichenfolgen in Unicode dargestellt. In Python 2 wird intern als 8-Bit-ASCII gespeichert. Daher muss 'u' angehängt werden, um Unicode zu erstellen. Es ist jetzt nicht mehr nötig.
Integrierte String-Methoden
Python enthält die folgenden integrierten Methoden zum Bearbeiten von Zeichenfolgen:
Sr.Nr. | Methoden & Beschreibung |
---|---|
1 | profitieren() Großschreibung des ersten Buchstabens |
2 | Mitte (Breite, Füllcharakter) Gibt eine mit Fillchar 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 der vielseitigste in Python verfügbare Datentyp, der als Liste von durch Kommas getrennten Werten (Elementen) in eckigen Klammern geschrieben werden kann. Wichtig an einer Liste ist, dass die 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/python3
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/python3
list = ['physics', 'chemistry', 1997, 2000]
print ("Value available at index 2 : ", list[2])
list[2] = 2001
print ("New value available at index 2 : ", 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 das verwenden delAnweisung, wenn Sie genau wissen, welche Elemente Sie löschen. Sie können die remove () -Methode verwenden, wenn Sie nicht genau wissen, welche Elemente gelöscht werden sollen. Zum Beispiel -
#!/usr/bin/python3
list = ['physics', 'chemistry', 1997, 2000]
print (list)
del list[2]
print ("After deleting value at index 2 : ", list)
Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:
['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]: print (x, end = '') | 1 2 3 | Wiederholung |
Indizieren, Schneiden und Matrizen
Da Listen Sequenzen sind, funktionieren Indizieren und Schneiden für Listen genauso wie für Zeichenfolgen.
Unter der Annahme der folgenden Eingabe -
L = ['C++'', 'Java', 'Python']
Python-Ausdruck | Ergebnisse | Beschreibung |
---|---|---|
L [2] | 'Python' | Offsets beginnen bei Null |
L [-2] | 'Java' | Negativ: von rechts zählen |
L [1:] | ['Java', 'Python'] | Das Schneiden holt Abschnitte |
Integrierte Listenfunktionen und -methoden
Python enthält die folgenden Listenfunktionen:
Sr.Nr. | Bedienungsanleitung |
---|---|
1 | len (Liste) Gibt die Gesamtlänge der Liste an. |
2 | max (Liste) Gibt ein Element aus der Liste mit dem Maximalwert zurück. |
3 | min (Liste) Gibt ein Element aus der Liste mit dem Mindestwert zurück. |
4 | Liste (seq) Konvertiert ein Tupel in eine Liste. |
Python enthält die folgenden Listenmethoden:
Sr.Nr. | Methoden & 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 Sammlung von Objekten, die geordnet und unveränderlich sind. Tupel sind Sequenzen, genau wie Listen. Der Hauptunterschied zwischen den Tupeln und den Listen besteht darin, dass die Tupel im Gegensatz zu Listen nicht geändert werden können. Tupel verwenden Klammern, 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/python3
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 der vorhandenen Tupel verwenden, um neue Tupel zu erstellen, wie das folgende Beispiel zeigt:
#!/usr/bin/python3
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/python3
tup = ('physics', 'chemistry', 1997, 2000);
print (tup)
del tup;
print ("After deleting tup : ")
print (tup)
Dies führt zu folgendem Ergebnis.
Note- Eine Ausnahme wird ausgelöst. Das liegt daran, dass 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): print (x, end = '') | 1 2 3 | Wiederholung |
Indizieren, Schneiden und Matrizen
Da Tupel Sequenzen sind, funktionieren Indizieren und Schneiden für Tupel genauso wie für Zeichenfolgen, vorausgesetzt, die folgenden Eingaben -
T=('C++', 'Java', 'Python')
Python-Ausdruck | Ergebnisse | Beschreibung |
---|---|---|
T [2] | 'Python' | Offsets beginnen bei Null |
T [-2] | 'Java' | Negativ: von rechts zählen |
T [1:] | ('Java', 'Python') | Das Schneiden holt Abschnitte |
Keine umschließenden Begrenzer
Keine einschließenden Trennzeichen sind mehrere durch Kommas getrennte Objekte, die ohne identifizierende Symbole geschrieben wurden, dh Klammern für Listen, Klammern für Tupel usw., standardmäßig Tupel, wie in diesen kurzen Beispielen angegeben.
Eingebaute Tupelfunktionen
Python enthält die folgenden Tupelfunktionen:
Sr.Nr. | Bedienungsanleitung |
---|---|
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/python3
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/python3
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['Zara']:
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 in einem einfachen Beispiel unten gezeigt.
#!/usr/bin/python3
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.
To explicitly remove an entire dictionary, just use the del statement. Following is a simple example −
#!/usr/bin/python3
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'])
This produces the following result.
An exception is raised because after del dict, the dictionary does not exist anymore.
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 − The del() method is discussed in subsequent section.
Properties of Dictionary Keys
Dictionary values have no restrictions. They can be any arbitrary Python object, either standard objects or user-defined objects. However, same is not true for the keys.
There are two important points to remember about dictionary keys −
(a) More than one entry per key is not allowed. This means no duplicate key is allowed. When duplicate keys are encountered during assignment, the last assignment wins. For example −
#!/usr/bin/python3
dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'}
print ("dict['Name']: ", dict['Name'])
When the above code is executed, it produces the following result −
dict['Name']: Manni
(b) Keys must be immutable. This means you can use strings, numbers or tuples as dictionary keys but something like ['key'] is not allowed. Following is a simple example −
#!/usr/bin/python3
dict = {['Name']: 'Zara', 'Age': 7}
print ("dict['Name']: ", dict['Name'])
When the above code is executed, it produces the following result −
Traceback (most recent call last):
File "test.py", line 3, in <module>
dict = {['Name']: 'Zara', 'Age': 7}
TypeError: list objects are unhashable
Built-in Dictionary Functions and Methods
Python includes the following dictionary functions −
Sr.No. | Function & Description |
---|---|
1 | cmp(dict1, dict2) No longer available in Python 3. |
2 | len(dict) Gives the total length of the dictionary. This would be equal to the number of items in the dictionary. |
3 | str(dict) Produces a printable string representation of a dictionary |
4 | type(variable) Returns the type of the passed variable. If passed variable is dictionary, then it would return a dictionary type. |
Python includes the following dictionary methods −
Sr.No. | Method & Description |
---|---|
1 | dict.clear() Removes all elements of dictionary dict |
2 | dict.copy() Returns a shallow copy of dictionary dict |
3 | dict.fromkeys() Create a new dictionary with keys from seq and values set to value. |
4 | dict.get(key, default=None) For key key, returns value or default if key not in dictionary |
5 | dict.has_key(key) Removed, use the in operation instead. |
6 | dict.items() Returns a list of dict's (key, value) tuple pairs |
7 | dict.keys() Returns list of dictionary dict's keys |
8 | dict.setdefault(key, default = None) Similar to get(), but will set dict[key] = default if key is not already in dict |
9 | dict.update(dict2) Adds dictionary dict2's key-values pairs to dict |
10 | dict.values() Returns list of dictionary dict's values |
A Python program can handle date and time in several ways. Converting between date formats is a common chore for computers. Python's time and calendar modules help track dates and times.
What is Tick?
Time intervals are floating-point numbers in units of seconds. Particular instants in time are expressed in seconds since 12:00am, January 1, 1970(epoch).
There is a popular time module available in Python which provides functions for working with times, and for converting between representations. The function time.time() returns the current system time in ticks since 12:00am, January 1, 1970(epoch).
Example
#!/usr/bin/python3
import time; # This is required to include time module.
ticks = time.time()
print ("Number of ticks since 12:00am, January 1, 1970:", ticks)
This would produce a result something as follows −
Number of ticks since 12:00am, January 1, 1970: 1455508609.34375
Date arithmetic is easy to do with ticks. However, dates before the epoch cannot be represented in this form. Dates in the far future also cannot be represented this way - the cutoff point is sometime in 2038 for UNIX and Windows.
What is TimeTuple?
Many of the Python's time functions handle time as a tuple of 9 numbers, as shown below −
Index | Field | Values |
---|---|---|
0 | 4-digit year | 2016 |
1 | Month | 1 to 12 |
2 | Day | 1 to 31 |
3 | Hour | 0 to 23 |
4 | Minute | 0 to 59 |
5 | Second | 0 to 61 (60 or 61 are leap-seconds) |
6 | Day of Week | 0 to 6 (0 is Monday) |
7 | Day of year | 1 to 366 (Julian day) |
8 | Daylight savings | -1, 0, 1, -1 means library determines DST |
For Example −
import time
print (time.localtime());
This would produce a result as follows −
time.struct_time(tm_year = 2016, tm_mon = 2, tm_mday = 15, tm_hour = 9,
tm_min = 29, tm_sec = 2, tm_wday = 0, tm_yday = 46, tm_isdst = 0)
The above tuple is equivalent to struct_time structure. This structure has following attributes −
Index | Attributes | Values |
---|---|---|
0 | tm_year | 2016 |
1 | tm_mon | 1 to 12 |
2 | tm_mday | 1 to 31 |
3 | tm_hour | 0 to 23 |
4 | tm_min | 0 to 59 |
5 | tm_sec | 0 to 61 (60 or 61 are leap-seconds) |
6 | tm_wday | 0 to 6 (0 is Monday) |
7 | tm_yday | 1 to 366 (Julian day) |
8 | tm_isdst | -1, 0, 1, -1 means library determines DST |
Getting current time
To translate a time instant from seconds since the epoch floating-point value into a timetuple, pass the floating-point value to a function (e.g., localtime) that returns a time-tuple with all valid nine items.
#!/usr/bin/python3
import time
localtime = time.localtime(time.time())
print ("Local current time :", localtime)
This would produce the following result, which could be formatted in any other presentable form −
Local current time : time.struct_time(tm_year = 2016, tm_mon = 2, tm_mday = 15,
tm_hour = 9, tm_min = 29, tm_sec = 2, tm_wday = 0, tm_yday = 46, tm_isdst = 0)
Getting formatted time
You can format any time as per your requirement, but a simple method to get time in a readable format is asctime() −
Live-Demo#!/usr/bin/python3
import time
localtime = time.asctime( time.localtime(time.time()) )
print ("Local current time :", localtime)
Dies würde das folgende Ergebnis erzeugen -
Local current time : Mon Feb 15 09:34:03 2016
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/python3
import calendar
cal = calendar.month(2016, 2)
print ("Here is the calendar:")
print (cal)
Dies würde das folgende Ergebnis erzeugen -
Here is the calendar:
February 2016
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
Das Zeitmodul
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. | Bedienungsanleitung |
---|---|
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, 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. |
Mit dem Zeitmodul stehen zwei wichtige Attribute zur Verfügung. Sie sind -
Sr.Nr. | Attribut & 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 diecalendar.setfirstweekday() Funktion.
Hier ist eine Liste der Funktionen, die mit dem verfügbar sind calendar Modul -
Sr.Nr. | Bedienungsanleitung |
---|---|
1 | calendar.calendar(year,w = 2,l = 1,c = 6) Gibt eine mehrzeilige Zeichenfolge mit einem Kalender für das Jahr zurück, der in drei durch c Leerzeichen getrennte Spalten formatiert ist. w ist die Breite in Zeichen jedes Datums; Jede Zeile hat eine Länge von 21 * w + 18 + 2 * c. l ist die Anzahl der Zeilen pro Woche. |
2 | calendar.firstweekday( ) Gibt die aktuelle Einstellung für den Wochentag zurück, der jede Woche beginnt. Wenn der Kalender zum ersten Mal importiert wird, ist dies standardmäßig 0, was Montag bedeutet. |
3 | calendar.isleap(year) Gibt True zurück, wenn das Jahr ein Schaltjahr ist. sonst falsch. |
4 | calendar.leapdays(y1,y2) Gibt die Gesamtzahl der Schalttage in den Jahren innerhalb des Bereichs (y1, y2) zurück. |
5 | calendar.month(year,month,w = 2,l = 1) Gibt eine mehrzeilige Zeichenfolge mit einem Kalender für den Monat, den Monat des Jahres und das Jahr zurück, eine Zeile pro Woche plus zwei Kopfzeilen. w ist die Breite in Zeichen jedes Datums; Jede Zeile hat die Länge 7 * w + 6. l ist die Anzahl der Zeilen pro Woche. |
6 | calendar.monthcalendar(year,month) Gibt eine Liste mit Ints-Listen zurück. Jede Unterliste bezeichnet eine Woche. Tage außerhalb des Monats Monat des Jahres Jahr werden auf 0 gesetzt; Tage innerhalb eines Monats werden auf den Tag des Monats 1 und höher eingestellt. |
7 | calendar.monthrange(year,month) Gibt zwei Ganzzahlen zurück. Der erste ist der Code des Wochentags für den ersten Tag des Monats Monat im Jahr Jahr; Der zweite ist die Anzahl der Tage im Monat. Wochentagscodes sind 0 (Montag) bis 6 (Sonntag); Monatszahlen sind 1 bis 12. |
8 | calendar.prcal(year,w = 2,l = 1,c = 6) Wie print calendar.calendar (Jahr, w, l, c). |
9 | calendar.prmonth(year,month,w = 2,l = 1) Wie print calendar.month (Jahr, Monat, w, l). |
10 | calendar.setfirstweekday(weekday) Legt den ersten Tag jeder Woche auf den Wochentagcode Wochentag fest. Wochentagscodes sind 0 (Montag) bis 6 (Sonntag). |
11 | calendar.timegm(tupletime) Die Umkehrung von time.gmtime: akzeptiert einen Zeitzeitpunkt in Zeittupelform und gibt denselben Zeitpunkt wie eine Gleitkommazahl von Sekunden seit der Epoche zurück. |
12 | calendar.weekday(year,month,day) Gibt den Wochentagscode für das angegebene Datum zurück. Wochentagscodes sind 0 (Montag) bis 6 (Sonntag); Die Monatszahlen sind 1 (Januar) bis 12 (Dezember). |
Andere Module und Funktionen
Wenn Sie interessiert sind, finden Sie hier eine Liste anderer wichtiger Module und Funktionen, mit denen Sie in Python mit Datum und Uhrzeit spielen können -
- Das datetime-Modul
- Das Pytz-Modul
- Das Dateutil-Modul
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 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. Es folgt ein Beispiel zum Aufrufen derprintme() Funktion -
#!/usr/bin/python3
# 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("This is first call to the user defined function!")
printme("Again second call to the same function")
Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:
This is first call to the 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/python3
# Function definition is here
def changeme( mylist ):
"This changes a passed list into this function"
print ("Values inside the function before change: ", mylist)
mylist[2]=50
print ("Values inside the function after change: ", 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. Daher würde dies das folgende Ergebnis erzeugen -
Values inside the function before change: [10, 20, 30]
Values inside the function after change: [10, 20, 50]
Values outside the function: [10, 20, 50]
Es gibt noch ein weiteres Beispiel, bei dem Argumente als Referenz übergeben werden und die Referenz innerhalb der aufgerufenen Funktion überschrieben wird.
#!/usr/bin/python3
# Function definition is here
def changeme( mylist ):
"This changes a passed list into this function"
mylist = [1,2,3,4] # This would assi 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 mylistist 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.
Funktion aufrufen printme()müssen Sie auf jeden Fall ein Argument übergeben, da sonst ein Syntaxfehler wie folgt angezeigt wird:
#!/usr/bin/python3
# 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 auch Keyword-Aufrufe an dieprintme() Funktion auf folgende Weise -
#!/usr/bin/python3
# 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 zeigt ein klareres Bild. Beachten Sie, dass die Reihenfolge der Parameter keine Rolle spielt.
#!/usr/bin/python3
# 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/python3
# 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 ist unten angegeben -
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/python3
# 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 deklariert werden defStichwort. Du kannst den ... benutzenlambda Schlüsselwort zum Erstellen kleiner anonymer Funktionen.
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 aus Leistungsgründen nicht den Inline-Anweisungen in C oder C ++, deren Zweck darin besteht, die Zuweisung durch Übergabe der Funktion während des Aufrufs zu stapeln.
Syntax
Die Syntax von lambda Funktionen enthält nur eine einzige Anweisung, die wie folgt lautet:
lambda [arg1 [,arg2,.....argn]]:expression
Das folgende Beispiel zeigt, wie lambda Form der Funktion funktioniert -
#!/usr/bin/python3
# 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ückgabeerklärung
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 unten angegebenen Beispiele geben keinen Wert zurück. Sie können einen Wert von einer Funktion wie folgt zurückgeben:
#!/usr/bin/python3
# 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/python3
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 Importanweisung
Sie können jede Python-Quelldatei als Modul verwenden, indem Sie eine Importanweisung in einer anderen Python-Quelldatei ausführen. Dasimport 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 hello.py zu importieren, müssen Sie den folgenden Befehl oben im Skript einfügen:
#!/usr/bin/python3
# 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 wiederholt erfolgt, wenn mehrere Importe ausgeführt werden.
Die from ... import Anweisung
Pythons fromMit dieser Anweisung können Sie bestimmte Attribute aus einem Modul in den aktuellen Namespace importieren. Dasfrom...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:
#!/usr/bin/python3
# Fibonacci numbers module
def fib(n): # return Fibonacci series up to n
result = []
a, b = 0, 1
while b < n:
result.append(b)
a, b = b, a + b
return result
>>> from fib import fib
>>> fib(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
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 als Skripte ausführen
Innerhalb eines Moduls ist der Name des Moduls (als Zeichenfolge) als Wert der globalen Variablen __name__ verfügbar. Der Code im Modul wird so ausgeführt, als ob Sie ihn importiert hätten, jedoch mit dem Namen __name__ auf "__main__".
Fügen Sie diesen Code am Ende Ihres Moduls hinzu -
#!/usr/bin/python3
# Fibonacci numbers module
def fib(n): # return Fibonacci series up to n
result = []
a, b = 0, 1
while b < n:
result.append(b)
a, b = b, a + b
return result
if __name__ == "__main__":
f = fib(100)
print(f)
Wenn Sie den obigen Code ausführen, wird die folgende Ausgabe angezeigt.
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
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 / python3 /.
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:\python34\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/python3
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/python3
# 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 Funktionen Globals () und Locals ()
Das globals() und locals() Funktionen können verwendet werden, um die Namen in den globalen und lokalen Namespaces zurückzugeben, abhängig von dem Ort, von dem aus sie aufgerufen werden.
Wenn locals() Wird innerhalb einer Funktion aufgerufen, werden alle Namen zurückgegeben, auf die von dieser Funktion aus lokal zugegriffen werden kann.
Wenn globals() Wird innerhalb einer Funktion aufgerufen, 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 extrahiert werdenkeys() Funktion.
Die Funktion reload ()
Wenn ein 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/python3
def Pots():
print ("I'm Pots Phone")
Ähnlich haben wir zwei andere Dateien mit unterschiedlichen Funktionen mit demselben Namen wie oben. Sie sind -
Telefon / Isdn.py- Datei mit der Funktion Isdn ()
Telefon / G3.py- Datei mit der Funktion G3 ()
Erstellen Sie nun 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/python3
# 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 3 verfügbar sind. Weitere Funktionen finden Sie in der Standarddokumentation zu Python.
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/python3
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 2 verfügt über zwei integrierte Funktionen zum Lesen von Daten aus Standardeingaben, die standardmäßig von der Tastatur stammen. Diese Funktionen sindinput() und raw_input()
In Python 3 ist die Funktion raw_input () veraltet. Darüber hinaus lesen input () -Funktionen Daten von der Tastatur als Zeichenfolge, unabhängig davon, ob sie in Anführungszeichen ('' oder "") eingeschlossen sind oder nicht.
Die Eingabefunktion
Das input([prompt]) Die Funktion entspricht raw_input, setzt jedoch voraus, dass die Eingabe ein gültiger Python-Ausdruck ist, und gibt das ausgewertete Ergebnis an Sie zurück.
#!/usr/bin/python3
>>> x = input("something:")
something:10
>>> x
'10'
>>> x = input("something:")
something:'10' #entered data treated as string with or without ''
>>> x
"'10'"
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. | Modus & 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 ein 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. |
Note - Das Softspace-Attribut wird in Python 3.x nicht unterstützt
Beispiel
#!/usr/bin/python3
# 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)
fo.close()
Dies ergibt das folgende Ergebnis:
Name of the file: foo.txt
Closed or not : False
Opening mode : wb
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/python3
# Open a file
fo = open("foo.txt", "wb")
print ("Name of the file: ", fo.name)
# Close opened 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 es benutztread() und write() Methoden zum Lesen und Schreiben von Dateien.
Die write () -Methode
Das 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/python3
# Open a file
fo = open("foo.txt", "w")
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 den folgenden Inhalt:
Python is a great language.
Yeah its great!!
Die read () -Methode
Das 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/python3
# Open a file
fo = open("foo.txt", "r+")
str = fo.read(10)
print ("Read String is : ", str)
# Close opened 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. DasoffsetArgument gibt die Anzahl der zu verschiebenden Bytes an. Dasfrom Argument gibt die Referenzposition an, von der aus die Bytes verschoben werden sollen.
Wenn from auf 0 gesetzt ist, wird der Anfang der Datei als Referenzposition verwendet. Wenn es auf 1 gesetzt ist, wird die aktuelle Position als Referenzposition verwendet. Wenn es 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/python3
# 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 opened 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 ()
Das rename() method takes two arguments, the current filename and the new filename.
Syntax
os.rename(current_file_name, new_file_name)
Example
Following is an example to rename an existing file test1.txt −
#!/usr/bin/python3
import os
# Rename a file from test1.txt to test2.txt
os.rename( "test1.txt", "test2.txt" )
The remove() Method
You can use the remove() method to delete files by supplying the name of the file to be deleted as the argument.
Syntax
os.remove(file_name)
Example
Following is an example to delete an existing file test2.txt −
#!/usr/bin/python3
import os
# Delete file test2.txt
os.remove("text2.txt")
Directories in Python
All files are contained within various directories, and Python has no problem handling these too. The os module has several methods that help you create, remove, and change directories.
The mkdir() Method
You can use the mkdir() method of the os module to create directories in the current directory. You need to supply an argument to this method, which contains the name of the directory to be created.
Syntax
os.mkdir("newdir")
Example
Following is an example to create a directory test in the current directory −
#!/usr/bin/python3
import os
# Create a directory "test"
os.mkdir("test")
The chdir() Method
You can use the chdir() method to change the current directory. The chdir() method takes an argument, which is the name of the directory that you want to make the current directory.
Syntax
os.chdir("newdir")
Example
Following is an example to go into "/home/newdir" directory −
#!/usr/bin/python3
import os
# Changing a directory to "/home/newdir"
os.chdir("/home/newdir")
The getcwd() Method
The getcwd() method displays the current working directory.
Syntax
os.getcwd()
Example
Following is an example to give current directory −
#!/usr/bin/python3
import os
# This would give location of the current directory
os.getcwd()
The rmdir() Method
The rmdir() method deletes the directory, which is passed as an argument in the method.
Before removing a directory, all the contents in it should be removed.
Syntax
os.rmdir('dirname')
Example
Following is an example to remove the "/tmp/test" directory. It is required to give fully qualified name of the directory, otherwise it would search for that directory in the current directory.
#!/usr/bin/python3
import os
# This would remove "/tmp/test" directory.
os.rmdir( "/tmp/test" )
File and Directory Related Methods
There are three important sources, which provide a wide range of utility methods to handle and manipulate files & directories on Windows and Unix operating systems. They are as follows −
File Object Methods
The file object provides functions to manipulate files.
OS Object Methods
This provides methods to process files as well as directories.
Python provides two very important features to handle any unexpected error in your Python programs and to add debugging capabilities in them −
Exception Handling − This would be covered in this tutorial. Here is a list standard Exceptions available in Python − Standard Exceptions.
Assertions − This would be covered in Assertions in Python 3 tutorial.
Standard Exceptions
Here is a list of Standard Exceptions available in Python. −
Sr.No. | Exception Name & Description |
---|---|
1 | Exception Base class for all exceptions |
2 | StopIteration Raised when the next() method of an iterator does not point to any object. |
3 | SystemExit Raised by the sys.exit() function. |
4 | StandardError Base class for all built-in exceptions except StopIteration and SystemExit. |
5 | ArithmeticError Base class for all errors that occur for numeric calculation. |
6 | OverflowError Raised when a calculation exceeds maximum limit for a numeric type. |
7 | FloatingPointError Raised when a floating point calculation fails. |
8 | ZeroDivisonError Raised when division or modulo by zero takes place for all numeric types. |
9 | AssertionError Raised in case of failure of the Assert statement. |
10 | AttributeError Raised in case of failure of attribute reference or assignment. |
11 | EOFError Raised when there is no input from either the raw_input() or input() function and the end of file is reached. |
12 | ImportError Raised when an import statement fails. |
13 | KeyboardInterrupt Raised when the user interrupts program execution, usually by pressing Ctrl+c. |
14 | LookupError Base class for all lookup errors. |
15 | IndexError Raised when an index is not found in a sequence. |
16 | KeyError Raised when the specified key is not found in the dictionary. |
17 | NameError Raised when an identifier is not found in the local or global namespace. |
18 | UnboundLocalError Raised when trying to access a local variable in a function or method but no value has been assigned to it. |
19 | EnvironmentError Base class for all exceptions that occur outside the Python environment. |
20 | IOError Raised when an input/ output operation fails, such as the print statement or the open() function when trying to open a file that does not exist. |
21 | OSError Raised for operating system-related errors. |
22 | SyntaxError Raised when there is an error in Python syntax. |
23 | IndentationError Raised when indentation is not specified properly. |
24 | SystemError Raised when the interpreter finds an internal problem, but when this error is encountered the Python interpreter does not exit. |
25 | SystemExit Raised when Python interpreter is quit by using the sys.exit() function. If not handled in the code, causes the interpreter to exit. |
26 | TypeError Raised when an operation or function is attempted that is invalid for the specified data type. |
27 | ValueError Raised when the built-in function for a data type has the valid type of arguments, but the arguments have invalid values specified. |
28 | RuntimeError Raised when a generated error does not fall into any category. |
29 | NotImplementedError Raised when an abstract method that needs to be implemented in an inherited class is not actually implemented. |
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 mithilfe der try-exception-Anweisung abgefangen und behandelt werden. Wenn sie nicht behandelt werden, beenden sie das Programm und erzeugen einen Traceback.
Beispiel
Hier ist eine Funktion, die eine bestimmte Temperatur von Grad Kelvin in Grad Fahrenheit umwandelt. Da 0 ° K so kalt wie es nur geht, wird die Funktion beendet, wenn eine negative Temperatur festgestellt wird -
#!/usr/bin/python3
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/python3
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, in der Sie nicht über die Schreibberechtigung verfügen. Daher wird eine Ausnahme ausgelöst.
#!/usr/bin/python3
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. Dasfinally: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.
......................
Note- Sie können außer Klausel (en) oder eine finally-Klausel angeben, aber nicht beide. Sie können die else- Klausel nicht zusammen mit einer finally-Klausel verwenden.
Beispiel
#!/usr/bin/python3
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")
fh.close()
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/python3
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")
Dies ergibt das folgende Ergebnis:
Going to close the file
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 as 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/python3
# Define a function here.
def temp_convert(var):
try:
return int(var)
except ValueError as 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'
Eine Ausnahme 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 Exception(level)
# The code below to this would not be executed
# if we raise the exception
return level
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 Exception as e:
Exception handling here using e.args...
else:
Rest of the code here...
Das folgende Beispiel zeigt die Verwendung der Auslösung einer Ausnahme -
#!/usr/bin/python3
def functionName( level ):
if level <1:
raise Exception(level)
# The code below to this would not be executed
# if we raise the exception
return level
try:
l = functionName(-10)
print ("level = ",l)
except Exception as e:
print ("error in level argument",e.args[0])
Dies führt zu folgendem Ergebnis
error in level argument -10
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 Ihnen zu helfen:
Ü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 wird. 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 zugegriffen werden kann ClassName.__doc__.
Das class_suite besteht aus allen Komponentenanweisungen, die Klassenmitglieder, Datenattribute und Funktionen definieren.
Beispiel
Das Folgende ist ein Beispiel für eine einfache 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 von a in 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/python3
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.salary = 7000 # Add an 'salary' attribute.
emp1.name = 'xyz' # Modify 'age' attribute.
del emp1.salary # 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, 'salary') # Returns true if 'salary' attribute exists
getattr(emp1, 'salary') # Returns value of 'salary' attribute
setattr(emp1, 'salary', 7000) # Set attribute 'salary' at 7000
delattr(emp1, 'salary') # Delete attribute 'salary'
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/python3
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)
emp1 = Employee("Zara", 2000)
emp2 = Employee("Manni", 5000)
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__: (<class 'object'>,)
Employee.__dict__: {
'displayCount': <function Employee.displayCount at 0x0160D2B8>,
'__module__': '__main__', '__doc__': 'Common base class for all employees',
'empCount': 2, '__init__':
<function Employee.__init__ at 0x0124F810>, 'displayEmployee':
<function Employee.displayEmployee at 0x0160D300>,
'__weakref__':
<attribute '__weakref__' of 'Employee' objects>, '__dict__':
<attribute '__dict__' of 'Employee' objects>
}
Objekte zerstören (Garbage Collection)
Python löscht nicht benötigte Objekte (integrierte Typen oder Klasseninstanzen) automatisch, um den Speicherplatz freizugeben. Der Prozess, durch den Python regelmäßig Speicherblöcke zurückfordert, die nicht mehr verwendet werden, 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/python3
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, wird das folgende Ergebnis erzeugt:
140338326963984 140338326963984 140338326963984
Point destroyed
Note- Idealerweise sollten Sie Ihre Klassen in einer separaten Datei definieren und sie dann mithilfe der import- Anweisung in Ihre Hauptprogrammdatei importieren .
Im obigen Beispiel ist die Annahme, dass die Definition einer Point-Klasse in point.py enthalten ist und kein anderer ausführbarer Code darin enthalten ist.
#!/usr/bin/python3
import point
p1 = point.Point()
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/python3
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 calss 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 Methoden der Eltern ist, dass Sie möglicherweise spezielle oder andere Funktionen in Ihrer Unterklasse wünschen.
Beispiel
#!/usr/bin/python3
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/python3
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/python3
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. Dasre Modul löst die Ausnahme aus re.error 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. Dennoch 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'.
Grundmuster, die mit einzelnen Zeichen übereinstimmen
Sr.Nr. | Ausdruck & Übereinstimmungen |
---|---|
1 | a, X, 9, < gewöhnliche Charaktere passen einfach genau zu sich. |
2 | . (a period) stimmt mit einem einzelnen Zeichen außer der Zeilenumbruch '\ n' überein. |
3 | \w entspricht einem "Wort" -Zeichen: einem Buchstaben oder einer Ziffer oder einem Unterstrich [a-zA-Z0-9_]. |
4 | \W Entspricht einem beliebigen Nicht-Wort-Zeichen. |
5 | \b Grenze zwischen Wort und Nichtwort |
6 | \s Entspricht einem einzelnen Leerzeichen - Leerzeichen, Zeilenumbruch, Rückgabe, Tabulator |
7 | \S Entspricht einem Nicht-Leerzeichen. |
8 | \t, \n, \r Tab, Newline, Return |
9 | \d Dezimalstelle [0-9] |
10 | ^ stimmt mit dem Anfang der Zeichenfolge überein |
11 | $ Passen Sie das Ende der Zeichenfolge an |
12 | \ hemmen die "Besonderheit" eines Charakters. |
Kompilierungsflags
Mit Kompilierungsflags können Sie einige Aspekte der Funktionsweise regulärer Ausdrücke ändern. Flags sind im re-Modul unter zwei Namen verfügbar, einem langen Namen wie zIGNORECASE und eine kurze Ein-Buchstaben-Form wie I.
Sr.Nr. | Flagge & Bedeutung |
---|---|
1 | ASCII, A Lässt mehrere Escapezeichen wie \ w, \ b, \ s und \ d nur für ASCII-Zeichen mit der jeweiligen Eigenschaft übereinstimmen. |
2 | DOTALL, S Machen Sie, passen Sie jedes Zeichen an, einschließlich Zeilenumbrüche |
3 | IGNORECASE, I Führen Sie Übereinstimmungen ohne Berücksichtigung der Groß- und Kleinschreibung durch |
4 | LOCALE, L Führen Sie ein Gebietsschema-fähiges Match durch |
5 | MULTILINE, M Mehrzeiliger Abgleich, der sich auf ^ und $ auswirkt |
6 | VERBOSE, X (for ‘extended’) Aktivieren Sie ausführliche REs, die übersichtlicher und verständlicher organisiert werden können |
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/python3
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, wird das folgende Ergebnis erzeugt:
matchObj.group() : Cats are smarter than dogs
matchObj.group(1) : Cats
matchObj.group(2) : smarter
Die Suchfunktion
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 den ü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/python3
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, wird das folgende Ergebnis erzeugt:
matchObj.group() : Cats are smarter than dogs
matchObj.group(1) : Cats
matchObj.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/python3
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 --> matchObj.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 ist. Diese Methode gibt eine geänderte Zeichenfolge zurück.
Beispiel
#!/usr/bin/python3
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 der Steuerzeichen (+ ? . * ^ $ ( ) [ ] { } | \)Alle Charaktere stimmen überein. Sie können einem Steuerzeichen entkommen, indem Sie ihm einen Backslash voranstellen.
In der folgenden Tabelle ist die in Python verfügbare Syntax für reguläre Ausdrücke aufgeführt.
Sr.Nr. | Parameter & 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 Nicht-Wortgrenzen. |
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 Word - First CGI Program</title>')
print ('</head>')
print ('<body>')
print ('<h2>Hello Word! This is my first CGI program</h2>')
print ('</body>')
print ('</html>')
Note- Die erste Zeile im Skript muss der Pfad zur ausführbaren Python-Datei sein. Unter Linux sollte es #! / Usr / bin / python3 sein
Geben Sie die folgende URL in Ihren Browser ein
http://localhost:8080/cgi-bin/hello.py
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=ALIDrunter 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
- SQLite
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
Python bietet eine integrierte Unterstützung für SQLite. In diesem Abschnitt lernen wir alle Konzepte mit MySQL kennen. Das MySQLdb-Modul, eine beliebte Schnittstelle zu MySQL, ist nicht mit Python 3 kompatibel. Stattdessen verwenden wir das PyMySQL- Modul.
Was ist PyMySQL?
PyMySQL ist eine Schnittstelle zum Herstellen einer Verbindung zu einem MySQL-Datenbankserver von Python. Es implementiert die Python-Datenbank-API v2.0 und enthält eine reine Python-MySQL-Clientbibliothek. Das Ziel von PyMySQL ist es, MySQLdb zu ersetzen.
Wie installiere ich PyMySQL?
Bevor Sie fortfahren, stellen Sie sicher, dass PyMySQL auf Ihrem Computer installiert ist. Geben Sie einfach Folgendes in Ihr Python-Skript ein und führen Sie es aus:
#!/usr/bin/python3
import pymysql
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 pymysql
ImportError: No module named pymysql
Die letzte stabile Version ist auf PyPI verfügbar und kann mit pip - installiert werden.
pip install pymysql
Alternativ (z. B. wenn pip nicht verfügbar ist) kann ein Tarball von GitHub heruntergeladen und wie folgt mit Setuptools installiert werden:
$ # X.X is the desired pymysql version (e.g. 0.5 or 0.6).
$ curl -L https://github.com/PyMySQL/PyMySQL/tarball/pymysql-X.X | tar xz $ cd PyMySQL*
$ python setup.py install $ # The folder PyMySQL* can be safely removed now.
Note - Stellen Sie sicher, dass Sie über Root-Rechte verfügen, um das oben genannte Modul zu installieren.
Datenbankverbindung
Stellen Sie vor dem Herstellen einer Verbindung zu einer MySQL-Datenbank die folgenden Punkte 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 PyMySQL ist ordnungsgemäß auf Ihrem Computer installiert.
Sie haben das MySQL-Tutorial durchgearbeitet, um die MySQL-Grundlagen zu verstehen .
Beispiel
Es folgt ein Beispiel für die Verbindung mit der MySQL-Datenbank "TESTDB" -
#!/usr/bin/python3
import pymysql
# Open database connection
db = pymysql.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()
Beim Ausführen dieses Skripts wird das folgende Ergebnis erzielt.
Database version : 5.5.20-log
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 eine Datenbanktabelle erstellen. MITARBEITER -
#!/usr/bin/python3
import pymysql
# Open database connection
db = pymysql.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
Die INSERT-Operation 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 Tabelle EMPLOYEE zu erstellen.
#!/usr/bin/python3
import pymysql
# Open database connection
db = pymysql.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/python3
import pymysql
# Open database connection
db = pymysql.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 die 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/python3
import pymysql
# Open database connection
db = pymysql.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 = "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 fetch data")
# disconnect from server
db.close()
Ausgabe
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/python3
import pymysql
# Open database connection
db = pymysql.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/python3
import pymysql
# Open database connection
db = pymysql.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 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 eine 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, um das aufzurufen 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 die rollback() Methode.
Hier ist ein einfaches Beispiel, um das aufzurufen 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 die 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 erhalten Sie einen Einblick in 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 -
|
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 Sockelmodul
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.
Rufen Sie jetzt die 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/python3 # This is server.py file
import socket
# create a socket object
serversocket = socket.socket(
socket.AF_INET, socket.SOCK_STREAM)
# get local machine name
host = socket.gethostname()
port = 9999
# bind to the port
serversocket.bind((host, port))
# queue up to 5 requests
serversocket.listen(5)
while True:
# establish a connection
clientsocket,addr = serversocket.accept()
print("Got a connection from %s" % str(addr))
msg = 'Thank you for connecting'+ "\r\n"
clientsocket.send(msg.encode('ascii'))
clientsocket.close()
Ein einfacher Client
Schreiben wir ein sehr einfaches Client-Programm, das eine Verbindung zu einem bestimmten Port 12345 und einem bestimmten Host herstellt. Es ist sehr einfach, 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.
Beispiel
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/python3 # This is client.py file
import socket
# create a socket object
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# get local machine name
host = socket.gethostname()
port = 9999
# connection to hostname on the port.
s.connect((host, port))
# Receive no more than 1024 bytes
msg = s.recv(1024)
s.close()
print (msg.decode('ascii'))
Führen Sie nun diese server.py im Hintergrund aus und führen Sie dann die obige 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
Ausgabe
Dies würde folgendes Ergebnis liefern -
on server terminal
Got a connection from ('192.168.1.10', 3747)
On client terminal
Thank you for connecting
Python-Internetmodule
Eine Liste einiger wichtiger Module in der Python-Netzwerk- / Internet-Programmierung finden Sie unten -
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 einer E-Mail und das Weiterleiten von E-Mails zwischen Mailservern übernimmt.
Python bietet smtplib Modul, das ein SMTP-Client-Sitzungsobjekt definiert, mit dem E-Mails an jeden Internetcomputer mit einem SMTP- oder ESMTP-Listener-Daemon 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 nur localhost als Option 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/python3
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 ein 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 . Verwenden Sie dann die sendmail- Methode zusammen mit der Nachricht, der Absenderadresse und der Zieladresse als Parameter (obwohl sich die Absender- und Absenderadressen in der E-Mail selbst befinden, werden diese nicht immer zum Weiterleiten der E-Mail verwendet).
Wenn Sie auf Ihrem lokalen Computer keinen SMTP-Server ausführen , können Sie den smtplib- Client verwenden, um mit einem Remote-SMTP-Server zu kommunizieren. Sofern Sie keinen Webmail-Dienst (wie Google Mail 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:
mail = smtplib.SMTP('smtp.gmail.com', 587)
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 Option, 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 den Zeichensatz zum Senden einer HTML-E-Mail angeben.
Beispiel
Im Folgenden finden Sie ein Beispiel zum Senden des HTML-Inhalts als E-Mail. Probieren Sie es einmal aus -
#!/usr/bin/python3
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, müssen Sie die Option festlegen Content-type Header zu multipart/mixed. Anschließend können der Text und die 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.
Die angehängten Dateien sollten mit dem verschlüsselt werden pack("m") Funktion, um vor der Übertragung eine Base 64-Codierung zu haben.
Beispiel
Es folgt ein Beispiel, das eine Datei sendet /tmp/test.txtals Anhang. Probieren Sie es einmal aus -
#!/usr/bin/python3
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.
Es gibt zwei verschiedene Arten von Threads -
- Kernel-Thread
- Benutzer-Thread
Kernel-Threads sind Teil des Betriebssystems, während die User-Space-Threads nicht im Kernel implementiert sind.
Es gibt zwei Module, die die Verwendung von Threads in Python3 unterstützen -
- _thread
- threading
Das Thread-Modul ist seit geraumer Zeit "veraltet". Benutzer werden aufgefordert, stattdessen das Threading-Modul zu verwenden. Daher ist in Python 3 das Modul "Thread" nicht mehr verfügbar. Aus Gründen der Abwärtskompatibilität in Python3 wurde es jedoch in "_thread" umbenannt.
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/python3
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
Ausgabe
Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:
Thread-1: Fri Feb 19 09:41:39 2016
Thread-2: Fri Feb 19 09:41:41 2016
Thread-1: Fri Feb 19 09:41:41 2016
Thread-1: Fri Feb 19 09:41:43 2016
Thread-2: Fri Feb 19 09:41:45 2016
Thread-1: Fri Feb 19 09:41:45 2016
Thread-1: Fri Feb 19 09:41:47 2016
Thread-2: Fri Feb 19 09:41:49 2016
Thread-2: Fri Feb 19 09:41:53 2016
Das Programm läuft in einer Endlosschleife. Sie müssen Strg-C drücken, um zu stoppen
Obwohl es für Threading auf niedriger Ebene sehr effektiv ist, ist das Thread- Modul 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 run () -Methode aufruft .
Beispiel
#!/usr/bin/python3
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, delay, counter):
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()
thread1.join()
thread2.join()
print ("Exiting Main Thread")
Ergebnis
Wenn wir das obige Programm ausführen, wird das folgende Ergebnis erzeugt:
Starting Thread-1
Starting Thread-2
Thread-1: Fri Feb 19 10:00:21 2016
Thread-2: Fri Feb 19 10:00:22 2016
Thread-1: Fri Feb 19 10:00:22 2016
Thread-1: Fri Feb 19 10:00:23 2016
Thread-2: Fri Feb 19 10:00:24 2016
Thread-1: Fri Feb 19 10:00:24 2016
Thread-1: Fri Feb 19 10:00:25 2016
Exiting Thread-1
Thread-2: Fri Feb 19 10:00:26 2016
Thread-2: Fri Feb 19 10:00:28 2016
Thread-2: Fri Feb 19 10:00:30 2016
Exiting Thread-2
Exiting Main Thread
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 die 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/python3
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")
Ausgabe
Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:
Starting Thread-1
Starting Thread-2
Thread-1: Fri Feb 19 10:04:14 2016
Thread-1: Fri Feb 19 10:04:15 2016
Thread-1: Fri Feb 19 10:04:16 2016
Thread-2: Fri Feb 19 10:04:18 2016
Thread-2: Fri Feb 19 10:04:20 2016
Thread-2: Fri Feb 19 10:04:22 2016
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/python3
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")
Ausgabe
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 wenn 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 an die 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 sind die Details 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.
Die Analysemethode
Die folgende Methode erstellt einen SAX-Parser und verwendet ihn zum Parsen eines Dokuments.
xml.sax.parse( xmlfile, contenthandler[, errorhandler])
Hier sind die Details 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 sind die Details 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/python3
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")
Ausgabe
Dies würde das folgende Ergebnis erzeugen -
*****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 scientific 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, ein XML-Dokument schnell zu laden und mit dem Modul xml.dom ein Minidom-Objekt 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 durch die Datei angegebene XML-Datei in ein DOM-Baumobjekt zu analysieren.
Beispiel
#!/usr/bin/python3
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)
Ausgabe
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 scientific 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 Funktionen 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-Oberfläche für das wxWidgets-GUI-Toolkit. Ein vollständiges Tutorial zu WxPython finden Sie hier .
PyQt−Dies ist auch eine Python-Schnittstelle für eine beliebte plattformübergreifende Qt-GUI-Bibliothek. TutorialsPoint hat ein sehr gutes Tutorial auf PyQt hier .
JPython - JPython ist ein Python-Port für Java, über den Python-Skripte nahtlos auf die 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/python3
import tkinter # note that module name has changed from Tkinter in Python 2 to tkinter in Python 3
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. |
Standardattribute
Schauen wir uns an, wie einige ihrer gemeinsamen Attribute wie Größen, Farben und Schriftarten angegeben werden.
Dimensions
Colors
Fonts
Anchors
Relief styles
Bitmaps
Cursors
Geometry Management
All Tkinter widgets have access to the specific geometry management methods, which have the purpose of organizing widgets throughout the parent widget area. Tkinter exposes the following geometry manager classes: pack, grid, and place.
The pack() Method − This geometry manager organizes widgets in blocks before placing them in the parent widget.
The grid() Method − This geometry manager organizes widgets in a table-like structure in the parent widget.
The place() Method − This geometry manager organizes widgets by placing them in a specific position in the parent widget.
Any code that you write using any compiled language like C, C++, or Java can be integrated or imported into another Python script. This code is considered as an "extension."
A Python extension module is nothing more than a normal C library. On Unix machines, these libraries usually end in .so (for shared object). On Windows machines, you typically see .dll (for dynamically linked library).
Pre-Requisites for Writing Extensions
To start writing your extension, you are going to need the Python header files.
On Unix machines, this usually requires installing a developer-specific package such as .
Windows users get these headers as part of the package when they use the binary Python installer.
Additionally, it is assumed that you have a good knowledge of C or C++ to write any Python Extension using C programming.
First look at a Python Extension
For your first look at a Python extension module, you need to group your code into four part −
The header file Python.h.
The C functions you want to expose as the interface from your module.
A table mapping the names of your functions as Python developers see them as C functions inside the extension module.
An initialization function.
The Header File Python.h
You need to include Python.h header file in your C source file, which gives you the access to the internal Python API used to hook your module into the interpreter.
Make sure to include Python.h before any other headers you might need. You need to follow the includes with the functions you want to call from Python.
The C Functions
The signatures of the C implementation of your functions always takes one of the following three forms −
static PyObject *MyFunction( PyObject *self, PyObject *args );
static PyObject *MyFunctionWithKeywords(PyObject *self,
PyObject *args,
PyObject *kw);
static PyObject *MyFunctionWithNoArgs( PyObject *self );
Each one of the preceding declarations returns a Python object. There is no such thing as a void function in Python as there is in C. If you do not want your functions to return a value, return the C equivalent of Python's None value. The Python headers define a macro, Py_RETURN_NONE, that does this for us.
The names of your C functions can be whatever you like as they are never seen outside of the extension module. They are defined as static function.
Your C functions usually are named by combining the Python module and function names together, as shown here −
static PyObject *module_func(PyObject *self, PyObject *args) {
/* Do your stuff here. */
Py_RETURN_NONE;
}
This is a Python function called func inside the module module. You will be putting pointers to your C functions into the method table for the module that usually comes next in your source code.
The Method Mapping Table
This method table is a simple array of PyMethodDef structures. That structure looks something like this −
struct PyMethodDef {
char *ml_name;
PyCFunction ml_meth;
int ml_flags;
char *ml_doc;
};
Here is the description of the members of this structure −
ml_name − This is the name of the function as the Python interpreter presents when it is used in Python programs.
ml_meth − This is the address of a function that has any one of the signatures described in the previous section.
ml_flags − This tells the interpreter which of the three signatures ml_meth is using.
This flag usually has a value of METH_VARARGS.
This flag can be bitwise OR'ed with METH_KEYWORDS if you want to allow keyword arguments into your function.
This can also have a value of METH_NOARGS that indicates you do not want to accept any arguments.
ml_doc − This is the docstring for the function, which could be NULL if you do not feel like writing one.
This table needs to be terminated with a sentinel that consists of NULL and 0 values for the appropriate members.
Example
For the above-defined function, we have the following method mapping table −
static PyMethodDef module_methods[] = {
{ "func", (PyCFunction)module_func, METH_NOARGS, NULL },
{ NULL, NULL, 0, NULL }
};
The Initialization Function
The last part of your extension module is the initialization function. This function is called by the Python interpreter when the module is loaded. It is required that the function be named initModule, where Module is the name of the module.
The initialization function needs to be exported from the library you will be building. The Python headers define PyMODINIT_FUNC to include the appropriate incantations for that to happen for the particular environment in which we are compiling. All you have to do is use it when defining the function.
Your C initialization function generally has the following overall structure −
PyMODINIT_FUNC initModule() {
Py_InitModule3(func, module_methods, "docstring...");
}
Here is the description of Py_InitModule3 function −
func − This is the function to be exported.
module_methods − This is the mapping table name defined above.
docstring − This is the comment you want to give in your extension.
Putting all this together, it looks like the following −
#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...");
}
Example
A simple example that makes use of all the above concepts −
#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!");
}
Here the Py_BuildValue function is used to build a Python value. Save above code in hello.c file. We would see how to compile and install this module to be called from Python script.
Building and Installing Extensions
The distutils package makes it very easy to distribute Python modules, both pure Python and extension modules, in a standard way. Modules are distributed in the source form, built and installed via a setup script usually called setup.py as.
For the above module, you need to prepare the following setup.py script −
from distutils.core import setup, Extension
setup(name = 'helloworld', version = '1.0', \
ext_modules = [Extension('helloworld', ['hello.c'])])
Now, use the following command, which would perform all needed compilation and linking steps, with the right compiler and linker commands and flags, and copies the resulting dynamic library into an appropriate directory −
$ python setup.py install
On Unix-based systems, you will most likely need to run this command as root in order to have permissions to write to the site-packages directory. This usually is not a problem on Windows.
Importing Extensions
Once you install your extensions, you would be able to import and call that extension in your Python script as follows −
Example
#!/usr/bin/python3
import helloworld
print helloworld.helloworld()
Output
This would produce the following result −
Hello, Python extensions!!
Passing Function Parameters
As you will most likely want to define functions that accept arguments, you can use one of the other signatures for your C functions. For example, the following function, that accepts some number of parameters, would be defined like this −
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;
}
Ausgabe
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 die 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 die 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 würde mithilfe einer Liste in Python erfasst.
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 zu einem Zeichenfolgenformat zusammengefügt werden.
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.