#!coding: utf-8
from __future__ import print_function, division
###
# Base UNE : "="
### egal
# <nav class="external">
# <a class="video" href="https://www.youtube.com/watch?v=zJ-w2izNvg4">Programmation — Théorie 1 : Structure, variables et conditions</a>
# </nav>
# <br/>
# <nav class="external">
# <a class="video" href="https://youtu.be/fForqjCBVeY">Théorie 1, prise en main et <code>exercice0</code></a>
# </nav>
#
# <span span>Allez sur repl.it python3 ou bien ouvrez Wing 101 (téléchargeable sur le site de Wing). </i>
# Les variables permettent de stocker une valeur dans la mémoire de l'ordinateur :
# <ul><li> <code>"="</code> permet de changer la valeur d'une variable
# <li> <code>print()</code> permet d'afficher à l'écran la valeur d'une variable </ul>
a = 5
print(a)
a = 6
print(a)
# <span class="comment">en python 2, les parenthèses n'étaient pas nécessaires
#
# On peut faire des maths :
b = a + 1 # b vaut maintenant a + 1 = 7
c = a + b * 2 # priorité des opérations
d = (a + b) * 2 # mettre des parenthèses si nécessaire !
print(b) # b n'a pas changé depuis qu'on a fait "b ="
print(c)
print(d)
#
# On peut modifier une variable existante :
a = a + 1 # on calcule "a + 1", puis on met le résultat dans a
print(a) # La variable "a" a donc été augmentée de 1"
#
# Pour afficher du texte, il faut le mettre entre guillemets :
print("fin")
#
# Pour afficher plusieurs choses on écrit une virgule:
print("J'ai", a, "patates") # en python 2, les parenthèses n'étaient pas obligatoires
# Essayez ce code sur [pythontutor](http://pythontutor.com/visualize.html#code=a%20%3D%205%0Aprint%28a%29%20%20%23%20en%20python%202,%20les%20parenth%C3%A8ses%20n'%C3%A9taient%20pas%20n%C3%A9cessaires%0Aa%20%3D%206%0Aprint%28a%29%0A%0Ab%20%3D%20a%20%2B%201%20%20%20%20%20%20%20%20%23%20b%20vaut%20maintenant%20a%20%2B%201%20%3D%207%0Ac%20%3D%20a%20%2B%20b%20*%202%20%20%20%20%23%20priorit%C3%A9%20des%20op%C3%A9rations%0Ad%20%3D%20%28a%20%2B%20b%29%20*%202%20%20%23%20mettre%20des%20parenth%C3%A8ses%20si%20n%C3%A9cessaire%20!%0Aa%20%3D%20a%20%2B%201%20%20%20%20%20%20%20%20%23%20on%20calcule%20%22a%20%2B%201%22,%20puis%20on%20met%20le%20r%C3%A9sultat%20dans%20a%0Aprint%28a%29%20%20%20%20%20%20%20%20%20%23%20La%20variable%20%22a%22%20a%20donc%20%C3%A9t%C3%A9%20augment%C3%A9e%20de%201%22%0Aprint%28b%29%20%20%20%20%20%20%20%20%20%23%20b%20n'a%20pas%20chang%C3%A9%20depuis%20qu'on%20a%20fait%20%22b%20%3D%22%0Aprint%28c%29%0Aprint%28d%29%0A%0Aprint%28%22fin%22%29&cumulative=false&curInstr=0&heapPrimitives=false&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) !
# Cliquez sur <strong>Visualize execution</strong> puis cliquez sur <strong>Forward</strong> pour exécuter chaque ligne ou sur <strong>Last</strong> pour voir uniquement le résultat final.
# Le résultat imprimé en raison de <code>"print"</code> est affiché dans le cadre <em>Print output</em>.
# Petite, question, quelle est la différence entre
# <code>print(a)</code> et <code>print("a")</code> ?
###
# Base DEUX : "if"
### if
#
# Qu'affiche ce programme ?
a = 7
if a < 10:
print("Coucou")
print("Hello")
# Le code se dit <em>est-ce que a < 10 ? Oui!</em>
# et donc il affiche <em>Coucou</em>, puis <em>Hello</em>.
# [Remplace](http://pythontutor.com/visualize.html#code=a%20%3D%207%0A%0Aif%20a%20%3C%2010%3A%0A%20%20%20%20print%28%22%7B%7BCoucou%7CKookoo%7D%7D%22%29%0A%20%20%20%20print%28%22Hello%22%29&cumulative=false&curInstr=0&heapPrimitives=false&mode=edit&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)
# maintenant <code>a = 7</code> par <code>a = 12</code> et relance le programme,
# quelle va être la difference ?
a = 12 # DIFF
if a < 10:
print("Coucou")
print("Hello")
# Quand <code>a = 12</code>, le code se dit <em>est-ce que a < 10 ? Non!</em>
# il saute le <code>if</code> et ne fait rien.
#
# Et celui là ?
a = 7 # DIFF
if a < 10:
print("Coucou")
print("Hello") # DIFF
# Correction:
#
# Et celui-là ?
#
a = 12 # DIFF
if a < 10:
print("Coucou")
print("Hello") # DIFF
# Correction: ...
#
# Le bloc if de ce programme va afficher <em>Coucou</em> puis <em>Hello</em> seulement si a est plus petit que 10,
# sinon, il saute le bloc et donc, ne fait rien.
# [Essayez](http://pythontutor.com/visualize.html#code=a%20%3D%207%0A%0Aif%20a%20%3C%2010%3A%0A%20%20%20%20print%28%22Coucou%22%29%0A%20%20%20%20print%28%22Hello%22%29&cumulative=false&curInstr=0&heapPrimitives=false&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)
# avec d'autres valeurs de <code>a</code>, comme <code>a = 12</code> ou <code>a = 10</code> par exemple.
# Mais si on veut quand même faire quelque chose quand la condition est fausse ?
# C'est là que vient le <code>else</code> :
if a < 10:
print("Coucou")
print("Hello")
else: # NEW
print("Tadaa") # NEW
# Si a < 10: le programme affiche <em>Coucou</em> puis <em>Hello</em>,
# sinon il affiche <em>Tadaa</em>.
## Diagrammes et exemple réels !
#
# Un autre exemple, on veut donner 50 points de vie à un personnage, sans dépasser 100...
vie = 75
vie = vie + 50
if vie > 100:
vie = 100
#
# Pour afficher plusieurs choses on écrit une virgule:
print("Votre vie est de", vie) # en python 2, les parenthèses n'étaient pas obligatoires
# Voici une représentation en diagramme de [ce if](http://pythontutor.com/visualize.html#code=vie%20%3D%2080%0A%0Avie%20%3D%20vie%20%2B%2050%0Aif%20vie%20%3E%20100%3A%0A%20%20%20%20print%28%22Max%20!%22%29%0A%20%20%20%20vie%20%3D%20100%0A%0Aprint%28vie%29&cumulative=false&curInstr=0&heapPrimitives=false&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) :
# <figure><img height=400 src="if_as_diagram.fr.svg"/></figure>
#
# On peut faire un <code>else</code>, le code ira dans le <code>else</code> si la condition est fausse:
if vie == 100:
print("Rempli!")
else:
print("Potions!")
#
# Ainsi le code précédent affiche <code>"Rempli!"</code> si vie vaut 100, sinon il affiche <code>"Potions!"</code>.
# Voici un diagramme de [ce if/else](http://pythontutor.com/visualize.html#code=if%20vie%20%3D%3D%20100%3A%0A%20%20%20%20print%28%22Rempli!%22%29%0Aelse%3A%0A%20%20%20%20print%28%22Potions!%22%29%0A%0Aprint%28%22Fin%22%29&cumulative=false&curInstr=0&heapPrimitives=false&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) :
# <figure><img height=270 src="ifelse_as_diagram.fr.svg"/></figure>
## Les opérateurs de comparaison
# Les opérateurs de comparaison sont
# <code>"<", ">", "<=", ">=", "==", "!="</code> (différent).
# Attention, pour comparer deux valeurs il faut utiliser <code>"=="</code>.
# et non <code>"="</code>.
# Autrement dit, <em>si un <code>"="</code> est dans un if, il doit avoir être doublé</em>.
# On se rappelle que <code>a = 5</code> veut dire <em>imposer que a vaut 5</em>
# alors que <code>a == 5</code> veut dire <em>est-ce que a vaut 5 ?</em>
#
# Petit exercice, essaie de réécrire le code précédent en utilisant l'opérateur <code>"!="</code> (différent).
## Récapitulons
# Dans un <code>if</code>, on peut mettre n'importe quel code,
# comme un <code>"="</code>, un <code>"print"</code>, ou... un autre <code>"if"</code>!
if a == 5:
a = 2
print("Yo")
if b == 5:
print("Hello")
else:
print("Tada")
else:
print("Hum")
print(a)
# Essaie ce programme avec plusieurs valeurs et vois ce qu'il se passe : <ul>
# <li> [<code>a = 5; b = 5;</code>](http://pythontutor.com/visualize.html#code=a%20%3D%205%0Ab%20%3D%205%0A%0Aif%20a%20%3D%3D%205%3A%0A%20%20%20%20a%20%3D%202%0A%20%20%20%20print%28%22Yo%22%29%0A%20%20%20%20if%20b%20%3D%3D%205%3A%0A%20%20%20%20%20%20%20%20print%28%22Hello%22%29%0A%20%20%20%20else%3A%0A%20%20%20%20%20%20%20%20print%28%22Tada%22%29%0Aelse%3A%0A%20%20%20%20print%28%22Hum%22%29%0A%20%20%20%0Aprint%28a%29&cumulative=false&curInstr=1&heapPrimitives=false&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)
# <li> [<code>a = 5; b = 2;</code>](http://pythontutor.com/visualize.html#code=a%20%3D%205%0Ab%20%3D%202%0A%0Aif%20a%20%3D%3D%205%3A%0A%20%20%20%20a%20%3D%202%0A%20%20%20%20print%28%22Yo%22%29%0A%20%20%20%20if%20b%20%3D%3D%205%3A%0A%20%20%20%20%20%20%20%20print%28%22Hello%22%29%0A%20%20%20%20else%3A%0A%20%20%20%20%20%20%20%20print%28%22Tada%22%29%0Aelse%3A%0A%20%20%20%20print%28%22Hum%22%29%0A%20%20%20%0Aprint%28a%29&cumulative=false&curInstr=1&heapPrimitives=false&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)
# <li> [<code>a = 2; b = 2;</code>](http://pythontutor.com/visualize.html#code=a%20%3D%202%0Ab%20%3D%202%0A%0Aif%20a%20%3D%3D%205%3A%0A%20%20%20%20a%20%3D%202%0A%20%20%20%20print%28%22Yo%22%29%0A%20%20%20%20if%20b%20%3D%3D%205%3A%0A%20%20%20%20%20%20%20%20print%28%22Hello%22%29%0A%20%20%20%20else%3A%0A%20%20%20%20%20%20%20%20print%28%22Tada%22%29%0Aelse%3A%0A%20%20%20%20print%28%22Hum%22%29%0A%20%20%20%0Aprint%28a%29&cumulative=false&curInstr=1&heapPrimitives=false&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)
# </ul>
# Fais maintenant l'exercice 0
# et regarde [la correction](http://pythontutor.com/visualize.html#code=a%20%3D%205%0Ab%20%3D%202%0A%0Aif%20a%20%3C%20b%3A%0A%20%20%20print%28a%29%0A%20%20%20print%28b%29%0Aelse%3A%0A%20%20%20print%28b%29%0A%20%20%20print%28a%29&py=3)
# sur pythontutor. Pour cet exercice, quels sont les cas à tester ? J'en vois au moins deux !
#
# J'ai également fait une vidéo sur cette page de théorie.
#
# Pour continuer la théorie, place à la théorie 2!
#
# Mais avant ça, je conseille de faire les exercices 1 à 4.
# <ul>
# <li> exercice0_trier_deux_nombres.py
# <li> exercice1_minute_suivante.py
# <li> exercice2_minute_suivante_un_print.py
# </ul>
#
# Tu peux aussi lire la section ci-dessous qui parle de <code>"and/or"</code> car elle <strong>peut</strong> t'être utile pour les exercices 3 et 4.
# <ul>
# <li> exercice3_trier_trois_nombres.py
# <li> exercice4_le_sept_parfait.py
# <li> theorie2_liste_while.py
# </ul>
## Les conditions combinées avec and et or
#
# On peut écrire des conditions combinées avec <code>"and"</code> et <code>"or"</code>, par exemple :
if a == 1 and b == 2:
print("Yo")
else:
print("Da")
# Ce programme affiche <code>"Yo"</code> si a est égal à 1 et b est égal à 2, sinon <code>"Da"</code>.
# Les <strong>deux</strong> conditions doivent être vraies.
# Il est appelé le <em>et logique</em>.
# Voici une représentation en diagramme d'un exemple de <code>"and"</code> :
# <figure><img height=495 src="and_as_diagram.fr.svg"/></figure>
# [Essayez](http://pythontutor.com/visualize.html#code=if%20a%20%3E%205%20and%20a%20%3D%3D%202%3A%0A%20%20%20%20print%28%22Waw%20!%22%29%0A%0Atruc%20%3D%2050%0A&cumulative=false&curInstr=0&heapPrimitives=false&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)
# de changer les valeurs de a et b pour vérifier que les flèches corespondent bien au code.
#
# On peut également utiliser <code>"or"</code> :
if a == 1 or b == 2:
print("Yo")
else:
print("Da")
# Ce programme affiche <code>"Yo"</code> si a est égal à 1 ou b est égal à 2.
# <strong>Au moins une</strong> des deux conditions doit être vraie.
# Il est appelé le <em>ou logique</em>.
# Voici une représentation en diagramme d'un exemple de <code>"or"</code> :
# <figure><img height=400 src="or_as_diagram.fr.svg"/></figure>
# [Essayez](http://pythontutor.com/visualize.html#code=if%20a%20%3E%205%20or%20a%20%3D%3D%202%3A%0A%20%20%20%20print%28%22Waw%20!%22%29%0A%0Atruc%20%3D%2050%0A&cumulative=false&curInstr=0&heapPrimitives=false&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)
# de changer les valeurs de a et b pour vérifier que les flèches corespondent bien au code.
# Attention, si tu mélanges des <code>and</code> et des <code>or</code>,
# utilise des parenthèses pour bien préciser l'ordre des opérations :
if a == 2 or b == 2 and c == 2: # qui du "or" ou du "and" a la priorité ?
print("Yo")
# cette ligne est équivalente à la précédente : or est "comme" un +, and est "comme" un *
if a == 2 or (b == 2 and c == 2):
print("Yo")
if (a == 2 or b == 2) and c == 2:
print("Yo")
#######################
# Pour en savoir plus
#######################
## =
# des raccourcis pour incrémenter/décrémenter !
a = a + 1
a += 1 # raccourci pour a = a + 1
a -= 1 # raccourci pour a = a - 1
a *= 2 # a = a * 2
# etc.
# floats (nombre à virgule, notez que "entier" se dit "integer" en anglais, souvent abbrégé en "int")
a = 2.5
a = 2.5e6 # la notation "e" crée toujours un float, ici 2.5 * 10^6 = 2.5 millions
a = 2e6 # 2000000.0, un float
# exposant
a = 2 ** 5 # 2 exposant 5 = 32, int ** int = int
a = 2.1 ** 2 # float ** int = float
a = 10 ** 0.5 # number ** float = float
a = 2 * 10 ** 6 # 2000000, un int, remarquez que l'exposant a priorité sur le "*"
# si on divise 14 par 4 on a 3.5
a = 14 / 4 # 3.5 (attention ! En python 2, 14 / 4 = 3)
a = 14 / 4.0 # 3.5 (même en python 2)
a = 14 / float(4) # 3.5 (float(4) fait la conversion int → float)
# l'opérateur de division entière "//" et l'opérateur de "reste" % (aussi appelé "modulo")
# si on divise 14 par 4 on a 3 avec un reste de 2 (comme à l'école primaire !) et donc sait que 14 = 3 * 4 + 2.
d = 14 // 4 # 3, la partie entière
m = 14 % 4 # 2, le reste (on dira "14 modulo 4 = 2")
# modulo négatifs (python is cool !), observez le cycle 0 1 2 3 4 :
n = -2 % 5 # 3 car -2 = -1 * 5 + 3
n = -1 % 5 # 4 car -1 = -1 * 5 + 4
n = 0 % 5 # 0
n = 1 % 5 # 1
n = 2 % 5 # 2
n = 3 % 5 # 3
n = 4 % 5 # 4
n = 5 % 5 # 0
n = 6 % 5 # 1
## plusieurs lignes
# si on ouvre une parenthèse, on peut passer à la ligne autant que l'on veut
x = (5 + 2 * 3
+ 7 * 2
+ 1
- 2)
## écrire en binaire ou hexadécimal
print(0b100) # 4
print(0xa2) # 162
print(hex(162)) # 0xa2
print(bin(4)) # 0b100
print(int('100', 2)) # 4
print(int('a2', 16)) # 162
## comparaisons multiple
if 2 <= a <= 5: # 2 <= a and a <= 5
print("a est entre 2 et 5")
if a == b == 0: # a == b and b == 0
print("a et b valent 0")
## not: "inverser" une condition
if a == 5: # si a == 5...
pass # ne rien faire
else:
print("a n'est pas égal à 5")
# équivalent à
if not(a == 5):
print("a n'est pas égal à 5")
else:
pass # ne rien faire
# équivalent à
if not(a == 5):
print("a n'est pas égal à 5")
# "sinon ne rien faire" est une opération inutile, on peut donc l'enlever
# équivalent à
if a != 5:
print("a n'est pas égal à 5")
# En effet, au choix du programmeur, le not peut être simplifié : <ul>
# <li> <code>not(a == b) ↔ a != b</code>
# <li> <code>not(a < b) ↔ a >= b</code> (ATTENTION : plus grand ou ÉGAL)
# <li> <code>not(X and Y) ↔ (not X) or (not Y)</code> (ATTENTION : OR)
# <li> <code>not(X or Y) ↔ (not X) and (not Y)</code> </ul>
# Les deux dernières lois sont souvent appelées <em>lois de De Morgan</em>.
if not(a == 5 and b < 7):
print("not(a == 5 and b < 7)")
if a != 5 or b >= 7: # équivalent au précédent
print("a != 5 or b >= 7")
# En règle générale, quand on a un if / else quelconque
# on peut, au choix, inverser la condition en mettant un <code>not</code>.
# Je conseille de faire ça quand vous avez un long <code>if</code> et un court <code>else</code> :
if a != 5 and a > 0:
print("yoyo")
print("tada")
print("truc")
if a == 4:
print("da")
else:
print("yo")
else: # ce "else" est court et oublié :(
print("coucou")
# on peut (au choix) l'inverser en "not(X)" sa condition :
if not(a != 5 and a > 0): # appliquez les lois de De Morgan si vous voulez
print("coucou") # aaah, l'ancien else est mis en avant :)
else:
print("yoyo")
print("tada")
print("truc")
if a == 4:
print("da")
else:
print("yo")
## elif
#
# Parfois, on a un <code>else</code> qui ne contient qu'une seule instruction, qui est un <code>if</code> :
if a < 5:
print("petit")
else:
if a < 10:
print("moyen")
else:
if a < 15:
print("grand")
else:
print("graaaand")
#
# Il existe un raccourci : <code>elif</code> (else if) :
if a < 5: # si a < 5
print("petit")
elif a < 10: # sinon... si a < 10
print("moyen")
elif a < 15:
print("grand")
else:
print("graaaand")
## bool
# Les conditions peuvent être mises dans des variables,
# cette variable sera de type "bool" (booléen), il vaut Vrai ou Faux (True or False)
condition = (a < 5)
if condition == True:
print("Plus petit !")
else:
print("Plus grand ou égal")
#
# Le <code>if</code> attend un bool, on peut donc enlever <code>== True</code>.
condition = a < 5 # parenthèse non nécessaires
if condition: # == True enlevé
print("Plus petit")
else:
print("Plus grand ou égal")
# on peut donc faire des "opérations" sur les bool
x = True
y = False
z = x or y # z = True or False = True
n = not x # n = not True = False
g = a < 5 and z
#
# Nous verrons que manipuler des bool sera plus pratique quand nous apprendront les <em>fonctions</em>.
## if fonctionnel
#
# Parfois, on a un <code>if/else</code> qui ne fait qu'assigner une variable, et rien d'autre !
if a == 5:
b = 8
else:
b = 3
# Il existe un raccourci: le <code>if/else</code> dit <em>en une ligne</em>,
# ou encore appelé, le <em>if fonctionnel</em> ou <em>l'opérateur ternaire</em> :
b = (8 if a == 5 else 3) # même code qu'au dessus
b = 8 if a == 5 else 3 # parenthèses non nécessaires
b = (8 if a == 5 else
3) # deux lignes c'est plus clair !
c = (8 if a == 5 else
4 if a == 2 else
1 if a < 0 else
0) # longue chaine !
#theorie1_egal_if.py
#White
#Dark
#txt
#download
#pdf