<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
<title>Programmation Impérative Introduction Python et Variables</title>
<meta name="cours-n" content="3">
<meta name="author" content="Rémi Emonet">
<meta name="venue" content="ProgImp L2 Chimie/SPI">
<meta name="date" content="2016">
<meta name="affiliation" content="Université Jean Monnet − Laboratoire Hubert Curien">
<style type="text/css">
</style>
<!--
<script src="deck.js/extensions/includedeck/load.js"></script>
<script src="extensions/slides-dev.js"></script>
-->
<script src="extensions/deck-packed.js"></script>
<script src="extensions/slides.js"></script>
<script>go(function() {
$('.overview:first').addClass('no-print');
$('.overview:not(.no-print):first').addClass('no-print');
})</script>
</head>
<body>
<div class="deck-container">
<div class="deck-loading-splash" style="background: black; color: chartreuse;"><span class="vcenter" style="font-size: 30px; font-family: Arial; ">Please wait, while our marmots are preparing the hot chocolate…</span></div>
<section class="smart">
# @chunk: chunks/title.md
# Questions ? <br/> Commentaires ? {no-print}
# @chunk: chunks/objectives.md
## Programmation Impérative <span>{var-cours-n}</span> : Plan {#plan overview}
- Historique de Python {histo}
- Premiers programmes Python {firstprog}
- Variables et types {vartypes}
- Instructions conditionnelles {ifthenetc}
- Interaction avec l'utilisateur {interact}
# @copy:#plan
<!--
- Listes de valeurs {lists}
-->
<!-- #################################### -->
# @copy:#plan: %+class:inred: .histo
## Historique de Python {libyli} // en faire une motivation : pkoi python dans ce cours
- Début en 1989-1990
- Écrit en C // mais aussi Java, .net, Python
- Versions « précédentes »
- 1.5.2 : 1999
// ancien
- 2.0 : 2000
- 2.7.12 : juin 2016
// toujours en évolution
- 3.0 : 2008 // pour faire des gros changement alors qu'il y a bcp d'utilisateurs déjà
- 3.5.2 : juin 2016
// toujours en évolution
- De plus en plus utilisé dans le monde scientifiques
- Tous types d'utilisations
- faire des calculs, des statistiques
- interfaces graphiques
- jeux
- sites webs (<a href="http://www.djangopony.com/">django</a>, …)
// certains parlaient de php
## Notre Second Langage : Python 3 {py}
- Langage tous usages
- ordre (principal) = manipuler des variables, fonctions
- ordre = lancer d'autres programmes {bashli dense} // pas besoin d'avoir les autres prog en python
- simple à apprendre mais complet{slide}
- disponible sur Linux, Mac, Windows{slide anim-continue}
- beaucoup de « bibliothèques »{slide}
// comme les programmes externes de bash, mais pas externes
- Langage interprété (Python, bash, PERL, …){slide}
- écriture du programme dans un fichier{slide}
- exécution de l'interpréteur sur ce fichier (textuel){slide}
- exemple : `python3 programme.py` {no}
- Rappel : langage compilé (C, C++, Ada, …){slide}
- écriture du programme dans un fichier{slide}
- lancement du *compilateur* sur ce fichier{slide}
- lecture du fichier (textuel)
- transformation vers du langage machine
- sauvegarde dans un nouvel exécutable (binaire)
- lancement de l'exécutable créé{slide}
<!-- ######################################## -->
# @copy:#plan: %+class:inred: .firstprog
## Premiers Programmes Python // le faire en mode démo, avec écriture et sauvegarde de fichier
- Affichage et types
```python
print(42)
print ( 42 )
print("Hello bob")
print("Hello bob")
print("42")
print("le nombre vaut", 42)
print(42.42)
help(print)
print("le nombre", 42, sep=" vaut ")
{denser}
```
- Commentaires {slide anim-continue}
```python
# toute cette ligne est un commentaire
print(42) # cette fin de ligne est un commentaire
# print(42) toute cette ligne est un commentaire
{denser slide}
```
- Opérations arithmétiques {slide anim-continue}
```python
print(40 + 2)
print(42*1.01, 42.42 / 1.01)
print(2+4 * 10) # priorité
print(42**2) # puissance : 42²
print(42**0.5) # racine ! : √42
print((2 + 4)*10) # parenthèses
print(51 // 5) # division entière (10)
print(51 % 5) # reste de la division entière (1)
{denser slide}
```
<!-- ######################################## -->
# @copy:#plan: %+class:inred: .vartypes
## Types et Variables {py libyli}
- Toute valeur a un type {libyli}
- ex : `12` est un entier mais `"12"` est une chaîne de caractères
- accès au type avec `type()`
- par exemple `print( type(12), type("12") )`
- types principaux en python
- `int` : entier // illimité en python 3
- `float` : nombre réel (à virgule flottante)
- `str` : string, chaîne de caractères (simple ou double guillemets)
- (toutes les valeurs sont des chaînes de caractères){bashli dense}
- Variable : un nom pour une valeur
- affectation de variable
// attention : pas des MATH, comme BASH mais besoin de guillemets pour les str
- `a="tp1"`, `a = "tp1"`, `a = 12`
- `dossier = 'tp1'`, `dep = 40 + 2` {slide}
// noms plus longs, calculs
- `dossier=tp1` {bashli dense slide}
- utilisation de variables {slide}
- `print(dossier)`, `print(dep)`, `print(dep**dep)`
- texte par défaut, `$` pour les variables : `echo texte ${dossier}{}` {bashli dense slide}
- variables par défaut, systématiquement des guillemets pour le texte{pyli dense slide}
<!--
- `complex` : nombre complexes ($a + b\cdot j$)
- `list` : liste de valeurs // on verra plus tard
- `dict` : dictionnaire, conteneur associatif
-->
## Exemple de Variables en Python
- Programme du TP1 {slide}
```python
x = 1
y = 100
a = 0.2
res = x + a * y
print("res = ", res)
{slide}
```
- Carrés des nombres {slide anim-continue}
```python
i = 1
print(i, "a pour carré", i*i)
i = 2
print(i, "a pour carré", i*i)
i = 3
print(i, "a pour carré", i*i)
i = 4
print(i, "a pour carré", i*i)
i = 5
print(i, "a pour carré", i*i)
i = 6
print(i, "a pour carré", i*i)
{slide}
```
## Python : Typage Fort et Dynamique
- Typage dynamique en Python
- chaque valeur a un type
- les variables ont le type des valeurs qu'on leur affecte
```python
i = "bonjour" # type str
i = 42 # puis type int
print(type(i)) # <- type() pour obtenir le type
{}
```
- {no}
- typage statique (C) : un type à chaque variable, une fois pour toutes
- Typage fort en Python{slide}
- certaines opérations entre types sont interdites
- ex : `"salut" / 42`
- elles causent des erreurs à l'exécution // selon vous, pourquoi à l'exécution
- les opérations permises dépendent des types, ex :{slide}
- `a * b` permis ? // selon vous que peut on multiplier ?
- nb * nb ⇒ ok, ex : `40 * 1.05`{slide}
- str * int ⇒ ok, ex : `"la" * 42`{slide}
- list * int ⇒ ok {slide}
- str * str ⇒ non {slide}
## Noms de Variables et Mots Clés
- Noms de variables :
- ex : `a` `truc` `objet2` `maVariable` `ma_variable`
- ne contient que des lettres, chiffres et `_`
- ne doit pas commencer par un chiffre
- Mots clés {slide}
- mots ayant une sémantique spéciale
// nous en verrons la plupart
- `False` `None` `True` `and` `as` `assert` `break` `class` `continue` `def` `del` `elif` `else` `except` `finally` `for` `from` `global` `if` `import` `in` `is` `lambda` `nonlocal` `not` `or` `pass` `raise` `return` `try` `while` `with` `yield` {dense}
- Interdits comme nom de variable (ou fonction) {slide} // ou ne peuvent pas pour certains
# @chunk: chunks/q/py-norm-vec-1.md
# @chunk: chunks/q/py-norm-vec-2.md
# @chunk: chunks/q/py-norm-vec-3.md
# @chunk: chunks/q/py-typical.md
## Challenge {no-print}
- Calcul des racines d'un polynôme de degré 2 : $a x^2 + b x + c$
- Début du programme
```python
a = 12.532623
b = 42.424242
c = 3.14
{}
```
- À vous de jouer ! // aide de math en bullet point suivant
- Aide {slide}
- discriminant : $\Delta = b^2 - 4 a c$
- solutions quand elles existent : $\frac{-b \pm \sqrt{\Delta}}{2 a}{}$
<!-- ######################################## -->
# @copy:#plan: %+class:inred: .ifthenetc
## Instructions Conditionnelles `if` `else`
- Instruction conditionnelle
- besoin d'exécuter une partie du programme ou une autre
- selon une condition
- Instructions `if` en Python {slide libyli}
```python
unites = 42
prixUnitaire = 9.50
if unites*prixUnitaire < 400:
reste = 400 - unites*prixUnitaire
print("C est bon, il te reste", reste)
print("Fin de la transaction")
{slide}
```
- Instructions `if…else` (si…sinon) {slide anim-continue}
```python
…
if unites*prixUnitaire < 400:
reste = 400 - unites*prixUnitaire
print("C est bon, il te reste", reste)
else:
print("Non....")
print("Fin de la transaction")
{slide}
```
## Importance de l'Indentation en Python {libyli}
- Indentation : nombres d'espaces en début de ligne
- Bonnes pratiques (tous languages)
- l'identation reflète la structure du programme
- chaque « bloc » est indenté par rapport à son parent
- ex : les sous parties de `if` ont plus d'espaces
- En Python : indentation = bloc
- **obligation** d'indenter correctement
- le contenu du `if` (et `else`) **doivent** avoir plus d'espaces
- Conseils
- indenter avec 4 espaces
- ne jamais utiliser de tabulations
## Logique Booléenne {libyli}
- “Mathématiquement”
- $12 < 13$ est vrai (valeur booléenne V)
- $11 \le 10$ est faux (valeur booléenne F)
- Opérateurs booléens *et*, *ou*, *non* {libyli}
- {no c4 floatleft}
- F *et* F ... vaut ... F
- V *et* F ... vaut ... F
- V *et* V ... vaut ... V
- {no c4 floatleft}
- F *ou* F ... vaut ... F
- V *ou* F ... vaut ... V
- V *ou* V ... vaut ... V
- {no c4 floatleft}
- *non* V ... vaut ... F
- *non* F ... vaut ... V
- En Python {clearboth}
- constante `True` et `False`, opérateurs booléens `and`, `or`, `not`
- opérateurs de comparaison : `==` *<{smartcode}* *>{smartcode}* *<={smartcode}* *>={smartcode}* `!=`
```python
enPanne = False
carburant = 25.42
if carburant > 5 and not enPanne:
print("Tout va bien")
{slide}
```
## Retour sur l'Instruction `if` de Python {libyli}
- Structure à suivre pour `if` {anim-continue}
```python
if «cond»:
«instr» # si cond est True
«instr» # si cond est True
… # si cond est True
… # après le if
{slide}
```
```python
if «cond»:
«instr» # si cond est True
… # si cond est True
else:
«instr» # si cond est False
… # si cond est False
… # apres le if
{slide marginup}
```
- Où{libyli}
- «cond» est une condition booléenne
- «instr» représente n'importe quelle instruction Python
- les `:` sont obligatoire
- l'indentation (devant «instr») est obligatoire
- la désindentation marque la fin du `if`
# @chunk: chunks/q/py-if-1.md
# @chunk: chunks/q/py-if-2.md
<!-- ########################################
# @copy:#plan: %+class:inred: .lists
## Listes en Python
- Liste
- peut aussi être appelée « tableau »
- conteneur d'éléments
- une liste contient des éléments
- Exemples de listes {slide}
```python
l1 = [10, 13, 9, 4, 15]
l1bis = [10,13,9,4, 15 ]
l2 = ["bonjour", "salut", "hello", "hola"]
{slide marginup}
```
```python
l3 = ["pi", 3.141592, "echap", 16777216]
listeVide = []
{slide marginup}
```
```python
e = 2.7
x = 42.42
message = "hello"
l = [e, x, message, "autre", e, x*e]
...
{slide marginup}
```
## Opérations sur les Listes : accès simple
- Accès à un élément : «variable»`[`«indice»`]` (ex: `l1bis[2]`) {libyli}
- lecture/écriture
- **indices commençant à 0 !**
```python
l = ["premier", "second", "dernier"]
print(l[0]) # premier
print(l[2]) # dernier
l[1] = "DEUXIEME"
print(l[1]) # DEUXIEME
print(l) # ['premier', 'DEUXIEME', 'dernier']
{slide}
```
- Longueur d'une liste, fonction `len()` {slide}
- nombre d'éléments dans la liste
```python
print( len(l) ) # 3
print( len([]) ) # 0
print( len( ["hello"] ) ) # 1
{slide}
```
- Test d'appartenance à une liste, mot clé `in` {slide}
```python
l = ["un", "deux", "trois"]
print( 'un' in l, 'quatre' in l) # True False
{slide}
```
## Opérations sur les listes {libyli}
- Concaténation de deux listes et répétition d'une liste
- opérateur `+` : «liste» `+` «liste»
- opérateur `*` : «liste» `*` «entier»
- Ajout d'un élément à la fin
- fonction `append` : «liste»`.append(`«element»`)`
- Statistiques // seulement pour les nombres
- fonctions `sum` / `min` / `max` : par ex. `sum(`«liste»`)`, ...
```python
A = [1, 2, 3]
B = [4, 5]
print(A + B) # [1, 2, 3, 4, 5]
print(B * 3) # [4, 5, 4, 5, 4, 5]
y = A + B
y.append(42)
print(y) # [1, 2, 3, 4, 5, 42]
y[0] = 0
y = y + [3.14]
print(y) # [0, 2, 3, 4, 5, 42, 3.14]
print(max(y)) # 42
{slide}
```
# @chunk: chunks/q/py-list-1.md
# @chunk: chunks/q/py-list-2.md
# @chunk: chunks/q/py-list-3.md
-->
<!-- ######################################## -->
# @copy:#plan: %+class:inred: .interact
## Entrée Utilisateur : la Fonction `input` {libyli}
- But : rendre un programme interactif
- Comment : demander à l'utilisateur de taper du texte
- Fonction `input(invite)`
- affiche l'invite à l'utilisateur
- attend que l'utilisateur tape du texte et valide avec « entrée »
- renvoie la chaîne tapée par l'utilisateur
- Exemple {anim-continue}
```python
nom = input("Entrez votre nom : ")
msg = input("Entrez un message : ")
print("Yo", nom, "! Tu as dit «", msg, "»")
{slide}
```
- Le programme est interactif ! // Question: faut-il utiliser cette fonction ?
- Faut-il utiliser la fonction *input* ?
- plus « fun »
- mais moins automatisable
## Lecture de Nombres : Conversions {libyli}
- `input()` renvoie une chaîne de caractères
```python
nb = input("Entrez un nombre : ") # 5
msg = input("Entrez un message : ") # Poum Tchak
print( nb * msg ) # erreur chaine*chaine
{slide}
```
- But : conversion string⇆nombre (pas limité au cas de `input`) {libyli}
- fonction `int(chaine)` renvoie un entier
- fonction `float(chaine)` renvoie un flottant (réel)
- fonction `str(truc)` renvoie une string
```python
print( int("123") == 123 ) # True
print( float("42.12") == 42.1200) # True
print( int(nb) * msg) # ok!
{slide}
```
```python
age_string = input("Quel est votre age ? ")
suivant = int(age_string) + 1
suivant_str = str(suivant)
print("Vous allez avoir " + suivant_str + " ans !")
{slide marginup}
```
## Paramètres d'un Programme {libyli}
- But : l'utilisateur donne des paramètres au programme
- `bash creer-tp.bash tp1 tp2` {bashli}
- accès aux paramètres avec `${1}{}`, `${2}{}`, ...
- `python3 monprog.py poum tchak 5` {libyli pyli}
- importation du « module » `sys` (détails plus tard)
- `sys.argv[0]` contient le nom du fichier .py
- `sys.argv[1]` contient le premier paramètre
- `sys.argv[2]` contient le second paramètre
- chaque paramètre est une chaîne de caractères
```python
import sys
print("Le fichier python :", sys.argv[0])
# => Le fichier python monprog.py
print(len(sys.argv))
# 4 (le nom du fichier + 3 paramètres)
texte = sys.argv[1] + "-" + sys.argv[2] + " "
nb = int(sys.argv[3]) # conversion vers un entier
print(nb * texte)
{slide}
```
<!-- ######################################## -->
## Points Clés {key deck-status-fake-end}
- **Variables** en programmation impérative
- Types de base et variables en Python
- Logique booléenne
- **Instruction conditionnelle** (`if`/`else`)
- Entrée utilisateur avec la fonction `input`
- Paramètre de programme avec `sys.argv`
- `sys.argv[0]` : nom du fichier python
- `sys.argv[1]` : premier paramètre
- `sys.argv[2]` : second paramètre
- ...
<!--
## Paramètres d'un Programme {libyli}
- But : l'utilisateur donne des paramètres au programme
- `bash creer-tp.bash tp1 tp2` {bashli}
- accès aux paramètres avec `${1}{}`, `${2}{}`, ... et `$@`
- `python3 monprog.py poum tchak 5` {libyli pyli}
- importation du « module » `sys` (détails plus tard)
- `sys.argv` contient une liste avec
- le nom du fichier .py
- puis les paramètres
- chaque paramètre est une chaîne de caractères
```python
import sys
print(sys.argv)
# ["monprog.py", "poum", "tchak", "5"]
print(len(sys.argv))
# 4 (le nom du fichier + 3 paramètres)
texte = sys.argv[1] + "-" + sys.argv[2] + " "
nb = int(sys.argv[3]) # conversion vers un entier
print(nb * texte)
{slide}
```
-->
<!--
- Type liste et opération sur les listes
- Fonctions prédéfinies `len`, `sum`, `range`, ...
- Fonctions de variables `ma_liste.append(...)`
-->
</section>
<!-- deck.status snippet -->
<p class="deck-status deck-progress-10"> <span class="deck-status-current"></span> / <span class="deck-status-total"></span> − <span class="var-author">will be replaced by the author</span> − <span class="var-title">will be replaced by the title</span></p>
<a data-progress-size=": spe.top(15, 555); height: 45*designRatio; left: slide.right - 90*designRatio; width: 90*designRatio" class="ccby" href="http://en.wikipedia.org/wiki/Creative_Commons_license" title="This work is under CC-BY licence." target="_blank"></a>
<a class="ujm" data-progress-size=": spe.top(15, 525); height: 65*designRatio; left: slide.left; width: 130*designRatio" target="_blank"></a>
</div>
<!-- clicky Cla -->
<script type="text/javascript">
var clicky_site_ids = clicky_site_ids || [];
clicky_site_ids.push(100779706);
(function() {
var s = document.createElement('script');
s.type = 'text/javascript';
s.async = true;
s.src = '//static.getclicky.com/js';
( document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0] ).appendChild( s );
})();
</script>
<noscript><p><img alt="Clicky" width="1" height="1" src="//in.getclicky.com/100779706ns.gif" /></p></noscript>
<!-- Histats.com START (aync)-->
<script type="text/javascript">var _Hasync= _Hasync|| [];
_Hasync.push(['Histats.start', '1,2767123,4,0,0,0,00010000']);
_Hasync.push(['Histats.fasi', '1']);
_Hasync.push(['Histats.track_hits', '']);
(function() {
var hs = document.createElement('script'); hs.type = 'text/javascript'; hs.async = true;
hs.src = ('http://s10.histats.com/js15_as.js');
(document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(hs);
})();</script>
<noscript><a href="http://www.histats.com" target="_blank"><img src="http://sstatic1.histats.com/0.gif?2767123&101" alt="javascript hit counter" border="0"></a></noscript>
<!-- Histats.com END -->
</body>
</html>