Premiers Pas

Note

Les objectifs du TP :

• Préparer votre environnement de travail et organiser votre dossier utilisateur.
• Lancer l’IDLE Python et l’IDE Spyder, et commencer à jouer avec Python.
• Introduire les notions de variables et d’affectation.

Environnement de travail

Dans Windows

Dans l’ordre :

1. Ouvrez votre session.
2. Dans votre répertoire créer un dossier nommé TP qui contiendra tous les TP de cette année.
3. Dans ce dossier, créer un dossier TP1 qui contiendra les fichiers de ce TP.

Dans l’IDLE

Lancez l’IDLE, Python 3. La fenêtre qui s’ouvre s’appelle “Python Shell” et ressemble peu ou prou à ça :

Note

Le symbole >>> s’appelle le “prompt” ou l”invite de commande”. Il signifie que l’interpréteur est disponible à prendre vos commandes.

Note

La syntaxe de base en Python :

• Les commentaires, que vous utiliserez (plus tard) pour annoter votre code afin de le rendre compréhensible et de vous souvenir de ce qu’il fait s’obtiennent avec un #.

  # Tout ce qui suit un dièse sur une ligne est ignoré
  

• De manière générale vous taperez une instruction par ligne, sans marqueur à la fin.

• Si vous souhaitez taper plusieurs instructions par ligne, il faudra les séparer par ;

• L’indentation est syntaxique et non décorative. Un bloc doit être indenté et doit toujours être précédé d’une ligne se terminant par un ”:”

  if montant > 50:
      print("Frais de port offerts")
  else:
      print("Frais de port : 5 euros")
      montant += 5
  

Pyhton sait compter et il nous le prouve.

Exercice 1 : Taper les différentes opérations suivantes (chacune sur une ligne) :

2 + 3; 3 - 5; -2 * 7; 9 ** 2; 3.11 / 2.7; 2.2 / 3.5; 15.0 / 2.0; 15 // 2; 16 % 3

Avertissement

On utilise la notation anglo-saxonne le point remplace la virgule.

Vous devriez obtenir quelque chose comme ça :

>>> 2 + 3
5
...

• Observez le format des différents résultats.
• Quittez l’IDLE et le relancer. Qu’observez-vous ?

Note

Opération	Résultat
+	Addition
-	Soustraction
*	Multiplication
**	Puissance
/	Division
//	Quotient dans la division euclidienne
%	Reste dans la division euclidienne

Avertissement

Il y a une différence notable entre Python 2 et 3 pour la division.

• En Python 3 : / est la division de flottants

  >>> 2 / 3
  0.6666666666666666
  

• En Python 2 : / est la division euclidienne lorsqu’elle est appliquée sur des entiers.

  >>> 2 / 3
  0
  >>> 2. / 3.
  0.6666666666666666
  

On peut obtenir le comportement de Python 3 en Python 2 en incluant en début de fichier l’instruction suivante :

from __future__ import division

Avertissement

A la fermeture de l’IDLE tout ce qui est tapé dans le shell est perdu...

Exercice 2 : Ouvrez une nouvelle fenêtre et sauvez le fichier dans votre dossier TP1 sous le nom : TP1.py. Dans ce fichier inscrivez les commandes suivantes :

1 + 1
print("2")
2 + 3
print(2*3)
2*3

Enregistrez et exécutez votre fichier. Qu’observez-vous ? Que fait Python exactement ?

Note

Pour ouvrir/sauver un nouveau fichier vous pouvez utiliser le menu Edit ou Edition. Ou alors utiliser les raccourcis clavier : CTRL - N et CTRL - S.

De même pour l’exécuter vous pouvez utiliser le raccourci F5.

Avertissement

Contrairement à ce qui se passe dans le shell, lorsqu’on exécute le code contenu dans un fichier Python effectue les calculs mais ne les affiche pas. Pour les afficher il faut le demander à l’aide de la commande print.

Exercice 3 : Modifiez le code contenu dans le fichier TP1.py pour qu’à l’exécution il affiche la table de 7 après avoir fait les calculs.

Solution.

Exercice 4 : Remplacez le code du fichier TP1.py par :

for i in range(1,11):
        print(i,"* 7 = ", i*7)

