Guide rapide Python

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 d'autres langues utilisent la ponctuation, et il a moins de constructions syntaxiques que les autres langues.

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.

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 à l'étudiant de comprendre rapidement la langue.
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, quelques-unes sont répertoriées 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 est disponible sur une grande variété de plates-formes, y compris Linux et Mac OS X. Voyons comment configurer notre environnement Python.

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.

Unix (Solaris, Linux, FreeBSD, AIX, HP / UX, SunOS, IRIX, etc.)
Gagnez 9x / NT / 2000
Macintosh (Intel, PPC, 68 Ko)
OS/2
DOS (plusieurs versions)
PalmOS
Téléphones mobiles Nokia
Windows CE
Système d'exploitation Acorn / RISC
BeOS
Amiga
VMS/OpenVMS
QNX
VxWorks
Psion
Python a également été porté sur les machines virtuelles Java et .NET

Obtenir Python

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 https://www.python.org/

Vous pouvez télécharger la documentation Python depuis https://www.python.org/doc/. La documentation est disponible aux formats HTML, PDF et PostScript.

Installer Python

La distribution Python est disponible pour une grande variété de plates-formes. Vous devez télécharger uniquement le code binaire applicable à votre plateforme et installer Python.

Si le code binaire de votre plateforme n'est pas disponible, vous avez besoin d'un compilateur C pour compiler le code source manuellement. La compilation du code source offre plus de flexibilité en termes de choix des fonctionnalités dont vous avez besoin dans votre installation.

Voici un bref aperçu de l'installation de Python sur différentes plates-formes -

Installation Unix et Linux

Voici les étapes simples pour installer Python sur une machine Unix / Linux.

Ouvrez un navigateur Web et accédez à https://www.python.org/downloads/.
Suivez le lien pour télécharger le code source compressé disponible pour Unix / Linux.
Téléchargez et extrayez des fichiers.
Modification du fichier Modules / Setup si vous souhaitez personnaliser certaines options.
exécuter le script ./configure
make
faire installer

Cela installe Python à l'emplacement standard / usr / local / bin et ses bibliothèques dans / usr / local / lib / pythonXX où XX est la version de Python.

Installation de Windows

Voici les étapes pour installer Python sur une machine Windows.

Ouvrez un navigateur Web et accédez à https://www.python.org/downloads/.
Suivez le lien pour le fichier d' installation de Windows python-XYZ.msi où XYZ est la version que vous devez installer.
Pour utiliser ce programme d'installation python-XYZ.msi , le système Windows doit prendre en charge Microsoft Installer 2.0. Enregistrez le fichier du programme d'installation sur votre ordinateur local, puis exécutez-le pour savoir si votre ordinateur prend en charge MSI.
Exécutez le fichier téléchargé. Cela fait apparaître l'assistant d'installation Python, qui est vraiment facile à utiliser. Acceptez simplement les paramètres par défaut, attendez que l'installation soit terminée et vous avez terminé.

Installation sur Macintosh

Les Mac récents sont livrés avec Python installé, mais il peut être obsolète de plusieurs années. Voirhttp://www.python.org/download/mac/pour obtenir des instructions sur l'obtention de la version actuelle ainsi que des outils supplémentaires pour prendre en charge le développement sur Mac. Pour les Mac OS plus anciens avant Mac OS X 10.3 (publié en 2003), MacPython est disponible.

Jack Jansen le maintient et vous pouvez avoir un accès complet à toute la documentation sur son site Web - http://www.cwi.nl/~jack/macpython.html. Vous pouvez trouver les détails d'installation complets pour l'installation de Mac OS.

Configurer PATH

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

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.

le path La variable est nommée 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 / python" et appuyez sur Entrée.
In the bash shell (Linux) - tapez export PATH = "$ PATH: / usr / local / bin / python" et appuyez sur Entrée.
In the sh or ksh shell - tapez PATH = "$ PATH: / usr / local / bin / python" et appuyez sur Entrée.
Note - / usr / local / bin / python 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 peuvent être 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 Il fournit une sortie de débogage.
2	-O Il génère un bytecode optimisé (résultant en des fichiers .pyo).
3	-S N'exécutez pas 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é en ligne de commande en appelant l'interpréteur sur votre application, comme dans ce qui suit -

$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 2.4.3 disponible sur la version CentOS de Linux.

