Objektorientiertes Python - Kurzanleitung

Programmiersprachen und verschiedene Methoden tauchen ständig auf. Objektorientierte Programmierung ist eine solche Methode, die in den letzten Jahren sehr populär geworden ist.

In diesem Kapitel werden die Funktionen der Programmiersprache Python erläutert, die sie zu einer objektorientierten Programmiersprache machen.

Klassifizierungsschema für die Sprachprogrammierung

Python kann unter objektorientierten Programmiermethoden charakterisiert werden. Das folgende Bild zeigt die Eigenschaften verschiedener Programmiersprachen. Beachten Sie die Funktionen von Python, die es objektorientiert machen.

Langauage Klassen Kategorien Sprachen
Programmierparadigma Verfahren C, C ++, C #, Ziel-C, Java, Los
Skripting CoffeeScript, JavaScript, Python, Perl, PHP, Ruby
Funktionell Clojure, Eralang, Haskell, Scala
Zusammenstellungsklasse Statisch C, C ++, C #, Ziel-C, Java, Go, Haskell, Scala
Dynamisch CoffeeScript, JavaScript, Python, Perl, PHP, Ruby, Clojure, Erlang
Typklasse Stark C #, Java, Go, Python, Rubin, Clojure, Erlang, Haskell, Scala
Schwach C, C ++, C #, Ziel-C, CoffeeScript, JavaScript, Perl, Php
Speicherklasse Gelang es Andere
Nicht verwaltet C, C ++, C #, Ziel-C

Was ist objektorientierte Programmierung?

Object Orientedbedeutet auf Objekte gerichtet. Mit anderen Worten bedeutet dies funktional auf die Modellierung von Objekten gerichtet. Dies ist eine der vielen Techniken, die zur Modellierung komplexer Systeme verwendet werden, indem eine Sammlung interagierender Objekte über ihre Daten und ihr Verhalten beschrieben wird.

Python, eine objektorientierte Programmierung (OOP), ist eine Programmiermethode, die sich auf die Verwendung von Objekten und Klassen zum Entwerfen und Erstellen von Anwendungen konzentriert. Die wichtigsten Säulen der objektorientierten Programmierung (OOP) sind Inheritance, Polymorphism, Abstraction, Anzeige Encapsulation.

Objektorientierte Analyse (OOA) ist der Prozess der Untersuchung eines Problems, Systems oder einer Aufgabe und der Identifizierung der Objekte und Interaktionen zwischen ihnen.

Warum objektorientierte Programmierung wählen?

Python wurde mit einem objektorientierten Ansatz entwickelt. OOP bietet folgende Vorteile:

  • Bietet eine klare Programmstruktur, mit der sich Probleme der realen Welt und ihre Lösungen leicht abbilden lassen.

  • Erleichtert die einfache Wartung und Änderung des vorhandenen Codes.

  • Verbessert die Programmmodularität, da jedes Objekt unabhängig vorhanden ist und neue Funktionen problemlos hinzugefügt werden können, ohne die vorhandenen zu stören.

  • Bietet ein gutes Framework für Codebibliotheken, in dem gelieferte Komponenten vom Programmierer einfach angepasst und geändert werden können.

  • Verbessert die Wiederverwendbarkeit von Code

Prozedurale vs. objektorientierte Programmierung

Die prozedurale Programmierung wird aus der strukturellen Programmierung abgeleitet, die auf den Konzepten von basiert functions/procedure/routines. In der prozedurorientierten Programmierung ist es einfach, auf die Daten zuzugreifen und diese zu ändern. Andererseits ermöglicht die objektorientierte Programmierung (OOP) die Zerlegung eines Problems in eine Anzahl von aufgerufenen Einheitenobjectsund erstellen Sie dann die Daten und Funktionen um diese Objekte. Es konzentriert sich mehr auf die Daten als auf Prozeduren oder Funktionen. Auch in OOP sind Daten ausgeblendet und können nicht durch externe Prozeduren abgerufen werden.

Die Tabelle im folgenden Bild zeigt die Hauptunterschiede zwischen POP- und OOP-Ansatz.

Unterschied zwischen prozedural orientierter Programmierung (POP) vs. Objektorientierte Programmierung (OOP).

Verfahrensorientierte Programmierung Objekt orientierte Programmierung
Beyogen auf In Pop liegt der gesamte Fokus auf Daten und Funktionen Hoppla basiert auf einem realen Szenario. Das gesamte Programm ist in kleine Teile unterteilt, die als Objekt bezeichnet werden
Wiederverwendbarkeit Begrenzte Wiederverwendung von Code Wiederverwendung von Code
Ansatz Top-down-Ansatz Objektorientiertes Design
Zugriffsspezifizierer Keine Öffentlich, privat und geschützt
Datenbewegung Daten können sich frei von Funktionen zu Funktionen im System bewegen In Ups können Daten über Mitgliedsfunktionen verschoben und miteinander kommuniziert werden
Datenzugriff In Pop verwenden die meisten Funktionen globale Daten für die Freigabe, auf die von Funktion zu Funktion im System frei zugegriffen werden kann In Ups können Daten nicht frei von Methode zu Methode verschoben werden. Sie können öffentlich oder privat aufbewahrt werden, damit wir den Zugriff auf Daten steuern können
Ausblenden von Daten In Pop, so spezielle Art, Daten zu verbergen, so ein bisschen weniger sicher Es bietet Daten versteckt, so viel sicherer
Überlastung Nicht möglich Funktionen und Überlastung des Bedieners
Beispielsprachen C, VB, Fortran, Pascal C ++, Python, Java, C #
Abstraktion Verwendet Abstraktion auf Prozedurebene Verwendet Abstraktion auf Klassen- und Objektebene

Prinzipien der objektorientierten Programmierung

Die objektorientierte Programmierung (OOP) basiert auf dem Konzept von objects eher als Aktionen, und dataeher als Logik. Damit eine Programmiersprache objektorientiert ist, sollte sie über einen Mechanismus verfügen, der das Arbeiten mit Klassen und Objekten sowie die Implementierung und Verwendung der grundlegenden objektorientierten Prinzipien und Konzepte ermöglicht, nämlich Vererbung, Abstraktion, Kapselung und Polymorphismus.

Lassen Sie uns kurz jede der Säulen der objektorientierten Programmierung verstehen -

Verkapselung

Diese Eigenschaft verbirgt unnötige Details und erleichtert die Verwaltung der Programmstruktur. Die Implementierung und der Status jedes Objekts sind hinter genau definierten Grenzen verborgen und bieten eine saubere und einfache Schnittstelle für die Arbeit mit ihnen. Eine Möglichkeit, dies zu erreichen, besteht darin, die Daten privat zu machen.

Erbe

Die Vererbung, auch Generalisierung genannt, ermöglicht es uns, eine hierarchische Beziehung zwischen Klassen und Objekten zu erfassen. Zum Beispiel ist eine "Frucht" eine Verallgemeinerung von "Orange". Vererbung ist aus Sicht der Wiederverwendung von Code sehr nützlich.

Abstraktion

Diese Eigenschaft ermöglicht es uns, die Details auszublenden und nur die wesentlichen Merkmale eines Konzepts oder Objekts freizulegen. Zum Beispiel weiß eine Person, die einen Roller fährt, dass beim Drücken einer Hupe ein Ton ausgegeben wird, aber sie hat keine Ahnung, wie der Ton beim Drücken der Hupe tatsächlich erzeugt wird.

Polymorphismus

Polymorphismus bedeutet viele Formen. Das heißt, eine Sache oder Handlung ist auf verschiedene Formen oder Arten vorhanden. Ein gutes Beispiel für Polymorphismus ist die Überladung von Konstruktoren in Klassen.

Objektorientiertes Python

Das Herzstück der Python-Programmierung ist object und OOPSie müssen sich jedoch nicht darauf beschränken, die OOP zu verwenden, indem Sie Ihren Code in Klassen organisieren. OOP ergänzt die gesamte Designphilosophie von Python und fördert eine saubere und pragmatische Art der Programmierung. OOP ermöglicht auch das Schreiben größerer und komplexer Programme.

Module vs. Klassen und Objekte

Module sind wie "Wörterbücher"

Beachten Sie bei der Arbeit an Modulen die folgenden Punkte:

  • Ein Python-Modul ist ein Paket zum Einkapseln von wiederverwendbarem Code.

  • Module befinden sich in einem Ordner mit einem __init__.py Datei darauf.

  • Module enthalten Funktionen und Klassen.

  • Module werden mit dem importiert import Stichwort.

Denken Sie daran, dass ein Wörterbuch ein ist key-valuePaar. Das heißt, wenn Sie ein Wörterbuch mit einem Schlüssel habenEmployeID und wenn Sie es abrufen möchten, müssen Sie die folgenden Codezeilen verwenden:

employee = {“EmployeID”: “Employee Unique Identity!”}
print (employee [‘EmployeID])

Sie müssen an Modulen mit dem folgenden Prozess arbeiten -

  • Ein Modul ist eine Python-Datei mit einigen Funktionen oder Variablen.

  • Importieren Sie die gewünschte Datei.

  • Jetzt können Sie mit dem '.' Auf die Funktionen oder Variablen in diesem Modul zugreifen. (dot) Operator.

Betrachten Sie ein Modul mit dem Namen employee.py mit einer Funktion darin aufgerufen employee. Der Code der Funktion ist unten angegeben -

# this goes in employee.py
def EmployeID():
   print (“Employee Unique Identity!”)

Importieren Sie nun das Modul und greifen Sie auf die Funktion zu EmployeID - -

import employee
employee. EmployeID()

Sie können eine Variable mit dem Namen einfügen Age, wie gezeigt -

def EmployeID():
   print (“Employee Unique Identity!”)
# just a variable
Age = “Employee age is **”

Greifen Sie nun wie folgt auf diese Variable zu:

import employee
employee.EmployeID()
print(employee.Age)

Vergleichen wir dies jetzt mit dem Wörterbuch -

Employee[‘EmployeID’] # get EmployeID from employee
Employee.employeID() # get employeID from the module
Employee.Age # get access to variable

Beachten Sie, dass es in Python ein allgemeines Muster gibt -

  • Nehmen Sie eine key = value Stil Container

  • Holen Sie sich etwas daraus mit dem Namen des Schlüssels

Beim Vergleichen des Moduls mit einem Wörterbuch sind beide ähnlich, mit Ausnahme der folgenden:

  • Im Falle der dictionaryist der Schlüssel eine Zeichenfolge und die Syntax ist [Schlüssel].

  • Im Falle der moduleDer Schlüssel ist ein Bezeichner und die Syntax lautet .key.

Klassen sind wie Module

Das Modul ist ein spezielles Wörterbuch, in dem Python-Code gespeichert werden kann, sodass Sie mit dem '.' Operator. Eine Klasse ist eine Möglichkeit, eine Gruppierung von Funktionen und Daten in einen Container zu legen, damit Sie mit dem Operator '.''auf sie zugreifen können.

Wenn Sie eine Klasse erstellen müssen, die dem Mitarbeitermodul ähnelt, können Sie dies mit dem folgenden Code tun:

class employee(object):
   def __init__(self):
      self. Age = “Employee Age is ##”
   def EmployeID(self):
      print (“This is just employee unique identity”)

Note- Klassen werden Modulen vorgezogen, da Sie sie unverändert und ohne große Störungen wiederverwenden können. Während Sie mit Modulen arbeiten, haben Sie nur eines mit dem gesamten Programm.

Objekte sind wie Mini-Importe

Eine Klasse ist wie eine mini-module und Sie können auf ähnliche Weise wie für Klassen importieren, indem Sie das aufgerufene Konzept verwenden instantiate. Beachten Sie, dass Sie beim Instanziieren einer Klasse eine erhaltenobject.

Sie können ein Objekt instanziieren, ähnlich wie beim Aufrufen einer Klasse wie einer Funktion.

this_obj = employee() # Instantiatethis_obj.EmployeID() # get EmployeId from the class
print(this_obj.Age) # get variable Age

Sie können dies auf eine der folgenden drei Arten tun:

# dictionary style
Employee[‘EmployeID’]
# module style
Employee.EmployeID()
Print(employee.Age)
# Class style
this_obj = employee()
this_obj.employeID()
Print(this_obj.Age)

In diesem Kapitel wird das Einrichten der Python-Umgebung auf Ihrem lokalen Computer ausführlich erläutert.

Voraussetzungen und Toolkits

Bevor Sie mit Python fortfahren, empfehlen wir Ihnen zu überprüfen, ob die folgenden Voraussetzungen erfüllt sind:

  • Die neueste Version von Python ist auf Ihrem Computer installiert

  • Eine IDE oder ein Texteditor ist installiert

  • Sie sind mit dem Schreiben und Debuggen in Python vertraut, dh Sie können in Python Folgendes tun:

    • Kann Python-Programme schreiben und ausführen.

    • Debuggen Sie Programme und diagnostizieren Sie Fehler.

    • Arbeiten Sie mit grundlegenden Datentypen.

    • Schreiben for Schleifen, while Schleifen und if Aussagen

    • Code functions

Wenn Sie keine Programmiersprachenerfahrung haben, finden Sie in Python viele Anfänger-Tutorials

https://www.tutorialpoints.com/

Python installieren

Die folgenden Schritte zeigen Ihnen ausführlich, wie Sie Python auf Ihrem lokalen Computer installieren.

Step 1 - Gehen Sie zur offiziellen Python-Website https://www.python.org/, Klick auf das Downloads Menü und wählen Sie die neueste oder eine stabile Version Ihrer Wahl.

Step 2- Speichern Sie die heruntergeladene Python-Installations-Exe-Datei und öffnen Sie sie, sobald Sie sie heruntergeladen haben. Klicke aufRun und wähle Next Option standardmäßig und beenden Sie die Installation.

Step 3- Nach der Installation sollte nun das Python-Menü angezeigt werden (siehe Abbildung unten). Starten Sie das Programm, indem Sie IDLE (Python GUI) wählen.

Dadurch wird die Python-Shell gestartet. Geben Sie einfache Befehle ein, um die Installation zu überprüfen.

IDE auswählen

Eine integrierte Entwicklungsumgebung ist ein Texteditor, der auf die Softwareentwicklung ausgerichtet ist. Sie müssen eine IDE installieren, um den Ablauf Ihrer Programmierung zu steuern und Projekte zu gruppieren, wenn Sie an Python arbeiten. Hier sind einige der online verfügbaren IDEs. Sie können eine nach Belieben auswählen.

  • Pycharm IDE
  • Komodo IDE
  • Eric Python IDE

