Ce sont des tableaux où les objets sont indexés à partir de 0.

On peut atteindre un objet depuis son

Les bases de Python # indice :

>>> L = ["a", "b", "c"] # Les listes sont notées entre [ ]

>>> L[2] # le TROISIEME élément de L
1. Bloc d’instruction # 'c'

En Python chaque ligne donne une instruction. Pour séparer certains blocs ( fonctions, conditions, Les listes sont mutables. On peut les modifier modifier
boucles etc.) on utilise l’indentation (4 espaces). Les commentaires sont précédés d’un # et ne sont
pas exécutés.
>>> L.pop(0) # renvoyer l'élément 0 et l'effacer de la liste
'a'
>>> L
note = 20 # instruction ['b', 'c'] # la liste a bien été modifiée.
if note == 20: # condition >>> L.append("d") # ajouter un élément à la fin de la liste
print("super note !") # n'est effectué que si x vaut 20 >>> L
print("au revoir") # sera toujours effectué ['b', 'c', 'd']

La syntaxe Python impose de respecter l’indentation. Chaque bloc qui est indenté est précédé du
symbole : c) Les tuples #

Ce sont des séries indexées d’objets. Ils sont notés avec des parenthèses. Les tuples ne sont pas
Opérations de base : #
mutables. C’est comme les listes, mais pas mutable et plus rapide.

Exemple résultat opération >>> tup = (1, 2, 3)

(1, 2, 3)
3+2 5 somme >>> tup.pop(0)
3-2 -1 soustraction Traceback (most recent call last):
File "<stdin>", line 1, in <module>
3*2 6 produit AttributeError: 'tuple' object has no attribute 'pop'
3 ** 2 9 puissance
3/2 1.5 division
3 // 2 1 quotient
d) Les dictionnaires (tables de hashage), type dict #
3%2 1 reste

Ce sont des tables d’associations entre une clé et une valeur. On les notes entre accolades.
Certaines agissent différemment selon l’objet : 'a' + 'b' == 'ab' Attention, dans les accolades on utilise : .

Les dictionnaires sont mutables.

2. Affecter #
>>> dict = {"DS": 5, "DM": 1} # remarquez les :
Pour affecter une valeur à une variable on utilise la notation variable = valeur . >>> dict["DM"] # obtenir un élément d'un dictionnaire
1
>>> dict["IE"] = 2 # ajouter une nouvelle paire clé:valeur
>>> del dict["DM"] # del permet d'effacer un élément d'un mutable
>>> dict
Par exemple note = 20 . On peut inclure n’importe quel objet Python dans une variable. {"DS": 5, "IE": 2}

3. Types de base # Les conditions : if elif else #

 int : les entiers naturels. Ex: 2  Permettent de réaliser des choix ou de tester des résultats.

 float : les nombres à virgule flottantes. Ex: 3.14  s’utilisent dans cet ordre : if, elif (optionnel), else (optionnel)

 boolean : les booléens. Ex True, False, a != b

La syntaxe est :

On obtient le type d’un objet avec la fonction type :

if condition_1: # les : sont obligatoires !
bloc execute si condition_1 est True # indentation !!!
>>> type(4) elif condition_2:
<class 'int'> bloc execute si condition_1 est False et condition_2 True
>>> type(1 != 2) else:
<class 'bool'> bloc execute si condition_1 est False et condition_2 False
bloc toujours execute car pas indente

4. Types complexes #  Les comparaisons entre nombres sont : ==, >, <, >=, <=, !=

 On peut tester si un objet est dans un autre avec in

On a déjà rencontré quatre types complexes : str , list , tuple et dict .

>>> 4 in [1, 2, 3]
False
>>> "DM" in {"DS": 5, "DM": 1}
a) Les chaînes de caractères. Type str #
True

Ce sont des séries de caractères affichables à l’écran (simplification abusive). En Python 3 ils
sont encodés en utf-8 . On en reparlera. On les note avec des apostrophes ou des guillemets.  On peut tester plusieurs conditions grace aux opérateurs booléens and et or

Chaque caractère est numéroté et on peut l’atteindre avec son indice.

Attention c’est un simplification et and et or sont en réalité plus compliqués.

>>> chaine = "Bonjour"

>>> chaine[0]
'B' Les boucles : for et while #

Les chaînes de caractères ne sont pas mutables. Mais on peut opérer dessus ! Il existe deux types de boucles :

>>> "Bonjour" + "Papy" # concaténation

'BonjourPapy'
>>> "Bonjour {}".format("Diego") # formatage, version 1  for quand on veut parcourir un objet ou qu’on connait le nombre d’étapes.
'Bonjour Diego'
>>> nom = "Robert"
>>> f"Bonjour {nom}" # formatage, version 2
 while quand on ne connait pas le nombre d’étapes.
'Bonjour Robert'

Boucle for #
b) Les tableaux ou listes. Type list #

En Python, for parcourt toujours une collection d’objet (un itérable).

 
On construit une série de nombres avec range(debut, fin, pas) . Attention on s’arrête toujours avant fin .
Une fonction se définit avec def nom(parametre): suivi d’un bloc indenté.

>>> for k in range(0, 3, 1): # k varie de 0 à 2 avec un pas de 1  On retourne une valeur avec return truc_de_sortie
... k # indentation !!!
...
0
1 def carre(x):
2 '''
documentation : détaillé ci-dessous
'''
return x ** 2
On peut parcourir une liste, un tuple, une chaîne ou un dictionnaire (vu plus tard).

>>> for nombre in [0, 2, 4]: Documentation #

... nombre ** 2
...
0
4 Quand vous définissez une fonction, vous devez toujours la documenter.
16
>>> for lettre in 'abc':
... lettre
'a'
'b' La documentation est dans une chaîne sur plusieurs lignes entre triples apostrophes. On y trouve :
'c'

 La description rapide de la fonction

Boucle while

#

les paramètre d’entrée :

Effectuer quelque chose tant qu’une condition est vraie.  les paramètres retournés :

 un exemple, quand c’est faisable :

Pour arrêter une boucle while il faut que la condition devienne FAUSSE.

'''
Renvoie le carré d'un nombre
Exemple : chaque mois je gagne 100€. Combien de mois avant d’avoir 2.000€ ? @param x: (int ou float)
@return: (int ou float)
>>> carre(2)
4
>>> mois = 0 # sera mon compteur '''
>>> somme = 0 # je vais ajouter mes revenus dans somme
>>> while somme < 2000: # tant que ma somme est plus petite que 2000...
... somme = somme + 100 # je cumule ma somme
... mois = mois + 1 # et je compte
...
>>> mois # remarquez que mois contient la bonne valeur...
Indications de types #

20

On peut considérablement abréger la documentation en indiquant les types.

Boucle infinie

Plutôt que d’écrire :

 On exécute une boucle infinie avec while True:


def somme_trois_nombres(a, b, c):
Pour l’arrêter, on peut utiliser le mot clé break """
Renvoie la somme des trois nombres.

@param a: (int)
@param b: (int)
@param c: (int)
Fonctions # @return: (int)
"""
return a + b + c

Qu’est ce qu’une fonction ? #

On peut se contenter de :

Les fonctions sont des morceaux de code qu’on peut appeler quand on le souhaite. def somme_trois_nombres(a: int, b: int, c: int) -> int:
"""Renvoie la somme des trois nombres."""
return a + b + c

On doit d’abord définir la fonction avant de l’appeler.

entrée != saisie et sortie != affichage #

Les fonctions, comme en maths, prennent des paramètres d’entrée et retournent toujours une valeur.

Si elle font autre chose, comme afficher du texte ou modifier la mémoire, on parle d’ effet de bord.  utiliser input permet de demander à l’utilisateur d’un programme de taper une valeur.
Ce n’est pas le paramètre d’entrée d’une fonction

 utiliser print affiche du texte, ce n’est pas le paramètre de sortie d’une fonction.
Exemples # Paramètre de sortie : return

Par exemple, len est une fonction qui renvoie la longueur d’un itérable.
Les erreurs ou exceptions #
>>> len("abcd")
4

Lire les messages d’erreur #

 Son paramètre d’entrée est un itérable ( list, tuple, dict, str etc.)
Quand un programme génère une erreur, Python lève une exception.
 Sa valeur de retour est un int

 À ma connaissance elle n’a pas d’effet de bord. Il affiche alors un message commençant par Traceback et se lisant de bas en haut :

>>> l = [0, 1, 2]
Autre exemple, print est une fonction qui prend une chaîne ou n’importe quel objet qu’on peut écrire
>>> l[4]
à l’écran et qui l’affiche. Elle renvoie None (rien). Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range

 Son paramètre d’entrée est une chaîne ou n’importe quel objet affichable

 Sa valeur de retour est None (rien…)  Le type d’exception : IndexError

 Son effet de bord et d’afficher à l’écran quelque chose.  la ligne : 1

 d’autres informations (par exemple quelle série d’appels de fonctions a provoqué

cette erreur)
Définir une fonction #

Les erreurs courantes sont : #

Erreurs produises quand Python lit le fichier .py : 14. Exercices corrigés▲

 IndentationError : mélange entre espaces et tabulations ou indentation incorrecte 14-1. Énoncés des exercices▲

 SyntaxError : oublier des parenthèses, oublier : après if , print 3 ,

Les exercices suivants sont fournis à titre d'exemple et de

Erreurs produites durant l’exécution du programme lui même :
modèles.

Ils sont soit simples, soit moins simples (notés ? dans le titre)
 ZeroDivisionError : division par 0,
soit plus difficiles (notés ??).
 IndexError : aller chercher un élément inexistant dans une liste,

 ValueError : racine carrée d’un nombre négatif etc. 14-2. Exercices▲

 TypeError : réaliser une opération impossible sur ce type ( len(print) ),

 AssertionError : quand un test avec assert est faux 14-2-1. Numéro 1▲

>>> assert 2 == 3 Écrire un programme qui, à partir de la saisie d'un rayon et d'une hauteur, calcule le
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
volume d'un cône droit.
AssertionError

14-2-2. Numéro 2▲
try: ... except Exception as e: ... #

Une boucle while : entrez un prix HT (entrez o pour terminer) et affichez sa valeur
On peut attraper une exception prévisible avec try except . C’est à la limite du programme mais vous TTC.
le rencontrerez souvent dans le code.

14-2-3. Numéro 3▲
C’est un procédé courant, en particulier pour gérer les saisies d’utilisateur.

Une autre boucle while : calculez la somme d'une suite de nombres positifs ou nuls.
Comptez combien il y avait de données et combien étaient supérieures à 100.

Entrer un nombre inférieur ou égal à 0 indique la fin de la suite.

14-2-4. Numéro 4▲

L'utilisateur donne un entier positif n� et le programme affiche PAIR s'il est divisible
par 2, IMPAIR sinon.

14-2-5. Numéro 5▲

L'utilisateur donne un entier positif et le programme annonce combien de fois de suite

cet entier est divisible par 2.

14-2-6. Numéro 6 ?▲

L'utilisateur donne un entier supérieur à 1 et le programme affiche, s'il y en a, tous ses

diviseurs propres sans répétition ainsi que leur nombre. S'il n'y en a pas, il indique qu'il
est premier. Par exemple :

Sélectionnez

Entrez un entier strictement positif : 12

Diviseurs propres sans répétition de 12 : 2 3 4 6 (soit 4

diviseurs propres)

Entrez un entier strictement positif : 13

Diviseurs propres sans répétition de 13 : aucun ! Il est

premier

14-2-7. Numéro 7▲

Écrire un programme qui approxime par défaut la valeur de la constante

mathématique e�, pour n� assez grand (56) , en utilisant la formule :

e≈∑i=0n1i!�≈∑�=0�1�!

Pour cela, définissez la fonction factorielle et, dans votre programme principal, saisissez
l'ordre n� et affichez l'approximation correspondante de e�.
14-2-8. Numéro 8▲
chaîne : attgcaatggtggtacatg

Un gardien de phare va aux toilettes cinq fois par jour. Or les WC sont au rez-de-
séquence : ca
chaussée…
Il y a 10.53 % de "ca" dans votre chaîne.

Écrire une procédure (donc sans return) hauteurParcourue qui reçoit deux
paramètres, le nombre de marches du phare et la hauteur de chaque marche (en cm), et 14-2-12. Numéro 12▲
qui affiche :

Il s'agit d'écrire, d'une part, un programme principal et, d'autre part, une fonction
utilisée dans le programme principal.

La fonction listAleaInt(n, a, b) retourne une liste de n entiers aléatoires

Sélectionnez dans [a .. b] en utilisant la fonction randint(a, b) du module random.

Pour x marches de y cm, il parcourt z.zz m par semaine. Dans le programme principal :

On n'oubliera pas :
 construire la liste en appelant la fonction listAleaInt() ;

 calculer l'index de la case qui contient le minimum ;

 qu'une semaine comporte 7 jours ;
 échangez le premier élément du tableau avec son minimum.
 qu'une fois en bas, le gardien doit remonter ;

 que le résultat est à exprimer en m.

14-2-13. Numéro 13▲

14-2-9. Numéro 9▲ Comme précédemment, il s'agit d'écrire, d'une part, un programme principal et, d'autre
part, une fonction utilisée dans le programme principal.

Un permis de chasse à points remplace désormais le permis de chasse traditionnel.