Nous avons déjà mis en place l'environnement de programmation Python en ligne, afin que vous puissiez exécuter tous les exemples disponibles en ligne en même temps lorsque 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 des 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 2.4.3 (#1, Nov 11 2010, 13:34:43)
[GCC 4.1.2 20080704 (Red Hat 4.1.2-48)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

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

>>> print "Hello, Python!"

Si vous exécutez une nouvelle version de Python, vous devez utiliser l'instruction print avec parenthèses comme dans print ("Hello, Python!");. Cependant, dans la version 2.4.3 de Python, 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 une 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 la variable PATH. Maintenant, essayez d'exécuter ce programme comme suit -

$ python test.py

Cela produit le résultat suivant -

Hello, Python!

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

#!/usr/bin/python

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é.
Le début d'un identifiant avec deux traits de soulignement en tête indique un identifiant fortement privé.
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 constante ou variable ou tout autre nom d'identifiant. Tous les mots-clés Python contiennent uniquement des lettres minuscules.

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

Lignes et retrait

Python ne fournit pas d'accolades pour indiquer les 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 que vous avez bien compris les différents blocs, même s'ils sont sans accolades.

#!/usr/bin/python

import sys

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

Déclarations multilignes

Les instructions en Python se terminent généralement par une nouvelle ligne. Python autorise cependant 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 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 commence un commentaire. Tous les caractères après le # et jusqu'à la fin de la ligne physique font partie du commentaire et l'interpréteur Python les ignore.

#!/usr/bin/python

# 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

Vous pouvez commenter plusieurs lignes 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, l'instruction disant "Appuyez sur la touche Entrée pour quitter" et attend que l'utilisateur agisse -

#!/usr/bin/python

raw_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

Un groupe d'instructions individuelles, qui forment un seul bloc de code, est appelé 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. Les arguments de ligne de commande sont un sujet avancé et devraient être étudiés un peu plus tard une fois que vous aurez parcouru le reste des concepts Python.

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 en 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/python

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 à l'aide de l'instruction del. La syntaxe de l'instruction del est -

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

Vous pouvez supprimer un ou plusieurs objets à l'aide de l'instruction del. Par exemple -

del var
del var_a, var_b

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

int (entiers signés)
long (entiers longs, ils peuvent également être représentés en octal et hexadécimal)
float (valeurs réelles en virgule flottante)
complexe (nombres complexes)

Exemples

Voici quelques exemples de nombres -

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

Python vous permet d'utiliser un l minuscule avec un long, mais il est recommandé de n'utiliser qu'un L majuscule pour éviter toute confusion avec le nombre 1. Python affiche les entiers longs avec un L. majuscule.
Un nombre complexe se compose d'une paire ordonnée de nombres réels à virgule flottante notés x + yj, où x et y sont les 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 permet des paires 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/python

str = 'Hello World!'

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

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. Une différence 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/python

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

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

Cela produit le résultat suivant -

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

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 placés entre parenthèses.

Les principales différences entre les listes et les tuples sont les suivantes: 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/python

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

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

Cela produit le résultat suivant -

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

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/python

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

Dictionnaire Python

Les dictionnaires de Python sont une sorte de type de 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/python

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

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


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

Cela produit le résultat suivant -

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

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 le nom du type comme 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. base spécifie la base si x est une chaîne.
2	long(x [,base] ) Convertit x en un entier long. base spécifie la base si x est une chaîne.
3	float(x) Convertit x en nombre à virgule flottante.
4	complex(real [,imag]) Crée un nombre complexe.
5	str(x) Convertit l'objet x en une représentation sous forme de chaîne.
6	repr(x) Convertit l'objet x en une chaîne d'expression.
sept	eval(str) Évalue une chaîne et renvoie un objet.
8	tuple(s) Convertit s en tuple.
9	list(s) Convertit les s en liste.
dix	set(s) Convertit s en un ensemble.
11	dict(d) Crée un dictionnaire. d doit être une séquence de tuples (clé, valeur).
12	frozenset(s) Convertit les s en ensemble figé.
13	chr(x) Convertit un entier en caractère.
14	unichr(x) Convertit un entier en caractère Unicode.
15	ord(x) Convertit un seul caractère en sa valeur entière.
16	hex(x) Convertit un entier en chaîne hexadécimale.
17	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 opérandes et + est appelé 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 sur tous les opérateurs un par un.

Opérateurs arithmétiques Python

Supposons que la variable a soit 10 et la variable b 20, alors -

[ Afficher l'exemple ]

Opérateur	La description	Exemple
+ Ajout	Ajoute des valeurs de chaque côté de l'opérateur.	a + b = 30
- Soustraction	Soustrait l'opérande de droite de l'opérande de gauche.	a - b = -10
* Multiplication	Multiplie les valeurs de chaque côté de l'opérateur	a * b = 200
/ Division	Divise l'opérande de gauche par l'opérande de droite	b / a = 2
% Module	Divise l'opérande de gauche par l'opérande de droite et renvoie le reste	b% a = 0
** 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 que la variable a soit 10 et la variable b 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 les valeurs de deux opérandes ne sont pas égales, la condition devient vraie.	(a <> b) est vrai. Ceci est similaire à l'opérateur! =.
>	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 que la variable a soit 10 et la variable b 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 / 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; Désormais, au format binaire, leurs valeurs seront respectivement 0011 1100 et 0000 1101. Le tableau suivant répertorie les opérateurs binaires pris en charge par le langage Python avec un exemple chacun dans ceux-ci, nous utilisons les deux variables ci-dessus (a et b) comme opérandes -

a = 0011 1100

b = 0000 1101

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

a & b = 0000 1100

a | b = 0011 1101

a ^ b = 0011 0001

~ a = 1100 0011

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 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 des opérandes 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 des opérandes de gauche est déplacée vers la droite du nombre de bits spécifié par l'opérande de droite.	a >> 2 = 15 (signifie 0000 1111)

Opérateurs logiques Python

Les opérateurs logiques suivants sont pris en charge par le langage Python. Supposons que la variable a soit 10 et la variable b 20 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 vrai.
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 faux.

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é expliqués 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 du programme et la spécification des actions prises en fonction des conditions.

Les structures de décision évaluent plusieurs expressions qui produisent VRAI ou FAUX 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 les valeurs sont TRUE, et si c'est le cas zero ou null, alors il est supposé comme valeur FALSE.

Le langage de programmation Python fournit les types suivants d'instructions de prise de décision. Cliquez sur les liens suivants pour vérifier leurs détails.

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 brièvement en revue chaque prise de décision -

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.

Voici un exemple de one-line if clause -

#!/usr/bin/python

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

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 à l'intérieur d'une autre boucle while, for ou do.. while.

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. Cliquez sur les liens suivants pour vérifier leurs détails.

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

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.

Les types de données numériques stockent des valeurs numériques. Ce sont des types de données immuables, ce qui 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 de l'instruction del 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 quatre types numériques différents -

int (signed integers) - Ils sont souvent appelés simplement des entiers ou des entiers, sont des nombres entiers positifs ou négatifs sans point décimal.
long (long integers ) - Aussi appelés longs, ce sont des entiers de taille illimitée, écrits comme des entiers et suivis d'un L. majuscule ou minuscule.
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 les parties entières et 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.

Exemples

Voici quelques exemples de nombres

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

Python vous permet d'utiliser un L minuscule avec un long, mais il est recommandé de n'utiliser qu'un L majuscule pour éviter toute confusion avec le nombre 1. Python affiche les entiers longs avec un L. majuscule.
Un nombre complexe consiste en une paire ordonnée de nombres réels à virgule flottante notée 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. Mais 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 comprend 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
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/python

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/python

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/python

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% -

Symbole de format	Conversion
% c	personnage
% s	conversion de chaîne via str () avant le formatage
%je	entier décimal signé
%ré	entier décimal signé
% u	entier décimal non signé
% o	entier octal
%X	entier hexadécimal (lettres minuscules)
%X	entier hexadécimal (lettres majuscules)
% e	notation exponentielle (avec 'e' minuscule)
% E	notation exponentielle (avec MAJUSCULE 'E')
%F	nombre réel à virgule flottante
%g	le plus court de% f et% e
%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 -

symbole	Fonctionnalité
*	l'argument spécifie la largeur ou la précision
-	justification à gauche
+	afficher le signe
<sp>	laisser un espace vide avant un nombre positif
#	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.
0	pad de gauche avec des zéros (au lieu d'espaces)
%	'%%' vous laisse avec un seul littéral '%'
(var)	variable de mappage (arguments du dictionnaire)
mn	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/python

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

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/python

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/python

print r'C:\\nowhere'

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

C:\\nowhere

Chaîne Unicode

Les chaînes normales en Python sont stockées en interne en ASCII 8 bits, tandis que les chaînes Unicode sont stockées en Unicode 16 bits. Cela permet un jeu de caractères plus varié, y compris des caractères spéciaux de la plupart des langues du monde. Je vais limiter mon traitement des chaînes Unicode à ce qui suit -

#!/usr/bin/python

print u'Hello, world!'

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

Hello, world!

Comme vous pouvez le voir, les chaînes Unicode utilisent le préfixe u, tout comme les chaînes brutes utilisent le préfixe r.

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 avec description
1	capitaliser() Met en majuscule la première lettre de la chaîne
2	center (width, fillchar) Renvoie une chaîne remplie d'espaces 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]) Exécute à la fois lstrip () et rstrip () sur la 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 un type de données le plus polyvalent disponible en Python qui peut être écrit sous la forme d'une liste de valeurs (éléments) séparées par des virgules 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/python

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

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/python

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

Note - La méthode append () est discuté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 l'instruction del si vous savez exactement quel (s) élément (s) vous supprimez ou la méthode remove () si vous ne le savez pas. Par exemple -

#!/usr/bin/python

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

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]: imprimer x,	1 2 3	Itération

Indexation, découpage et matrices

Les listes étant 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 = ['spam', 'Spam', 'SPAM!']

Expression Python	Résultats	La description
L [2]	SPAM!	Les décalages commencent à zéro
L [-2]	Spam	Négatif: compter à partir de la droite
L [1:]	["Spam", "SPAM!"]	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.	Fonction avec description
1	cmp (liste1, liste2) Compare les éléments des deux listes.
2	len (liste) Donne la longueur totale de la liste.
3	max (liste) Renvoie l'élément de la liste avec une valeur maximale.
4	min (liste) Renvoie l'élément de la liste avec une valeur minimale.
5	liste (seq) Convertit un tuple en liste.

Python inclut les méthodes de liste suivantes

Sr.No.	Méthodes avec 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 séquence immuable d'objets Python. Les tuples sont des séquences, tout comme les listes. Les différences entre les tuples et les listes sont que les tuples ne peuvent pas être modifiés contrairement aux listes et 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. 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/python

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

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 de tuples existants pour créer de nouveaux tuples comme le montre l'exemple suivant -

#!/usr/bin/python

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

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

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

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/python

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

Cela produit le résultat suivant. Notez une exception levée, car 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): imprimer x,	1 2 3	Itération

Indexation, découpage et matrices

Étant donné que 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 -

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

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

Pas de délimiteurs fermants

Tout 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 -

#!/usr/bin/python

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

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

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

Fonctions de tuple intégrées

Python inclut les fonctions de tuple suivantes -

Sr.No.	Fonction avec description
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/python

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

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

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

Si nous essayons d'accéder à un élément de données avec une clé, qui ne fait pas partie du dictionnaire, nous obtenons une erreur comme suit -

#!/usr/bin/python

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

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

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

Mise à jour du dictionnaire

Vous pouvez mettre à jour un dictionnaire en ajoutant une nouvelle entrée ou une paire clé-valeur, en modifiant une entrée existante ou en supprimant une entrée existante comme indiqué ci-dessous dans l'exemple simple -

#!/usr/bin/python

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

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

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

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

Supprimer les éléments du dictionnaire

Vous pouvez supprimer des éléments de dictionnaire individuels ou effacer tout le contenu d'un dictionnaire. Vous pouvez également supprimer tout le dictionnaire en une seule opération.

Pour supprimer explicitement un dictionnaire entier, utilisez simplement le deldéclaration. Voici un exemple simple -

#!/usr/bin/python

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

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

Cela produit le résultat suivant. Notez qu'une exception est déclenchée car aprèsdel dict le dictionnaire n'existe plus -

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 - La méthode del () est discutée dans la section suivante.

Propriétés des clés de dictionnaire

Les valeurs du dictionnaire n'ont aucune restriction. Il peut s'agir de n'importe quel objet Python arbitraire, qu'il s'agisse d'objets standard ou d'objets définis par l'utilisateur. Cependant, il n'en est pas de même pour les clés.

Il y a deux points importants à retenir à propos des clés de dictionnaire -

(a)Plus d'une entrée par clé n'est pas autorisée. Ce qui signifie qu'aucune clé en double n'est autorisée. Lorsque des clés en double sont rencontrées pendant l'affectation, la dernière affectation l'emporte. Par exemple -

#!/usr/bin/python

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

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

dict['Name']:  Manni

(b)Les clés doivent être immuables. Ce qui signifie que vous pouvez utiliser des chaînes, des nombres ou des tuples comme clés de dictionnaire, mais quelque chose comme ['key'] n'est pas autorisé. Voici un exemple simple -

#!/usr/bin/python

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

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

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

Fonctions et méthodes intégrées du dictionnaire

Python inclut les fonctions de dictionnaire suivantes -

Sr.No.	Fonction avec description
1	cmp (dict1, dict2) Compare les éléments des deux dict.
2	len (dict) Donne la longueur totale du dictionnaire. Ce serait égal au nombre d'éléments dans le dictionnaire.
3	str (dict) Produit une représentation sous forme de chaîne imprimable d'un dictionnaire
4	type (variable) Renvoie le type de la variable transmise. Si la variable passée est un dictionnaire, elle renverra un type de dictionnaire.

Python inclut les méthodes de dictionnaire suivantes -

Sr.No.	Méthodes avec description
1	dict.clear () Supprime tous les éléments du dictionnaire dict
2	dict.copy () Renvoie une copie superficielle du dictionnaire dict
3	dict. touches () Créez un nouveau dictionnaire avec des clés de seq et des valeurs définies sur value .
4	dict.get (clé, par défaut = Aucun) Pour la clé clé, renvoie la valeur ou la valeur par défaut si la clé n'est pas dans le dictionnaire
5	dict.has_key (clé) Renvoie vrai si la clé dans le dictionnaire dict , faux sinon
6	dict.items () Renvoie une liste de paires de tuples de dict (clé, valeur)
sept	dict.keys () Renvoie la liste des clés du dictionnaire dict
8	dict.setdefault (clé, par défaut = Aucun) Similaire à get (), mais définira dict [key] = default si la clé n'est pas déjà dans dict
9	dict.update (dict2) Ajoute les paires valeur / clé de dictionnaire dict2 à dict
dix	dict.values () Renvoie la liste des valeurs du dictionnaire dict

Un programme Python peut gérer la date et l'heure de plusieurs manières. La conversion entre les formats de date est une tâche courante pour les ordinateurs. Les modules d'heure et de calendrier de Python aident à suivre les dates et les heures.

Qu'est-ce que Tick?

Les intervalles de temps sont des nombres à virgule flottante en unités de secondes. Des instants particuliers dans le temps sont exprimés en secondes depuis le 1er janvier 1970 à 00:00:00 (époque).

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. La fonction time.time () renvoie l'heure système actuelle en ticks depuis le 1er janvier 1970 (époque) à 00:00:00.

Exemple

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

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

Cela produirait un résultat comme suit -

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

L'arithmétique des dates est facile à faire avec les graduations. Cependant, les dates antérieures à l'époque ne peuvent pas être représentées sous cette forme. Les dates dans un futur lointain ne peuvent pas non plus être représentées de cette manière - le point de coupure est quelque part en 2038 pour UNIX et Windows.

Qu'est-ce que TimeTuple?

De nombreuses fonctions de temps de Python traitent le temps comme un tuple de 9 nombres, comme indiqué ci-dessous -

Indice	Champ	Valeurs
0	Année à 4 chiffres	2008
1	Mois	1 à 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

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

Index	Attributes	Values
0	tm_year	2008
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 a seconds since the epoch floating-point value into a time-tuple, pass the floating-point value to a function (e.g., localtime) that returns a time-tuple with all nine items valid.

#!/usr/bin/python
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=2013, tm_mon=7, 
tm_mday=17, tm_hour=21, tm_min=26, tm_sec=3, tm_wday=2, tm_yday=198, tm_isdst=0)

