Webographie : · Vault

Introduction au langage Python

Animé par : Dr. Guelzim Ibrahim

https://www.docstring.fr/
https://python.sdv.univ-paris-diderot.fr/
https://courspython.com/
http://www.xavierdupre.fr/app/teachpyx/helpsphinx/index.html
https://pythontutor.com/render.html#mode=edit

Introduction Générale

Python est un Langage : - Gratuit - Ecrit en langage C (CPython : implémentation officielle de Python.) - D'autres variantes : Jpython , écrit en Java , ... - Open : code accessible - Multi-plateforme (portable): Windows , Linux , Mac OS , Android, … - Ouvert aux autres langages : code python dans un code C

Versions : 3.13.7 ( 14 août 2025 )
Utilisation : Plusieurs façons
- https://www.python.org/
  - Télécharger et Installer (attention, au path)
  - Invite de commandes (cmd) :
    - python + ↵ (démarrage d'un interpréteur : 3+2 affiche 5)
    - … Travailler …
    - quit()
  - écrire un script via un éditeur de text (de mieux un éditeur qui reconnait les mot clés du langage : change de couleur)
    - Extension du Fichier Python : .py
    - puis l'executer dans invite de commandes (cmd) : python NomScript.py
- En ligne
- Via une plateforme , Ex : Anaconda

Versions Python (sur anaconda)

import sys
print(sys.version)

!python --version

Mettre à jour la version

possible via la commande : conda
Vivement Recommandé : créer un nouvel environnement puis installer les versions souhaitées

Forces de Python

Polyvalent : Machine Learning, data science, automatisation, web, Quantum computing ...
Top 3, avec le C et Java
Communauté large : Help disponible
Bibliothèque, packages déjà écrits et opérationnels

Aussi

Plus simple dans l'implémentation ( que le langage C)
moins de lignes de code que le C (Cf plus loin)

Pyhton est un langage Interprété ≠ Compilé (C, C++,…) ( Difference diminue au fil du temps)

print("Bonjour")
print("tout le")
print("monde")

# print("apres")

Bonjour
tout le
monde

Python est un langage Faiblement typé ≠ C (Fortement Typé)

#Faiblement typé
x = 5
print("var x:",x," - type :",type(x))

x = "bonjour"
print("var x:",x," - type :",type(x))

Indenté :

print("Bonjour")
print("tout le")
 print("monde")

Commentaires

#### - Sur une seule Ligne

print("Bonjour") # ctrl + /
# print("tout")
print("le monde")

#### - Sur Plusieurs Lignes

"""
print("Bonjour")
print("tout le")
prin("monde")
"""

print("apres")

print("Bonjour")
print("tout le")
print("monde")

print("après")

Variables

Moyen pour stocker de l’information
Nom de variables : identificateur
Contient lettres, chiffres et _ (pas d’espaces ou caractères spéciaux)
Commence par lettre ou _
De préférence significatif de sa fonction :
- prixTTC
- age
- salaire
Sensible à la casse : __s__alaire ≠ __S__alaire

Bonnes Pratiques :
- PrixVente ( CamelCase )
- prixVente ( camelCase )
- prix_vente
- Prix_Vente
Affectation : donner une valeur à la variable via l’opérateur =

x = 7
print('x : ', x , ' de type : ' , type(x))

_y = 17
print('y : ', _y , ' de type : ' , type(_y))

Variables : type

Les principaux types

- Entiers (integer ou int)
- Nombres décimaux (float): 
 le séparateur décimal est le caractère . et non pas le ,
- Chaînes de carcatères (string ou str)
- Booléens : x = True; y = False
- Nombres complexes: 3 + 5j; 3 + 5J ; complex(3,5)
- ... Etc

# Type complexe :
x = 3 + 7j ; y = 3 + 7J ; z = complex(3,7) 

# Type booleen :
v = True;
print(v)

Mots-clés du langage : (déjà réservés)

interdits comme identificateurs

import keyword
print(keyword.kwlist)

Rappels

Opérateurs

Les opérateurs sont des symboles spéciaux utilisés pour effectuer des opérations sur des variables et des valeurs.
Python supporte plusieurs catégories : (avec exemples)
- Arithmétiques : a + 3, ...
- Relationnels : x == y
- Logiques : p and q
- D’affectation : a = 7
- Bit à bit : a & b
- Spéciaux : in

Operateurs Unaires : s'appliquent à un seul opérande :: exemples

# not :
a = 6
if (not a):
    print("Tr a")
else:
    print("False a")

# moins :
b = 6
print(-b)

# Complément bit à bit :
x = 5          # 5 en binaire: 00000101
print(~x)      # -6 (complément: 11111010)

... à voir dans la suite du cours : in, is ... etc

Operateurs Binaires : s'appliquent à deux opérandes :: exemples

a = 10
b = 3

print(a + b)   # 13
print(a > b)   # True

Expression

un ensemble de valeur(s),
reliées éventuellement par des opérateurs,
équivalent à une seule valeur:
exemples :
- a + B
- "You get what you work for, not what you wish for"
- som != A + b
- E

Valeur numérique d'une expression (numerique) : valeur arithmétique
Exemples:
- si une variable x vaut 7, alors sa valeur numérique est 7
- La valeur numérique de l'expression de l'affectation : s = 13 est égale à 13

Valeur logique d'une expression: valeur booléenne
Deux possibilités:
- Vrai ou 1 : la valeur logique d'une expression est "Vrai" si sa valeur numérique est différente de 0,
  (y compris les valeurs négatives)
- Faux ou 0: la valeur logique d'une expression est "Faux" si sa valeur numérique est égale à 0

if (14-14) :
    print ("T")
else:
    print("Fal")

ch = "Alphabet"
cha = ""

if(ch):
    print("chaine NON vide : valeur True")
else:
    print("chaine NON vide : valeur False")

if(cha):
    print("chaine vide : valeur True")
else:
    print("chaine vide : valeur False")

Exemples:

Opérateurs / Opérations Pyhton : (suite)

La fonction type() :

u = 5
print(type(u))

print("")
print("x :",x, "| type : ",type(x))
print("y :",y, "| type : ",type(y))
print("z :",z, "| type : ",type(z))

v = True
print("\nv :",v,"| type : ",type(v))

- Remarque : Jupyter Notebook garde en mémoire les variables des cellules precedement executées

Affectation simple :

x = 5
s = 1.2
y = 4
print(x*s) # type reel (opérateur et opérandes)
print(x*y) # type reel (opérateur et opérandes)

a = 15; b = True; 
c = a+b; 
print(type(a))
print(type(b))
print(type(c))
print(c)

x = 1.2 ; y = 7

print("x : ",x,"| Type :", type(x))
print("y : ",y,"| Type :", type(y))

print("\n")

y = x # ( ≠ Langage C)
print("x : ",x,"| Type :", type(x))
print("y : ",y,"| Type :", type(y))

Affectation : Plusieurs sur une seule ligne

x = 5; s = 1.2 ; y = 4
print(x*s) # type reel (opérateur et types opérandes)
print(x*y) # type reel (opérateur et types opérandes)

Affectations séquentielles :

x = y = t = 3
print(x, y, t)

y = 4
x = y = t = 3
print(x, y, t)

y = 4
x = y 
y = t 
t = 3
print(x, y, t)

Affectations multiples : (Expl permutation)

x , y = 5 , 9
print("x :",x ," - y :", y)

Question: écrire un code qui permute x et y

- Solution 1 : utilisant variable d'aide

print("x et y Av : ",x, " - " , y)
a = x
x = y
y = a
print("x et y Ap : ",x, " - " , y)

- Solution 2 : sans utilisation de variable d'aide

x , y = 3 , 7

print("x et y Av : ",x, " - " , y)
x = x + y
y = x - y
x = x - y
print("x et y Ap : ",x, " - " , y)

- Solution Python

x , y = 1 , 8

# Permutation
print("x :",x ," - y :", y)
x,y = y,x
print("x :",x ," - y :", y)

# Test de séquence
import time

x , y = 5 , 9
print("x :",x ," - y :", y)

t = 2 ; time.sleep(t)

x = y
y = x
print("x :",x ," - y :", y)

Test Multiple ( ≠ Langage C)

x = 9
if 8 < x <= 9:
    print("T")
else:
    print("F")

Attention aux floats : Erreur dûe au codage

print((3 - 2.8) == 0.2)

print(3 - 2.8)

Alternative :

delta = 0.0001
var = 3.0 - 2.8
print(0.2 - delta < var < 0.2 + delta)
print (abs(var - 0.2) < delta)

print(0.3)
print(f"{0.3:.5f}")
print(f"{0.3:.30f}")
print(f"{3 - 2.7:.30f}")

# On observe que lorsqu'on tape 0.3, Python affiche une valeur arrondie. 
# En se limitant à une quantité finie de bits, on ne peut obtenir qu'une approximation.
# le nombre réel 0.3 ne peut être qu'approché lorsqu'on le code en nombre flottant.

Opérations sur les types numériques :

Arithmétiques : +, - , *

x = 5; s = 1.2 ; y = 4
print(x*s) # type reel (opérateur et types opérandes)
print(x+y)

Arithmétique : oprération / :: retourne par défaut un type float même si les opérandes sont des entiers

# ( ≠ Langage C) 
a = 8; b = 2
print(a/b)

Opérateur Puissance : **

puiss = 2**5
print(puiss)

Opérateur Division entière : //

divEnt = 7//2
print(divEnt)

Opérateur Modulo :

restDivEnt = 7%2

print(restDivEnt)
print(8%2)

Opérateur divmod ( ≠ Langage C)

b,c = divmod(14,4)
print(b,c)

Affectation composée : += , -= , *= , %= , /= , //= , **=

a = 4
a %= 3 # a = a%3
print(a)

a = 4
a **= 3 # a = a**3
print(a)

Opérations de comparaison

x = 3 # type int 
y = 2.5 # type float

print('égalité :', x == y)
print('inégalité :', x != y)
print('inférieur ou égal :', x <= y)
print('supérieur ou égal :', x >= y)

égalité : False
inégalité : True
inférieur ou égal : False
supérieur ou égal : True

Opérations Logiques sur Booléens

print('ET :', False and True)
print('OU :', False or True)
print('OU exclusif :', True ^ False)
print('Comparaison :', True != False)

ET : False
OU : True
OU exclusif : True
OU exclusif : True

Opérations sur les chaînes de caractères :

Concaténation : +

A = "Assalamo"
B = "Alaykom"

print(A+B)

AssalamoAlaykom

Concaténation : ,

A = "Assalamo"
B = "Alaykom"
C = A,B

print(A+B)
print(A,B)
print(C)

AssalamoAlaykom
Assalamo Alaykom
('Assalamo', 'Alaykom')

Multiplication (par entier) :: duplication : opérateur *

X = "Abc"
print(X*2)

AbcAbc

Conversion (explicite) de types:

Forcer une variable à changer de type, via les fonctions : int(), float() et str()

i = 3
print(str(i))

i = '456'
print(int(i)+1)

print(float(i))

i = '    13.1416    '
print(float(i)+1)

y = 13.7

z = int(y)
z

Opérateurs Minimum et maximum : fonctions min() et max()

renvoient respectivement le minimum et le maximum
opèrent sur 2 ou plusieurs variables numériques (entiers ,floats) ou booléennes:

print(min(1.5, -2, 4))
print(min(1.5, 2, 4 , False))
print(int(min(1.5, 2, 4 , False)))

Opérateur de Saisie: input()

prixHT = input("Prix HT du produit : ")
print("Voici le prix HT :", prixHT)
prixTTC = prixHT * 1.2
print("Voici le prix TTC :", prixTTC) # Résultat ??

prixHT = input("Prix HT du produit : ")
print("Voici le prix HT :", prixHT)
# prixTTC = int(prixHT) * 2
prixTTC = float(prixHT) * 1.2
print("Voici le prix TTC :", prixTTC) # Résultat ??

prixHT = input("Prix HT du produit : ")
print("Voici le prix HT :", prixHT)
prixVente = prixHT * 2
print("Voici le prix de Vente :", prixVente) # Résultat ??

prixHT = eval(input("Prix HT du produit : "))
print("Voici le prix HT :", prixHT)
# prixTTC = int(prixHT) * 2
# prixTTC = float(prixHT) * 1.2
prixTTC = prixHT * 1.2
print("Voici le prix TTC :", prixTTC) # Résultat ??

Prix HT du produit :  f

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[15], line 1
----> 1 prixHT = eval(input("Prix HT du produit : "))
      2 print("Voici le prix HT :", prixHT)
      3 # prixTTC = int(prixHT) * 2
      4 # prixTTC = float(prixHT) * 1.2

File <string>:1

NameError: name 'f' is not defined

écriture (notation) scientifique:

* écrire des nombres très grands ou très petits
* utilisant:
   <br>   - des puissances de 10
   <br>   - le symbole e
* AeB : A * 10<sup>B</sup>
* Python génère des floats même si le symbole e est entouré par des entiers : Ex 1e5

x = 9
y = 2
print(1e5)
print(4.15e-3)
print(type(1e5))
x
y

100000.0
0.00415
<class 'float'>

écriture de très grands nombres:
Utilisation dans le code source du caractère "souligné" ( underscore : _ )
pour séparer des groupes de chiffres

Nbr_cellules = 3_301_496 # on peut aussi = 33_01_4_96 
print(Nbr_cellules)

Nbr_cellules = 3_30_14_96
print(Nbr_cellules)

3301496
3301496