Mon cour pensée logique et programmation

2TI1 PENSÉE COMPUTATIONNELLE & PROGRAMMATION
NESRINE HLILOU 1
Les types numériques :
Le type entier: l’ensemble des entiers
relatifs (ℤ)
Exemple : 2, -5, -1, 0, 122,…
Entier int
Le type réel : l’ensemble des réels (ℝ).
Exemple : -3.5, -1, 0, 12.33, …
Réel float
Somme + +
Soustraction - -
Mutiplication * *
Puissance : n=ab
Cette fonction n’existe pas dans la
convention algorithmique !!! On la
developpera ultérieurement.
n=a**b #ou bien
import math
n=math.pow(a,b)
Division (réelle)
➔ retourne toujours un réel.
exemple : 4/2 = 2.0
/ /
Division entière (euclidienne)
➔ retourne toujours un entier.
Exemple : 4 Div 2 = 2
Div //
Reste de la division entière
➔ retourne toujours un entier
Exemple : 20 Mod 6 = 2
Mod %

NESRINE HLILOU 2
Description: En Algorithme Implémentation en python:
Retourne la valeur absolue de x.
Exemple : Abs(-3)=3
Abs(x) abs(x)
Retourne l’entier le plus proche de la
valeur de x.
Exemple : Arrondi(5.2)=5
Arrondi (x) round(x)
Retourne la racine carrée d’un nombre x
positif.
Exemple : Racine carré(4)=2.0
RacineCarré (x)
from math import *
sqrt(x)
Retourne la partie entière de x.
Exemple : Ent(12.3)=12
Ent (x)
int(x) #ou
from math import *
trunc(x) # ou
floor(x)
Retourne un entier aléatoire de
l’intervalle [vi, vf].
Exemple : Aléa(0,1)= 0 ou 1
Aléa (vi,vf)
from random import *
randint(vi,vf)
:
1- Évaluer les expressions suivantes puis les réécrire en python :
5 + 2 * 3 – 12 Div 2 Mod 4 / 2 = 10.0 (réel)
En python : 5+2*3-12//2%4/2
Arrondi(Abs(-75.6)) = arrondi(75.6) = 76
En python : round(abs(75.6))
RacineCarré(16) = 4.0 (réel)
En python : from math import *
sqrt(16)
Ent(102.8)= 102 (entier)

