Cours gratuits » Cours informatique » Cours programmation » Cours Python

Débuter et progresser avec la programmation PYTHON

Documents similaires

Python livre pour debuter la programmation avec le language

Formation complet Merise pour debuter et progresser

Formation pour débuter en programmation web python

Initiation à la programmation avec Python et C++

Ebook d’introduction au Framework Flask pour Python avec exemples

Introduction à la programmation et calcul avec le langage Python

Apprendre à créer des applications avec le langage de programmation Python

Cours avancé de la programmation avec le langage Python

Débuter et progresser avec la programmation PYTHON

3.53.5 étoiles sur 5 a partir de 1 votes.
Votez ce document: ☆☆☆☆☆★★★★★

Lien de téléchargement

La syntaxe Python

Guillaume Wisniewski septembre 2010

Résumé

Ce document a pour objectif de présenter rapidement la syntaxe de Python ainsi que certaines constructions et bibliothèques que nous utiliserons dans ce cours. Une introduction plus détaillée au langage est disponible à l’url

Table des matières

1 Exécuter un programme python

Il y a deux manière d’exécuter un programme python :

– soit en sauvegardant le programme dans un fichier (ayant généralement l’extension .py) et en exécutant la commande : python .

– soit en utilisant directement l’interpréteur : en lan¸cant le programme python il est possible d’entrer directement des commandes qui seront exécutées au fur et à mesure de leur saise.

Dans les exemples de ce document, nous utiliserons cette dernière méthode : les lignes commen¸cant par In [1]: correspondent aux commandes qui sont saisies et les autres aux « réponses » de l’interpréteur.

2 Types standards

2.1 Type de base

Python est un langage typé dynamiquement : le type d’une variable est déterminé par l’interpréteur au moment de l’exécution et n’a pas besoin d’être déclaré :

In [17]: a = 1 # a est de type integer

In [18]: b = 2.0 # b est de type float

In [19]: a = "le chat" # a est maitenant de type string

In [1]: c = 3 + 2j # nombre complexes

In [2]: print c Out[2]: (3+2j)

In [3]: d = 1 == 2 # booléens

In [4]: d # dans l’interpréteur, le print n’est pas obligatoire Out[4]: False

In [1]: e, f = 3, 2.1

On remarquera que :

– le marqueur de fin de ligne est le retour chariot et non le point virgule comme dans la plupart des autres langage;

– le caractère # permet d’indiquer un commentaire;

– il est possible d’effectuer plusieurs assignations simultanément.

2.2 Collections

Python fournit de manière standard différents types de collections. Chacune de ces collections est un objet et il est donc possible d’utiliser les méthodes d’exploration dynamique pour connaˆ?tre la liste des méthodes disponibles (cf. paragraphe ??).

2.2.1 Listes

a = [1, 2, 3, 4, "maman", 5.1]

Les listes peuvent stocker, de manière ordonnée, des éléments de différents types.

Il est possible :

– d’accéder directement à un élément

In [4]: r = [1, 2, 3, 7]

In [5]: r[2]

Out[5]: 3

In [6]: r[-1]

Out[6]: 7

In [11]: r[-3] Out[11]: 2

En utilisant des indices négatifs, il est possible d’accéder aux éléments en partant de la fin (l’indice ?1 correspond au dernier élément, ?2 à l’avantdernier, )

– d’extraire des sous-listes :

# tous les éléments renvoyés sont des listes

In [4]: r

Out[4]: [1, 2, 3, 7]

In [7]: r[3:] Out[7]: [7]

In [8]: r[2:]

Out[8]: [3, 7]

In [9]: r[:2]

Out[9]: [1, 2]

In [10]: r[::2]

Out[10]: [1, 3]

La syntaxe générale est : [indice début:indice fin:pas]. Ces paramètres sont facultatifs : par défaut, indice début correspond au premier indice de la liste (0), indice fin au dernier indice et pas à 1. En utilisant des pas négatifs, il est possible de parcourir la liste à l’envers. Par exemple a[::-1] permet d’inverser la liste (on parcours la liste du début à la fin avec un pas de ?1).

– d’ajouter des éléments à une liste

In [12]: a = [1, 2, 3]

In [13]: a.append(4)

In [14]: print a

[1, 2, 3, 4]

In [15]: b = [5, 6]

