Python - DS 1 55

Cours Python
2023/2024
Présenté par AMAL TARIFA
Plan
• Introduction Générale (python+ data science)
• Types de variables , les boucles, les fonctions, les décorateurs
• POO , les exceptions, les tests unitaires
• Numpy + TP
• Pandas + TP
• Matplotlib+ analyse exploratoire +TP
• Préparation de la data
• ML:Supervisé
• ML:Non supervisé
• Traitement des données textuelles, embedding
• deep learning
• Mini Projet
Presented By PhD Amal TRIFA

Introduction
générale

Introduction générale
Il a été créé par Guido van Rossum en 1991 et développé par la “Python Software
Foundation”. Il a été conçu en mettant l'accent sur la lisibilité du code et sa syntaxe
permet aux programmeurs d'exprimer leurs concepts en moins de lignes de
code.Python est un langage de programmation qui vous permet de travailler
rapidement et d'intégrer des systèmes plus efficacement.
Deux versions principalement:

• Python 2
• Python 3

Particularités:
1. Libre et open source

2. Orienté objets
3. Mode Interactif
4. De haut niveau
5. Des librairies standards
6. Scalable (évolutif)
7. Extensible
8. Portable

Particularités:
1. ‘Garbage Collector’ automatique
2. Programmation GUI (interfaces) [ PyQt5, PyQt4, wxPython, Tk in
Python]
3. Intégré
4. Interprété

Particularités:
Rappel: Interprété??
l'interpréteur va exécuter les lignes du code une par

une.
(+) Dans un langage interprété, le même code

source fonctionne directement sur tout ordinateur.
Avec un langage compilé, on doit tout recompiler à
chaque fois ce qui pose parfois des soucis.
Exemple: PhP, Javascript, python, Java

Particularités:
Rappel: Compilé??
(+)Dans un langage compilé, le

programme est directement exécuté sur
l'ordinateur, donc il sera en général plus
rapide que le même programme dans un
langage interprété.
exemple: C, C++, C#

Particularités: Interprété et
portabilité Si pas d’erreurs
Code machine
La portabilité !!

Particularités:
Tout est objet en python!!!

x=1
NB: x n’est pas une simple valeur mais un pointeur vers un objet (Pyobject)!!!
un entier en C est essentiellement une étiquette pour une position en mémoire dont les octets codent une
valeur entière.
Un entier Python est un pointeur vers une position en mémoire contenant toutes les informations de l'objet
Python, y compris les octets qui contiennent la valeur entière.

Particularités:
Une large communauté

Pour pouvoir exécuter du python , il faut avoir un interpréteur et un IDE:

• Eclipse with PyDev Plugin
• Python Tools for Visual Studio (for Windows users)
• PyCharm
• Spyder
• Komodo IDE
Anaconda: est un outil en distribution libre et open source destiné à la programmation Python et R. Il contient
plusieurs packages.
Jupyter notebook: C'est un outil puissant pour développer et présenter de manière interactive des projets de
science des données.

Les interpréteurs:
CPython : le plus utilisé, l'interpréteur original écrit en langage C . Utilisé par anaconda.
Jython: fonctionne dans une machine virtuelle Java, permet l'interaction, au sein de la même machine
virtuelle Java, de code écrit en Java avec du code écrit en Python.
PyPy: écrit en python, offre une portabilité extrême.

Syntaxe:
Python utilise l'indentation pour indiquer un bloc de code.
Par exemple:
a=5
if a > 2:
print(“a est sup!")
a=5
erreur
if a > 2:
print(“a est sup!")

Notions basiques

Notions basiques
Les variables
Le type est attribué dynamiquement.
Les variables n’ont pas besoin d’une déclaration à l’avance, on assigne une valeur et le type est
automatiquement assigné et la vérification se fait à chaque lecture ou utilisation de celle ci:
z = -325552 print(type(z))
z = -35.59 print(type(z))
z = -5j print(type(z))

Notions basiques
Les variables
Pour la declaration des variables, il faut éviter les mots clés, liés à python:
and del from None True as elif global

nonlocal try assert else if not while break
except import or with class False in pass yield
continue finally is raise def for lambda return

Notions basiques
Les variables: types
Texte : str
Numérique: int, long, float, complex
Séquences: list, tuple
Mappage: dict
ensemble: set, frozenset

Boolean: bool

Notions basiques
Les variables: mutables Vs non mutables

Notions basiques
Les variables: mutables Vs non mutables
Immutable VS mutable:
Immuable --→ pas de mise à jour:
Exemple:.
b=5
b += 2 ---→nous ne mettons pas à jour 5 à 7, mais le pointeur est déplacé vers 7.
Par contre les variables mutable comme les listes sont mis à jour localement et on ne
créé pas de nouvelles listes.

Notions basiques
Les variables: numériques
Forcer la conversion en un type spécifique (casting): Créer un nombre aléatoire:

Random
float(x)
int(y) import random
complex(z) print(random.randrange(6, 15))
long() #randrange ([start,] stop [,step])
Faire des operations multiples: +, -, *, / , **

a= 10 x5= a//b Choice(seq), uniform(x,y)
b = 20 Seed(x), shuffle(list)
x=a+b
x2=a-b à essayer!!
x3=a*b
x4= a/b (avec virgule flottante)
x5=a**2+ b**2
Notions basiques
Les variables: boolean
>>> 3>4
Valeurs: False --→ false
True
Vous pouvez tester d’autres exemples

Opérations: >>> (3>1) and (0>1)
not, and, or
Comparaison: bool(b) -→ forcer une variable b à être

==, !=, >, >=, < et <= booléenne.
:

Notions basiques
Les variables: texte
a= ‘administration’ Longueur: len(a)

a= ‘’administration’’ Parcourir:
For x in a:
print(x)
Si plusieurs lignes:
a=‘ ‘ ‘L’administration………………………
………………………………………………… On peut verifier la presence d’un mot:
………………. if “administration" in a:
………………………………’ ‘ ‘ print("oui")
Ou ‘’ ‘’ ‘’ …………’’ ‘’ ‘’

Notions basiques
a= ‘administration’ b=‘amal , imen’ format() pour inserer un int dans un string

L’indexation d’une liste commence par 0:
H=60
print(a[2:5]) =>‘min’ txt = "My name is Amal, and I am {}"
print(txt.format(H))
print(a[:5]) => ‘admin’
print(a[-5:-2]) => ‘io’ txt = 'It\'s alright.’ # caractère spécial
print(txt)
a.strip()=> élimine les espaces du début et du fin
a.replace(“m", “b")=> ‘adbinistration’ \t: tabulation
\n: nouvelle ligne
b.split(",") => [‘amal’, ‘imen’]
c=a+b
print(c) =>?
Notions basiques
a= ‘administration’ b=‘amal , imen’ myDict = {"name": "John", "country":

L’indexation d’une liste commence par 0: "Norway"}
mySeparator = " "
x = mySeparator.join(myDict)
isnumeric(): vérifie s’il y a un nombre dans le
string
myTuple = ("John", "Vicky")

x = "#".join(myTuple)

Notions basiques
Exercices :
Inverser le texte suivant en éliminant les caractères spéciaux et en les remplaçant par des espaces:
animaux = "girafe:tigre:singe::souris“.
Calculer le nombre d’apparition du caractère i.

Notions basiques Changer la valeur d’un item:
L1[0]=2
Les variables: séquences -> List
Pour insérer un item:
L1.insert(1, 88)=>[12,88,5,0,11,13]
L1.remove(88)=>[12, 5, 0, 11, 13] #valeur
Un ensemble d’items possédant chacun une L1.pop(1)=>[12,0,11,13] #index
indexation.
la duplication des valeurs est permise, À partir d’une liste vide:
Type d’items pour une liste: int, str, boolean, list L1=[ ]
Une liste peut contenir plusieurs types L1.append(88)
L1=[12, 5, 0, 11, 13]
List() est le constructeur de création d’une liste: Associer deux listes:
L1= List((12,5,0,11,13)) L2=[0,0,0,0]
L1[0]=>12 L1.extend(L2) )=>[12,88,5,0,11,13,0,0,0,0]
L1[:2]=>[12,5]
L1[-1]=>13
del L1 => supprime la liste
L1.clear() => liste vide
Notions basiques
Pour parcourir une liste: [x+2 for x in thislist]

L1 =[12,5,0,3,13] La méthode la plus courte et efficace
for x in L1:
print(x)
for i in range(len(L1)): Exercice:

print(L1[i]) L1=[‘karim’,’salma’,’hamdi’, ‘Youssef’,’lili’]
Afficher les noms qui intègrent la letter ‘a’
i=0
while i < len(L1):
print(L1[i])
i=i+1

Notions basiques
sort() est utilisé pour ordonner les items Pour copier une liste:
(ascendant), s’il s’agit de string, c’est l’ordre L1.copy()
alphabétique qui est considéré. Ou
L1=[‘karim’,’salma’,’hamdi’, ‘Youssef’,’lili’] L2=List(L1)
print(L1.sort()) Pour joindre deux listes:

L3=L1+L2
Ou
Ordre descendant : for x in L2:
L1.sort(reverse=True) L1.append(x)
Ou
L1.extend(L2)
L1.reverse()=> renverser l’ordre des items
L1.index(‘karim’)=>0

Notions basiques
Les variables: séquences -> Tuple
Pour forcer la modification:
Tuple ->list -> tuple:
C’est un ensemble d’éléments qui ne peuvent pas x = ("apple", "banana", "cherry")
changer après la création, pas d’ajout d’éléments ni y = list(x)
de suppression. y[1] = "kiwi"
Duplication possible. x = tuple(y)
Len()
Un tuple peut inclure plusieurs types à la fois:
L1=tuple((‘karim’, 100, 20, ‘aicha’)) Possibilité d’ajouter tuple1 à tuple 2:
L1[0]=>’karim’ L1 = ("apple", "banana", "cherry")
L1[-1]=>’aicha’ L2= ("orange",)
L1 += L2
if “aicha" in L1:
print("Yes") Del L1=> supprime L1

Notions basiques
Les variables: séquences -> Tuple
Subdiviser le tuple: Pour dupliquer le contenu d’un tuple plusieurs fois:

pers = (“amine", “karime", “salma") n=2
(a, b, c) = pers pers = (“amine", “karime", “salma")
print(a) L1 = pers * n
print(b)
print(c)
Le matching n’est pas equitable:* count():Renvoie le nombre de fois qu'une valeur
pers = (“amine", “karime", “salma“, “imen”) apparaisse dans le tuple.
(a,b,*c)=pers index (): Recherche l’indexe une valeur spécifiée
c=>[“salma”, “imen”] liste

Notions basiques
Les variables: séquences -> Set
Pour supprimer un élément d'un ensemble, utilisez la
méthode remove () ou discard().
Un ensemble est une collection non ordonnée, non pers.remove(“taha")
modifiable* et non indexée.
Pas de duplication.
1 et True sont considérés une duplication et ne
peuvent pas figurer dans un set Pour éliminer le 1er item on utilise pop().
pers.pop() -> élimine amine
pers = {“amine", “karime", “salma“}
pers.add(“taha")
set3 = set1.union(set2) #union
Pour ajouter plusieurs élements: set3=set1.update(set2) #union
Pers1={“nada”,”jamel”} set4= set1.intersection(set2) #intersection
pers.update(pers1) set1.issubset(set2)=> true si tt elt ds set1 existent ds
set2

Notions basiques
my_dict = {
1: "Hello",
Les variables: mappage -> Dict
(1, 2): "Hello Hi",
3: [1, 2, 3] }
len(my_dict)=>3
Un dictionnaire est une collection ordonnée,
modifiable et qui n'autorise pas les doublons. Accéder à une Valeur à travers key:
Composé de :key et value. my_dict[1]=>”Hello”
my_dict[1]= “amal”
Les clés (key) de dictionnaire doivent être
inchangeables, telles que les tuples, les chaînes,
les entiers, etc. Nous ne pouvons pas utiliser Ajouter un élément au dictionnaire en attribuant une
d'objets mutables (changeables) tels que les valeur à une nouvelle clé:
listes comme clés. my_dict[2]=2
Ou
Les valeurs :values: sont mutables. dict2={5:”rim”}
my_dict.update(dict2)

Notions basiques Un dict peut contenir un dict:
Les variables: mappage -> Dict myfamily = {

"child1" : {
"name" : "Emil",
"year" : 2004
for x in my_dict.values(): },
Try itprint(x)
Yourself » "child2" : {
"name" : "Tobias",
"year" : 2007
for x in my_dict.keys(): },
print(x) "child3" : {
"name" : "Linus",
"year" : 2011
for x, y in my_dict.items(): }
print(x, y)
myfamily["child2"]["name"]=>”Tobias”

Notions basiques
Créer un dict:
myfamiy.keys()=>[child1, child2, child3]
Try it Yourself »
Myfamily.get[‘child1’]=> {
"name" : "Emil", nombre_de_pneus = {}
"year" : 2004 nombre_de_pneus["voiture"] = 4
} nombre_de_pneus["vélo"] = 2
myfamily.popitem()=> supprime le dernier

item
myfamily.pop(“child1”)=> supprime cet item

Notions basiques
myfamily = {
"child1" : {
"name" : "Emil",
myfamiy.keys()=>[child1, child2, child3] "year" : 2004
Try it Yourself »
Myfamily.get[‘child1’]=> { },
"name" : "Emil", "child2" : {
"year" : 2004 "name" : "Tobias",
} "year" : 2007
},
myfamily.popitem()=> supprime le dernier "child3" : {
item "name" : "Linus",
myfamily.pop(“child1”)=> supprime cet item "year" : 2011
}

Notions basiques
Les boucles: WHILE, FOR
Semblable à java for x in range(6):
i=1 if x == 3:
while i < 6: print(x)
Tryprint(i)
it Yourself » break
if (i == 3): else:
break print("Finally finished!")
i += 1
i=1 adj = ["red", "big", "tasty"]

while i < 6: fruits = ["apple", "banana", "cherry"]
print(i)
i += 1 for x in adj:
else: for y in fruits:
print("i is no longer less than 6") print(x, y)

Notions basiques
Exercices:
• Générer la liste de Fibonacci à partir d’un entier donné en input :90
0 1 1 2 3 5 8 13 21 34 55 89
Try it Yourself »
• Vérifier si une liste est un palindrome. (L1=[1,2,3,2,1])
Utiliser jupyter notebook

Notions basiques
Les Fonctions Vs Méthodes
Une méthode est définit au sein d’une

Try it Yourself
classe: »
class nomClasse:
def nom_methode(parameters):
# Statements…
Nom_objet.nom_methode(arguments)

Notions basiques def test():
b=5
Les Fonctions
print(a, b)
a=2 Variables globales, visibles dans ma
def nom_fonction(liste de paramètres):
b=7 fonction mais le contraire n’est pas vrai
bloc d'instructions
test()
TryFaire appel à»la function:
it Yourself Fait appel à la fonction
nom_function(paramètres)
def compteur_complet(start, stop, step): li = [1,2,3]
i = start new = list(map(lambda x:x+1, li))
print(new)
while i < stop:
print(i) Une fonction dite
i = i + step anonyme
compteur_complet(1, 7, 2)

Notions basiques
Les Fonctions
Nous pouvons inclure une fonction dans une autre, appelée fonction imbriquée.
Nous pouvons passer une fonction comme argument à une autre fonction en Python.
Try itPar exemple:
Yourself »
def add(x, y):
return
return x ++ yy
def calculate(func, x, y):
y):
return
return func(x, y)y) greeting(name):
def greeting(name):
result = calculate(add, 4, 6) def hello():
print(result) # prints
prints 10
10 return "Hello,
return "Hello, " + name
name + "!"
"!"
return hello
return hello
Nous pouvons retourner une fonction greet
greet == greeting(“Amal")
greeting(“Amal")
print(greet()) # prints
prints "Hello, Amal!“
Amal!“

Notions basiquesdef make_pretty(func):
# define the inner function
def inner():
Les Fonctions: @decorateur # add some additional behavior to the decorated function
print("I got decorated")
Un décorateur Python est une fonction # call original function
qui prend une fonction et la renvoie en func()
ajoutant des fonctionnalités: # return the inner function
Try it Yourself » return inner
# define ordinary function
def ordinary():
print("I am ordinary")
# decorate the ordinary function
C’est le décorateur decorated_func = make_pretty(ordinary)
# output???

Notions basiques
Exemples: @decorateur def smart_divide(func):
def inner(a, b):
def make_pretty(func):
print("I am going to divide", a, "and", b)
def inner():
if b == 0:
print("I got decorated")
print("Whoops! cannot divide")
func()
Return
return inner
Try it Yourself » return func(a, b)
@make_pretty
return inner
def ordinary():
@smart_divide
print("I am ordinary")
def divide(a, b):
ordinary()
print(a/b)
divide(2,5)
=Smart_divide(divide(2,5))

Notions basiques
L'opérateur * utilisé lors de la définition d'une fonction
signifie que tous les arguments de position
Fonction: args, kargs supplémentaires passés à la fonction se retrouvent dans
la variable précédée d'un *
def multiply(*args): On peut considérer les kwargs comme un dictionnaire

z=1 qui mappe chaque mot-clé à la valeur que nous lui
for num in args: transmettons.
Try it Yourself »
z *= num
print(z)
multiply(4, 5)
def myFun(**kwargs):
multiply(10, 9)
for key, value in kwargs.items():
multiply(2, 3, 4)
print("%s == %s" % (key, value))
multiply(3, 5, 10, 6)
# Driver code
myFun(first='Geeks', mid='for', last='Geeks')

Notions basiques map(function, iterable)
Fonction: lambda def square(n):
filter, map, reduce return n ** 2
squares = list(map(square, range(1, 10, 2)))
Fonction très utilisée:
Exemple: def find_odd(x):
x = lambda a : a + 10 if x % 2 != 0:
Try it Yourself » return x
print(x(5))
nums = [1, 34, 23, 56, 89, 44, 92]
Elle peut prendre plusieurs arguments mais une seule odds = list(filter(find_odd, nums))
expression: filter(function, iterable)
x = lambda a, b, c : a + b + c
print(x(5, 6, 2)) from functools import reduce
nums = [1, 2, 3, 4, 5]
summ = reduce(lambda x, y: x + y, nums)

Notions basiques
POO
La programmation orientée objets se base sur la définition des objets:
Chaque objet possède: des propriétés, un comportement.
Un objet c’est une instance d’une classe qui possède des attributs et des méthodes.
Try Une
it Yourself » comme un template pour la creation des objets
classe est
class C:
Classe X x=12
Les attributs c=2
Les méthodes
def affich1():
print(’amal’)
objet1 objet2 objet3

Notions basiques
Attribut class: partagés par
POO toutes les instances
class C: C1=C() #instance objet C1
x=12 C1.affich1()
y=2 C1.e=list[0,1,2,3]
print(C1.x) # attributs instance C1
Try it Yourself » def affich1(self):
print(self.x+self.y) Attribut instance: lié à

l’instance
il est possible d’ajouter de nouveaux attributs d’instance

(ici le C1.z = 44) ou même de nouveaux attributs de
classe (ici C.z = 6).

class C :
Notions basiques ”””Documentation de la classe C.”””
x = 23 # attibut de classe
a = C()
POO print(a.x)
a.x = 12 # modifie son attribut d’instance
(attention...)
Try •it Yourself
Les classes
» peuvent utiliser les variables a.x # 12
définies au niveau principal mais elles ne C.x # 23 mais l’attribut de classe est
peuvent pas les modifier. inchangé
• Les instances peuvent utiliser les variables C.z = 6 # z : nouvel attribut de classe
définies au niveau de la classe mais elles ne a.y = 44 # y : nouvel attribut de l’instance a
peuvent pas les modifier. b = C() # b est un autre objet de la classe C
(une autre instance)
b.x # 23 : b connaît bien son attribut de
classe, mais...
b.y # ... b n’a pas d’attribut y !

Notions basiques
POO telephone_portable
Instanciation d’objets id
Via init() Couleur,
Prix,
Try it Yourself »
Id_marque
Permet d’initialiser un objet avec
__init__() des valeurs
faireDesAppels()
Jouer() Tel1=telephone_portable(val1,
val2, val3)
def __init__(self, val1, val2, val3): À ce niveau la fonction init est
self.couleur = val1 appelée directement.
self.prix=val2
self.Id_marque=val3

Notions basiques
POO
Exercice:
Créer une fonction qui prend un argument n et crée n objets de la classe
Employé
Corriger l’erreur au niveau du code
Try it Yourself »
class Employee:
def __init__(self, emp_id):
self.emp_id = emp_id
def create_employees(n):
employee_list = []
for i in range(n):
employee_list.append(Employee(i))

Notions basiques
POO
Classe et instanciation d’objets: property property(fget=None, fset=None, fdel=None, doc=None)
la fonction property() offre une interface pour manipuler
les instances des attributs.
class Voiture():
def __init__(self):
Try it Yourself » Généralement on utilise les @property -> decorateur au
self._roues=4 lieu de cette
def _get_roues(self):
"Récupération du nombre de roues"
return self._roues
def _set_roues(self, v):
"Changement du nombre de roues"
self._roues = v ma_voiture=Voiture()
roues=property(_get_roues, _set_roues) ma_voiture.roues=5 # mise à jour
Print(ma_voiture.roues)
Notions basiques class Person:
def __init__(self, name):
POO self._name = name
Classe et instanciation d’objets:@property @property
def name(self):
Les décorateurs nous permettent d'envelopper une print('Getting name...’)
autre fonction afin d'étendre le comportement de la return self._name
Try itfonction
Yourselfenveloppée
» sans l'affecter de manière @name.setter
permanente. def name(self, value):
print('Setting name to:', value)
Au lieu d'utiliser Python property(), vous pouvez self._name = value
également assigner le getter, le setter et le deleter en @name.deleter
utilisant le décorateur Python @property def name(self):
print('Deleting name...’)
del self._name
p = Person('David’)
print(p.name)
p.name = 'Rocky’
del p.name
Notions basiques
POO
Classe et instanciation d’objets :
quelques fonctions utiles
Try it Yourself »
La fonction dir énumère la liste des méthodes
relatives à l’objet
dir(personne) ??
__dict__ renvoie les valeurs de l’attribue de

l’instance
p.__dict__ -→?
Notions basiques
L’héritage
La classe client hérite de la classe

utilisateur.
Try Pour la déclaration
it Yourself » de l’héritage:
Classe fille(nom de la classe mère)
Si la classe fille possède plusieurs

attributs à initialiser :
class MaClasseFille(MaClasseMere):
def __init__(self):
super().__init__() NB: L’accès au code de la classe mère se fait à travers
… super().
Notions basiques
L’héritage
L’hériage multiple est possible:
La surcharge est possible:
• Attributs class Client(Utilisateur, Enseignant):
• Fonctions def __init__(self):
Try it Yourself »
Utilisateur.__init__(self)
Pour un attribut, il suffit de remplacer sa valeur dans la classe Enseignant.__init__(self)
fille:
Chaque client étant à la fois un
class Client(Utilisateur):
utilisateur et un enseignant, il peut
def __init__(self):
hériter des deux classes.
Utilisateur.__init__(self)
self.user_name = ‘Karim'
Attention aux fonctions ayant le
Pour une fonction, il suffit de la réécrire. meme nom dans les classes mères.

Python - DS 1 55

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Python - DS 1 55

Transféré par

Droits d'auteur :

Formats disponibles

Cours Python

Presented By PhD Amal TRIFA

Presented By PhD Amal TRIFA

Deux versions principalement:

Presented By PhD Amal TRIFA

1. Libre et open source

Presented By PhD Amal TRIFA

Presented By PhD Amal TRIFA

l'interpréteur va exécuter les lignes du code une par

(+) Dans un langage interprété, le même code

Exemple: PhP, Javascript, python, Java

Presented By PhD Amal TRIFA

(+)Dans un langage compilé, le

Presented By PhD Amal TRIFA

Presented By PhD Amal TRIFA

Tout est objet en python!!!

Presented By PhD Amal TRIFA

Une large communauté

Presented By PhD Amal TRIFA

Pour pouvoir exécuter du python , il faut avoir un interpréteur et un IDE:

Presented By PhD Amal TRIFA

PyPy: écrit en python, offre une portabilité extrême.

Presented By PhD Amal TRIFA

Python utilise l'indentation pour indiquer un bloc de code.

Presented By PhD Amal TRIFA

Presented By PhD Amal TRIFA

Le type est attribué dynamiquement.

Presented By PhD Amal TRIFA

and del from None True as elif global

Presented By PhD Amal TRIFA

Séquences: list, tuple

ensemble: set, frozenset

Presented By PhD Amal TRIFA

Presented By PhD Amal TRIFA

Presented By PhD Amal TRIFA

Forcer la conversion en un type spécifique (casting): Créer un nombre aléatoire:

Faire des operations multiples: +, -, *, / , **

Vous pouvez tester d’autres exemples

Comparaison: bool(b) -→ forcer une variable b à être

Presented By PhD Amal TRIFA

a= ‘administration’ Longueur: len(a)

Presented By PhD Amal TRIFA

a= ‘administration’ b=‘amal , imen’ format() pour inserer un int dans un string

a= ‘administration’ b=‘amal , imen’ myDict = {"name": "John", "country":

myTuple = ("John", "Vicky")

Presented By PhD Amal TRIFA

Calculer le nombre d’apparition du caractère i.

Presented By PhD Amal TRIFA

Pour parcourir une liste: [x+2 for x in thislist]

for i in range(len(L1)): Exercice:

Presented By PhD Amal TRIFA

print(L1.sort()) Pour joindre deux listes:

Presented By PhD Amal TRIFA

Presented By PhD Amal TRIFA

Subdiviser le tuple: Pour dupliquer le contenu d’un tuple plusieurs fois:

Presented By PhD Amal TRIFA

Presented By PhD Amal TRIFA

Presented By PhD Amal TRIFA

Les variables: mappage -> Dict myfamily = {

Presented By PhD Amal TRIFA

myfamily.popitem()=> supprime le dernier

Presented By PhD Amal TRIFA

Presented By PhD Amal TRIFA

dict renvoie les valeurs de l’attribue de