~~NOTOC~~
======Passer de SCRATCH à PYTHON====
Durant votre scolarité au collège, vous avez appris la programmation en bloc de type SCRATCH (Scratch, mBlock, Blockly ...). Vous savez qu'une fois que vous avez trouvé et écrit l'algorithme ou l'algorigramme, il faut le traduire en programme pour pouvoir le faire exécuter dans la machine/système. Vous savez aussi que Scratch, langage d'apprentissage, n'est pas le seul langage existant et qu'au lycée vous apprendrez le langage textuel Python.

<WRAP round box> 
**Compétences :**
  * CT 1.3 – CT 2.5 – CT 2.7 - DIC 1.5 : Imaginer des solutions pour produire des objets et des éléments de programmes informatiques en réponse au besoin.
  * CT 3.1 - OTSCIS 2.1 : Exprimer sa pensée à l’aide d’outils de description adaptés : croquis, schémas, graphes, diagrammes, tableaux.
  * CT 4.2 – CT 5.5 - IP 2.3 : Écrire un programme dans lequel des actions sont déclenchées par des événements extérieurs. 

**J’ai acquis la compétence si : **
  * J'ai compris les liens entre les blocs de contrôles Scratch et les instructions Python.
  * J'ai compris l'importance de la syntaxe des instructions et l'organisation des programmes.
  * J'ai repéré les principales instructions utilisées.
</WRAP>

Développé à des fins pédagogique, SCRATCH est inutilisable en dehors d'un cadre scolaire.

Dans ce cours, nous allons voir ce qu'est un langage de programmation textuel adapté aux débutants et toute la rigueur nécessaire à sa mise en œuvre.

=====PYTHON=====
Python et un langage de programmation structuré généraliste. Il s'utilise dans de très nombreux domaines et possède de nombreuses bibliothèques permettant d'en étendre les possibilités. C'est un langage populaire facile à exploiter. Il en est à la version 3.4.

Utilisé dans l'enseignement comme successeur du PASCAL qui est un langage compilé, il s'en rapproche sans en avoir la rigueur structurelle et en étant un langage interprété.
<WRAP group><WRAP half column centeralign>
PASCAL{{ :cours:logo_pascal.png?100|}}
<code Pascal>
program HelloWorld(output);
begin
  writeln('Hello World');
end.
</code>
</WRAP><WRAP half column centeralign>
PYTHON{{ :cours:logo_python.png?100|}}
<code Python>
print('Hello World!')
</code>
</WRAP></WRAP>