In [16]: a + b

Out[16]: [1, 2, 3, 4, 5, 6]

– de trier une liste

In [2]: r = [2, 7, 1, 3]

# la liste est en triée « en place »

# => renvoie None

In [3]: r.sort()

# crée une nouvelle liste triée In [5]: a = sorted(r)

In [4]: print r

Out[4]: [1, 2, 3, 7]

– de transformer une liste en chaˆ?ne de caractères :

In [7]: a = ["le", "petit", "chat"]

In [8]: "-".join(a)

Out[8]: ’le-petit-chat’

2.2.2 Des dictionnaires

Les dictionnaires permettent d’associer deux objets quelconques : le premier objet définit une clé; le suivant la valeur qui lui est associé.

In [29]: d = {’a’: 1, ’b’:1.2, ’c’:1j}

In [30]: d[’b’]

Out[30]: 1.2

In [31]: d[’d’] = ’d’

In [32]: d

Out[32]: {’a’: 1, ’b’: 1.2, ’c’: 1j, ’d’: ’d’}

In [33]: d.keys()

Out[33]: [’a’, ’c’, ’b’, ’d’]

In [34]: d.values()

Out[34]: [1, 1j, 1.2, ’d’]

2.2.3 Les chaˆ?nes de caractères

a = ’Mine’ a = "Chris’s"

# cha^?nes sur plusieurs lignes a = ’’’Mine and not his’’’

a = """Mine and Chris’s"""

– les chaˆ?nes de caractères sont des listes :

In [35]: s = ’Python is cool’

In [36]: s[-4:] Out[36]: ’cool’

– python fournit plusieurs méthodes intéressante :

In [1]: a = "Python is cool"

In [2]: a.replace("cool", "powerful")

Out[2]: ’Python is powerful’

In [3]: a.lower()

Out[3]: ’python is cool’

Nous verrons au paragraphe ?? comment découvrir facilement la liste complète des méthodes disponibles.

– substitution de chaˆ?ne de caractères

In [38]: ’An integer: %i; a float: %f; another string: %s’ % (1, 0.1, ’string’

Out[38]: ’An integer: 1; a float: 0.100000; another string: string’

)

– construction d’une liste :

In [9]: "1;2;3;4".split(";")

Out[9]: [’1’, ’2’, ’3’, ’4’]

In [11]: "1 2 3 4".split()

Out[11]: [’1’, ’2’, ’3’, ’4’]

split(sep) retourne la liste des mots contenus dans une chaˆ?ne de caractères en supposant que ceux-ci sont séparés par sep. Si sep n’est pas fournit split considère que les mots sont séparés par un ou plusieurs espaces.

3 Structure de contrôle

3.1 Conditions

In [23]: if a == 1:

.: print 1

.: elif a == 2:

.: print 2

.: else:

.: print "beaucoup"

.: beaucoup

– soit sur des expressions booléennes

– soit sur des objets : un objet est vrai si sa valeur n’est pas nulle ou si sa longueur est strictement plus grande que 0 (pour les séquences) :

In [1]: a = []

In [2]: if a: : print 1

: else:

: print 2

– il est également possible de tester si un objet appartient à une collection en utilisant le mot-clé in

In [19]: a = [1, 2, 3, 5]

In [20]: 2 in a

Out[20]: True

# pour les dictionnaires in teste l’existence d’une clé

In [21]: b = {"name": "Guillaume", 2:3}

In [22]: 2 in b

Out[22]: True

In [23]: "Guillaume" in b Out[23]: False

# pour les string

In [1]: a = "le chat et le chien"

In [2]: "chien" in a

Out[2]: True

In [3]: "poisson" in a

Out[3]: False

3.2 Boucles

Pour itérer sur un index :

In [24]: for i in range(4):

.: print i

Cette boucle est équivalente au code C suivant :

int i = 0; //

for (i = 0; i < 4; i++) { printf("%d\n", i);

}

La fonction range permet de construire une liste d’entiers consécutifs : range(4) = [0, 1, 2, 3]. Il est possible d’itérer sur n’importe quelle séquence :

In [25]: for word in [’cool’, ’powerful’, ’readable’]:

.: print(’Python is %s’ % word)

Python is cool

Python is powerful

Python is readable

et même :

