Programmation PeiP1 - Introduction

Introduction

Prise en main de l'environnement de programmation, notion de variables et types

EXERCICES DE COURS

1. Environnement de programmation

Pour écrire et exécuter des programmes Python 3 vous allez utiliser l'IDE (Integrated Development Environment) idle3 .

1.1. Programmation sous l'interpréte

Ouvrez une fenêtre de terminal et tapez idle3 & . Cela ouvre une fenêtre :
écran idle

Le & de la commande permet de mettre une tâche en arrière plan. Donc dans ce cas, vous aurez à la fois la fenêtre terminal et idle3.
L'interpréte Python peut être utilisé comme une machine à calculer. Par exemple vous pouvez taper les instructions :
4 + 56
4 + 56*2 (notez que les espaces ne sont pas significatifs et que la priorité des opérateurs est la priorité usuelle)
(4 + 56)*2 (on peut utiliser des parenthèses).
Essayez de taper 63/2 . Le résultat de l'opération est 31.5 qui est de type flottant. Les flottants sont une représentation machine finie des nombres décimaux. Pour obtenir le quotient de la division entière il faut utiliser l'opérateur //. Par exemple,

 63//2

renvoie 31 .
Notez que l'on peut connaitre le type d'une expression grâce à la fonction type . Tapez
type((4 + 56)*2)
type((4.0 + 56)*2)
type(35//2)
type(35/2)
Vous pouvez encore essayer (3.1416 * 54)/2 ou d'autres opérations qui vous font plaisir ...

1.2. Interprétation de programmes Python

En utilisant l'interprète Python comme une calculette, on ne peut pas stocker les opérations que l'on a exécutées, et il est donc difficile de ré-exécuter une suite d'opérations. Vous allez maintenant écrire les instructions Python dans un fichier dont l'extension sera .py. Une suite d'instructions est appelée un programme, les instructions d'un programme sont exécutées en séquence (i.e. les unes après les autres).

Avant de commencer, il est important d'organiser vos répertoires. Pour cela, créez un répertoire algoProgPeiP1 avec la commande
mkdir algoProgPeiP1.
Dans ce répertoire, créez un sous-répertoire td1 avec les commandes
cd algoProgPeiP1 mkdir td1
Pour chaque nouveau td, il faudra créer un sous-répertoire tdi dans algoProgPeiP1 où i est le numéro du td.

Sous idle, dans le menu Fichier faites Nouveau . Cela ouvre une fenêtre d'édition. Dans cette fenêtre tapez les instructions suivantes (ou plutôt, copier les depuis cette page de TD et collez-les dans l'éditeur idle) :
print(3 * 12) #ceci est un commentaire, il est ignoré mais bien utile pour savoir ce qu'on fait -4.5 * 16.2 # un exemple de calcul en flottant qui n'est pas affiché print (-4.5 * 16.2) # la fonction print permet d'afficher le résultat du calcul print (type(4))
Sauvez ce fichier dans exo1.py (ctrl-s ou fichier -> sauver) et tapez F5 pour exécuter le programme et observez en détail le résultat.

Explications : cycle d'exécution