Enregistrez et exécutez le avec Python 3. Magique non ? Que signifie ce code d’après vous ?

Dans Spyder

Lancez Spyder. La fenêtre qui s’ouvre ressemble à ça :

Il y a trois panneaux qui constituent la fenêtre :

1. Une console en bas à droite, prête à interpréter des commandes Python.

2. Un panneau d’information en haut à droite, qui comporte trois onglets :

   • Un explorateur de variables.
   • Un explorateur de fichiers.
   • Un inspecteur d’objets.

3. Un éditeur à gauche dans lequel vous écrirez vos programmes.

Avertissement

Ne déplacez pas les différents panneaux !! Ne les redimensionnez pas non plus !!

Exercice 5 : Vérifiez que la console réagit exactement comme le shell de l’IDLE, en exécutant quelques commandes.

Exercice 6 : Ouvrez le fichier TP1.py et exécutez le.

Note

Dans Spyder aussi on peut utiliser des raccourcis clavier :

• CTRL-O : Ouvrir un fichier.
• CTRL-S : Sauvegarder.
• CTRL-N : Nouveau fichier.
• F5 : Exécuter.

Variables et Affectations

Littéraux

Note

Un littéral est une valeur écrite dans le programme.

Exemples :

• Un entier : 2
• Un nombre à virgule flottante : 3.14
• Un nombre complexe : 4j
• Une chaîne de caractères : "PTSI-B"
• Une liste d’entiers : [3, 2, 1]

Lorsque vous tapez un littéral dans la console Python crée, disons, un nouvel “objet”.

>>> (2013, id(2013), type(2013))
(2013, 4342639664, <class 'int'>)

En plus de sa valeur, Python assigne à l’objet un identifiant, ici 4342639664, qui indique où l’objet est gardé en mémoire et un type, ici int pour entier.

Nous verrons plus en détail les types un peu plus loin, parmi les principaux on trouve :

• Les entiers int
• Les flottants float
• Les chaînes de caractères str
• Les listes list
• Les booléens bool

Variables et affectations

L’identifiant d’un objet est assez contraignant à utiliser. On a alors recourt aux variables.

Note

Une variable permet de stocker en mémoire une donnée pour la réutiliser à plusieurs reprises en la désignant par un nom.

Pour donner une valeur à une variable en Python on utilise le symbole = , cette opération s’appelle une affectation de valeur à une variable, ou plus simplement une affectation de variable.

Une affectation crée une liaison entre un nom et une donnée stockée en mémoire.

Avertissement

Les noms de variable (et aussi : de fonction, de classe...) doivent respecter certaines règles syntaxiques :

• Ils ne peuvent contenir que des lettres, des chiffres, des underscores ( _ ), et doivent commencer par une lettre.

• La casse est importante, autrement Python fait la différence entre majuscule et minuscule (ma_variable ≠ Ma_VaRiAbLE).

• D’après la PEP8, les noms de variables doivent être écrits en minuscules, avec des underscores si nécessaire : ma_variable.

• Les noms des constantes doivent être écrits en minuscules ou tout en majuscules, avec des underscores si nécessaire : une_constante ou UNE_CONSTANTE.

• Certains noms sont réservés par le langage et ne peuvent être utilisés comme nom de variable. Voici la liste pour Python 3 :

  and	assert	break	class	continue
  def	del	elif	else	except
  exec	finally	for	from	global
  if	import	in	is	lambda
  not	or	pass	print	raise
  return	try	while	yield

Dans un programme complexe, il faut impérativement donner des noms significatifs aux variables.

>>> a = 2013
>>> a
2013
>>> (id(a), type(a))
(4342640016, <class 'int'>)
>>> b = "PTSI-B"
>>> b
'PTSI-B'
>>> (id(b), type(b))
(4342667224, <class 'str'>)

Avertissement

Le symbole = utilisé pour l’affectation ne représente pas une égalité. En particulier il n’est pas symétrique.

 >>> a = 2013
 >>> a
 2013
 >>> 2013 = a
SyntaxError: can't assign to literal

Note

Il est d’usage de laisser une espace avant et une autre après le signe =.

Exercice 7 : Dans la console créez une variable mon_annee et affectez lui votre année de naissance. Demandez à Python son identifiant et son type à l’aide des commandes id() et type(). Taper ensuite les différentes commandes suivantes :