In [26]: vowels = ’aeiouy’

In [27]: for i in ’powerful’:

.: if i in vowels:

.: print i,

o e u

La virgule à la fin du print permet d’éviter le retour chariot.

Python dispose également d’une boucle while

In [28]: z = 1 + 1j

In [29]: while abs(z) < 100: .: if z.imag == 0:

3.3 Utilisation avancée des boucles

La boucle for permet de parcourir les éléments d’un dictionnaire :

In [7]: d = {’a’: 1, ’b’:1.2, ’c’:1j}

In [8]: for key, val in d.iteritems():

: print(’Key: %s has value: %s’ % (key, val))

Key: a has value: 1

Key: c has value: 1j

Key: b has value: 1.2

In [10]: for key in d: .: print key

a c b

Il est possible de construire directement des listes à l’aide de list comprehension :

In [4]: [i ** 2 for i in range(4)]

Out[4]: [0, 1, 4, 9]

In [5]: vowels = ’aeiouy’

In [6]: [i for i in "powerfull" if i in vowels] Out[6]: [’o’, ’e’, ’u’]

Pour parcourir une liste en conservant les indices des éléments, on peut utiliser le mot-clé enumerate :

In [12]: word = "le chat"

In [13]: for index, lettre in enumerate(word):

.: print index, lettre

0 l

1 e

3 c

4 h

5 a

6 t

4 Définir des fonctions

Une fonction est définie par le mot-clé def :

In [1]: def area(radius):

: return 3.14 * radius * radius

In [2]: area(1.5)

Out[2]: 7.0649999999999995

Comme pour les structures de contrôles, le corps de la fonction est délimité par l’indentation. Une fonction peut, de manière optionnelle, renvoyer une valeur grâce au mot-clé return.

Au moment de l’appel, l’interpréteur s’assure que le nombres de paramètres de la fonction est correct :

In [3]: def double_it(x):

: return x * 2

In [4]: double_it(3)

Out[4]: 6

In [5]: double_it()

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

/people/wisniews/enseignement/enseignement2010/iri/cours/intro_python/<

ipython console> in <module>()

TypeError: double_it() takes exactly 1 argument (0 given)

Il est également possible de définir des paramètres ayant des valeurs par défaut :

In [6]: def double_it(x=2):

: return x * 2

In [7]: double_it(3)

Out[7]: 6

In [8]: double_it()

Out[8]: 4

On peut spécifier les paramètres en utilisant leur nom :

In [9]: def slicer(seq, start=None, stop=None, step=None):

: """Implement basic python slicing."""

: return seq[start:stop:step] :

In [10]: seuss = ’one fish, two fish, red fish, blue fish’.split()

In [11]: seuss

Out[11]: [’one’, ’fish,’, ’two’, ’fish,’, ’red’, ’fish,’, ’blue’, ’fish’]

In [12]: slicer(seuss)

Out[12]: [’one’, ’fish,’, ’two’, ’fish,’, ’red’, ’fish,’, ’blue’, ’fish’]

In [13]: slicer(seuss, step=2)

Out[13]: [’one’, ’two’, ’red’, ’blue’]

In [14]: slicer(seuss, 1, step=2)

Out[14]: [’fish,’, ’fish,’, ’fish,’, ’fish’]

In [15]: slicer(seuss, start=1, stop=4, step=2)

Out[15]: [’fish,’, ’fish,’]

Il est possible qu’une fonction retourne plusieurs valeurs :

from __future__ import division

def mean_var(lst):

"""

Calcule la moyenne et la variance d’une liste

""" mean = sum(lst) / len(lst) var = sum([(x - mean) ** 2 for x in lst]) / len(lst) return mean, var m, v = mean_var(range(10))

Cette exemple montre plusieurs éléments intéressant de python : – la possibilité de retourner plusieurs valeurs dans une fonction;

– l’utilisation des fonctions sum et len;

– l’utilisation des docstring (la chaˆ?ne de caractères sous le nom de la fonction) pour documenter la fonction;

Il est possible d’accéder à la docstring d’une fonction directement depuis l’interpréteur python grâce à la commande help

In [18]: help(mean_var)

Help on function mean_var in module __main__:

mean_var(lst)

Calcule la moyenne et la variance d’une liste

5 Les objets

Voici un exemple d’objet en python