Chaque chasseur possède au départ un capital de 100 points. S'il tue une poule, il perd 1 La fonction listAleaFloat(n) retourne une liste de n flottants aléatoires en utilisant
point, 3 points pour un chien, 5 points pour une vache et 10 points pour un ami. Le la fonction random() du module random.
permis coûte 200 euros.

Dans le programme principal :

Écrire une fonction amende qui reçoit le nombre de victimes du chasseur et qui renvoie
la somme due.

 saisir un entier n dans l'intervalle : [2 .. 100] ;

Utilisez cette fonction dans un programme principal qui saisit le nombre de victimes et
qui affiche la somme que le chasseur doit débourser.  construire la liste en appelant la fonction listAleaFloat() ;

 afficher l'amplitude du tableau (écart entre sa plus grande et sa plus petite

14-2-10. Numéro 10▲ valeur) ;

 afficher la moyenne du tableau.

Je suis ligoté sur les rails en gare d'Arras. Écrire un programme qui affiche un tableau
me permettant de connaître l'heure à laquelle je serai déchiqueté par le train parti de la
gare du Nord à 9 h (il y a 170 km entre la gare du Nord et Arras).
14-2-14. Numéro 14▲

Le tableau prédira les différentes heures possibles pour toutes les vitesses de 100 km/h
à 300 km/h, par pas de 10 km/h, les résultats étant arrondis à la minute inférieure. Fonction renvoyant plusieurs valeurs sous forme d'un tuple.

Écrire une fonction minMaxMoy() qui reçoit une liste d'entiers et qui renvoie le
 Écrire une procédure tchacatchac qui reçoit la vitesse du train et qui minimum, le maximum et la moyenne de cette liste. Le programme principal appellera
affiche l'heure du drame ; cette fonction avec la liste : [10, 18, 14, 20, 12, 16].

 Écrire le programme principal qui affiche le tableau demandé.

14-2-15. Numéro 15▲

14-2-11. Numéro 11 ?▲
Saisir un entier entre 1 et 3999 (pourquoi cette limitation ?). L'afficher en nombre
romain.
Un programme principal saisit une chaîne d'ADN valide et une séquence d'ADN valide
(valide signifie qu'elles ne sont pas vides et sont formées exclusivement d'une
combinaison arbitraire de "a", "t", "g" ou "c"). 14-2-16. Numéro 16 ?▲

Écrire une fonction valide qui renvoie vrai si la saisie est valide, faux sinon.
Améliorer le script précédent en utilisant la fonction zip().

Écrire une fonction saisie qui effectue une saisie valide et renvoie la valeur saisie sous
forme d'une chaîne de caractères. 14-2-17. Numéro 17▲