mon_annee + 1 ; 3*mon_annee ; mon_annee + mon_annee ;

Exercice 8 : Dans la console tapez les lignes suivantes.

>>> a = 2013
>>> a = a + 1

Que vaut a à votre avis ? Vérifiez en affichant la valeur de a.

>>> a += 2
>>> a

Qu’a fait Python ? Essayez avec d’autres valeurs que 2 et avec d’autres opérations que +.

Note

On peut abréger certaines affectations.

a -= k
a /= k
a //= k
a %= k
a *= k
a **= k

Exercice 9 : Dans la console, tapez les commandes suivantes.

>>> a = 10
>>> b = a + 1

Que vaut b ? Vérifiez en affichant la valeur.

>>> a = 10
>>> b = 20
>>> a = b
>>> b = a

Que valent a et b maintenant ? Vérifiez.

>>> a = 10
>>> b = 20
>>> c = a
>>> a = b
>>> b = c

Que valent a et b maintenant ? Vérifiez.

>>> a = 10
>>> b = 20
>>> print("a = ", a, "b = ", b)
>>> (a,b) = (b,a)
>>> print("a = ", a, "b = ", b)

Que s’est-il passé ?

Note

On parle d’affectations multiples lorsqu’on affecte plusieurs variables en même temps. Par exemple :

>>> (a, b) = (4, 5) ; (a, b)
(4, 5)
>>> (a, b) = (b, a) ; (a, b)
(5, 4)

C’est très pratique pour échanger les valeurs de deux variables.

Exercice 10 : Tapez les instructions suivantes dans le fichier TP1.py et sauvez.

a = 10
b = 20
c = 30
a *= 2
c = b-a
print((a+b)*c+1)

Quel résultat va s’afficher à l’exécution ? Vérifiez.

Types de données simples

Note

En Python le typage des données est dynamique : les variables n’ont pas à proprement parler de type, c’est leurs valeurs qui en ont un. Donc au cours de l’exécution une même variable peut contenir des valeurs de types différents.

>>> a = 4
>>> type(a)
<class 'int'>

>>> a = (3, 8)
>>> type(a)
<class 'tuple'>

Dans Spyder vous pouvez utilisez l’explorateur de variables pour connaître la valeur d’une variable et son type.

>>> a = 10
>>> d = True
>>> b = 10.
>>> c = "Bonjour"

Les nombres

En Python il y a essentiellement qutre types de nombres :

• Les entiers de type int
• Les flottants de type float
• Les complexes de type complex
• Les fractions de type fraction

Exercice 11 : Dans la console, tapez les instructions suivantes.

>>> a = 1 ; type(a)
>>> b = 1. ; type(b)
>>> import cmath
>>> c = 1j ; type( c )
>>> import fractions
>>> d = fractions.Fraction(3,8) ; f = fractions.Fraction(6,4)
>>> print(d+f); type(d)
>>> a+2 ; type(a+2)
>>> 2*a ;type(2*a)
>>> a+2. ; type(a+2.)
>>> 2.*a ; type(2.*a)
>>> b+2 ; type(b+2)
>>> b+2. ; type(b+2.)
>>> 2 + c ; type(2+c)

Qu’observez-vous ?

Note

Python applique lui-même des conversions de types, on dit que ces conversions sont implicites.

Le conversions de type numérique int → float → complex sont les seules conversions implicites de type qui sont autorisées, toutes les autres sont formellement interdites et aboutissent à un message d’erreur. C’est pourquoi on dit que le typage est fort.

Lien vers la documentation du module de math

Chaînes de caractères

Note

Une chaîne de caractères, comme son nom l’indique est une série de lettres. On peut écrire une chaîne de caractère de plusieurs façons :

• entre guillemets
• entre apostrophes
• entre triples guillemets

Le type d’une chaîne est str.

>>> s1 = "Bonjour "
>>> s2 =' à '
>>> s3 = """ tous."""
>>> type(s1)
<type 'str'>

On peut concaténer des chaînes de caractère à l’aide de l’opérateur + et les répéter à l’aide de *.

>>> print(s1+s2+s3)
Bonjour à tous.
>>> print(2*s1)
BonjourBonjour