Note - Eclipse IDE wird hauptsächlich in Java verwendet, verfügt jedoch über ein Python-Plugin.

Pycharm

Pycharm, die plattformübergreifende IDE, ist eine der beliebtesten derzeit verfügbaren IDE. Es bietet Codierungsunterstützung und -analyse mit Code-Vervollständigung, Projekt- und Code-Navigation, integrierten Komponententests, Integration der Versionskontrolle, Debugging und vielem mehr

Download-Link

https://www.jetbrains.com/pycharm/download/#section=windows

Languages Supported - Python, HTML, CSS, JavaScript, Kaffeeskript, TypeScript, Cython, AngularJS, Node.js, Vorlagensprachen.

Bildschirmfoto

Warum wählen?

PyCharm bietet seinen Benutzern die folgenden Funktionen und Vorteile:

  • Plattformübergreifende IDE, kompatibel mit Windows, Linux und Mac OS
  • Beinhaltet Django IDE sowie CSS- und JavaScript-Unterstützung
  • Enthält Tausende von Plugins, integriertes Terminal und Versionskontrolle
  • Integriert in Git, SVN und Mercurial
  • Bietet intelligente Bearbeitungswerkzeuge für Python
  • Einfache Integration mit Virtualenv, Docker und Vagrant
  • Einfache Navigations- und Suchfunktionen
  • Code-Analyse und Refactoring
  • Konfigurierbare Injektionen
  • Unterstützt Tonnen von Python-Bibliotheken
  • Enthält Vorlagen und JavaScript-Debugger
  • Beinhaltet Python / Django-Debugger
  • Funktioniert mit Google App Engine, zusätzlichen Frameworks und Bibliotheken.
  • Verfügt über eine anpassbare Benutzeroberfläche und eine VIM-Emulation

Komodo IDE

Es ist eine polyglotte IDE, die mehr als 100 Sprachen unterstützt und im Wesentlichen für dynamische Sprachen wie Python, PHP und Ruby. Es handelt sich um eine kommerzielle IDE, die 21 Tage lang kostenlos mit voller Funktionalität getestet werden kann. ActiveState ist das Softwareunternehmen, das die Entwicklung der Komodo-IDE verwaltet. Es bietet auch eine gekürzte Version von Komodo, bekannt als Komodo Edit, für einfache Programmieraufgaben.

Diese IDE enthält alle Arten von Funktionen, von den einfachsten bis zu den fortgeschrittensten. Wenn Sie Student oder Freiberufler sind, können Sie es fast die Hälfte des tatsächlichen Preises kaufen. Es ist jedoch für Lehrer und Professoren anerkannter Institutionen und Universitäten völlig kostenlos.

Es verfügt über alle Funktionen, die Sie für die Web- und Mobilentwicklung benötigen, einschließlich der Unterstützung aller Ihrer Sprachen und Frameworks.

Download-Link

Die Download-Links für Komodo Edit (kostenlose Version) und Komodo IDE (kostenpflichtige Version) sind hier angegeben -

Komodo Edit (free)

https://www.activestate.com/komodo-edit

Komodo IDE (paid)

https://www.activestate.com/komodo-ide/downloads/ide

Bildschirmfoto

Warum wählen?

  • Leistungsstarke IDE mit Unterstützung für Perl, PHP, Python, Ruby und viele mehr.
  • Plattformübergreifende IDE.

Es enthält grundlegende Funktionen wie integrierte Debugger-Unterstützung, automatische Vervollständigung, DOM-Viewer (Document Object Model), Code-Browser, interaktive Shells, Haltepunktkonfiguration, Code-Profilerstellung und integrierte Komponententests. Kurz gesagt, es handelt sich um eine professionelle IDE mit einer Vielzahl produktivitätssteigernder Funktionen.

Eric Python IDE

Es ist eine Open-Source-IDE für Python und Ruby. Eric ist ein voll ausgestatteter Editor und eine IDE, die in Python geschrieben wurden. Es basiert auf dem plattformübergreifenden Qt-GUI-Toolkit, das die hochflexible Steuerung des Scintilla-Editors integriert. Die IDE ist sehr konfigurierbar und man kann wählen, was verwendet werden soll und was nicht. Sie können Eric IDE unter folgendem Link herunterladen:

https://eric-ide.python-projects.org/eric-download.html

Warum wählen?

  • Großartige Einrückung, Fehlerhervorhebung.
  • Code-Unterstützung
  • Code-Vervollständigung
  • Codebereinigung mit PyLint
  • Schnelle Suche
  • Integrierter Python-Debugger.

Bildschirmfoto

Texteditor auswählen

Möglicherweise benötigen Sie nicht immer eine IDE. Für Aufgaben wie das Erlernen des Codierens mit Python oder Arduino oder wenn Sie an einem schnellen Skript im Shell-Skript arbeiten, um einige Aufgaben zu automatisieren, ist ein einfacher und leichter Code-zentrierter Texteditor geeignet. Viele Texteditoren bieten ähnlich wie IDEs Funktionen wie Syntaxhervorhebung und programminterne Skriptausführung. Einige der Texteditoren sind hier angegeben -

  • Atom
  • Erhabener Text
  • Notepad++

Atom Text Editor

Atom ist ein hackbarer Texteditor, der vom Team von GitHub erstellt wurde. Es ist ein kostenloser und Open-Source-Text- und Code-Editor, der bedeutet, dass Sie den gesamten Code lesen, für Ihren eigenen Gebrauch ändern und sogar Verbesserungen beitragen können. Es ist ein plattformübergreifender Texteditor, der mit macOS, Linux und Microsoft Windows kompatibel ist und Plug-Ins unterstützt, die in Node.js und Embedded Git Control geschrieben sind.

Download-Link

https://atom.io/

Bildschirmfoto

Unterstützte Sprachen

C / C ++, C #, CSS, CoffeeScript, HTML, JavaScript, Java, JSON, Julia, Objective-C, PHP, Perl, Python, Ruby on Rails, Ruby, Shell-Skript, Scala, SQL, XML, YAML und viele mehr.

Erhabener Texteditor

Sublime Text ist eine proprietäre Software und bietet Ihnen eine kostenlose Testversion, um sie vor dem Kauf zu testen. Laut stackoverflow.com ist es die viertbeliebteste Entwicklungsumgebung.

Einige der Vorteile sind die unglaubliche Geschwindigkeit, Benutzerfreundlichkeit und Community-Unterstützung. Es unterstützt auch viele Programmiersprachen und Auszeichnungssprachen, und Benutzer können Funktionen mit Plugins hinzufügen, die normalerweise von der Community erstellt und unter Lizenzen für freie Software verwaltet werden.

Bildschirmfoto

Sprache unterstützt

  • Python, Ruby, JavaScript usw.

Warum wählen?

  • Passen Sie Tastenkombinationen, Menüs, Snippets, Makros, Vervollständigungen und mehr an.

  • Funktion zur automatischen Vervollständigung

  • Fügen Sie mithilfe von Snippets, Feldmarkierungen und Platzhaltern schnell Text und Code mit erhabenen Textausschnitten ein
  • Öffnet sich schnell

  • Plattformübergreifende Unterstützung für Mac, Linux und Windows.

  • Bewegen Sie den Cursor dorthin, wo Sie hin möchten

  • Wählen Sie Mehrere Zeilen, Wörter und Spalten

Editor ++

Es ist ein kostenloser Quellcode-Editor und Notepad-Ersatz, der mehrere Sprachen von Assembly bis XML und einschließlich Python unterstützt. Die Verwendung in der MS Windows-Umgebung unterliegt der GPL-Lizenz. Zusätzlich zur Syntaxhervorhebung verfügt Notepad ++ über einige Funktionen, die für Codierer besonders nützlich sind.

Bildschirmfoto

Hauptmerkmale

  • Syntaxhervorhebung und Syntaxfaltung
  • PCRE (Perl Compatible Regular Expression) Suchen / Ersetzen
  • Vollständig anpassbare GUI
  • SAuto Fertigstellung
  • Bearbeitung mit Registerkarten
  • Multi-View
  • Mehrsprachige Umgebung
  • Startbar mit verschiedenen Argumenten

Sprachunterstützung

  • Fast jede Sprache (über 60 Sprachen) wie Python, C, C ++, C #, Java usw.

Python-Datenstrukturen sind aus syntaktischer Sicht sehr intuitiv und bieten eine große Auswahl an Operationen. Sie müssen die Python-Datenstruktur auswählen, je nachdem, was die Daten beinhalten, ob sie geändert werden müssen oder ob es sich um feste Daten handelt und welcher Zugriffstyp erforderlich ist, z. B. am Anfang / Ende / Zufall usw.

Listen

Eine Liste repräsentiert den vielseitigsten Typ von Datenstruktur in Python. Eine Liste ist ein Container, der durch Kommas getrennte Werte (Elemente oder Elemente) in eckigen Klammern enthält. Listen sind hilfreich, wenn wir mit mehreren verwandten Werten arbeiten möchten. Da Listen Daten zusammenhalten, können wir dieselben Methoden und Operationen für mehrere Werte gleichzeitig ausführen. Listenindizes beginnen bei Null und im Gegensatz zu Zeichenfolgen sind Listen veränderbar.

Datenstruktur - Liste

>>>
>>> # Any Empty List
>>> empty_list = []
>>>
>>> # A list of String
>>> str_list = ['Life', 'Is', 'Beautiful']
>>> # A list of Integers
>>> int_list = [1, 4, 5, 9, 18]
>>>
>>> #Mixed items list
>>> mixed_list = ['This', 9, 'is', 18, 45.9, 'a', 54, 'mixed', 99, 'list']
>>> # To print the list
>>>
>>> print(empty_list)
[]
>>> print(str_list)
['Life', 'Is', 'Beautiful']
>>> print(type(str_list))
<class 'list'>
>>> print(int_list)
[1, 4, 5, 9, 18]
>>> print(mixed_list)
['This', 9, 'is', 18, 45.9, 'a', 54, 'mixed', 99, 'list']

Zugriff auf Elemente in der Python-Liste

Jedem Element einer Liste wird eine Nummer zugewiesen - das ist der Index oder die Position dieser Nummer. Die Indexierung beginnt immer bei Null, der zweite Index ist Eins und so weiter. Um auf Elemente in einer Liste zuzugreifen, können wir diese Indexnummern in einer eckigen Klammer verwenden. Beachten Sie zum Beispiel den folgenden Code:

>>> mixed_list = ['This', 9, 'is', 18, 45.9, 'a', 54, 'mixed', 99, 'list']
>>>
>>> # To access the First Item of the list
>>> mixed_list[0]
'This'
>>> # To access the 4th item
>>> mixed_list[3]
18
>>> # To access the last item of the list
>>> mixed_list[-1]
'list'

Leere Objekte

Leere Objekte sind die einfachsten und grundlegendsten in Python integrierten Typen. Wir haben sie mehrmals verwendet, ohne es zu bemerken, und sie auf jede von uns erstellte Klasse erweitert. Der Hauptzweck, eine leere Klasse zu schreiben, besteht darin, etwas vorerst zu blockieren und später zu erweitern und ein Verhalten hinzuzufügen.

Ein Verhalten zu einer Klasse hinzuzufügen bedeutet, eine Datenstruktur durch ein Objekt zu ersetzen und alle Verweise darauf zu ändern. Daher ist es wichtig, die Daten zu überprüfen, ob es sich um ein getarntes Objekt handelt, bevor Sie etwas erstellen. Beachten Sie zum besseren Verständnis den folgenden Code:

>>> #Empty objects
>>>
>>> obj = object()
>>> obj.x = 9
Traceback (most recent call last):
File "<pyshell#3>", line 1, in <module>
obj.x = 9
AttributeError: 'object' object has no attribute 'x'

Von oben sehen wir also, dass es nicht möglich ist, Attribute für ein Objekt festzulegen, das direkt instanziiert wurde. Wenn Python zulässt, dass ein Objekt beliebige Attribute hat, benötigt es eine bestimmte Menge an Systemspeicher, um zu verfolgen, welche Attribute jedes Objekt hat, um sowohl den Attributnamen als auch seinen Wert zu speichern. Selbst wenn keine Attribute gespeichert sind, wird eine bestimmte Speichermenge für potenzielle neue Attribute zugewiesen.

Daher deaktiviert Python standardmäßig beliebige Eigenschaften für Objekte und mehrere andere integrierte Funktionen.

>>> # Empty Objects
>>>
>>> class EmpObject:
    pass
>>> obj = EmpObject()
>>> obj.x = 'Hello, World!'
>>> obj.x
'Hello, World!'

Wenn wir also Eigenschaften gruppieren möchten, können wir sie in einem leeren Objekt speichern, wie im obigen Code gezeigt. Diese Methode wird jedoch nicht immer empfohlen. Denken Sie daran, dass Klassen und Objekte nur verwendet werden sollten, wenn Sie sowohl Daten als auch Verhalten angeben möchten.

Tupel

Tupel ähneln Listen und können Elemente speichern. Sie sind jedoch unveränderlich, sodass wir keine Objekte hinzufügen, entfernen oder ersetzen können. Der Hauptvorteil, den Tupel aufgrund seiner Unveränderlichkeit bietet, besteht darin, dass wir sie als Schlüssel in Wörterbüchern oder an anderen Stellen verwenden können, an denen ein Objekt einen Hashwert benötigt.

Tupel werden zum Speichern von Daten und nicht zum Verhalten verwendet. Wenn Sie Verhalten benötigen, um ein Tupel zu manipulieren, müssen Sie das Tupel an eine Funktion (oder Methode für ein anderes Objekt) übergeben, die die Aktion ausführt.

Da Tupel als Wörterbuchschlüssel fungieren kann, unterscheiden sich die gespeicherten Werte voneinander. Wir können ein Tupel erstellen, indem wir die Werte durch ein Komma trennen. Tupel werden in Klammern gesetzt, sind jedoch nicht obligatorisch. Der folgende Code zeigt zwei identische Zuordnungen.

>>> stock1 = 'MSFT', 95.00, 97.45, 92.45
>>> stock2 = ('MSFT', 95.00, 97.45, 92.45)
>>> type (stock1)
<class 'tuple'>
>>> type(stock2)
<class 'tuple'>
>>> stock1 == stock2
True
>>>