Écrire une fonction proportion qui reçoit deux arguments, la chaîne et la séquence et Un tableau contient n� entiers (2<n<1002<�<100) aléatoires tous compris entre 0
qui retourne la proportion de séquence dans la chaîne (c'est-à-dire son nombre
et 500. Vérifier qu'ils sont tous différents.
d'occurrences).

Le programme principal appelle la fonction saisie pour la chaîne et pour la séquence 14-2-18. Numéro 18▲
et affiche le résultat.

Proposer une autre version plus simple du problème précédent en comparant les
Exemple d'affichage : longueurs des tableaux avant et après traitement ; le traitement consiste à utiliser une
structure de données contenant des éléments uniques.

Sélectionnez
14-2-19. Numéro 19▲
# Import

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
L'utilisateur donne un entier n� entre 2 et 12, le programme donne le nombre de façons
de faire n� en lançant deux dés. ~~~~~~~~

from sys import exit

14-2-20. Numéro 20▲

# Définition de fonction
Même problème que le précédent, mais avec n� entre 3 et 18 et trois dés.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

14-2-21. Numéro 21 ??▲ def verif(entree, reference, precision=0, comment="") :

"""Vérifie que <entree> est égal à <référence>, à la

Généralisation des deux questions précédentes. L'utilisateur saisit deux entrées, d'une
précision près."""
part le nombre de dés, nbd��� (que l'on limitera pratiquement à 10) et, d'autre part
la somme, s�, comprise entre nbd��� et 6.nbd6.���. Le programme calcule et print("{} [{}, {}]".format(comment, entree, reference),
affiche le nombre de façons de faire s� avec les nbd��� dés.
end="")

if abs(entree - reference) <= precision :

14-2-22. Numéro 22 ??▲
print(" *** ok")

Même problème que le précédent, mais codé récursivement. else :

print(" ### ko")

14-2-23. Numéro 23 ?▲

Nombres parfaits et nombres chanceux. # Auto-test

==============================================================

 On appelle nombre premier tout entier naturel supérieur à 1 qui possède =====
exactement deux diviseurs, lui-même et l'unité.
if __name__=='__main__' :
 On appelle diviseur propre de n, un diviseur quelconque de n, n exclu.
verif(abs(-6/2), 3, comment="\nTeste la fonction 'abs' :")
 Un entier naturel est dit parfait s'il est égal à la somme de tous ses
diviseurs propres.

 Un entier n� tel que : (n+i+i2)(�+�+�2) est premier pour pi = 3.142

tout i� dans [0,n−2][0,�−2] est dit chanceux. print("\npi = {}".format(pi))

verif(pi, 3.14, 1e-2, comment="à 1e-2 :") # Ok

Écrire un module (parfait_chanceux_m.py) définissant quatre
fonctions : somDiv, estParfait, estPremier, estChanceux et un autotest. verif(pi, 3.14, 1e-3, comment="à 1e-3 :") # Erreur

 La fonction somDiv retourne la somme des diviseurs propres de son

Puis écrire le programme principal (parfait_chanceux.py) qui comporte :

argument.

 Les trois autres fonctions vérifient la propriété donnée par leur définition et  l'initialisation de deux listes : parfaits et chanceux ;
retourne un booléen. Si par exemple la fonction estPremier vérifie que
son argument est premier, elle retourne True, sinon elle retourne False.  une boucle de parcours de l'intervalle [2,1000][2,1000] incluant les tests
nécessaires pour remplir ces listes ;

La partie de test doit comporter quatre appels à la fonction verif permettant de  enfin l'affichage de ces listes.
tester somDiv(12), estParfait(6), estPremier(31) et estChanceux(11).

14-3. Solutions des exercices▲

Exercice 1
Sélectionnez

Cacher le codeSélectionnez
# !/usr/bin/env python

# -*- coding : utf8 -*- # -*- coding : utf8 -*-

"""Module de vérification.""" """Volume d'un cône droit."""

#============================================================= # Import
================= ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# fichier : verif.py ~~~~~~~~
# from math import pi
# auteur : Bob Cordeau

#============================================================= # Programme principal

================= =========================================================

rayon = float(input("Rayon du cône (m) :"))

hauteur = float(input("Hauteur du cône (m) :"))

 if n%2 == 0:

volume = (pi*rayon*rayon*hauteur)/3.0 print(n, "est pair.")

print("Volume du cône =", volume, "m3") else :

Exercice 2 print(n, "est impair.")

Exercice 5
Cacher le codeSélectionnez

Cacher le codeSélectionnez
# -*- coding : utf8 -*-

"""Calcul d'un prix TTC.""" # -*- coding : utf8 -*-

"""Nombre de fois qu'un entier est divisible par 2."""

# Programme principal

========================================================= # Programme principal

prixHT = float(input("Prix HT (0 pour terminer) ?")) =========================================================

while prixHT > 0: n = int(input("Entrez un entier strictement positif :"))

print("Prix TTC : { :.2f}\n".format(prixHT * 1.196)) while n < 1:

prixHT = float(input("Prix HT (0 pour terminer) ?")) n = int(input("Entrez un entier STRICTEMENT POSITIF,

s.v.p. :"))

print("Au revoir !") save = n

Exercice 3

cpt = 0
Cacher le codeSélectionnez
while n%2 == 0:

# -*- coding : utf8 -*- n /= 2

"""Somme d'entiers et nombre d'entiers supérieurs à 100.""" cpt += 1

# Programme principal print(save, "est", cpt, "fois divisible par 2.")

========================================================= Exercice 6

somme, nombreTotal, nombreGrands = 0, 0, 0

Cacher le codeSélectionnez

x = int(input("x (0 pour terminer) ?")) # -*- coding : utf8 -*-

while x > 0: """Diviseurs propres d'un entier."""

somme += x

nombreTotal += 1 # Programme principal

if x > 100: =========================================================

nombreGrands += 1 n = int(input("Entrez un entier strictement positif :"))

x = int(input("x (0 pour terminer) ?")) while n < 1:

n = int(input("Entrez un entier STRICTEMENT POSITIF,

print("\nSomme :", somme) s.v.p. :"))

print(nombreTotal, "valeur(s) en tout, dont", nombreGrands,

"supérieure(s) à 100") i = 2 # plus petit diviseur possible de n

Exercice 4 cpt = 0 # initialise le compteur de divisions

p = n/2 # calculé une fois dans la boucle

Cacher le codeSélectionnez

# -*- coding : utf8 -*- print("Diviseurs propres sans répétition de", n, " :", end='

"""Parité.""" ')

while i <= p :

# Programme principal if n%i == 0:

========================================================= cpt += 1

n = int(input("Entrez un entier strictement positif :")) print(i, end=' ')

while n < 1: i += 1

n = int(input("Entrez un entier STRICTEMENT POSITIF,

s.v.p. :")) if not cpt :

print("aucun ! Il est premier.")

else : def permisSup(p, c, v, a) :

print("(soit", cpt, "diviseurs propres)") pointsPerdus = p + 3*c + 5*v + 10*a

Exercice 7 nbrePermis = pointsPerdus/100.0

return 200*nbrePermis
Cacher le codeSélectionnez

# -*- coding : utf8 -*- # Programme principal

"""Approximation de 'e'.""" =========================================================

poules = int(input("Combien de poules ?"))

# Définition de fonction chiens = int(input("Combien de chiens ?"))

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ vaches = int(input("Combien de vaches ?"))

def fact(n) : amis = int(input("Combien d'amis ?"))

r = 1

for i in range(1, n+1) : payer = permisSup(poules, chiens, vaches, amis)

r *= i

return r print("\nA payer :", end=' ')

if payer == 0:

# Programme principal print("rien à payer")

========================================================= else :

n = int(input("n ?")) print(payer, "euros")

exp = 0.0 Exercice 10

for i in range(n) :
Cacher le codeSélectionnez
exp = exp + 1.0/fact(i)

# -*- coding : utf8 -*-

print("Approximation de 'e' : { :.3f}".format(exp)) """Histoire de train."""

Exercice 8

# Définition de fonction
Cacher le codeSélectionnez
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

# -*- coding : utf8 -*- def tchacatchac(v) :

"""Gardien de phare.""" """Affiche l'heure du drame."""

heure = 9 + int(170/v)

# Définition de fonction minute = (60 * 170 / v) % 60

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ print("A { :>3} km/h, je me fais déchiqueter à { :>2} h

def hauteurParcourue(nb, h) : { :.2f} min."

print("Pour { :d} marches de { :d} cm, il parcourt { :.2f} .format(v, heure, minute))

m par semaine !"

.format(nb, h, nb*h*2*5*7/100.0)) # Programme principal

=========================================================

# Programme principal i = 100

========================================================= while i <= 300:

nbMarches = int(input("Combien de marches ?")) tchacatchac(i)

hauteurMarche = int(input("Hauteur d'une marche (cm) ?")) i += 10

Exercice 11

hauteurParcourue(nbMarches, hauteurMarche)
Cacher le codeSélectionnez
Exercice 9

# -*- coding : utf8 -*-

Cacher le codeSélectionnez
"""Proportion d'une séquence dans une chaîne d'ADN."""

# -*- coding : utf8 -*-

"""Permis de chasse.""" # Définition de fonction

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

# Définition de fonction def valide(seq) :

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ """Retourne vrai si la séquence est valide, faux sinon."""

 ret = any(seq)

for c in seq : print("Avant échange :")

ret = ret and c in "atgc" print("\tt[0] =", t[0], "\tt[iMin] =", t[iMin])

return ret t[0], t[iMin] = t[iMin], t[0] # échange

print("Apres échange :")

def proportion(a, s) : print("\tt[0] =", t[0], "\tt[iMin] =", t[iMin])

"""Retourne la proportion de la séquence <s> dans la Exercice 13

chaîne <a>."""
Cacher le codeSélectionnez
return 100*a.count(s)/len(a)

# -*- coding : utf8 -*-

def saisie(ch) : """Amplitude et moyenne d'une liste de flottants."""
s = input("{ :s} :".format(ch))

while not valide(s) : # Import

print("'{ :s}' ne peut contenir que les chaînons 'a', ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
't', 'g' et 'c'" ~~~~~~~~
" et ne doit pas être vide".format(ch)) from random import seed, random
s = input("{ :s} :".format(ch))

return s # Définition de fonction

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Programme principal def listAleaFloat(n) :
========================================================= "Retourne une liste de <n> flottants aléatoires"
adn = saisie("chaîne") return [random() for i in range(n)]
seq = saisie("séquence")

# Programme principal
print('Il y a { :.2f} % de"{ :s}" dans votre chaîne.' =========================================================
.format(proportion(adn, seq), seq)) n = int(input("Entrez un entier [2 .. 100] :"))
Exercice 12 while not(n >= 2 and n <= 100) :

n = int(input("Entrez un entier [2 .. 100], s.v.p. :"))

Cacher le codeSélectionnez

# -*- coding : utf8 -*- seed() # initialise le générateur de nombres aléatoires

"""Echanges.""" t = listAleaFloat(n) # construction de la liste

# Import print("Amplitude : { :.2f}".format(max(t) - min(t)))

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ print("Moyenne : { :.2f}".format(sum(t)/n))

~~~~~~~~ Exercice 14

from random import seed, randint

Cacher le codeSélectionnez

# Définition de fonction # -*- coding : utf8 -*-

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ """Min, max et moyenne d'une liste d'entiers."""
def listAleaInt(n, a, b) :

"""Retourne une liste de <n> entiers aléatoires dans # Définition de fonction

[<a> .. <b>].""" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
return [randint(a, b) for i in range(n)] def minMaxMoy(liste) :

"""Renvoie le min, le max et la moyenne de la liste."""

# Programme principal min, max, som = liste[0], liste[0], float(liste[0])
========================================================= for i in liste[1:]:
seed() # initialise le générateur de nombres aléatoires if i < min :
t = listAleaInt(100, 2, 125) # construction de la liste min = i

if i > max :
iMin = t.index(min(t)) # calcule l'index du minimum de la max = i
liste som += i
 return (min, max, som/len(liste)) n -= 10

if n >= 9:

# Programme principal s += "IX"

========================================================= n -= 9

lp = [10, 18, 14, 20, 12, 16] if n >= 5:

s += "V"

print("liste =", lp) n -= 5

l = minMaxMoy(lp) if n >= 4:

print("min : {0[0]}, max : {0[1]}, moy : {0[2]}".format(l)) s += "IV"

Exercice 15 n -= 4

while n >= 1:
Cacher le codeSélectionnez
s += "I"

# -*- coding : utf8 -*- n -= 1

"""Nombres romains (version 1)."""

print("En romain :", s)

# Programme principal Exercice 16

=========================================================
Cacher le codeSélectionnez
n = int(input('Entrez un entier [1 .. 4000[ : '))

# -*- coding : utf8 -*-

while not(n >= 1 and n < 4000) : """Nombres romains (version 2)."""

n = int(input('Entrez un entier [1 .. 4000[, s.v.p. : '))

# globales

s = "" # Chaîne résultante ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~~~~~~

while n >= 1000: CODE = zip(

s += "M" [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9,

n -= 1000 5, 4, 1],

if n >= 900: [ "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX",

s += "CM" "V", "IV", "I"]

n -= 900 )

if n >= 500:

s += "D" # Définition de fonction

n -= 500 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

if n >= 400: def decToRoman(num) :

s += "CD" res = []

n -= 400 for d, r in CODE :

while num >= d :

while n >= 100: res.append(r)

s += "C" num -= d

n -= 100 return ''.join(res)

if n >= 90:

s += "XC" # Programme principal

n -= 90 =========================================================

if n >= 50: for i in range(1, 4000) :

s += "L" print(i, decToRoman(i))

n -= 50 Exercice 17

if n >= 40:
Cacher le codeSélectionnez
s += "XL"

n -= 40 # -*- coding : utf8 -*-

while n >= 10: """Liste d'entiers différents."""
s += "X"
# Import # Définition de fonction

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~~~~~~~~ def listAleaInt(n, a, b) :

from random import seed, randint """Retourne une liste de <n> entiers aléatoires entre <a>

et <b>."""

# Définition de fonction return [randint(a, b) for i in range(n)]

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

def listAleaInt(n, a, b) : # Programme principal

"""Retourne une liste de <n> entiers aléatoires entre <a> =========================================================

et <b>.""" n = int(input("Entrez un entier [1 .. 100] :"))

return [randint(a, b) for i in range(n)] while not(n >= 1 and n <= 100) :

n = int(input("Entrez un entier [1 .. 100], s.v.p. :"))

# Programme principal

========================================================= seed() # initialise le générateur de nombres aléatoires

n = int(input("Entrez un entier [1 .. 100] :")) avant = listAleaInt(n, 0, 500)

while not(n >= 1 and n <= 100) : apres = list(set(avant))

n = int(input("Entrez un entier [1 .. 100], s.v.p. :"))

if len(avant) == len(apres) :

# construction de la liste print("\nTous les éléments sont distincts.")

seed() # initialise le générateur de nombres aléatoires else :

t = listAleaInt(n, 0, 500) print("\nAu moins une valeur est répétée.")

print(avant)

# Sont-ils différents ? Exercice 19

tousDiff = True
Cacher le codeSélectionnez
i = 0

while tousDiff and i < (n-1) : # -*- coding : utf8 -*-

j = i + 1 """Jeu de dés (1)."""
while tousDiff and j < n :

if t[i] == t[j]: # Programme principal

tousDiff = False =========================================================
else : n = int(input("Entrez un entier [2 .. 12] :"))
j += 1 while not(n >= 2 and n <= 12) :
i += 1 n = int(input("Entrez un entier [2 .. 12], s.v.p. :"))

if tousDiff : s = 0
print("\nTous les éléments sont distincts.") for i in range(1, 7) :
else : for j in range(1, 7) :
print("\nAu moins une valeur est répétée.") if i+j == n :
print(t) s += 1
Exercice 18

print("Il y a { :d} façon(s) de faire { :d} avec deux

Cacher le codeSélectionnez
dés.".format(s, n))

# -*- coding : utf8 -*- Exercice 20

"""Liste d'entiers différents (seconde version)."""

Cacher le codeSélectionnez

# Import # -*- coding : utf8 -*-

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ """Jeu de dés (2)."""
~~~~~~~~

from random import seed, randint # Programme principal

=========================================================

n = int(input("Entrez un entier [3 .. 18] :"))

while not(n >= 3 and n <= 18) : I[j] += 1

n = int(input("Entrez un entier [3 .. 18], s.v.p. :")) else :

while I[j] == 6:

s = 0 I[j] = 1

for i in range(1, 7) : j += 1

for j in range(1, 7) : I[j] += 1

for k in range(1, 7) :

if i+j+k == n : print("Il y a { :d} façons de faire { :d} avec { :d}

s += 1 dés.".format(cpt, s, nbd))

Exercice 22

print("Il y a { :d} façon(s) de faire { :d} avec trois

Cacher le codeSélectionnez
dés.".format(s, n))

Exercice 21 # -*- coding : utf8 -*-

"""Jeu de dés (récursif)."""

Cacher le codeSélectionnez

# -*- coding : utf8 -*- # Globale

"""Jeu de dés (3).""" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~~~~~~~

# Globale MAX = 8

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~~~~~~~ # Définition de fonction

MAX = 8 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

def calcul(d, n) :

# Programme principal """Calcul récursif du nombre de façons de faire <n> avec

========================================================= <d> dés."""

nbd = int(input("Nombre de dés [2 .. { :d}] :".format(MAX))) resultat, debut = 0, 1

while not(nbd >= 2and nbd <= MAX) : if (d == 1) or (n == d) or (n == 6*d) : # conditions

nbd = int(input("Nombre de dés [2 .. { :d}], terminales

s.v.p. :".format(MAX))) return 1

else : # sinon appels récursifs

s = int(input("Entrez un entier [{ :d} .. if n > 6*(d-1) : # optimisation importante

{ :d}] :".format(nbd, 6*nbd))) debut = n - 6*(d-1)

while not(s >= nbd and s <= 6*nbd) : for i in range(debut, 7) :

s = int(input("Entrez un entier [{ :d} .. { :d}], if n == i :

s.v.p. :".format(nbd, 6*nbd))) break

resultat += calcul(d-1, n-i)

if s == nbd or s == 6*nbd : return resultat

cpt = 1 # 1 seule solution

else : # Programme principal

I = [1]*nbd # initialise une liste de <nbd> dés =========================================================

cpt, j = 0, 0 d = int(input("Nombre de dés [2 .. { :d}] :".format(MAX)))

while j < nbd : while not(d >= 2and d <= MAX) :

som = sum([I[k] for k in range(nbd)]) d = int(input("Nombre de dés [2 .. { :d}],

s.v.p. :".format(MAX)))

if som == s :

cpt += 1 # compteur de bonnes solutions n = int(input("Entrez un entier [{ :d} .. { :d}] :".format(d,

if som == 6*nbd : 6*d)))

break while not(n >= d and n <= 6*d) :

n = int(input("Entrez un entier [{ :d} .. { :d}],

j = 0 s.v.p. :"

if I[j] < 6: .format(d, 6*d)))

 verif(estParfait(6), True)

print("Il y a { :d} façon(s) de faire { :d} avec { :d} dés." verif(estPremier(31), True)

.format(calcul(d, n), n, d)) verif(estChanceux(11), True)

Exercice 23-1 Exercice 23-2

Cacher le codeSélectionnez Cacher le codeSélectionnez

# !/usr/bin/env python # !/usr/bin/env python

# -*- coding : utf8 -*- # -*- coding : utf8 -*-

"""Module pour les nombres parfaits et chanceux.""" """Nombres chanceux et parfaits."""

#============================================================= #=============================================================

================= =================

# fichier : parfait_chanceux_m.py # fichier : parfait_chanceux.py

# #

# auteur : Bob Cordeau # auteur : Bob Cordeau

#============================================================= #=============================================================

================= =================

# Définition de fonction # Import

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

def somDiv(n) : ~~~~~~~~

"""Retourne la somme des diviseurs propres de <n>.""" from parfait_chanceux_m import estParfait, estChanceux

som_div = 1

for div in range(2, (n//2)+1) : # programme principal

if n % div == 0: =========================================================

som_div += div parfait, chanceux = [], []

return som_div for n in range(2, 1001) :

if estParfait(n) :

def estParfait(n) : parfait.append(n)

"""Retourne True si <n> est parfait, False sinon.""" if estChanceux(n) :

return somDiv(n) == n chanceux.append(n)

def estPremier(n) : print("\nIl y a {} nombres parfaits dans [2, 1000] : {}"

"""Retourne True si <n> est premier, False sinon.""" .format(len(parfait), parfait))

return somDiv(n) == 1 print("\nIl y a {} nombres chanceux dans [2, 1000] : {}"

.format(len(chanceux), chanceux))

def estChanceux(n) :

"""Retourne True si <n> est chanceux, False sinon."""

est_chanceux = True

for i in range(0, n-1) :

est_chanceux = est_chanceux and estPremier(n + i +

i*i)

return est_chanceux
Révision[modifier | modifier le wikicode]
# Auto-test Dans ce qui suit, nous n'allons pas apprendre de
==============================================================
nouveaux concepts mais simplement utiliser tout ce que
nous connaissons déjà pour réaliser de vrais petits
=====
programmes.
if __name__== '__main__' :

from verif_m import verif

Contrôle du flux - Utilisation d'une liste
simple[modifier | modifier le wikicode]
verif(somDiv(12), 16)
Commençons par un petit retour sur les branchements se situe donc au même niveau que celles qui définissent
conditionnels (il s'agit peut-être là du groupe le corps principal du programme. L'instruction contenue
d'instructions le plus important dans n'importe quel dans cette ligne est donc toujours exécutée, alors que
langage !) : les deux suivantes (qui constituent encore un autre bloc)
ne sont exécutées que si la condition nn[2] > max est
vraie.
# Utilisation d'une liste et de branchements En suivant la même logique, on voit que les instructions
conditionnels
des deux dernières lignes font partie du bloc principal et
print ("Ce script recherche le plus grand de sont donc toujours exécutées.
trois nombres")
print ('Veuillez entrer trois nombres séparés Boucle while - Instructions
par des virgules : ')
# Note : la fonction list() convertit en liste
imbriquées[modifier | modifier le wikicode]
la séquence de données qu'on Continuons dans cette voie en imbriquant d'autres
# lui fournit en argument. L'instruction ci- structures :
dessous convertira donc les
# données fournies par l'utilisateur en une
liste nn : # Instructions composées <while> - <if> -
nn = list(input()) <elif> - <else>
max, index = nn[0], 'premier'
if nn[1] > max: # ne pas print 'Choisissez un nombre de 1 à 3 (ou zéro
omettre le double point ! pour terminer) ',
max = nn[1] a = input()
index = 'second' while a != 0: # l'opérateur != signifie
if nn[2] > max: "différent de"
max = nn[2] if a == 1:
index = 'troisième' print "Vous avez choisi un :"
print ("Le plus grand de ces nombres est", max) print "le premier, l'unique,
print ("Ce nombre est le", index, "de votre l'unité ..."
liste.") elif a == 2:
#Bonjour je me permets de rajouter mon print "Vous préférez le deux :"
code ,car le code proposé ne me permet pas de print "la paire, le couple, le duo ..."
trouver le max dans une liste elif a == 3:
print "Vous optez pour le plus grand
print ("Ce script recherche le plus grand de des trois :"
trois nombres") print "le trio, la trinité, le
print ('Veuillez entrer trois nombres un par triplet ..."
un : ') else :
print "Un nombre entre UN et TROIS,
nn=[] s.v.p."
for i in range(3): print 'Choisissez un nombre de 1 à 3 (ou
a=int(input()) zéro pour terminer) ',
nn.append(a) a = input()
print "Vous avez entré zéro :"
m = max(nn) print "L'exercice est donc terminé."
if nn[0] == m:
m = nn[0]
index = 'premier' Nous retrouvons ici une boucle while, associée à un
elif nn[1] == m: # ne pas groupe d'instructions if, elif et else.
omettre le double point !
m = nn[1] L'instruction while est utilisée ici pour relancer le
index = 'second' questionnement après chaque réponse de l'utilisateur
else: (du moins jusqu'à ce que celui-ci décide de « quitter »
m = nn[2] en entrant une valeur nulle : rappelons à ce sujet que
index = 'troisième' l'opérateur de comparaison != signifie « est différent
print ("Le plus grand de ces nombres est", m)
de »). Dans le corps de la boucle, nous trouvons le
print ("Ce nombre est le", index, "de votre
liste.") groupe d'instructions if, elif et else (de la ligne 6 à la
ligne 16), qui aiguille le flux du programme vers les
différentes réponses, ensuite une instruction print et
Dans cet exercice, vous retrouvez à nouveau le
une instruction input() (lignes 17 & 18) qui seront
concept de « bloc d'instructions », déjà abondamment
exécutées dans tous les cas de figure : notez bien leur
commenté aux chapitres 3 et 4, et que vous devez niveau d'indentation, qui est le même que celui du
absolument assimiler. Pour rappel, les blocs bloc if, elif et else, Après ces instructions, le
d'instructions sont délimités par l'indentation. Après la programme boucle et l'exécution reprend à
première instruction if, par exemple, il y a deux lignes l'instruction while (ligne 5). Les deux dernières
indentées définissant un bloc d'instructions. Ces instructions print (lignes 19 & 20) ne sont exécutées qu'à
instructions ne seront exécutées que si la condition la sortie de la boucle.
nn[1] > max est vraie.

La ligne suivante, par contre (celle qui contient la Exercices

deuxième instruction if) n'est pas indentée. Cette ligne
1. Que fait le programme ci-dessous, Attention : un triangle rectangle peut
dans les quatre cas où l'on aurait être isocèle.
défini au préalable que la variable a 28. Demander à l'utilisateur qu'il entre un
vaut 1, 2, 3 ou 15 ? nombre. Afficher ensuite : soit la
racine carrée de ce nombre, soit un
2. if a !=2: message indiquant que la racine
3. print 'perdu' carrée de ce nombre ne peut être
4. elif a ==3: calculée.
5. print 'un instant, s.v.p.'
29. Convertir une note scolaire N
6. else :
7. print 'gagné' quelconque, entrée par l'utilisateur
sous forme de points (par exemple 27
sur 85), en une note standardisée
8. Que font ces programmes ? suivant le code suivant :

9. a = 5
10. b = 2
11. if (a==5) & (b<2):
12. print '"&" signifie "et"; on
peut aussi utiliser le mot
"and"'
13. a, b = 2, 4
14. if (a==4) or (b!=4):
15. print 'gagné'
16. elif (a==4) or (b==4):
17. print 'presque gagné'
18. a = 1
19. if not a:
20. print 'gagné'
21. elif a:
22. print 'perdu'
23. Reprendre le programme c) avec a =
0 au lieu de a = 1. Que se passe-t-il ?
Conclure !
24. Écrire un programme qui, étant
données deux bornes entières a et b,
additionne les nombres multiples de 3
et de 5 compris entre ces bornes.
Prendre par exemple a = 0, b = 32 ®
le résultat devrait être alors 0 + 15 +
30 = 45.
Modifier légèrement ce programme
pour qu'il additionne les nombres
multiples de 3 ou de 5 compris entre
les bornes a et b. Avec les bornes 0
et 32, le résultat devrait donc être : 0
+ 3 + 5 + 6 + 9 + 10 + 12 + 15 + 18 +
20 + 21 + 24 + 25 + 27 + 30 = 225.
25. Déterminer si une année (dont le
millésime est introduit par l'utilisateur)
est bissextile ou non. (Une année A
est bissextile si A est divisible par 4.
Elle ne l'est cependant pas si A est un
multiple de 100, à moins que A ne
soit multiple de 400).
26. Demander à l'utilisateur son nom et
son sexe (M ou F). En fonction de
ces données, afficher « Cher
Monsieur » ou « Chère
Mademoiselle » suivi du nom de
l'élève.
27. Demander à l'utilisateur d'entrer trois
longueurs a, b, c. À l'aide de ces trois
longueurs, déterminer s'il est possible
de construire un triangle. Déterminer
ensuite si ce triangle est rectangle,
isocèle, équilatéral ou quelconque.
Note
N >= 80 %
80 % > N >= 60 %
60 % > N >= 50 %
50 % > N >= 40 %
N < 40 %
30. Soit la liste suivante :
['Jean-Michel', 'Marc',
'Vanessa', 'Anne',
'Maximilien', 'Alexandre-
Benoît', 'Louise']
Ecrivez un script qui affiche chacun
de ces noms avec le nombre de
caractères correspondant.
31. Écrire une boucle de programme qui
demande à l'utilisateur d'entrer des
notes d'élèves. La boucle se
terminera seulement si l'utilisateur
entre une valeur négative. Avec les
notes ainsi entrées, construire
progressivement une liste. Après
chaque entrée d'une nouvelle note (et
donc à chaque itération de la boucle),
afficher le nombre de notes entrées,
la note la plus élevée, la note la plus
basse, la moyenne de toutes les
notes.
32. Ecrivez un script qui affiche la valeur
de la force de gravitation s'exerçant
entre deux masses de 10000 kg ,
pour des distances qui augmentent
suivant une progression géométrique
de raison 2, à partir de 5 cm (0,05
mètre). La force de gravitation est
régie par la formule
Exemple d'affichage :
33. d = .05 m : la force vaut
2.668 N
34. d = .1 m : la force vaut
0.667 N
35. d = .2 m : la force vaut
0.167 N
 36. d = .4 m : la force vaut 42. print "L'année", a, ch,
0.0417 N "bissextile."
37. etc. 43.
44. Variante (proposée par Alex
Misbah) :
45. a=input('entrée une année:')
46.
Solution (cliquez) 47. if (a%4==0) and ((a%100!=0) or
(a%400==0)):
48. print a,"est une année
1. Réfléchissez ! bissextile"
2. Réfléchissez ! 49. else:
3. Réfléchissez ! 50. print a,"n'est pas une
année bissextile"
51.
4. # Traitement de nombres entiers 52. Variante (de Mik)
compris entre deux limites 53. a=input('année:')
5. 54. if (a%4==0 and a%100!=0)or(a
6. print "Veuillez entrer la %400==0):
limite inférieure :", 55. print "bi6"
7. a = input() 56. else:
8. print "Veuillez entrer la 57. print "nbi6"
limite supérieure :",
9. b = input()
10. s = 0 # somme 58.
recherchée (nulle au départ) 59. Réfléchissez !
11. # Parcours de la série des
nombres compris entre a et b : 60. from sys import exit #
12. n = a # module contenant des fonctions
nombre en cours de traitement système
13. while n <= b: 61.
14. if n % 3 ==0 and n % 5 ==0: 62. print """
# variante : 'or' au lieu de 63. Veuillez entrer les longueurs
'and' des 3 côtés
15. s = s + n 64. (en séparant ces valeurs à
16. n = n + 1 l'aide de virgules) :"""
17. 65. a, b, c = input()
18. print "La somme recherchée 66. # Il n'est possible de
vaut", s construire un triangle que si
chaque côté
19. 67. # a une longueur inférieure à
la somme des deux autres :
68. if a < (b+c) and b < (a+c) and
20. # Années bissextiles c < (a+b) :
21. 69. print "Ces trois longueurs
22. print "Veuillez entrer l'année déterminent bien un triangle."
à tester :", 70. else:
23. a = input() 71. print "Il est impossible de
24. construire un tel triangle !"
25. if a % 4 != 0: 72. exit() # ainsi
26. # a n'est pas divisible par l'on n'ira pas plus loin.
4 -> année non bissextile 73.
27. bs = 0 74. f = 0
28. else: 75. if a == b and b == c :
29. if a % 400 ==0: 76. print "Ce triangle est
30. # a divisible par 400 - équilatéral."
> année bissextile 77. f = 1
31. bs = 1 78. elif a == b or b == c or c == a
32. elif a % 100 ==0: :
33. # a divisible par 100 - 79. print "Ce triangle est
> année non bissextile isocèle."
34. bs = 0 80. f = 1
35. else: 81. if a*a + b*b == c*c or b*b +
36. # autres cas ou a est c*c == a*a or c*c + a*a == b*b
divisible par 4 -> année :
bissextile 82. print "Ce triangle est
37. bs = 1 rectangle."
38. if bs ==1: 83. f = 1
39. ch = "est" 84. if f == 0 :
40. else: 85. print "Ce triangle est
41. ch = "n'est pas" quelconque."
86. 133. min = 500
87. Variante (de Mik) # valeur supérieure à toute
88. a,b= input('a:'),input('b:') note
89. if b>a: 134. max, tot, i = 0, 0,
90. print '"c":](',b-a,'); 0
(',a+b,')[' 135. nn = len(notes)
91. else: # nombre de notes déjà entrées
92. print '"c":](',a-b,'); 136. while i < nn:
(',a+b,')[' 137. if notes[i] >
93. c=input('c:') max:
94. if a < (b+c) and b < (a+c) and 138. max =
c < (a+b) : notes[i]
95. print 'bien un triangle' 139. if notes[i] <
96. else: min:
97. print 'impossible 140. min =
constrution triangle' notes[i]
98. exit() 141. tot = tot +
99. if a>b and a>c: notes[i]
100. max=a 142. moy = tot/nn
101. x=c*c+b*b 143. i = i + 1
102. elif b>a and b>c: 144. print nn, "notes
103. max=b entrées. Max =", max, "Min =",
104. x=c*c+a*a min, "Moy =", moy
105. elif c>b and c>a:
106. max=c
107. x=a*a+b*b 145.
108. if a==b and b==c : 146.Réfléchissez !
109. print "triangle
équilatéral."
110. elif a==b or b==c or c==a : Exercices[modifier | modifier le wikicode]
111. print "triangle
isocèle." Exercice 1[modifier | modifier le wikicode]
112. elif x==max**2 :
113. print "triangle Écrire un programme qui affiche "Bonjour le monde".
rectangle." Solution
114. else:
115. print "triangle
quelconque."
print ("Bonjour le monde")

116.
117. Réfléchissez ! Exercice 2[modifier | modifier le wikicode]
118. Réfléchissez !
119. Réfléchissez ! Écrire un programme qui permet de saisir le nom de
l'utilisateur et de renvoyer "Bonjour", suivi de ce nom.
120. # Notes de travaux (3 solutions possibles)
scolaires
121. Solution 1
122. notes = [] #
liste à construire nom = input ("Quel est
123. n = 2 # votre nom ? ")
valeur positive quelconque pour print ("Bonjour", nom)
initier la boucle
124. while n >= 0 :
125. print "Entrez la note
suivante, s.v.p. : ",
126. n = float(raw_input()) Solution 2
# conversion de l'entrée en un
nombre réel print ("Bonjour", input
127. if n < 0 : ("Quel est votre nom ? "))
128. print "OK.
Terminé."
129. else:
130. notes.append(n)
# ajout d'une note à la liste Solution 3
131. # Calculs divers
sur les notes déjà entrées : name = input("Quel est
132. # valeurs minimale votre nom ? ")
et maximale + total de toutes print("Bonjour " + name +
les notes. "!")
Exercice 3[modifier | modifier le wikicode]
avez',age,'ans.')
Écrire un programme qui demande à l'utilisateur la
saisie de a et b et affiche la somme de a et de b.
Solution Exercice 5[modifier | modifier le wikicode]
Écrire un programme qui demande à l'utilisateur les
coordonnées de deux points dans le plan et qui calcule
a = input ("Valeur de a :
puis affiche la distance entre ces deux points selon la
")
b = input ("Valeur de b : formule :
")
a= int (a)
b= int (b) Solution
print ("Somme de a+b =
",a+b)

En version 3.1 cela pourrait être import math

print ("xA?")
xA = int(raw_input())
var_a = int(input("Donnez print ("yA?")
moi la valeur de a: ")) yA = int(raw_input())
var_b = int(input("Donnez print ("xB?")
moi la valeur de b: ")) xB = int(raw_input())
print ("yB?")
print("Voici le résultat de yB = int(raw_input())
a + b :" , var_a + var_b , print ("distance entre A et
"!") B:", math.sqrt( (xA-xB)**2
+ (yA-yB)**2))

Exercice 4[modifier | modifier le wikicode] En version 3.1

Écrire un programme qui demande à l'utilisateur son

année de naissance et qui affiche son âge. L'année import math
courante sera mise dans une variable.
xA = int(input("Donnez moi
Solution Xa"))
yA = int(input("Donnez moi
Ya"))
# Ce script ne gère pas si xB = int(input("Donnez moi
l'anniversaire est passé ou Xb"))
non d'où le "environ" yB = int(input("Donnez moi
annee_courante = 2016 Yb"))
print ("Quelle est votre
année de naissance ?") distance = math.sqrt((xB -
reponse = raw_input() xA)**2 + (yB - yA)**2)
print ("Vous avez environ",
annee_courante- print("Bonjour, la distance
int(reponse),"ans") qui sépare les deux points
est de " + str(distance))

Pour Python 3.1

# Ce script gère si
l'anniversaire est passé

from datetime import

datetime
dn=input('Votre date de
naissance ? (format
jj/mm/aaaa) :')
dn=dn.split('/');jn=int(dn[
0]);mn=int(dn[1]);an=int(dn
[2])
da=datetime.now()
if mn<da.month or
(mn==da.month and
jn<=da.day):
age=da.year-an
else:
age=da.year-an-1
print('Vous