<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
<title>Programmation Impérative Logique Python et Listes</title>
<meta name="cours-n" content="4">
<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}
- Rappels : conditions {ifthenetc}
- Rappels : interactions utilisateur {interact}
- Listes de valeurs {lists}
- Quelques « listes » utiles {useful}
- Boucle `for` sur une liste {forloop}
# @copy:#plan
<!-- ######################################## -->
# @copy:#plan: %+class:inred: .ifthenetc
# @chunk: chunks/q/py-if-1.md
# @chunk: chunks/q/py-typical-v3.md
# @chunk: chunks/q/py-if-3.md
## Importance de l'Indentation en Python {libyli}
```python
if n > 0:
print("n strictement positif")
else:
print("n négatif ou nul")
if n <= -999:
print("et n très négatif")
print("Fin")
{dense}
```
- 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}
- constantes `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}
```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ù `if` et les `:` sont obligatoires
- «cond» est une condition booléenne
- «instr» représente n'importe quelle instruction Python
- l'indentation (devant «instr») est obligatoire
- la désindentation marque la fin du `if`
- <a href="http://learn.heeere.com/2016-progimp-6a41/" target="_blank">site du cours</a>
# @chunk: chunks/q/py-if-2.md
# @chunk: chunks/q/py-if-4-elseif.md
<!-- ######################################## -->
# @copy:#plan: %+class:inred: .interact
## Rappel : la Fonction `input` {libyli}
- 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}
```
## Rappel : Conversions {libyli}
- `input()` (entre autre) 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}
```
## Rappel : Paramètres d'un Programme {libyli}
- But : l'utilisateur donne des paramètres au programme
- `python3 monprog.py poum tchak 5` {libyli}
- 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
- ...
- `len(sys.argv)` ⇒ nombre d'éléments dans `sys.argv`
- 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))
# vaut 4 ici (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}
```
<!-- ######################################## -->
# @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
## Rappel : paramètres d'un Programme {libyli}
- `python3 monprog.py poum tchak 5` (lancement)
- Accès aux paramètres
- importation du « module » `sys` (détails plus tard)
- `sys.argv` est 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}
```
<!-- ######################################## -->
# @copy:#plan: %+class:inred: .useful
## Pseudo-Listes : les String {libyli}
- Une chaîne de caractères (string) <br/>est accessible comme une liste {anim-continue}
```python
ch = "salut, bonjour"
print(ch[0]) # s
print(ch[5]) # ,
print(ch[len(ch)-2]) # u
{slide}
```
- Les chaînes peuvent aussi être concaténées avec `ch1 + ch2`
- Une chaîne peut être convertie en (vraie) liste {anim-continue}
```python
ch = "Salut !"
l = list(ch)
print(l) # ['S', 'a', 'l', 'u', 't', ' ', '!']
{slide}
```
## Pseudo-Listes : la Fonction `range` {libyli}
- Fonction `range` {libyli}
- `range(N)`, suite de $N$ nombres, de 0 à $N-1$
- `range(A,B)`, suite de $B-A$ nombres, de $A$ à $B-1$
- `range(A,B,S)`, nombres de $A$ à $B-1$ en comptant de $S$ en $S$
- NB : `range(N)` équivaut à `range(0, N)`
- NB : `range(A, B)` équivaut à `range(A, B, 1)`
- Peut être accédé comme une liste {anim-continue}
```python
r = range(10, 100) # les 90 entiers de 10 à 99
print(r[0]) # 10
print(r[9]) # 19
print(r[len(r)-1]) # 99
{slide}
```
- Peut être converti en (vraie) liste {anim-continue}
```python
r = range(5, 10)
l = list(r)
print(l) # [5, 6, 7, 8, 9]
{slide}
```
# @chunk: chunks/q/py-range-1.md
# @chunk: chunks/q/py-range-2.md
# @chunk: chunks/q/py-range-3.md
<!-- ######################################## -->
# @copy:#plan: %+class:inred: .forloop
## Itération sur les Listes : Boucle `for` {libyli}
- But des boucles
- exécuter plusieurs fois les mêmes instructions
- pour différentes valeurs
- ex : afficher les carrés d'un ensemble de nombres
- Exemple
```python
nombres = [1, 2, 3, 5, 7, 11]
for n in nombres:
print(n, "a pour carré", n*n)
{slide}
```
- Suivant le modèle
```python
for «var» in «liste»:
# ci-dessous : exécuté pour chaque élément de «liste»
«instr» # dans le for
«instr» # dans le for
… # dans le for
… # apres le for
{slide}
```
- `for`, `in`, `:` et l'indentation sont **obligatoires**
## Autre Exemple de Boucle `for`{libyli}
- Fonction `range` (rappel)
- `range(N)`, liste de $N$ éléments de 0 à $N-1$
- `range(A,B)`, liste de $B-A$ éléments de $A$ à $B-1$
```python
for n in range(5):
print(n, "a pour carré", n*n)
{slide}
```
```
0 a pour carre 0
1 a pour carre 1
2 a pour carre 4
3 a pour carre 9
4 a pour carre 16
{slide}
```
# @chunk: chunks/q/py-forrange-1.md
# @chunk: chunks/q/py-forrange-2.md
# @chunk: chunks/q/py-forrange-3.md
<!-- pas fait
# @chunk: chunks/q/py-forrange-4.md
# @chunk: chunks/q/py-forrangeneg-1.md
# @chunk: chunks/q/py-forrangeneg-2.md
## Itérer sur les Indices d'une Liste {libyli}
- But : avoir à la fois l'indice et la valeur d'une liste
```python
nbr = [1, 2, 3, 5, 7, 11]
for i in «????»:
print("nbr[", i, "] =", nbr[i])
{slide}
```
- Solution avec `range`:
```python
for i in range(len(nbr)):
print("nbr[", i, "] =", nbr[i])
{slide}
```
- Autre solution avec `enumerate` (plus tard)
# @chunk: chunks/q/py-fordizaine-1.md
# @chunk: chunks/q/py-fordizaine-2.md
-->
<!-- ######################################## -->
## Points Clés {key deck-status-fake-end}
- Rappels : `if`, `else`, `elif`, `input`, `sys.argv[…]`, `int(…)`, `float(…)`
- Type liste et opération sur les listes
- Fonctions prédéfinies `len`, `sum`, `range`, ...
- Fonctions de variables `ma_liste.append(...)`
- Fonction `range`
- `range(N)`, suite de $N$ nombres, de 0 à $N-1$
- `range(A,B)`, suite de $B-A$ nombres, de $A$ à $B-1$
- `range(A,B,S)`, nb de $A$ à $B-1$ en comptant de $S$ en $S$
- Boucle `for`
- répéter un bloc pour chaque élément d'une liste
<!--
- avec `range` et `len`, permet aussi de parcourir les indices d'une liste
-->
</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>