Ein Tupel definieren

Tupel sind der Liste sehr ähnlich, außer dass der gesamte Satz von Elementen in Klammern anstatt in eckigen Klammern eingeschlossen ist.

Genau wie beim Schneiden einer Liste erhalten Sie eine neue Liste und beim Schneiden eines Tupels erhalten Sie ein neues Tupel.

>>> tupl = ('Tuple','is', 'an','IMMUTABLE', 'list')
>>> tupl
('Tuple', 'is', 'an', 'IMMUTABLE', 'list')
>>> tupl[0]
'Tuple'
>>> tupl[-1]
'list'
>>> tupl[1:3]
('is', 'an')

Python-Tupel-Methoden

Der folgende Code zeigt die Methoden in Python-Tupeln -

>>> tupl
('Tuple', 'is', 'an', 'IMMUTABLE', 'list')
>>> tupl.append('new')
Traceback (most recent call last):
   File "<pyshell#148>", line 1, in <module>
      tupl.append('new')
AttributeError: 'tuple' object has no attribute 'append'
>>> tupl.remove('is')
Traceback (most recent call last):
   File "<pyshell#149>", line 1, in <module>
      tupl.remove('is')
AttributeError: 'tuple' object has no attribute 'remove'
>>> tupl.index('list')
4
>>> tupl.index('new')
Traceback (most recent call last):
   File "<pyshell#151>", line 1, in <module>
      tupl.index('new')
ValueError: tuple.index(x): x not in tuple
>>> "is" in tupl
True
>>> tupl.count('is')
1

Aus dem oben gezeigten Code können wir verstehen, dass Tupel unveränderlich sind und daher -

  • Sie cannot Fügen Sie einem Tupel Elemente hinzu.

  • Sie cannot eine Methode anhängen oder erweitern.

  • Sie cannot Elemente aus einem Tupel entfernen.

  • Tupel haben no Methode entfernen oder einfügen.

  • Anzahl und Index sind die in einem Tupel verfügbaren Methoden.

Wörterbuch

Dictionary ist einer der in Python integrierten Datentypen und definiert Eins-zu-Eins-Beziehungen zwischen Schlüsseln und Werten.

Wörterbücher definieren

Beachten Sie den folgenden Code, um Informationen zum Definieren eines Wörterbuchs zu erhalten:

>>> # empty dictionary
>>> my_dict = {}
>>>
>>> # dictionary with integer keys
>>> my_dict = { 1:'msft', 2: 'IT'}
>>>
>>> # dictionary with mixed keys
>>> my_dict = {'name': 'Aarav', 1: [ 2, 4, 10]}
>>>
>>> # using built-in function dict()
>>> my_dict = dict({1:'msft', 2:'IT'})
>>>
>>> # From sequence having each item as a pair
>>> my_dict = dict([(1,'msft'), (2,'IT')])
>>>
>>> # Accessing elements of a dictionary
>>> my_dict[1]
'msft'
>>> my_dict[2]
'IT'
>>> my_dict['IT']
Traceback (most recent call last):
   File "<pyshell#177>", line 1, in <module>
   my_dict['IT']
KeyError: 'IT'
>>>

Aus dem obigen Code können wir Folgendes beobachten:

  • Zuerst erstellen wir ein Wörterbuch mit zwei Elementen und weisen es der Variablen zu my_dict. Jedes Element ist ein Schlüssel-Wert-Paar, und der gesamte Satz von Elementen ist in geschweiften Klammern eingeschlossen.

  • Die Nummer 1 ist der Schlüssel und msftist sein Wert. Ähnlich,2 ist der Schlüssel und IT ist sein Wert.

  • Sie können Werte per Schlüssel erhalten, aber nicht umgekehrt. Also wenn wir es versuchenmy_dict[‘IT’] , es löst eine Ausnahme aus, weil IT ist kein Schlüssel.

Wörterbücher ändern

Beachten Sie den folgenden Code, um Informationen zum Ändern eines Wörterbuchs zu erhalten:

>>> # Modifying a Dictionary
>>>
>>> my_dict
{1: 'msft', 2: 'IT'}
>>> my_dict[2] = 'Software'
>>> my_dict
{1: 'msft', 2: 'Software'}
>>>
>>> my_dict[3] = 'Microsoft Technologies'
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies'}

Aus dem obigen Code können wir beobachten, dass -

  • Sie können keine doppelten Schlüssel in einem Wörterbuch haben. Durch Ändern des Werts eines vorhandenen Schlüssels wird der alte Wert gelöscht.

  • Sie können jederzeit neue Schlüssel-Wert-Paare hinzufügen.

  • Wörterbücher haben keinen Ordnungsbegriff zwischen Elementen. Es sind einfache ungeordnete Sammlungen.

Mischen von Datentypen in einem Wörterbuch

Beachten Sie den folgenden Code, um zu verstehen, wie Datentypen in einem Wörterbuch gemischt werden:

>>> # Mixing Data Types in a Dictionary
>>>
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies'}
>>> my_dict[4] = 'Operating System'
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System'}
>>> my_dict['Bill Gates'] = 'Owner'
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System',
'Bill Gates': 'Owner'}

Aus dem obigen Code können wir beobachten, dass -

  • Nicht nur Zeichenfolgen, sondern auch Wörterbuchwerte können von jedem Datentyp sein, einschließlich Zeichenfolgen, Ganzzahlen, einschließlich des Wörterbuchs selbst.

  • Im Gegensatz zu Wörterbuchwerten sind Wörterbuchschlüssel eingeschränkter, können jedoch von einem beliebigen Typ wie Zeichenfolgen, Ganzzahlen oder anderen sein.

Elemente aus Wörterbüchern löschen

Beachten Sie den folgenden Code, um Informationen zum Löschen von Elementen aus einem Wörterbuch zu erhalten:

>>> # Deleting Items from a Dictionary
>>>
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System',
'Bill Gates': 'Owner'}
>>>
>>> del my_dict['Bill Gates']
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System'}
>>>
>>> my_dict.clear()
>>> my_dict
{}

Aus dem obigen Code können wir beobachten, dass -

  • del - Mit dieser Option können Sie einzelne Elemente nach Schlüssel aus einem Wörterbuch löschen.

  • clear - löscht alle Elemente aus einem Wörterbuch.

Sets

Set () ist eine ungeordnete Sammlung ohne doppelte Elemente. Obwohl einzelne Elemente unveränderlich sind, ist das Set selbst veränderlich, dh wir können Elemente / Elemente zum Set hinzufügen oder daraus entfernen. Wir können mathematische Operationen wie Vereinigung, Schnittmenge usw. mit set ausführen.

Obwohl Sets im Allgemeinen mithilfe von Bäumen implementiert werden können, können Sets in Python mithilfe einer Hash-Tabelle implementiert werden. Dies ermöglicht eine hochoptimierte Methode zur Überprüfung, ob ein bestimmtes Element in der Menge enthalten ist

Set erstellen

Ein Set wird erstellt, indem alle Elemente (Elemente) in geschweiften Klammern platziert werden {}, durch Komma oder mithilfe der integrierten Funktion getrennt set(). Beachten Sie die folgenden Codezeilen -

>>> #set of integers
>>> my_set = {1,2,4,8}
>>> print(my_set)
{8, 1, 2, 4}
>>>
>>> #set of mixed datatypes
>>> my_set = {1.0, "Hello World!", (2, 4, 6)}
>>> print(my_set)
{1.0, (2, 4, 6), 'Hello World!'}
>>>

Methoden für Mengen

Beachten Sie den folgenden Code, um die Methoden für Mengen zu verstehen:

>>> >>> #METHODS FOR SETS
>>>
>>> #add(x) Method
>>> topics = {'Python', 'Java', 'C#'}
>>> topics.add('C++')
>>> topics
{'C#', 'C++', 'Java', 'Python'}
>>>
>>> #union(s) Method, returns a union of two set.
>>> topics
{'C#', 'C++', 'Java', 'Python'}
>>> team = {'Developer', 'Content Writer', 'Editor','Tester'}
>>> group = topics.union(team)
>>> group
{'Tester', 'C#', 'Python', 'Editor', 'Developer', 'C++', 'Java', 'Content
Writer'}
>>> # intersets(s) method, returns an intersection of two sets
>>> inters = topics.intersection(team)
>>> inters
set()
>>>
>>> # difference(s) Method, returns a set containing all the elements of
invoking set but not of the second set.
>>>
>>> safe = topics.difference(team)
>>> safe
{'Python', 'C++', 'Java', 'C#'}
>>>
>>> diff = topics.difference(group)
>>> diff
set()
>>> #clear() Method, Empties the whole set.
>>> group.clear()
>>> group
set()
>>>

Operatoren für Sets

Beachten Sie den folgenden Code, um mehr über Operatoren für Mengen zu erfahren:

>>> # PYTHON SET OPERATIONS
>>>
>>> #Creating two sets
>>> set1 = set()
>>> set2 = set()
>>>
>>> # Adding elements to set
>>> for i in range(1,5):
   set1.add(i)
>>> for j in range(4,9):
   set2.add(j)
>>> set1
{1, 2, 3, 4}
>>> set2
{4, 5, 6, 7, 8}
>>>
>>> #Union of set1 and set2
>>> set3 = set1 | set2 # same as set1.union(set2)
>>> print('Union of set1 & set2: set3 = ', set3)
Union of set1 & set2: set3 = {1, 2, 3, 4, 5, 6, 7, 8}
>>>
>>> #Intersection of set1 & set2
>>> set4 = set1 & set2 # same as set1.intersection(set2)
>>> print('Intersection of set1 and set2: set4 = ', set4)
Intersection of set1 and set2: set4 = {4}
>>>
>>> # Checking relation between set3 and set4
>>> if set3 > set4: # set3.issuperset(set4)
   print('Set3 is superset of set4')
elif set3 < set4: #set3.issubset(set4)
   print('Set3 is subset of set4')
else: #set3 == set4
   print('Set 3 is same as set4')
Set3 is superset of set4
>>>
>>> # Difference between set3 and set4
>>> set5 = set3 - set4
>>> print('Elements in set3 and not in set4: set5 = ', set5)
Elements in set3 and not in set4: set5 = {1, 2, 3, 5, 6, 7, 8}
>>>
>>> # Check if set4 and set5 are disjoint sets
>>> if set4.isdisjoint(set5):
   print('Set4 and set5 have nothing in common\n')
Set4 and set5 have nothing in common
>>> # Removing all the values of set5
>>> set5.clear()
>>> set5 set()

In diesem Kapitel werden wir objektorientierte Begriffe und Programmierkonzepte im Detail diskutieren. Die Klasse ist nur eine Fabrik für eine Instanz. Diese Factory enthält den Entwurf, der beschreibt, wie die Instanzen erstellt werden. Eine Instanz oder ein Objekt wird aus der Klasse erstellt. In den meisten Fällen können wir mehr als eine Instanz einer Klasse haben. Jede Instanz verfügt über eine Reihe von Attributen, und diese Attribute werden in einer Klasse definiert. Daher wird erwartet, dass jede Instanz einer bestimmten Klasse dieselben Attribute aufweist.

Klassenbündel: Verhalten und Zustand

Mit einer Klasse können Sie das Verhalten und den Status eines Objekts bündeln. Beachten Sie zum besseren Verständnis das folgende Diagramm -

Die folgenden Punkte sind bei der Erörterung von Klassenbündeln bemerkenswert -

  • Das Wort behavior ist identisch mit function - Es ist ein Code, der etwas tut (oder ein Verhalten implementiert).

  • Das Wort state ist identisch mit variables - Hier können Werte innerhalb einer Klasse gespeichert werden.

  • Wenn wir ein Klassenverhalten und einen Status zusammen behaupten, bedeutet dies, dass eine Klasse Funktionen und Variablen packt.

Klassen haben Methoden und Attribute

In Python definiert das Erstellen einer Methode ein Klassenverhalten. Die Wortmethode ist der OOP-Name, der einer Funktion gegeben wird, die innerhalb einer Klasse definiert ist. Zusammenfassend -

  • Class functions - ist ein Synonym für methods

  • Class variables - ist ein Synonym für name attributes.

  • Class - eine Blaupause für eine Instanz mit genauem Verhalten.

  • Object - Führen Sie in einer der Instanzen der Klasse die in der Klasse definierten Funktionen aus.

  • Type - gibt die Klasse an, zu der die Instanz gehört

  • Attribute - Beliebiger Objektwert: object.attribute

  • Method - ein in der Klasse definiertes "aufrufbares Attribut"

Beachten Sie zum Beispiel den folgenden Code:

var = “Hello, John”
print( type (var)) # < type ‘str’> or <class 'str'>
print(var.upper()) # upper() method is called, HELLO, JOHN

Schöpfung und Instanziierung

Der folgende Code zeigt, wie Sie unsere erste Klasse und dann ihre Instanz erstellen.

class MyClass(object):
   pass
# Create first instance of MyClass
this_obj = MyClass()
print(this_obj)
# Another instance of MyClass
that_obj = MyClass()
print (that_obj)

Hier haben wir eine Klasse namens erstellt MyClassund die keine Aufgabe erledigt. Das Argumentobject im MyClass Klasse beinhaltet Klassenvererbung und wird in späteren Kapiteln besprochen. pass im obigen Code zeigt an, dass dieser Block leer ist, das heißt, es ist eine leere Klassendefinition.

Lassen Sie uns eine Instanz erstellen this_obj von MyClass() Klasse und drucken Sie es wie gezeigt -

<__main__.MyClass object at 0x03B08E10>
<__main__.MyClass object at 0x0369D390>

Hier haben wir eine Instanz von erstellt MyClass.Der Hex-Code bezieht sich auf die Adresse, an der das Objekt gespeichert wird. Eine andere Instanz zeigt auf eine andere Adresse.

Definieren wir nun eine Variable innerhalb der Klasse MyClass() und holen Sie sich die Variable aus der Instanz dieser Klasse, wie im folgenden Code gezeigt -

class MyClass(object):
   var = 9

# Create first instance of MyClass
this_obj = MyClass()
print(this_obj.var)

# Another instance of MyClass

that_obj = MyClass()
print (that_obj.var)

Ausgabe

Sie können die folgende Ausgabe beobachten, wenn Sie den oben angegebenen Code ausführen -

9
9

Da die Instanz weiß, von welcher Klasse sie instanziiert wird, sucht die Instanz bei der Anforderung eines Attributs von einer Instanz nach dem Attribut und der Klasse. Dies nennt man dasattribute lookup.

Instanzmethoden

Eine in einer Klasse definierte Funktion heißt a method.Eine Instanzmethode benötigt eine Instanz, um sie aufzurufen, und benötigt keinen Dekorator. Beim Erstellen einer Instanzmethode ist der erste Parameter immerself. Obwohl wir es (self) bei jedem anderen Namen nennen können, wird empfohlen, self zu verwenden, da es sich um eine Namenskonvention handelt.

class MyClass(object):
   var = 9
   def firstM(self):
      print("hello, World")
obj = MyClass()
print(obj.var)
obj.firstM()

Ausgabe

Sie können die folgende Ausgabe beobachten, wenn Sie den oben angegebenen Code ausführen -

9
hello, World

Beachten Sie, dass wir im obigen Programm eine Methode mit self als Argument definiert haben. Wir können die Methode jedoch nicht aufrufen, da wir kein Argument dafür deklariert haben.

class MyClass(object):
   def firstM(self):
      print("hello, World")
      print(self)
obj = MyClass()
obj.firstM()
print(obj)

Ausgabe

Sie können die folgende Ausgabe beobachten, wenn Sie den oben angegebenen Code ausführen -

hello, World
<__main__.MyClass object at 0x036A8E10>
<__main__.MyClass object at 0x036A8E10>

Verkapselung

Die Kapselung ist eine der Grundlagen von OOP. OOP ermöglicht es uns, die Komplexität der internen Arbeitsweise des Objekts, die für den Entwickler von Vorteil ist, auf folgende Weise zu verbergen:

  • Vereinfacht und erleichtert das Verständnis der Verwendung eines Objekts ohne Kenntnis der Interna.

  • Jede Änderung kann leicht verwaltet werden.

Die objektorientierte Programmierung hängt stark von der Kapselung ab. Die Begriffe Kapselung und Abstraktion (auch als Datenverstecken bezeichnet) werden häufig als Synonyme verwendet. Sie sind fast synonym, da die Abstraktion durch Einkapselung erreicht wird.

Die Kapselung bietet uns den Mechanismus, den Zugriff auf einige der Objektkomponenten einzuschränken. Dies bedeutet, dass die interne Darstellung eines Objekts nicht von außerhalb der Objektdefinition gesehen werden kann. Der Zugriff auf diese Daten erfolgt normalerweise über spezielle Methoden -Getters und Setters.

Diese Daten werden in Instanzattributen gespeichert und können von überall außerhalb der Klasse bearbeitet werden. Um dies zu sichern, sollte auf diese Daten nur mit Instanzmethoden zugegriffen werden. Direkter Zugriff sollte nicht gestattet sein.

class MyClass(object):
   def setAge(self, num):
      self.age = num

   def getAge(self):
      return self.age

zack = MyClass()
zack.setAge(45)
print(zack.getAge())

zack.setAge("Fourty Five")
print(zack.getAge())

Ausgabe

Sie können die folgende Ausgabe beobachten, wenn Sie den oben angegebenen Code ausführen -

45
Fourty Five

Die Daten sollten nur unter Verwendung von Ausnahmebehandlungskonstrukten gespeichert werden, wenn sie korrekt und gültig sind. Wie wir oben sehen können, gibt es keine Einschränkung für die Benutzereingabe der setAge () -Methode. Es kann sich um eine Zeichenfolge, eine Zahl oder eine Liste handeln. Wir müssen also den obigen Code überprüfen, um sicherzustellen, dass er korrekt gespeichert wird.

class MyClass(object):
   def setAge(self, num):
      self.age = num

   def getAge(self):
      return self.age
zack = MyClass()
zack.setAge(45)
print(zack.getAge())
zack.setAge("Fourty Five")
print(zack.getAge())

Init Konstruktor

Das __initDie Methode __ wird implizit aufgerufen, sobald ein Objekt einer Klasse instanziiert wird. Dadurch wird das Objekt initialisiert.

x = MyClass()

Die oben gezeigte Codezeile erstellt eine neue Instanz und weist dieses Objekt der lokalen Variablen x zu.

Das heißt, die Instanziierungsoperation calling a class object, erstellt ein leeres Objekt. Viele Klassen erstellen gerne Objekte mit Instanzen, die an einen bestimmten Anfangszustand angepasst sind. Daher kann eine Klasse eine spezielle Methode mit dem Namen '__init __ ()' wie gezeigt definieren -

def __init__(self):
   self.data = []

Python ruft während der Instanziierung __init__ auf, um ein zusätzliches Attribut zu definieren, das auftreten soll, wenn eine Klasse instanziiert wird, die möglicherweise einige Anfangswerte für dieses Objekt einrichtet oder eine für die Instanziierung erforderliche Routine ausführt. In diesem Beispiel kann eine neue, initialisierte Instanz erhalten werden durch -

x = MyClass()

Die Methode __init __ () kann für eine größere Flexibilität einzelne oder mehrere Argumente enthalten. Der Init steht für Initialisierung, da er Attribute der Instanz initialisiert. Es wird der Konstruktor einer Klasse genannt.

class myclass(object):
   def __init__(self,aaa, bbb):
      self.a = aaa
      self.b = bbb

x = myclass(4.5, 3)
print(x.a, x.b)

Ausgabe

4.5 3

Klassenattribute

Das in der Klasse definierte Attribut heißt "Klassenattribute" und die in der Funktion definierten Attribute heißen "Instanzattribute". Während der Definition wird diesen Attributen kein Selbst vorangestellt, da dies die Eigenschaft der Klasse und nicht einer bestimmten Instanz ist.

Auf die Klassenattribute kann sowohl von der Klasse selbst (className.attributeName) als auch von den Instanzen der Klasse (inst.attributeName) zugegriffen werden. Die Instanzen haben also Zugriff sowohl auf das Instanzattribut als auch auf Klassenattribute.

>>> class myclass():
   age = 21
>>> myclass.age
21
>>> x = myclass()
>>> x.age
21
>>>

Ein Klassenattribut kann in einer Instanz überschrieben werden, obwohl dies keine gute Methode ist, um die Kapselung zu unterbrechen.

In Python gibt es einen Suchpfad für Attribute. Die erste ist die in der Klasse definierte Methode und dann die darüber liegende Klasse.

>>> class myclass(object):
   classy = 'class value'
>>> dd = myclass()
>>> print (dd.classy) # This should return the string 'class value'
class value
>>>
>>> dd.classy = "Instance Value"
>>> print(dd.classy) # Return the string "Instance Value"
Instance Value
>>>
>>> # This will delete the value set for 'dd.classy' in the instance.
>>> del dd.classy
>>> >>> # Since the overriding attribute was deleted, this will print 'class
value'.

>>> print(dd.classy)
class value
>>>

Wir überschreiben das Klassenattribut 'classy' in der Instanz dd. Wenn es überschrieben wird, liest der Python-Interpreter den überschriebenen Wert. Sobald der neue Wert mit 'del' gelöscht wurde, ist der überschriebene Wert in der Instanz nicht mehr vorhanden, und daher geht die Suche eine Ebene höher und wird von der Klasse abgerufen.

Arbeiten mit Klassen- und Instanzdaten

Lassen Sie uns in diesem Abschnitt verstehen, wie sich die Klassendaten auf die Instanzdaten beziehen. Wir können Daten entweder in einer Klasse oder in einer Instanz speichern. Wenn wir eine Klasse entwerfen, entscheiden wir, welche Daten zur Instanz gehören und welche Daten in der Gesamtklasse gespeichert werden sollen.

Eine Instanz kann auf die Klassendaten zugreifen. Wenn wir mehrere Instanzen erstellen, können diese Instanzen auf ihre einzelnen Attributwerte sowie auf die gesamten Klassendaten zugreifen.

Somit sind Klassendaten die Daten, die von allen Instanzen gemeinsam genutzt werden. Beachten Sie den unten angegebenen Code, um das Verständnis zu verbessern -

class InstanceCounter(object):
   count = 0 # class attribute, will be accessible to all instances
   def __init__(self, val):
      self.val = val
      InstanceCounter.count +=1 # Increment the value of class attribute, accessible through class name
# In above line, class ('InstanceCounter') act as an object
   def set_val(self, newval):
      self.val = newval

   def get_val(self):
      return self.val

   def get_count(self):
      return InstanceCounter.count
a = InstanceCounter(9)
b = InstanceCounter(18)
c = InstanceCounter(27)

for obj in (a, b, c):
   print ('val of obj: %s' %(obj.get_val())) # Initialized value ( 9, 18, 27)
   print ('count: %s' %(obj.get_count())) # always 3

Ausgabe

val of obj: 9
count: 3
val of obj: 18
count: 3
val of obj: 27
count: 3

Kurz gesagt, Klassenattribute sind für alle Instanzen der Klasse gleich, während Instanzattribute für jede Instanz spezifisch sind. Für zwei verschiedene Instanzen haben wir zwei verschiedene Instanzattribute.

class myClass:
   class_attribute = 99

   def class_method(self):
      self.instance_attribute = 'I am instance attribute'

print (myClass.__dict__)

Ausgabe

Sie können die folgende Ausgabe beobachten, wenn Sie den oben angegebenen Code ausführen -

{'__module__': '__main__', 'class_attribute': 99, 'class_method': <function myClass.class_method at 0x04128D68>, '__dict__': <attribute '__dict__' of 'myClass' objects>, '__weakref__': <attribute '__weakref__' of 'myClass' objects>, '__doc__': None}

Das Instanzattribut myClass.__dict__ wie gezeigt -

>>> a = myClass()
>>> a.class_method()
>>> print(a.__dict__)
{'instance_attribute': 'I am instance attribute'}

In diesem Kapitel werden verschiedene in Python integrierte Funktionen, Datei-E / A-Operationen und Überladungskonzepte ausführlich beschrieben.

Integrierte Python-Funktionen

Der Python-Interpreter verfügt über eine Reihe von Funktionen, die als integrierte Funktionen bezeichnet werden und zur Verwendung verfügbar sind. In seiner neuesten Version enthält Python 68 integrierte Funktionen, wie in der folgenden Tabelle aufgeführt -

EINGEBAUTE FUNKTIONEN
Abs() dict () Hilfe() Mindest() setattr ()
alle() dir () verhexen() Nächster() Scheibe()
irgendein() divmod () Ich würde() Objekt() sortiert ()
ASCII() aufzählen() Eingang() oct () statische Methode ()
Behälter() eval () int () öffnen() str ()
bool () exec () isinstance () ord () Summe()
bytearray () Filter() issubclass () pow () Super()
Bytes () schweben() iter () drucken() Tupel ()
abrufbar() Format() len () Eigentum() Art()
chr () frozenset () Liste() Angebot() vars ()
Klassenmethode () getattr () Einheimische () repr () Postleitzahl()
kompilieren() Globals () Karte() rückgängig gemacht() __importieren__()
Komplex() hasattr () max () runden()
delattr () hash () memoryview () einstellen()

In diesem Abschnitt werden einige wichtige Funktionen kurz erläutert.

len () Funktion

Die Funktion len () ermittelt die Länge von Zeichenfolgen, Listen oder Sammlungen. Es gibt die Länge oder Anzahl der Elemente eines Objekts zurück, wobei das Objekt eine Zeichenfolge, eine Liste oder eine Sammlung sein kann.

>>> len(['hello', 9 , 45.0, 24])
4

Die Funktion len () funktioniert intern wie list.__len__() oder tuple.__len__(). Beachten Sie daher, dass len () nur für Objekte mit einem __ funktioniertlen__() Methode.

>>> set1
{1, 2, 3, 4}
>>> set1.__len__()
4

In der Praxis bevorzugen wir jedoch len() anstatt der __len__() Funktion aus folgenden Gründen -

  • Es ist effizienter. Und es ist nicht erforderlich, dass eine bestimmte Methode geschrieben wird, um den Zugriff auf spezielle Methoden wie __len__ zu verweigern.

  • Es ist leicht zu pflegen.

  • Es unterstützt die Abwärtskompatibilität.

Umgekehrt (seq)

Es gibt den umgekehrten Iterator zurück. seq muss ein Objekt sein, das die Methode __reversed __ () hat oder das Sequenzprotokoll unterstützt (die Methode __len __ () und die Methode __getitem __ ()). Es wird allgemein in verwendetfor Schleifen, wenn wir Elemente von hinten nach vorne durchlaufen möchten.

>>> normal_list = [2, 4, 5, 7, 9]
>>>
>>> class CustomSequence():
   def __len__(self):
      return 5
   def __getitem__(self,index):
      return "x{0}".format(index)
>>> class funkyback():
   def __reversed__(self):
      return 'backwards!'
>>> for seq in normal_list, CustomSequence(), funkyback():
      print('\n{}: '.format(seq.__class__.__name__), end="")
      for item in reversed(seq):
         print(item, end=", ")

Die for-Schleife am Ende druckt die umgekehrte Liste einer normalen Liste und Instanzen der beiden benutzerdefinierten Sequenzen. Die Ausgabe zeigt dasreversed() funktioniert bei allen dreien, hat aber bei der Definition sehr unterschiedliche Ergebnisse __reversed__.

Ausgabe

Sie können die folgende Ausgabe beobachten, wenn Sie den oben angegebenen Code ausführen -

list: 9, 7, 5, 4, 2,
CustomSequence: x4, x3, x2, x1, x0,
funkyback: b, a, c, k, w, a, r, d, s, !,

Aufzählen

Das enumerate () Die Methode fügt einem Iterable einen Zähler hinzu und gibt das Aufzählungsobjekt zurück.

Die Syntax von enumerate () lautet -

enumerate(iterable, start = 0)

Hier das zweite Argument start ist optional und der Index beginnt standardmäßig mit Null (0).

>>> # Enumerate
>>> names = ['Rajesh', 'Rahul', 'Aarav', 'Sahil', 'Trevor']
>>> enumerate(names)
<enumerate object at 0x031D9F80>
>>> list(enumerate(names))
[(0, 'Rajesh'), (1, 'Rahul'), (2, 'Aarav'), (3, 'Sahil'), (4, 'Trevor')]
>>>

Damit enumerate()Gibt einen Iterator zurück, der ein Tupel ergibt, das die Anzahl der Elemente in der übergebenen Sequenz zählt. Da der Rückgabewert ein Iterator ist, ist ein direkter Zugriff darauf nicht sehr nützlich. Ein besserer Ansatz für enumerate () besteht darin, die Zählung innerhalb einer for-Schleife zu halten.

>>> for i, n in enumerate(names):
   print('Names number: ' + str(i))
   print(n)
Names number: 0
Rajesh
Names number: 1
Rahul
Names number: 2
Aarav
Names number: 3
Sahil
Names number: 4
Trevor

Es gibt viele andere Funktionen in der Standardbibliothek, und hier ist eine weitere Liste einiger weiter verbreiteter Funktionen -

  • hasattr, getattr, setattr und delattr, Dadurch können Attribute eines Objekts anhand ihrer Zeichenfolgennamen bearbeitet werden.

  • all und any, die ein iterierbares Objekt akzeptieren und zurückkehren True wenn alle oder einige der Elemente als wahr bewertet werden.

  • nzip, Dies nimmt zwei oder mehr Sequenzen und gibt eine neue Sequenz von Tupeln zurück, wobei jedes Tupel einen einzelnen Wert aus jeder Sequenz enthält.

Datei-E / A.

Das Konzept der Dateien ist mit dem Begriff objektorientierte Programmierung verbunden. Python hat die von den Betriebssystemen bereitgestellte Schnittstelle in die Abstraktion eingebunden, die es uns ermöglicht, mit Dateiobjekten zu arbeiten.

Das open()Die integrierte Funktion wird verwendet, um eine Datei zu öffnen und ein Dateiobjekt zurückzugeben. Es ist die am häufigsten verwendete Funktion mit zwei Argumenten -

open(filename, mode)

Die Funktion open () ruft zwei Argumente auf, das erste ist der Dateiname und das zweite ist der Modus. Hier kann der Modus "r" für den schreibgeschützten Modus, "w" für das reine Schreiben (eine vorhandene Datei mit demselben Namen wird gelöscht) und "a" die Datei zum Anhängen öffnen. Alle in die Datei geschriebenen Daten werden automatisch hinzugefügt bis zum Ende. 'r +' öffnet die Datei zum Lesen und Schreiben. Der Standardmodus ist schreibgeschützt.

Unter Windows öffnet 'b', das an den Modus angehängt ist, die Datei im Binärmodus, daher gibt es auch Modi wie 'rb', 'wb' und 'r + b'.

>>> text = 'This is the first line'
>>> file = open('datawork','w')
>>> file.write(text)
22
>>> file.close()

In einigen Fällen möchten wir nur an die vorhandene Datei anhängen, anstatt sie zu überschreiben, da wir den Wert 'a' als Modusargument angeben können, um sie an das Ende der Datei anzuhängen, anstatt die vorhandene Datei vollständig zu überschreiben Inhalt.

>>> f = open('datawork','a')
>>> text1 = ' This is second line'
>>> f.write(text1)
20
>>> f.close()

Sobald eine Datei zum Lesen geöffnet wurde, können wir die Methode read, readline oder readlines aufrufen, um den Inhalt der Datei abzurufen. Die read-Methode gibt den gesamten Inhalt der Datei als str- oder bytes-Objekt zurück, je nachdem, ob das zweite Argument 'b' ist.

Aus Gründen der Lesbarkeit und um zu vermeiden, dass eine große Datei auf einmal gelesen wird, ist es häufig besser, eine for-Schleife direkt für ein Dateiobjekt zu verwenden. Bei Textdateien wird jede Zeile einzeln gelesen, und wir können sie innerhalb des Schleifenkörpers verarbeiten. Für Binärdateien ist es jedoch besser, Datenblöcke mit fester Größe mit der read () -Methode zu lesen und einen Parameter für die maximale Anzahl der zu lesenden Bytes zu übergeben.

>>> f = open('fileone','r+')
>>> f.readline()
'This is the first line. \n'
>>> f.readline()
'This is the second line. \n'

Beim Schreiben in eine Datei wird über die Schreibmethode für Dateiobjekte ein Zeichenfolgenobjekt (Bytes für Binärdaten) in die Datei geschrieben. Die Methode writelines akzeptiert eine Folge von Zeichenfolgen und schreibt jeden der iterierten Werte in die Datei. Die Writelines-Methode fügt nach jedem Element in der Sequenz keine neue Zeile an.

Schließlich sollte die Methode close () aufgerufen werden, wenn wir mit dem Lesen oder Schreiben der Datei fertig sind, um sicherzustellen, dass alle gepufferten Schreibvorgänge auf die Festplatte geschrieben werden, dass die Datei ordnungsgemäß bereinigt wurde und dass alle mit der Datei verknüpften Ressourcen wieder freigegeben werden das Betriebssystem. Es ist ein besserer Ansatz, die close () -Methode aufzurufen, aber technisch gesehen geschieht dies automatisch, wenn das Skript vorhanden ist.

Eine Alternative zur Methodenüberladung

Das Überladen von Methoden bezieht sich auf mehrere Methoden mit demselben Namen, die unterschiedliche Sätze von Argumenten akzeptieren.

Bei einer einzelnen Methode oder Funktion können wir die Anzahl der Parameter selbst festlegen. Abhängig von der Funktionsdefinition kann es mit null, eins, zwei oder mehr Parametern aufgerufen werden.

class Human:
   def sayHello(self, name = None):
      if name is not None:
         print('Hello ' + name)
      else:
         print('Hello ')

#Create Instance
obj = Human()

#Call the method, else part will be executed
obj.sayHello()

#Call the method with a parameter, if part will be executed
obj.sayHello('Rahul')

Ausgabe

Hello
Hello Rahul

Standardargumente

Funktionen sind auch Objekte

Ein aufrufbares Objekt ist ein Objekt, das einige Argumente akzeptieren kann und möglicherweise ein Objekt zurückgibt. Eine Funktion ist das einfachste aufrufbare Objekt in Python, aber es gibt auch andere wie Klassen oder bestimmte Klasseninstanzen.

Jede Funktion in einem Python ist ein Objekt. Objekte können Methoden oder Funktionen enthalten, aber Objekt ist keine Funktion erforderlich.

def my_func():
   print('My function was called')
my_func.description = 'A silly function'
def second_func():

   print('Second function was called')

   second_func.description = 'One more sillier function'

def another_func(func):
   print("The description:", end=" ")
   print(func.description)
   print('The name: ', end=' ')
   print(func.__name__)
   print('The class:', end=' ')
   print(func.__class__)
   print("Now I'll call the function passed in")
   func()

another_func(my_func)
another_func(second_func)

Im obigen Code können wir zwei verschiedene Funktionen als Argument an unsere dritte Funktion übergeben und für jede unterschiedliche Ausgabe erhalten -

The description: A silly function
The name: my_func
The class: 
      
        Now I'll call the function passed in My function was called The description: One more sillier function The name: second_func The class: 
       
         Now I'll call the function passed in Second function was called 
       
      

callable objects

Just as functions are objects that can have attributes set on them, it is possible to create an object that can be called as though it were a function.

In Python any object with a __call__() method can be called using function-call syntax.

Inheritance and Polymorphism

Inheritance and polymorphism – this is a very important concept in Python. You must understand it better if you want to learn.

Inheritance

One of the major advantages of Object Oriented Programming is re-use. Inheritance is one of the mechanisms to achieve the same. Inheritance allows programmer to create a general or a base class first and then later extend it to more specialized class. It allows programmer to write better code.

Using inheritance you can use or inherit all the data fields and methods available in your base class. Later you can add you own methods and data fields, thus inheritance provides a way to organize code, rather than rewriting it from scratch.

In object-oriented terminology when class X extend class Y, then Y is called super/parent/base class and X is called subclass/child/derived class. One point to note here is that only data fields and method which are not private are accessible by child classes. Private data fields and methods are accessible only inside the class.

syntax to create a derived class is −

class BaseClass:
   Body of base class
class DerivedClass(BaseClass):
   Body of derived class

Inheriting Attributes

Now look at the below example −

Output

We first created a class called Date and pass the object as an argument, here-object is built-in class provided by Python. Later we created another class called time and called the Date class as an argument. Through this call we get access to all the data and attributes of Date class into the Time class. Because of that when we try to get the get_date method from the Time class object tm we created earlier possible.

Object.Attribute Lookup Hierarchy

  • The instance
  • The class
  • Any class from which this class inherits

Inheritance Examples

Let’s take a closure look into the inheritance example −

Let’s create couple of classes to participate in examples −

  • Animal − Class simulate an animal
  • Cat − Subclass of Animal
  • Dog − Subclass of Animal

In Python, constructor of class used to create an object (instance), and assign the value for the attributes.

Constructor of subclasses always called to a constructor of parent class to initialize value for the attributes in the parent class, then it start assign value for its attributes.

Output

In the above example, we see the command attributes or methods we put in the parent class so that all subclasses or child classes will inherits that property from the parent class.

If a subclass try to inherits methods or data from another subclass then it will through an error as we see when Dog class try to call swatstring() methods from that cat class, it throws an error(like AttributeError in our case).

Polymorphism (“MANY SHAPES”)

Polymorphism is an important feature of class definition in Python that is utilized when you have commonly named methods across classes or subclasses. This permits functions to use entities of different types at different times. So, it provides flexibility and loose coupling so that code can be extended and easily maintained over time.

This allows functions to use objects of any of these polymorphic classes without needing to be aware of distinctions across the classes.

Polymorphism can be carried out through inheritance, with subclasses making use of base class methods or overriding them.

Let understand the concept of polymorphism with our previous inheritance example and add one common method called show_affection in both subclasses −

From the example we can see, it refers to a design in which object of dissimilar type can be treated in the same manner or more specifically two or more classes with method of the same name or common interface because same method(show_affection in below example) is called with either type of objects.

Output

So, all animals show affections (show_affection), but they do differently. The “show_affection” behaviors is thus polymorphic in the sense that it acted differently depending on the animal. So, the abstract “animal” concept does not actually “show_affection”, but specific animals(like dogs and cats) have a concrete implementation of the action “show_affection”.

Python itself have classes that are polymorphic. Example, the len() function can be used with multiple objects and all return the correct output based on the input parameter.

Overriding

In Python, when a subclass contains a method that overrides a method of the superclass, you can also call the superclass method by calling

Super(Subclass, self).method instead of self.method.

Example

class Thought(object):
   def __init__(self):
      pass
   def message(self):
      print("Thought, always come and go")

class Advice(Thought):
   def __init__(self):
      super(Advice, self).__init__()
   def message(self):
      print('Warning: Risk is always involved when you are dealing with market!')

Inheriting the Constructor

If we see from our previous inheritance example, __init__ was located in the parent class in the up ‘cause the child class dog or cat didn’t‘ve __init__ method in it. Python used the inheritance attribute lookup to find __init__ in animal class. When we created the child class, first it will look the __init__ method in the dog class, then it didn’t find it then looked into parent class Animal and found there and called that there. So as our class design became complex we may wish to initialize a instance firstly processing it through parent class constructor and then through child class constructor.

Output

In above example- all animals have a name and all dogs a particular breed. We called parent class constructor with super. So dog has its own __init__ but the first thing that happen is we call super. Super is built in function and it is designed to relate a class to its super class or its parent class.

In this case we saying that get the super class of dog and pass the dog instance to whatever method we say here the constructor __init__. So in another words we are calling parent class Animal __init__ with the dog object. You may ask why we won’t just say Animal __init__ with the dog instance, we could do this but if the name of animal class were to change, sometime in the future. What if we wanna rearrange the class hierarchy,so the dog inherited from another class. Using super in this case allows us to keep things modular and easy to change and maintain.

So in this example we are able to combine general __init__ functionality with more specific functionality. This gives us opportunity to separate common functionality from the specific functionality which can eliminate code duplication and relate class to one another in a way that reflects the system overall design.

Conclusion

  • __init__ is like any other method; it can be inherited

  • If a class does not have a __init__ constructor, Python will check its parent class to see if it can find one.

  • As soon as it finds one, Python calls it and stops looking

  • We can use the super () function to call methods in the parent class.

  • We may want to initialize in the parent as well as our own class.

Multiple Inheritance and the Lookup Tree

As its name indicates, multiple inheritance is Python is when a class inherits from multiple classes.

For example, a child inherits personality traits from both parents (Mother and Father).

Python Multiple Inheritance Syntax

To make a class inherits from multiple parents classes, we write the the names of these classes inside the parentheses to the derived class while defining it. We separate these names with comma.

Below is an example of that −

>>> class Mother:
   pass

>>> class Father:
   pass

>>> class Child(Mother, Father):
   pass

>>> issubclass(Child, Mother) and issubclass(Child, Father)
True

Multiple inheritance refers to the ability of inheriting from two or more than two class. The complexity arises as child inherits from parent and parents inherits from the grandparent class. Python climbs an inheriting tree looking for attributes that is being requested to be read from an object. It will check the in the instance, within class then parent class and lastly from the grandparent class. Now the question arises in what order the classes will be searched - breath-first or depth-first. By default, Python goes with the depth-first.

That’s is why in the below diagram the Python searches the dothis() method first in class A. So the method resolution order in the below example will be

Mro- D→B→A→C

Look at the below multiple inheritance diagram −

Let’s go through an example to understand the “mro” feature of an Python.

Output

Example 3

Let’s take another example of “diamond shape” multiple inheritance.

Above diagram will be considered ambiguous. From our previous example understanding “method resolution order” .i.e. mro will be D→B→A→C→A but it’s not. On getting the second A from the C, Python will ignore the previous A. so the mro will be in this case will be D→B→C→A.

Let’s create an example based on above diagram −

Output

Simple rule to understand the above output is- if the same class appear in the method resolution order, the earlier appearances of this class will be remove from the method resolution order.

In conclusion −

  • Any class can inherit from multiple classes

  • Python normally uses a “depth-first” order when searching inheriting classes.

  • But when two classes inherit from the same class, Python eliminates the first appearances of that class from the mro.

Decorators, Static and Class Methods

Functions(or methods) are created by def statement.

Though methods works in exactly the same way as a function except one point where method first argument is instance object.

We can classify methods based on how they behave, like

  • Simple method − defined outside of a class. This function can access class attributes by feeding instance argument:

def outside_func(():
  • Instance method

def func(self,)
  • Class method − if we need to use class attributes

   @classmethod
def cfunc(cls,)
  • Static method − do not have any info about the class

      @staticmethod
def sfoo()

Till now we have seen the instance method, now is the time to get some insight into the other two methods,

Class Method

The @classmethod decorator, is a builtin function decorator that gets passed the class it was called on or the class of the instance it was called on as first argument. The result of that evaluation shadows your function definition.

syntax

class C(object):
   @classmethod
   def fun(cls, arg1, arg2, ...):
      ....
fun: function that needs to be converted into a class method
returns: a class method for function

They have the access to this cls argument, it can’t modify object instance state. That would require access to self.

  • It is bound to the class and not the object of the class.

  • Class methods can still modify class state that applies across all instances of the class.

Static Method

A static method takes neither a self nor a cls(class) parameter but it’s free to accept an arbitrary number of other parameters.

syntax

class C(object):
   @staticmethod
   def fun(arg1, arg2, ...):
   ...
returns: a static method for function funself.
  • A static method can neither modify object state nor class state.
  • They are restricted in what data they can access.

When to use what

  • We generally use class method to create factory methods. Factory methods return class object (similar to a constructor) for different use cases.

  • We generally use static methods to create utility functions.

Python Design Pattern

Overview

Modern software development needs to address complex business requirements. It also needs to take into account factors such as future extensibility and maintainability. A good design of a software system is vital to accomplish these goals. Design patterns play an important role in such systems.

To understand design pattern, let’s consider below example −

  • Every car’s design follows a basic design pattern, four wheels, steering wheel, the core drive system like accelerator-break-clutch, etc.

So, all things repeatedly built/ produced, shall inevitably follow a pattern in its design.. it cars, bicycle, pizza, atm machines, whatever…even your sofa bed.

Designs that have almost become standard way of coding some logic/mechanism/technique in software, hence come to be known as or studied as, Software Design Patterns.

Why is Design Pattern Important?

Benefits of using Design Patterns are −

  • Helps you to solve common design problems through a proven approach.

  • No ambiguity in the understanding as they are well documented.

  • Reduce the overall development time.

  • Helps you deal with future extensions and modifications with more ease than otherwise.

  • May reduce errors in the system since they are proven solutions to common problems.

Classification of Design Patterns

The GoF (Gang of Four) design patterns are classified into three categories namely creational, structural and behavioral.

Creational Patterns

Creational design patterns separate the object creation logic from the rest of the system. Instead of you creating objects, creational patterns creates them for you. The creational patterns include Abstract Factory, Builder, Factory Method, Prototype and Singleton.

Creational Patterns are not commonly used in Python because of the dynamic nature of the language. Also language itself provide us with all the flexibility we need to create in a sufficient elegant fashion, we rarely need to implement anything on top, like singleton or Factory.

Also these patterns provide a way to create objects while hiding the creation logic, rather than instantiating objects directly using a new operator.

Structural Patterns

Sometimes instead of starting from scratch, you need to build larger structures by using an existing set of classes. That’s where structural class patterns use inheritance to build a new structure. Structural object patterns use composition/ aggregation to obtain a new functionality. Adapter, Bridge, Composite, Decorator, Façade, Flyweight and Proxy are Structural Patterns. They offers best ways to organize class hierarchy.

Behavioral Patterns

Behavioral patterns offers best ways of handling communication between objects. Patterns comes under this categories are: Visitor, Chain of responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy and Template method are Behavioral Patterns.

Because they represent the behavior of a system, they are used generally to describe the functionality of software systems.

Commonly used Design Patterns

Singleton

It is one of the most controversial and famous of all design patterns. It is used in overly object-oriented languages, and is a vital part of traditional object-oriented programming.

The Singleton pattern is used for,

  • When logging needs to be implemented. The logger instance is shared by all the components of the system.

  • The configuration files is using this because cache of information needs to be maintained and shared by all the various components in the system.

  • Managing a connection to a database.

Here is the UML diagram,

class Logger(object):
   def __new__(cls, *args, **kwargs):
      if not hasattr(cls, '_logger'):
      cls._logger = super(Logger, cls).__new__(cls, *args, **kwargs)
return cls._logger

In this example, Logger is a Singleton.

When __new__ is called, it normally constructs a new instance of that class. When we override it, we first check if our singleton instance has been created or not. If not, we create it using a super call. Thus, whenever we call the constructor on Logger, we always get the exact same instance.

>>>
>>> obj1 = Logger()
>>> obj2 = Logger()
>>> obj1 == obj2
True
>>>
>>> obj1
<__main__.Logger object at 0x03224090>
>>> obj2
<__main__.Logger object at 0x03224090>

Object Oriented Python - Advanced Features

In this we will look into some of the advanced features which Python provide

Core Syntax in our Class design

In this we will look onto, how Python allows us to take advantage of operators in our classes. Python is largely objects and methods call on objects and this even goes on even when its hidden by some convenient syntax.

>>> var1 = 'Hello'
>>> var2 = ' World!'
>>> var1 + var2
'Hello World!'
>>>
>>> var1.__add__(var2)
'Hello World!'
>>> num1 = 45
>>> num2 = 60
>>> num1.__add__(num2)
105
>>> var3 = ['a', 'b']
>>> var4 = ['hello', ' John']
>>> var3.__add__(var4)
['a', 'b', 'hello', ' John']

So if we have to add magic method __add__ to our own classes, could we do that too. Let’s try to do that.

We have a class called Sumlist which has a contructor __init__ which takes list as an argument called my_list.

class SumList(object):
   def __init__(self, my_list):
      self.mylist = my_list
   def __add__(self, other):
     new_list = [ x + y for x, y in zip(self.mylist, other.mylist)]

     return SumList(new_list)
   
   def __repr__(self):
      return str(self.mylist)

aa = SumList([3,6, 9, 12, 15])

bb = SumList([100, 200, 300, 400, 500])
cc = aa + bb # aa.__add__(bb)
print(cc) # should gives us a list ([103, 206, 309, 412, 515])

Output

[103, 206, 309, 412, 515]

But there are many methods which are internally managed by others magic methods. Below are some of them,

'abc' in var # var.__contains__('abc')
var == 'abc' # var.__eq__('abc')
var[1] # var.__getitem__(1)
var[1:3] # var.__getslice__(1, 3)
len(var) # var.__len__()
print(var) # var.__repr__()

Inheriting From built-in types

Classes can also inherit from built-in types this means inherits from any built-in and take advantage of all the functionality found there.

In below example we are inheriting from dictionary but then we are implementing one of its method __setitem__. This (setitem) is invoked when we set key and value in the dictionary. As this is a magic method, this will be called implicitly.

class MyDict(dict):

   def __setitem__(self, key, val):
      print('setting a key and value!')
      dict.__setitem__(self, key, val)

dd = MyDict()
dd['a'] = 10
dd['b'] = 20

for key in dd.keys():
   print('{0} = {1}'.format(key, dd[key]))

Output

setting a key and value!
setting a key and value!
a = 10
b = 20

Let’s extend our previous example, below we have called two magic methods called __getitem__ and __setitem__ better invoked when we deal with list index.

# Mylist inherits from 'list' object but indexes from 1 instead for 0!
class Mylist(list): # inherits from list
   def __getitem__(self, index):
      if index == 0:
         raise IndexError
      if index > 0:
         index = index - 1
         return list.__getitem__(self, index) # this method is called when

# we access a value with subscript like x[1]
   def __setitem__(self, index, value):
      if index == 0:
         raise IndexError
      if index > 0:
      index = index - 1
      list.__setitem__(self, index, value)

x = Mylist(['a', 'b', 'c']) # __init__() inherited from builtin list

print(x) # __repr__() inherited from builtin list

x.append('HELLO'); # append() inherited from builtin list

print(x[1]) # 'a' (Mylist.__getitem__ cutomizes list superclass
               # method. index is 1, but reflects 0!

print (x[4]) # 'HELLO' (index is 4 but reflects 3!

Output

['a', 'b', 'c']
a
HELLO

In above example, we set a three item list in Mylist and implicitly __init__ method is called and when we print the element x, we get the three item list ([‘a’,’b’,’c’]). Then we append another element to this list. Later we ask for index 1 and index 4. But if you see the output, we are getting element from the (index-1) what we have asked for. As we know list indexing start from 0 but here the indexing start from 1 (that’s why we are getting the first item of the list).

Naming Conventions

In this we will look into names we’ll used for variables especially private variables and conventions used by Python programmers worldwide. Although variables are designated as private but there is not privacy in Python and this by design. Like any other well documented languages, Python has naming and style conventions that it promote although it doesn’t enforce them. There is a style guide written by “Guido van Rossum” the originator of Python, that describe the best practices and use of name and is called PEP8. Here is the link for this, https://www.python.org/dev/peps/pep-0008/

PEP stands for Python enhancement proposal and is a series of documentation that distributed among the Python community to discuss proposed changes. For example it is recommended all,

  • Module names − all_lower_case
  • Class names and exception names − CamelCase
  • Global and local names − all_lower_case
  • Functions and method names − all_lower_case
  • Constants − ALL_UPPER_CASE

These are just the recommendation, you can vary if you like. But as most of the developers follows these recommendation so might me your code is less readable.

Why conform to convention?

We can follow the PEP recommendation we it allows us to get,

  • More familiar to the vast majority of developers
  • Clearer to most readers of your code.
  • Will match style of other contributers who work on same code base.
  • Mark of a professional software developers
  • Everyone will accept you.

Variable Naming − ‘Public’ and ‘Private’

In Python, when we are dealing with modules and classes, we designate some variables or attribute as private. In Python, there is no existence of “Private” instance variable which cannot be accessed except inside an object. Private simply means they are simply not intended to be used by the users of the code instead they are intended to be used internally. In general, a convention is being followed by most Python developers i.e. a name prefixed with an underscore for example. _attrval (example below) should be treated as a non-public part of the API or any Python code, whether it is a function, a method or a data member. Below is the naming convention we follow,

  • Public attributes or variables (intended to be used by the importer of this module or user of this class) −regular_lower_case

  • Private attributes or variables (internal use by the module or class) −_single_leading_underscore

  • Private attributes that shouldn’t be subclassed −__double_leading_underscore

  • Magic attributes −__double_underscores__(use them, don’t create them)

class GetSet(object):

   instance_count = 0 # public
   
   __mangled_name = 'no privacy!' # special variable

   def __init__(self, value):
      self._attrval = value # _attrval is for internal use only
      GetSet.instance_count += 1

   @property
   def var(self):
      print('Getting the "var" attribute')
      return self._attrval

   @var.setter
   def var(self, value):
      print('setting the "var" attribute')
      self._attrval = value

   @var.deleter
   def var(self):
      print('deleting the "var" attribute')
      self._attrval = None

cc = GetSet(5)
cc.var = 10 # public name
print(cc._attrval)
print(cc._GetSet__mangled_name)

Output

setting the "var" attribute
10
no privacy!

Object Oriented Python - Files and Strings

Strings

Strings are the most popular data types used in every programming language. Why? Because we, understand text better than numbers, so in writing and talking we use text and words, similarly in programming too we use strings. In string we parse text, analyse text semantics, and do data mining – and all this data is human consumed text.The string in Python is immutable.

String Manipulation

In Python, string can be marked in multiple ways, using single quote ( ‘ ), double quote( “ ) or even triple quote ( ‘’’ ) in case of multiline strings.

>>> # String Examples
>>> a = "hello"
>>> b = ''' A Multi line string,
Simple!'''
>>> e = ('Multiple' 'strings' 'togethers')

String manipulation is very useful and very widely used in every language. Often, programmers are required to break down strings and examine them closely.

Strings can be iterated over (character by character), sliced, or concatenated. The syntax is the same as for lists.

The str class has numerous methods on it to make manipulating strings easier. The dir and help commands provides guidance in the Python interpreter how to use them.

Below are some of the commonly used string methods we use.

Sr.No. Method & Description
1

isalpha()

Checks if all characters are Alphabets

2

isdigit()

Checks Digit Characters

3

isdecimal()

Checks decimal Characters

4

isnumeric()

checks Numeric Characters

5

find()

Returns the Highest Index of substrings

6

istitle()

Checks for Titlecased strings

7

join()

Returns a concatenated string

8

lower()

returns lower cased string

9

upper()

returns upper cased string

10

partion()

Returns a tuple

11

bytearray()

Returns array of given byte size

12

enumerate()

Returns an enumerate object

13

isprintable()

Checks printable character

Let’s try to run couple of string methods,

>>> str1 = 'Hello World!'
>>> str1.startswith('h')
False
>>> str1.startswith('H')
True
>>> str1.endswith('d')
False
>>> str1.endswith('d!')
True
>>> str1.find('o')
4
>>> #Above returns the index of the first occurence of the character/substring.
>>> str1.find('lo')
3
>>> str1.upper()
'HELLO WORLD!'
>>> str1.lower()
'hello world!'
>>> str1.index('b')
Traceback (most recent call last):
   File "<pyshell#19>", line 1, in <module>
      str1.index('b')
ValueError: substring not found
>>> s = ('hello How Are You')
>>> s.split(' ')
['hello', 'How', 'Are', 'You']
>>> s1 = s.split(' ')
>>> '*'.join(s1)
'hello*How*Are*You'
>>> s.partition(' ')
('hello', ' ', 'How Are You')
>>>

String Formatting

In Python 3.x formatting of strings has changed, now it more logical and is more flexible. Formatting can be done using the format() method or the % sign(old style) in format string.

The string can contain literal text or replacement fields delimited by braces {} and each replacement field may contains either the numeric index of a positional argument or the name of a keyword argument.

syntax

str.format(*args, **kwargs)

Basic Formatting

>>> '{} {}'.format('Example', 'One')
'Example One'
>>> '{} {}'.format('pie', '3.1415926')
'pie 3.1415926'

Below example allows re-arrange the order of display without changing the arguments.

>>> '{1} {0}'.format('pie', '3.1415926')
'3.1415926 pie'

Padding and aligning strings

A value can be padded to a specific length.

>>> #Padding Character, can be space or special character
>>> '{:12}'.format('PYTHON')
'PYTHON '
>>> '{:>12}'.format('PYTHON')
' PYTHON'
>>> '{:<{}s}'.format('PYTHON',12)
'PYTHON '
>>> '{:*<12}'.format('PYTHON')
'PYTHON******'
>>> '{:*^12}'.format('PYTHON')
'***PYTHON***'
>>> '{:.15}'.format('PYTHON OBJECT ORIENTED PROGRAMMING')
'PYTHON OBJECT O'
>>> #Above, truncated 15 characters from the left side of a specified string
>>> '{:.{}}'.format('PYTHON OBJECT ORIENTED',15)
'PYTHON OBJECT O'
>>> #Named Placeholders
>>> data = {'Name':'Raghu', 'Place':'Bangalore'}
>>> '{Name} {Place}'.format(**data)
'Raghu Bangalore'
>>> #Datetime
>>> from datetime import datetime
>>> '{:%Y/%m/%d.%H:%M}'.format(datetime(2018,3,26,9,57))
'2018/03/26.09:57'

Strings are Unicode

Strings as collections of immutable Unicode characters. Unicode strings provide an opportunity to create software or programs that works everywhere because the Unicode strings can represent any possible character not just the ASCII characters.

Many IO operations only know how to deal with bytes, even if the bytes object refers to textual data. It is therefore very important to know how to interchange between bytes and Unicode.

Converting text to bytes

Converting a strings to byte object is termed as encoding. There are numerous forms of encoding, most common ones are: PNG; JPEG, MP3, WAV, ASCII, UTF-8 etc. Also this(encoding) is a format to represent audio, images, text, etc. in bytes.

This conversion is possible through encode(). It take encoding technique as argument. By default, we use ‘UTF-8’ technique.

>>> # Python Code to demonstrate string encoding 
>>> 
>>> # Initialising a String 
>>> x = 'TutorialsPoint' 
>>> 
>>> #Initialising a byte object 
>>> y = b'TutorialsPoint'
>>> 
>>> # Using encode() to encode the String >>> # encoded version of x is stored in z using ASCII mapping 
>>> z = x.encode('ASCII') 
>>> 
>>> # Check if x is converted to bytes or not 
>>> 
>>> if(z==y): 
   print('Encoding Successful!') 
else: 
   print('Encoding Unsuccessful!') 
Encoding Successful!

Converting bytes to text

Converting bytes to text is called the decoding. This is implemented through decode(). We can convert a byte string to a character string if we know which encoding is used to encode it.

So Encoding and decoding are inverse processes.

>>> 
>>> # Python code to demonstrate Byte Decoding 
>>> 
>>> #Initialise a String 
>>> x = 'TutorialsPoint' 
>>> 
>>> #Initialising a byte object 
>>> y = b'TutorialsPoint' 
>>> 
>>> #using decode() to decode the Byte object 
>>> # decoded version of y is stored in z using ASCII mapping 
>>> z = y.decode('ASCII')
>>> #Check if y is converted to String or not 
>>> if (z == x): 
   print('Decoding Successful!') 
else: 
   print('Decoding Unsuccessful!') Decoding Successful! 
>>>

File I/O

Operating systems represents files as a sequence of bytes, not text.

A file is a named location on disk to store related information. It is used to permanently store data in your disk.

In Python, a file operation takes place in the following order.

  • Open a file
  • Read or write onto a file (operation).Open a file
  • Close the file.

Python wraps the incoming (or outgoing) stream of bytes with appropriate decode (or encode) calls so we can deal directly with str objects.

Opening a file

Python has a built-in function open() to open a file. This will generate a file object, also called a handle as it is used to read or modify the file accordingly.

>>> f = open(r'c:\users\rajesh\Desktop\index.webm','rb')
>>> f
<_io.BufferedReader name='c:\\users\\rajesh\\Desktop\\index.webm'>
>>> f.mode
'rb'
>>> f.name
'c:\\users\\rajesh\\Desktop\\index.webm'

For reading text from a file, we only need to pass the filename into the function. The file will be opened for reading, and the bytes will be converted to text using the platform default encoding.

Exception and Exception Classes

In general, an exception is any unusual condition. Exception usually indicates errors but sometimes they intentionally puts in the program, in cases like terminating a procedure early or recovering from a resource shortage. There are number of built-in exceptions, which indicate conditions like reading past the end of a file, or dividing by zero. We can define our own exceptions called custom exception.

Exception handling enables you handle errors gracefully and do something meaningful about it. Exception handling has two components: “throwing” and ‘catching’.

Identifying Exception (Errors)

Every error occurs in Python result an exception which will an error condition identified by its error type.

>>> #Exception
>>> 1/0
Traceback (most recent call last):
   File "<pyshell#2>", line 1, in <module>
      1/0
ZeroDivisionError: division by zero
>>>
>>> var = 20
>>> print(ver)
Traceback (most recent call last):
   File "<pyshell#5>", line 1, in <module>
      print(ver)
NameError: name 'ver' is not defined
>>> #Above as we have misspelled a variable name so we get an NameError.
>>>
>>> print('hello)

SyntaxError: EOL while scanning string literal
>>> #Above we have not closed the quote in a string, so we get SyntaxError.
>>>
>>> #Below we are asking for a key, that doen't exists.
>>> mydict = {}
>>> mydict['x']
Traceback (most recent call last):
   File "<pyshell#15>", line 1, in <module>
      mydict['x']
KeyError: 'x'
>>> #Above keyError
>>>
>>> #Below asking for a index that didn't exist in a list.
>>> mylist = [1,2,3,4]
>>> mylist[5]
Traceback (most recent call last):
   File "<pyshell#20>", line 1, in <module>
      mylist[5]
IndexError: list index out of range
>>> #Above, index out of range, raised IndexError.

Catching/Trapping Exception

When something unusual occurs in your program and you wish to handle it using the exception mechanism, you ‘throw an exception’. The keywords try and except are used to catch exceptions. Whenever an error occurs within a try block, Python looks for a matching except block to handle it. If there is one, execution jumps there.

syntax

try:
   #write some code
   #that might throw some exception
except <ExceptionType>:
   # Exception handler, alert the user

The code within the try clause will be executed statement by statement.

If an exception occurs, the rest of the try block will be skipped and the except clause will be executed.

try:
   some statement here
except:
   exception handling

Let’s write some code to see what happens when you not use any error handling mechanism in your program.

number = int(input('Please enter the number between 1 & 10: '))
print('You have entered number',number)

Above programme will work correctly as long as the user enters a number, but what happens if the users try to puts some other data type(like a string or a list).

Please enter the number between 1 > 10: 'Hi'
Traceback (most recent call last):
   File "C:/Python/Python361/exception2.py", line 1, in <module>
      number = int(input('Please enter the number between 1 & 10: '))
ValueError: invalid literal for int() with base 10: "'Hi'"

Now ValueError is an exception type. Let’s try to rewrite the above code with exception handling.

import sys

print('Previous code with exception handling')

try:
   number = int(input('Enter number between 1 > 10: '))

except(ValueError):
   print('Error..numbers only')
   sys.exit()

print('You have entered number: ',number)

If we run the program, and enter a string (instead of a number), we can see that we get a different result.

Previous code with exception handling
Enter number between 1 > 10: 'Hi'
Error..numbers only

Raising Exceptions

To raise your exceptions from your own methods you need to use raise keyword like this

raise ExceptionClass(‘Some Text Here’)

Let’s take an example

def enterAge(age):
   if age<0:
      raise ValueError('Only positive integers are allowed')
   if age % 2 ==0:
      print('Entered Age is even')
   else:
      print('Entered Age is odd')

try:
   num = int(input('Enter your age: '))
   enterAge(num)
except ValueError:
   print('Only positive integers are allowed')

Run the program and enter positive integer.

Expected Output

Enter your age: 12
Entered Age is even

But when we try to enter a negative number we get,

Expected Output

Enter your age: -2
Only positive integers are allowed

Creating Custom exception class

You can create a custom exception class by Extending BaseException class or subclass of BaseException.

From above diagram we can see most of the exception classes in Python extends from the BaseException class. You can derive your own exception class from BaseException class or from its subclass.

Create a new file called NegativeNumberException.py and write the following code.

class NegativeNumberException(RuntimeError):
   def __init__(self, age):
      super().__init__()
      self.age = age

Above code creates a new exception class named NegativeNumberException, which consists of only constructor which call parent class constructor using super()__init__() and sets the age.

Now to create your own custom exception class, will write some code and import the new exception class.

from NegativeNumberException import NegativeNumberException
def enterage(age):
   if age < 0:
      raise NegativeNumberException('Only positive integers are allowed')

   if age % 2 == 0:
      print('Age is Even')

   else:
      print('Age is Odd')

try:
   num = int(input('Enter your age: '))
   enterage(num)
except NegativeNumberException:
   print('Only positive integers are allowed')
except:
   print('Something is wrong')

Output

Enter your age: -2
Only positive integers are allowed

Another way to create a custom Exception class.

class customException(Exception):
   def __init__(self, value):
      self.parameter = value

   def __str__(self):
      return repr(self.parameter)
try:
   raise customException('My Useful Error Message!')
except customException as instance:
   print('Caught: ' + instance.parameter)

Output

Caught: My Useful Error Message!

Exception hierarchy

The class hierarchy for built-in exceptions is −

+-- SystemExit 
+-- KeyboardInterrupt 
+-- GeneratorExit 
+-- Exception 
+-- StopIteration 
+-- StopAsyncIteration 
+-- ArithmeticError 
| +-- FloatingPointError 
| +-- OverflowError 
| +-- ZeroDivisionError 
+-- AssertionError 
+-- AttributeError 
+-- BufferError 
+-- EOFError 
+-- ImportError 
+-- LookupError 
| +-- IndexError 
| +-- KeyError 
+-- MemoryError 
+-- NameError 
| +-- UnboundLocalError 
+-- OSError 
| +-- BlockingIOError 
| +-- ChildProcessError 
| +-- ConnectionError 
| | +-- BrokenPipeError 
| | +-- ConnectionAbortedError 
| | +-- ConnectionRefusedError 
| | +-- ConnectionResetError 
| +-- FileExistsError 
| +-- FileNotFoundError 
| +-- InterruptedError 
| +-- IsADirectoryError 
| +-- NotADirectoryError 
| +-- PermissionError 
| +-- ProcessLookupError 
| +-- TimeoutError 
+-- ReferenceError 
+-- RuntimeError 
| +-- NotImplementedError 
| +-- RecursionError 
+-- SyntaxError 
| +-- IndentationError
| +-- TabError 
+-- SystemError 
+-- TypeError 
+-- ValueError 
| +-- UnicodeError 
| +-- UnicodeDecodeError 
| +-- UnicodeEncodeError 
| +-- UnicodeTranslateError 
+-- Warning 
+-- DeprecationWarning 
+-- PendingDeprecationWarning 
+-- RuntimeWarning 
+-- SyntaxWarning 
+-- UserWarning 
+-- FutureWarning 
+-- ImportWarning 
+-- UnicodeWarning 
+-- BytesWarning 
+-- ResourceWarning

Object Oriented Python - Object Serialization

In the context of data storage, serialization is the process of translating data structures or object state into a format that can be stored (for example, in a file or memory buffer) or transmitted and reconstructed later.

In serialization, an object is transformed into a format that can be stored, so as to be able to deserialize it later and recreate the original object from the serialized format.

Pickle

Pickling is the process whereby a Python object hierarchy is converted into a byte stream (usually not human readable) to be written to a file, this is also known as Serialization. Unpickling is the reverse operation, whereby a byte stream is converted back into a working Python object hierarchy.

Pickle is operationally simplest way to store the object. The Python Pickle module is an object-oriented way to store objects directly in a special storage format.

What can it do?

  • Pickle can store and reproduce dictionaries and lists very easily.
  • Stores object attributes and restores them back to the same State.

What pickle can’t do?

  • It does not save an objects code. Only it’s attributes values.
  • It cannot store file handles or connection sockets.

In short we can say, pickling is a way to store and retrieve data variables into and out from files where variables can be lists, classes, etc.

To Pickle something you must −

  • import pickle
  • Write a variable to file, something like
pickle.dump(mystring, outfile, protocol),

where 3rd argument protocol is optional To unpickling something you must −

Import pickle

Write a variable to a file, something like

myString = pickle.load(inputfile)

Methods

The pickle interface provides four different methods.

  • dump() − The dump() method serializes to an open file (file-like object).

  • dumps() − Serializes to a string

  • load() − Deserializes from an open-like object.

  • loads() − Deserializes from a string.

Based on above procedure, below is an example of “pickling”.

Output

My Cat pussy is White and has 4 legs
Would you like to see her pickled? Here she is!
b'\x80\x03c__main__\nCat\nq\x00)\x81q\x01}q\x02(X\x0e\x00\x00\x00number_of_legsq\x03K\x04X\x05\x00\x00\x00colorq\x04X\x05\x00\x00\x00Whiteq\x05ub.'

So, in the example above, we have created an instance of a Cat class and then we’ve pickled it, transforming our “Cat” instance into a simple array of bytes.

This way we can easily store the bytes array on a binary file or in a database field and restore it back to its original form from our storage support in a later time.

Also if you want to create a file with a pickled object, you can use the dump() method ( instead of the dumps*()* one) passing also an opened binary file and the pickling result will be stored in the file automatically.

[….]
binary_file = open(my_pickled_Pussy.bin', mode='wb')
my_pickled_Pussy = pickle.dump(Pussy, binary_file)
binary_file.close()

Unpickling

The process that takes a binary array and converts it to an object hierarchy is called unpickling.

The unpickling process is done by using the load() function of the pickle module and returns a complete object hierarchy from a simple bytes array.

Let’s use the load function in our previous example.

Output

MeOw is black
Pussy is white

JSON

JSON(JavaScript Object Notation) has been part of the Python standard library is a lightweight data-interchange format. It is easy for humans to read and write. It is easy to parse and generate.

Because of its simplicity, JSON is a way by which we store and exchange data, which is accomplished through its JSON syntax, and is used in many web applications. As it is in human readable format, and this may be one of the reasons for using it in data transmission, in addition to its effectiveness when working with APIs.

An example of JSON-formatted data is as follow −

{"EmployID": 40203, "Name": "Zack", "Age":54, "isEmployed": True}

Python makes it simple to work with Json files. The module sused for this purpose is the JSON module. This module should be included (built-in) within your Python installation.

So let’s see how can we convert Python dictionary to JSON and write it to a text file.

JSON to Python

Reading JSON means converting JSON into a Python value (object). The json library parses JSON into a dictionary or list in Python. In order to do that, we use the loads() function (load from a string), as follow −

Output

Below is one sample json file,

data1.json
{"menu": {
   "id": "file",
   "value": "File",
   "popup": {
      "menuitem": [
         {"value": "New", "onclick": "CreateNewDoc()"},
         {"value": "Open", "onclick": "OpenDoc()"},
         {"value": "Close", "onclick": "CloseDoc()"}
      ]
   }
}}

Above content (Data1.json) looks like a conventional dictionary. We can use pickle to store this file but the output of it is not human readable form.

JSON(Java Script Object Notification) is a very simple format and that’s one of the reason for its popularity. Now let’s look into json output through below program.

Output

Above we open the json file (data1.json) for reading, obtain the file handler and pass on to json.load and getting back the object. When we try to print the output of the object, its same as the json file. Although the type of the object is dictionary, it comes out as a Python object. Writing to the json is simple as we saw this pickle. Above we load the json file, add another key value pair and writing it back to the same json file. Now if we see out data1.json, it looks different .i.e. not in the same format as we see previously.

To make our Output looks same (human readable format), add the couple of arguments into our last line of the program,

json.dump(conf, fh, indent = 4, separators = (‘,’, ‘: ‘))

Similarly like pickle, we can print the string with dumps and load with loads. Below is an example of that,

YAML

YAML may be the most human friendly data serialization standard for all programming languages.

Python yaml module is called pyaml

YAML is an alternative to JSON −

  • Human readable code − YAML is the most human readable format so much so that even its front-page content is displayed in YAML to make this point.

  • Compact code − In YAML we use whitespace indentation to denote structure not brackets.

  • Syntax for relational data − For internal references we use anchors (&) and aliases (*).

  • One of the area where it is used widely is for viewing/editing of data structures − for example configuration files, dumping during debugging and document headers.

Installing YAML

As yaml is not a built-in module, we need to install it manually. Best way to install yaml on windows machine is through pip. Run below command on your windows terminal to install yaml,

pip install pyaml (Windows machine)
sudo pip install pyaml (*nix and Mac)

On running above command, screen will display something like below based on what’s the current latest version.

Collecting pyaml
Using cached pyaml-17.12.1-py2.py3-none-any.whl
Collecting PyYAML (from pyaml)
Using cached PyYAML-3.12.tar.gz
Installing collected packages: PyYAML, pyaml
Running setup.py install for PyYAML ... done
Successfully installed PyYAML-3.12 pyaml-17.12.1

To test it, go to the Python shell and import the yaml module, import yaml, if no error is found, then we can say installation is successful.

After installing pyaml, let’s look at below code,

script_yaml1.py

Above we created three different data structure, dictionary, list and tuple. On each of the structure, we do yaml.dump. Important point is how the output is displayed on the screen.

Output

Dictionary output looks clean .ie. key: value.

White space to separate different objects.

List is notated with dash (-)

Tuple is indicated first with !!Python/tuple and then in the same format as lists.

Loading a yaml file

So let’s say I have one yaml file, which contains,

---
# An employee record
name: Raagvendra Joshi
job: Developer
skill: Oracle
employed: True
foods:
   - Apple
   - Orange
   - Strawberry
   - Mango
languages:
   Oracle: Elite
   power_builder: Elite
   Full Stack Developer: Lame
education:
   4 GCSEs
   3 A-Levels
   MCA in something called com

Now let’s write a code to load this yaml file through yaml.load function. Below is code for the same.

As the output doesn’t looks that much readable, I prettify it by using json in the end. Compare the output we got and the actual yaml file we have.

Output

One of the most important aspect of software development is debugging. In this section we’ll see different ways of Python debugging either with built-in debugger or third party debuggers.

PDB – The Python Debugger

The module PDB supports setting breakpoints. A breakpoint is an intentional pause of the program, where you can get more information about the programs state.

To set a breakpoint, insert the line

pdb.set_trace()

Example

pdb_example1.py
import pdb
x = 9
y = 7
pdb.set_trace()
total = x + y
pdb.set_trace()

We have inserted a few breakpoints in this program. The program will pause at each breakpoint (pdb.set_trace()). To view a variables contents simply type the variable name.

c:\Python\Python361>Python pdb_example1.py
> c:\Python\Python361\pdb_example1.py(8)<module>()
-> total = x + y
(Pdb) x
9
(Pdb) y
7
(Pdb) total
*** NameError: name 'total' is not defined
(Pdb)

Press c or continue to go on with the programs execution until the next breakpoint.

(Pdb) c
--Return--
> c:\Python\Python361\pdb_example1.py(8)<module>()->None
-> total = x + y
(Pdb) total
16

Eventually, you will need to debug much bigger programs – programs that use subroutines. And sometimes, the problem that you’re trying to find will lie inside a subroutine. Consider the following program.

import pdb
def squar(x, y):
   out_squared = x^2 + y^2
   return out_squared
if __name__ == "__main__":
   #pdb.set_trace()
   print (squar(4, 5))

Now on running the above program,

c:\Python\Python361>Python pdb_example2.py
> c:\Python\Python361\pdb_example2.py(10)<module>()
-> print (squar(4, 5))
(Pdb)

We can use ? to get help, but the arrow indicates the line that’s about to be executed. At this point it’s helpful to hit s to s to step into that line.

(Pdb) s
--Call--
>c:\Python\Python361\pdb_example2.py(3)squar()
-> def squar(x, y):

This is a call to a function. If you want an overview of where you are in your code, try l −

(Pdb) l
1 import pdb
2
3 def squar(x, y):
4 -> out_squared = x^2 + y^2
5
6 return out_squared
7
8 if __name__ == "__main__":
9 pdb.set_trace()
10 print (squar(4, 5))
[EOF]
(Pdb)

You can hit n to advance to the next line. At this point you are inside the out_squared method and you have access to the variable declared inside the function .i.e. x and y.

(Pdb) x
4
(Pdb) y
5
(Pdb) x^2
6
(Pdb) y^2
7
(Pdb) x**2
16
(Pdb) y**2
25
(Pdb)

So we can see the ^ operator is not what we wanted instead we need to use ** operator to do squares.

This way we can debug our program inside the functions/methods.

Logging

The logging module has been a part of Python’s Standard Library since Python version 2.3. As it’s a built-in module all Python module can participate in logging, so that our application log can include your own message integrated with messages from third party module. It provides a lot of flexibility and functionality.

Benefits of Logging

  • Diagnostic logging − It records events related to the application’s operation.

  • Audit logging − It records events for business analysis.

Messages are written and logged at levels of “severity” &minu

  • DEBUG (debug()) − diagnostic messages for development.

  • INFO (info()) − standard “progress” messages.

  • WARNING (warning()) − detected a non-serious issue.

  • ERROR (error()) − encountered an error, possibly serious.

  • CRITICAL (critical()) − usually a fatal error (program stops).

Let’s looks into below simple program,

import logging

logging.basicConfig(level=logging.INFO)

logging.debug('this message will be ignored') # This will not print
logging.info('This should be logged') # it'll print
logging.warning('And this, too') # It'll print

Above we are logging messages on severity level. First we import the module, call basicConfig and set the logging level. Level we set above is INFO. Then we have three different statement: debug statement, info statement and a warning statement.

Output of logging1.py

INFO:root:This should be logged
WARNING:root:And this, too

As the info statement is below debug statement, we are not able to see the debug message. To get the debug statement too in the Output terminal, all we need to change is the basicConfig level.

logging.basicConfig(level = logging.DEBUG)

And in the Output we can see,

DEBUG:root:this message will be ignored
INFO:root:This should be logged
WARNING:root:And this, too

Also the default behavior means if we don’t set any logging level is warning. Just comment out the second line from the above program and run the code.

#logging.basicConfig(level = logging.DEBUG)

Output

WARNING:root:And this, too

Python built in logging level are actually integers.

>>> import logging
>>>
>>> logging.DEBUG
10
>>> logging.CRITICAL
50
>>> logging.WARNING
30
>>> logging.INFO
20
>>> logging.ERROR
40
>>>

We can also save the log messages into the file.

logging.basicConfig(level = logging.DEBUG, filename = 'logging.log')

Now all log messages will go the file (logging.log) in your current working directory instead of the screen. This is a much better approach as it lets us to do post analysis of the messages we got.

We can also set the date stamp with our log message.

logging.basicConfig(level=logging.DEBUG, format = '%(asctime)s %(levelname)s:%(message)s')

Output will get something like,

2018-03-08 19:30:00,066 DEBUG:this message will be ignored
2018-03-08 19:30:00,176 INFO:This should be logged
2018-03-08 19:30:00,201 WARNING:And this, too

Benchmarking

Benchmarking or profiling is basically to test how fast is your code executes and where the bottlenecks are? The main reason to do this is for optimization.

timeit

Python comes with a in-built module called timeit. You can use it to time small code snippets. The timeit module uses platform-specific time functions so that you will get the most accurate timings possible.

So, it allows us to compare two shipment of code taken by each and then optimize the scripts to given better performance.

The timeit module has a command line interface, but it can also be imported.

There are two ways to call a script. Let’s use the script first, for that run the below code and see the Output.

import timeit
print ( 'by index: ', timeit.timeit(stmt = "mydict['c']", setup = "mydict = {'a':5, 'b':10, 'c':15}", number = 1000000))
print ( 'by get: ', timeit.timeit(stmt = 'mydict.get("c")', setup = 'mydict = {"a":5, "b":10, "c":15}', number = 1000000))

Output

by index: 0.1809192126703489
by get: 0.6088525265034692

Above we use two different method .i.e. by subscript and get to access the dictionary key value. We execute statement 1 million times as it executes too fast for a very small data. Now we can see the index access much faster as compared to the get. We can run the code multiply times and there will be slight variation in the time execution to get the better understanding.

Another way is to run the above test in the command line. Let’s do it,

c:\Python\Python361>Python -m timeit -n 1000000 -s "mydict = {'a': 5, 'b':10, 'c':15}" "mydict['c']"
1000000 loops, best of 3: 0.187 usec per loop

c:\Python\Python361>Python -m timeit -n 1000000 -s "mydict = {'a': 5, 'b':10, 'c':15}" "mydict.get('c')"
1000000 loops, best of 3: 0.659 usec per loop

Above output may vary based on your system hardware and what all applications are running currently in your system.

Below we can use the timeit module, if we want to call to a function. As we can add multiple statement inside the function to test.

import timeit

def testme(this_dict, key):
   return this_dict[key]

print (timeit.timeit("testme(mydict, key)", setup = "from __main__ import testme; mydict = {'a':9, 'b':18, 'c':27}; key = 'c'", number = 1000000))

Output

0.7713474590139164

Object Oriented Python - Libraries

Requests − Python Requests Module

Requests is a Python module which is an elegant and simple HTTP library for Python. With this you can send all kinds of HTTP requests. With this library we can add headers, form data, multipart files and parameters and access the response data.

As Requests is not a built-in module, so we need to install it first.

You can install it by running the following command in the terminal −

pip install requests

Once you have installed the module, you can verify if the installation is successful by typing below command in the Python shell.

import requests

If the installation has been successful, you won’t see any error message.

Making a GET Request

As a means of example we’ll be using the “pokeapi”

Output −

Making POST Requests

The requests library methods for all of the HTTP verbs currently in use. If you wanted to make a simple POST request to an API endpoint then you can do that like so −

req = requests.post(‘http://api/user’, data = None, json = None)

This would work in exactly the same fashion as our previous GET request, however it features two additional keyword parameters −

  • data which can be populated with say a dictionary, a file or bytes that will be passed in the HTTP body of our POST request.

  • json which can be populated with a json object that will be passed in the body of our HTTP request also.

Pandas: Python Library Pandas

Pandas is an open-source Python Library providing high-performance data manipulation and analysis tool using its powerful data structures. Pandas is one of the most widely used Python libraries in data science. It is mainly used for data munging, and with good reason: Powerful and flexible group of functionality.

Built on Numpy package and the key data structure is called the DataFrame. These dataframes allows us to store and manipulate tabular data in rows of observations and columns of variables.

There are several ways to create a DataFrame. One way is to use a dictionary. For example −

Output

From the output we can see new brics DataFrame, Pandas has assigned a key for each country as the numerical values 0 through 4.

If instead of giving indexing values from 0 to 4, we would like to have different index values, say the two letter country code, you can do that easily as well −

Adding below one lines in the above code, gives

brics.index = ['BR', 'RU', 'IN', 'CH', 'SA']

Output

Indexing DataFrames

Output

Pygame

Pygame is the open source and cross-platform library that is for making multimedia applications including games. It includes computer graphics and sound libraries designed to be used with the Python programming language. You can develop many cool games with Pygame.’

Overview

Pygame is composed of various modules, each dealing with a specific set of tasks. For example, the display module deals with the display window and screen, the draw module provides functions to draw shapes and the key module works with the keyboard. These are just some of the modules of the library.

The home of the Pygame library is at https://www.pygame.org/news

To make a Pygame application, you follow these steps −

Import the Pygame library

import pygame

Initialize the Pygame library

pygame.init()

Create a window.

screen = Pygame.display.set_mode((560,480))
Pygame.display.set_caption(‘First Pygame Game’)

Initialize game objects

In this step we load images, load sounds, do object positioning, set up some state variables, etc.

Start the game loop.

It is just a loop where we continuously handle events, checks for input, move objects, and draw them. Each iteration of the loop is called a frame.

Let’s put all the above logic into one below program,

Pygame_script.py

Output

Beautiful Soup: Web Scraping with Beautiful Soup

The general idea behind web scraping is to get the data that exists on a website, and convert it into some format that is usable for analysis.

It’s a Python library for pulling data out of HTML or XML files. With your favourite parser it provide idiomatic ways of navigating, searching and modifying the parse tree.

As BeautifulSoup is not a built-in library, we need to install it before we try to use it. To install BeautifulSoup, run the below command

$ apt-get install Python-bs4 # For Linux and Python2 
$ apt-get install Python3-bs4 # for Linux based system and Python3.

$ easy_install beautifulsoup4 # For windows machine, 
Or 
$ pip instal beatifulsoup4 # For window machine

Once the installation is done, we are ready to run few examples and explores Beautifulsoup in details,

Output

Below are some simple ways to navigate that data structure −

One common task is extracting all the URLs found within a page’s <a> tags −

Another common task is extracting all the text from a page −