introduction aux variables

Introduction: le rôle clé des variables

Les exemples suivants montrent le rôle crucial des variables dans les algorithmes…

Compteur de passages

Un dispositif numérique, équipé d’un capteur, compteur le nombre de passage par une porte.

L’algorithme utilisé comporte 3 parties:

• initialisation de la variable
• boucle avec condition d’execution
• modification de la variable

Il utilise la fonction: coupure_faisceau

Et la variable: i nombre de passages detectés

i = 0
repeter indefiniment:
  {
  si coupure_faisceau_lumiere():
    {
    i = i + 1
    fin si
    }
  fin repeter
  }

Point neutre Terre-Lune

Dans l’un de ses célèbres romans intitulé De la Terre à la Lune, Jules Verne (1828-1905) relate les aventures de trois héros ayant pris place à l’intérieur d’un énorme projectile qu’un gigantesque canon, baptisé Colombiad, propulse en direction de la Lune. Lors de ce périple, Jules Verne fait allusion à un point neutre, situé à une distance d = 350 000 km du centre de la Terre où les forces gravitationnelles exercées par la Terre et la Lune sur le projectile se compensent.

L’algorithme utilisé comporte 3 parties:

• phase d’initialisation de la variable
• boucle avec condition d’execution
• modification de la variable

Il utilise les fonctions: F1 force de gravitation de la Terre, F2 force de gravitation de la Lune

Et la variable: d distance à la surface de la Terre

d = 0
repeter tant que F1 (d) > F2(d):
  {
  d = d + 1
  fin repeter
  }
afficher d

calculer en python

Les types de base: numériques, string, booléens

En python, les objets natifs de base ont pour type:

• nombre entier: integer ou int en Python
• nombre réel décimal: float
• chaine de caractères: str
• les valeurs logiques: booléen bool

Lorsque l’on présente une valeur dans le programme, le langage s’adapte selon le type, comme on le verra plus loin.

Pour vérifier le type d’un objet, on utilise la fonction type

Exemples

> type(12)
int
> type(12.0)
float
> type('12')
str
> type(True)
bool

Pour changer le type, on utilise les fonctions int, float, str. On utilise par exemple int lorsque l’on veut transformer un float ou un str en un entier:

> int('12')
12
> str(12)
'12'
> float(12)
12.0

Les nombres entiers et décimaux

Entier

Un entier: type int (ou integer). C’est un nombre qui n’a pas de point décimal. Les algorithmes utilisent en général des entiers, ce qui est avantageux pour les opérations de comparaison comme == ou !=.

valeurs possibles: 1, 2492042932330932, -23,...

Certaines opérations retournent un résultat de type entier:

expressions possibles: 13+3928, 34*2+10//3, 12%5, 2**8, ...

Un entier peut avoir une valeur aussi grande que celle que la machine peut stocker. Pour un nombre entier non signé, stocké sur 32 bits, cette valeur maximale vaut $2^{32}-1$

un nombre entier négatif: type int s’écrit avec un $-$ devant: $-10$ par exemple. Les entiers signés, codés sur 32 bits ont des valeurs qui s’étendent entre $[-2^{31},2^{31}-1]$

Décimal

un nombre décimal: type float s’écrit avec un point comme séparateur, comme par exemple: 6.02

valeurs possibles: 1.0, 249204.2932330932, -23.47,...

Les nombres exprimés avec l’opérateur e (puissance de 10), sont aussi des float, des décimaux:

> a = 12e3 # a vaut 12000
> print(a)
12000.0
> type(a)
float

La division de 2 nombres avec l’opérateur $/$ retourne toujours un type float, même avec des entiers:

> 20/8
2.5
> 20/10
2.0

Les float en Python ont une précision limitée. Ils sont généralement codés sur 15 chiffres significatifs et encodés sur 53 bits. Cela génère des imprecisions comme par exemple:

> 0.3/0.1
2.9999999999999996

Chaine de caractère

C’est une séquence constituée d’un ou plusieurs caractères, entourés de guillemets simples ou doubles.

Notez que des chiffres mis entre guillemets sont des chaines de caractères et ne peuvent pas être manipulés comme des nombres (voir plus loin).

Exemples

"Bonjour"
'Hello'
"18"
"Un longue chaine de caractères"
'une autre chaine'

caractères spéciaux

Certains caractères spéciaux ne sont pas affichés, mais permettent la mise en forme:

• Par exemple, le caractère \n génère un retour à la ligne:

> citation_python = 'je disais, "être ou ne pas être,\ntelle est la question"'
> print(citation_python)
# affiche
être ou ne pas être,
telle est la question

addition de chaines

L’addition de chaines* (concaténation) se fait avec l’opérateur +

> print("Bonjour"+"Hello")
BonjourHello

• L’opérateur * permet des répétitions multiples:

> print('Hi'*3)
HiHiHi

• Ou bien avec des accolades {} dans une expression formatée. Exemples:

# Exemple 1 avec .format
m = 100
Ec = 1200
resultat = "Pour le systeme m = {} et E = {}".format(m,Ec)
print(resultat)
# affiche
# Pour le systeme m = 100 et E = 1200

# Exemple 2 avec un f-string
m = 100
Ec = 1200
resultat = f"Pour le systeme m = {m} et E = {Ec}"
print(resultat)
# affiche
# Pour le systeme m = 100 et E = 1200

L’exemple 2 illustre une chaine particulière appelée f-string. C’est une chaine:

• préfixée par un f
• suivie par une chaine entre guillemets "" ou ''
• contenant des accolades {}
• où tout texte placé entre accolades sera remplacé par la valeur de la variable correspondante.

Test d’appartenance

L’opérateur in permet de tester si une suite de caractères se trouve dans un chaine:

• "ou" in "jour" vaut True
• "ou" not in "jour" vaut False

Ordre lexicographique

On peut comparer les caractères ou les mots à partir de leur rang dans l’alphabet:

'A' > 'B'
# Affiche False
'A' < 'B'
# Affiche True
'sauver'>'sauveur'
# Affiche False

Les valeurs logiques

Ce sont les valeurs True et False.

opérations avec not, and et or

On peut les combiner dans des formules logiques avec les opérateurs not, and, or:

> True and False
False
> True or False
True

opérateurs de comparaison

Une opération de comparaison, utilisant les signes ==, !=, >, >=, <, <= retourne un booléen True ou False:

> 0 == 0
True
> 0 == 1
False
> 0 != 1
True

Expressions possibles: 0 == 0, 8+1 == 2 * 3, 13 >= 1, 'A'<'B', 'a'>'c', 'Sol' in 'Soleil', ...

Utiliser les opérations booléennes dans un programme

Le booléen permet un branchement dans un algorithme (voir les structures conditionnelles). Exemples:

if True:
  # instruction 1
else:
  # instruction 2