Getting formatted time

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

#!/usr/bin/python
import time;

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

This would produce the following result −

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

Getting calendar for a month

The calendar module gives a wide range of methods to play with yearly and monthly calendars. Here, we print a calendar for a given month ( Jan 2008 ) −

#!/usr/bin/python
import calendar

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

This would produce the following result −

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

The time Module

There is a popular time module available in Python which provides functions for working with times and for converting between representations. Here is the list of all available methods −

Sr.No.	Function with Description
1	time.altzone The offset of the local DST timezone, in seconds west of UTC, if one is defined. This is negative if the local DST timezone is east of UTC (as in Western Europe, including the UK). Only use this if daylight is nonzero.
2	time.asctime([tupletime]) Accepts a time-tuple and returns a readable 24-character string such as 'Tue Dec 11 18:07:14 2008'.
3	time.clock( ) Returns the current CPU time as a floating-point number of seconds. To measure computational costs of different approaches, the value of time.clock is more useful than that of time.time().
4	time.ctime([secs]) Like asctime(localtime(secs)) and without arguments is like asctime( )
5	time.gmtime([secs]) Accepts an instant expressed in seconds since the epoch and returns a time-tuple t with the UTC time. Note : t.tm_isdst is always 0
6	time.localtime([secs]) Accepts an instant expressed in seconds since the epoch and returns a time-tuple t with the local time (t.tm_isdst is 0 or 1, depending on whether DST applies to instant secs by local rules).
7	time.mktime(tupletime) Accepts an instant expressed as a time-tuple in local time and returns a floating-point value with the instant expressed in seconds since the epoch.
8	time.sleep(secs) Suspends the calling thread for secs seconds.
9	time.strftime(fmt[,tupletime]) Accepts an instant expressed as a time-tuple in local time and returns a string representing the instant as specified by string fmt.
10	time.strptime(str,fmt='%a %b %d %H:%M:%S %Y') Parses str according to format string fmt and returns the instant in time-tuple format.
11	time.time( ) Returns the current time instant, a floating-point number of seconds since the epoch.
12	time.tzset() Resets the time conversion rules used by the library routines. The environment variable TZ specifies how this is done.