NESRINE HLILOU 3
En python : from math import *
floor(102.8) (ou bien trunc(102.8) ou encore int(102.8))
Aléa(0,2) = 0 ou 1 ou 2 (entier)
En python : from random import randint
randint(0,2)
2- Résoudre les problèmes suivants :
Problèmes Implémentation en python:
Le Jeu d’échange consiste à tirer une
carte parmi 10 (numérotées de 1 à 10)
puis les échanger.
Simuler ce jeu contre l’ordinateur.
Exemple :
Entrer le numéro de votre carte : 9
J’ai choisi la carte numéro 6
Après échange ma carte est 9
Votre carte est 6
Algorithme echange
Début
écrire("entrer le N° de votre
carte")
lire(u)
o←aléa(1,10)
écrire("l'ordinateur a choisi",o)
z←o
o←u
u←z
écrire("ton numéro devient",u)
écrire("le numéro de l’ordinateur
devient",o)
Fin.
from random import randint
u=int(input("entrer le N° de votre carte
"))
o=randint(1,10)
print("l'ordinateur a choisi",o)
o,u=u,o
print("ton numéro devient",u)
print("le numéro de l’ordinateur
devient",o)
On désire faire le programme qui
calcule l’aire d’un trapèze en
demandant à l’utilisateur de saisir les
valeurs de la hauteur (h) , la base1 (b1)
et la base 2 (b2).
Algorithme trapeze
Début
Écrire("taper la grande base :")
lire(b1)
Écrire("taper la petite base :")
lire(b2)
Écrire("taper le coté a :") lire(a)
b1=float(input("taper la grande base :"))
b2=float(input("taper la petite base :"))
a=float(input("taper le coté a :"))
c=float(input("taper le coté c :"))
h=float(input("taper la hauteur h :"))
p=a+b1+b2+c
s=((b1+b2)*h)/2
print(s)
print(p)

NESRINE HLILOU 4
Écrire("taper le coté c :") lire(c)
Écrire("taper la hauteur h :")
lire(h)
p←a+b1+b2+c
s←((b1+b2)*h)/2
écrire("s=",s,"cm²")
écrire("p=",p,"cm")
fin.
print("s=",s,"cm²")
print("p=",p,"cm")
La distance entre deux points A(xa,ya)
et B(xb,yb) est calculée par la formule
suivante :
Calculer et afficher la distance entre
deux points A et B sachant que les
coordonnées sont des donnés.
Algorithme distanceAB
Début
Écrire("taper l’abscisse du point
A :")
lire(xa)
Écrire("taper l’ordonné du point
A :")
lire(ya)
Écrire("taper l’abscisse du point
B :")
lire(xb)
Écrire("taper l’ordonné du point
B :")
lire(yb)
AB←RacineCarré((xb-xa)*(xb-
xa)+(yb-ya)*(yb-ya))
Écrire("la distance entre A et
B :",AB)
Fin.
from math import sqrt
from turtle import *
xa=float(input("taper l’abscisse du point
A :"))
ya=float(input("taper l’ordonné du point A
:"))
xb=float(input("taper l’abscisse du point
B :"))
yb=float(input("taper l’ordonné du point B
:"))
penup()
goto(xa*37.8,ya*37.8)
pendown()
goto(xb*37.8,yb*37.8)
AB=sqrt((xb-xa)**2+(yb-ya)**2)
print("la distance entre A et B
:",AB,"cm")

NESRINE HLILOU 5
Représenter une somme d’argent
donnée en dinars par le maximum de
billets de 50d, 20d, 10d et le reste.
Exemple :
Entrer la somme d’argent à
représenter : 83
83d = 1 billet(s) de 50d, 1 billet(s) de
20d, 1 billet(s) de 10d et 3 d.
Algorithme monnaie
Début
écrire("Entrer la somme d’argent à
représenter : ")
lire(m)
a←m Div 50
b←m Mod 50 Div 20
c←m Mod 50 Mod 20 Div 10
r←m Mod 10
écrire(m,"d=",a,"billet(s) de
50d,",b,"billet(s) de
20d,",c,"billet(s) de 10d et",r,"d")
Fin.
Écrire un algorithme intitulé
INSERTION qui permet de saisir un
nombre N formé de deux chiffres et
insérer 0 entre ses deux chiffres.
Exemple : Si N = 12 on affiche 102.
Algorithme insertion
Début
écrire("taper un entier de 2
chiffres : ")
lire(N)
d←N Div 10
u←N Mod 10
r←d*100+u
écrire(N,"==>",R)
Fin.

NESRINE HLILOU 6
Écrire un algorithme intitulé CHIFFRES
qui permet d’afficher la somme des
chiffres d’un entier N de 3 chiffres.
Exemple :
pour N= 528
L’ordinateur affiche :
« Somme des chiffres de 528 = 15 »
Algorithme chiffres
Début
chiffres : ")
lire(N)
c←N Div 100
d←N Mod 100 Div 10
u←N Mod 10
r←c+d+u
écrire("la somme des chiffres
de",N,"=",s)
Fin.
Écrire un algorithme intitulé INVERSE
qui permet d’inverser un entier N de 4
chiffres.
Exemple :
Pour N= 5218
L’ordinateur affiche :
« 5218 inversé devient 8125 »
Algorithme inverse
Début
chiffres : ")
lire(N)
m←N Div 1000
c←N Mod 1000 Div 100
d←N Mod 100 Div 10
u←N Mod 10
r←u*100+d*100+c*10+m
écrire(N,"inversé devient",R)
Fin.

NESRINE HLILOU 7
Écrire un algorithme intitulé
CONVERSION et en déduire le
programme qui permet de saisir un
nombre binaire B formé de 4 chiffres
binaires (0 ou 1) puis de calculer et
d’afficher le nombre décimale D
correspondant.
-L’affichage doit être fait sous la forme
des exemples suivants :
B=1001➔D=(1*8)+(0*4)+(0*2)+(1*1)
➔D=9.
L’ordinateur affiche : 1001 binaire = 9
décimale.
Algorithme conversion_binaire
Début
écrire("taper un entier de 4 bits :
")
lire(B)
m←B Div 1000
c←B Mod 1000 Div 100
d←B Mod 100 Div 10
u←B Mod 10
r←m*8+c*4+d*2+u
écrire(B,"binaire =",R,"décimale")
Fin.

NESRINE HLILOU 8
Le contrôle de saisie :
Notez bien :
Contrôler la saisie de l’utilisateur signifie accepter seulement les données qui respectent les contraintes :
Exemple :
Si on veut lancer une application bloquée par un mot de passe on doit entrer un mot de passe valide.
En cas d’erreur on doit : Répéter
La saisie
Jusqu’à fournir un mot de passe correcte
Répéter
Traitement de saisie
Jusqu’à condition d’arrêt
Saisir un entier strictement positif :
Répéter
Ecrire("Saisir un entier strictement positif :")
Lire(e)
Jusqu’à (e > 0)

NESRINE HLILOU 9
Saisir un réel non nul :
Répéter
Ecrire("Saisir un réel non nul :")
Lire(r)
Jusqu’à( r ≠ 0)
Saisir un chiffre :
Répéter
Ecrire("Saisir un chiffre :")
Lire(c)
Jusqu’à (c ∈ [0. .9])
Saisir un entier pair :
Répéter
Ecrire("Saisir un entier pair :")
Lire(e)
Jusqu’à (e Mod 2 = 0)

NESRINE HLILOU 10
Saisir un entier impair :
Répéter
Ecrire("Saisir un entier impair :")
Lire(e)
Saisir un multiple de 5 :
Répéter
Ecrire("Saisir un entier multiple de 5 :")
Lire(e)
La condition d’arrêt peut retourner : Vrai ou Faux (True or False en python)
Si elle est Vrai la saisie est valide le programme quitte la boucle et passe à l’instruction suivante.
Si elle est Faux le programme reboucle et redemande la saisie de nouveau.
Vrai et Faux sont deux valeurs qui représentent le type Booléen (bool en python)

NESRINE HLILOU 11
Le type booléen :
Le résultat d’une opération de
comparaison.
Utilisé pour les test.
Booléen :
Vrai , Faux
bool
True , False
Egal = ==
Différent ≠ !=
Strictement supérieur > >
Supérieur ou égal >= >=
Strictement inférieur < <
Inférieur ou égal <= <=
Appartient ∈ in
Négation Non not
Conjonction Et and
Disjonction Ou or
1
( )
non
2
*, /, div, mod
et
3
+, -
ou

NESRINE HLILOU 12
4 =, ≠, <, >, <=, >=, ∈
Dans le cas ou on trouve plusieurs opérateurs ayant la même priorité on commence par le plus à gauche.
Applications :
1- Compléter la table de vérité suivante :
Expression A Expression B Non(A) A Et B A Ou B A Ouex B
Vrai Vrai Faux Vrai Vrai Faux
Vrai Faux Faux Faux Vrai Vrai
Faux Vrai Vrai Faux Vrai Vrai
Faux Faux Vrai Faux Faux Faux
2- Évaluer les expressions suivantes puis les implémenter en python :
non(8=8) = non Vrai = Faux
en python : not(8==8)
(5>2) et (3=3) = Vrai et Vrai = Vrai
En python : (5>2)and(3=3)
(20 div 2 < 20) ou (22 mod 4 div 2 >= 1) = (10<20) ou (2 div 2>=1) =Vrai ou Vrai = Vrai
En python : (20//2<20)or(22%4//2>=1)
(2 * 2 + 4 mod 3 = 5) ou (9 ≠ 9) = (4 + 1 =5) ou (9 ≠ 9) = Vrai ou Faux = Vrai
En python : (2*2+4%3==5)or(9!=9)
(12 - 24 / 2 * 3 > 0) ou (5 <= 10) = (12-36>0) ou (5<=10) = (-24>0) ou (5<=10) = Faux ou Vrai = Vrai
En python : (12-24/2*3>0)or(5<=10)
non(13 - 5 div 5 + 8 = 20) et (7 mod 10 ≠ 0) = non(13 - 1 + 8 =20) et (7 ≠ 0) non Vrai et Vrai = Faux et Vrai = Faux
En python : not(13-5//5+8==20)and(7%10!=0)
aléa(10,50)>=10 ou (25/5<5) = Vrai ou Faux = Vrai
en python : from random import randint
randint(10,50)>=10 or (25/5<5)
(arrondi(10.63)=10) ou (ent(RacineCarré(9))=3) = ((11=10) ou (3=3)) = Faux ou Vrai = Vrai
en python : from math import sqrt
(round(10.63)==10) or int(sqrt(9))==3)

NESRINE HLILOU 13
(arrondi(5/2) = 5) ou (ent(17/3)=5) et non(aléa(2,10) ∈ [2..10]) = (3=5) ou (5=5) et non Vrai = Faux ou Vrai et Faux = Faux
(round(5/2)==5)or(int(17/3)=5)and not(randint(2,10)in range(2,11)
non(aléa(5,10)>20) ou (arrondi(17.32)=17) et (3>=3) = non Faux ou Vrai et Vrai = Vrai
not(randint(5,10)>20) or (round(17.32)==17) and (3>=3)

NESRINE HLILOU 14
Les structures itératives : Les boucles
Appelées aussi répétitives
➔Rôle : Répétition d'un traitement
Nombre de répétition est
connu au préalable
Nombre de répétition est inconnu mais on connait la condition d'arrêt du traitement
n fois Au moins 1 fois Au moins 0 fois
La structure complète Pour :
Ou la boucle Pour
La structure à condition d’arrêt
Répéter…jusqu’à :
Ou la boucle Répéter
La structure à condition d’arrêt Tantque…faire:
Ou la boucle Tantque
Exemple : Tu vas aider ton petit frère à apprendre un poème donc tu peux lui demander :
Lis le poème 7 fois. Lis le poème jusqu’à l’apprendre Tant que tu n’as pas appris le poème répète le
Pour i de 1 à 7 faire
Lire le poème
Fin pour
Répéter
Lire le poème
Jusqu’à apprendre=vrai
Tantque apprendre=faux faire
Lire le poème
Fin tant que
1. Afficher le mot bonjour 3
fois.
pour i de 0 à 2 faire
écrire("bonjour")
fin pour
for i in range(3) :
print("bonjour")
2. Afficher les 100 premiers
entiers strictement positifs.
pour i de 0 à 99 faire
écrire(i)
fin pour
for i in range(100) :
print(i)
3. Afficher les entiers pairs
strictement positifs <= 100.
pour i de 2 à 100 pas=2 faire
écrire(i)
fin pour
for i in range(2,101,2) :
print(i)
4. Afficher les 100 premiers
entiers strictement positifs
dans un ordre décroissant.
pour i de 100 à 1 pas= -1 faire
écrire(i)
finpour
for i in range(100,0,-1) :
print(i)

NESRINE HLILOU 15
5. Afficher les caractères d'une
chaine ch chacun dans une
ligne.
pour i de 0 à long(ch)-1 faire
écrire(ch[i])
finpour
for i in range(len(ch)) :
print(ch[i])
6. Afficher le miroir (l’inverse)
d'une chaine de caractères
de longueur minimum 5
caractères saisie par
l’utilisateur.
Algorithme inverse
Début
répéter
écrire("ch=") lire(ch)
jusqu’à(long(ch)>=5)
ch1←""
pour i de long(ch)-1 à 0 pas=-1 faire
ch1←ch1+ch[i]
fin pour
écrire(ch,"inversée",ch1)
Fin.
ch=''
while(len(ch)<5):
ch=input("taper une chaine de
caractère ")
ch1=""
for i in range(len(ch)-1,-1,-1):
ch1=ch1+ch[i]
print(ch,"inversée",ch1)
7. Afficher les lettres d'une
chaine ch sous la forme
escalier :
Exp: Pour ch="AMAL
A
AM
AMA
AMAL
Algorithme escalier
Début
répéter
écrire("ch=") lire(ch)
jusqu’à(long(ch)>=3)
ch1←""
pour i de 0 à long(ch)-1 faire
écrire(sous_chaine(ch,0,i+1)
fin pour
Fin.
ch=''
while(len(ch)<3):
ch=input("taper une chaine de
caractère ")
ch1=''
for i in range(len(ch)):
ch[:i+1]

NESRINE HLILOU 16
8. Afficher le PGCD de deux
entiers strictement positifs
en utilisant la méthode de
différence.
Exp: Pour A=12 B=15
➔ PGCD(12,15)=PGCD(12,3
=PGCD(9,3)=PGCD(6,3)
=PGCD(3,3)=3
Algorithme PGCD_Difference
Début
répéter
écrire("taper un entier a>0") lire(a)
écrire("taper un entier b>0") lire(b)
jusqu’à(a>0 et b>0)
x←a
y←b
tant que a ≠ b faire
si a > b alors
a ← a - b
sinon
b ← b - a
fin si
fin tant que
écrire ("PGCD(",x,",",y,")=",a)
Fin
a=b=0
while not(a>0 and b>0):
a=int(input('taper un entier a>0
'))
b=int(input('taper un entier b>0
'))
x=a
y=b
while a!=b:
if a>b:
a=a-b
else:
b=b-a
print("PGCD(",x,",",y,")=",a)
9. Afficher le code binaire d'un
entier strictement positif.
Exp: Pour N=2 code binaire=10
Algorithme conversion_binaire
Début
répéter
écrire("n=") lire(n)
jusqu’à (n>0)
binaire←""
tant que n>0 faire
bit←n mod 2
binaire←convch(bit)+binaire
n←n div 2
fin tant que
écrire("Le code binaire est :", binaire)
Fin.
n=0
while(n<=0):
n=int(input("n="))
binaire=""
while n>0:
bit=n%2
binaire=str(bit)+binaire
n=n//2
print("Le code binaire est :",
binaire)

NESRINE HLILOU 17
Les structures de contrôle conditionnelles :
➔Rôle : Choisir un traitement en fonction d’une condition
Une condition Plusieurs conditions
Un traitement Deux traitements Plusieurs traitements
La structure
conditionnelle simple
La structure conditionnelle
complète
La structure conditionnelle
généralisée
La structure conditionnelle à
choix multiples
Exemples :
Avant de sortir de la
maison je vérifie s’il
pleut pour prendre mon
parapluie.
Pour résoudre un exercice je
peux demander l’aide de mon
père.
J’explique à mon petit frère la
nature d’un entier : positif,
négatif ou nul.
Dans une garderie Les enfants ont
le doit à choisir un seul menu
pour le déjeuner parmi plusieurs.
Si la pluie tombe alors
Je prends mon
parapluie
FinSi
Si je comprends l’exercice alors
Je le résous seul
Sinon
Mon père m’aide à le
résoudre
FinSi
Si l’entier = 0 alors
Il est nul
Sinon Si l’entier > 0 alors
Il est positif
Sinon
Il est négatif
FinSi
Selon choix
1 : Menu pizza
2 : Menu escalope
3 : Menu lasagne
Fin Selon
Formes générales :
Si condition alors
Traitement
FinSi
Si condition alors
Traitement1
Sinon
Traitement2
FinSi.
Si condition1 alors
Traitement1
Sinon Si condition2 alors
Traitement2
…………………………………………………
Sinon Si condition N-1 alors
Traitement N-1
Selon Sélecteur
Valeur1 : Traitement1
Valeur2, Valeur3 : Traitement2
Valeur4..Valeur6 : Traitement3
……………………………………………...
Sinon : TraitementN
Fin Selon

NESRINE HLILOU 18
Sinon
Traitement N
FinSi
Remarque : Le sélecteur doit
être de type scalaire (caractère
ou entier).
Problèmes En Algorithme Implémentation en python:
Saisir un réel x et
afficher sa racine
carrée.
Algorithme racine
Début
écrire("x=") lire(x)
si x>=0 alors
Rc ← RacineCarré(x)
écrire("la racine carré de",x,"=",Rc)
sinon
Écrire(x,"est négatif ➔ pas de racine
carré")
finsi
Fin.
import math
x=float(input("x="))
if x>=0:
Rc=math.sqrt(x)
print("la racine carré de",x,"=",Rc)
else:
print(x,"est négatif ==> pas de racine
carré")
Améliorer le
programme pour
afficher le message
la racine n’existe
pas.
Saisir une moyenne m et
afficher la mention :
- m≥17 : Très bien
- 15≤m<17 : Bien
- 12≤m<15 : Assez bien
- 10≤m<12 : Passable
- m<10 : Faible
Algorithme mention
Début
Répéter
écrire("m=") lire(m)
jusqu’à (0<=m<=20)
si m>=17 alors
mention ←"Très Bien"
sinon si m>=15 alors
mention ←"Bien"
mention ←"Assez Bien"
mention ←"Passable"
m=-1
while not(0<=m<=20):
m=float(input("taper votre moyenne "))
if m>=17 :
mention ="Très Bien"
elif m>=15 :
mention ="Bien"
elif m>=12 :
mention ="Assez Bien"
elif m>=10 :
mention ="Pasable"
else:
mention ="Faible"
print(m,"==>",mention)

NESRINE HLILOU 19
sinon
mention ←"Faible"
finsi
écrire(m,"➔",mention)
Fin.
Afficher la nature
d’une touche
appuyée par
l’utilisateur :
chiffre, lettre ou
symbole.
Algorithme touche
Début
Écrire("taper un caractère")
Lire(c)
Selon majus(c )
"0".."9" : msg←"chiffre"
"A".."Z" :
si majus(c) ∈["A","E","I","O","U","Y"]
alors
msg←"voyelle"
sinon
msg←"consonne"
fin si
sinon : msg←"symbole"
fin selon
écrire (c,"➔",msg)
Fin.
c=""
while(len(c)!=1):
c=input("taper un caractère ")
match c:
case c if "0"<=c<="9": msg="chiffre"
case c if "A"<=c.upper()<="Z":
if c.upper() in ["A","E","I","O","U","Y"]:
msg="voyelle"
else:
msg="consonne"
case _:msg="symbole"
print(c,"==>",msg)

NESRINE HLILOU 20
Les types alphanumériques :
- Le type caractère :
Regroupe :
*Les chiffres : "0".."9"
*Les lettres : "A".. "Z","a".."z",…
*Les signes de ponctuation :"?"…
*Les symboles : "+","/",""…
*Les caractères non imprimable comme
l’espace, tabulation…
➔Tous ces caractères sont ordonnés
selon leurs codes ASCII. (Voir tableau des
codes ASCII à l’annexe 1).
➔Sur le Type caractère on peut
appliquer :
- Les opérateurs relationnels pour la
comparaison.
- Les fonctions :
✓ Retourne le code ASCII du
caractère c.
✓ Retourne le caractère dont le
code ASCII est n.
Caractère
<, >, >=, <=, =, ≠, ∈
Exp : "A"<"B"=vrai
ord(c)
Exp : ord("A")=65
chr(n)
Exp : chr(97)="a"
Exp : "1"+"0"="10"
(Chaîne de 2 caractères)
≠ 1+0=1
str
#Chaîne d’un seul caractère
#Puisqu’en python il existe
un seul type #textuel chaîne
<, >, <=, >=, ==, !=, in
ord(c)
chr(n)

NESRINE HLILOU 21
- L’opérateur + permet la
concaténation : le résultat de la
concaténation est de type chaîne.
➔Une valeur de type caractère doit
figurer entre deux guillemets ou deux
apostrophes.
Exp : "A", "§","9" Exp : "A", ′§′,′9′
Évaluer les expressions suivantes :
ord("a")+ ord("z")=97 + 122=219
ord("A")+ord("Z ")=65+90=155
ord("0")+ord("9")=48+57=105
chr(ord("A")+32)=chr(65+32)=chr(97)="a"
chr(ord("b")-32) =chr(98-32)=chr(66)="B"
ord(chr(98))=98
chr(65)+chr(76)+chr(73)="A"+"L"+"I"="ALI"
"2"+"0"+"2"+"1"="2021"

NESRINE HLILOU 22

NESRINE HLILOU 23
Les types alphanumériques :
- Le type chaîne de caractères :
Permet de stocker la concaténation de
plusieurs caractères. La valeur chaîne
figure entre guillemets ou
apostrophes :
Exemples : "Algo ?", "Info2@", "101",
"1"…
Mais il existe aussi :
➢ "" : la chaîne vide.
➢ " " : la chaîne espace.
➔Les caractères qui forment une chaîne
possèdent un indice : sa position dans la
chaîne.
Donc on peut accéder à un caractère
dans une chaîne en utilisant son nom
suivi de l’indice entre accolades.
➔On peut modifier les caractères d’une
chaîne en algorithme directement ≠ en
python les chaînes sont immutables.
➔Objet immutable : un objet dont l'état
ne peut pas être modifié après sa
création.
Chaîne de caractères
Exp : ch="P Y T H O N"
0 1 2 3 4 5
Exp : ch[1] vaut "Y"
ch[0] vaut "P"
ch←"kalo"
ch[1]←"i"
ch devient "kilo"
str
ch[1]
ch[0]
ch[1]= "i" ➔ Interdit ➔
Erreur ➔ Une chaîne est un
objet immutable en python.
➔On doit la reconstruire :
ch=ch[0]+"i"+ch[2 :]

NESRINE HLILOU 24
➔Sur le Type chaîne on peut appliquer :
- Les opérateurs relationnels pour la
comparaison : La comparaison des
chaînes se fait caractère par caractère
selon le code ASCII.
- L’opérateur + permet la
concaténation.
- Les fonctions :
✓ Retourne le nombre de
caractère d’une chaîne.
✓ Retourne la première position
de la chaîne ch2 dans ch1, Si ch2
n’est pas dans ch1, elle retourne
-1.
✓ Retourne la conversion d’un
nombre x en une chaîne de
caractère
✓ Retourne vrai si la chaîne ch est
convertible en une valeur
numérique, sinon elle retourne
faux.
<, > ,>=,<=,=,≠,∈
Exp :
"ABC"<"Ab"=vrai➔ Car "B"<"b"
"a">"INFO" = vrai ➔ Car "a">"I"
Exp : ch←"Bon"+"jour"
➔ch="Bonjour"
Long(ch)
Exp : L←Long("PYTHON")➔L=6
Pos(ch2,ch1)
Exp :
p← Pos("m","Programme")➔p=6
p←Pos("r","Programme")➔p=1
p←Pos("R","Programme")➔p=-1
Convch(x)
Exp :
ch←Convch(120) ➔ch="120"
ch←Convch(15.5) ➔ch="15.5"
Estnum(ch)
Exp :
test←Estnum("Bon")➔ test=Faux
test←Estnum("1400")➔test=Vrai
<, >, <=, >=, ==, !=, in
ch="Bon"+"jour"
L=len("PYTHON")
ch1.find(ch2)
p="Programme".find("m")
str(x)
ch=str(120) ➔ ch="120"
ch=str(15.5) ➔ ch="15.5"
ch.isdecimal()

NESRINE HLILOU 25
✓ Retourne la conversion d’une
chaîne ch en une valeur
numérique, si c’est possible.
✓ Retourne une partie de la chaîne
ch à partir de la position d
jusqu’à la position f (f exclue).
✓ Retourne une sous chaîne de ch
après la suppression des
caractères de la position d à la
position f (f exclue)
✓ Convertit la chaîne ch en
majuscules.
Valeur(ch)
Exp :n←Valeur("2021") ➔n= 2021
x←Valeur("17.25")➔x=17.25
Sous_chaîne(ch,d,f)
Exp : ch←Sous_chaîne("Bonjour",0,3)
ch="Bon"
Effacer(ch,d,f)
Exp : ch←"Bonnejour"
ch←Effacer(ch,3,5)
➔ ch devient "Bonjour"
Majus(ch)
Exp : ch←Majus("Bon")➔ch="BON"
int(ch)#pour les entiers
float(ch)#pour les réels
ch[d:f]
ch="Bonjour"[0:3]
ch=ch[:d]+ch[f:]
Exp : ch=ch[:3]+ch[5:]
ch='Bon'+'jour'
ch='Bonjour'
ch.upper()
Évaluer les expressions suivantes :
Instruction en algorithme Instruction en python Résultat Type de
Résultat
ch1←convch (2021)
ch2←sous_chaine("Baccalauréat",0,3)
ch←ch2+ch1
ch1=str(2021)
ch2="Baccalauréat"[0:3]
ch=ch2+ch1
print(ch)
"Bac2021" Chaine de
caractères
(str)
ok←(majus("b")∈["B","o","n"]) et ("Papa"<"pi") ok="b".upper()in["B","o","n"]and
("Papa"<"pi")
Vrai(True) Booléen
(bool)

NESRINE HLILOU 26
ch←"On"+chr(ord("E")+32) ch="On"+chr(ord("E")+32) "One" Chaine de
caractères
(str)
ch←"Algorithme"
ch←Efface(ch,4,long(ch))
ch="Algorithme"
ch=ch[:4]
"Algo" Chaine de
caractères
(str)
ch←"12"
si Estnum(ch) alors
x←valeur(ch)+pos("2",ch)*pos("0",ch)
sinon
x←0
finsi
ch="12"
if ch.isdecimal():
x=int(ch)+ch.find("2")*ch.find('0')
else:
x=0
11 Entier (int)
ch←"Pithon"
ch[1]←"y"
ch="Pithon"
ch=ch[0]+"y"+ch[2:]
Python Chaine de
caractères
(str)

NESRINE HLILOU 27
Jeu Deviner mon nombre
Objectifs visés :
Les types de données.
Les structures simples.
Les structures conditionnelles.
Les structures itératives.
Le programme lit un entier qui se trouve dans l’intervalle donnée [min,max] durant un nombre d’essais maximum nbe.
Si l’entier saisi est égal à l’entier choisi par l’ordinateur le programme affiche : « bravo »
Si l’entier saisi est inférieur à l’entier choisi par l’ordinateur le programme affiche : « trop petit »
Si l’entier saisi est supérieur à l’entier choisi par l’ordinateur le programme affiche : « trop grand »
Exemple 1 d’exécution : Exemple 2 d’exécution :

NESRINE HLILOU 28
…………………………………………………………………………………………………………………………………………..
…………………………………………………………………………………………………………………………………………..
…………………………………………………………………………………………………………………………………………..
…………………………………………………………………………………………………………………………………………..
…………………………………………………………………………………………………………………………………………..
…………………………………………………………………………………………………………………………………………..
…………………………………………………………………………………………………………………………………………..
…………………………………………………………………………………………………………………………………………..
…………………………………………………………………………………………………………………………………………..
…………………………………………………………………………………………………………………………………………..
…………………………………………………………………………………………………………………………………………..
…………………………………………………………………………………………………………………………………………..
…………………………………………………………………………………………………………………………………………..
…………………………………………………………………………………………………………………………………………..
…………………………………………………………………………………………………………………………………………..
…………………………………………………………………………………………………………………………………………..
…………………………………………………………………………………………………………………………………………..
…………………………………………………………………………………………………………………………………………..
…………………………………………………………………………………………………………………………………………..

Mon cour pensée logique et programmation

Contenu connexe

Similaire à Mon cour pensée logique et programmation

Mon cour pensée logique et programmation