# execution du bloc d'instruction 1

if False:
  # instruction 1
else:
  # instruction 2

# execution du bloc d'instruction 2

if 10 > 1:
  # instruction 1
else:
  # instruction 2

# execution du bloc d'instruction 1

On peut souhaiter executer infiniment le même bloc d’instructions, avec l’instruction `while:

while True:
  # bloc d'instructions

Changer de type avec la fonction bool

Lors de la transformation de type avec bool ou int, le True correspond à un 1 et le False à un 0:

> bool(1)
True
> bool(0)
False
> int(True)
1
> int(False)
0

Les opérations de base

1. Un langage informatique permet de réaliser des opérations sur des valeurs. L’écriture de ces opérations peut différer de ce que l’on écrit avec la calculatrice. Voici la liste des opérateurs en Python:

2. Ces opérateurs peuvent aussi être appliqués sur des chaines de caractères.

3. Un nombre ne peut pas être ajouté à une chaine de caractères:

10 + "x"
# retourne
...
TypeError: unsupported operand type(s) for +: 'int' and 'str' )

4. Opérations logiques Une opération logique consiste à comparer 2 valeurs et tester si celles-ci sont égales, ou s’il y a une relation d’ordre entre elles. Le résultat d’une opération logique ne peut être que True ou False:

ainsi, pour tester l’égalité entre 3 et 1+2, on peut écrire en python:

3 == 1+2
# retourne 
True
3 == 1+1
# retourne
False
3 > 1+1
# retourne 
True

Remarque: Le test de l’égalité n’est pas adapté pour les nombres réels. Seulement pour les nombres entiers. Ainsi, en Python, l’opération 0.1*3 == 0.3 renvoie … False!

Calcul sur des valeur entières

Les programmes informatiques préfèrent utiliser des valeurs entières pour les calculs, même si les calculs avec nombres à virgules sont possibles. Pour cette raison, les opérateurs // et % sont souvent utilisés en combinaison.

• Rappel: La division euclidienne de a par b est définie comme ceci: a est égal au quotient de a//b multiplié par le diviseur b, augmenté du reste a%b:

• Usages classiques:
  • n%2 vaut 0 si n est pair
  • n%2 vaut 1 si n est impair
  • n%10 conserve les unités
  • n//10 conserve les dizaines et supprime les unités.

travaux pratiques

TP1 Calculer en python

Liens

• Chapitre 1
  • types de base
  • TP1 sur les opérations et types de base
• Chapitre 2
  • Variables
  • TP2 sur les variables
• cours: structures conditionnelles
• TP3 conditions et fonctions
• TP4 Boucles non bornées - while

variables, opérations

Variables

1. Definition: Une variable sert à stocker une valeur, qui peut être un nombre, une chaine de caractère, ou autres. Une variable est identifiée par un nom, et pointe vers un espace mémoire.

Une variable est donc une zone précise de la mémoire vive de l’ordinateur (on parle d’adresse mémoire). À partir de cet emplacement, on trouvera une succession de bits dont l’agencement spécifique déterminera à la fois une valeur et un type.

2. Quel nom peut-on choisir pour une variable?: On peut choisir une lettre simple, minuscule ou majuscule, ou une chaine de caractères SANS espaces, et commençant obligatoirement par une LETTRE. Le nom peut contenir certains caractères spéciaux comme par exemple _. (ne pas utiliser le signe -, utilisé pour une soustraction entre 2 variables).

Exemples de noms de variables:

• x
• y
• a
• B
• longueur_L1
• nom
• age
• personne3
• Score
• Points_de_vie
• …

L’idée est de choisir un nom assez explicite, et d’éviter d’utiliser trop souvent x, y, a, b, c, …

3. Affectation On affecte une valeur à une variable en utilisant l’opérateur =.

Par exemple, pour affecter la valeur 5 à la variable x, on fait:

x = 5

Pour vérifier la valeur d’une variable, il suffit d’écrire celle-ci:

• soit toute seule dans une cellule du notebook

x
# retourne 
5

• soit à la dernière ligne de la cellule du notebook:

x = 5
# retourne 
5

• Soit avec la fonction print (ne pas mettre de guillemets)

x=5
print(x)
# retourne 
5

On peut modifier la valeur d’une variable existante. On peut méme lui affecter le résultat d’une opération:

x = 12/2
x
# retourne
6.0
# remarquer ici que la division simple retourne un float

Et utiliser la valeur de cette même variable pour l’opération:

x = 6
x = x + 1
x
# retourne
7

Affectation multiple: On peut affecter une valeur à plusieurs variables en une seule ligne, ce qui amèliore la lecture d’un script:

a = 1
b = 2

peut être remplacé par:

a, b = 1, 2

4. Opérations sur les variables Une variable a un TYPE qui est défini lors de l’affectation. Python s’adapte lorsque vous faites une affectation et choisit le type correspondant.

Pour démarrer, nous verrons les TYPES str (chaine de caractère), int (nombre entier) et float (nombre décimal, en virgule flottante).

Les opérations possibles sur une variable dépendent de son type.

• Pour les variables de type nombre int et float, on peut utiliser les opérateurs +,-,*,/,**,//,%
• Pour les variables de type str on peut aussi utiliser les opérateurs +,* mais le résultat est différent (opérateurs de concaténation).

Lorsque l’on modifie une variable, on affecte à nouveau à la variable le résultat de l’opération:

x = 6
x = x + 8
# x+8 vaut 14 que l'on affecte a nouveau a x
print(x)
# affiche 14

Opérateur d’affectation composée. L’instruction x = x + 8 peut être simplifiée en x += 8.

L’opérateur += réalise l’opération et l’affectation à la même varaible, x:

x = 6
x += 8
# x+8 vaut 14 que l'on affecte a nouveau a x
print(x)
# affiche 14

Il existe d’autres opérateurs d’affectation composée: -=, *=, /=.

Exemple:

x=6
x /= 2
x
# affiche 3.0

5. Variables et paramètres d’une fonction Les variables déclarées avec la fonction, entre parenthèse sont appelées paramètres. Le schéma suivant illustre l’affectation des valeurs des variables a = x et b = y lors de l’appel de la fonction additionne(x, y):

Visualiseur python

Le site pythontutor permet de visualiser le contenu des variables et leur espace de nom.

exemple 1: un espace mémoire pour chaque variable

x = 10
y = 14
x = x + 2
print(x)

Cliquer sur l’image pour lancer l’app pythontutor. Cliquer sur next pour dérouler le script pas à pas.

exemple 2: un espace mémoire pour les variables et pour les fonctions

x = 10
y = 14

# creation de la fonction avec le mot clé def
def additionne(a,b):
  return a + b

# appel de la fonction avec a = 10 et b = 14
> additionne(x,y)
24

Cliquer sur l’image pour lancer l’app pythontutor. Cliquer sur next pour dérouler le script pas à pas.

Travaux pratiques

TP2 Variables

Liens

• Chapitre 1
  • types de base
  • TP1 sur les opérations et types de base
• Chapitre 2
  • Variables
  • TP2 sur les variables
• cours: structures conditionnelles
• TP3 conditions et fonctions
• TP4 Boucles non bornées - while

Ce chapitre comporte 3 pages:

• Cours sur les structures conditionnelles: Lien
• TP3a, conditions, boucle while: Lien
• TP3b, algorithmes utilisant boucle while et structures conditionnelles: Lien

Structures conditionnelles simples et avec alternative

Conditions

1. Définition : Une instruction conditionnelle vérifie si une certaine condition est vraie avant d’executer son code :

if instruction_conditionnelle : 
  code_à_executer

Exemple :

if prix_essence > 1.8:
  print('Trop cher')

Remarquer que l’instruction if .. condition ..: finit par 2 points :, et que la ligne suivante est indentée

Toute portion de code associée à une structure de contrôle (finissant par 2 points :) nécéssite une indentation.

2. Les blocs du programme En Python, on utilise l’indentation (le retrait de la ligne) pour rendre compte des blocs de code.

3. L’alternative if - else Une instruction if - else contient une instruction if qui s’execute si la condition est True et une clause else qui s’execute si la condition est False.

if hauteur_plant < 3 : 
  print('laisser le plant dans la serre')
else : 
  print('le mettre dehors')

4. Conditions multiples if - elif - else Un bloc if - elif - else comprend une premiere instruction if, puis une suite de conditions de tests elif si le premier test echoue, puis un bloc else qui s’execute si tous les autres tests échouent.

Même s’il n’est pas obligatoire, il est fortement recommandé de finir une série de conditions elif par le bloc else.

if hauteur_plant < 3 : 
  print('laisser le plant dans la serre')
elif hauteur_plant < 10 : 
  print('le sortir le jour')
elif hauteur_plant < 15 : 
  print('le mettre dehors')
else : 
  print('Pret pour la recolte')

Rappelez vous:

• elif est toujours suivi d’une condition
• else n’est pas suivi d’une condition. C’est l’alternative, dont le bloc est executé lorsqu’aucune des conditions precedentes n’est vraie.

Tests logiques

Il s’agit d’une expression booléenne qui est évaluée est qui renvoie True si elle est vrai, False sinon.

Opérateurs de comparaison

Quelques exemples de tests logiques :

age == 18   # egalité
age != 18   # inegalité
age <= 18   # inferieur ou egal
nom == 'John' # egalité de chaines

Opérateurs et combinaisons logiques

L’expression peut aussi contenir les opérateurs logiques de combinaisons: and, or, not.

L’expression suivante, A and B est evaluée à True si A vaut True, et B vaut True. Dans tous les autres cas, (A vaut False, ou B vaut False, ou A et B valent False), A and B est evaluée à False. On peut résumer tous les cas dans une table logique:

Pour l’opérateur logique or:

et pour l’opérateur not

Exemple:

n = int(input('entrer un nombre entier: '))
if n%2 == 0 and n > 0:
    print('vous avez entré un entier pair et positif')

Une instruction if peut également tester une valeur booléenne et exécuter son code si cette valeur vaut True, comme par exemple, ci-dessous, avec if jeu_actif:

Il n’est pas nécéssaire d’écrire == True comme ici avec if jeu_actif == True:

if jeu_actif : 
  print('jouons !')

Test sur une liste

On peut aussi vérifier si un élement existe dans une liste :

capitales = ['Paris', 'Berlin', 'Rome', 'Londres', 'Madrid']
'Paris' in capitales  
# retourne
# True car 'Paris' est dans la liste capitales

Test sur un dictionnaire

Le mot-clé in permet de tester si une clé est présente dans le dictonnaire:

dico = {'cle1':'val1','cle2':'val2','cle3':'val3'}

print('cle1' in dico)
# affiche True

print('val1' in dico)
# affiche False car `'val1'` est une valeur et non une clé.

Remarque : 0 et None

Dans le test logique, 0 et None se comportent comme s’il s’agissait de False:

ch = input('Entrez un nombre entier quelconque')
n =eval(ch)
if n:
 print("vrai")
else:
 print("faux")

Ce petit script, lorsqu’il est executé, renvoie toujours True quel que soit le nombre saisi, mais False dans les cas suivants. Si on saisit

• 0 # zero
• None # le type Rien

A savoir: dans certains cas, on peut faire l’économie de l’opérateur logique. Dans l’instruction conditionnelle if n, la condition vaut True dès que n est différent de 0 ou de None, ou bien n vaut True.

Ainsi, les scripts suivants sont équivalents

# script 1
# sortir = True ou bien sortir = False
if sortir:
  print('Vous pouvez sortir')

if sortir==True:
  print('Vous pouvez sortir')

# script 2
# n est un entier
if n != 0:
  print('n est different de 0')

if n:
  print('n est different de 0')

Boucles non bornées: while

1. Definition: Une boucle non bornée permet de répéter un élément de code un nombre à priori inconnu de fois.

On écrit l’instruction: while <condition d execution>:

Le bloc de code est indenté sous cette première ligne:

while <condition d execution>:
  instruction 1
  instruction 2
instruction suivante # suite du programme

Cette boucle repète l’execution d’un bloc de code (instruction 1, instruction 2), tant que la <condition> est evaluée à True. Le test sur la <condition> est réalisé à chaque itération.

Lorsque cette <condition> n’est plus réalisée, le programme passe à l’instruction suivante.

Souvent, il sera nécessaire de démarrer le programme par initier une variable (celle utile pour la condition d’execution). De sorte que cette condition d’execution soit évaluée à True, et que le bloc de cette boucel s’execute au moins une fois.

Exemple 1: Réaliser un compteur

print("Jeu du cache-cache: compte jusqu'à 10")
i = 1
while i <= 10:
  print(i)
  i = i + 1
print("c'est fini, j'arrive")

• à la première itération, i vaut 0, donc la condition i <= 10 est évaluée à True et le bloc est executé. Le programme affiche 1 et i finit avec la valeur 2 (i = i + 1)
• La boucle se poursuit jusqu’à ce que i soit égal à 11. Alors i <= 10 est évaluée à False et le programme poursuit APRES la boucle, avec la dernière instruction: affiche "c'est fini"

Exemple 2: reste de la division euclidienne de 40 par 3

r = 40
while r >= 3:
  r = r - 3
print('à la fin du programme, r vaut ' + str(r))

• A la première itération, r vaut 40 donc la <condition> r > 3 est True. r est diminué de 3 et prend la valeur 37.
• A la dernière itération, 4 >= 3 est evalué à True. r est diminué de 3 et prend la valeur 1
• Puis r >= 3 est evalué à False. Le bloc n’est pas executé et le programme s’arrête s’il n’y a pas d’autres instructions (ou poursuit le script sinon).

2. Le problème de l’arrêt Pour le script précédent, si l’on avait remplacé la condition r >= 3 par r == 3 le programme aurait pu executer le bloc r = r - 3 indefiniment. r aurait pris successivement les valeurs 40, 37, … 4, 1, -2, -5, … etc, sans jamais prendre la valeur 0.

C’est le problème avec les boucles non bornées. Celles-ci peuvent ne pas finir, ce qui peut bloquer la machine.

Cet effet de boucle infini peut être recherché, par exemple en robotique, où l’on veut que le programme se poursuive indéfiniment. Ainsi, la structure d’un programme python sur carte microbit commence par la structure suivante:

from microbit import *

while True:
  # instructions
  # ...

Mais dans le cas général, il faudra veiller à ce que la boucle finisse à un moment donné. Par exemple, dans le script suivant, on met l’instruction break qui a pour effet d’interrompre la boucle lorsque break est executée :

while True : # boucle qui à priori ne finit jamais
  nom = input('Quel est votre nom ?')
  if nom == 'quitter':
    break
  print('Bonjour, {}'.format(nom))
print('sortie de la boucle')

Exemple:

Quel est votre nom ? John
Bonjour, John!
Quel est votre nom ? quitter
sortie de la boucle

Suite

Cours

TP3a conditions

TP3b conditions et algorithmes

Boucles bornées en Python

Definition

Une boucle bornée est un système d’instructions qui permet de répéter un certain nombre de fois toute une série d’opérations.

La syntaxe d’une boucle bornée, en langage algorithmique peut s’écrire:

Pour i allant de 0 a n-1
Faire:
   instruction 1
   instruction 2
FinPour

En python, la syntaxe correspondante est:

for i in range(n):
  instruction 1
  instruction 2

On peut représenter ce script avec des modules à assembler type scratch ou blocky):

Remarque

Construction de la boucle bornée

• Le bloc d’instruction sera executé n fois. Celui-ci peut contenir une ou plusieurs instructions, du moment qu’elles sont bien positionnées dans le bloc.
• En Python, le bloc est identifié par une indentation: un retrait par rapport au bord gauche, comprenant 2 espaces (ou 4).
• Pour sortir du bloc, on élimine l’indentation (on revient sur le bord gauche)

• La fonction range(n) renvoie la liste des entiers de 0 à n-1. C’est un principe général en informatique, on commence toujours à compter à partir de 0, et il faut donc s’arrêter à n-1 pour effectuer n fois la boucle.
• Pour chaque itération, le variant i prend une nouvelle valeur de l’ensemble {0,1,2,... n-1}, et peut être utilisé dans le bloc d’instructions.
• On peut choisir n’importe quel nom pour le variant, pas seulement i.
• Contrairement à la boucle non bornée while, le programmeur ne s’occupe pas de faire varier i à chaque itération. Cela ce fait tout seul.

Exemple:

for i in range(2):
    print(i)
# affiche
0
1

La boucle est executée 2 fois, et affiche 0 puis 1. Pas 2.

Boucle bornée et séquence

L’instruction utilisant le mot-clé for suit la construction suivante:

for variant in iterable:
    # bloc de code à repeter

Ce que l’on appelle iterable, c’est un ensemble de valeurs que prend successivement le variant.

iterable = range(5)

Dans ce premier cas, le variant prend successivement le valeurs de l’ensemble {0,1,2,3,4}. Le variant vaut 0 lors le premiere itération, puis 1 à la deuxieme, etc …

for i in range(5):
    print(i)
# affiche
0
1
2
3
4

A tester vous-même (python): Exemple 1: utiliser la fonction range

iterable = "abc"

Dans ce deuxieme cas, le variant i prend successivement le valeurs de l’ensemble {"a","b","c"}. Le variant vaut “a” lors le premiere itération, puis “b” à la deuxieme, etc …

for i in "abc":
    print(i)
# affiche
"a"
"b"
"c"

A tester vous-même (python): Exemple 2: utiliser une séquence de type str

iterable = [1998,2018]

Les listes en python sont des sequences qui placent les valeurs entre crochets [...]. Les valeurs sont séparées par des virgules ,

L = [1998, 2018]

for annee in L:
    print('La France a gagné la coupe du monde en ', annee)

A tester vous-même (python): Exemple 3: utiliser une séquence de type list

le variant annee prend successivement le valeurs de l’ensemble {1998,2018}

On peut placer autant de valeurs que l’on souhaite dans une liste.

Boucle bornée et non bornée

Pour la boucle bornée for, il n’est pas necessaire d’ajouter une instruction dans le bloc pour que le variant change de valeur à chaque itération. Cela se fait tout seul, à chaque fois que le programme revient sur l’instruction for.

Exemples

Exemple 1: afficher le variant de boucle i

# Boucle bornée
for i in range(3):
  print(i)
# affiche
0
1
2

Remarque: la fonction range(3) va créer une liste itérable constituée des valeurs 0, 1, 2. Ce sont les valeurs prises successivement par le variant i dans for i in range(3)

Voici le programme équivalent, utilisant une boucle NON BORNEE while:

# Boucle non bornée
i = 0
while i<3:
    print(i)
    i = i + 1
# affiche
0
1
2

Remarque: Avec une boucle non bornée, il faut:

• déclarer la valeur initiale du variant: i = 0
• écrire la condition d’execution après le while, i<3
• faire varier le variant dans la boucle while, i = i+1

Exemple 2: Ce variant peut être utilisé pour une formule mathématique, à l’intérieur de la boucle:

# boucle bornée
for i in range(3):
  x = i*7
  print(x)
# affiche la table de 7
0
7
14

# boucle non bornée
i = 0
while i < 3:
  x = i*7
  print(x)
  i = i + 1
# affiche la table de 7
0
7
14

Suite

Cours

TP3 Boucles bornées et non bornées

listes

Chaines de caractères, Listes et Boucles bornées

Chaines de caractères

1. Definition: Une chaine de caractère est une séquence ordonnée de caractères, mis entre guillements (simples ' ou doubles "). C’est le type str en python. Pour en savoir plus sur les chaines, on pourra consulter la page: google dev: chaines

On accède à un élément d’une chaine grace à sa position, appelée indice. Le premier élément a pour indice zero.

> voyelles = 'eio'
> voyelles[0]
e
> voyelles[1]
i
> voyelle[2]
o
> voyelles[-1]
o # le dernier element de la liste
> voyelles
'eio'

Un indice négatif permet d’identifier les éléments à partir de la fin: -1 pour le dernier caractère, -2 pour l’avant dernier, …

Illustration avec la chaine de caractères Hello:

2. Modifier une chaine Contrairement aux listes, il n’est pas possible de modifier un caractère dans une chaine:

> voyelles = 'eio'
> voyelles[2] = 'y'
TypeError: 'str' object does not support item assignment

3. Une fonction utile aux chaines: len La fonction len va retourner la longueur de la chaine de caractères.

> chaine = 'abc'
> len(chaine)
3

Listes

1. Definition: Une liste est une collection ordonnée d’objets. Une liste est entourée de crochets [ ]. C’est le type list en python. Pour en savoir plus sur les listes, on pourra consulter la page: google dev: listes

On accède à un élément d’une liste grace à sa position, appelée indice. Le premier élément a pour indice zero.

voyelles = ['e','i','o']
voyelles[0]
# affiche e
voyelles[1]
# affiche i
voyelle[2]
# affiche o
voyelles[-1]
# affiche o
voyelles
# affiche ['e','i','o']

2. Modifier les éléments d’une liste On ne peut modifier un élément d’une liste que si celui-ci existe. Par exemple, si l’on veut modifier l’élément “e” au rang zero de la liste voyelles par un “a”, il faut faire:

voyelles = ['e','i','o']
voyelles[0] = "a"
voyelles
# affiche ["a","i","o"]

Par contre, la liste ne contenant que 3 éléments, du rang 0 au rang 2, on ne peut pas ajouter l’élément “u” de la manière suivante:

voyelles[3] = "u"
# affiche
IndexError: list assignment index out of range

Mais alors, quelle est la bonne méthode pour ajouter un élément à une liste?

Pour ajouter un élément à une liste, il faut utiliser une méthode de liste: la méthode append

voyelles = ['e','i','o']
voyelles.append("u")
voyelles
# affiche ["e","i","o","u"]

L’écriture de la méthode append se fait avec une notation pointée: liste.append(x), où x est la valeur à ajouter à la fin de liste.

**On peut aussi utiliser l’opérateur +, mais il doit être suivi d’une autre Liste:

L = ['a','b','c']
L = L + ['d']
print(L)
# affiche ['a','b','c','d']
T = ['a','b','c']
T = T + 'd'
# affiche TypeError: can only concatenate list (not "str") to list

3. Une fonction utile aux listes: len La fonction len va retourner la longueur de la liste.

> L = ['a','b','c']
> len(L)
3

4. Autres méthodes de liste TRES utiles

Retirer un élément de liste: méthode pop

voyelles = ["e","i","o","u"]
voyelles.pop()
voyelles
# affiche ["e","i","o"]

Longueur d’une liste: fonction len

voyelles = ["e","i","o","u"]
len(voyelles)
# affiche 4 
# car la liste contient 4 éléments

5. Liste de listes Les éléments contenus peuvent aussi être une liste:

positions = [[0,0], [1,2], [2,4]]

C’est la représentation d’un tableau, qui sur un tableur peut être représenté sous la forme suivante:

Pour accéder au premier élément [0,0], on fait:

positions[0]
# retourne
[0,0]

Pour accéder au deuxieme élément [1,2], on fait:

positions[1]
# retourne
[1,2]

Et pour acceder au premier élément du 2e élément de positions, c’est à dire à la valeur 1, on fait:

positions[1][0]
# retourne
1

Cela permet d’afficher ou modifier la valeur 1.

Boucles bornées

1. Definition: Une boucle bornée est un système d’instructions qui permet de répéter un certain nombre de fois toute une série d’opérations.

La syntaxe d’une boucle bornée, en langage algorithmique peut s’écrire:

Pour i allant de 0 a n-1
Faire:
   instruction 1
   instruction 2
FinPour

En python, la syntaxe correspondante est:

for i in range(n):
  instruction 1
  instruction 2

• Remarques:

  • Le bloc d’instruction sera executé n fois. Celui-ci peut contenir une ou plusieurs instructions, du moment qu’elles sont bien positionnées dans le bloc.
  • En Python, le bloc est identifié par une indentation: un retrait par rapport au bord gauche, comprenant 2 espaces (ou 4).
  • Pour sortir du bloc, on élimine l’indentation (on revient sur le bord gauche)
  • La fonction range(n) renvoie la liste des entiers de 0 à n-1. C’est un principe général en informatique, on commence toujours à compter à partir de 0, et il faut donc s’arrêter à n-1 pour effectuer n fois la boucle.
  • Pour chaque itération, le variant i prend une nouvelle valeur de l’ensemble {0,1,2,... n-1}, et peut être utilisé dans le bloc d’instructions.
  • On peut choisir n’importe quel nom pour le variant, pas seulement i.

• Exemple

for c in range(3):
  print(c)
# affiche
0
1
2

Remarque: range(3) va créer une liste itérable constituée des valeurs 0, 1, 2. Ce sont les valeurs prises successivement par le variant c dans for c in range(3)

2. Parcourir les éléments d’une liste L avec range(len(L))

L = ["a","b","c"]
for i in range(len(L)):
  print(i, L[i])
# affiche
0 a
1 b
2 c

Remarque: Rappelez-vous que len(L) est une fonction qui retourne la longueur de la liste L. Si L contient 3 éléments, alors len(L) vaut 3.

3. Parcourir les éléments d’une liste L avec in L

L = ["a","b","c"]
for c in L:
  print(c)
# affiche
a
b
c

Ramarque: Cette fois-ci, le variant c prend successivement toutes les valeurs de la liste L.

Conclusion: Itérable et variant de boucle bornée

Les instructions for i in range(len(L)) et for c in L ont à peu près le même objectif: celui de parcourir TOUS les éléments de la liste L.

• Ce qui est COMMUN: c’est l’utilisation du mot clé IN, qui va créer ce que l’on appelle un itérable, c’est-à-dire une liste de valeurs qui seront proposées l’une après l’autre pour le variant de boucle.

• Ce qui est DIFFERENT: Dans le premier cas, on utilise la fonction range, qui créé un itérable entre 0 et la valeur mise en paramètre (valeur -1 pour être exact). Ce sont par exemple les indices de la liste L.

# exemple 1
for i in range(5):
  # instruction

La boucle va s’executer 5 fois. Mais à chaque fois, le variant i prend successivement l’une des valeurs dans [0,1,2,3,4]

# exemple 2
L = [0, 10, 20, 30]
for c in L:
  # instruction

L’instruction for c in L va, elle, créer un itérable constitué des valeurs de la liste L

Le nombre d’itération sera égal au nombre len(L), soit 4. Au cours des itérations, le variant c va prendre successivement chaque valeur de L, soit [0, 10, 20, 30]

Tracer un graphique y = f(x)

Pour tracer un graphique y=f(x), il faut disposer de 2 listes de mêmes dimensions x et y. Les coordonnées des points sont alors:

• (x[0],y[0]) pour le point M0
• (x[1],y[1]) pour le point M1
• …

On utilise la fonction plt.scatter (nuage de points) ou bien plt.plot (courbe) du module matplotlib.pyplot qui est importé à la premiere ligne du script de la manière suivante: import matplotlib.pyplot as plt

Les 2 listes sont positionnées entre parenthèses, dans l’ordre (liste des X, liste des Y). Ce sont les arguments de la fonction plt.scatter (ou de plt.plot).

import matplotlib.pyplot as plt
temps = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
T = [20, 20, 22, 24, 28, 32, 38, 44, 52, 60]
plt.clf()
plt.grid()
plt.scatter(temps,T)
plt.xlabel('temps(min)')
plt.ylabel('Temperature(°C)')
plt.show()

Liens

Cours

TP4 Listes

fonctions

Les fonctions

Fonction sans paramètre

1. Definition: Une fonction permet d’encapsuler un bloc d’instructions et de lui donnéer un nom:

def ma_fonction():
    # bloc de code ligne 1
    # bloc de code ligne 2

La fonction est déclarée après le mot-clé def.

Choisir un nom qui n’appartient pas à Python (aucune autre fonction porte ce nom dans le langage).

Le nom est suivi de parenthèses () et deux points :

Le bloc de code de la fonction est indenté sous la ligne def ma_fonction

Appel de fonction: On peut ensuite exécuter ce bloc en utilsant ce nom. On dit qu’on appelle cette fonction en écrivant son nom, suivi de parenthèses ().

ma_fonction()

Valeur de retour: Une fonction retourne en général une valeur. Après le mot-clé return

• Exemple 1 Dans ce script, on definit une fonction qui retourne Hi. Les lignes commençant par le symbole # sont des commentaires, et ne sont pas executées par Python. Elles sont optionnelles.

# definition de la fonction
def hello():
  return 'Hi'

# appel de la fonction
hello()
# 'Hi'

Fonction avec paramètre

Une fonction peut avoir un ou plusieurs paramètres qui permettent de transmettre des valeurs au bloc d’instructions. A l’interieur de la fonction, ces paramètres sont traités comme des variables, mais locales: Elles n’existent pas à l’exterieur du bloc.

Il y a alors une affectation: paramètre = argument

• Exemple 2 Dans ce script, on definit une fonction qui calcule le carré d’un nombre x.

# definition de la fonction
def carre(x):
  return x**2

# appel de la fonction
carre(5)
# retourne 25

Lors de la déclaration de la fonction, le seul paramètre attendu s’appelera x. Puis lors de l’appel de la fonction carre, l’argument choisi est 5. A l’interieur de la fonction, x vaut 5.

La valeur de retour est alors 25: l’intruction return x**2 évalue 5**2, soit 25, avant de retourner la valeur.

Observez comme la fonction Python avec paramètre ressemble à la déclaration d’une fonction en mathématiques:

# en math
f(x) = 10 * x + 20

On peut calculer f(x) pour toute valeur de x en remplaçant x dans $10\times x + 20$ par sa valeur. Par exemple, $f(1) = 10\times 1 + 20 = 30$

# en python
def f(x):
  return 10 * x + 20

En python, on appelle cette fonction avec la valeur $x=1$ en écrivant:

f(1)
# retourne 30

Le return correspond au signe = en langage mathématique.

Plusieurs paramètres

Lors de l’appel de la fonction, le ou les arguments passés doivent correspondre aus paramètres attendus. Ils doivent être placés dans l’ordre.

• Exemple 3: fonction qui calcule la surface d’un rectangle lorsque l’on divise chacun de ses côtés par un même coefficient c. On aura besoin de la longueur de ses côtés x et y (les 2 premiers paramètres de la fonction). Mais aussi de la valeur c:

# definition de la fonction
def calcul_surface(x,y,c):
  S = (x/c) * (y/c)
  return S

# appel de la fonction avec x=20 et y=30, c=1.5
# 20 sera place en premier argument
# 30 sera place en 2e argument
# 1.5 sera placé au niveau du 3e argument

calcul_surface(20,30,1.5)
# retourne 266.667

Importer des fonctions

On peut étendre les fonctions du langage en important des fonctions. Celle-ci sont natives, elles font partie du langage python, mais ne sont pas chargées au démarrage.

L’un des modules très utile est, par exemple, le module math. Celui-ci contient de nombreuses fonctions. Pour importer celle qui transforme le angles de degrés en radians, il faut ajouter la ligne suivante au debut du programme:

from math import radians

Puis, pour l’utiliser, et transformer 45° en radians, on écrira plus loin dans le programme:

angle = radians(45)
print(angle)

Placer un script dans une fonction

Le programme suivant comporte quelques lignes que l’on peut avoir à répéter. Imaginons un robot, chargé de laisser entrer les personnes dont l’age est supérieur ou egal à 18:

age = input('Quel age avez-vous? ')
age = int(age)
if age >18:
    print('Vous pouvez entrer')
else:
    print('Desole, ca ne va pas etre possible')

Il sera plus efficace de placer ces lignes dans une fonction.

Les règles pour écrire une fonction à partir de ce script sont les suivantes:

• les entrées et variables sont mises en paramètre: il s’agit de age
• Les print sont remplacés par return
• Il faut choisir un nom à la fonction, écrit après def

def entrer_en_discotheque(age):
  if age >=18:
      return 'Vous pouvez entrer'
  else:
      return 'Desole, ca ne va pas etre possible'

Lorsque vous executez le programme, … il ne se passe rien. Vous avez seulement chargé la fonction.

Il faut appeler la fonction pour que celle-ci soit executée, par exemple avec:

> entrer_en_discotheque(18)

Voici un exemple d’execution d’une fonction à partir du shell.

Son execution cesse lorsqu’elle arrive à l’instruction return. Le programme reprend alors son cours.

Liens

Cours

TP5a Fonctions, applications

TP5b fonctions utiles pour calculer

TP5b boucles et fonctions, traitements automatisés

lecture - ecriture fichier

au cours de ce TP, vous allez apprendre à:

• parcourir les caractères ou les éléments d’un fichier
• traiter les éléments un par un. Placer les éléments traités dans un fichier
• lire/ecrire dans un fichier

Manipuler des fichiers txt en python

Parcourir des séquences

Les séquences, comme le chaines str et les listes list python peuvent être parcourues avec une boucle for. On appelle parcourir le traitement des caractères ou des éléments l’un après l’autre.

Traiter les 2 exercices suivants pour démarrer ce TP.

ex 1: (a) Afficher une image à partir d’une Liste. Compléter le script:

L1 = [' ^___^','" o o "', '===X===','   "  ']
for l in L1:
    print(...

(b) Afficher une image à partir d’une liste de listes de caractères.

L2 = [[' ', '^', '_', '_', '_', '^'], ['"', ' ', 'o', ' ', 'o', ' ', '"'], ['=', '=', '=', 'X', '=', '=', '='], [' ', ' ', ' ', '"', ' ', ' ']]

for ligne in L2:
    s = ''
    for c in ligne:
        s += ...
    print(...

Remarquer que l’on utilise ici 2 boucles imbriquées, avec 2 variants: le variant ligne puis le variant c, qui contient chaque caractère de ligne.

ex 2: Quelle est l’image cachée dans cette matrice?

M = [['20', '2F', '5C', '5F', '2F', '5C', '20'],
     ['28', '20', '2E', '20', '2E', '20', '29'],
     ['3D', '5C', '5F', '76', '5F', '2F', '3D']]

Solution partielle:

for l in M:
    s = ''
    for r in l:
        s += ...
    print(...

Rappels:

• Conversion valeur hexa -> decimal: utiliser int(valeur,16)
• Conversion decimal -> ascii: utiliser chr

Lecture/ecriture dans un fichier

Introduction au TP

Les manipulations qui vont suivre demandent quelques pré-requis. Vous allez tester les instructions suivantes avant de réaliser le TP sur le déchiffrement.

Tester et comprendre chacun des exemples proposés ci-dessous.

Instruction de retour à la ligne \n:

Dans une chaine de caractères, pour faire un retour ligne, on utilise la combinaison de symboles \n.

Exemple:

>>> discours = "Je sais ta passion, et suis ravi de voir\nQue tous ses mouvements cèdent à ton devoir ;"
>>> print(discours)
Je sais ta passion, et suis ravi de voir
Que tous ses mouvements cèdent à ton devoir ;

Afficher le caractère \

\ est un caractère d’echappement. C’est à dire que lorsqu’il est placé dans une chaine de caractères, il n’est pas affiché mais interprété. Pour l’afficher, il faut alors mettre 2 fois le même symbole:

>>> print('\\')
\

Décalage de 1 rang pour un caractère “a” -> “b”

• On détermine le rang ascii du caractère: rang = ord("a")
• On definit un nouveau caractère avec décalage dans l’alphabet: chr

>>> rang = ord("a")
>>> car = chr(rang + 1)
>>> print(car)
b

Il s’agit d’un décalage de type monoalphabétique, permettant de chiffrer un texte pour le rendre secret. Ici, la clé de chiffrement est égale à 1. (1 seul rang de décalage).

Ecrire dans un fichier txt

• méthode 1: fonctions open et close. On créé un objet qui sert à désigner le fichier. Choisir un nom quelconque, pour l’exemple qui suit ce sera fileout. On utilise la fonction open avec pour paramètres, le nom du fichier (son chemin), suivi du caractère ‘w’ (pour write, ouverture du fichier en écriture).

On peut alors placer du texte dans le fichier à l’aide de la méthode write: fileout.write("...")

Penser alors à fermer le fichier de lecture: fileout.close()

fileout = open('exemple.txt','w')
fileout.write("Je sais ta passion, et suis ravi de voir\nQue tous ses mouvements cèdent à ton devoir ;")
fileout.close()

On peut alors vérifier le fichier et son contenu en parcourant le dossier avec l’explorateur windows.

• méthode 2: système d’instructions with + open

Le programme suivant est équivalent à celui de la méthode 1. Avec le mot clé with, les instructions de d’écriture dans le fichier sont mis dans un bloc, et donc indentées. A la sortie de ce bloc, le fichier est automatiquement fermé, ce qui fait l’economie de l’instruction close, et evite les oublis…

with open('exemple.txt','w') as fileout:
    fileout.write("Je sais ta passion, et suis ravi de voir\nQue tous ses mouvements cèdent à ton devoir ;")
   

Lire le contenu d’un fichier txt

• méthode 1: fonctions open et close. On créé un objet qui sert à importer le fichier. Choisir un nom quelconque, pour l’exemple qui suit ce sera file. On utilise la fonction open avec pour paramètres, le nom du fichier (son chemin), suivi du caractère ‘r’ (pour read, ouverture du fichier en lecture).

On peut alors récuperer le contenu textuel du fichier à l’aide de la méthode read. Dans l’exemple ci-dessous, on place le texte du fichier dans la variable texte.

On peut traiter cette variable comme on le souhaite, l’afficher en entier (print(texte)), ou parcourir et traiter les caractères les uns après les autres (for c in texte: ...)

Penser alors à fermer le fichier de lecture: file.close()

file = open('exemple.txt','r')
texte = file.read()
file.close()
print(texte)

• méthode 2: système d’instructions with + open

Le programme suivant est équivalent à celui de la méthode 1. Avec le mot clé with, les instructions de lecture du fichier sont mis dans un bloc, et donc indentées. A la sortie de ce bloc, le fichier est automatiquement fermé, ce qui fait l’economie de l’instruction close, et evite les oublis…

with open('exemple.txt', 'r') as file:
    texte = file.read()
print(texte)

TP Déchiffrement d’un texte

• Télécharger le fichier texte_chiffre.txt (faire un clic droit=> sauvegarder la cible du lien sous…)
• le placer dans le même dossier que votre fichier python.
• Dans le fichier texte_chiffre.txt, le texte est-il écrit en clair ou est-il chiffré?

Les chiffrements les plus anciens reposaient sur un simple décalage des caractères, comme vu dans les informations préliminaires. Par exemple, avec une clé de décalage égale à 1, le “a” devient un “b”, le “b” -> “c”, etc…

A partir des informations précédentes, écrire un script python qui devra:

1. Ouvrir le fichier ’texte_chiffre.txt’ en LECTURE
2. Lire le contenu et le placer dans une variable texte
3. Ouvrir un nouveau fichier en ECRITURE, que vous appelerez ’texte_dechiffre.txt’
4. Parcourir les caractères de texte, les uns après les autres: for c in texte:
5. Dans la boucle for: si le caractère c est différent de \ c’est à dire c != "\\"

• déterminer le rang ascii de c
• definir un nouveau caractère en essayant la clé de décalage égale à -1
• écrire ce nouveau caractère dans le fichier ’texte_dechiffre.txt’

6. Sinon, écrire \n dans le fichier ’texte_dechiffre.txt'
7. fermer le-s fichier-s si besoin.
8. Vérifier alors le contenu de votre fichier ’texte_dechiffre.txt’. Si celui-ci est toujours chiffré, recommencer avec une nouvelle clé (-2, puis -3, …)

Si vous avez terminé:

• Utiliser votre script pour créer une fonction que vous appelerez chiffre_dechiffre et qui aura 3 paramètres:
  • texte0 : le fichier texte d’origine
  • texte1 : le fichier texte de destination
  • decalage_ascii : la clé de décalage

Cette fonction devra créer un nouveau fichier texte1 à partir du texte du fichier texte0. Tous les caractères de texte1 seront définis à partir de ceux de texte0 en utilisant une clé de déclage: decalage_ascii

Exemple d’utilisation:

chiffre_dechiffre('texte_chiffre.txt','texte_dechiffre.txt',2)

Utilisez alors votre fonction pour réaliser le chiffrement d’un texte relativement long.

Suite

• Solution du TP lecture - ecriture python

• Projet transformer image -> ASCII: Lien

installation python

Python est-il déjà installé?

Verifier si Python est installé sur votre ordinateur:

Vous pouvez vérifier cela en ouvrant l’invite de commandes et en tapant:

python --version

• Windows: Télécharger le fichier d’installation depuis le site officiel de Python. Lancer l’executable et cocher “Add Python to PATH”. Puis cliquer sur Install now

• Linux: Python peut être installé et géré via un gestionnaire de paquets comme apt, yum.

• MacOS: utiliser le gestionnaire de paquets brew.

L’installation de Python via ces gestionnaires configure souvent automatiquement le PATH. Cependant, une fois l’installation reussie, la commande python --version peut renvoyer une erreur. Dans ce cas, il faudra ajouter Python à la variable d’environnement PATH: datascientist.fr

Installer un IDE python

Dans ce tutoriel, vous allez installer un editeur Python et suivre un premier tutoriel. Vous aurez besoin d’un ordinateur, PC, Linux ou mac.

Choisir l’un des IDE python ou distribution python proposés ci dessous:

• Thonny
• Pyzo
• Anaconda
• Winpython

Vous allez faire vos premiers pas dans l’apprentissage du langage.

Thonny

L’IDE le plus simple et complet à utiliser sera Thonny:

• Rendez vous à la page de telechargement
• Suivre les instructions d’installation

Anaconda

Installation de la distribution python ANACONDA. Systèmes Windows, Mac OSX, Linux

Page de telechargement sur le site anaconda.com

Il n’est pas nécessaire de fournir son email pour télécharger la distribution. (skip registration)

Winpython

Distribution uniquement pour le système Windows

Page de telechargement sur Sourceforge

Suivre un tuto python

courspython.com

fonctions et Turtle

Le module Turtle permet d’avoir un environnement simple muni d’une interface graphique.

La page suivante présente un aide-mémoire avec les principales instructions.

Il est conseillé d’avoir bien lu et traité les exemples des pages:

• TP boucles et fonctions
• Cours sur les fonctions

Premiers tracés

Script initial Ces exemples utilisent une boucle bornée pour répéter des consignes (for .. in range)

Utiliser Pyzo ou bien se rendre sur le notebook Turtle

Dans une nouvelle cellule: Copier-coller le script ci-dessous. Executer et analyser celui-ci:

import turtle

t = turtle.Turtle('turtle')
t.speed(8)
t.width(2)

largeur = 100

t.pendown()
t.color('red')
t.forward(largeur)
t.left(90)
t.forward(largeur)
t.left(90)
t.forward(largeur)
t.left(90)
t.forward(largeur)
t.left(90)
t.penup()
          
turtle.done()

Pour éviter les répétitions inutiles de script, utiliser une fonction carre, qui prendra largeur en paramètre, et qui s’executera lorsque l’on écrira: carre(largeur)

import turtle

t = turtle.Turtle('turtle')
t.speed(8)
t.width(2)

def carre(largeur):
    t.pendown()
    t.color('red')
    t.forward(largeur)
    t.left(90)
    t.forward(largeur)
    t.left(90)
    t.forward(largeur)
    t.left(90)
    t.forward(largeur)
    t.left(90)
    t.penup()
          
largeur = int(input('entrer la largeur'))
carre(largeur)
turtle.done()

Un script Python devra suivre une certaine structure pour la position de l’import des modules, déclaration de variables, des fonctions, et enfin le programme principal:

Le programme principal finira par turtle.done(), ce qui execute le tracé.

Modifier la fonction carre: utiliser une boucle bornée

Modifier pour avoir un script qui utilise le moins de lignes possibles pour cette fonction. (Rassembler les instructions t.left + t.forward dans une boucle)

Utiliser pour cela une boucle bornée for.

question 1: recopier le script de votre fonction

Une variante du programme: dessiner un rectangle

Definir et utiliser une fonction rectangle pour tracer un rectangle. On définira une nouvelle variable longueur qui sera utile comme paramètre de la fonction.

La valeur de cette variable sera introduite par une fonction input, comme dans le script précédent.

question 2: recopier le script de votre fonction

Dessiner des rectangles

Reproduire, à l’aide de votre fonction, le dessin ci-dessous. Celui-ci forme 3 rectangles colorés de dimension $80x100$.

question 3: recopier le script de votre programme (ne pas préciser les import et les definitions de fonctions)

Utiliser un variant de boucle

On utilisera maintenant la valeur de i dans l’instruction for i in range(N):

Pour dessiner la figure suivante, on utilisera une boucle bornée, qui répète plusieurs fois le bloc de code:

• calculer la valeur de x
• dessiner un carré de largeur x
• lever le stylo
• avancer jusqu’à la prochaine position.

La valeur du paramètre x, dans la fonction carre(x), dependra du variant i.

Ecrire un programme qui réalise ce dessin, à partir d’une fonction mathématique $x = a.i + b$

question 4: recopier le script de votre programme.

Dessiner des spirales

Avec des carrés emboités

Dans un carré de côté 100, on trace un carré dont les sommets sont situés au tiers des côtés du carré initial, et on répète indéfiniment l’opération.

On utilisera une boucle non bornée while avec le variant largeur. La condition d’execution pourrait être par exemple, largeur>20:

while largeur > 20:
	# instructions

A chaque itération:

• dessiner un carré avec la fonction carre et le paramètre largeur.
• avancer de $1/3 \times largeur$
• tourner de 26.565 degrés
• reduire la largeur d’un facteur 0.745: largeur = largeur * 0.745

question 5: recopier le script de votre programme principal

Avec des segments

Ecrire une fonction spirale qui devra reproduire une figure sur le modèle de la suivante:

• La fonction utilisera un paramètres: la longueur du segment initial
• le nombre d’itérations N voulues

Dans la fonction spirale: utiliser une boucle (for ou while) pour executer un certain nombre de traits.

question 6: recopier le script de votre fonction

Liens

• Editeur en ligne: https://pythonandturtle.com/turtle

Travaux pratiques

Travaux pratiques et mini-projets

Types

• types simples

  int, float, str, methodes de chaines string, slice
• types construits

  listes, tuples, dictionnaires, méthodes
• tables de données

  listes de listes, tri avec clé (lambda), conversion en dictionnaires, import de fichiers csv
• dataframe

  module pandas, dataframe