Let us go through the functions briefly −

There are following two important attributes available with time module −

Sr.No.	Attribute with Description
1	time.timezone Attribute time.timezone is the offset in seconds of the local time zone (without DST) from UTC (>0 in the Americas; <=0 in most of Europe, Asia, Africa).
2	time.tzname Attribute time.tzname is a pair of locale-dependent strings, which are the names of the local time zone without and with DST, respectively.

The calendar Module

The calendar module supplies calendar-related functions, including functions to print a text calendar for a given month or year.

By default, calendar takes Monday as the first day of the week and Sunday as the last one. To change this, call calendar.setfirstweekday() function.

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

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

Other Modules & Functions

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

The datetime Module
The pytz Module
The dateutil Module

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 ne lui donne qu'un nom, spécifie les paramètres à inclure 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 l'exemple pour appeler la fonction printme () -

#!/usr/bin/python

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

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

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

I'm first call to 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/python

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

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

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

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

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/python

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

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

Le paramètre mylist est 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/python

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

# Now you can call printme function
printme()

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 les 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 effectuer des appels de mots-clés à la fonction printme () des manières suivantes -

#!/usr/bin/python

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

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

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/python

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

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

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/python

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

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

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 la suivante:

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/python

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

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

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 à l'aide du mot clé def . Vous pouvez utiliser le mot clé lambda 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 lambda soient une version sur une ligne d'une fonction, ils ne sont pas équivalents aux instructions en ligne en C ou C ++, dont le but est de transmettre l'allocation de pile de fonctions lors de l'appel pour des raisons de performances.

