Le BN des bases de programmation avec Python 3 :

Nous avons découvert les bases de la programmation en Python 3 en nous appuyant sur les activités de la rubrique Cours et Problèmes proposées par FranceIOI.

Voici l'essentiel à retenir...

---

Ce document est un notebook jupyter, si vous n'êtes pas familiarisé avec cet environnement, regardez cette Introduction.

Les cellules si dessous sont éditables et exécutables. Vous pouvez exécuter une cellule à l'aide du bouton ou en utilisant le menu Cell>Run... ou encore en vous servant des touches :

• <Maj+Entrée> : le code de la cellule est exécuté et le curseur va à la cellule suivante.
• <Ctrl+Entrée> : le code de la cellule est exécuté et le curseur reste sur la même cellule.
• <Alt+Entrée> : le code de la cellule est exécuté et le notebook crée une nouvelle cellule immédiatement après.

Vous pouvez également ajouter une nouvelle cellule à l'aider du bouton .

Un des avantages principaux des notebooks est de vous permettre de modifier le code que nous avons écrit, et de voir par vous-même comment se comporte le code modifié.
Pour cette raison chaque élève dispose de sa propre copie de chaque notebook, ainsi vous pouvez bien sûr apporter toutes les modifications que vous souhaitez à vos notebooks sans affecter ceux des autres élèves et revenir à la version originale en rechargeant un notebook à partir du lien fourni.

---

Généralité :¶

Python) est un langage de programmation moderne imaginé par Guido Van Rossum , multi-plateforme, open-source, généraliste, orienté objet et de haut niveau.

Python n'a rien à voir avec le reptile du même nom, mais avec le groupe d'humoristes anglais des années 1970 Monty Python.

C'est un langage à la fois simple et puissant :

• simple car facile à apprendre, son code est réputé concis et clair, sa syntaxe est très proche d'une notation algorithmique, base de toute programmation.

• puissant car il possède une importante bibliothèque standard et un très grand nombre de paquets complémentaires dédiés au calcul scientifique et aussi pour de nombreux autres domaines d'application. C'est le langage retenu en Classe Préparatoire aux Grandes Ecoles...

Python est considéré comme un langage de conception rapide (Rapid Application Development).

C'est un langage interprété : pas besoin de compiler tout le programme source en code machine pour l'exécuter. L'interpréteur Python lit et exécute ligne après ligne un script codé en Python. Ce qui est un très gros avantage pour l'apprentissage d'un langage informatique car on peut tester progressivement des portions de code au cours du développement d'un programme plus complet.

Ceci est particulièrement favorisé dans un jupyter notebook qui permet d'exécuter du code cellule après cellule.
Mais attention, il est important que les cellules de code soient évaluées dans le bon ordre. Si vous ne respectez pas l'ordre dans lequel les cellules de code sont présentées, le résultat peut être inattendu.
On rappelle que la façon habituelle de lire l'ensemble du notebook consiste à partir de la première cellule de code à taper <Maj+Entrée> jusqu'à la fin du notebook, de sorte à bien évaluer toutes les cellules de code.
En fait, évaluer un programme sous forme de notebook revient à le découper en petits fragments, et si on exécute ces fragments dans le désordre, on obtient naturellement le résultat d'un programme différent.

Entrée In[ ]: et Sortie Out[ ]: :¶

En appuyant sur les touches <Maj+Entrée> (ou en cliquant sur le bouton , ou encore en utilisant dans le menu Cell>Run and Select Below...) celà a pour effet d'exécuter le code Python de la cellule sélectionnée.

Essayez vous-même :

In [1]:

1+1

1+1

Out[1]:

2

In [2]:

"Bonjour ! "

"Bonjour ! "

Out[2]:

'Bonjour ! '

Une ligne Out[ ]: apparait en dessous des instructions de code, affichant le résultat de celles-ci en sortie...

On peut rappeler le résultat de la dernière sortie dans la cellule suivante et le réutiliser ainsi :

In [3]:

_

_

Out[3]:

'Bonjour ! '

In [4]:

_ * 2

_ * 2

Out[4]:

'Bonjour ! Bonjour ! '

On peut rappeler le résultat d'une sortie particulière dans une autre cellule pour le réutiliser :

In [5]:

Out[1] * 2

Out[1] * 2

Out[5]:

4

Les Commentaires :¶

Lorsque l'on rédige un programme informatique il est essentiel de le commenter, pour cela en Python on utilise le caractère # qui permet d'indiquer que tous les caractères suivants sur la même ligne ne doivent pas être interprétés comme du code d'instruction :

In [6]:

##########################################
#   Un programme pour saluer doublement  #
##########################################
Out[2] * Out[1]
# Décommenter l'instruction précédente...