On peut accéder aux différentes lettres d’une chaîne de caractère en utilisant des crochets [].

Exercice 12 : Tapez les différentes instructions suivantes dans la console.

>>> s = "Hello World!"
>>> print(s)
>>> s[0]
>>> s[11]
>>> s[3:5]
>>> s[:5]
>>> s[6:]
>>> s[:]
>>> s[-3]
>>> s[-3:]
>>> s[0:8:2]
>>> s[::3]

Exercice 13: Définissez la chaîne de caractère s = "0123456789" et écrivez les instructions qui afficheront les résultats suivants :

'0123456789'
'5'
'345'
'789'
'02468'
'13579'
'036'

Note

Une liste de commande pour obtenir certains caractères ou pour formater du texte.

Utilité	Caractère
Aller à la ligne	\n
Tabulation	\t
Afficher un anti-slash	\
Afficher une apostrophe	\’
Afficher un guillemet	\”
Saut de page	\f
Retour en arrière	\b
Retour chariot	\r

Exercice 14 : Dans la console tapez les instructions qui affichent :

"J'aime beaucoup Python.
        Même si je ne comprends pas tout."

Solution

Les booléens

Note

En Python les booléens “vrai” et ‘faux” se notent True, False.

Ils sont manipulables avec les opérations standards +, -, *, \, or, and, not et avec les opérateurs de comparaison.

Les opérateurs de comparaison sont :

• L’égalité ==
• L’inégalité !=
• Les comparateurs d’ordre : < <= > >=
• L’identité is qui compare les id() .

Ils retournent un booléen.

L’évaluation d’une expression booléenne s’arrête dès que le résultat est connu (opérateurs paresseux ou en court-circuit)

>>> (True and False)
False
>>> # Les expressions a et b ne sont pas évaluées
>>> a = True; b = False; True and (a or b)
True
>>> not False
True

Exercice 15 : Tapez dans la console et évaluez les instructions suivantes.

>>> True + True ; True + False ; True * False ; False + False ; False * False
>>> 2 < 3
>>> 2 != 3
>>> s1 = "trois" ; s2 = "sept"
>>> s1 > s2
>>> 2 + 3 == 5
>>> a = 2 ; b = 2.
>>> a == b
>>> a is b
>>> a = 2 ; b = 2
>>> a == b
>>> a is b
>>> 1 < 2 and 3 <= 5
>>> not(3 > 4)
>>> 'a'+'b' == 'ab' or 7 < 3

Conversion de types

Note

En Python on peut faire certaines conversions de type, pour transformer un nombre en chaîne de caractère ou l’inverse par exemple. .. code-block:: python

>>> s = str(123) ; print(s) ; type(s)
123
<type 'str'>
>>> s = int(s) ; print(s) ; type(s)
123
<type 'int'>

Exercice 16 : Dans la console essayez les conversions suivantes :

float(123) ; bool(0) ; str(True) ; float(’1.22’) ; int(1.23)
bool(1) ; bool(’abc’) ; float(’123’) ; int(True) ; str(123) ; bool(’’)
float(True) ; int(False) ; str(1.23) ; bool(1.23) ; float(False)

Entrées-sorties

Note

Pour afficher un résultat dans la console on utilise la commande print

>>> a = 3 ; b = 2
>>> print("La somme de {} et {} est {}".format(a,b,a+b))
La somme de 3 et 2 est 5

Pour lire une entrée au clavier on utilise la commande input en Python 3 et raw_input en Python 2 le résultat est un chaîne de caractère.

>>> n = int(input("Entrez un nombre : ")) ; print(n/2)

Exercice 17 : Ecrire dans un fichier TP1-exercice17.py un programme qui demande à l’utilisateur son nom, son prénom et son année de naissance et qui retourne le résultat suivant sous la forme :

Nom : Leponge
Prénom : Bob
Année de naissance : 1900

Solution

Exercice 18 : Ecrire dans un fichier TP1-exercice18.py un programme qui demande à l’utilisateur le rayon d’une sphère et qui retourne le résultat suivant sous la forme :

Entrez le rayon en cm : 5
Une sphere de rayon 5.0 cm a pour surface : 314.159265359 cm2
Une boule de rayon 5.0 cm a pour volume : 523.5987755982989 cm3

Solution

Exercice 19 : Ecrire dans un fichier TP1-exercice19.py un programme qui demande à l’utilisateur son nom et son prénom et qui retourne ses initiales.

Solution

Structures de contrôle

Instruction conditionnelle

Note

Les instructions conditionnelles sont essentielles en informatique. Elles permettent d’exécuter des instructions sous réserve que certaines soient vérifiées.

Un exemple très simple, dans le quel on test si la valeur d’une variable est plus petite que 3, et si c’est le cas on affiche qu’elle l’est.

>>> if a < 3 :
...     print("a est plus petit que 3")

Cette structure de condition est dite minimale. Il en existe des plus complexes.

Avertissement

L’indentation est essentielle ! L’indentation c’est le décalage marqué sur la seconde ligne. Il est égal à 4 espaces (c’est mieux) ou une tabulation. On ne mélange pas les espaces et les tabulations !

Exercice 20 : Ecrire dans un fichier TP1-exercice20.py le programme suivant :

import random
nombre = random.randint(0,10)
n = int(input('Saisissez un entier dans [0, 10]'))
if n < nombre:
        print('Votre proposition est trop petite')
elif n > nombre:
        print('Votre proposition est trop grande')
else:
        print('Vous avez trouve le bon nombre!')

Que fait ce programme ? Vérifiez le.

Note

Une structure conditionnelle complète suit le schéma suivant :

if condition_1:
        instructions_1

elif condition_2:
        instructions_2

elif condition_3:
        instructions_3
...

else:
       instructions_else

Les instructions de la première condition évaluée à True sont exécutées, si aucune ne l’est on exécute instructions_else .

Exercice 21 : Ecrire dans un fichier TP1-exercice21.py, un programme qui demande un nombre entier à l’utilisateur et qui affiche si oui ou non il appartient à l’intervalle entier allant de 0 à 10.

Solution

Exercice 22 : Ecrire dans un fichier TP1-exercice22.py, un programme qui demande un nombre entier à l’utilisateur et qui affiche le double s’il est impair et le triple s’il est pair.

Solution

Exercice 23 : Ecrire dans un fichier TP1-exercice23.py, un programme qui demande un nombre entier à l’utilisateur et qui affiche le double s’il est impair, le triple s’il est pair mais pas divisible par 4 et sa moitié sinon.

Solution

Exercice 24 : Ecrire dans un fichier TP1-exercice24.py, un programme qui demande un nombre à l’utilisateur et qui renvoie sa valeur absolue.

Solution

Exercice 25 : Ecrire dans un fichier TP1-exercice25.py, un programme qui demande les trois coefficients réels d’un trinôme \(ax^2+bx+c\) à l’utilisateur et qui retourne une phrase indiquant le nombre de racines réelles distinctes de ce trinôme, après avoir vérifié qu’il s’agissait bien d’un polynôme du second degré.

Solution

Exercice 26 : Ecrire dans un fichier TP1-exercice26.py, un programme qui demande une année à l’utilisateur et qui indique si elle est bissextile ou non. Une année est bissextile par définition si sa valeur vérifie l’une des conditions :

• être multiple de 4 mais pas de 100 ;
• être multiple de 400.

Solution

Solution 2 Avec les mots or et and .

Exercice 27 : Ecrire dans un fichier TP1-exercice26.py, un programme qui fait la même chose que TP1-exercice26.py mais avec une structure conditionnelle minimale et des opérateurs booléens.

Solution

Petit problème : Ecrire un programme qui retourne le plus grand nombre parmi quatre nombres donnés par l’utilisateur.

Boucle while

Note

Les boucles permettent de répéter certaines opérations autant de fois que nécessaire. Nous en verrons de deux sortes.

Une boucle while permet de répéter un bloc d’instructions tant qu’une condition est vérifiée. La structure d’une boucle while (tant que en anglais) est la suivante :

while condition: # Tant que la condition est remplie effectuer les instructions
        instructions

Un exemple : La table de 7.

i = 0 # On initialise notre compteur
while i < 10: # Tant que le compteur i est strictement plus petit que 10 faire :
        print("{} * 7 = {}".format(i+1,(i+1)*7)) # Afficher le résultat
        i += 1 # Incrémenter le compteur