class Basket:

# attention: le premier argument doit toujours ^etre une référence

# à l’objet, appelée, par convention, self def __init__(self, contents=None):

if contents:

self.contents = contents

else:

self.contents = []

def add(self, element): self.contents.append(element)

def n_elements(self):

"""

Nombre d’éléments dans le panier

""" return len(self.contents)

def __str__(self):

""" méthode qui est appelée par print

(équivalent de toString en Java

""" result = "" for element in self.contents: result = result + " " + element

return "Contains: %s" % result

def str_python(self):

"""

Une manière plus dans l’esprit de python de coder __str__

""" return "contains: %s" % " ".join(self.contents)

b = Basket()

b.add("carottes")

b.add("melon") print b # appel à __str__

1. toutes les méthodes de l’objet prennent obligatoirement, en premier argument une référence à l’objet (correspondant au this en Java ou en C++). Par convention, cet argument s’appelle toujours self.

2. la méthode correspondant au constructeur s’appelle __init__; pour créer un objet il suffit d’appeller le nom de l’objet en passant les paramètres (b = Basket())

3. il n’y a pas de mode d’accès en python (private, public en java); tous les attributs sont publics.

4. si b est une référence sur un objet, on peut accéder à ses attributs par b.nom_attribut et appeler ses méthodes par b.methode() (en fournis-

sant, si nécessaire, les paramètres)

– os qui contient des fonctions permettant de manipuler le système de fichier;

– re pour utiliser des expressions régulières;

– codec pour lire des fichiers contenant des accents;

– sys qui permet d’accéder au système et notamment aux entrées et sorties standards;

– pickle qui permet de sauvegarder (et de recharger) un objet dans un fichier. Il est possible de définir ses propres bibliothèques. Si l’on suppose que l’on dispose d’un fichier définissant une fonction build_from_directory et d’une classe Corpus, il est possible d’utiliser ceux-ci dans n’importe quel autre fichier python après avoir fait :

from corpus import Corpus, build_from_directory

Il faut toutefois que les deux fichiers soient dans le même répertoire.

6.2 Aide dynamique

Il est possible de connaˆ?tre le contenu d’un module de manière dynamique à l’aide des commandes dir et help :

# les sorties des exemples suivants sont tronquées

In [25]: import os

In [26]: dir(os) Out[26]:

[’fdopen’,

’fork’,

’forkpty’,

’fpathconf’,

’fstat’,

’fstatvfs’,

’fsync’,

’ftruncate’,

’getcwd’,

’getcwdu’,

’getegid’, ’getenv’,

’geteuid’,

’getgid’,

’getgroups’] In [27]: help(os)

Help on module os:

NAME os - OS routines for Mac, NT, or Posix depending on what system we are on.

FILE

MODULE DOCS

DESCRIPTION

This exports:

- is one of the modules posixpath, or ntpath

- is ’posix’, ’nt’, ’os2’, ’ce’ or ’riscos’

La commande dir permet d’accéder aux noms des fonctions et des objets contenus dans un module et des méthodes d’un objet; la commande dir permet d’obtenir l’aide correspondant à une variable, à une fonction, à un objet ou à un module. Cette aide est définie par les docstring.

In [28]: a = {}

In [29]: dir(a)

Out[29]:

[’clear’,

’copy’,

’fromkeys’,

’has_key’,

’items’,

’iteritems’,

’iterkeys’,

’itervalues’,

’keys’,

’pop’,

’popitem’,

’setdefault’,

’update’,

’values’]

#sortie tronquée

In [30]: help(a.iterkeys)

Help on built-in function iterkeys:

iterkeys( )

D.iterkeys() -> an iterator over the keys of D

(END)

7 Utilisation de fichiers

L’ouverture et la fermeture d’un fichier se font par l’intermédiaire des commandes open et close :

In [67]: fp = open("", mode="r")

In [68]: fp

Out[68]: <open file ’’, mode ’r’ at 0xea1ec0>

In [73]: fp.close()

Un fichier peut être ouvert dans les modes suivant :

– lecture seul (mode="r")

– écriture seule (mode="w", si le fichier existe il est alors écrasé)

– ajout (mode="a")

Il est possible de lire un fichier ligne par ligne ou de lire toutes les lignes dans une liste en une seule opération :