Le programme exo1.py est constitué d'une séquence d'instructions. Quand vous tapez directement les instructions dans l'interprète Python, le cycle d'exécution est un cycle read-eval-print loop (plus de détails sur http://en.wikipedia.org/wiki/Read-eval-print_loop). Chaque instruction est lue, évaluée et affichée. Les opérations intermédiaires comme -4.5 * 16.2 sont donc affichées. Par contre, quand l'interprète exécute les instructions d'un programme, le cycle d'exécution est de lire le programme et l'évaluer en totalité sans affichage intermédiaire. Pour afficher, il faut utiliser la fonction print .

Explications : fonction print

print est une fonction qui indique à l'interprète d'afficher le ou les paramètres qui sont donnés entre (). Par exemple, print(-4.5 * 16.2) indique d'afficher le résultat de l'évaluation de -4.5 * 16.2. La fonction print peut afficher plusieurs valeurs, qui sont séparées par des virgules. Cela est très pratique pour afficher un message en plus du résultat. Voici deux exemples :

print("Le résultat est:",-4.5 * 16.2)

affiche :

Le résultat est: -72.9

print("Total de votre achat",5*34.5, "euros")

affiche :

Total de votre achat 172.5 euros

Exercice

L'opérateur % calcule le modulo d'un nombre entier. Par exemple, 47 % 5 est 2 puisque 47=9*5+2. Ecrire dans un fichier exo2.py un programme qui affiche le quotient et le reste de la division entière de 3124 par 6, qui affiche le type de l'expression 123*(1.56 -3) et le résultat de son évaluation. Le résultat de l'exécution de votre programme doit être le suivant :
```
quotient de 3124 par 6: 520 
reste de 3124 par 6: 4 
type de 123*(1.56 -3): <class 'float'> 
valeur de 123*(1.56 -3): -177.12 
```

2. Variables et type

2.1. Variables

Une variable est désignée par un nom et permet de stocker des valeurs, comme par exemple le résultat de calculs intermédiaires, ou les valeurs d'entrées du programme. Dans le programme ci-dessous, a et b sont des variables. Elles sont associées à un espace mémoire de votre ordinateur.


  a = 45
  b = 34
  print(a)
  print(a+b)
  a = a+b
  print(a)
  a = a*3
  print(a)

affiche

L'instruction a=45 est une affectation : cela signifie que la case mémoire associée à a reçoit la valeur 45. Une variable peut recevoir des valeurs successives : dans le programme ci-dessus, a stocke successivement la valeur 45 puis la valeur 79 (a+b) puis la valeur 237 (a*3).

Le = des langages de programmation n'a rien à voir avec le = des mathématiques, il n'est pas commutatif. Le membre gauche de l'expression doit être obligatoirement une variable, on ne peut pas écrire 2*3=x.
Dans l'affectation a=a*3 la nouvelle valeur de a est son ancienne valeur multipliée par 3, comme schématisé ci-dessous.

Pour choisir le nom des variables vous devez respecter des règles (© http://www.apprendre-en-ligne.net/python/TutoSwinnen/) : regle nom des variables

Exercice

Pâte à pizza.
Voici les ingrédients pour 4 personnes: 350 g de farine (type pâte à pain), 2 cuillères à café de sel, 1 sachet de levure boulangère, 3 cuillères à soupe d'huile d'olive et 25 cl d'eau tiède.
On vous demande d'écrire un programme qui affiche les proportions pour 4 personnes puis pour 10 personnes, selon l'exemple ci-dessous.
```
Pate à pizza pour 4 personnes
farine 350 g, sel 2 c. à cafè, levure 1 sachet, huile d'olive 3 c. à soupe, eau tiède 25 cl
Pate à pizza pour 10 personnes
farine 875.0 g, sel 5.0 c. à cafè, levure 2.5 sachet, huile d'olive 7.5 c. à soupe, eau tiède 62.5 cl
```
Nota Utilisez des variables car on peut aussi vous demander d'afficher les proportions pour 3 personnes.

Ecrire un programme divisionEntiere.py qui contient 2 variables v1 et v2 et qui affiche la décomposition entière de v1 par v2. Par exemple, si v1 vaut 49 et v2 vaut 3 il faut afficher :
```
Décomposition de 49 par 3 :
49 = 16 * 3 + 1
```
Tester votre programme en changeant les valeurs de v1 et v2.

2.1. Type booléen

Dans les exercices précédents, vous avez travaillé avec les types int les entiers, et float les nombres en virgule flottante. Nous allons voir ici le type booléen dont l'ensemble des valeurs est vrai ou faux, qui permettra d'exécuter des instructions selon certaines conditions (TD suivant).
Copier les instructions suivantes dans exo3.py et exécutez-le.

print(3>4)        
v = 4>3
print(v)          
print(type(v))    
print(not v)
a = 1==3
print(v and a)
print(v or a)

Explications : type booléen

Les variables v et a sont de type bool c'est à dire booléen. Un booléen a deux valeurs possibles False et True. Les opérateurs de comparaisons suivants renvoient des expressions booléennes :

    x == y     # égal
    x != y     # différent
    x < y      # inférieur strict
    x <= y     # inférieur ou égal
    x > y      # supérieur strict
    x >= y     # supérieur ou égal

Les expressions booléennes peuvent être composées pour donner d'autres expressions booléennes en utilisant les opérateurs logiques and (et), or (ou) et not (non).

Exercice

Que vaut 1<3 and (5<2 or 8>1) ?

Ecrire les tables de vérité de and, or et not

Ecrire un programme andEtOr.py qui contient deux variables booléennes b1 et b2 et qui calcule b1 and b2 en utilisant les opérateurs or et not. Vous pouvez utiliser le fait que not not a = a et que not (a or b) = (not a) and (not b). Tester votre programme pour toutes les valeurs possibles de b1 et b2.

2.2. Type chaînes de caractères

Copier les instructions suivantes dans exo4.py et exécutez-le.

a = "bonjour tout le monde"
print(a)
print(type(a))
print(len(a))
b = a + "en PeiP1"
print(b)
print(3*b)

Explications : chaînes de caractères

La variable a est de type str c'est à dire chaîne de caractères (string en anglais). La fonction len renvoie la longueur de la chaine, l'opérateur + permet de coller deux chaînes (on dit concaténer) et l'opérateur * permet de recopier une chaîne plusieurs fois.

Exercice

Ecrire un programme initiales.py qui affiche un rectangle avec vos initiales de la façon suivante (mes initiales sont HC):
```
HC HC HC HC HC HC HC HC HC HC 
HC                         HC
HC                         HC
HC                         HC
HC                         HC
HC HC HC HC HC HC HC HC HC HC
```
Remarques
- Il est recommandé d'utiliser l'opérateur *
- Puisqu'on écrit plusieurs fois la même chose, il est recommandé d'utiliser des variables.
- Dans une version avancée de votre programme, vous pouvez utiliser la taille de vos initiales (fonction len) pour que votre programme fonctionne correctement si vos initiales contiennent plus de 2 lettres (par exemple, pour quelqu'un qui s'appellerait Jean-Pierre Papin).

Collavizza Hélène