Accueil > Divers > Une introduction à Python

Une introduction à Python

Le langage Python a été conçu à partir de 1989 par Guido van Rossum, et est actuellement maintenu par la Python Software Foundation, sous la coupe de son benevolant dictator for life.Python

La principale philosophie derrière le langage est d’être simple à utiliser, aussi bien par sa lecture que son écriture. D’ailleurs, son nom vient de l’émission “Monty Python’s Flying Circus”, comme pour illustrer l’état d’esprit de ses utilisateurs.
Historiquement successeur du langage ABC, il s’en sert à la fois comme modèle et anti-modèle, reprenant certains traits comme la structure par indentation, mais évitant d’autres tels que son caractère monolithique.

Historique

La première version est publiée en janvier 1994, et inclut notamment la gestion d’exceptions et quelques outils repris de Lisp. D’autres éléments de ce langage y seront ajoutés par la suite.
La deuxième version est publiée en octobre 2000, et introduit plusieurs éléments repris de langages fonctionnels, tels que la liste en compréhension, et se rapproche du Haskell du point de vue de la structure, à la différence de la préférence pour les mots clés plutôt que la ponctuation. C’est également dans cette version qu’apparait le garbage collector. Dans la version 2.2, les types et les classes sont regroupés dans une hiérarchie unique; le langage devenant véritablement orienté objet.
La troisième version est publiée en décembre 2008, avec pour objectif de retirer les défauts du langage, ainsi que de retirer les implémentations redondantes de certaines fonctionnalités. Malheureusement, certaines modifications ne permettant pas de conserver une compatibilité descendante, les versions 2 et 3 doivent coexister pour une certaine durée.

Adoption

Bien que peu utilisé en France (en comparaison des USA par exemple) malgré son ancienneté (plus vieux que Java!), le langage est pourtant utilisé ou supporté (pour des scripts externes) dans de nombreuses applications, dont:

  • Bazaar (gestionnaire de sources)
  • BitTorrent (client P2P)
  • Blender 3D (modélisation et animation 3D)
  • Civilization IV (jeu vidéo)
  • Code_Aster (simulateur en mécanique des structures, développé par EDF)
  • Dropbox (service d’hébergement en ligne)
  • Google Search/Groups/GMail/Maps (services de recherche/utilisateur/messagerie/cartographie en ligne)
  • Mercurial (gestionnaire de sources)
  • OpenMDAO (framework d’analyse combinée, développé par la NASA)
  • Vim (éditeur de texte)
  • YUM (gestionnaire de paquets RPM)

Son interpréteur est notamment fourni par défaut dans (presque) toutes les distributions GNU/Linux.

Caractéristiques

Parmi les principales caractéristiques du langage, on peut notamment citer:

  • le multi-paradigme
  • la structure par indentation
  • le duck-typing
  • l’intégration de/à d’autres langages
  • le choix d’interpréter (par défaut), compiler juste-à-temps ou préalablement le code

Python est donc extrêmement souple, et produit du code concis et lisible.

Paradigmes

Fonctionnel

Notez comment les blocs de code sont définis par l’indentation.
On pourra également remarquer l’affectation et la modification simultanée de plusieurs variables, ainsi que l’utilisation de range() pour générer une liste de valeur (ici de 0 à x).

def fibonacci(x):
    a, b = 0, 1
    if x < 0:
        return "x must be a positive integer"
    for i in range(x):
        a, b = b, a+b
    return a
 
print(fibonacci(200))
Orienté objet

En Python, les variables d’instance (données membres) doivent être définies dans le constructeur (__init__). Des variables de classe (données membres statiques) peuvent être définies dans le corps de la classe, similairement aux données membres de classe dans d’autres langages.

class BankAccount:
    def __init__(self, initial_balance=0):
        self.balance = initial_balance
    def deposit(self, amount):
        self.balance += amount
    def withdraw(self, amount):
        self.balance -= amount
    def overdrawn(self):
        return self.balance < 0
 
my_account = BankAccount(15)
my_account.withdraw(5)
print(my_account.balance)
Orienté aspect

L’exemple ci-dessous présente le tissage d’un aspect à travers l’utilisation d’un Décorateur, qui intercepte ici toute exception levée par la fonction sur laquelle il est appliqué.

def logging_exception(function):
    def catch_n_log(*args):
        try:
            return function(*args)
        except Exception as e:
            print("Exception occured in " + str(function)
              + " with parameters " + str(args)
              + " : " + str(e))
 
    return catch_n_log
 
@logging_exception
def divide(a, b):
    return a / b
 
print(divide(30, 0))

Spécificités

En plus de supporter plusieurs paradigmes, Python permet également quelques manipulations intéressantes.

Comparaison multiple
def check_inputs(start, end):
    return 0 <= start <= end <= 10
Générateur
x = [i for i in range(1, 100) if i % 7 == 0]
Manipulations de tableaux

Ca marche aussi avec les chaines de caractères!

def manipule(array):
    print("Le premier element est ", array[0])
    print("Les trois elements suivants sont ", array[1:4])
    print("Le dernier element est ", array[-1])
    print("Les elements pairs sont ", array[1::2])
    print("Et dans l'autre sens, ca donne ", array[::-1])
 
manipule([4, 6, 8, 10, 2])
manipule("Hello")
Raw String

Il s’agit d’une chaine dont aucun caractère n’est interprété, y compris les caractères d’échappement.

import re
 
def extract_domain(url):
    return re.search(r'^[^/]*\.([^\./]+\.[^\./]+)/?.*', url).group(1)
 
extract_domain('blog.viseo.com')
Retour multiple
from math import cos, sin, sqrt, pi
 
def to_cartesian(ro, theta):
    x = ro * cos(theta)
    y = ro * sin(theta)
    return x, y
 
a, b = to_cartesian(sqrt(2), pi/4)
Zen of Python

On peut le voir comme la philosophie derrière le langage. Il a d’ailleurs été intégré parmi les guides de développement, ainsi que dans le langage même à travers un Easter egg (accessible en mode console uniquement).

import this
    The Zen of Python, by Tim Peters

    Beautiful is better than ugly.
    Explicit is better than implicit.
    Simple is better than complex.
    Complex is better than complicated.
    Flat is better than nested.
    Sparse is better than dense.
    Readability counts.
    Special cases aren't special enough to break the rules.
    Although practicality beats purity.
    Errors should never pass silently.
    Unless explicitly silenced.
    In the face of ambiguity, refuse the temptation to guess. There should be one-- and preferably only one --obvious way to do it.
    Although that way may not be obvious at first unless you're Dutch.
    Now is better than never.
    Although never is often better than right now.
    If the implementation is hard to explain, it's a bad idea.
    If the implementation is easy to explain, it may be a good idea.
    Namespaces are one honking great idea -- let's do more of those!

Python2 vs Python3

La version 3 de Python a introduit une rupture dans la rétrocompatibilité, à travers divers changements dans le langage, par exemple dans l’utilisation de types, le nommage ou la suppression de certains modules, ou l’appel à certaines fonctions courantes. Néanmoins, le module __future__ a été été introduit dans Python2 afin d’incorporer ces changements dans du code existant, bien qu’il soit prévu de ne plus backport les prochaines nouveautés de Python3 dans ce module à l’avenir.

from __future__ import division, absolute_import, print_function, unicode_literals

Produire en Python

Cette partie présente quelques informations intéressantes concernant les habitudes et les conventions de codage, ainsi que les outils de développement et de déploiement pour les applications codées dans ce langage.

Installation

Windows

Les différentes versions de Python à partir de la 2.0 peuvent être téléchargées depuis le site officiel. Lors de l’installation, les fichiers sont extraits par défaut vers un répertoire C:/PythonX.X/, où X.X est la version de Python, permettant d’installer plusieurs versions du langage.
Par ailleurs, afin d’éviter des conflits, le processus d’installation n’ajoute pas automatiquement le répertoire de Python au PATH système. Il faudra alors appeler directement l’interpréteur python, pour l’exécution, depuis son répertoire, ou préalablement ajouter ce répertoire au PATH système.

Linux

La plupart des distributions Linux possèdent par défaut les paquets pour Python: python pour la dernière version 3.x, et python2 pour la dernière version 2.x, disponibles dans les dépôts.
Pour une version spécifique, il faudra télécharger les sources depuis le site officiel et les compiler localement. Alternativement, certaines versions peuvent être disponibles en dépôt, selon la distribution utilisée (exemple avec Arch Linux).

Environnements de développement

Un outil de développement appelé IDLE est fourni avec chaque révision de Python. Celui-ci étant simpliste (et vraisemblablement peu stable), les développeurs se tournent généralement vers d’autres éditeurs, IDEs et plug-ins, dont:

  • Eclipse + PyDEV
  • Emacs (python.el ou python-mode.el)
  • Geany
  • JetBrains PyCharm
  • Netbeans + Python4NetBeans (Python n’est plus supporté par défaut depuis la version 7.0)
  • Notepad++
  • Vim (+ pydoc)

Convention de codage

Afin de faciliter le partage d’un code Python, une convention de codage a été réalisée, dont les principaux points sont:

  • Indenter par 4 espaces, éviter les tabulations.
  • Éviter les lignes de plus de 79 caractères.
  • Séparer les classes, fonctions, et grands blocs de code par une ligne vide.
  • Éviter de mettre code et commentaire sur une même ligne.
  • Documenter le code.
  • Laisser un espace autour des opérateurs et après les virgules de séparation.
  • Nommer classes et fonctions de façon consistante. Utiliser le CamelCase pour les classes, et des miniscules avec underscores pour les fonctions et les méthodes. Préférer utiliser self en premier paramètre de méthode d’instance.
  • Éviter les encodages exotiques et les caractères non-ASCII, surtout dans des développements internationaux (Python utilise UTF-8 par défaut).

Exécution

Un script Python doit être soumis à un interpréteur pour être exécuté, en appelant simplement cet interpréteur avec l’adresse du script en paramètre. Si plusieurs versions de Python sont installées, il peut être préférable d’appeler explicitement le bon interpréteur.

python script.py
C:\Python31\python.exe script.py
Exécution sur version spécifique

Sous Linux, il est possible de préciser la version de Python à utiliser dans le script même, via l’utilisation d’un shebang. Bien que l’on puisse y préciser l’adresse directe de l’interpréteur à utiliser, on préférera la formulation suivante à fin de compatibilité entre les distributions:

#!/usr/bin/env python3.1

Une fois le script rendu exécutable, le lancer appellera l’interpréteur spécifié dans le script pour son exécution.

Windows n’étant pas capable d’interpréter cette instruction, il est nécessaire de choisir la version de Python en appelant explicitement son interpréteur.
L’utilisation du shebang peut toutefois s’avérer intéressante si le script est destiné à être déployé sur un serveur. En effet, les serveurs logiciels supportant le Common Gateway Interface (soit presque tous) et fonctionnant sous Windows sont également capables d’interpréter cette instruction, évitant ainsi d’avoir à inscrire l’adresse de l’interpréteur dans le PATH.

Documentation

Categories: Divers Tags:
  1. Ioan Bucur
    02/06/2015 à 15:28 | #1

    Cool, merci!

  1. Pas encore de trackbacks


1 × = sept