Syntaxe

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

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

Voici l'exemple pour montrer comment fonctionne la forme lambda de la fonction -

#!/usr/bin/python

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

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

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 ci-dessus ne renvoient aucune valeur. Vous pouvez renvoyer une valeur à partir d'une fonction comme suit -

#!/usr/bin/python

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

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

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/python

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

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

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. L' importation 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 support.py, vous devez mettre la commande suivante en haut du script -

#!/usr/bin/python

# 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 encore et encore si plusieurs importations se produisent.

La déclaration from ... import

L' instruction from de Python vous permet d'importer des attributs spécifiques d'un module dans l'espace de noms actuel. L' importation from ... 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 -

from fib import fibonacci

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 actuel 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.

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 / python /.

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:\python20\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/python

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/python

# 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 globals () et locaux () Fonctions

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

Si locals () est appelé à partir d'une fonction, il renverra tous les noms accessibles localement à partir de cette fonction.

Si globals () est appelé à partir d'une fonction, il renverra 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 à l'aide de la fonction keys ().

Le reload () Fonction

Lorsque le 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/python

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

De manière similaire, nous avons deux autres fichiers ayant des fonctions différentes avec le même nom que ci-dessus -

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 l' annuaire téléphonique -

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/python

# 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 en Python. 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/python

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 fournit deux fonctions intégrées pour lire une ligne de texte à partir d'une entrée standard, qui par défaut provient du clavier. Ces fonctions sont -

raw_input
input

La fonction raw_input

La fonction raw_input ([prompt]) lit une ligne à partir de l'entrée standard et la renvoie sous forme de chaîne (en supprimant la nouvelle ligne de fin).

#!/usr/bin/python

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

Cela vous invite à entrer une chaîne et elle affichera la même chaîne à l'écran. Quand j'ai tapé "Hello Python!", Sa sortie est comme ceci -

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

La fonction d' entrée

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

#!/usr/bin/python

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

Cela produirait le résultat suivant par rapport à l'entrée entrée -

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

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.	Modes 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.

Le fichier des attributs d'objet

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 à l'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.
4	file.softspace Renvoie false si l'espace est explicitement requis avec print, true sinon.

Exemple

#!/usr/bin/python

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

Cela produit le résultat suivant -

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

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/python

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

# Close opend 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. Nous verrons comment utiliser les méthodes read () et write () pour lire et écrire des fichiers.

La méthode write ()

La méthode write () é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/python

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

# Close opend file
fo.close()

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 ()

La méthode read () lit une chaîne à partir d'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/python

# Open a file
fo = open("foo.txt", "r+")
str = fo.read(10);
print "Read String is : ", str
# Close opend 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. L' argument offset indique le nombre d'octets à déplacer. L' argument from 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, cela signifie utiliser le début du fichier comme position de référence et 1 signifie utiliser la position actuelle comme position de référence et 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/python

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

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

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

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 ()

La méthode rename () 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 l'exemple pour renommer un fichier existant test1.txt -

#!/usr/bin/python
import os

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

La méthode remove ()

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

Syntaxe

os.remove(file_name)

Exemple

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

#!/usr/bin/python
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 la méthode mkdir () duosmodule 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 l'exemple pour créer un test de répertoire dans le répertoire courant -

#!/usr/bin/python
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 l'exemple pour aller dans le répertoire "/ home / newdir" -

#!/usr/bin/python
import os

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

Le getcwd () Méthode

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

Syntaxe

os.getcwd()

Exemple

Voici l'exemple pour donner le répertoire courant -

#!/usr/bin/python
import os

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

La méthode rmdir ()

La méthode rmdir () 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 l'exemple de suppression du 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/python
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 __gVirt_NP_NN_NNPS<__ objet de fichier : Le fichier objet fournit des fonctions pour manipuler des fichiers.
Méthodes d'objets du système d'exploitation : 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 .

Liste des exceptions standard -

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	ZeroDivisionError 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	IOError 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, mais si elles ne sont pas gérées, elles mettront fin au programme et produiront une trace.

Exemple

Voici une fonction qui convertit une température de degrés Kelvin en degrés Fahrenheit. Puisque zéro degré Kelvin est aussi froid que possible, la fonction renonce si elle voit une température négative -

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

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/python

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

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 déclenche donc une exception -

#!/usr/bin/python

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

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. Le bloc finally 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.
   ......................

Vous ne pouvez pas également utiliser la clause else avec une clause finally.

Exemple

#!/usr/bin/python

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

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/python

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

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, 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/python

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

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

Cela produit le résultat suivant -

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

Lever des exceptions

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 "Invalid level!", level
      # The code below to this would not be executed
      # if we raise the exception

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

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

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 qu'il existe. 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 de la programmation orientée objet (POO) pour vous apporter à la vitesse -

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__ .
La class_suite comprend toutes les instructions de composant définissant les membres de classe, les attributs de données et les fonctions.

Exemple

Voici l'exemple d'une 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 d'une classe this. 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/python

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

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

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

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

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.age = 7  # Add an 'age' attribute.
emp1.age = 8  # Modify 'age' attribute.
del emp1.age  # 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, 'age')    # Returns true if 'age' attribute exists
getattr(emp1, 'age')    # Returns value of 'age' attribute
setattr(emp1, 'age', 8) # Set attribute 'age' at 8
delattr(empl, 'age')    # Delete attribute 'age'

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/python

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

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

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

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

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__: ()
Employee.__dict__: {'__module__': '__main__', 'displayCount':
<function displayCount at 0xb7c84994>, 'empCount': 2, 
'displayEmployee': <function displayEmployee at 0xb7c8441c>, 
'__doc__': 'Common base class for all employees', 
'__init__': <function __init__ at 0xb7c846bc>}

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. Mais 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/python

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

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

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

3083401324 3083401324 3083401324
Point destroyed

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

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/python

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

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

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

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

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

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

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

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 class 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. L'une des raisons pour lesquelles les méthodes parent sont remplacées est que vous souhaiterez peut-être des fonctionnalités spéciales ou différentes dans votre sous-classe.

Exemple

#!/usr/bin/python

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

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

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

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/python

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

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

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

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 sont alors pas directement visibles pour les étrangers.

