Introduction au langage python (Notion de base)

Introduction au langage python
AIT-OMAR Mohamed

Plan
• Pourquoi python?
• Instructions de base
• Structures conditionnels
• Boucles
• Fonctions
• Collections
• Fichiers

Python, élu « meilleur langage 2017 » par IEEE, dépasse encore Java et C en termes d’influence en 2018. Ce
classement a été élaboré à partir des données collectées sur différentes sources. Ce sont les nombres de requêtes pour
Python sur Google Search et les tendances provenant de Google Trends qui le conforme.

Pourquoi python ?
• Python est portable sur différents environnements tels que Unix et
Windows, Mac ...
• Logiciel libre.
• La syntaxe du langage est simple.
• Python gére lui-même l’espace mémoire disponible.
• Python est doté d’un typage dynamique car il n’y a pas de déclaration
explicite de variables ni de spécification de types; le type d’une
variable est déterminé à l’exécution seulemen

Pourquoi python ?
• Il existe des interpréteurs en Python.
• Il existe des compilateurs en Python qui produisent un code
intermédiaire, appelé bytecode lequel est transmis à un interpréteur
pour l’exécution finale.
• Il offre des possibilités pour la programmation orientée objets.
• Il posséde une bibliothéque trés riche (interfaces graphiques, bases de
données, protocoles Internet, …).

Pourquoi python ?
• Python est associé à de très nombreuses librairies très
performantes,notamment des librairies de calcul scientifique (Numpy,
SciPy, Pandas, etc.).
• De fait, il est de plus en plus populaire, y compris auprès des data
scientists.
• Il est plus généraliste que R qui est vraiment tourné vers les
statistiques.

Affectation-Typage automatique
• a = 1.2
• a est une variable, en interne elle a été automatiquement typée en
flottant « float » parce qu’il y a un point décimal.
• a est l’identifiant de la variable (attention à ne pas utiliser le mots
réservés comme identifiant),
• = est l’opérateur d’affectation

• Forcer le typage d’une variable (sert aussi pour le transtypage)
• b = float(1)
• Même sans point décimal, b sera considéré comme float (b = 1, il
aurait été int dans ce cas).
• Connaître le type d’un objet type(nom_de_variable)
• Affiche le type interne d’une variable (ex. type(a) )
• Supprimer un objet de la mémoire del nom_de_variable

• a=‘ 12 ‘ # a est de type chaîne caractère
• b = float(a) #b est de type float
• N.B. Si la conversion n’est pas possible ex. float(« toto »), Python
renvoie une erreur
• Conversion en logique
• a = bool(« TRUE ») # a est de type bool est contient la valeur True
• a = bool(1) # renvoie True également
• Conversion en chaîne de caractères
• a = str(15) # a est de type chaîne et contient ‘15 ‘

• Les opérateurs arithmétiques applicables sont : + , - , * , / (division
réelle), ** (puissance) , % (modulo) , // (division entière)
• Les opérateurs logiques sont not (négation), and (ET logique), or (OU
logique
• Les opérateurs de comparaison servent à comparer des valeurs de
même type et renvoient un résultat de type booléen.
• Sous Python, ces opérateurs sont <=, >, >=, != , ==
ex. a = (12 == 13) # a est de type bool, il a la valeur False
• N.B. On utilisera principalement ces opérateurs dans les branchements
conditionnels

• 1 instruction = 1 ligne:
• La plus couramment utilisée
• Autres possibilités:
• Personne n’utilise ces écritures
a=1
b=5
c=a+b
a=1 ; b=5 ; c=a+b
a=1;
b=5;
c=a+b

Entrées et sorties :
• la fonction print() reste indispensable aux affichages dans les scripts
>> a, b = 2, 5 # affectation multiple
>>> print(a, b)
2 5
>>> print(”Somme :”, a + b)
Somme : 7
>>>> print(a - b, ”est la différence”)
-3 est la différence
>>> print(”Le produit de”, a, ”par”, b, ”vaut :”, a * b)
Le produit de 2 par 5 vaut : 10
>>> # pour afficher autre chose qu’un espace en fin de ligne :
>>> print(a, end=”@”)
2@

• La fonction input() effectue toujours une saisie en mode texte (la
valeur retournée est une dchaîne) dont on peut ensuite changer le type
(on dit aussi « transtyper » ou cast en anglais) :
>>> f1 = input(”Entrez un flottant : ”)
Entrez un flottant : ’12.345’
>>> type(f1)
<class ‘str’>
>>> f2 = float(input(”Entrez un autre flottant : ”))
Entrez un autre flottant : 12.345
>>> type(f2)
<class ‘float’>

• Attention au : qui est primordial
• C’est l’indentation (le décalage par rapport à la marge gauche) qui
délimite le bloc d’instructions
• La partie else est facultative

par exemple, Pour trouver, le minimum de deux nombres, on peut utiliser
l’operateur ternaire:
>>> x = 4
>>> y = 3
>>> if x < y: # écriture classique
plus_petit = x
else:
plus_petit = y
print(”Plus petit : ”, plus_petit)
Plus petit : 3
>>> plus_petit = x if x < y else y # utilisation de l’opérateur ternaire
>>> print(”Plus petit : ”, plus_petit)
Plus petit : 3

While() :
Remarque :
• Attention à l’indentation toujours
• On peut « casser » la boucle avec break

Utilisation classique : la saisie filtrée d’une valeur numérique (on doit
préciser le type car on se rappelle que input() saisit une chaîne) :
n = int( input( ’ Entrez un entier [1 .. 10] : ’ ))
while not(1 <= n <= 10) :
n = int( input( ’ Entrez un entier [1 .. 10], S. V. P. : ’ ))

For :
Remarque :
• Attention à l’indentation toujours
• On peut « casser » la boucle avec break
• Des boucles imbriquées sont possibles
• Le bloc d’instructions peut contenir des conditions

>>> nb_voyelles = 0
>>> for lettre in ”Python est un langage tres sympa”:
if lettre in ”aeiouy”:
nb_voyelles = nb_voyelles + 1
>>> nb_voyelles
10
>>> for x in [2, ’a’, 3.14]:
print(x)
2
‘a’
3.14

>>> for i in range(5)
print(i)
0
1
2
3
4

• Une fonction est une séquence d’instructions consiste à résoudre une tache bien
déterminée.
• Syntaxe :
def nomdefonction ( argument1 , argument2 , …,argumentk ) :
bloc_instructions
return valeur
def sommeCarre ( x, y) :
z = x**2 + y**2
return z
>>> a=2
>>> b=3
>>> print(sommeCarre(a,b))
13

Pourquoi créer des fonctions ?
1. Meilleure organisation du programme (regrouper
les tâches par blocs : lisibilité et maintenance)
2. Eviter la redondance (pas de copier/coller,
maintenance, meilleure réutilisation du code)
3. Possibilité de partager les fonctions (via des
modules)
4. Le programme principal doit être le plus simple
possible

Qu’est-ce qu’un module sous Python ?
1. Module = fichier « .py »
2. On peut regrouper dans un module les fonctions
traitant des problèmes de même nature ou
manipulant le même type d’objet
3. Pour charger les fonctions d’un module dans un
autre module / programme principal, on utilise la
commande : import nom_du_module
4. Les fonctions importées sont chargées en mémoire.
Si collision de noms, les plus récentes écrasent les
anciennes.

Fonction:
• Bloc d’instructions
• Prend (éventuellement) des paramètres en entrée
(non typés)
• Renvoie une valeur en sortie (ou plusieurs
valeurs, ou pas de valeur)

Exemple 1:
• def pour dire que l’on définit une fonction
• Le nom de la fonction est « petit »
• Les paramètres ne sont pas typés
• Attention à l’indentation
• return renvoie la valeur
• return provoque immédiatement la sortie de la fonction
def petit(a,b):
if(a<b):
d=a
else:
d=0
return d

Variables locales et globales:
1. Les variables définies localement dans les fonctions sont uniquement
visibles dans ces fonctions.
2. Les variables définies (dans la mémoire globale) en dehors de la
fonction ne sont pas accessibles dans la fonction
3. Elles ne le sont uniquement que si on utilise un mot clé spécifique

Lambda function :
• Fonction anonyme (lambda function)
• Le mot-clé lambda en Python permet la création de fonctions
anonymes (i.e. sans nom et donc non définie par def)
>>> f = lambda x : x * x
>>> f ( 3 )
9

Fonctions récursives
• Une fonction est dite récursive si elle s’appelle elle-même :
on parle alors d’appel récursif de la fonction
def factorielle(n):
if n==0:
return 0
else:
return n*factorielle(n-1)

Listes:
• Une liste est une suite ordonnée d’objets, pouvant être de type différent.
Ces objets peuvent éventuellement être eux-même des listes (listes
imbriquées). Ils peuvent même être égaux à la liste globale (définition
récursive).
• La liste est la structure de donnée la plus utilisée en Python. Pour
programmer correctement dans ce langage, il est donc crucial de savoir
l'utiliser efficacement dans tous les cas.
• Liste est de taille dynamique ,indexé, hétérogène et modifiable,
• L=[8, 17.5, ‘ordinateur’, [2, 3]]
• L[1]=3+5j
• L=[8, 3+5j, ‘ordinateur’, [2, 3]]

Operateur sur les listes:
• +: Concatenation
>>>L1=[1,2,3]
>>>L2=[4,5]
>>>L=L1+L2
>>>print(L)
[1,2,3,4,5]
• *: multiplication
>>>T=4*[0]
>>>print(T)
[0,0,0,0]

Technique d’extraction (slicing):
• L[i:j] # Extraction de la tranche [L[i], ... , L[j1]]
• L[i:j:p] # De même de p en p à partir de L[i], tant que i+k*p < j
>>> M = [0,1,2,3,4,5,6,7,8,9,10]
>>> M[3:6]
[3, 4, 5]
>>> M[2:8:2]
[2, 4, 6]

Opérations et méthodes applicables à une liste:
• len(L) # longueur (nombre d’éléments) de L
• L1 + L2 # concaténation des listes
• n * L # pour n entier: concaténation répétée de L avec elle-même.
• L.append(a) # ajout de l’objet a en fin de liste L
• L.insert(i,a) # insertion de l’objet a en position i
• L.remove(a) # retrait de la premiére occurrence de a
• L.pop(i) # retrait et renvoi de l’élément d’indic

• L.index(a) # position de la premiére occurrence de a
• # ValueError si a n’est pas dans la liste
• L.count(a) # nombre d’occurrences de a dans la liste
• a in L # teste l’appartenance de a à L
• L.copy() # copie simple de L
• L.reverse() # retourne la liste (inversion des indexations) (m)
• L.sort() # trie la liste dans l’ordre croissant (m)

Chaine de caractère:
• Une chaîne de caractères est une suite finie de caractères consécutifs,
qu’on note entre apostrophes ou guillemets ; elle est considéré comme
un tableau des caractères (liste d’une manière générale qui peut être
manipulé d’une manière globale), par contre il est impossible de
modifié les éléments d’une liste de caractères après sa définition

• La chaîne vide se note : '' ou ""
• On peut stocker une chaîne dans une variable :
>>> s = 'Bonjour’
Pour accéder à chacun des caractères on utilise son indice : s[i]
>>> s[2]
‘n‘
>>> s[-1]
'r’
>>> s[-2]
'u’
>>> s[-7]
'B’

• Concaténation :
On concatène deux chaînes à l’aide de l’opérateur +
>>> s = 'Bonjour '+ 'lecteur !’
>>> s
'Bonjour lecteur ! ‘
Longueur :
On utilise la fonction len() pour obtenir la longueur d’une chaîne :
>>> len('Bonjour’)
7
Sous-chaîne :
>>> s = 'Bonjour lecteur !’
>>> s[0:7]
'Bonjour’
>>> s[8:15]
'lecteur'

• Test d’appartenance :
Il est à noter qu’il est également possible de tester la présence d’une
sous-chaîne dans une chaîne avec la même construction :
>>> 'lecteur' in 'Bonjour lecteur !’
True
>>> 'Bjr' in 'Bonjour lecteur !’
False
L’opérateur in sert à tester l’appartenance d’un caractère à une chaîne :
>>> 'o' in 'Bonjour‘
True

• Conversion:
On peut convertir une valeur d’un type simple vers une chaîne de caractères à
l’aide de la fonction str(e) :
>>> str(1.2)
'1.2’
Il est possible de reconvertir une telle chaîne vers une valeur d’un type simple :
>>> int('123’)
123
>>> float('1.2’)
1.2
>>> bool('true’)
True
>>> bool('True’)
True

• Les chaînes ne sont pas modifiables
>>> s = 'Bonjour lecteur !’
>>> s[0]= 'b' # erreur
TypeError: 'str' object does not support item assignment

• compter le nombre d’occurrences d’un caractère dans la chaine
>>> s=‘el jadida‘
>>> s.count('a’)
2
• Chercher une chaine dans une autre
>>> s.find('a') #retourne l’index du caractère dans la chaine s’il existe.
4
>>> s.find(‘jadid’)
3
>>> s.find(‘s') #retourne -1 si le caractère n’existe pas dans la chaine.
-1
• Transformer une chaine en une liste
>>> Ch='mot1 mot2 mot3 mot4’
>>> Ch.split()
['mot1', 'mot2', 'mot3', 'mot4']

• Transformer une liste de chaines en une seule chaine
>>> t = [ "Ceci" , "est" , "un" , "tableau" , "de mots"]
>>>' '.join(t)
'Ceci est un tableau de mots’
• Supprimer un caractère à gauche et à droite d’une chaine
>>>ch='AABBAACCAA’
>>> ch.strip('A’)
'BBAACC’
• Supprimer un caractère à gauche d’une chaine
>>> ch='AABBAACCAA’
>>> ch.lstrip('A’)
'BBAACCAA

• Supprimer un caractère à droite d’une chaine
>>> ch='AABBCCAA’
>>> ch.rstrip('A’)
'AABBAACC’
>>> S='Alin’
>>> S
'Alin’
>>> s.rstrip('n’)
'Al

Les tuples:
• Un tuple est une collection d’objets séparés par une virgule, et
délimitées par des parenthèses.
• Exemple
-- Un couple composé d’un entier et d’un flottant : (1, 2.2)
-- Un triplé d’entiers : (0, 1, 2)

• Remarques
Les parenthèses aux extrémités sont facultatives (l’important, ce sont
les virgules) mais recommandées pour la lisibilité.
>>> a=123,'abcd ', 4.56, True
>>> b=(123,'abcd ',4.56,True)
>>> print(a==b)
True

• Accès à un élément d’un tuple
Les éléments d’un tuple sont des séquences comme les éléments d’une
liste et on peut sélectionner une partie d’un tuple avec la même syntaxe
que celle utilisée pour les listes.
Exemple :
>>> t = (1, 2.2)
Pour obtenir la première composante du couple, on pourra alors évaluer :
>>>t[0]
1
>>> t[1]
2.2

• Affectations multiples
• Les tuples en Python permettent d’effectuer des affectations multiples.
>>> a,b=(1,2),(3,’abc’)
• On peut donc s’en servir pour échanger les valeurs de deux variables d’un
coup (sans introduire de variable auxiliaire) :
print('Avant :',a,b)
Avant : (1,2),(3,’abc’)
a , b = b , a
print('Après :',a,b)
Après : (3,’abc’),(1,2)

• Les tuples sont immuables. Cela signifie qu’il n’est pas possible
d’affecter de nouvelles valeurs aux composantes. Ainsi l’instruction
suivante produit une erreur :
>>> t[0] = 2
TypeError: 'tuple' object does not support item assignment
• Test d’appartenance
Il est possible de tester si une valeur appartient à un tuple à l’aide de
l’opérateur in :
>>> 3 in (1,2,3)
True

• Concatenation:
>>> (1,2,3) + (4,5) # concatenation de deux tuples
(1, 2, 3, 4, 5)
>>> (1,2) + 3
TypeError: can only concatenate tuple (not "int") to tuple L’expression
correcte est :
>>> (1,2) + (3,)
(1,2,3)
>>> (0,)*5 # le ‘tuple’ (0) répété 5 fois
(0, 0, 0, 0, 0)

Dictionnaires:
• Un dictionnaire est une collection modifiable de couples (clé, valeur) sans ordre
défini et sans doublons de clés.
• Les dictionnaires ressemblent aux listes dans une certaine mesure (ils sont
modifiables comme elles), mais ce ne sont pas des séquences (non ordonnées).
• Pour accéder à un élément on utilise un indice spécifique que l'on appellera une
clé (key),
• Exemple 1 :
>>> dico = {} # Un dictionnaire vide
>>> dico['computer'] = 'ordinateur’
>>> dico['mouse'] ='souris’
>>> dico['keyboard'] ='clavier’
>>> print dico
{'computer': 'ordinateur', 'keyboard': 'clavier', 'mouse': souris'}

Remarques:
• les valeurs d'un dictionnaire peuvent être de n'importe quel type de
données, y compris des chaînes, des entiers, des objets et même
d'autres dictionnaires.
• Les clés d'un dictionnaire sont plus restrictives, mais elles peuvent
être des chaînes, des entiers ou. N’importe quel objet immuable
(hashable), par exemple, des tuples:
• Exemple 2 :
>>> positions = {(48.85, 48.85): 'Paris', (40.71, -74.00): 'New York'}
>>> positions[(48.856614, 48.856614)]
'Paris'

• Parcourir un dictionnaire :
• Pour parcourir un dictionnaire, on peut utiliser une simple boucle for,
qui affectera à la variable de travail les clés du dictionnaire dans un
ordre imprévisible.
def afficheDic(d) :
for e in d:
print (e,'t', d[e])
>>> afficheDic(dico)
keyboard clavier
mouse souris
computer ordinateur

• Longueur d’un dictionnaire
>>> len(dico)
3
Test d’appartenance
>>> 'mouse' in dico
True
>>> 'mouse' in dico.keys()
True
>>> 'souris' in dico
False
>>> 'souris' in dico.values()
True

Introduction au langage python (Notion de base)

Contenu connexe

Tendances

Similaire à Introduction au langage python (Notion de base)

Dernier

Introduction au langage python (Notion de base)