Pour faciliter l'écriture d'un programme et tester facilement son code, il existe des IDE (Environnement de travail intégré). Un des plus simple à utiliser est [[https://edupython.tuxfamily.org/|EduPython]], développé pour l'éducation et qui peut fonctionner à partir d'une clé USB.

Il existe aussi des IDE en ligne tel [[https://www.mycompiler.io/fr/new/python|MyCompiler]] qui permet aussi d'utiliser d'autres langages.

Les IDE colorent généralement les éléments du langage en fonction de leur type : variable, instruction, paramètre, opérateur, commentaire ...

<WRAP round tip>
  * Le **PYTHON** est un langage de programmation structuré généraliste très utilisé et simple à apprendre. C'est un langage interprété.
  * Un **programme compilé** est transformé en code machine en 1 seule fois. Il est plus rigoureux à écrire et à déboguer mais plus efficace dans les systèmes.
  * Un **programme interprété** est transformé en code machine ligne par ligne. Il plus simple à écrire et à déboguer mais moins efficace dans les systèmes.
  * Un **IDE (Environnement de travail intégré)** permet de simplifier l'écriture, le débogage et les test d'un programme.
</WRAP>

=====Instructions et syntaxe de base=====
Un commentaire, texte non interprété par l'IDE débute au symbole '#' et se termine à la fin de la ligne.

====Les variables et opérateurs====
===Les variables===
Comme en SCRATCH, les **variables** sont des espaces mémoires contenant une information et qui sont identifiés par un nom. Les variables Python ne sont pas typées et peuvent être un nombre entier (int()), décimal (float()), une chaîne de caractères (string()) ou une valeur vrai/faux (bool()).

===Instruction d'affectation===
<WRAP group><WRAP third column>
Les instructions algorithmiques suivante :
  * Mettre la valeur 2 dans la variable x
  * Mettre la valeur Pierre dans la variable nom
utilisent le **symbole d'affectation '='** qui permet aussi de modifier le contenu d'une variable.
</WRAP><WRAP third column>SCRATCH
{{ :cours:sp1.png?200 |}}
</WRAP><WRAP third column>
PYTHON
<code Python>
#Affectations
x = 2
nom = "Pierre"
x = x + 5
</code></WRAP></WRAP>

===Opérateurs===
Les **opérateurs arithmétiques** ( + - * / <nowiki>//) sont utilisés pour les opérations numériques (// = le reste de la division entière)</nowiki>. \\
**l'opérateur ( + ) permet aussi la concaténation** de chaîne de caractères.
<WRAP group><WRAP half column>
<code Python>identité = "Nom" + " " + "Prénom"</code>
</WRAP><WRAP third column>
{{ :cours:sp2.png?300|}}
</WRAP></WRAP>

Les **opérateurs logiques** sont <nowiki>( < > <= >= == != )</nowiki> : plus petit, plus grand, plus petit ou égal, plus grand ou égal, égal et différent.

Les **opérateurs booléens** True (vrai), False (faux), and (vrai si les 2 opérateurs sont vrais), or (vrai si 1 des opérateurs est vrai) et not (inverse True et False.

<WRAP round tip>Python utilise :
  * des **commentaires** débutants par '#'
  * des **variables** sont non typées et peuvent contenir un entier, un décimal, une chaîne de caractère ou un booleen
  * des **opérateur arithmétiques** + - * / <nowiki>// (modulo)</nowiki>
  * des **opérateurs logiques** <nowiki>< <= > >= == !=</nowiki>
  * des **opérateurs booleens** True, False, and, or, not
</WRAP>

====Les structures de contrôle====
Les **structures de contrôle (conditions, boucles)** permettent d'organiser les séquences d'instructions qui composent le programme.

Remarquer que, comme pour les algorithmes, **l'indentation (le décalage) est utilisé pour définir le bloc d'instructions** concerné par la structure. L'instruction concernée est terminé par le symbole ':'.

===Instruction conditionnelle : si - alors - sinon===
ALGORITHME<code>
Si d <0
    Afficher "Température négative"
Sinon
    Si d = 0
        Afficher "Température nulle"
    Sinon
        Afficher "Température positive"
</code><WRAP group><WRAP half column>SCRATCH{{ :cours:sp3.png?150 |}}
</WRAP><WRAP half column>PYTHON<code Python>
#Contrôle température
if d < 0 :
    print("Température négative")
else :
    if d == 0 :
        print("Température nulle")
    else :
        print("Température positive")
</code></WRAP></WRAP>

===Instruction boucle bornée : répéter - de - à===
Contrairement à SCRATCH, une boucle fermée ne démarre pas obligatoirement à 0.
ALGORITHME<code>
Demander un nombre et le mettre dans la variable X
Mettre la variable f à 1
Pour la variable n allant de 1 à x
    Mettre la variable f à f*n
Afficher "Factorielle de ", valeur variable x, " vaut ", valeur variable f
</code><WRAP group><WRAP half column>SCRATCH{{ :cours:sp4.png?400 |}}
</WRAP><WRAP half column>PYTHON<code Python>
#Factorielle
x = int(input("Entrer un nombre"))
f = 1
for n in range (1, x+1) :
    f = f * n
print ("Factorielle ", x, " = ", f)
</code></WRAP></WRAP>
L'instruction "input" permet d'afficher un message afin de permettre la saisie d'une valeur de type chaîne de caractère (string). Pour la convertir en nombre entier il faut utiliser l'instruction int() et float() pour convertir en nombre à virgule.

L'expression "in range" détermine la borne de début et la borne à ne pas atteindre (1, x+1 => n s'arrête donc à x). La borne de début peut être omise et vaut 0 par défaut. \\
L'expression "in variable chaîne" parcours 1 à 1 tous les caractères de la chaîne fournie.

===Instruction boucle conditionnelle : tant que===
Le boucle s'arrête lorsque la condition devient fausse.
ALGORITHME<code>
Demander un nombre et le mettre dans la variable X
Mettre la variable l à 0
Mettre la variable n à x
Tant que n >= 0
    l = l + 1
    n = (n - (n modulo 10)) / 10
Afficher valeur variable x, " contient ", valeur variable f, " chiffres"
</code><WRAP group><WRAP half column>SCRATCH{{ :cours:sp5.png?400 |}}
</WRAP><WRAP half column>PYTHON<code Python>
#Calcul nombre de chiffes
x = int(input("Entrer un nombre"))
l = 0
while n >= 0 :
    n = n//10
    l = l+1
print (x, " contient ", l, " chiffres")
</code></WRAP></WRAP>

<WRAP round tip> Les **structures de contrôles** sont :
  * **print**("texte ou", variable) #pour afficher un résultat
  * variable = **input**("texte") #pour demander une information
  * **if** condition : **else** : #pour un test vrai ou faux
  * **for** variable **in range** (deb, fin+1) : #pour une boucle bornée numérique (**in** chaîne #pour les caractères de la chaîne)
  * **while** condition : #pour une boucle conditionnelle
Les instructions contenues dans la structure sont indentées après le ':' jusqu'au retour à la ligne.
</WRAP>

====Les fonctions====
Les fonctions sont des sous programmes utilisant des paramètres afin de d'effectuer des séquences d'instructions répétitives.

===Fonctions utilisateur===
<WRAP group><WRAP half column>
<code Python>
#Definition de la fonction
def nom_fonction (parametre1, parametrex) :
    #Bloc d'instruction
    #...
    return valeur
    
#Programme principal
#...
x = nom_fonction (parametre1, parametrex)
#...
</code>
</WRAP><WRAP half column>
La fonction possède un nom et parfois une liste de paramètres (variables) séparées par des ','. 

A la fin de son exécution, elle peut retourner une liste de valeurs.
</WRAP></WRAP>

===Bibliothèques de fonction===
<WRAP group><WRAP third column>
De nombreuses fonctions utiles ont été développées et placés dans des bibliothèques les regroupant par type d'utilisation.
</WRAP><WRAP twothirds column>
<code Python>
#Importer la fonction Racine_Carrée contenu dans la bibliothèque math
from math import sqrt 
#Pour importer toutes les fonctions, utiliser '*' à la place du nom

#Utilisation de la fonction
print(sqrt(2)) #Affichage de la racine carrée de 2
</code></WRAP></WRAP>

<WRAP round tip>
  * Une **fonction utilisateur** utilise les mots clés **def** et **return**. Elle peut utiliser des paramètres en entrée et sortie.
  * Les **fonctions de bibliothèques** sont importées grâce à **from** et **import**. Elles s'utilisent de la même manière.
</WRAP>