Exemple

#!/usr/bin/python

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

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

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. Le module re 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. Mais 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'.

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/python
import re

line = "Cats are smarter than dogs"

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

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

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.	Faire correspondre les méthodes et la description des objets
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/python
import re

line = "Cats are smarter than dogs";

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

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

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

searchObj.group() :  Cats are smarter than dogs
searchObj.group(1) :  Cats
searchObj.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/python
import re

line = "Cats are smarter than dogs";

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

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

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

No match!!
search --> searchObj.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/python
import re

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

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

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

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 -

Sr.No.	Modèle 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 gamme.
21	(?! re) Spécifie la position à l'aide de la négation du motif. N'a pas de gamme.
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 non-mot.
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 World - First CGI Program</title>'
print '</head>'
print '<body>'
print '<h2>Hello World! This is my first CGI program</h2>'
print '</body>'
print '</html>'

Si vous cliquez sur hello.py, cela produit la sortie suivante -

Bonjour le monde! 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

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

Nous apprendrions tous les concepts en utilisant MySQL, alors parlons du module MySQLdb.

Qu'est-ce que MySQLdb?

MySQLdb est une interface pour se connecter à un serveur de base de données MySQL depuis Python. Il implémente l'API de base de données Python v2.0 et est construit sur l'API MySQL C.

Comment installer MySQLdb?

Avant de continuer, assurez-vous que MySQLdb est installé sur votre machine. Tapez simplement ce qui suit dans votre script Python et exécutez-le -

#!/usr/bin/python

import MySQLdb

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 MySQLdb
ImportError: No module named MySQLdb

Pour installer le module MySQLdb, utilisez la commande suivante -

For Ubuntu, use the following command -
$ sudo apt-get install python-pip python-dev libmysqlclient-dev For Fedora, use the following command - $ sudo dnf install python python-devel mysql-devel redhat-rpm-config gcc
For Python command prompt, use the following command -
pip install MySQL-python

Note - Assurez-vous que vous disposez du privilège 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 MySQLdb est correctement installé sur votre machine.
Vous avez parcouru le didacticiel MySQL pour comprendre les bases de MySQL.

Exemple

Voici l'exemple de connexion avec la base de données MySQL "TESTDB"

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# execute SQL query using execute() method.
cursor.execute("SELECT VERSION()")

# Fetch a single row using fetchone() method.
data = cursor.fetchone()
print "Database version : %s " % data

# disconnect from server
db.close()

Lors de l'exécution de ce script, il produit le résultat suivant sur ma machine Linux.

Database version : 5.0.45

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 la table de base de données EMPLOYÉ -

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Drop table if it already exist using execute() method.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

# Create table as per requirement
sql = """CREATE TABLE EMPLOYEE (
         FIRST_NAME  CHAR(20) NOT NULL,
         LAST_NAME  CHAR(20),
         AGE INT,  
         SEX CHAR(1),
         INCOME FLOAT )"""

cursor.execute(sql)

# disconnect from server
db.close()

Opération INSERT

Il est nécessaire 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/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to INSERT a record into the database.
sql = """INSERT INTO EMPLOYEE(FIRST_NAME,
         LAST_NAME, AGE, SEX, INCOME)
         VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

L'exemple ci-dessus peut être écrit comme suit pour créer des requêtes SQL de manière dynamique -

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to INSERT a record into the database.
sql = "INSERT INTO EMPLOYEE(FIRST_NAME, \
       LAST_NAME, AGE, SEX, INCOME) \
       VALUES ('%s', '%s', '%d', '%c', '%d' )" % \
       ('Mac', 'Mohan', 20, 'M', 2000)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

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 notre 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/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

sql = "SELECT * FROM EMPLOYEE \
       WHERE INCOME > '%d'" % (1000)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Fetch all the rows in a list of lists.
   results = cursor.fetchall()
   for row in results:
      fname = row[0]
      lname = row[1]
      age = row[2]
      sex = row[3]
      income = row[4]
      # Now print fetched result
      print "fname=%s,lname=%s,age=%d,sex=%s,income=%d" % \
             (fname, lname, age, sex, income )
except:
   print "Error: unable to fecth data"

# disconnect from server
db.close()

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/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to UPDATE required records
sql = "UPDATE EMPLOYEE SET AGE = AGE + 1
                          WHERE SEX = '%c'" % ('M')
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

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/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to DELETE required records
sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (20)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

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 à nouveau 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 l'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 à appeler 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 rollback() méthode.

Voici un exemple simple à appeler 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 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 explique le concept le plus connu de la mise en réseau - 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.

Appelez maintenant 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/python           # This is server.py file

import socket               # Import socket module

s = socket.socket()         # Create a socket object
host = socket.gethostname() # Get local machine name
port = 12345                # Reserve a port for your service.
s.bind((host, port))        # Bind to the port

s.listen(5)                 # Now wait for client connection.
while True:
   c, addr = s.accept()     # Establish connection with client.
   print 'Got connection from', addr
   c.send('Thank you for connecting')
   c.close()                # Close the connection

Un client simple

Écrivons un programme client très simple qui ouvre une connexion vers un port donné 12345 et un hôte donné. C'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.

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/python           # This is client.py file

import socket               # Import socket module

s = socket.socket()         # Create a socket object
host = socket.gethostname() # Get local machine name
port = 12345                # Reserve a port for your service.

s.connect((host, port))
print s.recv(1024)
s.close()                  # Close the socket when done

Maintenant, exécutez ce server.py en arrière-plan, puis exécutez ci-dessus client.py 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

Cela produirait le résultat suivant -

Got connection from ('127.0.0.1', 48437)
Thank you for connecting

Modules Internet Python

Une liste de quelques modules importants de la programmation Python Network / Internet.

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'e-mails 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 du courrier à 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. C'est un argument optionnel.
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 à partir de cette 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/python

import smtplib

sender = '[email protected]'
receivers = ['[email protected]']

message = """From: From Person <[email protected]>
To: To Person <[email protected]>
Subject: SMTP e-mail test

