Quelques bases de programmation en Python 3¶

Nous avons découvert la programmation en Python 3 en nous appuyant sur les activités de futurecoder.io ;

Après une présentation rapide du langage Python, de l'outil futurecoder.io et des notebook jupyter, vous trouverez ci-dessous un résumé de ce qu'il vous faudra retenir pour la suite de votre apprentissage ainsi que quelques exercices d'application et des précisions complémentaires...

Généralité¶

Python est un langage de programmation moderne imaginé par Guido Van Rossum , multi-plateforme, open-source, généraliste, orienté objet et de haut niveau.

Python n'a rien à voir avec le reptile du même nom, mais avec le groupe d'humoristes anglais des années 1970 Monty Python.

C'est un langage à la fois simple et puissant :

simple car facile à apprendre, son code est réputé concis et clair, sa syntaxe est très proche d'une notation algorithmique, base de toute programmation.
puissant car il possède une importante bibliothèque standard et un très grand nombre de paquets complémentaires dédiés au calcul scientifique et aussi pour de nombreux autres domaines d'application. C'est le langage retenu en Classe Préparatoire aux Grandes Ecoles...

Python est considéré comme un langage de conception rapide (Rapid Application Development).

C'est un langage interprété : pas besoin de compiler tout le programme source en code machine pour l'exécuter. L'interpréteur Python lit et exécute ligne après ligne un script codé en Python.
Ce qui est un très gros avantage pour l'apprentissage d'un langage informatique car on peut tester progressivement des portions de code au cours du développement d'un programme plus complet.

Un mot sur furturcoder.io¶

Parce que "Le code du futur, c'est vous !", Alex HALL (alexmojaki) a développé futurcoder.io un projet 100% open source d’envergure internationale de découverte de Python.
Il s’agit d'un interpréteur Python en ligne associé à un cours moderne et assez complet pour débutant, avec des exercices interactifs, un système d’aide très bien fait et des débugueurs variés.

In [2]:

from IPython.display import HTML

HTML('''
<center>
<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/un1BrrV57PA" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
</center>
''')

Out[2]:

La traduction française officielle a été réalisée par une poignée d'enseignants de NSI membres très actifs de l'AEIF. Une copie hébergée en France (plus RGPD et sans tracker) est maintenue disponible à l'adresse https://futurecoder.forge.aeif.fr/.

A l'instar d'autres développements tels que Basthon, JupyterLite, ou encore PyScript, que nous utiliserons par la suite, furturcoder.io est basé sur la récente technologie Pyodide qui permet d'interpréter des instructions Python directement dans un navigateur de façon interactive coté client...

Utilisation des notebook Jupyter¶

Ce document est un jupyter notebook, il permet d'exécuter du code cellule après cellule et ainsi d'expérimenter progressivement les portions d'un programme plus complet au cours de son développement.

Vous pouvez télécharger ce fichier avec son extension .ipynb en cliquant sur le bouton en haut à droite afin de l'éditer sur votre iPad en local avec l'application Carnets ou dans votre navigateur avec Basthon, ou encore avec Visual Studio Code pour le Web en y installant les extensions nécessaires...

Pour l'ouvrir dans l'application Carnets, il faut préalablement déplacer le fichier téléchargé avec l'application Fichier dans le dossier Carnets sur votre iPad ;

Potentiellement, Safari peut ajouter une extension .txt, il faut alors ouvrir votre fichier avec l'application Carnets et choisir dans le menu "File>Rename" pour supprimer cette extension puis cliquer sur < pour revenir dans l'explorateur des fichiers...

La façon habituelle de lire l'ensemble du notebook consiste à exécuter successivement les instructions de la première cellule de code jusqu'à la fin du notebook.

Mais attention, il est important que les cellules de code soient évaluées dans le bon ordre. Si vous ne respectez pas l'ordre dans lequel les cellules de code sont présentées, le résultat peut être inattendu.

En fait, évaluer un programme sous forme de notebook revient à le découper en petits fragments, et si on exécute ces fragments dans le désordre, on obtient naturellement le résultat d'un programme différent.

Entrée In[ ]: et Sortie Out[ ]:¶