########################################## # Un programme pour saluer doublement # ########################################## Out[2] * Out[1] # Décommenter l'instruction précédente...

Out[6]:

'Bonjour ! Bonjour ! '

Remarque: Le simple fait d'ajouter un # permet de désactiver une ligne d'instruction sans avoir à l'effacer. Elle ne sera donc pas prise en compte par Python lors de l'exécution du programme. Aussi, il suffira de la décommenter en enlevant ce # pour la réactiver plus tard si besoin...

Pour cela on peut utiliser la combinaison de touches <Ctrl+/>.

Essayez vous-même :

• Décommenter l'instruction Out[2] * Out[1]

Variables :¶

Dans la mémoire vive de notre ordinateur, nous créons des boîtes (les variables) dans lesquelles nous mettons des valeurs :

In [1]:

maPremiereVariable='Hello World!'

maPremiereVariable='Hello World!'

Pour déclarer une variable en Python, il suffit de la nommer directement (sans autre mot clé comme var, int, contrairement à d'autres langages).
Pour affecter une valeur à la variable on utilise l'opérateur d'affectation = et Python lui attribue de façon dynamique un type correspondant à cette valeur.

Depuis le menu Edit > nbextensions config cocher la case Variable Inspector puis dans le menu du notebook cliquer sur le bouton pour faire apparaitre la fenêtre de suivie des variables.

Contrairement à Python ou JavaScript qui ont un typage dynamique, certains langages ont un typage statique, c’est à dire qu’il faut indiquer le type de chaque variable avant de l’utiliser. C’est le cas en Java ou en C par exemple : int a = 5;.

Le premier programme qu'écrit tout apprentis programmeur est le fameux "Hello World!", pour ce faire, exécutez ces deux premières intructions précédente puis suivante :

In [2]:

maPremiereVariable

maPremiereVariable

Out[2]:

'Hello World!'

Permutation de variables :

Soit les variables a et b telles que :

In [2]:

a = 5
b = 'toto'

a = 5 b = 'toto'

In [3]:

a

a

Out[3]:

5

In [4]:

b

b

Out[4]:

'toto'

Dans la cellule suivante, écrire un script qui, en utilsant une variable tampon nommée c, va intervertir les valeus de a et de b :

In [7]:

# Il faut que b = a et que a = b
c = a
a = b
b = c

# Il faut que b = a et que a = b c = a a = b b = c

Structure séquentielle : une ligne de code <=> une instruction¶

Un programme informatique est une séquence d'instructions.

L'instruction 3 sera exécutée seulement après l'exécution de l'instruction 2. L'ordre des instructions est donc important.

Dans de nombreux langages de programmation comme Java, C, PHP ou JavaScript, les instructions sont séparées par un point-virgule.

On observe qu'il n'y a pas de ; à la fin d'une instruction Python, c'est donc le retour à la ligne qui marque la fin de l'instruction et donc le début de la suivante.

France IOI - Dans le fourré :

Coller ici le code de votre programme qui a permis sur France IOI à votre robot d'atteindre la clé :

In [8]:

from robot import *
haut()
haut()
haut()
droite()
droite()
bas()
bas()
droite()

from robot import * haut() haut() haut() droite() droite() bas() bas() droite()

---------------------------------------------------------------------------
ModuleNotFoundError                       Traceback (most recent call last)
<ipython-input-8-d7f3c02335a7> in <module>
----> 1 from robot import *
      2 haut()
      3 haut()
      4 haut()
      5 droite()

ModuleNotFoundError: No module named 'robot'

En réalité Python autorise le ; pour séparer des instructions et permet ainsi d'écrire une séquence d'instructions sur une même ligne tel que :

In [10]:

maPremiereVariable='Hello World!';maPremiereVariable

maPremiereVariable='Hello World!';maPremiereVariable

Out[10]:

'Hello World!'

Le résultat est bien évidemment le même, mais cette pratique, très rarement utilisée, est à éviter car cela devient vite illisible.
Elle est à réserver pour des tests temporaires pour son coté pratique car il suffit alors d'un seul # pour désactiver toute une séquence...

Type :¶

La fonction type() renvoie le type de la variable :

Essayez vous-même :

In [11]:

type(maPremiereVariable)

type(maPremiereVariable)

Out[11]:

str

In [12]:

maSecondeVariable=5
maSecondeVariable, type(maSecondeVariable)

maSecondeVariable=5 maSecondeVariable, type(maSecondeVariable)

Out[12]:

(5, int)

In [13]:

maTroisiemeVariable=5.0
maTroisiemeVariable, type(maTroisiemeVariable)

maTroisiemeVariable=5.0 maTroisiemeVariable, type(maTroisiemeVariable)

Out[13]:

(5.0, float)

Voici donc quelques types de variables :

• str pour string, une chaine de caractères alphanumériques ;
• int pour integer, un nombre entier ;
• float un nombre flottant, représentant un nombre réel.

Fonction d'entrée de données :¶

Il est parfois nécessaire de demander à l'utilisateur d'entrer des données pour attribuer une valeur à une variable. On utilise pour cela la fonction input().

Essayez vous-même :

• Exécuter cette cellule plusieurs fois pour essayer avec des entrées de différents types...

In [1]:

maVariable=input("Entrer une valeur d'un type quelconque : ")
maVariable, type(maVariable)

maVariable=input("Entrer une valeur d'un type quelconque : ") maVariable, type(maVariable)

Entrer une valeur d'un type quelconque : 10

Out[1]:

('10', str)

On observe que le type renvoyé par cette cellule est toujours une chaines de caractères alphanumériques.
Il sera donc nécessaire de changer ce type en nombre pour pouvoir utiliser cette variable dans des opérations de calculs arythmétiques, et inversement pour des opérations sur des chaines de caractères.

Les fonctions de conversion de type qui nous seront utiles ici sont int(), float(), str().

In [1]:

maNouvelleVariable=float(input("Entrer un réel : "))
maNouvelleVariable, type(maNouvelleVariable)

maNouvelleVariable=float(input("Entrer un réel : ")) maNouvelleVariable, type(maNouvelleVariable)

Entrer un réel : 5

Out[1]:

(5.0, float)

Opération de calcul sur les nombres :¶

Les opérateurs arithmétiques de Python 3 sont :

Symbole	Opération
+	Addition
-	Soustraction
*	Multiplication
/	Division
//	Division partie entière
**	Puissance
%	Modulo

Pour observer les fonctionnalités de la machine à calculer Python, rendez-vous sur le bloc note Arithmétique

Ces opérations arithmétiques s'appliquent aussi entre des variables de type nombre et on peut en mémoriser le résultat dans une autre variable :

In [17]:

a, b = 5, 12
c = a + b
c

a, b = 5, 12 c = a + b c

Out[17]:

17

Ces opérateurs vont donc nous permettre de faire évoluer les variables de type nombre dans nos programme...

Permutation de variables par calcul :

Soit les variables a et b telles que :

In [14]:

a = 5
b = 3

a = 5 b = 3

In [15]:

a

a

Out[15]:

5

In [16]:

b

b

Out[16]:

3

Dans la cellule suivante, écrire un script qui, par une suite d'opérations arithmétiques, va intervertir les valeus de a et de b :

In [26]:

a = a + b
b = a - b
a = a - b

a = a + b b = a - b a = a - b

In [27]:

a

a

Out[27]:

7

In [20]:

b

b

Out[20]:

5

Essayez vous-même :

• Initialisez la variable i puis,
• Exécutez les cellules des codes d'incrémentation et de décrémentation suivantes plusieures fois de suite ;
• Essayez aussi pour des valeurs de $pas\neq1$...

In [28]:

# initialisation de la variable
i = 0
i

# initialisation de la variable i = 0 i

Out[28]:

0

L'incrémentation :¶

In [29]:

# incrémentation de la variable d'un pas de 1, code de base
i = i + 1
i

# incrémentation de la variable d'un pas de 1, code de base i = i + 1 i

Out[29]:

1

In [30]:

# incrémentation de la variable d'un pas de 1, code condensé
i += 1
i

# incrémentation de la variable d'un pas de 1, code condensé i += 1 i

Out[30]:

2

La décrémentation :¶

In [31]:

# incrémentation de la variable d'un pas de -1, code de base
i = i - 1
i

# incrémentation de la variable d'un pas de -1, code de base i = i - 1 i

Out[31]:

1

In [32]:

# incrémentation de la variable d'un pas de -1, code condensé
i -= 1
i

# incrémentation de la variable d'un pas de -1, code condensé i -= 1 i

Out[32]:

0

D'autres langages possèdent des notations encore plus condensées pour l'incrémentation i++ et la décrémentation i-- par pas de 1.

Opération sur les chaines de caractères alphanumériques :¶

En Python, les chaines de caractères sont des données immutables (non modifiables).

Ce sont des valeurs textuelles (espace, alphanumériques, symboles) encadrée par deux apostrophes ' où par deux guillemets ". Ce qui permet d'intégrer une ' ou des " dans une chaines de caractères.

Une autre solution consiste à utiliser un caractère spécial d'échappement \ :

Essayez vous-même :

Concaténation¶

On peut concaténer deux chaines grâce à l'opérateur +.

In [47]:

phrase= 'Hello'+' '+'World'+' !'
phrase

phrase= 'Hello'+' '+'World'+' !' phrase

Out[47]:

'Hello World !'

Répétition¶

On peut répéter une chaine grâce à l'opérateur *.

In [48]:

mot="to"*2
mot

mot="to"*2 mot

Out[48]:

'toto'

Fonction d'affichage en sortie :¶

La fonction print() permet d'afficher du contenu :

Essayez vous-même :

In [33]:

print("L'heure est venue de programmer")
print("au","lycée","Notre","Dame","du","Mur")
print(maPremiereVariable)
print(maSecondeVariable)
print(maTroisiemeVariable)
print(0x1A)
print(0b1100)
print("Python...\n" + ">" * 10, 'c\'est "cool" !')

print("L'heure est venue de programmer") print("au","lycée","Notre","Dame","du","Mur") print(maPremiereVariable) print(maSecondeVariable) print(maTroisiemeVariable) print(0x1A) print(0b1100) print("Python...\n" + ">" * 10, 'c\'est "cool" !')

L'heure est venue de programmer
au lycée Notre Dame du Mur
Hello World!
5
5.0
26
12
Python...
>>>>>>>>>> c'est "cool" !

On observe que les chaines de caractères s'affichent sans guillemets
et qu'un nombre indiqué en hexadécimal ou en binaire est affiché en décimal.

La fonction print() admet deux arguments interessants :

• sep qui permet de séparer les valeurs par un texte de votre choix. Par défaut le séparateur est un espace " ".
• end qui permet d'ajouter à la fin un texte de votre choix. Par defaut la fin de ligne est un retour à la ligne "\n".

In [34]:

print("L'heure est venue de programmer", end = " ")
print("au","lycée","Notre","Dame","du","Mur")
print(maPremiereVariable, end=" | ")
print(maSecondeVariable, end=" | ")
print(maTroisiemeVariable, end=" | ")
print(0x1A, end=" | ")
print(0b1100)
print("Python...", ">" * 10 + ' c\'est "cool" !', sep = "\n")

print("L'heure est venue de programmer", end = " ") print("au","lycée","Notre","Dame","du","Mur") print(maPremiereVariable, end=" | ") print(maSecondeVariable, end=" | ") print(maTroisiemeVariable, end=" | ") print(0x1A, end=" | ") print(0b1100) print("Python...", ">" * 10 + ' c\'est "cool" !', sep = "\n")

L'heure est venue de programmer au lycée Notre Dame du Mur
Hello World! | 5 | 5.0 | 26 | 12
Python...
>>>>>>>>>> c'est "cool" !

Pour afficher un résultat avec du texte combiné avec des variables, il existe plusieurs méthodes :

In [35]:

u = 15
i = 1
print("u",i," = ",u,sep='')

u = 15 i = 1 print("u",i," = ",u,sep='')

u1 = 15

Par défaut sep est un espace, si on souhaite que l'indice soit acollé à la variable u, il faut redéfinir sep...

In [36]:

u = 15
i = 1
print("u"+str(i)+" = "+str(u))

u = 15 i = 1 print("u"+str(i)+" = "+str(u))

u1 = 15

Il faut convertir les nombres en string pour pouvoir les concaténer avec du texte.

Avant Python 3.6, le plus élégant consistait à utiliser la méthode format(), en voici un exemple :

In [37]:

a=4
b=5
print("Le produit de {0} par {1} est {2}\nLa division de {1} par {0} donne {3}".format(a,b,a*b,b/a))

a=4 b=5 print("Le produit de {0} par {1} est {2}\nLa division de {1} par {0} donne {3}".format(a,b,a*b,b/a))

Le produit de 4 par 5 est 20
La division de 5 par 4 donne 1.25

On remplace { } par le contenu de la variable. Peu importe son type, le résultat sera affiché.

Depuis Python 3.6, on peut utiliser les f-strings pour formatter une chaine de caractères :

In [38]:

a=4
b=5
toto = f"Le produit de {a} par {b} est {a*b}\nLa division de {b} par {a} donne {b/a}"
toto

a=4 b=5 toto = f"Le produit de {a} par {b} est {a*b}\nLa division de {b} par {a} donne {b/a}" toto

Out[38]:

'Le produit de 4 par 5 est 20\nLa division de 5 par 4 donne 1.25'

In [39]:

print(toto)

print(toto)

Le produit de 4 par 5 est 20
La division de 5 par 4 donne 1.25

Structure itérative : boucle de répétitions avec for¶

La notion de boucle est fondamentale en informatique. Une boucle permet d'exécuter plusieurs fois des instructions qui ne sont inscrites qu'une seule fois dans le code.

La boucle for prend ses valeurs dans un ensemble itératif :

for variable in liste_valeurs

À chaque itération la variable prendra pour valeur un élément de la liste.

Pour créer une boucle équivalente aux boucles traditionnelles (pour i allant de m à n, faire...), nous utiliserons la fonction range().
La syntaxe générale est

for i in range(m,n,p):

i prend alors toutes les valeurs de m à n-1 par pas de p

Essayez vous-même :

In [40]:

for i in range(1,4):
    print(i)

for i in range(1,4): print(i)

1
2
3

In [41]:

for i in range(4):
    print(i)

for i in range(4): print(i)

0
1
2
3

In [42]:

for i in range(0,6,2):
    print(i)

for i in range(0,6,2): print(i)

0
2
4

In [43]:

for i in range(4,0,-1):
    print(i)

for i in range(4,0,-1): print(i)

4
3
2
1

On peut aussi parcourir une chaîne de caractères :

In [44]:

for i in "Bonjour":
    print(i)

for i in "Bonjour": print(i)

B
o
n
j
o
u
r

France IOI - Vendanges :

Coller ici le code de votre programme qui a permis sur France IOI à votre robot d'aider aux vendanges :

Le robot est initialement tout à gauche, là où se trouve un grand tas de raisins. Il devra, 20 fois :

• ramasser des raisins pour remplir la hotte de ramassage ;
• se rendre à la charrette ;
• déposer le contenu de la hotte ;
• revenir au point de départ.

In [20]:

from robot import *

for loop in range(20) :
    ramasser()
    for loop in range(15) :
        droite()
    deposer()
    for loop in range(15) :
        gauche()

from robot import * for loop in range(20) : ramasser() for loop in range(15) : droite() deposer() for loop in range(15) : gauche()

---------------------------------------------------------------------------
ModuleNotFoundError                       Traceback (most recent call last)
<ipython-input-20-d4f248c2d2d6> in <module>
----> 1 from robot import *
      2 
      3 for loop in range(20) :
      4    ramasser()
      5    for loop in range(15) :

ModuleNotFoundError: No module named 'robot'

Indentation obligatoire en Python :¶

Python oblige donc le développeur à structurer son code a l'aide des indentations : ce sont elles qui, après les :, détermineront les limites du bloc de la séquence d'instructions répétées dans la boucle et non pas les accolades comme dans la majorité des langages comme par exemple en JavaScript:

for (initialisation ; condition ; modification) {
    Instruction 1 ;
    Instruction 2 ;
    ... ;
}

L'indentation n'est donc pas ogligatoire dans tous les langages informatiques. Par exemple en Javascript on pourrait programmer tel que :

for(var i=0;i<8;i++){ellipse(positionX+entraxe*i,positionY,diametre,diametre);Instruction 2 ; Instruction 3 ; Instruction 4 ... ;}

Ce qui devient bien évidemment rapidement illisible pour un humain normalement constitué...

Python oblige donc par nature à produire du code clair et lisible donc plus facilement maintenable...

Que ceux qui souhaiteraient coder avec des accolades en Python, exécutent l'instruction suivante dans un interpréteur :

from __future__ import braces

In [45]:

from __future__ import braces

from __future__ import braces

  File "<ipython-input-45-6d5c5b2f0daf>", line 4
SyntaxError: from __future__ imports must occur at the beginning of the file

et constatent que les développeurs de Python, avec ce genre d'"easter egg", ne manquent pas d'humour à l'instar des Monty... https://stackoverflow.com/questions/17811855/syntax-error-not-a-chance

Essayer aussi avec :

import this

import __hello__

import antigravity

In [46]:

import this

import this

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Opérateurs relationnels, les comparateurs :¶

Symbole	Opération
==	égal
!=	différent
<	inférieur
>	supérieur
<=	inférieur ou égal
>=	supérieur ou égal

Ces opérateurs permettent de faire des tests conditionnels :

Essayez vous-même :

In [47]:

condition1 = ( 0 == 1 )
condition1,type(condition1)

condition1 = ( 0 == 1 ) condition1,type(condition1)

Out[47]:

(False, bool)

In [48]:

condition2 = ( 0 <= 1 )
condition2,type(condition2)

condition2 = ( 0 <= 1 ) condition2,type(condition2)

Out[48]:

(True, bool)

On découvre là un nouveau type de variable bool pour booléen, leur valeur est soit True soit False.

Nous verrons plus tard plus en détails la logique booléenne que l'on doit à George

Structure conditionnelle (alternatives), si ... alors ... sinon :¶

if condition:
    # Traitement bloc 1
else:
    # Traitement bloc 2

Pour les tests multiples, il faudra enchaîner les if en cascade grâce à l'instruction elif, contraction de else if :

if condition:
    # Traitement bloc 1
elif:
    # Traitement bloc 2
else:
    # Traitement bloc 3

France IOI - Mot de passe du village :

Coller ici le code de votre programme qui a permis sur France IOI à votre robot d'autoriser certains villageois à accéder au festin :

Votre programme doit lire un entier : le code fourni par l'utilisateur. Si ce code correspond au code secret, qui est 64 741, alors le programme devra afficher le texte « Bon festin ! ». Sinon, il devra afficher « Allez-vous en ! ».

In [49]:

codesecret = int(input())

if codesecret== 64741 :
    print("Bon festin !")
else :
    print("Allez-vous en !")

codesecret = int(input()) if codesecret== 64741 : print("Bon festin !") else : print("Allez-vous en !")

25
Allez-vous en !

Autre exemple à tester vous-même :

• Essayez le script de la cellule suivante et trouver une stratégie qui permet de réduire le nombre de tentatives :

In [1]:

# L'ordinateur génère un nombre secret compris entre 1 et 100 de façon aléatoire
from random import randint
nombre_secret = randint(1,100)

print("Saurez-vous trouver le nombre secret en moins de 10 coups ?")

for i in range (10) :
    
    # On demande au joueur de saisir un nombre entier compris entre 1 et 100
    proposition_du_joueur = int(input("\nSaisir un nombre entier compris entre 1 et 100 = "))
    
    if proposition_du_joueur < nombre_secret :
        print(f"C'est plus grand...\nIl vous reste {9-i} tentatives.")
            
    elif proposition_du_joueur > nombre_secret :
        print(f"C'est plus petit...\nIl vous reste {9-i} tentatives.")
            
    else :
        print(f"Bravo, vous avez trouvez le nombre secret en {i+1} coups !")
        break

if i+1 == 10 :
    print(f"Dommage, vous n'avez pas trouvez le nombre secret en moins de {i+1} coups !\nRéfléchissez à une stratégie pour trouvez en réduisant vos tentatives...")

# L'ordinateur génère un nombre secret compris entre 1 et 100 de façon aléatoire from random import randint nombre_secret = randint(1,100) print("Saurez-vous trouver le nombre secret en moins de 10 coups ?") for i in range (10) : # On demande au joueur de saisir un nombre entier compris entre 1 et 100 proposition_du_joueur = int(input("\nSaisir un nombre entier compris entre 1 et 100 = ")) if proposition_du_joueur < nombre_secret : print(f"C'est plus grand...\nIl vous reste {9-i} tentatives.") elif proposition_du_joueur > nombre_secret : print(f"C'est plus petit...\nIl vous reste {9-i} tentatives.") else : print(f"Bravo, vous avez trouvez le nombre secret en {i+1} coups !") break if i+1 == 10 : print(f"Dommage, vous n'avez pas trouvez le nombre secret en moins de {i+1} coups !\nRéfléchissez à une stratégie pour trouvez en réduisant vos tentatives...")

Saurez-vous trouver le nombre secret en moins de 10 coups ?

Saisir un nombre entier compris entre 1 et 100 = 50
C'est plus grand...
Il vous reste 9 tentatives.

Saisir un nombre entier compris entre 1 et 100 = 75
C'est plus petit...
Il vous reste 8 tentatives.

Saisir un nombre entier compris entre 1 et 100 = 62
C'est plus grand...
Il vous reste 7 tentatives.

Saisir un nombre entier compris entre 1 et 100 = 68
C'est plus petit...
Il vous reste 6 tentatives.

Saisir un nombre entier compris entre 1 et 100 = 65
C'est plus petit...
Il vous reste 5 tentatives.

Saisir un nombre entier compris entre 1 et 100 = 64
C'est plus petit...
Il vous reste 4 tentatives.

Saisir un nombre entier compris entre 1 et 100 = 63
Bravo, vous avez trouvez le nombre secret en 7 coups !

Ce script utilise la méthode randint() du module random :

In [51]:

from random import randint
help(randint)

from random import randint help(randint)

Help on method randint in module random:

randint(a, b) method of random.Random instance
    Return random integer in range [a, b], including both end points.

In [52]:

randint(1,6)# Simule le lancé d'un dé à six faces

randint(1,6)# Simule le lancé d'un dé à six faces

Out[52]:

6

Chi Fou Mi à coder vous même :

• Programmer un jeu de Pierre-Feuille-Ciseau entre un joueur et l'ordinateur. Le meilleur des cinqs manches remporte la partie :

In [ ]:

from random import randint

# ecrire une fonction qui definie pierre par 1, papier par 2 et ciseaux par 3

def ecrire(nombre):
    if nombre == 1:
        print("pierre",end=" ")
    elif nombre == 2:
        print("papier",end=" ")
    else:
        print("ciseaux",end=" ")
        
# ecrire une fonction qui augmente les scores de chaque joueur 

def augmenter_scores(mon_coup,ton_coup):
    global mon_score, ton_score
    if mon_coup == 1 and ton_coup == 2:
        ton_score += 1
    elif mon_coup == 2 and ton_coup == 1:
        mon_score += 1
    elif mon_coup == 1 and ton_coup == 3:
        mon_score += 1
    elif mon_coup == 3 and ton_coup == 1:
        ton_score += 1
    elif mon_coup == 3 and ton_coup == 2:
        mon_score += 1
    elif mon_coup == 2 and ton_coup == 3:
        ton_score += 1

# definir les scores de chaque joueur

ton_score = 0
mon_score = 0
fin = 5
print("Pierre-papier-ciseaux. Le premier à",fin,"a gagné !")
no_manche = 0
while mon_score < fin and ton_score < fin:
    ton_coup = int(input("1 : pierre, 2 : papier, 3 : ciseaux ? "))
    while ton_coup < 1 or ton_coup > 3:
        ton_coup =int(input("1 : pierre, 2 : papier, 3 : ciseaux ? "))
    print("Vous montrez",end=" ")
    ecrire(ton_coup)
    mon_coup = randint(1,3) 
    print("- Je montre",end=" ")
ecrire(mon_coup)
print()     # aller à la ligne
augmenter_scores(mon_coup,ton_coup)
print("vous",ton_score,"   moi",mon_score)

from random import randint # ecrire une fonction qui definie pierre par 1, papier par 2 et ciseaux par 3 def ecrire(nombre): if nombre == 1: print("pierre",end=" ") elif nombre == 2: print("papier",end=" ") else: print("ciseaux",end=" ") # ecrire une fonction qui augmente les scores de chaque joueur def augmenter_scores(mon_coup,ton_coup): global mon_score, ton_score if mon_coup == 1 and ton_coup == 2: ton_score += 1 elif mon_coup == 2 and ton_coup == 1: mon_score += 1 elif mon_coup == 1 and ton_coup == 3: mon_score += 1 elif mon_coup == 3 and ton_coup == 1: ton_score += 1 elif mon_coup == 3 and ton_coup == 2: mon_score += 1 elif mon_coup == 2 and ton_coup == 3: ton_score += 1 # definir les scores de chaque joueur ton_score = 0 mon_score = 0 fin = 5 print("Pierre-papier-ciseaux. Le premier à",fin,"a gagné !") no_manche = 0 while mon_score < fin and ton_score < fin: ton_coup = int(input("1 : pierre, 2 : papier, 3 : ciseaux ? ")) while ton_coup < 1 or ton_coup > 3: ton_coup =int(input("1 : pierre, 2 : papier, 3 : ciseaux ? ")) print("Vous montrez",end=" ") ecrire(ton_coup) mon_coup = randint(1,3) print("- Je montre",end=" ") ecrire(mon_coup) print() # aller à la ligne augmenter_scores(mon_coup,ton_coup) print("vous",ton_score," moi",mon_score)

Pierre-papier-ciseaux. Le premier à 5 a gagné !
1 : pierre, 2 : papier, 3 : ciseaux ? 1
Vous montrez pierre - Je montre 1 : pierre, 2 : papier, 3 : ciseaux ? 1
Vous montrez pierre - Je montre 

Autres boucles avec while (TANT QUE ou JUSQU'A) :¶

Initialisation
# Début de la boucle
while Condition :
    Instruction 1
    Instruction 2
    ...
    Dernière Instruction
    Modification
# fin de la boucle et suite du programme

Les instructions inscrites dans la boucle forment un bloc d'instructions. Elles seront répétées tant que la condition de répétition est vrai.
Dès que la condition de répétition est fausse le programme sort de la boucle et se poursuit au delà.
L'initialisation déclare une variable et lui affecte une valeur initiale par exemple i = 0. La modification fait évoluer cette variable de façon régulière à chaque tour de boucle, par exemple par incrémentation i+=1. La condition consiste donc à faire un test binaire (vrai ou faux) sur la valeur de la variable i. Puisque i évolue à chaque tour de boucle, le résultat du test deviendra donc faux au bout d'un nombre fini d'itération.
Ce test s'appuie sur des opérateurs relationnels afin d'établir une comparaison entre la variable i et la valeur limite de répétition, par exemple i < 8.

Ce qui donne par exemple :

In [1]:

i=0
print('Début de la boucle')
while i<8 :
    print('    Mon')
    print('    Bloc')
    print("    d'instructions")
    i+=1
    print('   ',i)
print('Fin de la boucle, prêt pour la suite du programme')

i=0 print('Début de la boucle') while i<8 : print(' Mon') print(' Bloc') print(" d'instructions") i+=1 print(' ',i) print('Fin de la boucle, prêt pour la suite du programme')

Début de la boucle
    Mon
    Bloc
    d'instructions
    1
    Mon
    Bloc
    d'instructions
    2
    Mon
    Bloc
    d'instructions
    3
    Mon
    Bloc
    d'instructions
    4
    Mon
    Bloc
    d'instructions
    5
    Mon
    Bloc
    d'instructions
    6
    Mon
    Bloc
    d'instructions
    7
    Mon
    Bloc
    d'instructions
    8
Fin de la boucle, prêt pour la suite du programme

France IOI - Département d'architecture : construction d'une pyramide :

Coller ici le code de votre programme qui a permis sur France IOI de construire la plus grande pyramide possible :

Votre programme doit d'abord lire un entier : le nombre maximum de pierres dont pourra être composée la pyramide. Il devra ensuite calculer et afficher un entier : la hauteur de la plus grande pyramide qui pourra être construite, ainsi que le nombre de pierres qui sera nécessaire.

In [ ]:

Les fonctions :¶

Les fonctions se définissent de la façon suivante :

def maFonction(parametre1, parametre2):
    instructions
    return valeur1, valeur2

Exemple :

In [2]:

def max(x,y):
    if (x > y):
        return x
    else :
        return y

def max(x,y): if (x > y): return x else : return y

Pour l'utiliser, il faut l'appeler :

In [15]:

max(6,3)

max(6,3)

Out[15]:

6

On peut ensuite la rapeller autant de fois qu'on le souhaite :

In [16]:

max(-9,1)

max(-9,1)

Out[16]:

1

France IOI - Formes creuses :

Coller ici le code de votre programme qui a permis sur France IOI d'afficher davantage de dessins pour vos spectateurs :

Ce que doit faire votre programme :

Écrivez un programme qui affiche une ligne de « X », un rectangle de « # », et un triangle de « @ ». Les deux formes doivent être creuses (remplies avec des espaces).

L'entrée comporte quatre entiers, un par ligne :

le nombre de « X » de la ligne à afficher ; le nombre de lignes du rectangle de « # » ; le nombre de colonnes du rectangle ; le nombre de lignes du triangle de « @ ».

Vous devez afficher les trois formes successivement, avec une ligne blanche entre chaque forme, comme le montre l'exemple.

Votre objectif doit être d'obtenir le code source le plus simple et clair possible, en le décomposant en fonctions.

Exemple

entrée :

15
5
12
6

sortie :

XXXXXXXXXXXXXXX

############
#          #
#          #
#          #
############

@
@@
@ @
@  @
@   @
@@@@@@

Commentaires

Attention : le nombre de lignes ou de colonnes peut être égal à 1.

L'outil Python tutor :¶

Python tutor permet de visualiser pas à pas ce que fait votre script.

Il est possible de l'utiliser dans un notebook jupyter pour celà il faut :

1. l'installer (si ce n'est pas déjà fait) : %pip install metakernel
2. puis exécuter les instructions de la cellule suivante :

In [1]:

from metakernel import register_ipython_magics
register_ipython_magics()

from metakernel import register_ipython_magics register_ipython_magics()

---------------------------------------------------------------------------
ModuleNotFoundError                       Traceback (most recent call last)
<ipython-input-1-9e79f06f58b7> in <module>
----> 1 from metakernel import register_ipython_magics
      2 register_ipython_magics()

ModuleNotFoundError: No module named 'metakernel'

1. inscrire la commande %%tutor devant le script à tester dans la cellule :

In [2]:

%%tutor
# Script à tester :
for i in range(0,6,2):
    print(i)

%%tutor # Script à tester : for i in range(0,6,2): print(i)

UsageError: Cell magic `%%tutor` not found.

---

Références aux programmes :¶

Compétences développées	Capacités attendues	Commentaires
Écriture d’un entier positif dans une base b ⩾ 2	Passer de la représentation d’une base dans une autre.	Les bases 2, 10 et 16 sont privilégiées.

Autres ressources :¶

• Documentation python 3
• France IOI
• Fabrice DUMONT
• Jean-Daniel Bonjour
• Débuter avec python au lycée

Ce document est mis à disposition selon les termes de la Licence Creative Commons Attribution - Partage dans les Mêmes Conditions 4.0 International.

Pour toute question, suggestion ou commentaire : eric.madec@ecmorlaix.fr

In [ ]: