Introduction à Python

Wingel Grégory

FSUGAr

Historique

fin 1989
Guido Van Rossum (Free Software award 2001)
Monty Python

Implémentations

CPython
Jython
Python.NET

CPython : Classic Python

Rapide
Robuste
Ecrit en C
Portable
Placé sous la licence Open Source CNRI(Corporation for National Research Initiatives) (1.6) puis sortie de Python 1.6.1 dont la licence est compatible GPL (2000).

Généralement appelé tout simplement Python.

Jython

Compilation du code écrit en Python en bytecode java
plus lent que CPython
Permet d'utiliser n'importe quelle classe Java (standard, personelle,...), héritage de classes java.

http://www.jython.org/

Python.NET (IronPython)

Plateforme .NET de Microsoft
Semblable à Jython mais pour une compilation en MSIL(Microsoft Intermediate Language)

http://ironpython.com/

Particularités

Pas de ;
Blocs délimités par les indentations
Nombre incalculable de bibliothèques pour mysql, re, gmail...)

et on importe les bibliothèques aveci mport * from biblio
pour toutes les méthodes associées ou from blio import methode.

Littéraux:

Séquences d'éléments:

Les tuples

Séquence immuable, pouvant contenir des types différents

(42,)           # Tuple d'un élément
(42,"FSUGAr")   # Tuple de deux éléments
()              # Tuple vide
tuple('FSUGAr') # équivalent à
('F','S','U','G','A','r')

Séquences d'éléments:

Les listes

Séquence modifiable, pouvant contenir des types différents

[42,'FSUGAr',4.2] # Liste de 3 éléments
[]                # Liste vide
list('FSUGAr')    # équivalent à
['F','S','U','G','A','r']

Séquences d'éléments:

Les dictionnaires

Mapping, clé et valeur associée

{'a':42,'b':"FSUGAr",'leet':1337} # Chaîne comme clé
{1:2,3:4} # Entier comme clé
dict([[1, 2],[3, 4]]) # Equivalent

Séquences d'éléments:

Accès et modification : listes

foo = [1, 2, 3, 4]
foo[1]   # 2
foo[-1]  # 4
foo[1:2] # ['2']
foo[1:3] # ['2','3']
foo[1] = 42 # [1, 42, 3, 4]
foo[1:3] = [10, 11, 12] # [1, 10, 11, 12, 4]
del foo[1] # [1, 11, 12, 4

et plein de méthode comme count(x), reverse(), pop([i])...

Séquences d'éléments:

Accès et modification : dictionnaires

foo = {'a':42,'b':"FSUGAr",'leet':1337}
foo['a'] = "toto"
foo['foo'] = "bar" # ajout dans le dictionnaire

Et plein de méthodes keys(), clear()...

Affichage

print "Hello FSUGAr" # Hello FSUGAr
foo = "FSUGAr"
print "Hello",foo   # Hello FSUGAr
print "Hello"+foo   # HelloFSUGAr

Boucles

Si dict est un dictionnaire
for cle, valeur in dict.items(): # items methode qui retourne une liste
  print dict[cle]                # de paires clé, valeur
  
for i in range(3):
  print "ok"        # affiche 3 fois ok

Il existe aussi while.

Conditions

if i in liste:
  print "ok"
else:
  print "ko"

if i in liste:
  print "dans la liste"
elif i in liste2:
  print "dans la deuxième liste"
else:
  print "dans aucune liste"

Fonctions

def fonction(arguments):
  instructions
  return valeur # Facultatif
  
def carre(x):
  return x*x

def somme(*nombres):
  total = 0
  for nombre in nombres:
    total += nombre
  return total

  print somme(1,2,3,4) # retourne 10

Orienté Objet

class Camion:
    """
    La Classe représente un camion
    """
    
    __marque  = ""
    __couleur = ""
    
    # constructeur
    def __init__(self, marque, couleur):        
        self.__marque  = marque
        self.__couleur = couleur
    
    # une méthode repeindre
    def repeindre(self, couleur):
        self.__couleur = couleur
    
    # affichage
    def __str__(self):
        return "Marque: " + self.__marque + " et couleur: " + self.__couleur
    
    # destructeur
    def __del__(self):
        pass # ne rien faire

Orienté Objet : suite

if __name__ == "__main__":
    
    cam1 = Camion("Man", "Noir")
    cam2 = Camion("Mercedes", "Rouge")
    
    garage = [cam1, cam2]
    
    cam2.repeindre("Jaune")
    
    for cam in garage:
        print cam

Affichage:

Marque: Man et couleur: Noir
Marque: Mercedes et couleur: Jaune

Il supporte l'héritage multiple et la surcharge des opérateurs.

17/12/2005