In [50]: fp = open("")

In [69]: first_line = fp.readline()

In [70]: first_line

Out[70]: "GUARD: ’Allo, daffy English kaniggets and Monsieur Arthur-King, who is

In [76]: all_lines = fp.readlines()

In [77]: all_lines

\n"

Out[77]:

["GUARD: ’Allo, daffy English kaniggets and Monsieur Arthur-King, who is\n", ’ afraid of a duck, you know! So, we French fellows out-wit you a\n’,

’ second time!\n’,

’ \n’,

’ \n’]

In [78]: all_lines[0]

Out[78]: "GUARD: ’Allo, daffy English kaniggets and Monsieur Arthur-King, who is

\n"

En utilisant une boucle for, il est possible d’itérer directement sur les lignes d’un fichier :

In [81]: fp = open("")

In [82]: for line in fp:

.: print line

GUARD: Allo, daffy English kaniggets and Monsieur Arthur-King, who is

afraid of a duck, you know ! So, we French fellows out-wit you a

second time !

In [83]: fp = open(’’, ’w’)

In [84]: fp.write("I am not a tiny-brained wiper of other people’s bottoms!")

In [85]: fp.close()

In [86]: fp = open(’’)

In [87]: ()

Out[87]: "I am not a tiny-brained wiper of other people’s bottoms!"

Il est possible de sauvegarder directement des objets Python dans un fichier grâce au module pickle.

import pickle

# exemple de sauvegarde d’objet data = {’a’: [1, 2.0, 3, 4+6j],

’b’: (’string’, u’Unicode string’),

’c’: None}

output = open(’’, ’wb’) (data, output) output.close()

# pour recharger l’objet pkl_file = open(’’, ’rb’)

data = (pkl_file) print data pkl_file.close()

8 Correcteur orthographique en python

Nous allons maintenant illustrer les différents aspects de Python en étudiant un programme de correction orthographique complet. Le principe de ce correcteur est relativement simple : si l’on suppose que l’on dispose d’une liste de tous les mots avec leur fréquence d’apparition (un dictionnaire, il suffit, pour vérifier l’orthographe d’un mot de générer une liste de corrections possibles et choisir, parmi celles-ci, la plus fréquente.

Voici un programme python mettant en œuvre ce principe :

import re, collections

def words(text): return re.findall(’[a-z]+’, text.lower())

def train(features): model = collections.defaultdict(lambda: 1) for f in features: model[f] += 1

return model

NWORDS = train(words(file(’’).read())) alphabet = ’abcdefghijklmnopqrstuvwxyz’

def edits1(word):

s = [(word[:i], word[i:]) for i in range(len(word) + 1)] deletes = [a + b[1:] for a, b in s if b] transposes = [a + b[1] + b[0] + b[2:] for a, b in s if len(b) > 1] replaces = [a + c + b[1:] for a, b in s for c in alphabet if b] inserts = [a + c + b for a, b in s for c in alphabet] return set(deletes + transposes + replaces + inserts)

def correct(word):

candidates = known([word]) or known(edits1(word)) or [word] return max(candidates, )

– les fonctions words et train construisent le dictionnaire en i) segmentant un texte en mot et en ii) comptant le nombre d’occurrences de chaque mot;

– la fonction edits1 permet de générer une liste de corrections possibles en considérant :

– tous les mots obtenus en supprimant une des lettres du mot à corriger;

– tous les mots obtenus en échangeant deux lettres adjacentes;

– tous les mots obtenus en rempla¸cant une des lettres du mot à corriger;

– tous les mots obtenus en ajoutant une lettre au mot à corriger (à toutes les positions possibles);

Cette ensemble de correction n’est pas complet, mais il couvre la plupart des erreurs commises.

– la fonction known filtre les corrections possibles (générées par edits1 en ne gardant que celles qui sont dans le dictionnaire.

– la fonction correct parcourt la liste de toutes les corrections possibles et trouve la correction la plus fréquente, la première ligne de la fonction permet de sélectionner le premier ensemble qui n’est pas vide.

[1] Ces notes sont basées sur une présentation de Christopher Burns et Ga¨el Varoquaux à

Scipy’09

[2] L’encapsulation (qui n’est qu’une question de style!) est assurée par un mécanisme beaucoup plus puissant, les propriétés.

d’après http