This is a test e-mail message.
"""

try:
   smtpObj = smtplib.SMTP('localhost')
   smtpObj.sendmail(sender, receivers, message)         
   print "Successfully sent email"
except SMTPException:
   print "Error: unable to send email"

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 Subject en-tête, séparé du corps de l'e-mail par une ligne vide.

Pour envoyer le courrier, vous utilisez smtpObj pour vous connecter au serveur SMTP sur la machine locale, puis utilisez la méthode sendmail avec le message, l'adresse de l'expéditeur et l'adresse de destination comme paramètres (même si les adresses de et vers sont dans le -mail lui-même, ils ne sont pas toujours utilisés pour acheminer le courrier).

Si vous n'exécutez pas de serveur SMTP sur votre ordinateur local, vous pouvez utiliser le client smtplib pour communiquer avec un serveur SMTP distant. Sauf si vous utilisez un service de messagerie Web (tel que Hotmail ou Yahoo! Mail), votre fournisseur de messagerie doit vous avoir fourni les détails du serveur de messagerie sortant que vous pouvez les fournir, comme suit -

smtplib.SMTP('mail.your-domain.com', 25)

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. Mais Python offre la possibilité d'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 un jeu de caractères pour envoyer un e-mail HTML.

Exemple

Voici l'exemple pour envoyer du contenu HTML sous forme d'e-mail. Essayez-le une fois -

#!/usr/bin/python

import smtplib

message = """From: From Person <[email protected]>
To: To Person <[email protected]>
MIME-Version: 1.0
Content-type: text/html
Subject: SMTP HTML e-mail test

This is an e-mail message to be sent in HTML format

<b>This is HTML message.</b>
<h1>This is headline.</h1>
"""

try:
   smtpObj = smtplib.SMTP('localhost')
   smtpObj.sendmail(sender, receivers, message)         
   print "Successfully sent email"
except SMTPException:
   print "Error: unable to send email"

Envoi de pièces jointes par e-mail

Pour envoyer un e-mail avec un contenu mixte, il faut définir Content-type en-tête à multipart/mixed. Ensuite, les sections de texte et de pièce jointe peuvent être spécifiées 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 base64 avant la transmission.

Exemple

Voici l'exemple, qui envoie un fichier /tmp/test.txten pièce jointe. Essayez-le une fois -

#!/usr/bin/python

import smtplib
import base64

filename = "/tmp/test.txt"

# Read a file and encode it into base64 format
fo = open(filename, "rb")
filecontent = fo.read()
encodedcontent = base64.b64encode(filecontent)  # base64

sender = '[email protected]'
reciever = '[email protected]'

marker = "AUNIQUEMARKER"

body ="""
This is a test email to send an attachement.
"""
# Define the main headers.
part1 = """From: From Person <[email protected]>
To: To Person <[email protected]>
Subject: Sending Attachement
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary=%s
--%s
""" % (marker, marker)

# Define the message action
part2 = """Content-Type: text/plain
Content-Transfer-Encoding:8bit

%s
--%s
""" % (body,marker)

# Define the attachment section
part3 = """Content-Type: multipart/mixed; name=\"%s\"
Content-Transfer-Encoding:base64
Content-Disposition: attachment; filename=%s

