<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
<title>Informatique 3 autres bases</title>
<meta name="cours-n" content="3">
<meta name="author" content="Rémi Emonet">
<meta name="venue" content="L2SPICHI">
<meta name="date" content="2018">
<meta name="affiliation" content="Université Jean Monnet − Laboratoire Hubert Curien">
<style type="text/css">
.strik{text-decoration: line-through;}
</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() {
});</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
# @chunk: chunks/objectives.md
## RAPPEL: Pour la semaine "prochaine" (lundi 17) {libyli}
- Inversion de classe : réviser les bases
- [https://learn.heeere.com/python/](https://learn.heeere.com/python/)
- Revoir : variables, listes, boucles, ...
- Prendre des notes : questions, points importants, surprenant
- Installer Python et les outils (si vous utilisez un ordinateur personnel)
- *Possiblitité d'examen court*
- Faire une carte conceptuelle (elle sera *ramassée*)
- choisir un thème (quelques « épisodes »)
- lister les concepts (4 à 10)
- tracer les relations
- (re)mettre en forme
- vérifier que les relations forment des propositions
- Rendu des cartes conceptuelles
- Des questions suites à vos révisions/installation ?
# ...
# Test rapide
## Informatique <span>{var-cours-n}</span> : Plan {#plan overview}
- Logistique TP et autre {tp}
- Bibliothèques en Python {biblio}
- Fonctions en Python {fonctions}
- Démarche d'écriture d'algorithme {algo}
- Un programme complet ? {moreprog}
<!-- TP -->
# @copy:#plan: %+class:inred: .tp
## Rendu Classique (à partir du TP2) {libyli}
- Typiquement 2 rendus
- premier rendu en fin de séance
- second rendu libre, avant le lundi suivant 5h00 (matin)
- Comment rendre
- créez un fichier .zip
- aller sur claroline connect
- aller dans ressource « Rendu TP... »
- envoyez votre fichier zip
- (ne pas supprimer l'ancien s'il y en a déjà un)
- Que rendre ?
- fichier zip avec le code python, le compte rendu, etc (voir énoncé de TP)
- bien penser à vos noms (les 2 pour un binôme) dans le compte rendu
- ⚠ fichiers absents, nom manquant, ... ⇒ comme si pas rendu
- NB: si le « rendu TP... » n'existe pas encore, me le dire
- RAPPEL: examen de TP personnel (pas de binôme)
## Semaine prochaine : « seconde chance » {libyli}
- TD de lundi
- aide au sujet du TD1 et TP1
- réponse aux questions (sur Python, etc)
- sur la base du volontariat
- besoin de soutient
- envie de servir de tuteurs/tutrices
- TP de mercredi
- fin du TP2 (l'avoir avancé avant si nécessaire)
- renforcement avec TP1
- prise d'avance sur le TP3
- CM de jeudi
- suite
# Autre Logistique
## À venir {libyli}
- Changement d'emploi du temps probable <br/> dans la semaine du (jeudi) 4 octobre
- Contrôle intermédiaire possible
- Semaine du 4 octobre ou la suivante
- Contenu parmi
- **tableaux numpy (une dimension) et matplotlib élémentaire**
- bases de Python (variables, boucles, listes, conversion)
- démarche d'écriture d'algorithme
## Plateformes {libyli}
- Claroline Connect
- lien vers les autres « sites du cours »
- si vous n'avez pas accès au cours ⇒
- vous inscrire (administrativement)
- m'envoyer un e-mail
- Plateforme d'exercice
- Objectif : vous permettre de pratiquer les bases
- Principe
- site web avec des exercices
- exercices générés automatiquement
- explications à chaque fois
- Incitation
- vous aide à réussir (TP et exam)
- participation régulière (chaque semaine)
- participation suffisante (min. 20 questions)
- identifiant de la forme : `etu-ab12345z`
- mot de passe à 6 chiffres : voir « Résultat » sur claroline
<!-- ######################################## -->
# @copy:#plan: %+class:inred: .biblio
## Qu'est ce qu'une Bibliothèque ? {libyli}
- Une collection de fonctions réutilisables, prêtes à l'usage
- Un ou des fichiers Python (`.py`)
- Bibliothèques interne, standards et externes {libyli}
- fonctions accessibles par défaut : `print`, `len`, `sum`, …
- bibliothèques standards
- accessibles du moment que Python est installé
- ex : `sys`, `math`, `random`, ...
- bibliothèques supplémentaires
- besoin d'être installées en plus de Python
- parfois disponibles par défaut (ex : anaconda) // cf infos pour l'install
- ex : `numpy`, `qtido`, ...
- En Python, aussi appelées « modules »
- But :
- ne pas réinventer la roue
- s'abstraire des détails
## Importer des Fonctions d'un Module {libyli}
- Il y a 3 façon pour utiliser les fonctions d'un module
- importation du module {anim-continue no}
```python
import math
print( math.sqrt(100) )
{slide}
```
- importation d'une fonction en particulier {anim-continue no}
```python
from math import sqrt
print( sqrt(100) )
{slide}
```
- importation de toutes les fonctions d'un module <br/>(ne pas en abuser, risque de conflicts) {anim-continue no}
```python
from math import *
print( sqrt(100) )
{slide}
```
- Aide d'un module avec `help`
```python
import math
help(math)
{slide}
```
## Exemple d'utilisation de fonction {libyli}
- Autre figure géométrique
```python
from qtido import *
f = creer(400, 200) # créer une fenêtre
couleur(f, 1, 1, 1) # Blanc
disque(f, 50, 50, 20) # centreX, centreY, rayon
couleur(f, 1, 0, 0) # Rouge
disque(f, 60, 30, 9)
disque(f, 40, 30, 9)
attendre_pendant(f, 1000) # en millisecondes
{slide}
```
- Illustration <img class="floatright" src="media/qtido/mickey-1.png"/>
<!-- ######################################## -->
# @copy:#plan: %+class:inred: .fonctions
# Mais avant… Quizz
# @chunk: chunks/q/py-accsum-sumif.md
# @chunk: chunks/q/py-fordizaine-2.md
# @copy:#plan: %+class:inred: .fonctions
## Fonctions en Python {libyli}
- Les bibliothèques fournissent des fonctions
- Il est possible d'écrire ses propres fonctions
- ne pas réinventer la roue (pas plus d'une fois)
- éviter de se répéter
- éviter le copier/coller
- Qu'est ce qu'une fonction
- un nom
- une liste de noms de paramètres
- un corps (suite d'instructions)
- possiblement une valeur retournée
## Définition de Fonctions en Python {libyli}
```python
import math
# les fonctions courtes peuvent être sur une ligne
def puissance(a, b): return a**b
def info(message): print("INFO :", message)
def distance_origine(x, y):
"renvoie la distance du point (x,y) à l'origine)"
d = x*x + y*y
return math.sqrt(d)
{slide}
```
- Suivant le modèle
```python
def «nom» ( «liste-param» ):
"documentation de la fonction, optionnelle"
«instr» # dans le corps de la fonction
«instr» # dans le corps de la fonction
… # dans le corps de la fonction
{slide}
```
- `def`, `(`, `)`, `:` et l'indentation sont **obligatoires**
- dans «liste-param», les noms sont séparés par des `,`
## Appel de Fonction et Valeur de Retour {libyli}
```python
def puissance(a, b):
print("notons que a vaut", a)
return a**b
v = puissance(2*21, 4)
v2 = puissance(v, 2)
print(v, v2)
{}
```
- À chaque fois qu'une fonction est appelée <br/> (ex, `puissance(2*21, 4)`) {libyli}
- les valeurs de paramètres sont calculées (ex, 42 et 4)
- ... et affectées à des variables (ex, a=42 et b=4)
- le corps de la fonction est exécuté (le print, puis le return)
- ... jusque la fin ou jusque `return`
- la valeur de l'appel est la valeur retournée <br/> (ex, `puissance(2*21, 4)` vaut `3111696`)
- `return` renvoie la valeur et **interrompt** la fonction
- si la fin arrive sans `return`, la fonction renvoie `None`
## Définition et appel de fonction
<div class="c6 floatleft">
```python
def norme(x, y):
d = x**2 + y**2
return d ** 0.5
# Appel 1
print(norme(3, 4))
# Appel 2
print(norme(40, 30))
{a}
```
</div>
<div class="c6 floatright">
```python
# Juste se rappeler
# ... que norme existe
a1_x = 3
a1_y = 4
a1_d = a1_x**2 + a1_y**2
a1 = a1_d ** 0.5
print(a1)
a2_x = 40
a2_y = 30
a2_d = a2_x**2 + a2_y**2
a2 = a2_d ** 0.5
print(a2)
{b}
```
</div>
- @anim: .a>span:nth-of-type(1), .a>span:nth-of-type(2), .a>span:nth-of-type(3)
- @anim: .b>span:nth-of-type(1), .b>span:nth-of-type(2)
- @anim: .b>span:nth-of-type(5), .b>span:nth-of-type(6) | .b>span:nth-of-type(7) | .b>span:nth-of-type(8)
- @anim: .b>span:nth-of-type(10)
- @anim: .b>span:nth-of-type(13), .b>span:nth-of-type(14), .b>span:nth-of-type(15), .b>span:nth-of-type(16)
- @anim: .b>span:nth-of-type(18)
- NB {slide}
- chaque appel a ses propres paramètres (x et y)
- chaque appel a ses propres variables locales (d)
- `return` donne la valeur par laquelle sera remplacée l’appel
## Fonctions : plus...
- Référence Python
- Site de L1 pour les détails (cours-06)
- TP L1
- Technique de la fonction principale
- Important : pile d'appel
- voir « python tutor » (cours précédent)
- voir « cours-06 » (L1)
<!-- ######################################## -->
# @copy:#plan: %+class:inred: .algo
## Algorithme d'Écriture d'Algorithme {libyli}
- But 1 : résoudre le problème ci dessous
- But 2 : **introspection**
- réfléchissez/étudiez ce que vous faites
- quelles étapes suivez vous pour résoudre le problème ?
- Problème : <br/>Écrivez une fonction `somme(l)` qui
- retourne la somme des valeurs de la liste `l`
- n'utilise pas la fonction `sum()` prédéfinie
## Étapes pour l'Écriture d'un Programme {libyli}
- Objectif pour vous : le programme (ou la fonction) {first}
- le programme n'est qu'une traduction de l'algorithme
- dans un langage que l'ordinateur comprend
- ⇒ sous objectif : écrire l'algorithme
- @anim: -.first | %attr:.first:height:0 +
- Conception d'un algorithme {libyli}
- décrire la tâche (sur papier)
- entrées reçues
- sortie voulue
- lister un/des exemples (sur papier)
- valeurs d'entrées, valeur de sortie attendue
- avoir des exemples variés : du plus simple au plus compliqué
- pour chaque exemple (sur papier)
- décrire les actions successives permettant d'arriver à la sortie attendue
- actions : lecture de valeurs, affectations (écriture)
- actions : opérateurs simples
- généraliser, rendre plus générique
- utiliser des variables/symboles
- faire apparaître des répétitions (boucles) et conditions
- exécuter à la main l'algorithme pour vérifier que ça fonctionne
- écrire le programme et le valider (par des tests)
## Avant de faire un exemple : <br/> processus inverse (lecture et réécriture)
```python
n = ...
f = creer(500, 500)
for i in range(20, 200, 4):
rectangle(f, i*4, 0, i*4+4, i*2)
attendre_fermeture(f)
```
## Exemple : écriture et généralisation
- Étant donné un entier $n$, écrire un programme qui affiche
- $n=1$ <img src="media/disques/disques-1.png"/>
- $n=2$ <img src="media/disques/disques-2.png"/>
- $n=3$ <img src="media/disques/disques-3.png"/>
- $n=5$ <img src="media/disques/disques-5.png"/>
- $n=9$ <img src="media/disques/disques-9.png"/>
## Pour pratiquer plus {libyli}
- Notes sur la conception d'algorithmes
- on va se tromper
- nos tests et exemples vont nous le montrer
- on va étudier les cas où ça ne fonctionne pas
- on va faire plusieurs itérations jusqu'à trouver une solution
- Exo : Tracer une diagonale de carrées (50 carrés de taille 10)
- Exo : Tracer une diagonale de carrées (tailles données par l'utilisateur)
- Exo : Soustraire 42 à tous les éléments d'une liste
- Exo : Compter les occurrences d'un élément dans une liste (ex: le nombre d'élément "poum")
- Exo : Remplacer toutes les occurrences d'un élément donné par un autre (ex: transformer les "poum" en "tchak")
- Exo : Inverser une liste, retourner une nouvelle liste avec le résultat
- Exo : Calculer la factorielle d'un nombre ($n!$)
<!-- Programme complet -->
# @copy:#plan: %+class:inred: .moreprog
## Que faire aujourd'hui ?
- Listes et tout
- Estimation de π par simulation ?
- Snake ??
## « Liste en compréhension » {libyli}
- Cas d'utilisation
- on veut parcourir une liste
- calculer une valeur pour chaque élément
- et remplir une nouvelle liste
- Version « classique » {anim-continue}
```python
premiers = [2, 3, 5, 7, 11]
carres = []
for n in premiers:
carres.append(n*n)
{slide}
```
- Compréhension de liste {anim-continue}
```python
premiers = [2, 3, 5, 7, 11, 13]
carres = [n*n for n in premiers]
{slide}
```
- Compréhension de liste avec condition {anim-continue}
```python
def premier(n):
...
return ... # True ssi le nombre est premier
carres = [n*n for n in range(15) if premier(n)]
{slide}
```
# listes
```python
"na" * 10
[20, 30] * 10
[0] * 100
list(range(10))
[0 for i in range(10)]
[i for i in range(100)]
a[0]
a[-1]
a[2:4]
a[2:3]
a[2:]
a[:4]
a[:-1]
{comment}
```
# $\pi$
- {comment}
- pi en générant une grille de nombres au hasards
- et en mappant vers une liste de distances
- et en mappant vers une liste de booléen (éventuellement `booleen_vers_int`)
- puis en sommant (sum())
# OK
<!--
## Points Clés {key deck-status-fake-end}
-->
</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 -->
<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 = ('//s10.histats.com/js15_as.js');
(document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(hs);
})();</script>
<noscript><a href="//www.histats.com" target="_blank"><img src="//sstatic1.histats.com/0.gif?2767123&101" alt="javascript hit counter" border="0"></a></noscript>
<!-- Histats.com END -->
</body>
</html>