En cliquant sur le bouton (ou en appuyant sur les touches d'un clavier <Maj+Entrée>, ou encore en utilisant dans le menu Cell>Run Cells and Select Below... cela a pour effet d'exécuter le code Python de la cellule sélectionnée et de présélectionner la cellule suivante...

Essayez vous-même :

In [ ]:

1+1

In [ ]:

"Bonjour ! "

Une ligne Out[ ]: apparait en dessous des instructions de code, affichant le résultat de celles-ci en sortie...

On peut rappeler le résultat de la dernière sortie dans la cellule suivante et le réutiliser ainsi :

In [ ]:

_ * 2

On peut rappeler le résultat d'une sortie particulière dans une autre cellule pour le réutiliser :

In [ ]:

Out[1] * 2

Rejouer les cellules précedentes, puis essayer de le refaire encore mais dans un ordre différent...

Vous pouvez également ajouter une nouvelle cellule à l'aider du bouton pour essayer autre chose.

Un des avantages principaux des notebooks est de vous permettre de modifier le code que nous avons préalablement écrit, et de voir par vous-même comment se comporte le code modifié.

Pour cette raison chaque élève dispose de sa propre copie de chaque notebook, ainsi vous pouvez bien sûr apporter toutes les modifications que vous souhaitez à vos notebooks sans affecter ceux des autres élèves et revenir à la version originale en rechargeant un notebook à partir du lien fourni.

Notions de programmation à retenir¶

Les Commentaires¶

Lorsque l'on rédige un programme informatique il est essentiel de le commenter pour expliquer des intentions de développement, pour cela en Python on utilise le caractère # qui permet d'indiquer que tous les caractères suivants sur la même ligne ne doivent pas être interprétés comme du code d'instruction :

In [3]:

##########################################
#   Un programme pour saluer doublement  #
##########################################
# Out[2] * Out[1]
# Décommenter l'instruction précédente...

Remarque: Le simple fait d'ajouter un # permet de désactiver une ligne d'instruction sans avoir à l'effacer. Elle ne sera donc pas prise en compte par Python lors de l'exécution du programme. Aussi, il suffira de la décommenter en enlevant ce # pour la réactiver plus tard si besoin...

Pour cela on peut utiliser la combinaison de touches <Ctrl+/>.

Essayez vous-même :

Décommenter l'instruction Out[2] * Out[1]

Opération de calcul sur les nombres¶

Les opérateurs arithmétiques de Python sont :

Symbole	Opération
+	Addition
-	Soustraction
*	Multiplication
/	Division
//	Division entière (renvoie le quotient)
**	Puissance
%	Modulo (renvoie le reste)

Pour observer les fonctionnalités de la machine à calculer Python, rendez-vous sur le bloc note Arithmetique

A faire vous-même :

Faire sur brouillon les calculs des instructions suivantes puis vérifier vos résultats en exécutant les cellules.

In [ ]:

(-4 + 13 * 2) // 20

In [ ]:

(-4 + 13 * 2) % 20

Opération sur les chaines de caractères alphanumériques :¶

Une chaîne de caractères est une suite de caractères.
Un caractère est un symbole tel qu'une lettre, un chiffre, un symbole de ponctuation, etc...

Pour délimiter le début et la fin d'une chaine de caractères, on l'encadre par des guillemets simples (apostrophes) ' ou doubles ".

Ce qui permet d'intégrer une ' ou des " dans une chaine de caractères.
Une autre solution consiste à utiliser un caractère spécial d'échappement \

En Python, les chaines de caractères sont des données immutables (non modifiables).

Essayez vous-même :

Les deux cellules suivantes produisent le même résultat :

In [ ]:

'ma chaine'

In [ ]:

"ma chaine"

A faire vous-même :

Vérifiez que l'instruction suivante produit une erreur puis trouvez une solution pour y remédier :

In [ ]:

'Demat d'an holl'

Concaténation¶

On peut concaténer deux chaines grâce à l'opérateur +.

Il faut saisir un caractère espace dans une chaine pour laisser une espace entre deux portions de chaines.

In [ ]:

'Hello'+' '+'World'+' !'

Répétition¶

On peut répéter une chaine grâce à l'opérateur *.

In [ ]:

"to"*2

Variables :¶

Pour définir une variable en Python, il suffit :

de la nommer (directement, sans autre mot clé comme var, int, contrairement à d'autres langages),

Il est recommandé de choisir pour les variables des noms significatifs de ce qu'elles représentent ;
Pour former un nom de variable avec plusieurs mots on remplace les espaces par des tirets du bas _ (le caractère underscore) ;

et de lui associer une valeur en utilisant l'opérateur d'affectation : =.

In [2]:

ma_premiere_variable = 'Hello World !'

L'exécution d'une instruction constituée du nom d'une variable renvoie la valeur qu'elle référence

In [ ]:

ma_premiere_variable

L'exécution d'une instruction comportant une variable non définie renvoie systématiquement une erreur.

In [ ]:

ma_seconde_variable

Mais rien n'est définitif, car l'intérêt des variables est de pouvoir changer de valeur

In [3]:

ma_seconde_variable = 5

initialiser une variable consite à lui affecter une valeur de départ comme par exemple :

mot = '' => une chaine vide, aucun caractère au départ ;

score = 0 => un nombre nul, début à partir de zéro...

Permutation de variables version 1 :

Soit les variables a et b définies telles que :

In [ ]:

a = 5
b = 'toto'

In [ ]:

Dans la cellule suivante, écrire un script qui, en utilisant une variable tampon nommée c, va intervertir les valeurs de a et de b :

In [ ]:

Typage dynamique¶

La fonction type() renvoie le type d'une valeur (ou celui de la valeur associée à une variable) :

Essayez vous-même :

In [ ]:

type("Demat d'an holl !")

In [ ]:

type(ma_premiere_variable)

In [ ]:

type(ma_seconde_variable)

In [6]:

ma_troisieme_variable = 5.0
ma_troisieme_variable, type(ma_troisieme_variable)

Out[6]:

(5.0, float)

Voici donc quelques types de valeurs :

str pour string, une chaine de caractères alphanumériques ;

int pour integer, un nombre entier ;

float un nombre flottant, représentant un nombre réel.

Python attribue de façon dynamique à une variable le type correspondant à la valeur qu'elle référence.

Opérations entre variables¶

Les opérations vues précédemment s'appliquent aussi entre des variables à condition que leur types soient compatibles et on peut alors en mémoriser le résultat dans une autre variable :

Essayez vous-même :

In [ ]:

(ma_premiere_variable + " ") * ma_seconde_variable

In [ ]:

v = 5
u = 12
t = v + u
t

In [ ]:

ma_premiere_variable + ma_seconde_variable

In [ ]:

(ma_premiere_variable + " ") * ma_troisieme_variable

Incrémentation et décrémentation d'une variable¶

Essayez vous-même :

Initialisez la variable i puis,
Exécutez les cellules des codes d'incrémentation et de décrémentation suivantes plusieures fois de suite ;
Essayez aussi pour des valeurs de $pas\neq1$...

In [ ]:

# initialisation de la variable
i = 0
i

In [ ]:

# incrémentation de la variable d'un pas de 1, code de base
i = i + 1
i

In [ ]:

# incrémentation de la variable d'un pas de 1, code condensé
i += 1
i

In [ ]:

# incrémentation de la variable d'un pas de -1, code de base
i = i - 1
i

In [ ]:

# incrémentation de la variable d'un pas de -1, code condensé
i -= 1
i

D'autres langages possèdent des notations encore plus condensées pour l'incrémentation i++ et la décrémentation i-- par pas de 1.

Permutation de variables version 2 :

Soit les variables a et b définies telles que :

In [ ]:

a = 5
b = 3

In [ ]:

Dans la cellule suivante, écrire un script qui, par une suite d'opérations arithmétiques, va intervertir les valeus de a et de b :

In [ ]:

Fonction d'entrée de données :¶

Il est parfois nécessaire de demander à l'utilisateur d'entrer des données pour attribuer une valeur à une variable. On utilise pour cela la fonction input().

Essayez vous-même :

Exécuter cette cellule plusieurs fois pour essayer avec des entrées de différents types...

In [ ]:

ma_variable = input("Entrer une valeur d'un type quelconque : ")
ma_variable, type(ma_variable)

On observe que le type renvoyé par cette cellule est toujours une chaines de caractères alphanumériques.

Il sera donc nécessaire de changer ce type en nombre pour pouvoir utiliser cette variable dans des opérations de calculs arythmétiques, et inversement pour des opérations de concaténation sur des chaines de caractères.

Les fonctions de conversion de type (transtypage ou cast) qui nous seront utiles ici sont int(), float(), str().

In [ ]:

ma_nouvelle_variable = float(input("Entrer un réel : "))
ma_nouvelle_variable, type(ma_nouvelle_variable)

Fonction d'affichage en sortie :¶

La fonction print() permet d'afficher du contenu :

Essayez vous-même :

In [ ]:

print("L'heure est venue de programmer")
print("au","lycée","Notre","Dame","du","Mur")
print(maPremiereVariable)
print(maSecondeVariable)
print(maTroisiemeVariable)
print(0x1A)
print(0b1100)
print("Python...\n" + ">" * 10, 'c\'est "cool" !')

On observe que les chaines de caractères s'affichent sans guillemets
et qu'un nombre indiqué en hexadécimal ou en binaire est affiché en décimal...

La fonction print() admet deux arguments interessants :

sep qui permet de séparer les valeurs par un texte de votre choix. Par défaut le séparateur est une espace " ".
end qui permet d'ajouter à la fin un texte de votre choix. Par defaut la fin de ligne est un retour à la ligne "\n".

In [ ]:

print("L'heure est venue de programmer", end = " ")
print("au","lycée","Notre","Dame","du","Mur")
print(maPremiereVariable, end=" | ")
print(maSecondeVariable, end=" | ")
print(maTroisiemeVariable, end=" | ")
print(0x1A, end=" | ")
print(0b1100)
print("Python...", ">" * 10 + ' c\'est "cool" !', sep = "\n")

Pour afficher un résultat avec du texte combiné avec des variables, il existe plusieurs méthodes :

In [ ]:

u = 15
i = 1
print("u",i," = ",u,sep='')

Par défaut sep est un espace, si on souhaite que l'indice soit acollé à la variable u, il faut redéfinir sep...

In [ ]:

u = 15
i = 1
print("u"+str(i)+" = "+str(u))

Il faut convertir les nombres en string pour pouvoir les concaténer avec du texte.

Avant Python 3.6, le plus élégant consistait à utiliser la méthode format(), en voici un exemple :

In [ ]:

a=4
b=5
print("Le produit de {0} par {1} est {2}\nLa division de {1} par {0} donne {3}".format(a,b,a*b,b/a))

On remplace { } par le contenu de la variable. Peu importe son type, le résultat sera affiché.

Depuis Python 3.6, on peut utiliser les f-strings pour formatter une chaine de caractères :

In [ ]:

a=4
b=5
print(f"Le produit de {a} par {b} est {a*b}\nLa division de {b} par {a} donne {b/a}")

A faire vous-même :

Vérifiez que la cellule suivante produit une erreur puis trouvez une solution pour y remédier en remplaçant toutes les concaténations de chaine par une seule f-string :

In [ ]:

nom = "Alice"
age = 20
print("Bonjour " + nom + ". Vous avez " + age + " ans.")

Structure séquentielle : une ligne de code <=> une instruction¶

Un programme informatique est une séquence d'instructions.

L'instruction 3 sera exécutée seulement après l'exécution de l'instruction 2. L'ordre des instructions est donc important.

Dans de nombreux langages de programmation comme Java, C, PHP ou JavaScript, les instructions sont séparées par un point-virgule.

On observe qu'il n'y a pas de ; à la fin d'une instruction Python, c'est donc le retour à la ligne qui marque la fin de l'instruction et donc le début de la suivante.

France IOI - Algoréa - Séquence d'instructions

Est-ce la première, la seconde, la troisième ou la quatrième grille en partant de la gauche ?

Votre réponse :

En réalité Python autorise le ; pour séparer des instructions et permet ainsi d'écrire une séquence d'instructions sur une même ligne tel que :

In [ ]:

maPremiereVariable='Hello World!';maPremiereVariable

Le résultat est bien évidemment le même, mais cette pratique, très rarement utilisée, est à éviter car cela devient vite illisible.

Elle est à réserver pour des tests temporaires pour son coté pratique car il suffit alors d'un seul # pour désactiver toute une séquence...

Structure itérative : boucle de répétitions avec for¶

La notion de boucle est fondamentale en informatique. Une boucle permet d'exécuter plusieurs fois des instructions qui ne sont inscrites qu'une seule fois dans le code.

La boucle for prend ses valeurs dans un ensemble itératif :

for variable in iterable

À chaque itération (un tour de boucle), la variable prendra pour valeur un élément de l'itérable (un caractère d'une chaine, un élément d'une liste, ...).

Pour créer une boucle équivalente aux boucles traditionnelles (pour i allant de m à n, faire...), nous utiliserons la fonction range() pour créer un itérable égal à une suite de valeurs entières.

La syntaxe générale est

for i in range(m,n,p):

i prend alors toutes les valeurs de m à n-1 par pas de p

Essayez vous-même :

In [ ]:

for i in range(1,4):
    print(i)

In [ ]:

for i in range(4):
    print(i)

In [ ]:

for i in range(0,6,2):
    print(i)

In [ ]:

for i in range(4,0,-1):
    print(i)

On peut aussi parcourir une chaîne de caractères :

In [ ]:

for lettre in "Bonjour":
    print(lettre)

A faire vous-même :

Modifier le programme de la cellule suivante pour qu'il affiche d, l, r, o, W,

In [1]:

nom = 'World'
ligne = ''
for caractere in nom:
    ligne = ligne + caractere
    print(ligne)

W
Wo
Wor
Worl
World

In [2]:

nom = 'World'
ligne = ''
for caractere in nom:
    ligne = # zone à modifier
print(ligne)

d,l,r,o,W,

France IOI - Algoréa - Boucle `for` :

Est-ce le premier, le second, le troisième ou le quatrième programme en partant de la gauche ?

Votre réponse :

Indentation obligatoire en Python :¶

Python oblige donc le développeur à structurer son code a l'aide des indentations : ce sont elles qui, après les :, détermineront les limites du bloc de la séquence d'instructions répétées dans la boucle et non pas les accolades comme dans la majorité des langages comme par exemple en JavaScript:

for (initialisation ; condition ; modification) {
    Instruction 1 ;
    Instruction 2 ;
    ... ;
}

L'indentation n'est donc pas ogligatoire dans tous les langages informatiques. Par exemple en Javascript on pourrait programmer tel que :

for(var i=0;i<8;i++){ellipse(positionX+entraxe*i,positionY,diametre,diametre);Instruction 2 ; Instruction 3 ; Instruction 4 ... ;}

Ce qui devient bien évidemment rapidement illisible pour un humain normalement constitué...

Python oblige donc par nature à produire du code clair et lisible donc plus facilement maintenable...

Il convient de toujours indenter avec 4 espaces. D'autres valeurs sont possibles, dans un bloc, de manière cohérente, mais 4 espaces est la convention adoptée par presque tout le monde. Remarquez que l'éditeur vous simplifie la tâche. Si vous pressez "Tab" dans l'éditeur, il va insérer 4 espaces pour vous.

Que ceux qui souhaiteraient coder avec des accolades en Python, exécutent l'instruction suivante dans un interpréteur :

In [ ]:

from __future__ import braces

et constatent que les développeurs de Python, avec ce genre d'"easter egg", ne manquent pas d'humour à l'instar des Monty... https://stackoverflow.com/questions/17811855/syntax-error-not-a-chance

Essayer aussi avec :

import this

import __hello__

import antigravity

In [ ]:

import this

Opérateurs relationnels, les comparateurs :¶

Symbole	Opération
==	égal
!=	différent
<	inférieur
>	supérieur
<=	inférieur ou égal
>=	supérieur ou égal

Ces opérateurs permettent de faire des tests conditionnels :

Essayez vous-même :

In [ ]:

condition1 = ( 0 == 1 )
condition1,type(condition1)

In [ ]:

condition2 = ( 0 <= 1 )
condition2,type(condition2)

On découvre là un nouveau type de variable bool pour booléen, leur valeur est soit True soit False.

Nous verrons plus tard plus en détails la logique booléenne que l'on doit à George

Structure conditionnelle (alternatives), si ... alors ... sinon :¶

if condition:
    # Traitement bloc 1
else:
    # Traitement bloc 2

Pour les tests multiples, il faudra enchaîner les if en cascade grâce à l'instruction elif, contraction de else if :

if condition:
    # Traitement bloc 1
elif:
    # Traitement bloc 2
else:
    # Traitement bloc 3

France IOI - Algoréa - Alternative :

Est-ce la première, la seconde, la troisième ou la quatrième instruction en partant de la gauche ?

Votre réponse :

Autre exemple à tester vous-même :

Essayez le script de la cellule suivante et trouver une stratégie qui permet de réduire le nombre de tentatives :

In [ ]:

# L'ordinateur génère un nombre secret compris entre 1 et 100 de façon aléatoire
from random import randint
nombre_secret = randint(1,100)

print("Saurez-vous trouver le nombre secret en moins de 10 coups ?")

for i in range (10) :
    
    # On demande au joueur de saisir un nombre entier compris entre 1 et 100
    proposition_du_joueur = int(input("\nSaisir un nombre entier compris entre 1 et 100 = "))
    
    if proposition_du_joueur < nombre_secret :
        print(f"C'est plus grand...\nIl vous reste {9-i} tentatives.")
            
    elif proposition_du_joueur > nombre_secret :
        print(f"C'est plus petit...\nIl vous reste {9-i} tentatives.")
            
    else :
        print(f"Bravo, vous avez trouvez le nombre secret en {i+1} coups !")
        break

if i+1 == 10 :
    print(f"Dommage, vous n'avez pas trouvez le nombre secret en moins de {i+1} coups !\nRéfléchissez à une stratégie pour trouvez en réduisant vos tentatives...")
      

Ce script utilise la méthode randint() du module random :

In [ ]:

from random import randint
help(randint)

In [ ]:

randint(1,6)# Simule le lancé d'un dé à six faces

Chi Fou Mi à coder vous même :

Programmer un jeu de Pierre-Feuille-Ciseau entre un joueur et l'ordinateur. Le meilleur des cinqs manches remporte la partie :

In [ ]:

Autres boucles avec while (TANT QUE ou JUSQU'A) :¶

Initialisation
# Début de la boucle
while Condition :
    Instruction 1
    Instruction 2
    ...
    Dernière Instruction
    Modification
# fin de la boucle et suite du programme

Les instructions inscrites dans la boucle forment un bloc d'instructions. Elles seront répétées tant que la condition de répétition est vrai.
Dès que la condition de répétition est fausse le programme sort de la boucle et se poursuit au delà.
L'initialisation déclare une variable et lui affecte une valeur initiale par exemple i = 0. La modification fait évoluer cette variable de façon régulière à chaque tour de boucle, par exemple par incrémentation i+=1. La condition consiste donc à faire un test binaire (vrai ou faux) sur la valeur de la variable i. Puisque i évolue à chaque tour de boucle, le résultat du test deviendra donc faux au bout d'un nombre fini d'itération.
Ce test s'appuie sur des opérateurs relationnels afin d'établir une comparaison entre la variable i et la valeur limite de répétition, par exemple i < 8.

Ce qui donne par exemple :

In [ ]:

i=0
print('Début de la boucle')
while i<8 :
    print('    Mon')
    print('    Bloc')
    print("    d'instructions")
    i+=1
    print('   ',i)
print('Fin de la boucle, prêt pour la suite du programme')

France IOI - Algoréa - Boucle `while` :

Est-ce le premier, le second, le troisième ou le quatrième programme en partant de la gauche ?

Votre réponse :

Les fonctions :¶

Les fonctions se définissent de la façon suivante :

def maFonction(parametre1, parametre2):
    instructions
    return valeur1, valeur2

Exemple :

In [ ]:

def max(x,y):
    if (x > y):
        return x
    else :
        return y

Pour l'utiliser, il faut l'appeler :

In [ ]:

max(6,3)

On peut ensuite la rapeller autant de fois qu'on le souhaite :

In [ ]:

max(-9,1)

France IOI - Algoréa - Fonction :

Est-ce le premier, le second, le troisième ou le quatrième programme en partant de la gauche ?

Votre réponse :

Formes creuses en console à coder vous même :

Ce que doit faire votre programme :

Écrivez un programme qui affiche une ligne de « X », un rectangle de « # », et un triangle de « @ ». Les deux formes doivent être creuses (remplies avec des espaces).

L'entrée comporte quatre entiers, un par ligne :

le nombre de « X » de la ligne à afficher ; le nombre de lignes du rectangle de « # » ; le nombre de colonnes du rectangle ; le nombre de lignes du triangle de « @ ».

Vous devez afficher les trois formes successivement, avec une ligne blanche entre chaque forme, comme le montre l'exemple.

Votre objectif doit être d'obtenir le code source le plus simple et clair possible, en le décomposant en fonctions.

Exemple

entrée :

sortie :

XXXXXXXXXXXXXXX

############
#          #
#          #
#          #
############

@
@@
@ @
@  @
@   @
@@@@@@

Commentaires

Attention : le nombre de lignes ou de colonnes peut être égal à 1.

In [ ]:

Outils¶

Interpréteur en ligne¶

L'ide de futurecoder peut être utilisé à tout moment avec ses débuggeur propres que sont snoop et birdseye pour tester du code et cela indépendemment de votre progression dans le flux normal des pages du cours de futurecoder
La console de basthon offre également un ide en ligne.

Notebook en ligne¶

Python tutor :¶

Python tutor permet de visualiser pas à pas ce que fait votre script.

Il est possible de l'utiliser dans un notebook jupyter pour cela il faut :

l'installer (si ce n'est pas déjà fait) : %pip install metakernel
puis exécuter les instructions de la cellule suivante :

In [ ]:

from metakernel import register_ipython_magics
register_ipython_magics()

inscrire la commande %%tutor devant le script à tester dans la cellule :

In [ ]:

%%tutor
# Script à tester :
for i in range(0,6,2):
    print(i)

Vocabulaire¶

expression : une portion de code qui possède une valeur ;
évaluer : calculer la valeur d'une expression ;
instruction : une ligne de code qui commande d'exécuter une action ;
affectation : action de donner une valeur à une variable ;
itération : un tour de boucle ;
concaténer : joindre des chaines de caractères ;
incrémenter/décrémenter : Augmenter/diminuer une variable d'une valeur fixée ;
indentation : ajout de tabulation ou d'espaces (x4) pour délimiter des blocs d'instructions ;

Autres ressources :¶

Références aux programmes :¶

Langages et programmation

Contenus	Capacités attendues	Commentaires
Constructions élémentaires	Mettre en évidence un corpus de constructions élémentaires.	Séquences, affectation, conditionnelles, boucles bornées, boucles non bornées, appels de fonction
Diversité et unité des langages de programmation	Repérer, dans un nouveau langage de programmation, les traits communs et les traits particuliers à ce langage.	Les manières dont un même programme simple s’écrit dans différents langages sont comparées.

Ce document est mis à disposition selon les termes de la Licence Creative Commons Attribution - Partage dans les Mêmes Conditions 4.0 International.

Pour toute question, suggestion ou commentaire : eric.madec@ecmorlaix.fr

Quelques bases de programmation en Python 3¶

Généralité¶

Un mot sur furturcoder.io¶

Utilisation des notebook Jupyter¶

Entrée In[ ]: et Sortie Out[ ]:¶

Essayez vous-même :

Notions de programmation à retenir¶

Les Commentaires¶

Essayez vous-même :

Opération de calcul sur les nombres¶

A faire vous-même :

Opération sur les chaines de caractères alphanumériques :¶

Essayez vous-même :

A faire vous-même :

Concaténation¶

Répétition¶

Variables :¶

Permutation de variables version 1 :

Typage dynamique¶

Essayez vous-même :

Opérations entre variables¶

Essayez vous-même :

Incrémentation et décrémentation d'une variable¶

Essayez vous-même :

Permutation de variables version 2 :

Fonction d'entrée de données :¶

Essayez vous-même :

Fonction d'affichage en sortie :¶

Essayez vous-même :

A faire vous-même :

Structure séquentielle : une ligne de code <=> une instruction¶

France IOI - Algoréa - Séquence d'instructions

Structure itérative : boucle de répétitions avec for¶

Essayez vous-même :

A faire vous-même :

France IOI - Algoréa - Boucle for :

Indentation obligatoire en Python :¶

Opérateurs relationnels, les comparateurs :¶

Essayez vous-même :

Structure conditionnelle (alternatives), si ... alors ... sinon :¶

France IOI - Algoréa - Alternative :

Autre exemple à tester vous-même :

Chi Fou Mi à coder vous même :

Autres boucles avec while (TANT QUE ou JUSQU'A) :¶

France IOI - Algoréa - Boucle while :

Les fonctions :¶

France IOI - Algoréa - Fonction :

Formes creuses en console à coder vous même :

Outils¶

Interpréteur en ligne¶

Notebook en ligne¶

Python tutor :¶

Vocabulaire¶

Autres ressources :¶

Références aux programmes :¶

Langages et programmation

¶

France IOI - Algoréa - Boucle `for` :

France IOI - Algoréa - Boucle `while` :