**Ceci est une ancienne révision du document !**

Pour commencer, quelques remarques générales :

  • Python n'a qu'un seul type de fichier source, comme Java ou C# (et contrairement à C/C++).
  • Les identificateurs sont sensibles à la casse

Déclaration de fonction

def nom_fonction ( parametre = valeur_defaut ) :
    ''' Description de la fonction, cette partie s'appelle une docstring
    la docstring peut s'étendre sur plusieurs ligne est se termine par '''
 
    ensuite, tout ce qui est tabulé est le corps de la fonction
    quand on arrête de tabuler, la fonction est finie !

Appel de fonction

Lors d'un appel de fonction, on peut passer les paramètres dans n'importe quel ordre si on les nomme. Si les paramètres ne sont pas nommés, ils sont considérés comme passés dans l'ordre de la déclaration. On peut commencer à passer les paramètres dans l'ordre de la déclaration et commencer à les nommer à un moment mais pas l'inverse.

def ma_fonction( param1, param2, param3 ):
    print('param1 = {0}, param2 = {1}, param3 = {2}'.format(param1,param2,param3)
 
ma_fonction(1,2,3)
ma_fonction(1,param3=2,param2=3)

produira l'affichage :

param1 = 1, param2 = 2, param3 = 3
param1 = 1, param2 = 3, param2 = 3

Déclaration de variable

Une variable est déclarée par son affectation. Python type automatiquement en fonction de la valeur affectée.

ma_chaine = "Je suis une chaîne"
mon_autre_chaine = 'moi aussi'
un_entier = 5

Importer un module

Les modules constituent la boite à outils du développeur Python. On importe un module dans un script avec :

import nom_module

Les modules sont cherchés dans la variable sys.path (il faut bien sûr importer le module sys pour y accéder !).

Tout est objet

En Python, tout est objet. Et à ce titre, tout peut avoir des méthodes et des attributs. Par exemple, les fonctions sont elles-même des objets et elles ont un attribut doc qui retourne leur docstring.

Les exceptions

La gestion des erreurs en Python se fait au moyen d'exceptions. Les exceptions sont levées avec la syntaxe :

raise TypeExeception()

par exemple :

raise ValueError('nombre trop grand')

et elles sont capturées par :

try
    ...
except TypeException:
    ...

Un exemple typique d'utilisation d'exception, c'est le traitement de l'import d'un module :

try
    import un_module
except ImportError:
    un_module = None
 
if un_module:
    ...
else
    ...

Les modules

Chaque script est un module en lui-même. A l'intérieur d'un script, la variable spéciale __name__ vaut le nom du module s'il a été importé et la valeur “__main__” si on est dans le module principal.

Les types de données

Les principaux types de données sont :

  • Booléens : True ou False
  • Nombres : Entiers (ex : 1), Flottants (ex : 1.0), Fractions (ex : 1/3)
  • Chaînes : Toujours UNICODE
  • Octets et tableaux d'octets
  • Listes : suites ordonnées d'éléments
  • Tuples : suites ordonnées immuables d'éléments
  • Ensembles (sets) : groupes non ordonnés d'éléments
  • Dictionnaires : groupes non ordonnés de couples clé, valeur
  • et bien sûr toutes les classes (puisque tout est objet)

Pour connaître le type d'une variable, on dispose de l'opérateur type. Par exemple type(True) renvoie <class 'bool'>.

La conversion entier vers flottant se fait avec l'opérateur float() et l'inverse avec int() (attention, int() tronque le flottant, il n'y a pas d'arrondi !)

Les opérateurs classiques sont supportés (+, -, , /) ainsi que : : la division entière ** : l'exposant et %'' : le modulo Les listes sont déclarées avec des crochets. On accède à leurs éléments avec l'indice (base 0) entre crochets. On peut accéder aux élément à l'envers avec un indice négatif. [-1] est donc toujours le dernier élément d'une liste non vide. On peut découper une liste avec l'opérateur crochet et le deux-points : <code python> maliste = [ 1, 2, 3, 4, 5, 6 ] maliste[0] # → 1 maliste[1] # → 2 maliste[-1] # → 6 maliste[0:2] # → [ 1, 2, 3 ] maliste[:3] # → [ 1, 2, 3, 4 ] maliste[5:] # → [ 6 ] maliste[:] # → [ 1, 2, 3, 4, 5, 6 ] </code>