Exercice 28 : Ecrire ce programme en pseudo-code.

Avertissement

Si dans ce programme vous oubliez d’incrémenter le compteur il ne sera jamais supérieur ou égale à 10 et votre programme ne s’arrêtera jamais !! On appelle ça une boucle infinie. Si vous avez lancé une boucle infinie vous pouvez l’arrêter avec CTRL - C si vous êtes dans un shell ou à l’aide du bouton triangulaire orange dans la console de Syder.

Exercice 29 : (Racine carrée entière) Ecrire dans un fichier TP1-exercice29.py, un programme qui demande à l’utilisateur un nombre entier n , qui affiche l’entier dont le carré est l’entier, inférieur ou égal, le plus proche de n. Par exemple il affichera 2 si l’utilisateur rentre 7.

Solution

Exercice 30 : Ecrire dans un fichier TP1-exercice30.py, un programme qui calcule la somme des n premiers entiers, n étant rentré par l’utilisateur.

Solution

Exercice 31 : Que calcule ce programme ?

somme = 0
i=0
while i <= 20:
        if i % 2 == 0:
                somme += i
        i += 1
print(somme)

Réécrire ce code sans la structure conditionnelle.

Solution

Exercice 32 : Ecrire dans un fichier TP1-exercice32.py, un programme qui calcule la somme des multiples de 3 ou de 5 strictement inférieurs à 1000.

Solution

Exercice 33 : (L’algorithme des différences successives)

Que calcule ce programme ? Ecrire dans un fichier TP1-exercice33.py le code de ce programme. Le modifier pour obtenir la division euclidienne de a par b.

Solution

Petit problème 1 :

On définit la suite de Fibonacci par :

Calculer la somme des termes pairs plus petit que quatre millions.

Solution

Boucle for

Note

La structure d’une boucle for (pour en anglais) est la suivante :

for element in sequence: # Pour tous les éléments de la séquence faire :
        instructions

La boucle for permet d’effectuer un bloc d’instructions pendant que element prend successivement toutes les valeurs dans sequence .

Un exemple : Avec une chaine de caractère comme séquence.

chaine = "Vive la PTSI-B!"
for lettre in chaine: # Pour chaque lettre dans chaine faire :
        print(lettre) # Afficher la lettre

Notez bien que c’est la commande for qui a crée le variable lettre.

Exercice 34 : Dans la console écrire un programme qui affiche toutes les consonnes de la chaîne “Vive les TP Python en PTSI-B” et qui affiche un underscore à la place des voyelles.

Solution

Note

L’expression range est très utile on l’utilise comme suit :

range(m) # Ensemble des entiers de 0 à m-1
range(n,m) # Ensemble des entiers de n à m-1
range(n,m,p) # Ensemble des entiers de n à m-1 par pas de p

Exercice 35 : Dans la console écrire un programme qui affiche la somme des carrés des entiers de 10 à 38, puis la somme des cubes des entiers impaires de 10 à 38, qui utilise l’expression range().

Solution

Exercice 36 : Dans la console écrire un programme qui calcule \(5^{245}\) en effectuant toutes les multiplications. Comparer avec 5**245.

Solution

Exercice 37 : Dans la console écrire un programme qui calcule \(100!\) en effectuant toutes les multiplications. Comparer le résultat avec la fonction factorial du module math. Calculer la somme des décimales de ce nombre.

Solution

Petit problème 2 :

Dans cet exercice, on cherche une approximation de \(\pi\) par une méthode de Monte-Carlo qui consiste à:

• tirer aléatoirement et uniformément un point M de coordonnées \((x,y)\) dans le carré unité \((x,y) \in [0,1[^2\)
• déterminer si le point se trouve dans le quart de cercle de rayon unité \(x^2 + y^2 \leq 1\)
• lancer cette expérience un grand nombre de fois et évaluer le ratio entre le nombre de points dans le quart de cercle et le nombre total de points. Ce ratio tend vers \(\displaystyle\frac{\pi}{4}\).

Pour cela, on utilisera la fonction random.random() qui permet de générer pseudo-aléatoirement un nombre entre 0 et 1. Elle est accessible après avoir fait import random.

Solution