Python 3 - Guide rapide

Le module future

Python 3.x a introduit des mots-clés et fonctionnalités incompatibles avec Python 2 qui peuvent être importés via le module intégré __future__ de Python 2. Il est recommandé d'utiliser les importations __future__, si vous prévoyez la prise en charge de Python 3.x pour votre code.

Par exemple, si nous voulons le comportement de division d'entiers de Python 3.x dans Python 2, ajoutez l'instruction d'importation suivante.

from __future__ import division

La fonction d'impression

Le changement le plus notable et le plus connu de Python 3 est la façon dont le printla fonction est utilisée. L'utilisation de parenthèses () avec la fonction d'impression est désormais obligatoire. C'était facultatif dans Python 2.

print "Hello World" #is acceptable in Python 2
print ("Hello World") # in Python 3, print must be followed by ()

La fonction print () insère une nouvelle ligne à la fin, par défaut. Dans Python 2, il peut être supprimé en mettant «,» à la fin. Dans Python 3, "end = ''" ajoute un espace au lieu d'une nouvelle ligne.

print x,           # Trailing comma suppresses newline in Python 2
print(x, end=" ")  # Appends a space instead of a newline in Python 3

Lecture de l'entrée depuis le clavier

Python 2 a deux versions de fonctions d'entrée, input() et raw_input(). La fonction input () traite les données reçues comme une chaîne si elles sont incluses entre guillemets '' ou "", sinon les données sont traitées comme un nombre.

Dans Python 3, la fonction raw_input () est obsolète. De plus, les données reçues sont toujours traitées comme une chaîne.

In Python 2

>>> x = input('something:') 
something:10 #entered data is treated as number
>>> x
10

>>> x = input('something:')
something:'10' #entered data is treated as string
>>> x
'10'

>>> x = raw_input("something:")
something:10 #entered data is treated as string even without ''
>>> x
'10'

>>> x = raw_input("something:")
something:'10' #entered data treated as string including ''
>>> x
"'10'"

In Python 3

>>> x = input("something:")
something:10
>>> x
'10'

>>> x = input("something:")
something:'10' #entered data treated as string with or without ''
>>> x
"'10'"

>>> x = raw_input("something:") # will result NameError
Traceback (most recent call last):
   File "<pyshell#3>", line 1, in 
  <module>
   x = raw_input("something:")
NameError: name 'raw_input' is not defined

Division entière

Dans Python 2, le résultat de la division de deux entiers est arrondi à l'entier le plus proche. En conséquence, 3/2 affichera 1. Pour obtenir une division en virgule flottante, le numérateur ou le dénominateur doit être explicitement utilisé comme flottant. Par conséquent, 3,0 / 2 ou 3 / 2,0 ou 3,0 / 2,0 entraîneront 1,5

Python 3 évalue 3/2 comme 1,5 par défaut, ce qui est plus intuitif pour les nouveaux programmeurs.

Représentation Unicode

Python 2 vous oblige à marquer une chaîne avec au si vous souhaitez la stocker au format Unicode.

Python 3 stocke les chaînes au format Unicode, par défaut. Nous avons des chaînes Unicode (utf-8) et 2 classes d'octets: des tableaux d'octets et d'octets.

Fonction xrange () supprimée

En Python 2, range () renvoie une liste et xrange () renvoie un objet qui ne générera que les éléments de la plage lorsque cela sera nécessaire, économisant ainsi de la mémoire.

Dans Python 3, la fonction range () est supprimée et xrange () a été renommé en range (). De plus, l'objet range () prend en charge le découpage dans Python 3.2 et versions ultérieures.

lever une exception

Python 2 accepte les deux notations, la syntaxe «ancienne» et «nouvelle»; Python 3 déclenche une SyntaxError si nous ne mettons pas l'argument d'exception entre parenthèses.

raise IOError, "file error" #This is accepted in Python 2
raise IOError("file error") #This is also accepted in Python 2
raise IOError, "file error" #syntax error is raised in Python 3
raise IOError("file error") #this is the recommended syntax in Python 3

Arguments dans les exceptions

Dans Python 3, les arguments d'exception doivent être déclarés avec le mot clé 'as'.

except Myerror, err: # In Python2
except Myerror as err: #In Python 3

Fonction next () et méthode .next ()

En Python 2, next () en tant que méthode d'objet générateur, est autorisé. En Python 2, la fonction next (), pour itérer sur un objet générateur, est également acceptée. Dans Python 3, cependant, next (0 en tant que méthode de générateur est interrompue et lève AttributeError.

gen = (letter for letter in 'Hello World') # creates generator object
next(my_generator) #allowed in Python 2 and Python 3
my_generator.next() #allowed in Python 2. raises AttributeError in Python 3

Utilitaire 2to3

Avec l'interpréteur Python 3, le script 2to3.py est généralement installé dans le dossier tools / scripts. Il lit le code source Python 2.x et applique une série de correcteurs pour le transformer en un code Python 3.x valide.

Here is a sample Python 2 code (area.py):

def area(x,y = 3.14): 
   a = y*x*x
   print a
   return a

a = area(10)
print "area",a

To convert into Python 3 version:

$2to3 -w area.py

Converted code :

def area(x,y = 3.14): # formal parameters
   a = y*x*x
   print (a)
   return a

a = area(10)
print("area",a)

Python est un langage de script de haut niveau, interprété, interactif et orienté objet. Python est conçu pour être hautement lisible. Il utilise fréquemment des mots-clés anglais alors que les autres langues utilisent des ponctuations. Il a moins de constructions syntaxiques que les autres langages.

Python is Interpreted- Python est traité à l'exécution par l'interpréteur. Vous n'avez pas besoin de compiler votre programme avant de l'exécuter. Ceci est similaire à PERL et PHP.
Python is Interactive - Vous pouvez en fait vous asseoir à une invite Python et interagir directement avec l'interpréteur pour écrire vos programmes.
Python is Object-Oriented - Python prend en charge le style orienté objet ou la technique de programmation qui encapsule le code dans les objets.
Python is a Beginner's Language - Python est un excellent langage pour les programmeurs de niveau débutant et prend en charge le développement d'un large éventail d'applications, du simple traitement de texte aux navigateurs WWW en passant par les jeux.

Histoire de Python

Python a été développé par Guido van Rossum à la fin des années 80 et au début des années 90 à l'Institut national de recherche en mathématiques et en informatique des Pays-Bas.

Python est dérivé de nombreux autres langages, notamment ABC, Modula-3, C, C ++, Algol-68, SmallTalk et Unix shell et d'autres langages de script.
Python est protégé par copyright. Comme Perl, le code source Python est maintenant disponible sous la licence publique générale GNU (GPL).
Python est maintenant maintenu par une équipe de développement de base à l'institut, bien que Guido van Rossum joue toujours un rôle essentiel dans la direction de ses progrès.
Python 1.0 est sorti en novembre 1994. En 2000, Python 2.0 est sorti. Python 2.7.11 est la dernière édition de Python 2.
Pendant ce temps, Python 3.0 a été publié en 2008. Python 3 n'est pas rétrocompatible avec Python 2. L'accent dans Python 3 avait été sur la suppression des constructions et des modules de programmation en double afin qu '"Il devrait y en avoir un - et de préférence un seul - manière évidente de le faire. " Python 3.5.1 est la dernière version de Python 3.

Fonctionnalités Python

Les fonctionnalités de Python incluent -

Easy-to-learn- Python a peu de mots-clés, une structure simple et une syntaxe clairement définie. Cela permet à un élève de maîtriser la langue rapidement.
Easy-to-read - Le code Python est plus clairement défini et visible aux yeux.
Easy-to-maintain - Le code source de Python est assez facile à maintenir.
A broad standard library - La majeure partie de la bibliothèque de Python est très portable et compatible multiplateforme sous UNIX, Windows et Macintosh.
Interactive Mode - Python prend en charge un mode interactif qui permet des tests interactifs et le débogage d'extraits de code.
Portable - Python peut fonctionner sur une grande variété de plates-formes matérielles et a la même interface sur toutes les plates-formes.
Extendable- Vous pouvez ajouter des modules de bas niveau à l'interpréteur Python. Ces modules permettent aux programmeurs d'ajouter ou de personnaliser leurs outils pour être plus efficaces.
Databases - Python fournit des interfaces à toutes les principales bases de données commerciales.
GUI Programming - Python prend en charge les applications GUI qui peuvent être créées et portées vers de nombreux appels système, bibliothèques et systèmes Windows, tels que Windows MFC, Macintosh et le système X Window d'Unix.
Scalable - Python fournit une meilleure structure et un meilleur support pour les grands programmes que les scripts shell.

Outre les fonctionnalités mentionnées ci-dessus, Python a une grande liste de bonnes fonctionnalités. A, quelques-uns sont énumérés ci-dessous -

Il prend en charge les méthodes de programmation fonctionnelles et structurées ainsi que la POO.
Il peut être utilisé comme langage de script ou peut être compilé en byte-code pour créer de grandes applications.
Il fournit des types de données dynamiques de très haut niveau et prend en charge la vérification de type dynamique.
Il prend en charge le garbage collection automatique.
Il peut être facilement intégré avec C, C ++, COM, ActiveX, CORBA et Java.

Python 3 est disponible pour Windows, Mac OS et la plupart des versions du système d'exploitation Linux. Même si Python 2 est disponible pour de nombreux autres systèmes d'exploitation, la prise en charge de Python 3 n'a pas été rendue disponible pour eux ou a été abandonnée.

Configuration de l'environnement local

Ouvrez une fenêtre de terminal et tapez "python" pour savoir s'il est déjà installé et quelle version est installée.

Obtenir Python

Plate-forme Windows

Les binaires de la dernière version de Python 3 (Python 3.5.1) sont disponibles sur cette page de téléchargement

Les différentes options d'installation suivantes sont disponibles.

Fichier zip intégrable Windows x86-64
Programme d'installation de l'exécutable Windows x86-64
Programme d'installation Web Windows x86-64
Fichier zip intégrable Windows x86
Programme d'installation de l'exécutable Windows x86
Programme d'installation Web Windows x86

Note- Pour installer Python 3.5.1, la configuration minimale requise pour le système d'exploitation est Windows 7 avec SP1. Pour les versions 3.0 à 3.4.x, Windows XP est acceptable.

Plateforme Linux

Différentes versions de Linux utilisent différents gestionnaires de packages pour l'installation de nouveaux packages.

Sur Ubuntu Linux, Python 3 est installé à l'aide de la commande suivante à partir du terminal.

$sudo apt-get install python3-minimal

Installation à partir de la source

Téléchargez l'archive tar source gzippée à partir de l'URL de téléchargement de Python - https://www.python.org/ftp/python/3.5.1/Python-3.5.1.tgz

Extract the tarball
tar xvfz Python-3.5.1.tgz
Configure and Install:
cd Python-3.5.1
./configure --prefix = /opt/python3.5.1
make  
sudo make install

Mac OS

Téléchargez les programmes d'installation Mac OS à partir de cette URL - https://www.python.org/downloads/mac-osx/

Programme d'installation de Mac OS X 64 bits / 32 bits - python-3.5.1-macosx10.6.pkg
Programme d'installation de Mac OS X 32 bits i386 / PPC - python-3.5.1-macosx10.5.pkg

Double-cliquez sur ce fichier de package et suivez les instructions de l'assistant pour l'installer.

Le code source, les binaires, la documentation, les actualités, etc. les plus à jour et les plus récents sont disponibles sur le site officiel de Python -

Python Official Website - https://www.python.org/

Vous pouvez télécharger la documentation Python à partir du site suivant. La documentation est disponible aux formats HTML, PDF et PostScript.

Python Documentation Website- www.python.org/doc/

Configurer PATH

Les programmes et autres fichiers exécutables peuvent se trouver dans de nombreux répertoires. Par conséquent, les systèmes d'exploitation fournissent un chemin de recherche qui répertorie les répertoires dans lesquels il recherche les exécutables.

Les caractéristiques importantes sont -

Le chemin est stocké dans une variable d'environnement, qui est une chaîne nommée gérée par le système d'exploitation. Cette variable contient des informations disponibles pour le shell de commande et d'autres programmes.
La variable de chemin est nommée comme PATH sous Unix ou Path sous Windows (Unix est sensible à la casse; Windows ne l'est pas).
Sous Mac OS, le programme d'installation gère les détails du chemin. Pour appeler l'interpréteur Python à partir d'un répertoire particulier, vous devez ajouter le répertoire Python à votre chemin.

Définition du chemin sous Unix / Linux

Pour ajouter le répertoire Python au chemin d'une session particulière sous Unix -

In the csh shell - tapez setenv PATH "$ PATH: / usr / local / bin / python3" et appuyez sur Entrée.
In the bash shell (Linux) - tapez export PYTHONPATH = / usr / local / bin / python3.4 et appuyez sur Entrée.
In the sh or ksh shell - tapez PATH = "$ PATH: / usr / local / bin / python3" et appuyez sur Entrée.

Note - / usr / local / bin / python3 est le chemin du répertoire Python.

Définition du chemin sous Windows

Pour ajouter le répertoire Python au chemin d'une session particulière dans Windows -

At the command prompt - tapez path% path%; C: \ Python et appuyez sur Entrée.

Note - C: \ Python est le chemin du répertoire Python

Variables d'environnement Python

Voici des variables d'environnement importantes, qui sont reconnues par Python -

Sr.No.	Variable et description
1	PYTHONPATH Il a un rôle similaire à PATH. Cette variable indique à l'interpréteur Python où localiser les fichiers de module importés dans un programme. Il doit inclure le répertoire de la bibliothèque source Python et les répertoires contenant le code source Python. PYTHONPATH est parfois prédéfini par le programme d'installation Python.
2	PYTHONSTARTUP Il contient le chemin d'un fichier d'initialisation contenant le code source Python. Il est exécuté chaque fois que vous démarrez l'interpréteur. Il est nommé .pythonrc.py sous Unix et contient des commandes qui chargent des utilitaires ou modifient PYTHONPATH.
3	PYTHONCASEOK Il est utilisé dans Windows pour demander à Python de trouver la première correspondance insensible à la casse dans une instruction d'importation. Définissez cette variable sur n'importe quelle valeur pour l'activer.
4	PYTHONHOME C'est un chemin de recherche de module alternatif. Il est généralement intégré dans les répertoires PYTHONSTARTUP ou PYTHONPATH pour faciliter le changement de bibliothèques de modules.

Exécuter Python

Il existe trois façons différentes de démarrer Python -

Interprète interactif

Vous pouvez démarrer Python à partir d'Unix, de DOS ou de tout autre système qui vous fournit un interpréteur de ligne de commande ou une fenêtre shell.

Entrer python la ligne de commande.

Commencez immédiatement à coder dans l'interpréteur interactif.

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

Voici la liste de toutes les options de ligne de commande disponibles -

Sr.No.	Option et description
1	-d fournir une sortie de débogage
2	-O générer un bytecode optimisé (résultant en des fichiers .pyo)
3	-S ne pas exécuter le site d'importation pour rechercher les chemins Python au démarrage
4	-v sortie verbeuse (trace détaillée sur les instructions d'importation)
5	-X désactiver les exceptions intégrées basées sur les classes (utilisez simplement des chaînes); obsolète à partir de la version 1.6
6	-c cmd exécuter le script Python envoyé en tant que chaîne cmd
sept	file exécuter un script Python à partir d'un fichier donné

Script depuis la ligne de commande

Un script Python peut être exécuté sur la ligne de commande en appelant l'interpréteur sur votre application, comme illustré dans l'exemple suivant.

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

Note - Assurez-vous que le mode d'autorisation de fichier permet l'exécution.

Environnement de développement intégré

Vous pouvez également exécuter Python à partir d'un environnement d'interface utilisateur graphique (GUI), si vous avez une application GUI sur votre système qui prend en charge Python.

Unix - IDLE est le tout premier IDE Unix pour Python.
Windows - PythonWin est la première interface Windows pour Python et est un IDE avec une interface graphique.
Macintosh - La version Macintosh de Python avec l'IDE IDLE est disponible sur le site principal, téléchargeable sous forme de fichiers MacBinary ou BinHex'd.

Si vous ne parvenez pas à configurer correctement l'environnement, vous pouvez demander l'aide de votre administrateur système. Assurez-vous que l'environnement Python est correctement configuré et fonctionne parfaitement.

Note - Tous les exemples donnés dans les chapitres suivants sont exécutés avec la version Python 3.4.1 disponible sur Windows 7 et Ubuntu Linux.

Nous avons déjà mis en place un environnement de programmation Python en ligne, afin que vous puissiez exécuter tous les exemples disponibles en ligne pendant que vous apprenez la théorie. N'hésitez pas à modifier n'importe quel exemple et à l'exécuter en ligne.

Le langage Python présente de nombreuses similitudes avec Perl, C et Java. Cependant, il existe des différences certaines entre les langues.

Premier programme Python

Exécutons les programmes dans différents modes de programmation.

Programmation en mode interactif

Invoquer l'interpréteur sans passer un fichier de script comme paramètre fait apparaître l'invite suivante -

$ python

Python 3.3.2 (default, Dec 10 2013, 11:35:01)
[GCC 4.6.3] on Linux
Type "help", "copyright", "credits", or "license" for more information.
>>>

On Windows:

Python 3.4.3 (v3.4.3:9b73f1c3e601, Feb 24 2015, 22:43:06) [MSC v.1600 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>>

Tapez le texte suivant à l'invite Python et appuyez sur Entrée -

>>> print ("Hello, Python!")

Si vous exécutez l'ancienne version de Python (Python 2.x), utilisez les parenthèses comme inprintla fonction est facultative. Cela produit le résultat suivant -

Hello, Python!

Programmation en mode script

L'appel de l'interpréteur avec un paramètre de script commence l'exécution du script et continue jusqu'à ce que le script soit terminé. Lorsque le script est terminé, l'interpréteur n'est plus actif.

Écrivons un simple programme Python dans un script. Les fichiers Python ont l'extension.py. Tapez le code source suivant dans un fichier test.py -

print ("Hello, Python!")

Nous supposons que l'interpréteur Python est défini dans PATHvariable. Maintenant, essayez d'exécuter ce programme comme suit -

On Linux

$ python test.py

Cela produit le résultat suivant -

Hello, Python!

On Windows

C:\Python34>Python test.py

Cela produit le résultat suivant -

Hello, Python!

Essayons une autre façon d'exécuter un script Python sous Linux. Voici le fichier test.py modifié -

#!/usr/bin/python3
print ("Hello, Python!")

Nous supposons que l'interpréteur Python est disponible dans le répertoire / usr / bin. Maintenant, essayez d'exécuter ce programme comme suit -

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

Cela produit le résultat suivant -

Hello, Python!

Identificateurs Python

Un identifiant Python est un nom utilisé pour identifier une variable, une fonction, une classe, un module ou un autre objet. Un identifiant commence par une lettre A à Z ou a à z ou un trait de soulignement (_) suivi de zéro ou plusieurs lettres, traits de soulignement et chiffres (0 à 9).

Python n'autorise pas les caractères de ponctuation tels que @, $ et% dans les identificateurs. Python est un langage de programmation sensible à la casse. Donc,Manpower et manpower sont deux identifiants différents en Python.

Voici les conventions de dénomination des identifiants Python -

Les noms de classe commencent par une lettre majuscule. Tous les autres identifiants commencent par une lettre minuscule.
Le fait de commencer un identificateur avec un seul trait de soulignement indique que l'identificateur est privé.
Commencer un identifiant avec deux traits de soulignement en tête indique un identifiant privé fort.
Si l'identificateur se termine également par deux traits de soulignement à la fin, l'identificateur est un nom spécial défini par la langue.

Mots réservés

La liste suivante montre les mots-clés Python. Ce sont des mots réservés et vous ne pouvez pas les utiliser comme constantes ou variables ou tout autre nom d'identifiant. Tous les mots-clés Python contiennent uniquement des lettres minuscules.

et	exec	ne pas
comme	enfin	ou
affirmer	pour	passer
Pause	de	impression
classe	global	élever
continuer	si	revenir
def	importer	essayer
del	dans	tandis que
elif	est	avec
autre	lambda	rendement
sauf

Lignes et retrait

Python n'utilise pas d'accolades ({}) pour indiquer des blocs de code pour les définitions de classe et de fonction ou le contrôle de flux. Les blocs de code sont indiqués par une indentation de ligne, qui est appliquée de manière rigide.

Le nombre d'espaces dans l'indentation est variable, mais toutes les instructions du bloc doivent être indentées du même montant. Par exemple -

if True:
   print ("True")

else:
   print ("False")

Cependant, le bloc suivant génère une erreur -

if True:
   print ("Answer")
   print ("True")

else:
   print "(Answer")
   print ("False")

Ainsi, en Python, toutes les lignes continues indentées avec le même nombre d'espaces formeraient un bloc. L'exemple suivant comporte différents blocs d'instructions -

Note- N'essayez pas de comprendre la logique à ce stade. Assurez-vous simplement d'avoir bien compris les différents blocs, même s'ils sont sans accolades.

#!/usr/bin/python3
import sys

file_finish = "end"
file_text = ""
contents=[]

file_name=input("Enter filename: ")
if len(file_name) == 0:
   print("Please enter filename")
   sys.exit()

try:
   # open file stream
   file = open(file_name, "w")

except IOError:
   print ("There was an error writing to", file_name)
   sys.exit()

print ("Enter '", file_finish,)
print ("' When finished")

while file_text != file_finish:
   file_text = input("Enter text: ")
   contents.append(file_text)

   if file_text == file_finish:
      # close the file
      file.close()
      break

print(contents)
data = ' '.join([str(elem) for elem in contents])  
print(data)
file.write(data)
file.close()
file_name = input("Enter filename: ")

if len(file_name) == 0:
   print ("Next time please enter something")
   sys.exit()

try:
   file = open(file_name, "r")

except IOError:
   print ("There was an error reading file")
   sys.exit()
file_text = file.read()
file.close()
print (file_text)

Déclarations multilignes

Les instructions en Python se terminent généralement par une nouvelle ligne. Cependant, Python autorise l'utilisation du caractère de continuation de ligne (\) pour indiquer que la ligne doit continuer. Par exemple -

total = item_one + \
        item_two + \
        item_three

Les instructions contenues entre les crochets [], {} ou () n'ont pas besoin d'utiliser le caractère de continuation de ligne. Par exemple -

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

Devis en Python

Python accepte les guillemets simples ('), doubles (") et triples (' '' ou" "") pour désigner des chaînes littérales, à condition que le même type de guillemets commence et termine la chaîne.

Les guillemets triples sont utilisés pour couvrir la chaîne sur plusieurs lignes. Par exemple, tous les éléments suivants sont légaux -

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

Commentaires en Python

Un signe de hachage (#) qui n'est pas à l'intérieur d'un littéral de chaîne est le début d'un commentaire. Tous les caractères après le #, jusqu'à la fin de la ligne physique, font partie du commentaire et l'interpréteur Python les ignore.

#!/usr/bin/python3

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

Cela produit le résultat suivant -

Hello, Python!

Vous pouvez taper un commentaire sur la même ligne après une instruction ou une expression -

name = "Madisetti" # This is again comment

Python n'a pas de fonction de commentaire sur plusieurs lignes. Vous devez commenter chaque ligne individuellement comme suit -

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

Utilisation de lignes vides

Une ligne ne contenant que des espaces, éventuellement avec un commentaire, est connue comme une ligne vide et Python l'ignore totalement.

Dans une session d'interprétation interactive, vous devez entrer une ligne physique vide pour terminer une instruction multiligne.

En attente de l'utilisateur

La ligne suivante du programme affiche l'invite et, l'instruction disant «Appuyez sur la touche Entrée pour quitter», puis attend que l'utilisateur agisse -

#!/usr/bin/python3

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

Ici, "\ n \ n" est utilisé pour créer deux nouvelles lignes avant d'afficher la ligne réelle. Une fois que l'utilisateur appuie sur la touche, le programme se termine. C'est une bonne astuce pour garder une fenêtre de console ouverte jusqu'à ce que l'utilisateur en ait fini avec une application.

Déclarations multiples sur une seule ligne

Le point-virgule (;) autorise plusieurs instructions sur une seule ligne étant donné qu'aucune instruction ne démarre un nouveau bloc de code. Voici un exemple de snip utilisant le point-virgule -

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

Plusieurs groupes d'instructions en tant que suites

Les groupes d'instructions individuelles qui forment un seul bloc de code sont appelés suitesen Python. Les instructions composées ou complexes, telles que if, while, def et class nécessitent une ligne d'en-tête et une suite.

Les lignes d'en-tête commencent l'instruction (avec le mot-clé) et se terminent par deux points (:) et sont suivies d'une ou plusieurs lignes qui composent la suite. Par exemple -

if expression : 
   suite
elif expression : 
   suite 
else : 
   suite

Arguments de ligne de commande

De nombreux programmes peuvent être exécutés pour vous fournir des informations de base sur la manière dont ils doivent être exécutés. Python vous permet de faire cela avec -h -

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

[ etc. ]

Vous pouvez également programmer votre script de manière à accepter diverses options. Arguments de ligne de commande est une rubrique avancée. Comprenons-le.

Les variables ne sont rien d'autre que des emplacements de mémoire réservés pour stocker des valeurs. Cela signifie que lorsque vous créez une variable, vous réservez de l'espace dans la mémoire.

En fonction du type de données d'une variable, l'interpréteur alloue de la mémoire et décide de ce qui peut être stocké dans la mémoire réservée. Par conséquent, en attribuant différents types de données aux variables, vous pouvez stocker des entiers, des décimales ou des caractères dans ces variables.

Attribution de valeurs à des variables

Les variables Python n'ont pas besoin de déclaration explicite pour réserver de l'espace mémoire. La déclaration se produit automatiquement lorsque vous affectez une valeur à une variable. Le signe égal (=) est utilisé pour attribuer des valeurs aux variables.

L'opérande à gauche de l'opérateur = est le nom de la variable et l'opérande à droite de l'opérateur = est la valeur stockée dans la variable. Par exemple -

#!/usr/bin/python3

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

print (counter)
print (miles)
print (name)

Ici, 100, 1000,0 et «John» sont les valeurs attribuées respectivement aux variables compteur, miles et nom. Cela produit le résultat suivant -

100
1000.0
John

Affectation multiple

Python vous permet d'attribuer une seule valeur à plusieurs variables simultanément.

Par exemple -

a = b = c = 1

Ici, un objet entier est créé avec la valeur 1 et les trois variables sont affectées au même emplacement mémoire. Vous pouvez également affecter plusieurs objets à plusieurs variables. Par exemple -

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

Ici, deux objets entiers avec les valeurs 1 et 2 sont affectés aux variables a et b respectivement, et un objet chaîne avec la valeur «john» est affecté à la variable c.

Types de données standard

Les données stockées en mémoire peuvent être de plusieurs types. Par exemple, l'âge d'une personne est stocké sous forme de valeur numérique et son adresse est stockée sous forme de caractères alphanumériques. Python a différents types de données standard qui sont utilisés pour définir les opérations possibles sur eux et la méthode de stockage pour chacun d'eux.

Python a cinq types de données standard -

Numbers
String
List
Tuple
Dictionary

Numéros Python

Les types de données numériques stockent des valeurs numériques. Les objets numériques sont créés lorsque vous leur attribuez une valeur. Par exemple -

var1 = 1
var2 = 10

Vous pouvez également supprimer la référence à un objet numérique en utilisant le deldéclaration. La syntaxe dudel la déclaration est -

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

Vous pouvez supprimer un seul objet ou plusieurs objets en utilisant le del déclaration.

Par exemple -

del var
del var_a, var_b

Python prend en charge trois types numériques différents -

int (entiers signés)
float (valeurs réelles en virgule flottante)
complexe (nombres complexes)

Tous les entiers en Python3 sont représentés sous forme d'entiers longs. Par conséquent, il n'y a pas de type de nombre distinct aussi longtemps.

Exemples

Voici quelques exemples de nombres -

int	flotte	complexe
dix	0,0	3.14j
100	15,20	45.j
-786	-21,9	9.322e-36j
080	32,3 + e18	.876j
-0490	-90.	-.6545 + 0J
-0x260	-32,54e100	3e + 26J
0x69	70.2-E12	4.53e-7j

Un nombre complexe consiste en une paire ordonnée de nombres réels à virgule flottante désignés par x + yj, où x et y sont des nombres réels et j est l'unité imaginaire.

Chaînes Python

Les chaînes en Python sont identifiées comme un ensemble contigu de caractères représenté entre guillemets. Python autorise une paire de guillemets simples ou doubles. Les sous-ensembles de chaînes peuvent être pris en utilisant l'opérateur de tranche ([] et [:]) avec des index commençant à 0 au début de la chaîne et allant de -1 à la fin.

Le signe plus (+) est l'opérateur de concaténation de chaîne et l'astérisque (*) est l'opérateur de répétition. Par exemple -

#!/usr/bin/python3

str = 'Hello World!'

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

Cela produira le résultat suivant -

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

Listes Python

Les listes sont les types de données composés les plus polyvalents de Python. Une liste contient des éléments séparés par des virgules et placés entre crochets ([]). Dans une certaine mesure, les listes sont similaires aux tableaux en C. L'une des différences entre elles est que tous les éléments appartenant à une liste peuvent être de types de données différents.

Les valeurs stockées dans une liste sont accessibles à l'aide de l'opérateur de tranche ([] et [:]) avec des index commençant à 0 au début de la liste et allant jusqu'à la fin -1. Le signe plus (+) est l'opérateur de concaténation de liste et l'astérisque (*) est l'opérateur de répétition. Par exemple -

#!/usr/bin/python3

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

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

Cela produit le résultat suivant -

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

Tuples Python

Un tuple est un autre type de données de séquence similaire à la liste. Un tuple se compose d'un certain nombre de valeurs séparées par des virgules. Contrairement aux listes, cependant, les tuples sont entre parenthèses.

La principale différence entre les listes et les tuples est - Les listes sont entre crochets ([]) et leurs éléments et leur taille peuvent être modifiés, tandis que les tuples sont entre parenthèses (()) et ne peuvent pas être mis à jour. Les tuples peuvent être considérés commeread-onlylistes. Par exemple -

#!/usr/bin/python3

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

print (tuple)           # Prints complete tuple
print (tuple[0])        # Prints first element of the tuple
print (tuple[1:3])      # Prints elements starting from 2nd till 3rd 
print (tuple[2:])       # Prints elements starting from 3rd element
print (tinytuple * 2)   # Prints tuple two times
print (tuple + tinytuple) # Prints concatenated tuple

Cela produit le résultat suivant -

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

Le code suivant n'est pas valide avec tuple, car nous avons tenté de mettre à jour un tuple, ce qui n'est pas autorisé. Un cas similaire est possible avec des listes -

#!/usr/bin/python3

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

Dictionnaire Python

Les dictionnaires de Python sont en quelque sorte de type table de hachage. Ils fonctionnent comme des tableaux associatifs ou des hachages trouvés en Perl et se composent de paires clé-valeur. Une clé de dictionnaire peut être presque n'importe quel type Python, mais il s'agit généralement de nombres ou de chaînes. Les valeurs, en revanche, peuvent être n'importe quel objet Python arbitraire.

Les dictionnaires sont entourés d'accolades ({}) et les valeurs peuvent être attribuées et accessibles à l'aide d'accolades ([]). Par exemple -

#!/usr/bin/python3

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

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

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

Cela produit le résultat suivant -

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

Les dictionnaires n'ont aucune notion d'ordre parmi les éléments. Il est incorrect de dire que les éléments sont «hors service»; ils ne sont tout simplement pas ordonnés.

Conversion de type de données

Parfois, vous devrez peut-être effectuer des conversions entre les types intégrés. Pour convertir entre les types, vous utilisez simplement les noms de type comme une fonction.

Il existe plusieurs fonctions intégrées pour effectuer la conversion d'un type de données à un autre. Ces fonctions renvoient un nouvel objet représentant la valeur convertie.

Sr.No.	Description de la fonction
1	int(x [,base]) Convertit x en entier. La base spécifie la base si x est une chaîne.
2	float(x) Convertit x en nombre à virgule flottante.
3	complex(real [,imag]) Crée un nombre complexe.
4	str(x) Convertit l'objet x en une représentation sous forme de chaîne.
5	repr(x) Convertit l'objet x en une chaîne d'expression.
6	eval(str) Évalue une chaîne et renvoie un objet.
sept	tuple(s) Convertit s en tuple.
8	list(s) Convertit les s en liste.
9	set(s) Convertit s en un ensemble.
dix	dict(d) Crée un dictionnaire. d doit être une séquence de tuples (clé, valeur).
11	frozenset(s) Convertit les s en ensemble figé.
12	chr(x) Convertit un entier en caractère.
13	unichr(x) Convertit un entier en caractère Unicode.
14	ord(x) Convertit un seul caractère en sa valeur entière.
15	hex(x) Convertit un entier en chaîne hexadécimale.
16	oct(x) Convertit un entier en chaîne octale.

Les opérateurs sont les constructions qui peuvent manipuler la valeur des opérandes. Considérez l'expression 4 + 5 = 9. Ici, 4 et 5 sont appelés les opérandes et + est appelé l'opérateur.

Types d'opérateurs

Le langage Python prend en charge les types d'opérateurs suivants -

Opérateurs arithmétiques
Opérateurs de comparaison (relationnels)
Opérateurs d'affectation
Opérateurs logiques
Opérateurs au niveau du bit
Opérateurs d'adhésion
Opérateurs d'identité

Jetons un coup d'œil à tous les opérateurs un par un.

Opérateurs arithmétiques Python

Supposons une variable a contient la valeur 10 et la variable b détient la valeur 21, alors -

Afficher l'exemple

Opérateur	La description	Exemple
+ Ajout	Ajoute des valeurs de chaque côté de l'opérateur.	a + b = 31
- Soustraction	Soustrait l'opérande de droite de l'opérande de gauche.	a - b = -11
* Multiplication	Multiplie les valeurs de chaque côté de l'opérateur	a * b = 210
/ Division	Divise l'opérande de gauche par l'opérande de droite	b / a = 2,1
% Module	Divise l'opérande de gauche par l'opérande de droite et renvoie le reste	b% a = 1
** Exposant	Effectue un calcul exponentiel (puissance) sur les opérateurs	a ** b = 10 à la puissance 20
//	Division du sol - La division des opérandes où le résultat est le quotient dans lequel les chiffres après la virgule décimale sont supprimés. Mais si l'un des opérandes est négatif, le résultat est plancher, c'est-à-dire arrondi à partir de zéro (vers l'infini négatif):	9 // 2 = 4 et 9,0 // 2,0 = 4,0, -11 // 3 = -4, -11,0 // 3 = -4,0

Opérateurs de comparaison Python

Ces opérateurs comparent les valeurs de chaque côté et décident de la relation entre eux. Ils sont également appelés opérateurs relationnels.

Supposons une variable a contient la valeur 10 et la variable b détient la valeur 20, alors -

Afficher l'exemple

Opérateur	La description	Exemple
==	Si les valeurs de deux opérandes sont égales, la condition devient vraie.	(a == b) n'est pas vrai.
! =	Si les valeurs de deux opérandes ne sont pas égales, la condition devient vraie.	(a! = b) est vrai.
>	Si la valeur de l'opérande gauche est supérieure à la valeur de l'opérande droit, la condition devient vraie.	(a> b) n'est pas vrai.
<	Si la valeur de l'opérande gauche est inférieure à la valeur de l'opérande droit, la condition devient vraie.	(a <b) est vrai.
> =	Si la valeur de l'opérande gauche est supérieure ou égale à la valeur de l'opérande droit, la condition devient vraie.	(a> = b) n'est pas vrai.
<=	Si la valeur de l'opérande gauche est inférieure ou égale à la valeur de l'opérande droit, la condition devient vraie.	(a <= b) est vrai.

Opérateurs d'affectation Python

Supposons une variable a contient la valeur 10 et la variable b détient la valeur 20, alors -

Afficher l'exemple

Opérateur	La description	Exemple
=	Assigne les valeurs des opérandes du côté droit à l'opérande du côté gauche	c = a + b attribue la valeur de a + b dans c
+ = Ajouter ET	Il ajoute l'opérande droit à l'opérande gauche et affecte le résultat à l'opérande gauche	c + = a équivaut à c = c + a
- = Soustraire ET	Il soustrait l'opérande droit de l'opérande gauche et attribue le résultat à l'opérande gauche	c - = a équivaut à c = c - a
* = Multiplier ET	Il multiplie l'opérande droit par l'opérande gauche et affecte le résultat à l'opérande gauche	c * = a équivaut à c = c * a
/ = Diviser ET	Il divise l'opérande gauche avec l'opérande droit et affecte le résultat à l'opérande gauche	c / = a équivaut à c = c / ac / = a équivaut à c = c / a
% = Module ET	Il prend le module en utilisant deux opérandes et affecte le résultat à l'opérande gauche	c% = a équivaut à c = c% a
** = exposant ET	Effectue un calcul exponentiel (puissance) sur les opérateurs et attribue une valeur à l'opérande de gauche	c = a équivaut à c = c a
// = Division du sol	Il effectue la division d'étage sur les opérateurs et attribue une valeur à l'opérande de gauche	c // = a équivaut à c = c // a

Opérateurs binaires Python

L'opérateur au niveau du bit fonctionne sur les bits et effectue des opérations bit par bit. Supposons si a = 60; et b = 13; Maintenant au format binaire, ils seront comme suit -

a = 0011 1100

b = 0000 1101

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

a & b = 0000 1100

a | b = 0011 1101

a ^ b = 0011 0001

~ a = 1100 0011

La fonction intégrée bin () de Python peut être utilisée pour obtenir une représentation binaire d'un nombre entier.

Les opérateurs Bitwise suivants sont pris en charge par le langage Python -

Afficher l'exemple

Opérateur	La description	Exemple
& Binaire ET	L'opérateur copie un peu, vers le résultat, s'il existe dans les deux opérandes	(a & b) (signifie 0000 1100)
\| OU binaire	Il copie un peu, s'il existe dans l'un ou l'autre des opérandes.	(a \| b) = 61 (signifie 0011 1101)
^ XOR binaire	Il copie le bit s'il est défini dans un opérande mais pas dans les deux.	(a ^ b) = 49 (signifie 0011 0001)
~ Complément binaire	Il est unaire et a pour effet de «retourner» les bits.	(~ a) = -61 (signifie 1100 0011 sous forme de complément à 2 en raison d'un nombre binaire signé.
<< Décalage binaire à gauche	La valeur de l'opérande de gauche est déplacée vers la gauche du nombre de bits spécifié par l'opérande de droite.	a << 2 = 240 (signifie 1111 0000)
>> Décalage binaire à droite	La valeur de l'opérande gauche est déplacée vers la droite du nombre de bits spécifié par l'opérande droit.	a >> 2 = 15 (signifie 0000 1111)

Opérateurs logiques Python

Les opérateurs logiques suivants sont pris en charge par le langage Python. Supposons une variablea détient Vrai et variable b détient False alors -

Afficher l'exemple

Opérateur	La description	Exemple
et logique ET	Si les deux opérandes sont vrais, la condition devient vraie.	(a et b) est faux.
ou logique OU	Si l'un des deux opérandes est différent de zéro, la condition devient vraie.	(a ou b) est vrai.
pas logique NON	Utilisé pour inverser l'état logique de son opérande.	Non (a et b) est vrai.

Opérateurs d'appartenance Python

Les opérateurs d'appartenance de Python testent l'appartenance à une séquence, telle que des chaînes, des listes ou des tuples. Il existe deux opérateurs d'adhésion comme expliqué ci-dessous -

Afficher l'exemple

Opérateur	La description	Exemple
dans	Évalue à vrai s'il trouve une variable dans la séquence spécifiée et à faux dans le cas contraire.	x dans y, ici donne un 1 si x est un membre de la suite y.
pas dedans	Évalue à vrai s'il ne trouve pas de variable dans la séquence spécifiée et à faux dans le cas contraire.	x pas dans y, ici pas dans donne un 1 si x n'est pas membre de la suite y.

Opérateurs d'identité Python

Les opérateurs d'identité comparent les emplacements mémoire de deux objets. Il existe deux opérateurs d'identité comme expliqué ci-dessous -

Afficher l'exemple

Opérateur	La description	Exemple
est	Évalue à vrai si les variables de chaque côté de l'opérateur pointent vers le même objet et à faux dans le cas contraire.	x est y, ici is donne 1 si id (x) est égal à id (y).
n'est pas	Évalue à faux si les variables de chaque côté de l'opérateur pointent vers le même objet et à vrai dans le cas contraire.	x n'est pas y, ici is not donne 1 si id (x) n'est pas égal à id (y).

Priorité des opérateurs Python

Le tableau suivant répertorie tous les opérateurs de la priorité la plus élevée à la plus basse.

Afficher l'exemple

Sr.No.	Opérateur et description
1	** Exponentiation (élever au pouvoir)
2	~ + - Complément, unaire plus et moins (les noms de méthode pour les deux derniers sont + @ et - @)
3	* / % // Multiplier, diviser, modulo et division au sol
4	+ - Addition et soustraction
5	>> << Décalage du bit à droite et à gauche
6	& Bitwise 'ET'
sept	^ \| `` OR '' exclusif au niveau du bit et `` OR '' régulier
8	<= < > >= Opérateurs de comparaison
9	<> == != Opérateurs d'égalité
dix	*= %= /= //= -= += = = Opérateurs d'affectation
11	is is not Opérateurs d'identité
12	in not in Opérateurs d'adhésion
13	not or and Opérateurs logiques

La prise de décision est l'anticipation des conditions survenant lors de l'exécution d'un programme et des actions spécifiées prises en fonction des conditions.

Les structures de décision évaluent plusieurs expressions, qui produisent TRUE ou FALSE comme résultat. Vous devez déterminer quelle action entreprendre et quelles instructions exécuter si le résultat est TRUE ou FALSE dans le cas contraire.

Voici la forme générale d'une structure de prise de décision typique trouvée dans la plupart des langages de programmation -

Le langage de programmation Python suppose que non-zero et non-null valeurs comme TRUE, et tout zero ou null values comme valeur FALSE.

Le langage de programmation Python fournit les types suivants d'énoncés de prise de décision.

Sr.No.	Déclaration et description
1	si déclarations Un if statement se compose d'une expression booléenne suivie d'une ou plusieurs instructions.
2	instructions if ... else Un if statement peut être suivi d'une option else statement, qui s'exécute lorsque l'expression booléenne est FALSE.
3	instructions if imbriquées Vous pouvez en utiliser un if ou else if déclaration dans un autre if ou else if déclaration (s).

Passons en revue chaque déclaration de prise de décision rapidement.

Suites à déclaration unique

Si la suite d'un if clause se compose d'une seule ligne, elle peut aller sur la même ligne que l'instruction d'en-tête.

Exemple

Voici un exemple de one-line if clause -

#!/usr/bin/python3

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

Production

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

Value of expression is 100
Good bye!

En général, les instructions sont exécutées de manière séquentielle - La première instruction d'une fonction est exécutée en premier, suivie de la seconde, et ainsi de suite. Il peut arriver que vous deviez exécuter un bloc de code plusieurs fois.

Les langages de programmation fournissent diverses structures de contrôle qui permettent des chemins d'exécution plus compliqués.

Une instruction de boucle nous permet d'exécuter une instruction ou un groupe d'instructions plusieurs fois. Le diagramme suivant illustre une instruction de boucle -

Le langage de programmation Python fournit les types de boucles suivants pour gérer les exigences de boucle.

Sr.No.	Type de boucle et description
1	boucle while Répète une instruction ou un groupe d'instructions lorsqu'une condition donnée est VRAIE. Il teste la condition avant d'exécuter le corps de la boucle.
2	pour boucle Exécute une séquence d'instructions plusieurs fois et abrége le code qui gère la variable de boucle.
3	boucles imbriquées Vous pouvez utiliser une ou plusieurs boucles dans une autre boucle while ou for.

Déclarations de contrôle de boucle

Les instructions de contrôle de boucle modifient l'exécution de sa séquence normale. Lorsque l'exécution quitte une étendue, tous les objets automatiques qui ont été créés dans cette étendue sont détruits.

Python prend en charge les instructions de contrôle suivantes.

Sr.No.	Déclaration de contrôle et description
1	déclaration break Termine l'instruction de boucle et transfère l'exécution à l'instruction immédiatement après la boucle.
2	continue déclaration Force la boucle à ignorer le reste de son corps et à retester immédiatement son état avant de réitérer.
3	déclaration de réussite L'instruction pass en Python est utilisée lorsqu'une instruction est requise syntaxiquement mais que vous ne souhaitez pas qu'une commande ou un code s'exécute.

Passons brièvement en revue les instructions de contrôle de boucle.

Itérateur et générateur

Iteratorest un objet qui permet à un programmeur de parcourir tous les éléments d'une collection, quelle que soit son implémentation spécifique. En Python, un objet itérateur implémente deux méthodes,iter() et next().

Les objets String, List ou Tuple peuvent être utilisés pour créer un Iterator.

list = [1,2,3,4]
it = iter(list) # this builds an iterator object
print (next(it)) #prints next available element in iterator
Iterator object can be traversed using regular for statement
!usr/bin/python3
for x in it:
   print (x, end=" ")
or using next() function
while True:
   try:
      print (next(it))
   except StopIteration:
      sys.exit() #you have to import sys module for this

UNE generator est une fonction qui produit ou produit une séquence de valeurs à l'aide de la méthode yield.

Lorsqu'une fonction de générateur est appelée, elle renvoie un objet générateur sans même commencer l'exécution de la fonction. Lorsque la méthode next () est appelée pour la première fois, la fonction commence à s'exécuter jusqu'à ce qu'elle atteigne l'instruction yield, qui renvoie la valeur obtenue. Le rendement garde une trace, c'est-à-dire se souvient de la dernière exécution et le deuxième appel next () continue à partir de la valeur précédente.

Exemple

L'exemple suivant définit un générateur, qui génère un itérateur pour tous les nombres de Fibonacci.

#!usr/bin/python3

import sys
def fibonacci(n): #generator function
   a, b, counter = 0, 1, 0
   while True:
      if (counter > n): 
         return
      yield a
      a, b = b, a + b
      counter += 1
f = fibonacci(5) #f is iterator object

while True:
   try:
      print (next(f), end=" ")
   except StopIteration:
      sys.exit()

Les types de données numériques stockent des valeurs numériques. Ce sont des types de données immuables. Cela signifie que la modification de la valeur d'un type de données numérique entraîne un nouvel objet alloué.

Les objets numériques sont créés lorsque vous leur attribuez une valeur. Par exemple -

var1 = 1
var2 = 10

Vous pouvez également supprimer la référence à un objet numérique en utilisant le deldéclaration. La syntaxe dudel la déclaration est -

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

Vous pouvez supprimer un seul objet ou plusieurs objets en utilisant le deldéclaration. Par exemple -

del var
del var_a, var_b

Python prend en charge différents types numériques -

int (signed integers) - Ils sont souvent appelés simplement des entiers ou ints. Ce sont des nombres entiers positifs ou négatifs sans point décimal. Les entiers dans Python 3 sont de taille illimitée. Python 2 a deux types entiers - int et long. Il n'y a pas 'long integer'dans Python 3 plus.
float (floating point real values)- Aussi appelés flottants, ils représentent des nombres réels et sont écrits avec un point décimal divisant l'entier et les parties fractionnaires. Les flotteurs peuvent également être en notation scientifique, avec E ou e indiquant la puissance de 10 (2,5e2 = 2,5 x 10 ² = 250).
complex (complex numbers)- sont de la forme a + bJ, où a et b sont des flottants et J (ou j) représente la racine carrée de -1 (qui est un nombre imaginaire). La partie réelle du nombre est a et la partie imaginaire est b. Les nombres complexes ne sont pas beaucoup utilisés dans la programmation Python.

Il est possible de représenter un entier sous forme hexadécimale ou octale

>>> number = 0xA0F #Hexa-decimal
>>> number
2575

>>> number = 0o37 #Octal
>>> number
31

Exemples

Voici quelques exemples de nombres.

int	flotte	complexe
dix	0,0	3.14j
100	15,20	45.j
-786	-21,9	9.322e-36j
080	32,3 + e18	.876j
-0490	-90.	-.6545 + 0J
-0 × 260	-32,54e100	3e + 26J
0 × 69	70.2-E12	4.53e-7j

Un nombre complexe consiste en une paire ordonnée de nombres réels à virgule flottante désignés par a + bj, où a est la partie réelle et b est la partie imaginaire du nombre complexe.

Conversion de type de nombre

Python convertit les nombres en interne dans une expression contenant des types mixtes en un type commun pour l'évaluation. Parfois, vous devez forcer un nombre explicitement d'un type à un autre pour satisfaire les exigences d'un opérateur ou d'un paramètre de fonction.

Type int(x) pour convertir x en un entier brut.
Type long(x) pour convertir x en un entier long.
Type float(x) pour convertir x en nombre à virgule flottante.
Type complex(x) pour convertir x en un nombre complexe avec une partie réelle x et une partie imaginaire zéro.
Type complex(x, y)pour convertir x et y en un nombre complexe avec une partie réelle x et une partie imaginaire y. x et y sont des expressions numériques

Fonctions mathématiques

Python inclut les fonctions suivantes qui effectuent des calculs mathématiques.

Sr.No.	Fonction et retours (Description)
1	abs (x) La valeur absolue de x: la distance (positive) entre x et zéro.
2	ceil (x) Le plafond de x: le plus petit entier non inférieur à x.
3	cmp(x, y) -1 si x <y, 0 si x == y, ou 1 si x> y. Deprecated en Python 3. Utilisez plutôt return (x>y)-(x<y).
4	exp (x) L'exponentielle de x: e ^x
5	fabs (x) La valeur absolue de x.
6	plancher (x) Le plancher de x: le plus grand entier non supérieur à x.
sept	log (x) Le logarithme naturel de x, pour x> 0.
8	log10 (x) Logarithme en base 10 de x pour x> 0.
9	max (x1, x2, ...) Le plus grand de ses arguments: la valeur la plus proche de l'infini positif
dix	min (x1, x2, ...) Le plus petit de ses arguments: la valeur la plus proche de l'infini négatif.
11	modf (x) Les parties fractionnaires et entières de x dans un tuple à deux éléments. Les deux parties ont le même signe que x. La partie entière est renvoyée sous forme de flottant.
12	pow (x, y) La valeur de x ** y.
13	rond (x [, n]) xarrondi à n chiffres à partir de la virgule décimale. Python arrondit à zéro comme un bris d'égalité: round (0.5) est 1.0 et round (-0.5) est -1.0.
14	sqrt (x) La racine carrée de x pour x> 0.

Fonctions de nombres aléatoires

Les nombres aléatoires sont utilisés pour les jeux, les simulations, les tests, la sécurité et les applications de confidentialité. Python inclut les fonctions suivantes qui sont couramment utilisées.

Sr.No.	Description de la fonction
1	choix (seq) Un élément aléatoire d'une liste, d'un tuple ou d'une chaîne.
2	randrange ([start,] stop [, step]) Un élément sélectionné au hasard dans la plage (démarrage, arrêt, étape).
3	Aléatoire() Un flotteur aléatoire r, tel que 0 est inférieur ou égal à r et r est inférieur à 1
4	graine ([x]) Définit la valeur de départ entière utilisée pour générer des nombres aléatoires. Appelez cette fonction avant d'appeler toute autre fonction de module aléatoire. Renvoie Aucun.
5	aléatoire (lst) Randomise les éléments d'une liste en place. Renvoie Aucun.
6	uniforme (x, y) Un flotteur aléatoire r, tel que x est inférieur ou égal à r et r est inférieur à y.

Fonctions trigonométriques

Python comprend les fonctions suivantes qui effectuent des calculs trigonométriques.

Sr.No.	Description de la fonction
1	acos (x) Renvoie l'arc cosinus de x, en radians.
2	asin (x) Renvoie l'arc sinus de x, en radians.
3	atan (x) Renvoie l'arc tangent de x, en radians.
4	atan2 (y, x) Renvoie atan (y / x), en radians.
5	cos (x) Renvoie le cosinus de x radians.
6	hypot (x, y) Renvoie la norme euclidienne, sqrt (x * x + y * y).
sept	sin (x) Renvoie le sinus de x radians.
8	bronzé (x) Renvoie la tangente de x radians.
9	degrés (x) Convertit l'angle x des radians en degrés.
dix	radians (x) Convertit l'angle x de degrés en radians.

Constantes mathématiques

Le module définit également deux constantes mathématiques -

Sr.No.	Constantes et description
1	pi La constante mathématique pi.
2	e La constante mathématique e.

Les chaînes sont parmi les types les plus populaires en Python. Nous pouvons les créer simplement en mettant les caractères entre guillemets. Python traite les guillemets simples de la même manière que les guillemets doubles. La création de chaînes est aussi simple que l'attribution d'une valeur à une variable. Par exemple -

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

Accès aux valeurs dans les chaînes

Python ne prend pas en charge un type de caractère; celles-ci sont traitées comme des chaînes de longueur un, donc également considérées comme une sous-chaîne.

Pour accéder aux sous-chaînes, utilisez les crochets pour le découpage avec l'index ou les index pour obtenir votre sous-chaîne. Par exemple -

#!/usr/bin/python3

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

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

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

Mise à jour des chaînes

Vous pouvez «mettre à jour» une chaîne existante en (ré) affectant une variable à une autre chaîne. La nouvelle valeur peut être liée à sa valeur précédente ou à une chaîne complètement différente. Par exemple -

#!/usr/bin/python3

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

Updated String :-  Hello Python

Personnages de fuite

Le tableau suivant est une liste de caractères d'échappement ou non imprimables qui peuvent être représentés avec une notation anti-slash.

Un caractère d'échappement est interprété; dans des chaînes entre guillemets simples et doubles.

Notation de barre oblique inverse	Caractère hexadécimal	La description
\une	0x07	Cloche ou alerte
\ b	0x08	Retour arrière
\ cx		Contrôle-x
\ Cx		Contrôle-x
\ e	0x1b	Échapper
\F	0x0c	Formfeed
\ M- \ Cx		Meta-Control-x
\ n	0x0a	Nouvelle ligne
\ nnn		Notation octale, où n est compris entre 0,7
\ r	0x0d	Retour chariot
\ s	0x20	Espace
\ t	0x09	Languette
\ v	0x0b	Onglet vertical
\X		Caractère x
\ xnn		Notation hexadécimale, où n est compris entre 0,9, af ou AF

Opérateurs spéciaux de chaîne

Supposons une variable de chaîne a contient 'Hello' et variable b détient 'Python', alors -

Opérateur	La description	Exemple
+	Concaténation - Ajoute des valeurs de chaque côté de l'opérateur	a + b donnera HelloPython
*	Répétition - Crée de nouvelles chaînes, concaténant plusieurs copies de la même chaîne	un * 2 donnera -BonjourBonjour
[]	Slice - Donne le caractère de l'index donné	a [1] donnera e
[:]	Range Slice - Donne les caractères de la plage donnée	a [1: 4] donnera ell
dans	Membership - Renvoie true si un caractère existe dans la chaîne donnée	H dans un donnera 1
pas dedans	Membership - Renvoie true si un caractère n'existe pas dans la chaîne donnée	M pas dans un donnera 1
r / R	Chaîne brute - Supprime la signification réelle des caractères d'échappement. La syntaxe des chaînes brutes est exactement la même que celle des chaînes normales à l'exception de l'opérateur de chaîne brute, la lettre «r», qui précède les guillemets. Le "r" peut être en minuscule (r) ou en majuscule (R) et doit être placé immédiatement avant le premier guillemet.	print r '\ n' imprime \ n et imprime R '\ n'imprime \ n
%	Format - Effectue le formatage de la chaîne	Voir dans la section suivante

Opérateur de formatage de chaîne

L'une des fonctionnalités les plus intéressantes de Python est l'opérateur de format de chaîne%. Cet opérateur est unique aux chaînes et compense l'ensemble des fonctions de la famille printf () de C. Voici un exemple simple -

#!/usr/bin/python3

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

My name is Zara and weight is 21 kg!

Voici la liste de l'ensemble complet de symboles qui peuvent être utilisés avec% -

Sr.No.	Symbole de format et conversion
1	%c personnage
2	%s conversion de chaîne via str () avant le formatage
3	%i entier décimal signé
4	%d entier décimal signé
5	%u entier décimal non signé
6	%o entier octal
sept	%x entier hexadécimal (lettres minuscules)
8	%X entier hexadécimal (lettres majuscules)
9	%e notation exponentielle (avec 'e' minuscule)
dix	%E notation exponentielle (avec MAJUSCULE 'E')
11	%f nombre réel à virgule flottante
12	%g le plus court de% f et% e
13	%G le plus court de% f et% E

Les autres symboles et fonctionnalités pris en charge sont répertoriés dans le tableau suivant -

Sr.No.	Symbole et fonctionnalité
1	* l'argument spécifie la largeur ou la précision
2	- justification à gauche
3	+ afficher le signe
4	<sp> laisser un espace vide avant un nombre positif
5	# ajoutez le zéro octal de début («0») ou hexadécimal de début «0x» ou «0X», selon que «x» ou «X» ont été utilisés.
6	0 pad de gauche avec des zéros (au lieu d'espaces)
sept	% '%%' vous laisse avec un seul littéral '%'
8	(var) variable de mappage (arguments du dictionnaire)
9	m.n. m est la largeur totale minimale et n est le nombre de chiffres à afficher après la virgule décimale (si applicable)

Citations triples

Les triples guillemets de Python viennent à la rescousse en permettant aux chaînes de s'étendre sur plusieurs lignes, y compris les NEWLINE textuelles, les TAB et tout autre caractère spécial.

La syntaxe des guillemets triples se compose de trois single or double citations.

#!/usr/bin/python3

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant. Notez comment chaque caractère spécial a été converti dans sa forme imprimée, jusqu'à la dernière NEWLINE à la fin de la chaîne entre le "haut". et fermer les guillemets triples. Notez également que les NEWLINEs se produisent soit avec un retour chariot explicite à la fin d'une ligne, soit avec son code d'échappement (\ n) -

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

Les chaînes brutes ne traitent pas du tout la barre oblique inverse comme un caractère spécial. Chaque caractère que vous mettez dans une chaîne brute reste tel que vous l'avez écrit -

#!/usr/bin/python3

print ('C:\\nowhere')

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

C:\nowhere

Utilisons maintenant la chaîne brute. Nous mettrions l'expressionr'expression' comme suit -

#!/usr/bin/python3

print (r'C:\\nowhere')

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

C:\\nowhere

Chaîne Unicode

En Python 3, toutes les chaînes sont représentées en Unicode, tandis qu'en Python 2 sont stockées en interne en ASCII 8 bits, il est donc nécessaire d'attacher 'u' pour le rendre Unicode. Ce n'est plus nécessaire maintenant.

Méthodes de chaîne intégrées

Python inclut les méthodes intégrées suivantes pour manipuler les chaînes -

Sr.No.	Méthodes et description
1	capitaliser() Met en majuscule la première lettre de la chaîne
2	center (width, fillchar) Renvoie une chaîne remplie de fillchar avec la chaîne d'origine centrée sur un total de colonnes de largeur .
3	count (str, begin = 0, end = len (string)) Compte le nombre de fois que str apparaît dans la chaîne ou dans une sous-chaîne de chaîne si l'index de début begin et end index end sont indiqués.
4	décoder (encoding = 'UTF-8', errors = 'strict') Décode la chaîne à l'aide du codec enregistré pour l'encodage. encoding utilise par défaut l'encodage de chaîne par défaut.
5	encode (encoding = 'UTF-8', errors = 'strict') Renvoie la version chaîne codée de la chaîne; en cas d'erreur, la valeur par défaut est de déclencher une ValueError à moins que des erreurs ne soient indiquées avec «ignorer» ou «remplacer».
6	endswith (suffixe, begin = 0, end = len (chaîne)) Détermine si la chaîne ou une sous-chaîne de chaîne (si l'index de départ begin et end index end sont donnés) se termine par un suffixe; renvoie true si c'est le cas et false dans le cas contraire.
sept	expandtabs (tabsize = 8) Développe les tabulations de la chaîne en plusieurs espaces; la valeur par défaut est de 8 espaces par onglet si la taille de l'onglet n'est pas fournie.
8	find (str, beg = 0 end = len (chaîne)) Détermine si str apparaît dans une chaîne ou dans une sous-chaîne de chaîne si l'index de début begin et de fin d'index end sont donnés renvoie index s'il est trouvé et -1 sinon.
9	index (chaîne, début = 0, fin = len (chaîne)) Identique à find (), mais lève une exception si str est introuvable.
dix	isalnum () Renvoie true si la chaîne contient au moins 1 caractère et que tous les caractères sont alphanumériques et false dans le cas contraire.
11	isalpha () Renvoie true si la chaîne contient au moins 1 caractère et que tous les caractères sont alphabétiques et false dans le cas contraire.
12	isdigit () Renvoie true si la chaîne ne contient que des chiffres et false dans le cas contraire.
13	est plus bas() Renvoie vrai si la chaîne a au moins 1 caractère casse et tous les caractères casse sont en minuscules et faux sinon.
14	isnumérique () Renvoie true si une chaîne Unicode contient uniquement des caractères numériques et false dans le cas contraire.
15	isspace () Renvoie true si la chaîne ne contient que des espaces et false dans le cas contraire.
16	istitle () Renvoie true si la chaîne est correctement "titlecased" et false dans le cas contraire.
17	isupper () Renvoie vrai si la chaîne a au moins un caractère casse et tous les caractères casse sont en majuscules et faux sinon.
18	rejoindre (seq) Fusionne (concatène) les représentations sous forme de chaîne d'éléments dans la séquence seq en une chaîne, avec une chaîne de séparation.
19	len (chaîne) Renvoie la longueur de la chaîne
20	ljust (width [, fillchar]) Renvoie une chaîne remplie d'espaces avec la chaîne d'origine justifiée à gauche sur un total de colonnes de largeur.
21	inférieur() Convertit toutes les lettres majuscules de la chaîne en minuscules.
22	bande l () Supprime tous les espaces de début de chaîne.
23	maketrans () Renvoie une table de traduction à utiliser dans la fonction de traduction.
24	max (str) Renvoie le caractère alphabétique maximum de la chaîne str.
25	min (str) Renvoie le caractère alphabétique min de la chaîne str.
26	remplacer (ancien, nouveau [, max]) Remplace toutes les occurrences de l'ancien dans la chaîne par de nouvelles occurrences ou au maximum si max est donné.
27	rfind (str, beg = 0, end = len (chaîne)) Identique à find (), mais recherche en arrière dans la chaîne.
28	rindex (str, beg = 0, end = len (chaîne)) Identique à index (), mais recherche en arrière dans la chaîne.
29	rjust (largeur, [, fillchar]) Renvoie une chaîne remplie d'espaces avec la chaîne d'origine justifiée à droite sur un total de colonnes de largeur.
30	rstrip () Supprime tous les espaces de fin de chaîne.
31	split (str = "", num = string.count (str)) Divise la chaîne en fonction du délimiteur str (espace si non fourni) et retourne la liste des sous-chaînes; divisé en au plus nombre de sous-chaînes s'il est donné.
32	lignes fractionnées (num = string.count ('\ n')) Divise la chaîne du tout (ou nombre) NEWLINEs et renvoie une liste de chaque ligne avec NEWLINEs supprimées.
33	commence avec (str, début = 0, fin = len (chaîne)) Détermine si la chaîne ou une sous-chaîne de chaîne (si l'index de départ begin et end index end sont donnés) commence par la sous-chaîne str; renvoie true si c'est le cas et false dans le cas contraire.
34	bande ([caractères]) Effectue à la fois lstrip () et rstrip () sur une chaîne
35	casier () Inverse la casse pour toutes les lettres de la chaîne.
36	Titre() Renvoie la version "titlecased" de la chaîne, c'est-à-dire que tous les mots commencent par des majuscules et les autres sont en minuscules.
37	translate (table, deletechars = "") Traduit la chaîne en fonction de la table de traduction str (256 caractères), en supprimant celles de la chaîne del.
38	plus haut() Convertit les lettres minuscules d'une chaîne en majuscules.
39	zfill (largeur) Renvoie la chaîne d'origine avec des zéros à gauche pour un total de caractères de largeur; destiné aux nombres, zfill () conserve tout signe donné (moins un zéro).
40	isdecimal () Renvoie true si une chaîne Unicode contient uniquement des caractères décimaux et false dans le cas contraire.

La structure de données la plus basique en Python est la sequence. Chaque élément d'une séquence reçoit un numéro - sa position ou son index. Le premier index est zéro, le deuxième index est un, et ainsi de suite.

Python a six types de séquences intégrés, mais les plus courants sont les listes et les tuples, que nous verrons dans ce didacticiel.

Il y a certaines choses que vous pouvez faire avec tous les types de séquence. Ces opérations incluent l'indexation, le découpage, l'ajout, la multiplication et la vérification de l'appartenance. De plus, Python a des fonctions intégrées pour trouver la longueur d'une séquence et pour trouver ses éléments les plus grands et les plus petits.

Listes Python

La liste est le type de données le plus polyvalent disponible en Python, qui peut être écrit sous la forme d'une liste de valeurs séparées par des virgules (éléments) entre crochets. La chose importante à propos d'une liste est que les éléments d'une liste n'ont pas besoin d'être du même type.

Créer une liste est aussi simple que de mettre différentes valeurs séparées par des virgules entre crochets. Par exemple -

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

Semblables aux indices de chaîne, les index de liste commencent à 0 et les listes peuvent être découpées, concaténées, etc.

Accès aux valeurs dans les listes

Pour accéder aux valeurs des listes, utilisez les crochets pour le découpage avec l'index ou les indices pour obtenir la valeur disponible à cet index. Par exemple -

#!/usr/bin/python3

list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7 ]

print ("list1[0]: ", list1[0])
print ("list2[1:5]: ", list2[1:5])

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

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

Mise à jour des listes

Vous pouvez mettre à jour un ou plusieurs éléments de listes en donnant la tranche sur le côté gauche de l'opérateur d'affectation, et vous pouvez ajouter des éléments dans une liste avec la méthode append (). Par exemple -

#!/usr/bin/python3

list = ['physics', 'chemistry', 1997, 2000]
print ("Value available at index 2 : ", list[2])

list[2] = 2001
print ("New value available at index 2 : ", list[2])

Note - La méthode append () est abordée dans la section suivante.

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

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

Supprimer des éléments de liste

Pour supprimer un élément de liste, vous pouvez utiliser soit le delsi vous savez exactement quel (s) élément (s) vous supprimez. Vous pouvez utiliser la méthode remove () si vous ne savez pas exactement quels éléments supprimer. Par exemple -

#!/usr/bin/python3

list = ['physics', 'chemistry', 1997, 2000]
print (list)

del list[2]
print ("After deleting value at index 2 : ", list)

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

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

Note - La méthode remove () est discutée dans la section suivante.

Opérations de base sur les listes

Les listes répondent aux opérateurs + et * un peu comme des chaînes; ils signifient ici aussi concaténation et répétition, sauf que le résultat est une nouvelle liste et non une chaîne.

En fait, les listes répondent à toutes les opérations générales de séquence que nous avons utilisées sur les chaînes dans le chapitre précédent.

Expression Python	Résultats	La description
len ([1, 2, 3])	3	Longueur
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	Enchaînement
["Salut!"] * 4	[«Salut!», «Salut!», «Salut!», «Salut!»]	Répétition
3 dans [1, 2, 3]	Vrai	Adhésion
pour x dans [1,2,3]: print (x, end = '')	1 2 3	Itération

Indexation, découpage et matrices

Puisque les listes sont des séquences, l'indexation et le découpage fonctionnent de la même manière pour les listes que pour les chaînes.

En supposant l'entrée suivante -

L = ['C++'', 'Java', 'Python']

Expression Python	Résultats	La description
L [2]	'Python'	Les décalages commencent à zéro
L [-2]	'Java'	Négatif: compter à partir de la droite
L [1:]	['Java', 'Python']	Le tranchage récupère les sections

Fonctions et méthodes de liste intégrées

Python comprend les fonctions de liste suivantes -

Sr.No.	Description de la fonction
1	len (liste) Donne la longueur totale de la liste.
2	max (liste) Renvoie l'élément de la liste avec une valeur maximale.
3	min (liste) Renvoie l'élément de la liste avec une valeur minimale.
4	liste (seq) Convertit un tuple en liste.

Python inclut les méthodes de liste suivantes -

Sr.No.	Méthodes et description
1	list.append (obj) Ajoute l'objet obj à la liste
2	list.count (obj) Renvoie le nombre de fois où obj apparaît dans la liste
3	list.extend (seq) Ajoute le contenu de seq à la liste
4	list.index (obj) Renvoie l'index le plus bas de la liste dans lequel obj apparaît
5	list.insert (index, obj) Insère l'objet obj dans la liste à l'index de décalage
6	list.pop (obj = liste [-1]) Supprime et retourne le dernier objet ou obj de la liste
sept	list.remove (obj) Supprime l'objet obj de la liste
8	list.reverse () Inverse les objets de la liste en place
9	list.sort ([func]) Trie les objets de la liste, utilise la fonction de comparaison si elle est donnée

Un tuple est une collection d'objets ordonnés et immuables. Les tuples sont des séquences, tout comme les listes. La principale différence entre les tuples et les listes est que les tuples ne peuvent pas être modifiés contrairement aux listes. Les tuples utilisent des parenthèses, tandis que les listes utilisent des crochets.

Créer un tuple est aussi simple que de mettre différentes valeurs séparées par des virgules. Si vous le souhaitez, vous pouvez également mettre ces valeurs séparées par des virgules entre parenthèses. Par exemple -

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

Le tuple vide est écrit comme deux parenthèses ne contenant rien -

tup1 = ();

Pour écrire un tuple contenant une seule valeur, vous devez inclure une virgule, même s'il n'y a qu'une seule valeur -

tup1 = (50,)

Comme les indices de chaîne, les index de tuple commencent à 0 et peuvent être découpés, concaténés, etc.

Accéder aux valeurs dans les tuples

Pour accéder aux valeurs dans tuple, utilisez les crochets pour le découpage avec l'index ou les index pour obtenir la valeur disponible à cet index. Par exemple -

#!/usr/bin/python3

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )

print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

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

Mise à jour des tuples

Les tuples sont immuables, ce qui signifie que vous ne pouvez pas mettre à jour ou modifier les valeurs des éléments de tuple. Vous pouvez prendre des portions des tuples existants pour créer de nouveaux tuples comme le montre l'exemple suivant -

#!/usr/bin/python3

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

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

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

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

Supprimer les éléments de tuple

La suppression d'éléments de tuple individuels n'est pas possible. Il n'y a, bien sûr, rien de mal à assembler un autre tuple avec les éléments indésirables supprimés.

Pour supprimer explicitement un tuple entier, utilisez simplement le deldéclaration. Par exemple -

#!/usr/bin/python3

tup = ('physics', 'chemistry', 1997, 2000);

print (tup)
del tup;
print ("After deleting tup : ")
print (tup)

Cela produit le résultat suivant.

Note- Une exception est levée. C'est parce qu'aprèsdel tup, le tuple n'existe plus.

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

Opérations de base sur les tuples

Les tuples répondent aux opérateurs + et * un peu comme des chaînes; ils signifient ici aussi la concaténation et la répétition, sauf que le résultat est un nouveau tuple, pas une chaîne.

En fait, les tuples répondent à toutes les opérations générales de séquence que nous avons utilisées sur les chaînes dans le chapitre précédent.

Expression Python	Résultats	La description
len ((1, 2, 3))	3	Longueur
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	Enchaînement
('Salut!',) * 4	("Salut!", "Salut!", "Salut!", "Salut!")	Répétition
3 pouces (1, 2, 3)	Vrai	Adhésion
pour x dans (1,2,3): print (x, end = '')	1 2 3	Itération

Indexation, découpage et matrices

Comme les tuples sont des séquences, l'indexation et le découpage fonctionnent de la même manière pour les tuples que pour les chaînes, en supposant l'entrée suivante -

T=('C++', 'Java', 'Python')

Expression Python	Résultats	La description
T [2]	'Python'	Les décalages commencent à zéro
T [-2]	'Java'	Négatif: compter à partir de la droite
T [1:]	('Java', 'Python')	Le tranchage récupère les sections

Pas de délimiteurs fermants

Aucun délimiteur englobant n'est un ensemble d'objets multiples, séparés par des virgules, écrits sans symboles d'identification, c'est-à-dire, des crochets pour les listes, des parenthèses pour les tuples, etc., par défaut sur les tuples, comme indiqué dans ces courts exemples.

Fonctions de tuple intégrées

Python inclut les fonctions de tuple suivantes -

Sr.No.	Description de la fonction
1	cmp (tuple1, tuple2) Compare les éléments des deux tuples.
2	len (tuple) Donne la longueur totale du tuple.
3	max (tuple) Renvoie l'élément du tuple avec la valeur maximale.
4	min (tuple) Renvoie l'élément du tuple avec une valeur minimale.
5	tuple (seq) Convertit une liste en tuple.

Chaque clé est séparée de sa valeur par un signe deux-points (:), les éléments sont séparés par des virgules et le tout est entouré d'accolades. Un dictionnaire vide sans aucun élément est écrit avec seulement deux accolades, comme ceci: {}.

Les clés sont uniques dans un dictionnaire alors que les valeurs peuvent ne pas l'être. Les valeurs d'un dictionnaire peuvent être de n'importe quel type, mais les clés doivent être d'un type de données immuable tel que des chaînes, des nombres ou des tuples.

Accéder aux valeurs dans le dictionnaire

Pour accéder aux éléments du dictionnaire, vous pouvez utiliser les crochets familiers avec la clé pour obtenir sa valeur. Voici un exemple simple -

#!/usr/bin/python3

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

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

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

If we attempt to access a data item with a key, which is not a part of the dictionary, we get an error as follows −

#!/usr/bin/python3

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

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

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

Updating Dictionary

You can update a dictionary by adding a new entry or a key-value pair, modifying an existing entry, or deleting an existing entry as shown in a simple example given below.

#!/usr/bin/python3

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

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

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

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

Delete Dictionary Elements

You can either remove individual dictionary elements or clear the entire contents of a dictionary. You can also delete entire dictionary in a single operation.

To explicitly remove an entire dictionary, just use the del statement. Following is a simple example −

#!/usr/bin/python3

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

del dict['Name'] # remove entry with key 'Name'
dict.clear()     # remove all entries in dict
del dict         # delete entire dictionary

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

This produces the following result.

An exception is raised because after del dict, the dictionary does not exist anymore.

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

Note − The del() method is discussed in subsequent section.

Properties of Dictionary Keys

Dictionary values have no restrictions. They can be any arbitrary Python object, either standard objects or user-defined objects. However, same is not true for the keys.

There are two important points to remember about dictionary keys −

(a) More than one entry per key is not allowed. This means no duplicate key is allowed. When duplicate keys are encountered during assignment, the last assignment wins. For example −

#!/usr/bin/python3

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

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

dict['Name']:  Manni

(b) Keys must be immutable. This means you can use strings, numbers or tuples as dictionary keys but something like ['key'] is not allowed. Following is a simple example −

#!/usr/bin/python3

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

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

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

Built-in Dictionary Functions and Methods

Python includes the following dictionary functions −

Sr.No.	Function & Description
1	cmp(dict1, dict2) No longer available in Python 3.
2	len(dict) Gives the total length of the dictionary. This would be equal to the number of items in the dictionary.
3	str(dict) Produces a printable string representation of a dictionary
4	type(variable) Returns the type of the passed variable. If passed variable is dictionary, then it would return a dictionary type.

Python includes the following dictionary methods −

Sr.No.	Method & Description
1	dict.clear() Removes all elements of dictionary dict
2	dict.copy() Returns a shallow copy of dictionary dict
3	dict.fromkeys() Create a new dictionary with keys from seq and values set to value.
4	dict.get(key, default=None) For key key, returns value or default if key not in dictionary
5	dict.has_key(key) Removed, use the in operation instead.
6	dict.items() Returns a list of dict's (key, value) tuple pairs
7	dict.keys() Returns list of dictionary dict's keys
8	dict.setdefault(key, default = None) Similar to get(), but will set dict[key] = default if key is not already in dict
9	dict.update(dict2) Adds dictionary dict2's key-values pairs to dict
10	dict.values() Returns list of dictionary dict's values

A Python program can handle date and time in several ways. Converting between date formats is a common chore for computers. Python's time and calendar modules help track dates and times.

What is Tick?

Time intervals are floating-point numbers in units of seconds. Particular instants in time are expressed in seconds since 12:00am, January 1, 1970(epoch).

There is a popular time module available in Python which provides functions for working with times, and for converting between representations. The function time.time() returns the current system time in ticks since 12:00am, January 1, 1970(epoch).

Example

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

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

This would produce a result something as follows −

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

Date arithmetic is easy to do with ticks. However, dates before the epoch cannot be represented in this form. Dates in the far future also cannot be represented this way - the cutoff point is sometime in 2038 for UNIX and Windows.

What is TimeTuple?

Many of the Python's time functions handle time as a tuple of 9 numbers, as shown below −

Index	Field	Values
0	4-digit year	2016
1	Month	1 to 12
2	Day	1 to 31
3	Hour	0 to 23
4	Minute	0 to 59
5	Second	0 to 61 (60 or 61 are leap-seconds)
6	Day of Week	0 to 6 (0 is Monday)
7	Day of year	1 to 366 (Julian day)
8	Daylight savings	-1, 0, 1, -1 means library determines DST

For Example −

import time

print (time.localtime());

This would produce a result as follows −

time.struct_time(tm_year = 2016, tm_mon = 2, tm_mday = 15, tm_hour = 9, 
   tm_min = 29, tm_sec = 2, tm_wday = 0, tm_yday = 46, tm_isdst = 0)

The above tuple is equivalent to struct_time structure. This structure has following attributes −

Index	Attributes	Values
0	tm_year	2016
1	tm_mon	1 to 12
2	tm_mday	1 to 31
3	tm_hour	0 to 23
4	tm_min	0 to 59
5	tm_sec	0 to 61 (60 or 61 are leap-seconds)
6	tm_wday	0 to 6 (0 is Monday)
7	tm_yday	1 to 366 (Julian day)
8	tm_isdst	-1, 0, 1, -1 means library determines DST

Getting current time

To translate a time instant from seconds since the epoch floating-point value into a timetuple, pass the floating-point value to a function (e.g., localtime) that returns a time-tuple with all valid nine items.

#!/usr/bin/python3
import time

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

This would produce the following result, which could be formatted in any other presentable form −

Local current time : time.struct_time(tm_year = 2016, tm_mon = 2, tm_mday = 15, 
   tm_hour = 9, tm_min = 29, tm_sec = 2, tm_wday = 0, tm_yday = 46, tm_isdst = 0)

Getting formatted time

You can format any time as per your requirement, but a simple method to get time in a readable format is asctime() −

Démo en direct

#!/usr/bin/python3
import time

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

Cela produirait le résultat suivant -

Local current time : Mon Feb 15 09:34:03 2016

Obtenir un calendrier pour un mois

Le module de calendrier propose un large éventail de méthodes pour jouer avec les calendriers annuels et mensuels. Ici, nous imprimons un calendrier pour un mois donné (janvier 2008) -

#!/usr/bin/python3
import calendar

cal = calendar.month(2016, 2)
print ("Here is the calendar:")
print (cal)

Cela produirait le résultat suivant -

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

Le module de temps

Il y a un populaire timemodule disponible en Python, qui fournit des fonctions pour travailler avec les temps et pour convertir entre les représentations. Voici la liste de toutes les méthodes disponibles.

Sr.No.	Description de la fonction
1	time.altzone Décalage du fuseau horaire local de l'heure d'été, en secondes à l'ouest de UTC, le cas échéant. Ceci est négatif si le fuseau horaire local de l'heure d'été est à l'est de UTC (comme en Europe occidentale, y compris au Royaume-Uni). Utilisez ceci si la lumière du jour est différente de zéro.
2	time.asctime ([tupletime]) Accepte un temps-tuple et renvoie une chaîne de 24 caractères lisible telle que «Tue Dec 11 18:07:14 2008».
3	heure.horloge () Renvoie le temps processeur actuel sous forme de nombre de secondes à virgule flottante. Pour mesurer les coûts de calcul des différentes approches, la valeur de time.clock est plus utile que celle de time.time ().
4	time.ctime ([secs]) Comme asctime (localtime (secs)) et sans arguments est comme asctime ()
5	time.gmtime ([secs]) Accepte un instant exprimé en secondes depuis l'époque et renvoie un temps-tuple t avec l'heure UTC. Remarque - t.tm_isdst vaut toujours 0
6	time.localtime ([secs]) Accepte un instant exprimé en secondes depuis l'époque et renvoie un tuple de temps t avec l'heure locale (t.tm_isdst vaut 0 ou 1, selon que l'heure d'été s'applique aux secondes instantanées par les règles locales).
sept	time.mktime (tupletime) Accepte un instant exprimé sous forme de tuple de temps en heure locale et renvoie une valeur à virgule flottante avec l'instant exprimé en secondes depuis l'époque.
8	time.sleep (secondes) Suspend le thread appelant pendant secondes secondes.
9	time.strftime (fmt [, tupletime]) Accepte un instant exprimé sous forme de temps-tuple en heure locale et renvoie une chaîne représentant l'instant tel que spécifié par la chaîne fmt.
dix	time.strptime (str, fmt = '% a% b% d% H:% M:% S% Y') Analyse str en fonction de la chaîne de format fmt et renvoie l'instant au format time-tuple.
11	temps temps( ) Renvoie l'instant actuel, un nombre à virgule flottante de secondes depuis l'époque.
12	time.tzset () Réinitialise les règles de conversion de temps utilisées par les routines de la bibliothèque. La variable d'environnement TZ spécifie comment cela est fait.

Il existe deux attributs importants disponibles avec le module de temps. Ils sont -

Sr.No.	Attribut et description
1	time.timezone L'attribut time.timezone est le décalage en secondes du fuseau horaire local (sans heure d'été) par rapport à UTC (> 0 dans les Amériques; <= 0 dans la plupart des pays d'Europe, d'Asie et d'Afrique).
2	time.tzname L'attribut time.tzname est une paire de chaînes dépendant des paramètres régionaux, qui sont respectivement les noms du fuseau horaire local sans et avec l'heure d'été.

Le module calendrier

Le module de calendrier fournit des fonctions liées au calendrier, y compris des fonctions permettant d'imprimer un calendrier texte pour un mois ou une année donné.

Par défaut, le calendrier prend le lundi comme premier jour de la semaine et le dimanche comme dernier. Pour changer cela, appelez lecalendar.setfirstweekday() fonction.

Voici une liste des fonctions disponibles avec le calendar module -

Sr.No.	Description de la fonction
1	calendar.calendar(year,w = 2,l = 1,c = 6) Renvoie une chaîne multiligne avec un calendrier pour l'année année formaté en trois colonnes séparées par des espaces C. w est la largeur en caractères de chaque date; chaque ligne a une longueur 21 * w + 18 + 2 * c. l est le nombre de lignes pour chaque semaine.
2	calendar.firstweekday( ) Renvoie le paramètre actuel pour le jour de la semaine qui commence chaque semaine. Par défaut, lorsque le calendrier est importé pour la première fois, il s'agit de 0, ce qui signifie lundi.
3	calendar.isleap(year) Renvoie True si l'année est une année bissextile; sinon, Faux.
4	calendar.leapdays(y1,y2) Renvoie le nombre total de jours bissextiles dans les années comprises dans la plage (y1, y2).
5	calendar.month(year,month,w = 2,l = 1) Renvoie une chaîne multiligne avec un calendrier pour le mois mois de l'année année, une ligne par semaine plus deux lignes d'en-tête. w est la largeur en caractères de chaque date; chaque ligne a une longueur 7 * w + 6. l est le nombre de lignes pour chaque semaine.
6	calendar.monthcalendar(year,month) Renvoie une liste de listes d'entiers. Chaque sous-liste correspond à une semaine. Les jours hors mois mois de l'année année sont définis sur 0; les jours du mois sont définis sur leur jour du mois, 1 et plus.
sept	calendar.monthrange(year,month) Renvoie deux entiers. Le premier est le code du jour de la semaine pour le premier jour du mois mois de l'année année; le second est le nombre de jours dans le mois. Les codes de jour de la semaine vont de 0 (lundi) à 6 (dimanche); les numéros de mois vont de 1 à 12.
8	calendar.prcal(year,w = 2,l = 1,c = 6) Comme print calendar.calendar (année, w, l, c).
9	calendar.prmonth(year,month,w = 2,l = 1) Comme print calendar.month (année, mois, w, l).
dix	calendar.setfirstweekday(weekday) Définit le premier jour de chaque semaine sur le code du jour de la semaine. Les codes de jour de la semaine vont de 0 (lundi) à 6 (dimanche).
11	calendar.timegm(tupletime) L'inverse de time.gmtime: accepte un instant de temps sous forme de tuple de temps et renvoie le même instant qu'un nombre de secondes à virgule flottante depuis l'époque.
12	calendar.weekday(year,month,day) Renvoie le code du jour de la semaine pour la date donnée. Les codes de jour de la semaine vont de 0 (lundi) à 6 (dimanche); les numéros de mois vont du 1 (janvier) au 12 (décembre).

Autres modules et fonctions

Si vous êtes intéressé, vous trouverez ici une liste d'autres modules et fonctions importants pour jouer avec la date et l'heure en Python -

Le module datetime
Le module pytz
Le module dateutil

Une fonction est un bloc de code organisé et réutilisable utilisé pour effectuer une seule action associée. Les fonctions offrent une meilleure modularité pour votre application et un degré élevé de réutilisation du code.

Comme vous le savez déjà, Python vous offre de nombreuses fonctions intégrées comme print (), etc. mais vous pouvez également créer vos propres fonctions. Ces fonctions sont appelées fonctions définies par l'utilisateur.

Définition d'une fonction

Vous pouvez définir des fonctions pour fournir les fonctionnalités requises. Voici des règles simples pour définir une fonction en Python.

Les blocs fonctionnels commencent par le mot-clé def suivi du nom de la fonction et des parenthèses (()).
Tous les paramètres ou arguments d'entrée doivent être placés entre ces parenthèses. Vous pouvez également définir des paramètres à l'intérieur de ces parenthèses.
La première instruction d'une fonction peut être une instruction facultative - la chaîne de documentation de la fonction ou docstring .
Le bloc de code dans chaque fonction commence par deux points (:) et est indenté.
L'instruction return [expression] quitte une fonction, en renvoyant éventuellement une expression à l'appelant. Une instruction return sans argument équivaut à return None.

Syntaxe

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

Par défaut, les paramètres ont un comportement positionnel et vous devez les informer dans le même ordre qu'ils ont été définis.

Exemple

La fonction suivante prend une chaîne comme paramètre d'entrée et l'imprime sur l'écran standard.

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

Appeler une fonction

La définition d'une fonction lui donne un nom, spécifie les paramètres qui doivent être inclus dans la fonction et structure les blocs de code.

Une fois la structure de base d'une fonction finalisée, vous pouvez l'exécuter en l'appelant depuis une autre fonction ou directement depuis l'invite Python. Voici un exemple pour appeler leprintme() fonction -

#!/usr/bin/python3

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

# Now you can call printme function
printme("This is first call to the user defined function!")
printme("Again second call to the same function")

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

This is first call to the user defined function!
Again second call to the same function

Passer par référence vs valeur

Tous les paramètres (arguments) du langage Python sont passés par référence. Cela signifie que si vous modifiez ce à quoi un paramètre fait référence dans une fonction, le changement se reflète également dans la fonction appelante. Par exemple -

#!/usr/bin/python3

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   print ("Values inside the function before change: ", mylist)
   mylist[2]=50
   print ("Values inside the function after change: ", mylist)
   return

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

Ici, nous conservons la référence de l'objet passé et ajoutons des valeurs dans le même objet. Par conséquent, cela produirait le résultat suivant -

Values inside the function before change:  [10, 20, 30]
Values inside the function after change:  [10, 20, 50]
Values outside the function:  [10, 20, 50]

Il existe un autre exemple où l'argument est passé par référence et la référence est écrasée à l'intérieur de la fonction appelée.

#!/usr/bin/python3

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

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

Le paramètre mylistest local à la fonction changeme. Changer ma liste dans la fonction n'affecte pas ma liste. La fonction n'accomplit rien et finalement cela produirait le résultat suivant -

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

Arguments de fonction

Vous pouvez appeler une fonction en utilisant les types d'arguments formels suivants -

Arguments requis
Arguments de mots-clés
Arguments par défaut
Arguments de longueur variable

Arguments requis

Les arguments requis sont les arguments passés à une fonction dans l'ordre de position correct. Ici, le nombre d'arguments dans l'appel de fonction doit correspondre exactement à la définition de la fonction.

Pour appeler la fonction printme(), vous devez absolument passer un argument, sinon cela donne une erreur de syntaxe comme suit -

#!/usr/bin/python3

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

# Now you can call printme function
printme()

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

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

Arguments de mots clés

Les arguments de mot-clé sont liés aux appels de fonction. Lorsque vous utilisez des arguments de mot-clé dans un appel de fonction, l'appelant identifie les arguments par le nom du paramètre.

Cela vous permet d'ignorer des arguments ou de les placer dans le désordre car l'interpréteur Python est capable d'utiliser les mots-clés fournis pour faire correspondre les valeurs avec des paramètres. Vous pouvez également passer des appels de mots-clés versprintme() fonctionnent de la manière suivante -

#!/usr/bin/python3

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

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

My string

L'exemple suivant donne une image plus claire. Notez que l'ordre des paramètres n'a pas d'importance.

#!/usr/bin/python3

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

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

Name:  miki
Age  50

Arguments par défaut

Un argument par défaut est un argument qui prend une valeur par défaut si une valeur n'est pas fournie dans l'appel de fonction pour cet argument. L'exemple suivant donne une idée sur les arguments par défaut, il imprime l'âge par défaut s'il n'est pas passé -

#!/usr/bin/python3

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

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

Name:  miki
Age  50
Name:  miki
Age  35

Arguments de longueur variable

Vous devrez peut-être traiter une fonction pour plus d'arguments que vous n'en avez spécifié lors de la définition de la fonction. Ces arguments sont appelés arguments de longueur variable et ne sont pas nommés dans la définition de la fonction, contrairement aux arguments obligatoires et par défaut.

La syntaxe d'une fonction avec des arguments de variable sans mot-clé est donnée ci-dessous -

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

Un astérisque (*) est placé avant le nom de la variable qui contient les valeurs de tous les arguments de variable non mot clé. Ce tuple reste vide si aucun argument supplémentaire n'est spécifié lors de l'appel de fonction. Voici un exemple simple -

#!/usr/bin/python3

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

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

Output is:
10
Output is:
70
60
50

Les fonctions anonymes

Ces fonctions sont appelées anonymes car elles ne sont pas déclarées de manière standard en utilisant le defmot-clé. Vous pouvez utiliser lelambda mot-clé pour créer de petites fonctions anonymes.

Les formulaires Lambda peuvent prendre n'importe quel nombre d'arguments mais ne renvoient qu'une seule valeur sous la forme d'une expression. Ils ne peuvent pas contenir de commandes ni d'expressions multiples.
Une fonction anonyme ne peut pas être un appel direct à imprimer car lambda nécessite une expression.
Les fonctions Lambda ont leur propre espace de noms local et ne peuvent pas accéder à des variables autres que celles de leur liste de paramètres et celles de l'espace de noms global.
Bien qu'il semble que les lambdas soient une version sur une ligne d'une fonction, ils ne sont pas équivalents aux instructions inline en C ou C ++, dont le but est d'empiler l'allocation en passant une fonction, lors de l'appel pour des raisons de performances.

Syntaxe

La syntaxe de lambda fonctions ne contient qu'une seule instruction, qui est la suivante -

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

Voici un exemple pour montrer comment lambda forme de fonction fonctionne -

#!/usr/bin/python3

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

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

Value of total :  30
Value of total :  40

La déclaration de retour

L'instruction return [expression] quitte une fonction, en renvoyant éventuellement une expression à l'appelant. Une instruction return sans argument équivaut à return None.

Tous les exemples donnés ci-dessous ne renvoient aucune valeur. Vous pouvez renvoyer une valeur à partir d'une fonction comme suit -

#!/usr/bin/python3

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

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

Inside the function :  30
Outside the function :  30

Portée des variables

Toutes les variables d'un programme peuvent ne pas être accessibles à tous les emplacements de ce programme. Cela dépend de l'endroit où vous avez déclaré une variable.

La portée d'une variable détermine la partie du programme où vous pouvez accéder à un identifiant particulier. Il existe deux étendues de base de variables en Python -

Variables globales
Variables locales

Variables globales et locales

Les variables définies à l'intérieur d'un corps de fonction ont une portée locale et celles définies à l'extérieur ont une portée globale.

Cela signifie que les variables locales ne sont accessibles qu'à l'intérieur de la fonction dans laquelle elles sont déclarées, alors que les variables globales sont accessibles dans tout le corps du programme par toutes les fonctions. Lorsque vous appelez une fonction, les variables déclarées à l'intérieur sont placées dans la portée. Voici un exemple simple -

#!/usr/bin/python3

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

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

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

Un module vous permet d'organiser logiquement votre code Python. Le regroupement du code associé dans un module facilite la compréhension et l'utilisation du code. Un module est un objet Python avec des attributs nommés arbitrairement que vous pouvez lier et référencer.

Simplement, un module est un fichier composé de code Python. Un module peut définir des fonctions, des classes et des variables. Un module peut également inclure du code exécutable.

Exemple

Le code Python d'un module nommé aname réside normalement dans un fichier nomméaname.py. Voici un exemple de module simple, support.py -

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

La déclaration d'importation

Vous pouvez utiliser n'importe quel fichier source Python comme module en exécutant une instruction d'importation dans un autre fichier source Python. leimport a la syntaxe suivante -

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

Lorsque l'interpréteur rencontre une instruction d'importation, il importe le module si le module est présent dans le chemin de recherche. Un chemin de recherche est une liste de répertoires que l'interpréteur recherche avant d'importer un module. Par exemple, pour importer le module hello.py, vous devez mettre la commande suivante en haut du script -

#!/usr/bin/python3

# Import module support
import support

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

Hello : Zara

Un module n'est chargé qu'une seule fois, quel que soit le nombre de fois où il est importé. Cela empêche l'exécution du module de se produire à plusieurs reprises, si plusieurs importations se produisent.

La déclaration from ... import

Python fromL'instruction vous permet d'importer des attributs spécifiques d'un module dans l'espace de noms actuel. lefrom...import a la syntaxe suivante -

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

Par exemple, pour importer la fonction fibonacci depuis le module fib, utilisez l'instruction suivante -

#!/usr/bin/python3

# Fibonacci numbers module

def fib(n): # return Fibonacci series up to n
   result = []
   a, b = 0, 1
   while b < n:
      result.append(b)
      a, b = b, a + b
   return result
>>> from fib import fib
>>> fib(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Cette instruction n'importe pas le module fib entier dans l'espace de noms courant; il introduit simplement l'élément fibonacci du module fib dans la table de symboles globale du module d'importation.

La déclaration from ... import *

Il est également possible d'importer tous les noms d'un module dans l'espace de noms courant en utilisant l'instruction d'importation suivante -

from modname import *

Cela fournit un moyen facile d'importer tous les éléments d'un module dans l'espace de noms actuel; cependant, cette déclaration doit être utilisée avec parcimonie.

Exécution de modules en tant que scripts

Dans un module, le nom du module (sous forme de chaîne) est disponible comme valeur de la variable globale __name__. Le code du module sera exécuté, comme si vous l'aviez importé, mais avec le __name__ mis à "__main__".

Ajoutez ce code à la fin de votre module -

#!/usr/bin/python3

# Fibonacci numbers module

def fib(n): # return Fibonacci series up to n
   result = []
   a, b = 0, 1
   while b < n:
      result.append(b)
      a, b = b, a + b
   return result
if __name__ == "__main__":
   f = fib(100)
   print(f)

Lorsque vous exécutez le code ci-dessus, la sortie suivante s'affiche.

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Localisation des modules

Lorsque vous importez un module, l'interpréteur Python recherche le module dans les séquences suivantes -

Le répertoire actuel.
Si le module n'est pas trouvé, Python recherche alors chaque répertoire dans la variable shell PYTHONPATH.
Si tout le reste échoue, Python vérifie le chemin par défaut. Sous UNIX, ce chemin par défaut est normalement / usr / local / lib / python3 /.

Le chemin de recherche du module est stocké dans le module système sys en tant que sys.pathvariable. La variable sys.path contient le répertoire actuel, PYTHONPATH, et la valeur par défaut dépendante de l'installation.

La variable PYTHONPATH

Le PYTHONPATH est une variable d'environnement, constituée d'une liste de répertoires. La syntaxe de PYTHONPATH est la même que celle de la variable shell PATH.

Voici un PYTHONPATH typique d'un système Windows -

set PYTHONPATH = c:\python34\lib;

Et voici un PYTHONPATH typique d'un système UNIX -

set PYTHONPATH = /usr/local/lib/python

Espaces de noms et portée

Les variables sont des noms (identificateurs) qui correspondent aux objets. Un espace de noms est un dictionnaire de noms de variables (clés) et de leurs objets correspondants (valeurs).

Une instruction Python peut accéder aux variables dans un espace de noms local et dans l' espace de noms global . Si une variable locale et une variable globale ont le même nom, la variable locale masque la variable globale.
Chaque fonction a son propre espace de noms local. Les méthodes de classe suivent la même règle de portée que les fonctions ordinaires.
Python fait des suppositions éclairées sur le fait que les variables sont locales ou globales. Il suppose que toute variable affectée d'une valeur dans une fonction est locale.
Par conséquent, pour affecter une valeur à une variable globale dans une fonction, vous devez d'abord utiliser l'instruction globale.
L'instruction global VarName indique à Python que VarName est une variable globale. Python arrête de rechercher la variable dans l'espace de noms local.

Par exemple, nous définissons une variable Money dans l'espace de noms global. Dans la fonction Money, nous attribuons une valeur à Money, par conséquent Python suppose Money comme variable locale.

Cependant, nous avons accédé à la valeur de la variable locale Money avant de la définir, donc un UnboundLocalError est le résultat. Le fait de ne pas commenter l'instruction globale résout le problème.

#!/usr/bin/python3

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

print (Money)
AddMoney()
print (Money)

La fonction dir ()

La fonction intégrée dir () renvoie une liste triée de chaînes contenant les noms définis par un module.

La liste contient les noms de tous les modules, variables et fonctions définis dans un module. Voici un exemple simple -

#!/usr/bin/python3

# Import built-in module math
import math

content = dir(math)
print (content)

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

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

Ici, la variable de chaîne spéciale __name__ est le nom du module et __file__ est le nom de fichier à partir duquel le module a été chargé.

Les fonctions globals () et locales ()

le globals() et locals() Les fonctions peuvent être utilisées pour renvoyer les noms dans les espaces de noms globaux et locaux en fonction de l'emplacement d'où ils sont appelés.

Si locals() est appelé depuis une fonction, il retournera tous les noms accessibles localement depuis cette fonction.
Si globals() est appelée à partir d'une fonction, elle retournera tous les noms accessibles globalement depuis cette fonction.

Le type de retour de ces deux fonctions est dictionnaire. Par conséquent, les noms peuvent être extraits en utilisant lekeys() fonction.

La fonction reload ()

Lorsqu'un module est importé dans un script, le code de la partie de niveau supérieur d'un module n'est exécuté qu'une seule fois.

Par conséquent, si vous souhaitez réexécuter le code de niveau supérieur dans un module, vous pouvez utiliser la fonction reload () . La fonction reload () importe à nouveau un module précédemment importé. La syntaxe de la fonction reload () est la suivante -

reload(module_name)

Ici, nom_module est le nom du module que vous souhaitez recharger et non la chaîne contenant le nom du module. Par exemple, pour recharger le module hello, procédez comme suit -

reload(hello)

Paquets en Python

Un package est une structure de répertoires de fichiers hiérarchique qui définit un environnement d'application Python unique composé de modules et de sous-packages et de sous-sous-packages, etc.

Considérez un fichier Pots.py disponible dans l'annuaire téléphonique. Ce fichier a la ligne suivante de code source -

#!/usr/bin/python3

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

Similaire, nous avons deux autres fichiers ayant des fonctions différentes avec le même nom que ci-dessus. Ils sont -

Fichier Phone / Isdn.py ayant la fonction Isdn ()
Téléphone / fichier G3.py ayant la fonction G3 ()

Maintenant, créez un autre fichier __init__.py dans le répertoire du téléphone -

Phone/__init__.py

Pour rendre toutes vos fonctions disponibles lorsque vous avez importé Phone, vous devez mettre des instructions d'importation explicites dans __init__.py comme suit -

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

Après avoir ajouté ces lignes à __init__.py, toutes ces classes sont disponibles lorsque vous importez le package Phone.

#!/usr/bin/python3

# Now import your Phone Package.
import Phone

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

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

Dans l'exemple ci-dessus, nous avons pris l'exemple d'une seule fonction dans chaque fichier, mais vous pouvez conserver plusieurs fonctions dans vos fichiers. Vous pouvez également définir différentes classes Python dans ces fichiers, puis créer vos packages à partir de ces classes.

Ce chapitre couvre toutes les fonctions d'E / S de base disponibles dans Python 3. Pour plus de fonctions, veuillez vous référer à la documentation Python standard.

Impression à l'écran

Le moyen le plus simple de produire une sortie consiste à utiliser l' instruction print dans laquelle vous pouvez transmettre zéro ou plusieurs expressions séparées par des virgules. Cette fonction convertit les expressions que vous passez en chaîne et écrit le résultat dans la sortie standard comme suit -

#!/usr/bin/python3

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

Cela produit le résultat suivant sur votre écran standard -

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

Lecture de l'entrée du clavier

Python 2 possède deux fonctions intégrées pour lire les données à partir de l'entrée standard, qui par défaut provient du clavier. Ces fonctions sontinput() et raw_input()

Dans Python 3, la fonction raw_input () est obsolète. De plus, les fonctions input () lisent les données du clavier sous forme de chaîne, qu'elles soient placées entre guillemets («» ou «») ou non.

La fonction d'entrée

le input([prompt]) function équivaut à raw_input, sauf qu'elle suppose que l'entrée est une expression Python valide et vous renvoie le résultat évalué.

#!/usr/bin/python3

>>> x = input("something:")
something:10

>>> x
'10'

>>> x = input("something:")
something:'10' #entered data treated as string with or without ''

>>> x
"'10'"

Ouverture et fermeture de fichiers

Jusqu'à présent, vous lisiez et écriviez sur l'entrée et la sortie standard. Maintenant, nous allons voir comment utiliser les fichiers de données réels.

Python fournit les fonctions et méthodes de base nécessaires pour manipuler les fichiers par défaut. Vous pouvez effectuer la plupart des manipulations de fichiers en utilisant unfile objet.

La fonction ouverte

Avant de pouvoir lire ou écrire un fichier, vous devez l'ouvrir à l'aide de la fonction open () intégrée de Python. Cette fonction crée unfile objet, qui serait utilisé pour appeler d'autres méthodes de support qui lui sont associées.

Syntaxe

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

Voici les détails des paramètres -

file_name - L'argument nom_fichier est une valeur de chaîne contenant le nom du fichier auquel vous souhaitez accéder.
access_mode- Le access_mode détermine le mode dans lequel le fichier doit être ouvert, c'est-à-dire lire, écrire, ajouter, etc. Une liste complète des valeurs possibles est donnée ci-dessous dans le tableau. Il s'agit d'un paramètre facultatif et le mode d'accès aux fichiers par défaut est read (r).
buffering- Si la valeur de mise en mémoire tampon est définie sur 0, aucune mise en mémoire tampon n'a lieu. Si la valeur de mise en mémoire tampon est 1, la mise en mémoire tampon de ligne est effectuée lors de l'accès à un fichier. Si vous spécifiez la valeur de mise en mémoire tampon sous la forme d'un entier supérieur à 1, l'action de mise en mémoire tampon est exécutée avec la taille de tampon indiquée. S'il est négatif, la taille de la mémoire tampon est la valeur par défaut du système (comportement par défaut).

Voici une liste des différents modes d'ouverture d'un fichier -

Sr.No.	Mode et description
1	r Ouvre un fichier en lecture seule. Le pointeur de fichier est placé au début du fichier. C'est le mode par défaut.
2	rb Ouvre un fichier en lecture uniquement au format binaire. Le pointeur de fichier est placé au début du fichier. C'est le mode par défaut.
3	r+ Ouvre un fichier en lecture et en écriture. Le pointeur de fichier placé au début du fichier.
4	rb+ Ouvre un fichier pour la lecture et l'écriture au format binaire. Le pointeur de fichier placé au début du fichier.
5	w Ouvre un fichier pour l'écriture uniquement. Remplace le fichier si le fichier existe. Si le fichier n'existe pas, crée un nouveau fichier à écrire.
6	wb Ouvre un fichier pour l'écriture uniquement au format binaire. Remplace le fichier si le fichier existe. Si le fichier n'existe pas, crée un nouveau fichier à écrire.
sept	w+ Ouvre un fichier pour l'écriture et la lecture. Remplace le fichier existant si le fichier existe. Si le fichier n'existe pas, crée un nouveau fichier pour la lecture et l'écriture.
8	wb+ Ouvre un fichier pour l'écriture et la lecture au format binaire. Remplace le fichier existant si le fichier existe. Si le fichier n'existe pas, crée un nouveau fichier pour la lecture et l'écriture.
9	a Ouvre un fichier à ajouter. Le pointeur de fichier est à la fin du fichier si le fichier existe. Autrement dit, le fichier est en mode ajout. Si le fichier n'existe pas, il crée un nouveau fichier à écrire.
dix	ab Ouvre un fichier à ajouter au format binaire. Le pointeur de fichier est à la fin du fichier si le fichier existe. Autrement dit, le fichier est en mode ajout. Si le fichier n'existe pas, il crée un nouveau fichier à écrire.
11	a+ Ouvre un fichier pour l'ajout et la lecture. Le pointeur de fichier est à la fin du fichier si le fichier existe. Le fichier s'ouvre en mode ajout. Si le fichier n'existe pas, il crée un nouveau fichier pour la lecture et l'écriture.
12	ab+ Ouvre un fichier pour l'ajout et la lecture au format binaire. Le pointeur de fichier est à la fin du fichier si le fichier existe. Le fichier s'ouvre en mode ajout. Si le fichier n'existe pas, il crée un nouveau fichier pour la lecture et l'écriture.

Attributs d'objet de fichier

Une fois qu'un fichier est ouvert et que vous avez un objet fichier , vous pouvez obtenir diverses informations relatives à ce fichier.

Voici une liste de tous les attributs liés à un objet fichier -

Sr.No.	Attribut et description
1	file.closed Renvoie true si le fichier est fermé, false dans le cas contraire.
2	file.mode Renvoie le mode d'accès avec lequel le fichier a été ouvert.
3	file.name Renvoie le nom du fichier.

Note - l'attribut softspace n'est pas pris en charge dans Python 3.x

Exemple

#!/usr/bin/python3

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

Cela produit le résultat suivant -

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

La méthode close ()

La méthode close () d'un objet fichier vide toutes les informations non écrites et ferme l'objet fichier, après quoi aucune écriture ne peut plus être effectuée.

Python ferme automatiquement un fichier lorsque l'objet de référence d'un fichier est réaffecté à un autre fichier. Il est recommandé d'utiliser la méthode close () pour fermer un fichier.

Syntaxe

fileObject.close();

Exemple

#!/usr/bin/python3

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

# Close opened file
fo.close()

Cela produit le résultat suivant -

Name of the file:  foo.txt

Lecture et écriture de fichiers

L'objet fichier fournit un ensemble de méthodes d'accès pour nous faciliter la vie. On verrait comment utiliserread() et write() méthodes pour lire et écrire des fichiers.

La méthode write ()

le write()La méthode écrit n'importe quelle chaîne dans un fichier ouvert. Il est important de noter que les chaînes Python peuvent avoir des données binaires et pas seulement du texte.

La méthode write () n'ajoute pas de caractère de nouvelle ligne ('\ n') à la fin de la chaîne -

Syntaxe

fileObject.write(string);

Ici, le paramètre passé est le contenu à écrire dans le fichier ouvert.

Exemple

#!/usr/bin/python3

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

# Close opend file
fo.close()

La méthode ci-dessus créerait un fichier foo.txt et écrirait le contenu donné dans ce fichier et finalement fermerait ce fichier. Si vous ouvrez ce fichier, il aura le contenu suivant -

Python is a great language.
Yeah its great!!

La méthode read ()

le read()La méthode lit une chaîne dans un fichier ouvert. Il est important de noter que les chaînes Python peuvent avoir des données binaires. en dehors des données textuelles.

Syntaxe

fileObject.read([count]);

Ici, le paramètre passé est le nombre d'octets à lire dans le fichier ouvert. Cette méthode commence la lecture à partir du début du fichier et si le nombre est manquant, elle essaie de lire autant que possible, peut-être jusqu'à la fin du fichier.

Exemple

Prenons un fichier foo.txt , que nous avons créé ci-dessus.

#!/usr/bin/python3

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

# Close opened file
fo.close()

Cela produit le résultat suivant -

Read String is :  Python is

Positions des fichiers

La méthode tell () vous indique la position actuelle dans le fichier; en d'autres termes, la lecture ou l'écriture suivante se produira à ce nombre d'octets depuis le début du fichier.

La méthode de recherche (offset [, from]) modifie la position actuelle du fichier. leoffsetL'argument indique le nombre d'octets à déplacer. lefrom L'argument spécifie la position de référence à partir de laquelle les octets doivent être déplacés.

Si from est défini sur 0, le début du fichier est utilisé comme position de référence. S'il est défini sur 1, la position actuelle est utilisée comme position de référence. S'il est défini sur 2, la fin du fichier sera prise comme position de référence.

Exemple

Prenons un fichier foo.txt , que nous avons créé ci-dessus.

#!/usr/bin/python3

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

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

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

# Close opened file
fo.close()

Cela produit le résultat suivant -

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

Renommer et supprimer des fichiers

Python os module fournit des méthodes qui vous aident à effectuer des opérations de traitement de fichiers, telles que le changement de nom et la suppression de fichiers.

Pour utiliser ce module, vous devez d'abord l'importer, puis vous pouvez appeler toutes les fonctions associées.

La méthode rename ()

le rename() La méthode prend deux arguments, le nom de fichier actuel et le nouveau nom de fichier.

Syntaxe

os.rename(current_file_name, new_file_name)

Exemple

Voici un exemple pour renommer un fichier existant test1.txt -

#!/usr/bin/python3
import os

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

La méthode remove ()

Vous pouvez utiliser le remove() méthode pour supprimer des fichiers en fournissant le nom du fichier à supprimer comme argument.

Syntaxe

os.remove(file_name)

Exemple

Voici un exemple pour supprimer un fichier existant test2.txt -

#!/usr/bin/python3
import os

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

Répertoires en Python

Tous les fichiers sont contenus dans divers répertoires et Python n'a aucun problème à les gérer également. leos module propose plusieurs méthodes qui vous aident à créer, supprimer et modifier des répertoires.

La méthode mkdir ()

Vous pouvez utiliser le mkdir() méthode de la osmodule pour créer des répertoires dans le répertoire courant. Vous devez fournir un argument à cette méthode, qui contient le nom du répertoire à créer.

Syntaxe

os.mkdir("newdir")

Exemple

Voici un exemple pour créer un test de répertoire dans le répertoire courant -

#!/usr/bin/python3
import os

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

La méthode chdir ()

Vous pouvez utiliser la méthode chdir () pour changer le répertoire courant. La méthode chdir () prend un argument, qui est le nom du répertoire que vous voulez faire du répertoire courant.

Syntaxe

os.chdir("newdir")

Exemple

Voici un exemple pour aller dans le répertoire "/ home / newdir" -

#!/usr/bin/python3
import os

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

La méthode getcwd ()

le getcwd() La méthode affiche le répertoire de travail actuel.

Syntaxe

os.getcwd()

Exemple

Voici un exemple pour donner le répertoire courant -

#!/usr/bin/python3
import os

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

La méthode rmdir ()

le rmdir() La méthode supprime le répertoire, qui est passé en argument dans la méthode.

Avant de supprimer un répertoire, tout son contenu doit être supprimé.

Syntaxe

os.rmdir('dirname')

Exemple

Voici un exemple pour supprimer le répertoire "/ tmp / test". Il est nécessaire de donner le nom complet du répertoire, sinon il rechercherait ce répertoire dans le répertoire courant.

#!/usr/bin/python3
import os

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

Méthodes liées aux fichiers et aux répertoires

Il existe trois sources importantes, qui fournissent un large éventail de méthodes utilitaires pour gérer et manipuler les fichiers et répertoires sur les systèmes d'exploitation Windows et Unix. Ils sont les suivants -

Méthodes d'objet fichier

le file object fournit des fonctions pour manipuler les fichiers.
Méthodes d'objets OS

Cela fournit des méthodes pour traiter les fichiers ainsi que les répertoires.

Python fournit deux fonctionnalités très importantes pour gérer toute erreur inattendue dans vos programmes Python et pour y ajouter des capacités de débogage -

Exception Handling- Cela serait couvert dans ce tutoriel. Voici une liste d'exceptions standard disponibles en Python - Exceptions standard .
Assertions- Cela serait couvert dans le didacticiel Assertions in Python 3 .

Exceptions standard

Voici une liste des exceptions standard disponibles en Python. -

Sr.No.	Nom et description de l'exception
1	Exception Classe de base pour toutes les exceptions
2	StopIteration Déclenché lorsque la méthode next () d'un itérateur ne pointe vers aucun objet.
3	SystemExit Déclenché par la fonction sys.exit ().
4	StandardError Classe de base pour toutes les exceptions intégrées à l'exception de StopIteration et SystemExit.
5	ArithmeticError Classe de base pour toutes les erreurs qui se produisent pour le calcul numérique.
6	OverflowError Déclenché lorsqu'un calcul dépasse la limite maximale pour un type numérique.
sept	FloatingPointError Déclenché lorsqu'un calcul en virgule flottante échoue.
8	ZeroDivisonError Augmenté lorsque la division ou le modulo par zéro a lieu pour tous les types numériques.
9	AssertionError Levé en cas d'échec de la déclaration Assert.
dix	AttributeError Levé en cas d'échec de la référence d'attribut ou de l'affectation.
11	EOFError Déclenché lorsqu'il n'y a aucune entrée de la fonction raw_input () ou input () et que la fin du fichier est atteinte.
12	ImportError Déclenché lorsqu'une instruction d'importation échoue.
13	KeyboardInterrupt Déclenché lorsque l'utilisateur interrompt l'exécution du programme, généralement en appuyant sur Ctrl + c.
14	LookupError Classe de base pour toutes les erreurs de recherche.
15	IndexError Déclenché lorsqu'un index n'est pas trouvé dans une séquence.
16	KeyError Déclenché lorsque la clé spécifiée est introuvable dans le dictionnaire.
17	NameError Déclenché lorsqu'un identificateur n'est pas trouvé dans l'espace de noms local ou global.
18	UnboundLocalError Déclenché lors d'une tentative d'accès à une variable locale dans une fonction ou une méthode mais aucune valeur ne lui a été affectée.
19	EnvironmentError Classe de base pour toutes les exceptions qui se produisent en dehors de l'environnement Python.
20	IOError Déclenché lorsqu'une opération d'entrée / sortie échoue, comme l'instruction d'impression ou la fonction open () lors d'une tentative d'ouverture d'un fichier qui n'existe pas.
21	OSError Levé pour des erreurs liées au système d'exploitation.
22	SyntaxError Déclenché en cas d'erreur dans la syntaxe Python.
23	IndentationError Levé lorsque l'indentation n'est pas spécifiée correctement.
24	SystemError Déclenché lorsque l'interpréteur trouve un problème interne, mais lorsque cette erreur est rencontrée, l'interpréteur Python ne se ferme pas.
25	SystemExit Déclenché lorsque l'interpréteur Python est fermé à l'aide de la fonction sys.exit (). S'il n'est pas traité dans le code, provoque la fermeture de l'interpréteur.
26	TypeError Déclenché lorsqu'une opération ou une fonction est tentée qui n'est pas valide pour le type de données spécifié.
27	ValueError Déclenché lorsque la fonction intégrée pour un type de données a le type d'arguments valide, mais que les arguments ont des valeurs non valides spécifiées.
28	RuntimeError Déclenché lorsqu'une erreur générée n'appartient à aucune catégorie.
29	NotImplementedError Déclenché lorsqu'une méthode abstraite qui doit être implémentée dans une classe héritée n'est pas réellement implémentée.

Assertions en Python

Une assertion est un contrôle de cohérence que vous pouvez activer ou désactiver lorsque vous avez terminé votre test du programme.

La façon la plus simple de penser à une assertion est de la comparer à un raise-ifinstruction (ou pour être plus précis, une instruction rise-if-not). Une expression est testée et si le résultat est faux, une exception est déclenchée.
Les assertions sont effectuées par l'instruction assert, le mot-clé le plus récent de Python, introduit dans la version 1.5.
Les programmeurs placent souvent des assertions au début d'une fonction pour vérifier l'entrée valide, et après un appel de fonction pour vérifier la sortie valide.

La déclaration d'assert

Lorsqu'il rencontre une instruction assert, Python évalue l'expression d'accompagnement, ce qui est, espérons-le, vrai. Si l'expression est fausse, Python déclenche une exception AssertionError .

La syntaxe pour assert est -

assert Expression[, Arguments]

Si l'assertion échoue, Python utilise ArgumentExpression comme argument pour AssertionError. Les exceptions AssertionError peuvent être interceptées et gérées comme toute autre exception, à l'aide de l'instruction try-except. S'ils ne sont pas traités, ils mettront fin au programme et produiront une trace.

Exemple

Voici une fonction qui convertit une température donnée de degrés Kelvin en degrés Fahrenheit. Comme 0 ° K est aussi froid que possible, la fonction se retire si elle voit une température négative -

#!/usr/bin/python3

def KelvinToFahrenheit(Temperature):
   assert (Temperature >= 0),"Colder than absolute zero!"
   return ((Temperature-273)*1.8)+32

print (KelvinToFahrenheit(273))
print (int(KelvinToFahrenheit(505.78)))
print (KelvinToFahrenheit(-5))

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

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

Qu'est-ce qu'une exception?

Une exception est un événement, qui se produit pendant l'exécution d'un programme qui perturbe le flux normal des instructions du programme. En général, lorsqu'un script Python rencontre une situation à laquelle il ne peut pas faire face, il déclenche une exception. Une exception est un objet Python qui représente une erreur.

Lorsqu'un script Python lève une exception, il doit soit gérer l'exception immédiatement, sinon il se termine et se ferme.

Gérer une exception

Si vous avez un code suspect qui peut soulever une exception, vous pouvez défendre votre programme en plaçant le code suspect dans untry:bloquer. Après l'essai: bloquer, inclure unexcept: , suivi d'un bloc de code qui gère le problème le plus élégamment possible.

Syntaxe

Voici la syntaxe simple de try .... sauf ... else blocs -

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

Voici quelques points importants sur la syntaxe mentionnée ci-dessus -

Une seule instruction try peut avoir plusieurs instructions except. Ceci est utile lorsque le bloc try contient des instructions qui peuvent lever différents types d'exceptions.
Vous pouvez également fournir une clause except générique, qui gère toute exception.
Après la ou les clause (s) except, vous pouvez inclure une clause else. Le code du bloc else s'exécute si le code du bloc try: ne déclenche pas d'exception.
Le bloc else est un bon endroit pour le code qui n'a pas besoin de la protection try: block.

Exemple

Cet exemple ouvre un fichier, écrit le contenu dans le fichier, et sort correctement car il n'y a aucun problème -

#!/usr/bin/python3

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

Cela produit le résultat suivant -

Written content in the file successfully

Exemple

Cet exemple tente d'ouvrir un fichier dans lequel vous n'avez pas l'autorisation d'écriture, il lève donc une exception -

#!/usr/bin/python3

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

Cela produit le résultat suivant -

Error: can't find file or read data

La clause except sans exception

Vous pouvez également utiliser l'instruction except sans aucune exception définie comme suit -

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

Ce genre de try-exceptL'instruction intercepte toutes les exceptions qui se produisent. L'utilisation de ce type d'instruction try-except n'est cependant pas considérée comme une bonne pratique de programmation, car elle intercepte toutes les exceptions mais ne permet pas au programmeur d'identifier la cause première du problème pouvant survenir.

La clause except avec plusieurs exceptions

Vous pouvez également utiliser la même instruction except pour gérer plusieurs exceptions comme suit -

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

La clause try-finally

Vous pouvez utiliser un finally: bloquer avec un try:bloquer. lefinally:block est un endroit pour placer tout code qui doit s'exécuter, que le bloc try ait déclenché une exception ou non. La syntaxe de l'instruction try-finally est la suivante:

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

Note- Vous pouvez fournir des clauses except ou une clause finally, mais pas les deux. Vous ne pouvez pas également utiliser la clause else avec une clause finally.

Exemple

#!/usr/bin/python3

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

Si vous n'avez pas l'autorisation d'ouvrir le fichier en mode écriture, cela produira le résultat suivant -

Error: can't find file or read data

Le même exemple peut être écrit plus proprement comme suit -

#!/usr/bin/python3

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

Cela produit le résultat suivant -

Going to close the file

Lorsqu'une exception est levée dans le bloc try , l'exécution passe immédiatement au bloc finally . Une fois que toutes les instructions du bloc finally ont été exécutées, l'exception est à nouveau déclenchée et est gérée dans les instructions except si elle est présente dans la couche supérieure suivante de l' instruction try-except .

Argument d'une exception

Une exception peut avoir un argument , qui est une valeur qui donne des informations supplémentaires sur le problème. Le contenu de l'argument varie par exception. Vous capturez l'argument d'une exception en fournissant une variable dans la clause except comme suit -

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

Si vous écrivez le code pour gérer une seule exception, vous pouvez faire en sorte qu'une variable suive le nom de l'exception dans l'instruction except. Si vous interceptez plusieurs exceptions, vous pouvez faire en sorte qu'une variable suive le tuple de l'exception.

Cette variable reçoit la valeur de l'exception contenant principalement la cause de l'exception. La variable peut recevoir une ou plusieurs valeurs sous la forme d'un tuple. Ce tuple contient généralement la chaîne d'erreur, le numéro d'erreur et un emplacement d'erreur.

Exemple

Voici un exemple pour une seule exception -

#!/usr/bin/python3

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

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

Cela produit le résultat suivant -

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

Lever une exception

Vous pouvez lever des exceptions de plusieurs manières à l'aide de l'instruction rise. La syntaxe générale duraise la déclaration est la suivante -

Syntaxe

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

Ici, Exception est le type d'exception (par exemple, NameError) et l' argument est une valeur pour l'argument d'exception. L'argument est facultatif; s'il n'est pas fourni, l'argument d'exception est None.

L'argument final, traceback, est également facultatif (et rarement utilisé dans la pratique), et s'il est présent, est l'objet de traceback utilisé pour l'exception.

Exemple

Une exception peut être une chaîne, une classe ou un objet. La plupart des exceptions soulevées par le noyau Python sont des classes, avec un argument qui est une instance de la classe. La définition de nouvelles exceptions est assez simple et peut être effectuée comme suit -

def functionName( level ):
   if level <1:
      raise Exception(level)
      # The code below to this would not be executed
      # if we raise the exception
   return level

Note- Pour intercepter une exception, une clause "except" doit faire référence à la même exception lancée soit comme un objet de classe, soit comme une simple chaîne. Par exemple, pour capturer l'exception ci-dessus, nous devons écrire la clause except comme suit -

try:
   Business Logic here...
except Exception as e:
   Exception handling here using e.args...
else:
   Rest of the code here...

L'exemple suivant illustre l'utilisation de la levée d'une exception -

#!/usr/bin/python3

def functionName( level ):
   if level <1:
      raise Exception(level)
      # The code below to this would not be executed
      # if we raise the exception
   return level

try:
   l = functionName(-10)
   print ("level = ",l)
except Exception as e:
   print ("error in level argument",e.args[0])

Cela produira le résultat suivant

error in level argument -10

Exceptions définies par l'utilisateur

Python vous permet également de créer vos propres exceptions en dérivant des classes à partir des exceptions intégrées standard.

Voici un exemple lié à RuntimeError . Ici, une classe est créée qui est sous- classée à partir de RuntimeError . Ceci est utile lorsque vous devez afficher des informations plus spécifiques lorsqu'une exception est interceptée.

Dans le bloc try, l'exception définie par l'utilisateur est déclenchée et interceptée dans le bloc except. La variable e est utilisée pour créer une instance de la classe Networkerror .

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

Donc, une fois que vous avez défini la classe ci-dessus, vous pouvez lever l'exception comme suit -

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

Python est un langage orienté objet depuis son existence. Pour cette raison, la création et l'utilisation de classes et d'objets sont carrément faciles. Ce chapitre vous aide à devenir un expert dans l'utilisation de la prise en charge de la programmation orientée objet de Python.

Si vous n'avez aucune expérience préalable de la programmation orientée objet (OO), vous voudrez peut-être consulter un cours d'introduction à ce sujet ou au moins un didacticiel quelconque afin d'avoir une compréhension des concepts de base.

Cependant, voici une petite introduction à la programmation orientée objet (POO) pour vous aider -

Aperçu de la terminologie de la POO

Class- Un prototype défini par l'utilisateur pour un objet qui définit un ensemble d'attributs qui caractérisent tout objet de la classe. Les attributs sont des membres de données (variables de classe et variables d'instance) et des méthodes, accessibles via la notation par points.
Class variable- Une variable partagée par toutes les instances d'une classe. Les variables de classe sont définies dans une classe mais en dehors de toute méthode de la classe. Les variables de classe ne sont pas utilisées aussi fréquemment que les variables d'instance.
Data member - Une variable de classe ou une variable d'instance qui contient les données associées à une classe et à ses objets.
Function overloading- L'affectation de plus d'un comportement à une fonction particulière. L'opération effectuée varie selon les types d'objets ou d'arguments impliqués.
Instance variable - Une variable qui est définie à l'intérieur d'une méthode et appartient uniquement à l'instance actuelle d'une classe.
Inheritance - Le transfert des caractéristiques d'une classe vers d'autres classes qui en dérivent.
Instance- Un objet individuel d'une certaine classe. Un objet obj qui appartient à une classe Circle, par exemple, est une instance de la classe Circle.
Instantiation - La création d'une instance d'une classe.
Method - Un type spécial de fonction qui est défini dans une définition de classe.
Object- Une instance unique d'une structure de données définie par sa classe. Un objet comprend à la fois des membres de données (variables de classe et variables d'instance) et des méthodes.
Operator overloading - L'affectation de plus d'une fonction à un opérateur particulier.

Créer des classes

L' instruction de classe crée une nouvelle définition de classe. Le nom de la classe suit immédiatement la classe de mot-clé suivie de deux points comme suit -

class ClassName:
   'Optional class documentation string'
   class_suite

La classe a une chaîne de documentation, accessible via ClassName.__doc__.
le class_suite se compose de toutes les instructions de composant définissant les membres de classe, les attributs de données et les fonctions.

Exemple

Voici un exemple de classe Python simple -

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

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

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

La variable empCount est une variable de classe dont la valeur est partagée entre toutes les instances de a de cette classe. Ceci est accessible en tant que Employee.empCount depuis l'intérieur de la classe ou en dehors de la classe.
La première méthode __init __ () est une méthode spéciale, appelée constructeur de classe ou méthode d'initialisation que Python appelle lorsque vous créez une nouvelle instance de cette classe.
Vous déclarez d'autres méthodes de classe comme des fonctions normales à l'exception du fait que le premier argument de chaque méthode est self . Python ajoute l' argument self à la liste pour vous; vous n'avez pas besoin de l'inclure lorsque vous appelez les méthodes.

Création d'objets d'instance

Pour créer des instances d'une classe, vous appelez la classe en utilisant le nom de la classe et transmettez les arguments acceptés par sa méthode __init__ .

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

Accéder aux attributs

Vous accédez aux attributs de l'objet à l'aide de l'opérateur point avec objet. La variable de classe serait accessible en utilisant le nom de classe comme suit -

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

Maintenant, rassemblant tous les concepts -

#!/usr/bin/python3

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

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

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


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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

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

Vous pouvez ajouter, supprimer ou modifier des attributs de classes et d'objets à tout moment -

emp1.salary = 7000  # Add an 'salary' attribute.
emp1.name = 'xyz'  # Modify 'age' attribute.
del emp1.salary  # Delete 'age' attribute.

Au lieu d'utiliser les instructions normales pour accéder aux attributs, vous pouvez utiliser les fonctions suivantes -

le getattr(obj, name[, default]) - pour accéder à l'attribut d'objet.
le hasattr(obj,name) - pour vérifier si un attribut existe ou non.
le setattr(obj,name,value)- pour définir un attribut. Si l'attribut n'existe pas, il serait créé.
le delattr(obj, name) - pour supprimer un attribut.

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

Attributs de classe intégrés

Chaque classe Python continue de suivre les attributs intégrés et ils sont accessibles à l'aide de l'opérateur point comme tout autre attribut -

__dict__ - Dictionnaire contenant l'espace de noms de la classe.
__doc__ - Chaîne de documentation de classe ou aucune, si non définie.
__name__ - Nom de la classe.
__module__- Nom du module dans lequel la classe est définie. Cet attribut est "__main__" en mode interactif.
__bases__ - Un tuple éventuellement vide contenant les classes de base, dans l'ordre de leur occurrence dans la liste des classes de base.

Pour la classe ci-dessus, essayons d'accéder à tous ces attributs -

#!/usr/bin/python3

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

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

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

emp1 = Employee("Zara", 2000)
emp2 = Employee("Manni", 5000)
print ("Employee.__doc__:", Employee.__doc__)
print ("Employee.__name__:", Employee.__name__)
print ("Employee.__module__:", Employee.__module__)
print ("Employee.__bases__:", Employee.__bases__)
print ("Employee.__dict__:", Employee.__dict__ )

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

Employee.__doc__: Common base class for all employees
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: (<class 'object'>,)
Employee.__dict__: {
   'displayCount': <function Employee.displayCount at 0x0160D2B8>, 
   '__module__': '__main__', '__doc__': 'Common base class for all employees', 
   'empCount': 2, '__init__': 
   <function Employee.__init__ at 0x0124F810>, 'displayEmployee': 
   <function Employee.displayEmployee at 0x0160D300>,
   '__weakref__': 
   <attribute '__weakref__' of 'Employee' objects>, '__dict__': 
   <attribute '__dict__' of 'Employee' objects>
}

Détruire des objets (Garbage Collection)

Python supprime automatiquement les objets inutiles (types intégrés ou instances de classe) pour libérer de l'espace mémoire. Le processus par lequel Python récupère périodiquement des blocs de mémoire qui ne sont plus utilisés est appelé Garbage Collection.

Le garbage collector de Python s'exécute pendant l'exécution du programme et est déclenché lorsque le nombre de références d'un objet atteint zéro. Le nombre de références d'un objet change à mesure que le nombre d'alias qui pointent vers lui change.

Le nombre de références d'un objet augmente lorsqu'il reçoit un nouveau nom ou est placé dans un conteneur (liste, tuple ou dictionnaire). Le nombre de références de l'objet diminue lorsqu'il est supprimé avec del , sa référence est réaffectée ou sa référence est hors de portée. Lorsque le nombre de références d'un objet atteint zéro, Python le collecte automatiquement.

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

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

Vous ne remarquerez normalement pas quand le garbage collector détruit une instance orpheline et récupère son espace. Cependant, une classe peut implémenter la méthode spéciale __del __ () , appelée destructeur, qui est appelée lorsque l'instance est sur le point d'être détruite. Cette méthode peut être utilisée pour nettoyer toutes les ressources non mémoire utilisées par une instance.

Exemple

Ce destructeur __del __ () imprime le nom de classe d'une instance qui est sur le point d'être détruite -

#!/usr/bin/python3

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

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

140338326963984 140338326963984 140338326963984
Point destroyed

Note- Idéalement, vous devez définir vos classes dans un fichier séparé, puis vous devez les importer dans votre fichier programme principal à l'aide de l' instruction import .

Dans l'exemple ci-dessus, en supposant que la définition d'une classe Point est contenue dans point.py et qu'il n'y a pas d'autre code exécutable dedans.

#!/usr/bin/python3
import point

p1 = point.Point()

Héritage de classe

Au lieu de partir de zéro, vous pouvez créer une classe en la dérivant d'une classe préexistante en répertoriant la classe parente entre parenthèses après le nouveau nom de classe.

La classe enfant hérite des attributs de sa classe parente et vous pouvez utiliser ces attributs comme s'ils étaient définis dans la classe enfant. Une classe enfant peut également remplacer les membres de données et les méthodes du parent.

Syntaxe

Les classes dérivées sont déclarées un peu comme leur classe parente; cependant, une liste de classes de base à hériter est donnée après le nom de la classe -

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

Exemple

#!/usr/bin/python3

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

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

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

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

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

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

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

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

De la même manière, vous pouvez piloter une classe à partir de plusieurs classes parentes comme suit -

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

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

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

Vous pouvez utiliser les fonctions issubclass () ou isinstance () pour vérifier les relations de deux classes et instances.

le issubclass(sub, sup) La fonction booléenne renvoie True, si la sous-classe donnée sub est en effet une sous-classe de la superclasse sup.
le isinstance(obj, Class)La fonction booléenne renvoie True, si obj est une instance de classe Class ou est une instance d'une sous-classe de Class

Remplacer les méthodes

Vous pouvez toujours remplacer vos méthodes de classe parentes. Une des raisons de remplacer les méthodes parent est que vous pouvez souhaiter des fonctionnalités spéciales ou différentes dans votre sous-classe.

Exemple

#!/usr/bin/python3

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

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

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

Calling child method

Méthodes de surcharge de base

Le tableau suivant répertorie certaines fonctionnalités génériques que vous pouvez remplacer dans vos propres classes -

Sr.No.	Méthode, description et exemple d'appel
1	__init__ ( self [,args...] ) Constructeur (avec tous les arguments facultatifs) Exemple d'appel: obj = className (args)
2	__del__( self ) Destructeur, supprime un objet Exemple d'appel: del obj
3	__repr__( self ) Représentation sous forme de chaîne évaluable Exemple d'appel: repr (obj)
4	__str__( self ) Représentation sous forme de chaîne imprimable Exemple d'appel: str (obj)
5	__cmp__ ( self, x ) Comparaison d'objets Exemple d'appel: cmp (obj, x)

Surcharge des opérateurs

Supposons que vous ayez créé une classe Vector pour représenter des vecteurs à deux dimensions. Que se passe-t-il lorsque vous utilisez l'opérateur plus pour les ajouter? Il est fort probable que Python vous crie dessus.

Vous pouvez, cependant, définir la méthode __add__ dans votre classe pour effectuer l'ajout de vecteurs, puis l'opérateur plus se comporterait comme prévu -

Exemple

#!/usr/bin/python3

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

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

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

Vector(7,8)

Masquage des données

Les attributs d'un objet peuvent ou non être visibles en dehors de la définition de classe. Vous devez nommer les attributs avec un double préfixe de soulignement, et ces attributs ne seront alors pas directement visibles pour les étrangers.

Exemple

#!/usr/bin/python3

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

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

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

Python protège ces membres en modifiant le nom en interne pour inclure le nom de la classe. Vous pouvez accéder à des attributs tels que object._className__attrName . Si vous remplacez votre dernière ligne comme suit, cela fonctionne pour vous -

.........................
print (counter._JustCounter__secretCount)

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

1
2
2

Une expression régulière est une séquence spéciale de caractères qui vous aide à faire correspondre ou à trouver d'autres chaînes ou ensembles de chaînes, en utilisant une syntaxe spécialisée contenue dans un modèle. Les expressions régulières sont largement utilisées dans le monde UNIX.

Le module refournit une prise en charge complète des expressions régulières de type Perl en Python. lere module lève l'exception re.error si une erreur se produit lors de la compilation ou de l'utilisation d'une expression régulière.

Nous couvririons deux fonctions importantes, qui seraient utilisées pour gérer les expressions régulières. Néanmoins, une petite chose d'abord: il existe différents caractères, qui auraient une signification particulière lorsqu'ils sont utilisés dans une expression régulière. Pour éviter toute confusion lors du traitement des expressions régulières, nous utiliserions Raw Strings commer'expression'.

Modèles de base qui correspondent à des caractères uniques

Sr.No.	Expression et correspondances
1	a, X, 9, < les caractères ordinaires se correspondent exactement.
2	. (a period) correspond à n'importe quel caractère unique sauf le retour à la ligne '\ n'
3	\w correspond à un caractère "mot": une lettre ou un chiffre ou un tiret [a-zA-Z0-9_].
4	\W correspond à n'importe quel caractère autre qu'un mot.
5	\b frontière entre mot et non-mot
6	\s correspond à un seul caractère d'espacement - espace, nouvelle ligne, retour, tabulation
sept	\S correspond à n'importe quel caractère non blanc.
8	\t, \n, \r tabulation, nouvelle ligne, retour
9	\d chiffre décimal [0-9]
dix	^ correspond au début de la chaîne
11	$ correspond à la fin de la chaîne
12	\ inhiber la "particularité" d'un personnage.

Drapeaux de compilation

Les indicateurs de compilation vous permettent de modifier certains aspects du fonctionnement des expressions régulières. Les drapeaux sont disponibles dans le module re sous deux noms, un nom long tel queIGNORECASE et un court formulaire à une lettre comme I.

Sr.No.	Drapeau et signification
1	ASCII, A Fait correspondre plusieurs échappements comme \ w, \ b, \ s et \ d uniquement sur les caractères ASCII avec la propriété respective.
2	DOTALL, S Créez, faites correspondre n'importe quel caractère, y compris les nouvelles lignes
3	IGNORECASE, I Faire des correspondances insensibles à la casse
4	LOCALE, L Faire une correspondance tenant compte des paramètres régionaux
5	MULTILINE, M Correspondance multiligne, affectant ^ et $
6	VERBOSE, X (for ‘extended’) Activer les RE verbeux, qui peuvent être organisés de manière plus propre et compréhensible

La fonction match

Cette fonction tente de faire correspondre le modèle RE à une chaîne avec des indicateurs facultatifs .

Voici la syntaxe de cette fonction -

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

Voici la description des paramètres -

Sr.No.	Paramètre et description
1	pattern Il s'agit de l'expression régulière à rechercher.
2	string Il s'agit de la chaîne qui serait recherchée pour correspondre au modèle au début de la chaîne.
3	flags Vous pouvez spécifier différents indicateurs en utilisant OU au niveau du bit (\|). Ce sont des modificateurs, qui sont répertoriés dans le tableau ci-dessous.

La fonction re.match renvoie unmatch objecter au succès, Noneen cas d'échec. Nous utilisons la fonction group (num) ou groups () dematch objet pour obtenir l'expression correspondante.

Sr.No.	Match Object, méthode et description
1	group(num = 0) Cette méthode renvoie une correspondance complète (ou un numéro de sous-groupe spécifique)
2	groups() Cette méthode retourne tous les sous-groupes correspondants dans un tuple (vide s'il n'y en avait pas)

Exemple

#!/usr/bin/python3
import re

line = "Cats are smarter than dogs"

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

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

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

La fonction de recherche

Cette fonction recherche la première occurrence du modèle RE dans une chaîne avec des indicateurs facultatifs .

Voici la syntaxe de cette fonction -

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

Voici la description des paramètres -

Sr.No.	Paramètre et description
1	pattern Il s'agit de l'expression régulière à rechercher.
2	string Il s'agit de la chaîne qui sera recherchée pour correspondre au modèle n'importe où dans la chaîne.
3	flags Vous pouvez spécifier différents indicateurs en utilisant OU au niveau du bit (\|). Ce sont des modificateurs, qui sont répertoriés dans le tableau ci-dessous.

La fonction re.search renvoie unmatch objecter au succès, noneen cas d'échec. Nous utilisons la fonction group (num) ou groups () dematch objet pour obtenir l'expression correspondante.

Sr.No.	Match Object, méthode et description
1	group(num = 0) Cette méthode renvoie une correspondance complète (ou un numéro de sous-groupe spécifique)
2	groups() Cette méthode retourne tous les sous-groupes correspondants dans un tuple (vide s'il n'y en avait pas)

Exemple

#!/usr/bin/python3
import re

line = "Cats are smarter than dogs";

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

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

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

Correspondance et recherche

Python propose deux opérations primitives différentes basées sur des expressions régulières: match recherche une correspondance uniquement au début de la chaîne, tandis que search recherche une correspondance n'importe où dans la chaîne (c'est ce que fait Perl par défaut).

Exemple

#!/usr/bin/python3
import re

line = "Cats are smarter than dogs";

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

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

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

Rechercher et remplacer

L'un des plus importants re méthodes qui utilisent des expressions régulières est sub.

Syntaxe

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

Cette méthode remplace toutes les occurrences du modèle RE dans la chaîne par repl , en remplaçant toutes les occurrences sauf si max est fourni. Cette méthode renvoie une chaîne modifiée.

Exemple

#!/usr/bin/python3
import re

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

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

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

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

Modificateurs d'expressions régulières: indicateurs d'option

Les littéraux d'expression régulière peuvent inclure un modificateur facultatif pour contrôler divers aspects de la correspondance. Les modificateurs sont spécifiés comme un indicateur facultatif. Vous pouvez fournir plusieurs modificateurs en utilisant OU exclusif (|), comme indiqué précédemment et peut être représenté par l'un de ces -

Sr.No.	Modificateur et description
1	re.I Effectue une correspondance insensible à la casse.
2	re.L Interprète les mots en fonction des paramètres régionaux actuels. Cette interprétation affecte le groupe alphabétique (\ w et \ W), ainsi que le comportement des limites des mots (\ b et \ B).
3	re.M Fait correspondre $ à la fin d'une ligne (pas seulement la fin de la chaîne) et fait correspondre ^ le début de n'importe quelle ligne (pas seulement le début de la chaîne).
4	re.S Fait correspondre un point (point) à n'importe quel caractère, y compris une nouvelle ligne.
5	re.U Interprète les lettres selon le jeu de caractères Unicode. Cet indicateur affecte le comportement de \ w, \ W, \ b, \ B.
6	re.X Permet une syntaxe d'expression régulière "plus mignonne". Il ignore les espaces (sauf à l'intérieur d'un ensemble [] ou lorsqu'il est échappé par une barre oblique inverse) et traite un # non échappé comme un marqueur de commentaire.

Modèles d'expressions régulières

Sauf pour les caractères de contrôle, (+ ? . * ^ $ ( ) [ ] { } | \), tous les personnages se correspondent. Vous pouvez échapper un caractère de contrôle en le précédant d'une barre oblique inverse.

Le tableau suivant répertorie la syntaxe d'expression régulière disponible en Python -

Voici la liste de la syntaxe des expressions régulières en Python.

Sr.No.	Paramètre et description
1	^ Correspond au début de la ligne.
2	$ Correspond à la fin de la ligne.
3	. Correspond à n'importe quel caractère unique sauf le saut de ligne. L'utilisation de l'option m lui permet également de correspondre à la nouvelle ligne.
4	[...] Correspond à n'importe quel caractère unique entre crochets.
5	[^...] Correspond à n'importe quel caractère unique non entre crochets
6	re* Correspond à 0 occurrences ou plus de l'expression précédente.
sept	re+ Correspond à une ou plusieurs occurrences de l'expression précédente.
8	re? Correspond à 0 ou 1 occurrence de l'expression précédente.
9	re{ n} Correspond exactement au nombre n d'occurrences de l'expression précédente.
dix	re{ n,} Correspond à n occurrences ou plus de l'expression précédente.
11	re{ n, m} Correspond à au moins n et au plus m occurrences de l'expression précédente.
12	a\|b Correspond à a ou b.
13	(re) Regroupe les expressions régulières et mémorise le texte correspondant.
14	(?imx) Bascule temporairement sur les options i, m ou x dans une expression régulière. Si entre parenthèses, seule cette zone est affectée.
15	(?-imx) Désactive temporairement les options i, m ou x dans une expression régulière. Si entre parenthèses, seule cette zone est affectée.
16	(?: re) Regroupe les expressions régulières sans se souvenir du texte correspondant.
17	(?imx: re) Active temporairement les options i, m ou x entre parenthèses.
18	(?-imx: re) Désactive temporairement les options i, m ou x entre parenthèses.
19	(?#...) Commentaire.
20	(?= re) Spécifie la position à l'aide d'un motif. N'a pas de plage.
21	(?! re) Spécifie la position à l'aide de la négation du motif. N'a pas de plage.
22	(?> re) Correspond à un motif indépendant sans retour en arrière.
23	\w Correspond aux caractères des mots.
24	\W Correspond aux caractères non-mots.
25	\s Correspond aux espaces. Équivaut à [\ t \ n \ r \ f].
26	\S Correspond à un espace non blanc.
27	\d Correspond aux chiffres. Équivalent à [0-9].
28	\D Correspond aux non-chiffres.
29	\A Correspond au début de la chaîne.
30	\Z Correspond à la fin de la chaîne. Si une nouvelle ligne existe, elle correspond juste avant la nouvelle ligne.
31	\z Correspond à la fin de la chaîne.
32	\G Correspond au point où le dernier match s'est terminé.
33	\b Correspond aux limites des mots en dehors des crochets. Correspond à l'espace arrière (0x08) lorsqu'il est entre crochets.
34	\B Correspond aux limites autres que des mots.
35	\n, \t, etc. Correspond aux retours à la ligne, aux retours chariot, aux tabulations, etc.
36	\1...\9 Correspond à la nième sous-expression groupée.
37	\10 Correspond à la nième sous-expression groupée si elle correspond déjà. Sinon, fait référence à la représentation octale d'un code de caractère.

Exemples d'expressions régulières

Caractères littéraux

Sr.No.	Exemple et description
1	python Correspond à "python".

Classes de caractères

Sr.No.	Exemple et description
1	[Pp]ython Correspond à "Python" ou "python"
2	rub[ye] Correspondre à "ruby" ou "rube"
3	[aeiou] Correspond à n'importe quelle voyelle minuscule
4	[0-9] Correspond à n'importe quel chiffre; identique à [0123456789]
5	[a-z] Correspond à n'importe quelle lettre ASCII minuscule
6	[A-Z] Correspond à n'importe quelle lettre ASCII majuscule
sept	[a-zA-Z0-9] Correspond à l'un des éléments ci-dessus
8	[^aeiou] Correspond à tout autre chose qu'une voyelle minuscule
9	[^0-9] Correspond à autre chose qu'un chiffre

Classes de caractères spéciaux

Sr.No.	Exemple et description
1	. Correspond à n'importe quel caractère sauf le saut de ligne
2	\d Faire correspondre un chiffre: [0-9]
3	\D Faire correspondre un non-chiffre: [^ 0-9]
4	\s Faire correspondre un caractère d'espacement: [\ t \ r \ n \ f]
5	\S Correspondre à un espace non blanc: [^ \ t \ r \ n \ f]
6	\w Faire correspondre un seul caractère de mot: [A-Za-z0-9_]
sept	\W Correspond à un caractère non-mot: [^ A-Za-z0-9_]

Cas de répétition

Sr.No.	Exemple et description
1	ruby? Match "rub" ou "ruby": le y est facultatif
2	ruby* Correspond à "frotter" plus 0 ou plus de y
3	ruby+ Correspond à "frotter" plus 1 ou plus de y
4	\d{3} Correspond exactement à 3 chiffres
5	\d{3,} Correspond à 3 chiffres ou plus
6	\d{3,5} Correspond à 3, 4 ou 5 chiffres

Répétition sans réverbération

Cela correspond au plus petit nombre de répétitions -

Sr.No.	Exemple et description
1	*<.>** Répétition gourmande: correspond à "<python> perl>"
2	*<.?>** Nongreedy: correspond à "<python>" dans "<python> perl>"

Regroupement avec des parenthèses

Sr.No.	Exemple et description
1	\D\d+ Aucun groupe: + répète \ d
2	(\D\d)+ Groupé: + répète \ D \ d paire
3	([Pp]ython(,)?)+ Faites correspondre "Python", "Python, python, python", etc.

Références arrière

Cela correspond à nouveau à un groupe précédemment apparié -

Sr.No.	Exemple et description
1	([Pp])ython&\1ails Match python & seaux ou Python & seaux
2	*(['"])[^\1]\1** Chaîne entre guillemets simples ou doubles. \ 1 correspond quel que soit le premier groupe correspondant. \ 2 correspond quel que soit le 2e groupe, etc.

Alternatives

Sr.No.	Exemple et description
1	python\|perl Correspond à "python" ou "perl"
2	rub(y\|le) Faire correspondre «rubis» ou «rouble»
3	Python(!+\|\?) "Python" suivi d'un ou plusieurs! ou un ?

Ancres

Cela doit spécifier la position de correspondance.

Sr.No.	Exemple et description
1	^Python Correspond à "Python" au début d'une chaîne ou d'une ligne interne
2	Python$ Correspond à "Python" à la fin d'une chaîne ou d'une ligne
3	\APython Correspond à "Python" au début d'une chaîne
4	Python\Z Correspond à "Python" à la fin d'une chaîne
5	\bPython\b Faire correspondre "Python" à une limite de mot
6	\brub\B \ B n'est pas une limite de mot: correspond à "frotter" dans "rube" et "ruby" mais pas seul
sept	Python(?=!) Correspond à "Python", s'il est suivi d'un point d'exclamation.
8	Python(?!!) Correspond à "Python", s'il n'est pas suivi d'un point d'exclamation.

Syntaxe spéciale avec parenthèses

Sr.No.	Exemple et description
1	R(?#comment) Correspond à "R". Tout le reste est un commentaire
2	R(?i)uby Insensible à la casse tout en correspondant à "uby"
3	R(?i:uby) Comme ci-dessus
4	rub(?:y\|le)) Grouper uniquement sans créer \ 1 backreference

L'interface de passerelle commune, ou CGI, est un ensemble de normes qui définissent la manière dont les informations sont échangées entre le serveur Web et un script personnalisé. Les spécifications CGI sont actuellement mises à jour par le NCSA.

Qu'est-ce que CGI?

L'interface de passerelle commune, ou CGI, est une norme permettant aux programmes de passerelle externes de s'interfacer avec des serveurs d'informations tels que des serveurs HTTP.
La version actuelle est CGI / 1.1 et CGI / 1.2 est en cours de développement.

Navigation sur le Web

Pour comprendre le concept de CGI, voyons ce qui se passe lorsque nous cliquons sur un hyperlien pour parcourir une page Web ou une URL particulière.

Votre navigateur contacte le serveur Web HTTP et demande l'URL, c'est-à-dire le nom de fichier.
Le serveur Web analyse l'URL et recherche le nom de fichier. S'il trouve ce fichier, il le renvoie au navigateur, sinon il envoie un message d'erreur indiquant que vous avez demandé un mauvais fichier.
Le navigateur Web prend la réponse du serveur Web et affiche le fichier reçu ou le message d'erreur.

Cependant, il est possible de configurer le serveur HTTP de sorte que chaque fois qu'un fichier dans un certain répertoire est demandé, ce fichier ne soit pas renvoyé; au lieu de cela, il est exécuté en tant que programme, et tout ce que ce programme produit est renvoyé à votre navigateur pour l'afficher. Cette fonction est appelée Common Gateway Interface ou CGI et les programmes sont appelés scripts CGI. Ces programmes CGI peuvent être un script Python, un script PERL, un script Shell, un programme C ou C ++, etc.

Diagramme d'architecture CGI

Prise en charge et configuration du serveur Web

Avant de poursuivre la programmation CGI, assurez-vous que votre serveur Web prend en charge CGI et qu'il est configuré pour gérer les programmes CGI. Tous les programmes CGI à exécuter par le serveur HTTP sont conservés dans un répertoire préconfiguré. Ce répertoire est appelé Répertoire CGI et par convention, il est nommé comme / var / www / cgi-bin. Par convention, les fichiers CGI ont l'extension.cgi, mais vous pouvez conserver vos fichiers avec l'extension python .py ainsi que.

Par défaut, le serveur Linux est configuré pour exécuter uniquement les scripts du répertoire cgi-bin dans / var / www. Si vous souhaitez spécifier un autre répertoire pour exécuter vos scripts CGI, commentez les lignes suivantes dans le fichier httpd.conf -

<Directory "/var/www/cgi-bin">
   AllowOverride None
   Options ExecCGI
   Order allow,deny
   Allow from all
</Directory>

<Directory "/var/www/cgi-bin">
Options All
</Directory>

Ici, nous supposons que Web Server est opérationnel avec succès et que vous êtes capable d'exécuter n'importe quel autre programme CGI comme Perl ou Shell, etc.

Premier programme CGI

Voici un lien simple, qui est lié à un script CGI appelé hello.py . Ce fichier est conservé dans le répertoire / var / www / cgi-bin et a le contenu suivant. Avant d'exécuter votre programme CGI, assurez-vous que vous avez changé le mode de fichier en utilisantchmod 755 hello.py Commande UNIX pour rendre le fichier exécutable.

#!/usr/bin/python

print ("Content-type:text/html\r\n\r\n")
print ('<html>')
print ('<head>')
print ('<title>Hello Word - First CGI Program</title>')
print ('</head>')
print ('<body>')
print ('<h2>Hello Word! This is my first CGI program</h2>')
print ('</body>')
print ('</html>')

Note- La première ligne du script doit être le chemin vers l'exécutable Python. Sous Linux, cela devrait être #! / Usr / bin / python3

Entrez l'URL suivante dans votre navigateur

http://localhost:8080/cgi-bin/hello.py

Bonjour Word! Ceci est mon premier programme CGI

Ce script hello.py est un simple script Python, qui écrit sa sortie sur un fichier STDOUT, c'est-à-dire un écran. Il y a une caractéristique importante et supplémentaire disponible qui est la première ligne à imprimerContent-type:text/html\r\n\r\n. Cette ligne est renvoyée au navigateur et spécifie le type de contenu à afficher sur l'écran du navigateur.

A présent, vous devez avoir compris le concept de base de CGI et vous pouvez écrire de nombreux programmes CGI compliqués en utilisant Python. Ce script peut interagir avec tout autre système externe également pour échanger des informations telles que le SGBDR.

En-tête HTTP

La ligne Content-type:text/html\r\n\r\nfait partie de l'en-tête HTTP qui est envoyé au navigateur pour comprendre le contenu. Tout l'en-tête HTTP sera sous la forme suivante -

HTTP Field Name: Field Content

For Example
Content-type: text/html\r\n\r\n

Il existe quelques autres en-têtes HTTP importants que vous utiliserez fréquemment dans votre programmation CGI.

Sr.No.	En-tête et description
1	Content-type: Une chaîne MIME définissant le format du fichier renvoyé. L'exemple est Content-type: text / html
2	Expires: Date La date à laquelle les informations deviennent invalides. Il est utilisé par le navigateur pour décider du moment où une page doit être actualisée. Une chaîne de date valide est au format 01 janvier 1998 12:00:00 GMT.
3	Location: URL L'URL renvoyée à la place de l'URL demandée. Vous pouvez utiliser ce champ pour rediriger une demande vers n'importe quel fichier.
4	Last-modified: Date La date de la dernière modification de la ressource.
5	Content-length: N La longueur, en octets, des données renvoyées. Le navigateur utilise cette valeur pour rapporter le temps de téléchargement estimé d'un fichier.
6	Set-Cookie: String Définir le cookie passé à travers la chaîne

Variables d'environnement CGI

Tous les programmes CGI ont accès aux variables d'environnement suivantes. Ces variables jouent un rôle important lors de l'écriture de tout programme CGI.

Sr.No.	Nom et description de la variable
1	CONTENT_TYPE Le type de données du contenu. Utilisé lorsque le client envoie du contenu joint au serveur. Par exemple, le téléchargement de fichiers.
2	CONTENT_LENGTH La longueur des informations de requête. Il n'est disponible que pour les demandes POST.
3	HTTP_COOKIE Renvoie les cookies définis sous la forme d'une paire clé / valeur.
4	HTTP_USER_AGENT Le champ d'en-tête de demande User-Agent contient des informations sur l'agent utilisateur à l'origine de la demande. C'est le nom du navigateur Web.
5	PATH_INFO Le chemin du script CGI.
6	QUERY_STRING Informations encodées en URL envoyées avec la demande de méthode GET.
sept	REMOTE_ADDR L'adresse IP de l'hôte distant effectuant la demande. Ceci est utile pour la journalisation ou pour l'authentification.
8	REMOTE_HOST Le nom complet de l'hôte effectuant la demande. Si ces informations ne sont pas disponibles, REMOTE_ADDR peut être utilisé pour obtenir l'adresse IR.
9	REQUEST_METHOD La méthode utilisée pour faire la demande. Les méthodes les plus courantes sont GET et POST.
dix	SCRIPT_FILENAME Le chemin complet du script CGI.
11	SCRIPT_NAME Le nom du script CGI.
12	SERVER_NAME Le nom d'hôte ou l'adresse IP du serveur
13	SERVER_SOFTWARE Le nom et la version du logiciel exécuté par le serveur.

Voici un petit programme CGI pour lister toutes les variables CGI. Cliquez sur ce lien pour voir le résultat Get Environment

#!/usr/bin/python

import os

print ("Content-type: text/html\r\n\r\n");
print ("<font size=+1>Environment</font><\br>");
for param in os.environ.keys():
   print ("<b>%20s</b>: %s<\br>" % (param, os.environ[param]))

Méthodes GET et POST

Vous devez avoir rencontré de nombreuses situations où vous devez transmettre certaines informations de votre navigateur à un serveur Web et finalement à votre programme CGI. Le plus souvent, le navigateur utilise deux méthodes pour transmettre ces informations au serveur Web. Ces méthodes sont la méthode GET et la méthode POST.

Transmission d'informations à l'aide de la méthode GET

La méthode GET envoie les informations utilisateur codées ajoutées à la demande de page. La page et les informations encodées sont séparées par le? caractère comme suit -

http://www.test.com/cgi-bin/hello.py?key1=value1&key2=value2

La méthode GET est la méthode par défaut pour transmettre des informations du navigateur au serveur Web et elle produit une longue chaîne qui apparaît dans la zone Emplacement: de votre navigateur. N'utilisez jamais la méthode GET si vous avez un mot de passe ou d'autres informations sensibles à transmettre au serveur. La méthode GET a une limitation de taille: seuls 1024 caractères peuvent être envoyés dans une chaîne de requête. La méthode GET envoie des informations à l'aide de l'en-tête QUERY_STRING et sera accessible dans votre programme CGI via la variable d'environnement QUERY_STRING.

Vous pouvez transmettre des informations en concaténant simplement des paires clé et valeur avec n'importe quelle URL ou vous pouvez utiliser des balises HTML <FORM> pour transmettre des informations à l'aide de la méthode GET.

Exemple d'URL simple: méthode Get

Voici une URL simple, qui transmet deux valeurs au programme hello_get.py en utilisant la méthode GET.

/cgi-bin/hello_get.py?first_name=ZARA&last_name=ALI

Ci-dessous hello_get.pyscript pour gérer les entrées fournies par le navigateur Web. Nous allons utilisercgi module, ce qui facilite l'accès aux informations transmises -

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
first_name = form.getvalue('first_name')
last_name  = form.getvalue('last_name')

print ("Content-type:text/html\r\n\r\n")
print ("<html>")
print ("<head>")
print ("<title>Hello - Second CGI Program</title>")
print ("</head>")
print ("<body>")
print ("<h2>Hello %s %s</h2>" % (first_name, last_name))
print ("</body>")
print ("</html>")

Cela générerait le résultat suivant -

Bonjour ZARA ALI

Exemple de formulaire simple: méthode GET

Cet exemple transmet deux valeurs à l'aide du formulaire HTML et du bouton d'envoi. Nous utilisons le même script CGI hello_get.py pour gérer cette entrée.

<form action = "/cgi-bin/hello_get.py" method = "get">
First Name: <input type = "text" name = "first_name">  <br />

Last Name: <input type = "text" name = "last_name" />
<input type = "submit" value = "Submit" />
</form>

Voici la sortie réelle du formulaire ci-dessus, vous entrez le prénom et le nom, puis cliquez sur le bouton Soumettre pour voir le résultat.

Transmission d'informations à l'aide de la méthode POST

Une méthode généralement plus fiable pour transmettre des informations à un programme CGI est la méthode POST. Cela regroupe les informations exactement de la même manière que les méthodes GET, mais au lieu de les envoyer sous forme de chaîne de texte après un? dans l'URL, il l'envoie sous forme de message séparé. Ce message entre dans le script CGI sous la forme de l'entrée standard.

Ci-dessous se trouve le même script hello_get.py qui gère GET ainsi que la méthode POST.

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
first_name = form.getvalue('first_name')
last_name  = form.getvalue('last_name')

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Hello - Second CGI Program</title>"
print "</head>"
print "<body>"
print "<h2>Hello %s %s</h2>" % (first_name, last_name)
print "</body>"
print "</html>"

Reprenons le même exemple que ci-dessus qui passe deux valeurs à l'aide du formulaire HTML et du bouton d'envoi. Nous utilisons le même script CGI hello_get.py pour gérer cette entrée.

<form action = "/cgi-bin/hello_get.py" method = "post">
First Name: <input type = "text" name = "first_name"><br />
Last Name: <input type = "text" name = "last_name" />

<input type = "submit" value = "Submit" />
</form>

Voici la sortie réelle du formulaire ci-dessus. Vous entrez le prénom et le nom, puis cliquez sur le bouton Soumettre pour voir le résultat.

Transmission des données de case à cocher au programme CGI

Les cases à cocher sont utilisées lorsque plusieurs options doivent être sélectionnées.

Voici un exemple de code HTML pour un formulaire avec deux cases à cocher -

<form action = "/cgi-bin/checkbox.cgi" method = "POST" target = "_blank">
<input type = "checkbox" name = "maths" value = "on" /> Maths
<input type = "checkbox" name = "physics" value = "on" /> Physics
<input type = "submit" value = "Select Subject" />
</form>

Le résultat de ce code est la forme suivante -

Vous trouverez ci-dessous le script checkbox.cgi pour gérer l'entrée donnée par le navigateur Web pour le bouton de la case à cocher.

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
if form.getvalue('maths'):
   math_flag = "ON"
else:
   math_flag = "OFF"

if form.getvalue('physics'):
   physics_flag = "ON"
else:
   physics_flag = "OFF"

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Checkbox - Third CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> CheckBox Maths is : %s</h2>" % math_flag
print "<h2> CheckBox Physics is : %s</h2>" % physics_flag
print "</body>"
print "</html>"

Transmission des données de bouton radio au programme CGI

Les boutons radio sont utilisés lorsqu'une seule option doit être sélectionnée.

Voici un exemple de code HTML pour un formulaire avec deux boutons radio -

<form action = "/cgi-bin/radiobutton.py" method = "post" target = "_blank">
<input type = "radio" name = "subject" value = "maths" /> Maths
<input type = "radio" name = "subject" value = "physics" /> Physics
<input type = "submit" value = "Select Subject" />
</form>

Le résultat de ce code est la forme suivante -

Ci-dessous se trouve le script radiobutton.py pour gérer l'entrée donnée par le navigateur Web pour le bouton radio -

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
if form.getvalue('subject'):
   subject = form.getvalue('subject')
else:
   subject = "Not set"

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Radio - Fourth CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> Selected Subject is %s</h2>" % subject
print "</body>"
print "</html>"

Transmission de données de zone de texte au programme CGI

L'élément TEXTAREA est utilisé lorsqu'un texte multiligne doit être transmis au programme CGI.

Voici un exemple de code HTML pour un formulaire avec une zone TEXTAREA -

<form action = "/cgi-bin/textarea.py" method = "post" target = "_blank">
<textarea name = "textcontent" cols = "40" rows = "4">
Type your text here...
</textarea>
<input type = "submit" value = "Submit" />
</form>

Le résultat de ce code est la forme suivante -

Vous trouverez ci-dessous le script textarea.cgi pour gérer les entrées fournies par le navigateur Web -

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
if form.getvalue('textcontent'):
   text_content = form.getvalue('textcontent')
else:
   text_content = "Not entered"

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>";
print "<title>Text Area - Fifth CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> Entered Text Content is %s</h2>" % text_content
print "</body>"

Transmission de données de boîte déroulante au programme CGI

La boîte déroulante est utilisée lorsque de nombreuses options sont disponibles, mais qu'une ou deux seulement seront sélectionnées.

Voici un exemple de code HTML pour un formulaire avec une liste déroulante -

<form action = "/cgi-bin/dropdown.py" method = "post" target = "_blank">
<select name = "dropdown">
<option value = "Maths" selected>Maths</option>
<option value = "Physics">Physics</option>
</select>
<input type = "submit" value = "Submit"/>
</form>

Le résultat de ce code est la forme suivante -

Vous trouverez ci-dessous le script dropdown.py pour gérer les entrées fournies par le navigateur Web.

#!/usr/bin/python

# Import modules for CGI handling 
import cgi, cgitb 

# Create instance of FieldStorage 
form = cgi.FieldStorage() 

# Get data from fields
if form.getvalue('dropdown'):
   subject = form.getvalue('dropdown')
else:
   subject = "Not entered"

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Dropdown Box - Sixth CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> Selected Subject is %s</h2>" % subject
print "</body>"
print "</html>"

Utilisation de cookies dans CGI

Le protocole HTTP est un protocole sans état. Pour un site Web commercial, il est nécessaire de conserver les informations de session entre différentes pages. Par exemple, l'enregistrement d'un utilisateur se termine après avoir terminé de nombreuses pages. Comment gérer les informations de session de l'utilisateur sur toutes les pages Web?

Dans de nombreuses situations, l'utilisation de cookies est la méthode la plus efficace pour mémoriser et suivre les préférences, les achats, les commissions et d'autres informations nécessaires pour une meilleure expérience des visiteurs ou des statistiques du site.

Comment ça fonctionne?

Votre serveur envoie certaines données au navigateur du visiteur sous la forme d'un cookie. Le navigateur peut accepter le cookie. Si tel est le cas, il est stocké sous forme d'enregistrement en texte brut sur le disque dur du visiteur. Désormais, lorsque le visiteur arrive sur une autre page de votre site, le cookie est disponible pour la récupération. Une fois récupéré, votre serveur sait / se souvient de ce qui a été stocké.

Les cookies sont un enregistrement de données en texte brut de 5 champs de longueur variable -

Expires- La date d'expiration du cookie. Si ce champ est vide, le cookie expirera lorsque le visiteur quittera le navigateur.
Domain - Le nom de domaine de votre site.
Path- Le chemin d'accès au répertoire ou à la page Web qui définit le cookie. Cela peut être vide si vous souhaitez récupérer le cookie à partir de n'importe quel répertoire ou page.
Secure- Si ce champ contient le mot «sécurisé», alors le cookie ne peut être récupéré qu'avec un serveur sécurisé. Si ce champ est vide, une telle restriction n'existe pas.
Name=Value - Les cookies sont définis et récupérés sous la forme de paires clé et valeur.

Configurer les cookies

Il est très facile d'envoyer des cookies au navigateur. Ces cookies sont envoyés avec l'en-tête HTTP avant dans le champ Type de contenu. En supposant que vous souhaitiez définir l'ID utilisateur et le mot de passe en tant que cookies. La configuration des cookies se fait comme suit -

#!/usr/bin/python
print "Set-Cookie:UserID = XYZ;\r\n"
print "Set-Cookie:Password = XYZ123;\r\n"
print "Set-Cookie:Expires = Tuesday, 31-Dec-2007 23:12:40 GMT;\r\n"
print "Set-Cookie:Domain = www.tutorialspoint.com;\r\n"
print "Set-Cookie:Path = /perl;\n"
print "Content-type:text/html\r\n\r\n"
...........Rest of the HTML Content....

A partir de cet exemple, vous devez avoir compris comment configurer les cookies. Nous utilisonsSet-Cookie En-tête HTTP pour définir les cookies.

Il est facultatif de définir des attributs de cookies tels que Expire, Domain et Path. Il est à noter que les cookies sont définis avant l'envoi de la ligne magique"Content-type:text/html\r\n\r\n.

Récupération des cookies

Il est très facile de récupérer tous les cookies définis. Les cookies sont stockés dans la variable d'environnement CGI HTTP_COOKIE et ils auront la forme suivante -

key1 = value1;key2 = value2;key3 = value3....

Voici un exemple de récupération des cookies.

#!/usr/bin/python

# Import modules for CGI handling 
from os import environ
import cgi, cgitb

if environ.has_key('HTTP_COOKIE'):
   for cookie in map(strip, split(environ['HTTP_COOKIE'], ';')):
      (key, value ) = split(cookie, '=');
      if key == "UserID":
         user_id = value

      if key == "Password":
         password = value

print "User ID  = %s" % user_id
print "Password = %s" % password

Cela produit le résultat suivant pour les cookies définis par le script ci-dessus -

User ID = XYZ
Password = XYZ123

Exemple de téléchargement de fichier

Pour télécharger un fichier, le formulaire HTML doit avoir l'attribut enctype défini sur multipart/form-data. La balise d'entrée avec le type de fichier crée un bouton "Parcourir".

<html>
<body>
   <form enctype = "multipart/form-data" 
                     action = "save_file.py" method = "post">
   <p>File: <input type = "file" name = "filename" /></p>
   <p><input type = "submit" value = "Upload" /></p>
   </form>
</body>
</html>

Le résultat de ce code est la forme suivante -

L'exemple ci-dessus a été désactivé intentionnellement pour enregistrer les personnes téléchargeant le fichier sur notre serveur, mais vous pouvez essayer le code ci-dessus avec votre serveur.

Voici le script save_file.py pour gérer le téléchargement de fichiers -

#!/usr/bin/python

import cgi, os
import cgitb; cgitb.enable()

form = cgi.FieldStorage()

# Get filename here.
fileitem = form['filename']

# Test if the file was uploaded
if fileitem.filename:
   # strip leading path from file name to avoid 
   # directory traversal attacks
   fn = os.path.basename(fileitem.filename)
   open('/tmp/' + fn, 'wb').write(fileitem.file.read())

   message = 'The file "' + fn + '" was uploaded successfully'
   
else:
   message = 'No file was uploaded'
   
print """\
Content-Type: text/html\n
<html>
<body>
   <p>%s</p>
</body>
</html>
""" % (message,)

Si vous exécutez le script ci-dessus sous Unix / Linux, vous devez prendre soin de remplacer le séparateur de fichiers comme suit, sinon sur votre machine Windows, l'instruction open () devrait fonctionner correctement.

fn = os.path.basename(fileitem.filename.replace("\\", "/" ))

Comment ouvrir une boîte de dialogue "Téléchargement de fichier"?

Parfois, il est souhaitable que vous souhaitiez donner une option où un utilisateur peut cliquer sur un lien et une boîte de dialogue "Téléchargement de fichier" apparaîtra à l'utilisateur au lieu d'afficher le contenu réel. Ceci est très simple et peut être réalisé via l'en-tête HTTP. Cet en-tête HTTP est différent de l'en-tête mentionné dans la section précédente.

Par exemple, si vous voulez créer un FileName fichier téléchargeable à partir d'un lien donné, sa syntaxe est la suivante -

#!/usr/bin/python

# HTTP Header
print "Content-Type:application/octet-stream; name = \"FileName\"\r\n";
print "Content-Disposition: attachment; filename = \"FileName\"\r\n\n";

# Actual File Content will go here.
fo = open("foo.txt", "rb")

str = fo.read();
print str

# Close opend file
fo.close()

Nous espérons que vous avez apprécié ce tutoriel. Si oui, envoyez-moi vos commentaires à: Contactez-nous

La norme Python pour les interfaces de base de données est l'API DB Python. La plupart des interfaces de base de données Python adhèrent à cette norme.

Vous pouvez choisir la bonne base de données pour votre application. L'API de base de données Python prend en charge un large éventail de serveurs de base de données tels que -

GadFly
mSQL
MySQL
PostgreSQL
Microsoft SQL Server 2000
Informix
Interbase
Oracle
Sybase
SQLite

Voici la liste des interfaces de base de données Python disponibles - Interfaces de base de données Python et API . Vous devez télécharger un module DB API distinct pour chaque base de données à laquelle vous devez accéder. Par exemple, si vous avez besoin d'accéder à une base de données Oracle ainsi qu'à une base de données MySQL, vous devez télécharger les modules de base de données Oracle et MySQL.

L'API DB fournit une norme minimale pour travailler avec des bases de données utilisant les structures et la syntaxe Python dans la mesure du possible. Cette API comprend les éléments suivants -

Importation du module API.
Acquérir une connexion avec la base de données.
Émettre des instructions SQL et des procédures stockées.
Fermer la connexion

Python a une prise en charge intégrée de SQLite. Dans cette section, nous apprendrons tous les concepts en utilisant MySQL. Le module MySQLdb, une interface populaire avec MySQL n'est pas compatible avec Python 3. À la place, nous utiliserons le module PyMySQL .

Qu'est-ce que PyMySQL?

PyMySQL est une interface pour se connecter à un serveur de base de données MySQL à partir de Python. Il implémente l'API de base de données Python v2.0 et contient une bibliothèque cliente MySQL pure Python. Le but de PyMySQL est de remplacer MySQLdb.

Comment installer PyMySQL?

Avant de continuer, assurez-vous que PyMySQL est installé sur votre machine. Tapez simplement ce qui suit dans votre script Python et exécutez-le -

#!/usr/bin/python3

import pymysql

Si cela produit le résultat suivant, cela signifie que le module MySQLdb n'est pas installé -

Traceback (most recent call last):
   File "test.py", line 3, in <module>
      Import pymysql
ImportError: No module named pymysql

La dernière version stable est disponible sur PyPI et peut être installée avec pip -

pip install pymysql

Alternativement (par exemple, si pip n'est pas disponible), une archive tar peut être téléchargée depuis GitHub et installée avec Setuptools comme suit -

$ # X.X is the desired pymysql version (e.g. 0.5 or 0.6).
$ curl -L https://github.com/PyMySQL/PyMySQL/tarball/pymysql-X.X | tar xz $ cd PyMySQL*
$ python setup.py install $ # The folder PyMySQL* can be safely removed now.

Note - Assurez-vous que vous disposez des privilèges root pour installer le module ci-dessus.

Connexion à la base de données

Avant de vous connecter à une base de données MySQL, assurez-vous des points suivants -

Vous avez créé une base de données TESTDB.
Vous avez créé une table EMPLOYEE dans TESTDB.
Cette table contient les champs FIRST_NAME, LAST_NAME, AGE, SEX et INCOME.
L'ID utilisateur "testuser" et le mot de passe "test123" sont définis pour accéder à TESTDB.
Le module Python PyMySQL est correctement installé sur votre machine.
Vous avez parcouru le didacticiel MySQL pour comprendre les bases de MySQL.

Exemple

Voici un exemple de connexion à la base de données MySQL "TESTDB" -

#!/usr/bin/python3

import pymysql

# Open database connection
db = pymysql.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# execute SQL query using execute() method.
cursor.execute("SELECT VERSION()")

# Fetch a single row using fetchone() method.
data = cursor.fetchone()
print ("Database version : %s " % data)

# disconnect from server
db.close()

Lors de l'exécution de ce script, il produit le résultat suivant.

Database version : 5.5.20-log

Si une connexion est établie avec la source de données, un objet de connexion est renvoyé et enregistré dans db pour une utilisation ultérieure, sinon dbest défini sur Aucun. Prochain,db objet est utilisé pour créer un cursorobjet, qui à son tour est utilisé pour exécuter des requêtes SQL. Enfin, avant de sortir, il s'assure que la connexion à la base de données est fermée et que les ressources sont libérées.

Création d'une table de base de données

Une fois la connexion à la base de données établie, nous sommes prêts à créer des tables ou des enregistrements dans les tables de la base de données en utilisant execute méthode du curseur créé.

Exemple

Créons une table de base de données EMPLOYÉ -

#!/usr/bin/python3

import pymysql

# Open database connection
db = pymysql.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Drop table if it already exist using execute() method.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

# Create table as per requirement
sql = """CREATE TABLE EMPLOYEE (
   FIRST_NAME  CHAR(20) NOT NULL,
   LAST_NAME  CHAR(20),
   AGE INT,  
   SEX CHAR(1),
   INCOME FLOAT )"""

cursor.execute(sql)

# disconnect from server
db.close()

Opération INSERT

L'opération INSERT est requise lorsque vous souhaitez créer vos enregistrements dans une table de base de données.

Exemple

L'exemple suivant exécute l'instruction SQL INSERT pour créer un enregistrement dans la table EMPLOYEE -

#!/usr/bin/python3

import pymysql

# Open database connection
db = pymysql.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to INSERT a record into the database.
sql = """INSERT INTO EMPLOYEE(FIRST_NAME,
   LAST_NAME, AGE, SEX, INCOME)
   VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

L'exemple ci-dessus peut être écrit comme suit pour créer des requêtes SQL de manière dynamique -

#!/usr/bin/python3

import pymysql

# Open database connection
db = pymysql.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to INSERT a record into the database.
sql = "INSERT INTO EMPLOYEE(FIRST_NAME, \
   LAST_NAME, AGE, SEX, INCOME) \
   VALUES ('%s', '%s', '%d', '%c', '%d' )" % \
   ('Mac', 'Mohan', 20, 'M', 2000)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

Exemple

Le segment de code suivant est une autre forme d'exécution où vous pouvez passer des paramètres directement -

..................................
user_id = "test123"
password = "password"

con.execute('insert into Login values("%s", "%s")' % \
             (user_id, password))
..................................

LIRE l'opération

LIRE L'opération sur n'importe quelle base de données signifie récupérer des informations utiles dans la base de données.

Une fois la connexion à la base de données établie, vous êtes prêt à effectuer une requête dans cette base de données. Vous pouvez utiliser soitfetchone() méthode pour récupérer un seul enregistrement ou fetchall() méthode pour récupérer plusieurs valeurs à partir d'une table de base de données.

fetchone()- Il récupère la ligne suivante d'un jeu de résultats de requête. Un jeu de résultats est un objet renvoyé lorsqu'un objet curseur est utilisé pour interroger une table.
fetchall()- Il récupère toutes les lignes d'un jeu de résultats. Si certaines lignes ont déjà été extraites de l'ensemble de résultats, il récupère les lignes restantes de l'ensemble de résultats.
rowcount - Il s'agit d'un attribut en lecture seule et renvoie le nombre de lignes affectées par une méthode execute ().

Exemple

La procédure suivante interroge tous les enregistrements de la table EMPLOYEE ayant un salaire supérieur à 1000 -

#!/usr/bin/python3

import pymysql

# Open database connection
db = pymysql.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to INSERT a record into the database.
sql = "SELECT * FROM EMPLOYEE \
      WHERE INCOME > '%d'" % (1000)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Fetch all the rows in a list of lists.
   results = cursor.fetchall()
   for row in results:
      fname = row[0]
      lname = row[1]
      age = row[2]
      sex = row[3]
      income = row[4]
      # Now print fetched result
      print ("fname = %s,lname = %s,age = %d,sex = %s,income = %d" % \
         (fname, lname, age, sex, income ))
except:
   print ("Error: unable to fetch data")

# disconnect from server
db.close()

Production

Cela produira le résultat suivant -

fname = Mac, lname = Mohan, age = 20, sex = M, income = 2000

Opération de mise à jour

UPDATE L'opération sur n'importe quelle base de données signifie mettre à jour un ou plusieurs enregistrements, qui sont déjà disponibles dans la base de données.

La procédure suivante met à jour tous les enregistrements ayant SEX comme 'M'. Ici, nous augmentons l'âge de tous les hommes d'un an.

Exemple

#!/usr/bin/python3

import pymysql

# Open database connection
db = pymysql.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to UPDATE required records
sql = "UPDATE EMPLOYEE SET AGE = AGE + 1
                          WHERE SEX = '%c'" % ('M')
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

Effacer l'opération

L'opération DELETE est requise lorsque vous souhaitez supprimer certains enregistrements de votre base de données. Voici la procédure pour supprimer tous les enregistrements de EMPLOYÉ où AGE est plus de 20 -

Exemple

#!/usr/bin/python3

import pymysql

# Open database connection
db = pymysql.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to DELETE required records
sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (20)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

Effectuer des transactions

Les transactions sont un mécanisme qui garantit la cohérence des données. Les transactions ont les quatre propriétés suivantes -

Atomicity - Soit une transaction se termine, soit rien ne se passe du tout.
Consistency - Une transaction doit démarrer dans un état cohérent et laisser le système dans un état cohérent.
Isolation - Les résultats intermédiaires d'une transaction ne sont pas visibles en dehors de la transaction en cours.
Durability - Une fois qu'une transaction a été validée, les effets sont persistants, même après une panne du système.

L'API Python DB 2.0 fournit deux méthodes pour valider ou annuler une transaction.

Exemple

Vous savez déjà comment mettre en œuvre des transactions. Voici un exemple similaire -

# Prepare SQL query to DELETE required records
sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (20)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

Opération COMMIT

Valider est une opération qui donne un signal vert à la base de données pour finaliser les modifications, et après cette opération, aucune modification ne peut être annulée.

Voici un exemple simple pour appeler le commit méthode.

db.commit()

Fonctionnement ROLLBACK

Si vous n'êtes pas satisfait d'une ou de plusieurs modifications et que vous souhaitez annuler complètement ces modifications, utilisez le rollback() méthode.

Voici un exemple simple pour appeler le rollback() méthode.

db.rollback()

Déconnexion de la base de données

Pour déconnecter la connexion à la base de données, utilisez la méthode close ().

db.close()

Si la connexion à une base de données est fermée par l'utilisateur avec la méthode close (), toutes les transactions en cours sont annulées par la base de données. Cependant, au lieu de dépendre de l'un des détails d'implémentation de niveau inférieur de la base de données, votre application ferait mieux d'appeler explicitement commit ou rollback.

Traitement des erreurs

Il existe de nombreuses sources d'erreurs. Quelques exemples sont une erreur de syntaxe dans une instruction SQL exécutée, un échec de connexion ou l'appel de la méthode fetch pour un descripteur d'instruction déjà annulé ou terminé.

L'API DB définit un certain nombre d'erreurs qui doivent exister dans chaque module de base de données. Le tableau suivant répertorie ces exceptions.

Sr.No.	Exception et description
1	Warning Utilisé pour les problèmes non fatals. Doit sous-classe StandardError.
2	Error Classe de base pour les erreurs. Doit sous-classe StandardError.
3	InterfaceError Utilisé pour les erreurs dans le module de base de données, pas dans la base de données elle-même. Doit sous-classe Error.
4	DatabaseError Utilisé pour les erreurs dans la base de données. Doit sous-classe Error.
5	DataError Sous-classe de DatabaseError qui fait référence à des erreurs dans les données.
6	OperationalError Sous-classe de DatabaseError qui fait référence à des erreurs telles que la perte d'une connexion à la base de données. Ces erreurs sont généralement hors du contrôle du scripteur Python.
sept	IntegrityError Sous-classe de DatabaseError pour les situations qui endommageraient l'intégrité relationnelle, telles que les contraintes d'unicité ou les clés étrangères.
8	InternalError Sous-classe de DatabaseError qui fait référence à des erreurs internes au module de base de données, comme un curseur qui n'est plus actif.
9	ProgrammingError Sous-classe de DatabaseError qui fait référence à des erreurs telles qu'un nom de table incorrect et d'autres choses qui peuvent vous être imputées en toute sécurité.
dix	NotSupportedError Sous-classe de DatabaseError qui fait référence à la tentative d'appeler une fonctionnalité non prise en charge.

Vos scripts Python doivent gérer ces erreurs, mais avant d'utiliser l'une des exceptions ci-dessus, assurez-vous que votre MySQLdb prend en charge cette exception. Vous pouvez obtenir plus d'informations à leur sujet en lisant la spécification DB API 2.0.

Python fournit deux niveaux d'accès aux services réseau. À un niveau bas, vous pouvez accéder à la prise en charge de socket de base dans le système d'exploitation sous-jacent, qui vous permet d'implémenter des clients et des serveurs pour les protocoles orientés connexion et sans connexion.

Python dispose également de bibliothèques qui fournissent un accès de niveau supérieur à des protocoles réseau spécifiques au niveau de l'application, tels que FTP, HTTP, etc.

Ce chapitre vous donne une compréhension du concept le plus connu de la mise en réseau - la programmation de socket.

Qu'est-ce que Sockets?

Les sockets sont les extrémités d'un canal de communication bidirectionnel. Les sockets peuvent communiquer au sein d'un processus, entre des processus sur la même machine ou entre des processus sur différents continents.

Les sockets peuvent être implémentés sur un certain nombre de types de canaux différents: sockets de domaine Unix, TCP, UDP, etc. La bibliothèque de sockets fournit des classes spécifiques pour gérer les transports courants ainsi qu'une interface générique pour gérer le reste.

Les sockets ont leur propre vocabulaire -

Sr.No.	Terme et description
1	domain Famille de protocoles utilisée comme mécanisme de transport. Ces valeurs sont des constantes telles que AF_INET, PF_INET, PF_UNIX, PF_X25, etc.
2	type Type de communication entre les deux points de terminaison, généralement SOCK_STREAM pour les protocoles orientés connexion et SOCK_DGRAM pour les protocoles sans connexion.
3	protocol Typiquement zéro, cela peut être utilisé pour identifier une variante d'un protocole dans un domaine et un type.
4	hostname L'identifiant d'une interface réseau - Une chaîne, qui peut être un nom d'hôte, une adresse à quatre points ou une adresse IPV6 en notation deux-points (et éventuellement un point) Une chaîne "<broadcast>", qui spécifie une adresse INADDR_BROADCAST. Une chaîne de longueur nulle, qui spécifie INADDR_ANY, ou Un entier, interprété comme une adresse binaire dans l'ordre des octets de l'hôte.
5	port Chaque serveur écoute les clients appelant sur un ou plusieurs ports. Un port peut être un numéro de port Fixnum, une chaîne contenant un numéro de port ou le nom d'un service.

Le module de prise

Pour créer une socket, vous devez utiliser la fonction socket.socket () disponible dans le module socket, qui a la syntaxe générale -

s = socket.socket (socket_family, socket_type, protocol = 0)

Voici la description des paramètres -

socket_family - Il s'agit soit d'AF_UNIX, soit d'AF_INET, comme expliqué précédemment.
socket_type - Il s'agit soit de SOCK_STREAM, soit de SOCK_DGRAM.
protocol - Ceci est généralement laissé de côté, par défaut à 0.

Une fois que vous avez un objet socket , vous pouvez utiliser les fonctions requises pour créer votre programme client ou serveur. Voici la liste des fonctions requises -

Méthodes de socket serveur

Sr.No.	Méthode et description
1	s.bind() Cette méthode lie l'adresse (nom d'hôte, paire de numéros de port) au socket.
2	s.listen() Cette méthode configure et démarre l'écouteur TCP.
3	s.accept() Cela accepte passivement la connexion client TCP, en attendant que la connexion arrive (blocage).

Méthodes de socket client

Sr.No.	Méthode et description
1	s.connect() Cette méthode initie activement la connexion au serveur TCP.

Méthodes générales de socket

Sr.No.	Méthode et description
1	s.recv() Cette méthode reçoit un message TCP
2	s.send() Cette méthode transmet le message TCP
3	s.recvfrom() Cette méthode reçoit un message UDP
4	s.sendto() Cette méthode transmet un message UDP
5	s.close() Cette méthode ferme le socket
6	socket.gethostname() Renvoie le nom d'hôte.

Un serveur simple

Pour écrire des serveurs Internet, nous utilisons le socketfonction disponible dans le module socket pour créer un objet socket. Un objet socket est ensuite utilisé pour appeler d'autres fonctions afin de configurer un serveur socket.

Maintenant, appelez le bind(hostname, port)pour spécifier un port pour votre service sur l'hôte donné.

Ensuite, appelez la méthode accept de l'objet retourné. Cette méthode attend jusqu'à ce qu'un client se connecte au port que vous avez spécifié, puis renvoie un objet de connexion qui représente la connexion à ce client.

#!/usr/bin/python3           # This is server.py file
import socket                                         

# create a socket object
serversocket = socket.socket(
	        socket.AF_INET, socket.SOCK_STREAM) 

# get local machine name
host = socket.gethostname()                           

port = 9999                                           

# bind to the port
serversocket.bind((host, port))                                  

# queue up to 5 requests
serversocket.listen(5)                                           

while True:
   # establish a connection
   clientsocket,addr = serversocket.accept()      

   print("Got a connection from %s" % str(addr))
    
   msg = 'Thank you for connecting'+ "\r\n"
   clientsocket.send(msg.encode('ascii'))
   clientsocket.close()

Un client simple

Écrivons un programme client très simple qui ouvre une connexion à un port donné 12345 et à un hôte donné. Il est très simple de créer un client socket en utilisant la fonction de module socket de Python .

le socket.connect(hosname, port )ouvre une connexion TCP au nom d' hôte sur le port . Une fois que vous avez une socket ouverte, vous pouvez la lire comme n'importe quel objet IO. Une fois terminé, n'oubliez pas de le fermer, comme vous le feriez pour un fichier.

Exemple

Le code suivant est un client très simple qui se connecte à un hôte et un port donnés, lit toutes les données disponibles à partir du socket, puis quitte -

#!/usr/bin/python3           # This is client.py file

import socket

# create a socket object
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 

# get local machine name
host = socket.gethostname()                           

port = 9999

# connection to hostname on the port.
s.connect((host, port))                               

# Receive no more than 1024 bytes
msg = s.recv(1024)                                     

s.close()
print (msg.decode('ascii'))

Maintenant, exécutez ce server.py en arrière-plan, puis exécutez le client.py ci-dessus pour voir le résultat.

# Following would start a server in background.
$ python server.py & # Once server is started run client as follows: $ python client.py

Production

Cela produirait le résultat suivant -

on server terminal
Got a connection from ('192.168.1.10', 3747)
On client terminal
Thank you for connecting

Modules Internet Python

Une liste de quelques modules importants de la programmation Python Network / Internet est donnée ci-dessous -

Protocole	Fonction commune	Numéro de port	Module Python
HTTP	les pages Web	80	httplib, urllib, xmlrpclib
NNTP	Actualités Usenet	119	nntplib
FTP	Transferts de fichiers	20	ftplib, urllib
SMTP	Envoi d'un e-mail	25	smtplib
POP3	Récupération de l'e-mail	110	poplib
IMAP4	Récupération de l'e-mail	143	imaplib
Telnet	Lignes de commande	23	telnetlib
Gopher	Transferts de documents	70	gopherlib, urllib

Veuillez vérifier que toutes les bibliothèques mentionnées ci-dessus fonctionnent avec les protocoles FTP, SMTP, POP et IMAP.

Lectures supplémentaires

C'était un démarrage rapide avec la programmation de socket. C'est un vaste sujet. Il est recommandé de passer par le lien suivant pour trouver plus de détails -

Programmation de socket Unix .
Bibliothèque et modules de socket Python .

Le protocole SMTP (Simple Mail Transfer Protocol) est un protocole qui gère l'envoi d'un e-mail et le routage des e-mails entre les serveurs de messagerie.

Python fournit smtplib module, qui définit un objet de session client SMTP qui peut être utilisé pour envoyer des e-mails à n'importe quelle machine Internet avec un démon d'écoute SMTP ou ESMTP.

Voici une syntaxe simple pour créer un objet SMTP, qui pourra ensuite être utilisé pour envoyer un e-mail -

import smtplib

smtpObj = smtplib.SMTP( [host [, port [, local_hostname]]] )

Voici le détail des paramètres -

host- Il s'agit de l'hôte exécutant votre serveur SMTP. Vous pouvez spécifier l'adresse IP de l'hôte ou un nom de domaine comme tutorialspoint.com. Ceci est un argument facultatif.
port- Si vous fournissez un argument hôte , vous devez spécifier un port sur lequel le serveur SMTP écoute. Habituellement, ce port serait 25.
local_hostname- Si votre serveur SMTP s'exécute sur votre machine locale, vous pouvez spécifier uniquement localhost l'option.

Un objet SMTP a une méthode d'instance appelée sendmail, qui est généralement utilisé pour effectuer le travail d'envoi d'un message. Il faut trois paramètres -

L' expéditeur - Une chaîne avec l'adresse de l'expéditeur.
Les destinataires - Une liste de chaînes, une pour chaque destinataire.
Le message - Un message sous forme de chaîne formatée comme spécifié dans les diverses RFC.

Exemple

Voici un moyen simple d'envoyer un e-mail à l'aide d'un script Python. Essayez-le une fois -

#!/usr/bin/python3

import smtplib

sender = '[email protected]'
receivers = ['[email protected]']

message = """From: From Person <[email protected]>
To: To Person <[email protected]>
Subject: SMTP e-mail test

This is a test e-mail message.
"""

try:
   smtpObj = smtplib.SMTP('localhost')
   smtpObj.sendmail(sender, receivers, message)         
   print "Successfully sent email"
except SMTPException:
   print "Error: unable to send email"

Ici, vous avez placé un e-mail de base dans un message, en utilisant un triple guillemet, en prenant soin de formater correctement les en-têtes. Un e-mail nécessite unFrom, To, et un Subject en-tête, séparé du corps de l'e-mail par une ligne vide.

Pour envoyer le courrier, utilisez smtpObj pour vous connecter au serveur SMTP sur la machine locale. Ensuite, utilisez la méthode sendmail avec le message, l'adresse d'expédition et l'adresse de destination comme paramètres (même si les adresses de départ et d'arrivée se trouvent dans l'e-mail lui-même, elles ne sont pas toujours utilisées pour acheminer le courrier).

Si vous n'exécutez pas de serveur SMTP sur votre machine locale, vous pouvez utiliser le client smtplib pour communiquer avec un serveur SMTP distant. Sauf si vous utilisez un service de messagerie Web (tel que gmail ou Yahoo! Mail), votre fournisseur de messagerie doit vous avoir fourni les détails du serveur de messagerie sortant que vous pouvez leur fournir, comme suit:

mail = smtplib.SMTP('smtp.gmail.com', 587)

Envoi d'un e-mail HTML à l'aide de Python

Lorsque vous envoyez un message texte en utilisant Python, tout le contenu est traité comme un simple texte. Même si vous incluez des balises HTML dans un message texte, celui-ci s'affiche sous forme de texte simple et les balises HTML ne seront pas formatées selon la syntaxe HTML. Cependant, Python fournit une option pour envoyer un message HTML en tant que message HTML réel.

Lors de l'envoi d'un e-mail, vous pouvez spécifier une version Mime, un type de contenu et le jeu de caractères pour envoyer un e-mail HTML.

Exemple

Voici un exemple pour envoyer le contenu HTML sous forme de courrier électronique. Essayez-le une fois -

#!/usr/bin/python3

import smtplib

message = """From: From Person <[email protected]>
To: To Person <[email protected]>
MIME-Version: 1.0
Content-type: text/html
Subject: SMTP HTML e-mail test

This is an e-mail message to be sent in HTML format

<b>This is HTML message.</b>
<h1>This is headline.</h1>
"""

try:
   smtpObj = smtplib.SMTP('localhost')
   smtpObj.sendmail(sender, receivers, message)         
   print "Successfully sent email"
except SMTPException:
   print "Error: unable to send email"

Envoi de pièces jointes par e-mail

Pour envoyer un e-mail avec un contenu mixte, vous devez définir le Content-type en-tête à multipart/mixed. Ensuite, le texte et les sections de pièce jointe peuvent être spécifiés dansboundaries.

Une limite est commencée par deux traits d'union suivis d'un numéro unique, qui ne peut pas apparaître dans la partie message de l'e-mail. Une limite finale indiquant la section finale de l'e-mail doit également se terminer par deux tirets.

Les fichiers joints doivent être encodés avec le pack("m") fonction d'avoir un encodage en base 64 avant la transmission.

Exemple

Voici un exemple, qui envoie un fichier /tmp/test.txten pièce jointe. Essayez-le une fois -

#!/usr/bin/python3

import smtplib
import base64

filename = "/tmp/test.txt"

# Read a file and encode it into base64 format
fo = open(filename, "rb")
filecontent = fo.read()
encodedcontent = base64.b64encode(filecontent)  # base64

sender = '[email protected]'
reciever = '[email protected]'

marker = "AUNIQUEMARKER"

body ="""
This is a test email to send an attachement.
"""
# Define the main headers.
part1 = """From: From Person <[email protected]>
To: To Person <[email protected]>
Subject: Sending Attachement
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary=%s
--%s
""" % (marker, marker)

# Define the message action
part2 = """Content-Type: text/plain
Content-Transfer-Encoding:8bit

%s
--%s
""" % (body,marker)

# Define the attachment section
part3 = """Content-Type: multipart/mixed; name=\"%s\"
Content-Transfer-Encoding:base64
Content-Disposition: attachment; filename=%s

%s
--%s--
""" %(filename, filename, encodedcontent, marker)
message = part1 + part2 + part3

try:
   smtpObj = smtplib.SMTP('localhost')
   smtpObj.sendmail(sender, reciever, message)
   print "Successfully sent email"
except Exception:
   print ("Error: unable to send email")

L'exécution de plusieurs threads est similaire à l'exécution simultanée de plusieurs programmes différents, mais avec les avantages suivants:

Plusieurs threads au sein d'un processus partagent le même espace de données avec le thread principal et peuvent donc partager des informations ou communiquer entre eux plus facilement que s'il s'agissait de processus séparés.
Les threads sont parfois appelés processus légers et ne nécessitent pas beaucoup de mémoire supplémentaire; ils sont moins chers que les procédés.

Un thread a un début, une séquence d'exécution et une conclusion. Il a un pointeur d'instruction qui garde une trace de où dans son contexte est-il en cours d'exécution.

Il peut être préempté (interrompu).
Il peut être temporairement mis en attente (également connu sous le nom de veille) pendant que d'autres threads sont en cours d'exécution - c'est ce qu'on appelle le rendement.

Il existe deux types de threads différents -

fil du noyau
fil utilisateur

Les threads du noyau font partie du système d'exploitation, tandis que les threads de l'espace utilisateur ne sont pas implémentés dans le noyau.

Il existe deux modules qui prennent en charge l'utilisation des threads dans Python3 -

_thread
threading

Le module de thread est «obsolète» depuis assez longtemps. Les utilisateurs sont encouragés à utiliser le module de thread à la place. Par conséquent, dans Python 3, le module "thread" n'est plus disponible. Cependant, il a été renommé en "_thread" pour des compatibilités vers l'arrière dans Python3.

Démarrer un nouveau fil

Pour générer un autre thread, vous devez appeler la méthode suivante disponible dans le module thread -

_thread.start_new_thread ( function, args[, kwargs] )

Cet appel de méthode permet un moyen rapide et efficace de créer de nouveaux threads sous Linux et Windows.

L'appel de méthode retourne immédiatement et le thread enfant démarre et appelle la fonction avec la liste d' arguments passée . Lorsque la fonction retourne, le thread se termine.

Ici, args est un tuple d'arguments; utilisez un tuple vide pour appeler la fonction sans passer d'arguments. kwargs est un dictionnaire facultatif d'arguments de mots clés.

Exemple

#!/usr/bin/python3

import _thread
import time

# Define a function for the thread
def print_time( threadName, delay):
   count = 0
   while count < 5:
      time.sleep(delay)
      count += 1
      print ("%s: %s" % ( threadName, time.ctime(time.time()) ))

# Create two threads as follows
try:
   _thread.start_new_thread( print_time, ("Thread-1", 2, ) )
   _thread.start_new_thread( print_time, ("Thread-2", 4, ) )
except:
   print ("Error: unable to start thread")

while 1:
   pass

Production

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

Thread-1: Fri Feb 19 09:41:39 2016
Thread-2: Fri Feb 19 09:41:41 2016
Thread-1: Fri Feb 19 09:41:41 2016
Thread-1: Fri Feb 19 09:41:43 2016
Thread-2: Fri Feb 19 09:41:45 2016
Thread-1: Fri Feb 19 09:41:45 2016
Thread-1: Fri Feb 19 09:41:47 2016
Thread-2: Fri Feb 19 09:41:49 2016
Thread-2: Fri Feb 19 09:41:53 2016

Le programme se déroule dans une boucle infinie. Vous devrez appuyer sur ctrl-c pour arrêter

Bien qu'il soit très efficace pour le threading de bas niveau, le module thread est très limité par rapport au module threading plus récent.

Le module de filetage

Le nouveau module de threading inclus avec Python 2.4 fournit une prise en charge beaucoup plus puissante et de haut niveau pour les threads que le module de thread abordé dans la section précédente.

Le module de threading expose toutes les méthodes du module de thread et fournit des méthodes supplémentaires -

threading.activeCount() - Renvoie le nombre d'objets thread qui sont actifs.
threading.currentThread() - Renvoie le nombre d'objets thread dans le contrôle thread de l'appelant.
threading.enumerate() - Renvoie une liste de tous les objets thread actuellement actifs.

En plus des méthodes, le module de threading a la classe Thread qui implémente le threading. Les méthodes fournies par la classe Thread sont les suivantes -

run() - La méthode run () est le point d'entrée d'un thread.
start() - La méthode start () démarre un thread en appelant la méthode run.
join([time]) - Le join () attend la fin des threads.
isAlive() - La méthode isAlive () vérifie si un thread est toujours en cours d'exécution.
getName() - La méthode getName () renvoie le nom d'un thread.
setName() - La méthode setName () définit le nom d'un thread.

Création d'un fil à l'aide du module de filetage

Pour implémenter un nouveau thread à l'aide du module de threading, vous devez faire ce qui suit -

Définissez une nouvelle sous-classe de la classe Thread .
Remplacez la méthode __init __ (self [, args]) pour ajouter des arguments supplémentaires.
Ensuite, remplacez la méthode run (self [, args]) pour implémenter ce que le thread doit faire au démarrage.

Une fois que vous avez créé la nouvelle sous-classe Thread , vous pouvez en créer une instance, puis démarrer un nouveau thread en appelant la méthode start () , qui à son tour appelle la méthode run () .

Exemple

#!/usr/bin/python3

import threading
import time

exitFlag = 0

class myThread (threading.Thread):
   def __init__(self, threadID, name, counter):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.counter = counter
   def run(self):
      print ("Starting " + self.name)
      print_time(self.name, self.counter, 5)
      print ("Exiting " + self.name)

def print_time(threadName, delay, counter):
   while counter:
      if exitFlag:
         threadName.exit()
      time.sleep(delay)
      print ("%s: %s" % (threadName, time.ctime(time.time())))
      counter -= 1

# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# Start new Threads
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print ("Exiting Main Thread")

Résultat

Lorsque nous exécutons le programme ci-dessus, il produit le résultat suivant -

Starting Thread-1
Starting Thread-2
Thread-1: Fri Feb 19 10:00:21 2016
Thread-2: Fri Feb 19 10:00:22 2016
Thread-1: Fri Feb 19 10:00:22 2016
Thread-1: Fri Feb 19 10:00:23 2016
Thread-2: Fri Feb 19 10:00:24 2016
Thread-1: Fri Feb 19 10:00:24 2016
Thread-1: Fri Feb 19 10:00:25 2016
Exiting Thread-1
Thread-2: Fri Feb 19 10:00:26 2016
Thread-2: Fri Feb 19 10:00:28 2016
Thread-2: Fri Feb 19 10:00:30 2016
Exiting Thread-2
Exiting Main Thread

Synchronisation des threads

Le module de threading fourni avec Python comprend un mécanisme de verrouillage simple à implémenter qui vous permet de synchroniser les threads. Un nouveau verrou est créé en appelant la méthode Lock () , qui renvoie le nouveau verrou.

La méthode d' acquisition (blocage) du nouvel objet de verrouillage est utilisée pour forcer les threads à s'exécuter de manière synchrone. Le paramètre de blocage facultatif vous permet de contrôler si le thread attend pour acquérir le verrou.

Si le blocage est défini sur 0, le thread retourne immédiatement avec une valeur 0 si le verrou ne peut pas être acquis et avec un 1 si le verrou a été acquis. Si le blocage est défini sur 1, le thread se bloque et attend que le verrou soit libéré.

La méthode release () du nouvel objet de verrouillage est utilisée pour libérer le verrou lorsqu'il n'est plus nécessaire.

Exemple

#!/usr/bin/python3

import threading
import time

class myThread (threading.Thread):
   def __init__(self, threadID, name, counter):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.counter = counter
   def run(self):
      print ("Starting " + self.name)
      # Get lock to synchronize threads
      threadLock.acquire()
      print_time(self.name, self.counter, 3)
      # Free lock to release next thread
      threadLock.release()

def print_time(threadName, delay, counter):
   while counter:
      time.sleep(delay)
      print ("%s: %s" % (threadName, time.ctime(time.time())))
      counter -= 1

threadLock = threading.Lock()
threads = []

# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# Start new Threads
thread1.start()
thread2.start()

# Add threads to thread list
threads.append(thread1)
threads.append(thread2)

# Wait for all threads to complete
for t in threads:
   t.join()
print ("Exiting Main Thread")

Production

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

Starting Thread-1
Starting Thread-2
Thread-1: Fri Feb 19 10:04:14 2016
Thread-1: Fri Feb 19 10:04:15 2016
Thread-1: Fri Feb 19 10:04:16 2016
Thread-2: Fri Feb 19 10:04:18 2016
Thread-2: Fri Feb 19 10:04:20 2016
Thread-2: Fri Feb 19 10:04:22 2016
Exiting Main Thread

File d'attente prioritaire multithread

Le module File d'attente vous permet de créer un nouvel objet de file d'attente pouvant contenir un nombre spécifique d'éléments. Il existe des méthodes suivantes pour contrôler la file d'attente:

get() - Le get () supprime et renvoie un élément de la file d'attente.
put() - Le put ajoute un élément à une file d'attente.
qsize() - Le qsize () renvoie le nombre d'éléments qui sont actuellement dans la file d'attente.
empty()- Le vide () renvoie True si la file d'attente est vide; sinon, Faux.
full()- le full () renvoie True si la file d'attente est pleine; sinon, Faux.

Exemple

#!/usr/bin/python3

import queue
import threading
import time

exitFlag = 0

class myThread (threading.Thread):
   def __init__(self, threadID, name, q):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.q = q
   def run(self):
      print ("Starting " + self.name)
      process_data(self.name, self.q)
      print ("Exiting " + self.name)

def process_data(threadName, q):
   while not exitFlag:
      queueLock.acquire()
      if not workQueue.empty():
         data = q.get()
         queueLock.release()
         print ("%s processing %s" % (threadName, data))
      else:
         queueLock.release()
         time.sleep(1)

threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three", "Four", "Five"]
queueLock = threading.Lock()
workQueue = queue.Queue(10)
threads = []
threadID = 1

# Create new threads
for tName in threadList:
   thread = myThread(threadID, tName, workQueue)
   thread.start()
   threads.append(thread)
   threadID += 1

# Fill the queue
queueLock.acquire()
for word in nameList:
   workQueue.put(word)
queueLock.release()

# Wait for queue to empty
while not workQueue.empty():
   pass

# Notify threads it's time to exit
exitFlag = 1

# Wait for all threads to complete
for t in threads:
   t.join()
print ("Exiting Main Thread")

Production

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

Starting Thread-1
Starting Thread-2
Starting Thread-3
Thread-1 processing One
Thread-2 processing Two
Thread-3 processing Three
Thread-1 processing Four
Thread-2 processing Five
Exiting Thread-3
Exiting Thread-1
Exiting Thread-2
Exiting Main Thread

XML est un langage open source portable qui permet aux programmeurs de développer des applications qui peuvent être lues par d'autres applications, quel que soit le système d'exploitation et / ou le langage de développement.

Qu'est-ce que XML?

Le langage de balisage extensible (XML) est un langage de balisage semblable au HTML ou au SGML. Ceci est recommandé par le World Wide Web Consortium et disponible en tant que norme ouverte.

XML est extrêmement utile pour garder une trace de petites et moyennes quantités de données sans avoir besoin d'un backbone basé sur SQL.

Architectures et API d'analyseur XML

La bibliothèque standard Python fournit un ensemble d'interfaces minimal mais utile pour travailler avec XML.

Les deux API les plus basiques et les plus largement utilisées pour les données XML sont les interfaces SAX et DOM.

Simple API for XML (SAX)- Ici, vous enregistrez des rappels pour les événements intéressants, puis laissez l'analyseur parcourir le document. Ceci est utile lorsque vos documents sont volumineux ou que vous avez des limitations de mémoire, il analyse le fichier lorsqu'il le lit à partir du disque et le fichier entier n'est jamais stocké dans la mémoire.
Document Object Model (DOM) API - Il s'agit d'une recommandation du World Wide Web Consortium dans laquelle le fichier entier est lu dans la mémoire et stocké sous une forme hiérarchique (arborescente) pour représenter toutes les fonctionnalités d'un document XML.

SAX ne peut évidemment pas traiter les informations aussi vite que DOM, lorsqu'il travaille avec des fichiers volumineux. D'un autre côté, l'utilisation exclusive de DOM peut vraiment tuer vos ressources, surtout si elle est utilisée sur de nombreux petits fichiers.

SAX est en lecture seule, tandis que DOM autorise les modifications du fichier XML. Étant donné que ces deux API différentes se complètent littéralement, il n'y a aucune raison pour que vous ne puissiez pas les utiliser toutes les deux pour de grands projets.

Pour tous nos exemples de code XML, utilisons un simple fichier XML movies.xml comme entrée -

<collection shelf = "New Arrivals">
<movie title = "Enemy Behind">
   <type>War, Thriller</type>
   <format>DVD</format>
   <year>2003</year>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Talk about a US-Japan war</description>
</movie>
<movie title = "Transformers">
   <type>Anime, Science Fiction</type>
   <format>DVD</format>
   <year>1989</year>
   <rating>R</rating>
   <stars>8</stars>
   <description>A schientific fiction</description>
</movie>
   <movie title = "Trigun">
   <type>Anime, Action</type>
   <format>DVD</format>
   <episodes>4</episodes>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Vash the Stampede!</description>
</movie>
<movie title = "Ishtar">
   <type>Comedy</type>
   <format>VHS</format>
   <rating>PG</rating>
   <stars>2</stars>
   <description>Viewable boredom</description>
</movie>
</collection>

Analyse XML avec les API SAX

SAX est une interface standard pour l'analyse XML basée sur les événements. L'analyse XML avec SAX vous oblige généralement à créer votre propre ContentHandler en sous-classant xml.sax.ContentHandler.

Votre ContentHandler gère les balises et attributs particuliers de votre (vos) saveur (s) de XML. Un objet ContentHandler fournit des méthodes pour gérer divers événements d'analyse. Son propre analyseur appelle les méthodes ContentHandler lorsqu'il analyse le fichier XML.

Les méthodes startDocument et endDocument sont appelées au début et à la fin du fichier XML. Les caractères de méthode (texte) reçoivent les données de caractères du fichier XML via le texte de paramètre.

Le ContentHandler est appelé au début et à la fin de chaque élément. Si l'analyseur n'est pas en mode espace de noms, les méthodes startElement (balise, attributs) et endElement (balise) sont appelées; sinon, les méthodes correspondantes startElementNS et endElementNS sont appelées. Ici, la balise est la balise d'élément et les attributs est un objet Attributes.

Voici d'autres méthodes importantes à comprendre avant de continuer -

La méthode make_parser

La méthode suivante crée un nouvel objet analyseur et le renvoie. L'objet analyseur créé sera du premier type d'analyseur, détecte le système.

xml.sax.make_parser( [parser_list] )

Voici les détails des paramètres -

parser_list - L'argument optionnel consistant en une liste d'analyseurs à utiliser qui doivent tous implémenter la méthode make_parser.

La méthode parse

La méthode suivante crée un analyseur SAX et l'utilise pour analyser un document.

xml.sax.parse( xmlfile, contenthandler[, errorhandler])

Voici les détails des paramètres -

xmlfile - C'est le nom du fichier XML à lire.
contenthandler - Il doit s'agir d'un objet ContentHandler.
errorhandler - S'il est spécifié, errorhandler doit être un objet SAX ErrorHandler.

La méthode parseString

Il existe une autre méthode pour créer un analyseur SAX et analyser le XML string.

xml.sax.parseString(xmlstring, contenthandler[, errorhandler])

Voici les détails des paramètres -

xmlstring - Il s'agit du nom de la chaîne XML à partir de laquelle lire.
contenthandler - Il doit s'agir d'un objet ContentHandler.
errorhandler - S'il est spécifié, errorhandler doit être un objet SAX ErrorHandler.

Exemple

#!/usr/bin/python3

import xml.sax

class MovieHandler( xml.sax.ContentHandler ):
   def __init__(self):
      self.CurrentData = ""
      self.type = ""
      self.format = ""
      self.year = ""
      self.rating = ""
      self.stars = ""
      self.description = ""

   # Call when an element starts
   def startElement(self, tag, attributes):
      self.CurrentData = tag
      if tag == "movie":
         print ("*****Movie*****")
         title = attributes["title"]
         print ("Title:", title)

   # Call when an elements ends
   def endElement(self, tag):
      if self.CurrentData == "type":
         print ("Type:", self.type)
      elif self.CurrentData == "format":
         print ("Format:", self.format)
      elif self.CurrentData == "year":
         print ("Year:", self.year)
      elif self.CurrentData == "rating":
         print ("Rating:", self.rating)
      elif self.CurrentData == "stars":
         print ("Stars:", self.stars)
      elif self.CurrentData == "description":
         print ("Description:", self.description)
      self.CurrentData = ""

   # Call when a character is read
   def characters(self, content):
      if self.CurrentData == "type":
         self.type = content
      elif self.CurrentData == "format":
         self.format = content
      elif self.CurrentData == "year":
         self.year = content
      elif self.CurrentData == "rating":
         self.rating = content
      elif self.CurrentData == "stars":
         self.stars = content
      elif self.CurrentData == "description":
         self.description = content
  
if ( __name__ == "__main__"):
   
   # create an XMLReader
   parser = xml.sax.make_parser()
   # turn off namepsaces
   parser.setFeature(xml.sax.handler.feature_namespaces, 0)

   # override the default ContextHandler
   Handler = MovieHandler()
   parser.setContentHandler( Handler )
   
   parser.parse("movies.xml")

Production

Cela produirait le résultat suivant -

*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Year: 2003
Rating: PG
Stars: 10
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Year: 1989
Rating: R
Stars: 8
Description: A scientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Stars: 10
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Stars: 2
Description: Viewable boredom

Pour un détail complet sur la documentation de l'API SAX, veuillez vous référer aux API Python SAX standard .

Analyser XML avec les API DOM

Le modèle d'objet de document ("DOM") est une API multilingue du World Wide Web Consortium (W3C) pour accéder et modifier les documents XML.

Le DOM est extrêmement utile pour les applications à accès aléatoire. SAX ne vous permet d'afficher qu'un seul bit du document à la fois. Si vous regardez un élément SAX, vous n'avez pas accès à un autre.

Voici le moyen le plus simple de charger rapidement un document XML et de créer un objet minidom à l'aide du module xml.dom. L'objet minidom fournit une méthode d'analyse simple qui crée rapidement une arborescence DOM à partir du fichier XML.

L'exemple de phrase appelle la fonction parse (file [, parser]) de l'objet minidom pour analyser le fichier XML, désigné par file dans un objet d'arborescence DOM.

Exemple

#!/usr/bin/python3

from xml.dom.minidom import parse
import xml.dom.minidom

# Open XML document using minidom parser
DOMTree = xml.dom.minidom.parse("movies.xml")
collection = DOMTree.documentElement
if collection.hasAttribute("shelf"):
   print ("Root element : %s" % collection.getAttribute("shelf"))

# Get all the movies in the collection
movies = collection.getElementsByTagName("movie")

# Print detail of each movie.
for movie in movies:
   print ("*****Movie*****")
   if movie.hasAttribute("title"):
      print ("Title: %s" % movie.getAttribute("title"))

   type = movie.getElementsByTagName('type')[0]
   print ("Type: %s" % type.childNodes[0].data)
   format = movie.getElementsByTagName('format')[0]
   print ("Format: %s" % format.childNodes[0].data)
   rating = movie.getElementsByTagName('rating')[0]
   print ("Rating: %s" % rating.childNodes[0].data)
   description = movie.getElementsByTagName('description')[0]
   print ("Description: %s" % description.childNodes[0].data)

Production

Cela produirait le résultat suivant -

Root element : New Arrivals
*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Rating: PG
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Rating: R
Description: A scientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Description: Viewable boredom

Pour un détail complet sur la documentation de l'API DOM, veuillez vous référer aux API DOM Python standard .

Python fournit diverses options pour développer des interfaces utilisateur graphiques (GUI). Les caractéristiques les plus importantes sont énumérées ci-dessous.

Tkinter- Tkinter est l'interface Python de la boîte à outils Tk GUI livrée avec Python. Nous examinerions cette option dans ce chapitre.
wxPython- Ceci est une interface Python open-source pour la boîte à outils GUI wxWidgets. Vous pouvez trouver un tutoriel complet sur WxPython ici .
PyQt−C'est aussi une interface Python pour une bibliothèque d'interface graphique Qt multiplateforme populaire. TutorialsPoint a un très bon tutoriel sur PyQt ici .
JPython - JPython est un port Python pour Java qui donne aux scripts Python un accès transparent aux bibliothèques de classes Java sur la machine locale http://www.jython.org.

Il existe de nombreuses autres interfaces disponibles, que vous pouvez trouver sur le net.

Programmation Tkinter

Tkinter est la bibliothèque GUI standard pour Python. Python lorsqu'il est combiné avec Tkinter fournit un moyen rapide et facile de créer des applications GUI. Tkinter fournit une puissante interface orientée objet à la boîte à outils Tk GUI.

La création d'une application GUI à l'aide de Tkinter est une tâche facile. Tout ce que vous avez à faire est d'effectuer les étapes suivantes -

Importez le module Tkinter .
Créez la fenêtre principale de l'application GUI.
Ajoutez un ou plusieurs des widgets mentionnés ci-dessus à l'application GUI.
Entrez dans la boucle d'événements principale pour agir contre chaque événement déclenché par l'utilisateur.

Exemple

#!/usr/bin/python3

import tkinter # note that module name has changed from Tkinter in Python 2 to tkinter in Python 3
top = tkinter.Tk()
# Code to add widgets will go here...
top.mainloop()

Cela créerait une fenêtre suivante -

Widgets Tkinter

Tkinter fournit divers contrôles, tels que des boutons, des étiquettes et des zones de texte utilisées dans une application GUI. Ces contrôles sont communément appelés widgets.

Il existe actuellement 15 types de widgets dans Tkinter. Nous présentons ces widgets ainsi qu'une brève description dans le tableau suivant -

Sr.No.	Opérateur et description
1	Bouton Le widget Bouton est utilisé pour afficher les boutons dans votre application.
2	Toile Le widget Canvas est utilisé pour dessiner des formes, telles que des lignes, des ovales, des polygones et des rectangles, dans votre application.
3	Bouton à cocher Le widget Checkbutton est utilisé pour afficher un certain nombre d'options sous forme de cases à cocher. L'utilisateur peut sélectionner plusieurs options à la fois.
4	Entrée Le widget Entrée est utilisé pour afficher un champ de texte sur une seule ligne pour accepter les valeurs d'un utilisateur.
5	Cadre Le widget Frame est utilisé comme widget conteneur pour organiser d'autres widgets.
6	Étiquette Le widget Label est utilisé pour fournir une légende sur une seule ligne pour d'autres widgets. Il peut également contenir des images.
sept	Listbox Le widget Listbox est utilisé pour fournir une liste d'options à un utilisateur.
8	Bouton de menu Le widget Menubutton est utilisé pour afficher les menus dans votre application.
9	Menu Le widget Menu est utilisé pour fournir diverses commandes à un utilisateur. Ces commandes sont contenues dans Menubutton.
dix	Message Le widget Message est utilisé pour afficher des champs de texte multilignes pour accepter les valeurs d'un utilisateur.
11	Bouton radio Le widget Radiobutton est utilisé pour afficher un certain nombre d'options sous forme de boutons radio. L'utilisateur ne peut sélectionner qu'une seule option à la fois.
12	Échelle Le widget Echelle est utilisé pour fournir un widget curseur.
13	Barre de défilement Le widget Barre de défilement est utilisé pour ajouter une capacité de défilement à divers widgets, tels que les zones de liste.
14	Texte Le widget Texte est utilisé pour afficher du texte sur plusieurs lignes.
15	Haut niveau Le widget Toplevel est utilisé pour fournir un conteneur de fenêtre séparé.
16	Spinbox Le widget Spinbox est une variante du widget Tkinter Entry standard, qui peut être utilisé pour sélectionner parmi un nombre fixe de valeurs.
17	PanedWindow Un PanedWindow est un widget conteneur qui peut contenir n'importe quel nombre de volets, disposés horizontalement ou verticalement.
18	LabelFrame Un labelframe est un simple widget conteneur. Son objectif principal est d'agir comme un espaceur ou un conteneur pour des dispositions de fenêtres complexes.
19	tkMessageBox Ce module permet d'afficher des boîtes de messages dans vos applications.

Attributs standard

Voyons comment certains de leurs attributs communs, tels que les tailles, les couleurs et les polices, sont spécifiés.

Dimensions
Colors
Fonts
Anchors
Styles de relief
Bitmaps
Cursors

Gestion de la géométrie

Tous les widgets Tkinter ont accès aux méthodes de gestion de la géométrie spécifiques, qui ont pour but d'organiser les widgets dans la zone de widget parent. Tkinter expose les classes de gestionnaire de géométrie suivantes: pack, grid et place.

La méthode pack () - Ce gestionnaire de géométrie organise les widgets en blocs avant de les placer dans le widget parent.
La méthode grid () - Ce gestionnaire de géométrie organise les widgets dans une structure de type tableau dans le widget parent.
La méthode place () - Ce gestionnaire de géométrie organise les widgets en les plaçant dans une position spécifique dans le widget parent.

Tout code que vous écrivez à l'aide d'un langage compilé tel que C, C ++ ou Java peut être intégré ou importé dans un autre script Python. Ce code est considéré comme une «extension».

Un module d'extension Python n'est rien de plus qu'une bibliothèque C normale. Sur les machines Unix, ces bibliothèques se terminent généralement par.so(pour objet partagé). Sur les machines Windows, vous voyez généralement.dll (pour bibliothèque liée dynamiquement).

Prérequis pour l'écriture d'extensions

Pour commencer à écrire votre extension, vous aurez besoin des fichiers d'en-tête Python.

Sur les machines Unix, cela nécessite généralement l'installation d'un package spécifique au développeur tel que.
Les utilisateurs Windows obtiennent ces en-têtes dans le cadre du package lorsqu'ils utilisent le programme d'installation binaire Python.

De plus, il est supposé que vous avez une bonne connaissance de C ou C ++ pour écrire une extension Python à l'aide de la programmation C.

Premier regard sur une extension Python

Pour votre premier aperçu d'un module d'extension Python, vous devez regrouper votre code en quatre parties -

Le fichier d'en-tête Python.h .
Les fonctions C que vous souhaitez exposer comme interface de votre module.
Un tableau mappant les noms de vos fonctions car les développeurs Python les voient comme des fonctions C à l'intérieur du module d'extension.
Une fonction d'initialisation.

Le fichier d'en-tête Python.h

Vous devez inclure le fichier d'en-tête Python.h dans votre fichier source C, ce qui vous donne l'accès à l'API Python interne utilisée pour connecter votre module à l'interpréteur.

Assurez-vous d'inclure Python.h avant tout autre en-tête dont vous pourriez avoir besoin. Vous devez suivre les inclusions avec les fonctions que vous souhaitez appeler depuis Python.

Les fonctions C

Les signatures de l'implémentation C de vos fonctions prennent toujours l'une des trois formes suivantes -

static PyObject *MyFunction( PyObject *self, PyObject *args );

static PyObject *MyFunctionWithKeywords(PyObject *self,
                                 PyObject *args,
                                 PyObject *kw);

static PyObject *MyFunctionWithNoArgs( PyObject *self );

Chacune des déclarations précédentes renvoie un objet Python. Il n'y a pas de fonction void en Python comme en C. Si vous ne voulez pas que vos fonctions retournent une valeur, renvoyez l'équivalent C de PythonNonevaleur. Les en-têtes Python définissent une macro, Py_RETURN_NONE, qui fait cela pour nous.

Les noms de vos fonctions C peuvent être ce que vous voulez car ils ne sont jamais vus en dehors du module d'extension. Ils sont définis comme une fonction statique .

Vos fonctions C sont généralement nommées en combinant le module Python et les noms de fonction ensemble, comme indiqué ici -

static PyObject *module_func(PyObject *self, PyObject *args) {
   /* Do your stuff here. */
   Py_RETURN_NONE;
}

Il s'agit d'une fonction Python appelée func à l'intérieur du module module . Vous allez mettre des pointeurs vers vos fonctions C dans la table des méthodes pour le module qui vient généralement après dans votre code source.

La table de mappage des méthodes

Cette table de méthodes est un simple tableau de structures PyMethodDef. Cette structure ressemble à quelque chose comme ça -

struct PyMethodDef {
   char *ml_name;
   PyCFunction ml_meth;
   int ml_flags;
   char *ml_doc;
};

Voici la description des membres de cette structure -

ml_name - C'est le nom de la fonction que l'interpréteur Python présente lorsqu'il est utilisé dans les programmes Python.
ml_meth - Il s'agit de l'adresse d'une fonction qui possède l'une des signatures décrites dans la section précédente.
ml_flags - Ceci indique à l'interpréteur laquelle des trois signatures ml_meth utilise.
- Cet indicateur a généralement la valeur METH_VARARGS.
- Cet indicateur peut être binaire OU avec METH_KEYWORDS si vous souhaitez autoriser les arguments de mot-clé dans votre fonction.
- Cela peut également avoir une valeur de METH_NOARGS qui indique que vous ne souhaitez accepter aucun argument.
ml_doc - Ceci est la docstring de la fonction, qui pourrait être NULL si vous n'avez pas envie d'en écrire une.

Cette table doit être terminée par une sentinelle composée de valeurs NULL et 0 pour les membres appropriés.

Exemple

Pour la fonction définie ci-dessus, nous avons le tableau de mappage de méthode suivant -

static PyMethodDef module_methods[] = {
   { "func", (PyCFunction)module_func, METH_NOARGS, NULL },
   { NULL, NULL, 0, NULL }
};

La fonction d'initialisation

La dernière partie de votre module d'extension est la fonction d'initialisation. Cette fonction est appelée par l'interpréteur Python lorsque le module est chargé. Il est nécessaire que la fonction soit nomméeinitModule, où Module est le nom du module.

La fonction d'initialisation doit être exportée depuis la bibliothèque que vous allez construire. Les en-têtes Python définissent PyMODINIT_FUNC pour inclure les incantations appropriées pour que cela se produise pour l'environnement particulier dans lequel nous compilons. Tout ce que vous avez à faire est de l'utiliser lors de la définition de la fonction.

Votre fonction d'initialisation C a généralement la structure globale suivante -

PyMODINIT_FUNC initModule() {
   Py_InitModule3(func, module_methods, "docstring...");
}

Voici la description de Py_InitModule3 fonction -

func - C'est la fonction à exporter.
module_methods - Il s'agit du nom de la table de mappage défini ci-dessus.
docstring - C'est le commentaire que vous souhaitez donner dans votre extension.

En mettant tout cela ensemble, cela ressemble à ce qui suit -

#include <Python.h>

static PyObject *module_func(PyObject *self, PyObject *args) {
   /* Do your stuff here. */
   Py_RETURN_NONE;
}

static PyMethodDef module_methods[] = {
   { "func", (PyCFunction)module_func, METH_NOARGS, NULL },
   { NULL, NULL, 0, NULL }
};

PyMODINIT_FUNC initModule() {
   Py_InitModule3(func, module_methods, "docstring...");
}

Exemple

Un exemple simple qui utilise tous les concepts ci-dessus -

#include <Python.h>

static PyObject* helloworld(PyObject* self)
{
   return Py_BuildValue("s", "Hello, Python extensions!!");
}

static char helloworld_docs[] =
   "helloworld( ): Any message you want to put here!!\n";

static PyMethodDef helloworld_funcs[] = {
   {"helloworld", (PyCFunction)helloworld, 
   METH_NOARGS, helloworld_docs},
   {NULL}
};

void inithelloworld(void)
{
   Py_InitModule3("helloworld", helloworld_funcs,
                   "Extension module example!");
}

Ici, la fonction Py_BuildValue est utilisée pour créer une valeur Python. Enregistrez le code ci-dessus dans le fichier hello.c. Nous verrions comment compiler et installer ce module pour être appelé à partir d'un script Python.

Création et installation d'extensions

Le paquet distutils facilite la distribution des modules Python, à la fois en Python pur et en modules d'extension, de manière standard. Les modules sont distribués sous la forme source, construits et installés via un script de configuration généralement appelé setup.py as.

Pour le module ci-dessus, vous devez préparer le script setup.py suivant -

from distutils.core import setup, Extension
setup(name = 'helloworld', version = '1.0',  \
   ext_modules = [Extension('helloworld', ['hello.c'])])

Maintenant, utilisez la commande suivante, qui effectuerait toutes les étapes de compilation et de liaison nécessaires, avec les bons commandes et indicateurs du compilateur et de l'éditeur de liens, et copie la bibliothèque dynamique résultante dans un répertoire approprié -

$ python setup.py install

Sur les systèmes Unix, vous devrez probablement exécuter cette commande en tant que root pour avoir les autorisations d'écrire dans le répertoire site-packages. Ce n'est généralement pas un problème sous Windows.

Importation d'extensions

Une fois que vous avez installé vos extensions, vous pourrez importer et appeler cette extension dans votre script Python comme suit -

Exemple

#!/usr/bin/python3
import helloworld

print helloworld.helloworld()

Production

Cela produirait le résultat suivant -

Hello, Python extensions!!

Passer des paramètres de fonction

Comme vous voudrez probablement définir des fonctions qui acceptent des arguments, vous pouvez utiliser l'une des autres signatures pour vos fonctions C. Par exemple, la fonction suivante, qui accepte un certain nombre de paramètres, serait définie comme ceci -

static PyObject *module_func(PyObject *self, PyObject *args) {
   /* Parse args and do something interesting here. */
   Py_RETURN_NONE;
}

La table de méthode contenant une entrée pour la nouvelle fonction ressemblerait à ceci -

static PyMethodDef module_methods[] = {
   { "func", (PyCFunction)module_func, METH_NOARGS, NULL },
   { "func", module_func, METH_VARARGS, NULL },
   { NULL, NULL, 0, NULL }
};

Vous pouvez utiliser la fonction API PyArg_ParseTuple pour extraire les arguments du pointeur PyObject transmis à votre fonction C.

Le premier argument de PyArg_ParseTuple est l'argument args. C'est l'objet que vous analyserez . Le deuxième argument est une chaîne de format décrivant les arguments tels que vous vous attendez à ce qu'ils apparaissent. Chaque argument est représenté par un ou plusieurs caractères dans la chaîne de format comme suit.

static PyObject *module_func(PyObject *self, PyObject *args) {
   int i;
   double d;
   char *s;

   if (!PyArg_ParseTuple(args, "ids", &i, &d, &s)) {
      return NULL;
   }
   
   /* Do something interesting here. */
   Py_RETURN_NONE;
}

Production

Compiler la nouvelle version de votre module et l'importer vous permet d'appeler la nouvelle fonction avec n'importe quel nombre d'arguments de n'importe quel type -

module.func(1, s = "three", d = 2.0)
module.func(i = 1, d = 2.0, s = "three")
module.func(s = "three", d = 2.0, i = 1)

Vous pouvez probablement proposer encore plus de variantes.

La fonction PyArg_ParseTuple

Voici la signature standard pour le PyArg_ParseTuple fonction -

int PyArg_ParseTuple(PyObject* tuple,char* format,...)

Cette fonction renvoie 0 pour les erreurs et une valeur différente de 0 pour le succès. Tuple est le PyObject * qui était le deuxième argument de la fonction C. Ici, le format est une chaîne C qui décrit les arguments obligatoires et facultatifs.

Voici une liste de codes de format pour le PyArg_ParseTuple fonction -

Code	Type C	Sens
c	carboniser	Une chaîne Python de longueur 1 devient un caractère C.
ré	double	Un flotteur Python devient un double C.
F	flotte	Un flotteur Python devient un flotteur C.
je	int	Un Python int devient un C int.
l	longue	Un Python int devient un C long.
L	long long	Un Python int devient un C long long
O	PyObject *	Obtient une référence empruntée non NULL à l'argument Python.
s	carboniser*	Chaîne Python sans NULL incorporé au caractère C *.
s #	char * + int	Toute chaîne Python à l'adresse et à la longueur C.
t #	char * + int	Tampon à un seul segment en lecture seule à l'adresse et à la longueur C.
u	Py_UNICODE *	Python Unicode sans valeurs nulles incorporées à C.
u #	Py_UNICODE * + int	Toute adresse et longueur Python Unicode C.
w #	char * + int	Tampon à un seul segment en lecture / écriture à l'adresse et à la longueur C.
z	carboniser*	Comme s, accepte également None (définit C char * sur NULL).
z #	char * + int	Comme s #, accepte également None (définit C char * sur NULL).
(...)	selon ...	Une séquence Python est traitée comme un argument par élément.
\|		Les arguments suivants sont facultatifs.
:		Fin du format, suivi du nom de la fonction pour les messages d'erreur.
;		Fin du format, suivi du texte complet du message d'erreur.

Valeurs renvoyées

Py_BuildValue prend une chaîne de format un peu comme PyArg_ParseTuple le fait. Au lieu de transmettre les adresses des valeurs que vous créez, vous transmettez les valeurs réelles. Voici un exemple montrant comment implémenter une fonction d'ajout -

static PyObject *foo_add(PyObject *self, PyObject *args) {
   int a;
   int b;

   if (!PyArg_ParseTuple(args, "ii", &a, &b)) {
      return NULL;
   }
   return Py_BuildValue("i", a + b);
}

Voici à quoi cela ressemblerait s'il était implémenté en Python -

def add(a, b):
   return (a + b)

Vous pouvez renvoyer deux valeurs de votre fonction comme suit. Cela serait capturé à l'aide d'une liste en Python.

static PyObject *foo_add_subtract(PyObject *self, PyObject *args) {
   int a;
   int b;

   if (!PyArg_ParseTuple(args, "ii", &a, &b)) {
      return NULL;
   }
   return Py_BuildValue("ii", a + b, a - b);
}

Voici à quoi cela ressemblerait s'il était implémenté en Python -

def add_subtract(a, b):
   return (a + b, a - b)

La fonction Py_BuildValue

Voici la signature standard pour Py_BuildValue fonction -

PyObject* Py_BuildValue(char* format,...)

Ici, le format est une chaîne C qui décrit l'objet Python à construire. Les arguments suivants de Py_BuildValue sont des valeurs C à partir desquelles le résultat est construit. Le résultat PyObject * est une nouvelle référence.

Le tableau suivant répertorie les chaînes de code couramment utilisées, dont zéro ou plus sont jointes dans un format de chaîne.

Code	Type C	Sens
c	carboniser	AC char devient une chaîne Python de longueur 1.
ré	double	AC double devient un flotteur Python.
F	flotte	AC float devient un float Python.
je	int	AC int devient un Python int.
l	longue	AC long devient un int Python.
N	PyObject *	Passe un objet Python et vole une référence.
O	PyObject *	Passe un objet Python et l'INCREF comme d'habitude.
O &	convertir + annuler *	Conversion arbitraire
s	carboniser*	C 0-terminé char * en chaîne Python, ou NULL en None.
s #	char * + int	C char * et longueur en chaîne Python, ou NULL en None.
u	Py_UNICODE *	Chaîne C-wide, terminée par NULL à Python Unicode, ou NULL à None.
u #	Py_UNICODE * + int	Chaîne C-wide et longueur en Python Unicode, ou NULL en None.
w #	char * + int	Tampon à un seul segment en lecture / écriture à l'adresse et à la longueur C.
z	carboniser*	Comme s, accepte également None (définit C char * sur NULL).
z #	char * + int	Comme s #, accepte également None (définit C char * sur NULL).
(...)	selon ...	Construit un tuple Python à partir de valeurs C.
[...]	selon ...	Construit une liste Python à partir de valeurs C.
{...}	selon ...	Construit un dictionnaire Python à partir de valeurs C, en alternant les clés et les valeurs.

Code {...} construit des dictionnaires à partir d'un nombre pair de valeurs C, alternativement de clés et de valeurs. Par exemple, Py_BuildValue ("{issi}", 23, "zig", "zag", 42) renvoie un dictionnaire comme celui de Python {23: 'zig', 'zag': 42}.

Python 3 - Guide rapide

Le module __future__

La fonction d'impression

Lecture de l'entrée depuis le clavier

Division entière

Représentation Unicode

Fonction xrange () supprimée

lever une exception

Arguments dans les exceptions

Fonction next () et méthode .next ()

Utilitaire 2to3

Histoire de Python

Fonctionnalités Python

Configuration de l'environnement local

Obtenir Python

Plate-forme Windows

Plateforme Linux

Mac OS

Configurer PATH

Définition du chemin sous Unix / Linux

Définition du chemin sous Windows

Variables d'environnement Python

Exécuter Python

Interprète interactif

Script depuis la ligne de commande

Environnement de développement intégré

Premier programme Python

Programmation en mode interactif

Programmation en mode script

Identificateurs Python

Mots réservés

Lignes et retrait

Déclarations multilignes

Devis en Python

Commentaires en Python

Utilisation de lignes vides

En attente de l'utilisateur

Déclarations multiples sur une seule ligne

Plusieurs groupes d'instructions en tant que suites

Arguments de ligne de commande

Attribution de valeurs à des variables

Affectation multiple

Types de données standard

Numéros Python

Exemples

Chaînes Python

Listes Python

Tuples Python

Dictionnaire Python

Conversion de type de données

Types d'opérateurs

Opérateurs arithmétiques Python

Opérateurs de comparaison Python

Opérateurs d'affectation Python

Opérateurs binaires Python

Opérateurs logiques Python

Opérateurs d'appartenance Python

Opérateurs d'identité Python

Priorité des opérateurs Python

Suites à déclaration unique

Exemple

Production

Déclarations de contrôle de boucle

Itérateur et générateur

Exemple

Exemples

Conversion de type de nombre

Fonctions mathématiques

Fonctions de nombres aléatoires

Fonctions trigonométriques

Constantes mathématiques

Accès aux valeurs dans les chaînes

Mise à jour des chaînes

Personnages de fuite

Opérateurs spéciaux de chaîne

Opérateur de formatage de chaîne

Citations triples

Chaîne Unicode

Méthodes de chaîne intégrées

Listes Python

Le module future