%s
--%s--
""" %(filename, filename, encodedcontent, marker)
message = part1 + part2 + part3

try:
   smtpObj = smtplib.SMTP('localhost')
   smtpObj.sendmail(sender, reciever, message)
   print "Successfully sent email"
except Exception:
   print "Error: unable to send email"

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 surcharge de mémoire; 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 l'endroit où, dans son contexte, il s'exécute actuellement.

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.

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/python

import thread
import time

# Define a function for the thread
def print_time( threadName, delay):
   count = 0
   while count < 5:
      time.sleep(delay)
      count += 1
      print "%s: %s" % ( threadName, time.ctime(time.time()) )

# Create two threads as follows
try:
   thread.start_new_thread( print_time, ("Thread-1", 2, ) )
   thread.start_new_thread( print_time, ("Thread-2", 4, ) )
except:
   print "Error: unable to start thread"

while 1:
   pass

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

Thread-1: Thu Jan 22 15:42:17 2009
Thread-1: Thu Jan 22 15:42:19 2009
Thread-2: Thu Jan 22 15:42:19 2009
Thread-1: Thu Jan 22 15:42:21 2009
Thread-2: Thu Jan 22 15:42:23 2009
Thread-1: Thu Jan 22 15:42:23 2009
Thread-1: Thu Jan 22 15:42:25 2009
Thread-2: Thu Jan 22 15:42:27 2009
Thread-2: Thu Jan 22 15:42:31 2009
Thread-2: Thu Jan 22 15:42:35 2009

Bien qu'il soit très efficace pour le threading de bas niveau, le module thread est très limité par rapport au module de 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/python

import threading
import time

exitFlag = 0

class myThread (threading.Thread):
   def __init__(self, threadID, name, counter):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.counter = counter
   def run(self):
      print "Starting " + self.name
      print_time(self.name, self.counter, 5)
      print "Exiting " + self.name

def print_time(threadName, counter, delay):
   while counter:
      if exitFlag:
         threadName.exit()
      time.sleep(delay)
      print "%s: %s" % (threadName, time.ctime(time.time()))
      counter -= 1

# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# Start new Threads
thread1.start()
thread2.start()

print "Exiting Main Thread"

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

Starting Thread-1
Starting Thread-2
Exiting Main Thread
Thread-1: Thu Mar 21 09:10:03 2013
Thread-1: Thu Mar 21 09:10:04 2013
Thread-2: Thu Mar 21 09:10:04 2013
Thread-1: Thu Mar 21 09:10:05 2013
Thread-1: Thu Mar 21 09:10:06 2013
Thread-2: Thu Mar 21 09:10:06 2013
Thread-1: Thu Mar 21 09:10:07 2013
Exiting Thread-1
Thread-2: Thu Mar 21 09:10:08 2013
Thread-2: Thu Mar 21 09:10:10 2013
Thread-2: Thu Mar 21 09:10:12 2013
Exiting Thread-2

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/python

import threading
import time

class myThread (threading.Thread):
   def __init__(self, threadID, name, counter):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.counter = counter
   def run(self):
      print "Starting " + self.name
      # Get lock to synchronize threads
      threadLock.acquire()
      print_time(self.name, self.counter, 3)
      # Free lock to release next thread
      threadLock.release()

def print_time(threadName, delay, counter):
   while counter:
      time.sleep(delay)
      print "%s: %s" % (threadName, time.ctime(time.time()))
      counter -= 1

threadLock = threading.Lock()
threads = []

# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# Start new Threads
thread1.start()
thread2.start()

# Add threads to thread list
threads.append(thread1)
threads.append(thread2)

# Wait for all threads to complete
for t in threads:
    t.join()
print "Exiting Main Thread"

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

Starting Thread-1
Starting Thread-2
Thread-1: Thu Mar 21 09:11:28 2013
Thread-1: Thu Mar 21 09:11:29 2013
Thread-1: Thu Mar 21 09:11:30 2013
Thread-2: Thu Mar 21 09:11:32 2013
Thread-2: Thu Mar 21 09:11:34 2013
Thread-2: Thu Mar 21 09:11:36 2013
Exiting Main Thread

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/python

import Queue
import threading
import time

exitFlag = 0

class myThread (threading.Thread):
   def __init__(self, threadID, name, q):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.q = q
   def run(self):
      print "Starting " + self.name
      process_data(self.name, self.q)
      print "Exiting " + self.name

def process_data(threadName, q):
   while not exitFlag:
      queueLock.acquire()
         if not workQueue.empty():
            data = q.get()
            queueLock.release()
            print "%s processing %s" % (threadName, data)
         else:
            queueLock.release()
         time.sleep(1)

threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three", "Four", "Five"]
queueLock = threading.Lock()
workQueue = Queue.Queue(10)
threads = []
threadID = 1

# Create new threads
for tName in threadList:
   thread = myThread(threadID, tName, workQueue)
   thread.start()
   threads.append(thread)
   threadID += 1

# Fill the queue
queueLock.acquire()
for word in nameList:
   workQueue.put(word)
queueLock.release()

# Wait for queue to empty
while not workQueue.empty():
   pass

# Notify threads it's time to exit
exitFlag = 1

# Wait for all threads to complete
for t in threads:
   t.join()
print "Exiting Main Thread"

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é en 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 en 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 le DOM peut le faire lorsqu'il travaille avec de gros fichiers. D'un autre côté, l'utilisation exclusive de DOM peut vraiment tuer vos ressources, surtout si elle est utilisée sur beaucoup de 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) sont transmis des données de caractère 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étecté par le système.

xml.sax.make_parser( [parser_list] )

Voici le détail 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 le détail 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 le détail 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/python

import xml.sax

class MovieHandler( xml.sax.ContentHandler ):
   def __init__(self):
      self.CurrentData = ""
      self.type = ""
      self.format = ""
      self.year = ""
      self.rating = ""
      self.stars = ""
      self.description = ""

   # Call when an element starts
   def startElement(self, tag, attributes):
      self.CurrentData = tag
      if tag == "movie":
         print "*****Movie*****"
         title = attributes["title"]
         print "Title:", title

   # Call when an elements ends
   def endElement(self, tag):
      if self.CurrentData == "type":
         print "Type:", self.type
      elif self.CurrentData == "format":
         print "Format:", self.format
      elif self.CurrentData == "year":
         print "Year:", self.year
      elif self.CurrentData == "rating":
         print "Rating:", self.rating
      elif self.CurrentData == "stars":
         print "Stars:", self.stars
      elif self.CurrentData == "description":
         print "Description:", self.description
      self.CurrentData = ""

   # Call when a character is read
   def characters(self, content):
      if self.CurrentData == "type":
         self.type = content
      elif self.CurrentData == "format":
         self.format = content
      elif self.CurrentData == "year":
         self.year = content
      elif self.CurrentData == "rating":
         self.rating = content
      elif self.CurrentData == "stars":
         self.stars = content
      elif self.CurrentData == "description":
         self.description = content
  
if ( __name__ == "__main__"):
   
   # create an XMLReader
   parser = xml.sax.make_parser()
   # turn off namepsaces
   parser.setFeature(xml.sax.handler.feature_namespaces, 0)

   # override the default ContextHandler
   Handler = MovieHandler()
   parser.setContentHandler( Handler )
   
   parser.parse("movies.xml")

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 schientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Stars: 10
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Stars: 2
Description: Viewable boredom

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 des 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.

#!/usr/bin/python

from xml.dom.minidom import parse
import xml.dom.minidom

# Open XML document using minidom parser
DOMTree = xml.dom.minidom.parse("movies.xml")
collection = DOMTree.documentElement
if collection.hasAttribute("shelf"):
   print "Root element : %s" % collection.getAttribute("shelf")

# Get all the movies in the collection
movies = collection.getElementsByTagName("movie")

# Print detail of each movie.
for movie in movies:
   print "*****Movie*****"
   if movie.hasAttribute("title"):
      print "Title: %s" % movie.getAttribute("title")

   type = movie.getElementsByTagName('type')[0]
   print "Type: %s" % type.childNodes[0].data
   format = movie.getElementsByTagName('format')[0]
   print "Format: %s" % format.childNodes[0].data
   rating = movie.getElementsByTagName('rating')[0]
   print "Rating: %s" % rating.childNodes[0].data
   description = movie.getElementsByTagName('description')[0]
   print "Description: %s" % description.childNodes[0].data

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 schientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Description: Viewable boredom

Pour un détail complet sur la documentation des 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 plus importants sont énumérés 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 wxWindows http://wxpython.org.
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/python

import Tkinter
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.

Étudions ces widgets en détail -

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

Étudions-les brièvement -

Gestion de la géométrie

Tous les widgets Tkinter ont accès à des 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.

Étudions brièvement les méthodes de gestion de la géométrie -

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 python2.5-dev .
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 tels que les développeurs Python les voient aux 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, qui vous donne 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 doit s'agir 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 la fonction Py_InitModule3 -

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.

Mettre tout cela ensemble 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 forme source et construits et installés via un script de configuration généralement appelé setup.py comme suit.

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 afin d'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é votre extension, vous pourrez importer et appeler cette extension dans votre script Python comme suit -

#!/usr/bin/python
import helloworld

print helloworld.helloworld()

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;
}

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 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 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 caupturé à 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 au format 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}.