# data[].attributes.attachment_link.description
Repl.it is a simple yet powerful online IDE, Editor, Compiler, Interpreter, and REPL.

# data[].attributes.attachment_link.title
Visualize Python, Java, JavaScript, C, C++, Ruby code execution

# data[].attributes.attachment_link.readable_text
Tous les programmes de la première leçon ont été exécutés séquentiellement, ligne après ligne. Aucune ligne n'a pu être ignorée.

Considérons le problème suivant: pour l'entier X, détermine sa valeur absolue. Si X> 0 alors le programme devrait imprimer la valeur X, sinon il devrait imprimer -X. Ce comportement ne peut pas être atteint en utilisant le programme séquentiel. Le programme doit sélectionner conditionnellement l'étape suivante. C'est là que les conditions aident:

x = int(input())
if x > 0:
    print(x)
else:
    print(-x)

Ce programme utilise une instruction conditionnelle if . Après le if on met une condition (x > 0) suivie d'un deux-points. Après cela nous mettons un bloc d'instructions qui ne sera exécuté que si la condition est vraie (c'est-à-dire évalue à True ). Ce bloc peut être suivi par le mot else , deux-points et un autre bloc d'instructions qui ne seront exécutées que si la condition est fausse (c'est-à-dire évaluée à False ). C'est le cas ci-dessus, la condition est fausse, donc le bloc 'else' est exécuté. Chaque bloc doit être indenté en utilisant des espaces.

Pour résumer, l'instruction conditionnelle dans Python a la syntaxe suivante:

ifcondition : true-block several instructions that are executed if the condition evaluates to True else: false-block several instructions that are executed if the condition evaluates to False

Le mot-clé else avec le bloc 'false' peut être omis dans le cas où rien ne devrait être fait si la condition est fausse. Par exemple, nous pouvons remplacer la variable x par sa valeur absolue comme ceci:

x = int(input())
if x < 0:
    x = -x
print(x)

Dans cet exemple, la variable x est affectée à -x seulement si x < 0 . En revanche, l'instruction print(x) est exécutée à chaque fois, car elle n'est pas indentée, elle n'appartient donc pas au bloc "true".

L'indentation est un moyen général en Python de séparer des blocs de code. Toutes les instructions d'un même bloc doivent être indentées de la même manière, c'est-à-dire qu'elles doivent avoir le même nombre d'espaces au début de la ligne. Il est recommandé d'utiliser 4 espaces pour l'indentation.

L'indentation est ce qui différencie Python de la plupart des autres langages, dans lesquels les accolades { et } sont utilisées pour former les blocs.

En passant, il existe une fonction intégrée pour une valeur absolue en Python:

x = int(input())
print(abs(x))

Toute instruction Python peut être placée dans des blocs 'true' et 'false', y compris une autre instruction conditionnelle. De cette façon, nous obtenons des conditions imbriquées. Les blocs de conditions internes sont indentés en utilisant deux fois plus d'espaces (par exemple 8 espaces). Voyons voir un exemple. Compte tenu des coordonnées du point sur l'avion, imprimez son quadrant.

x = int(input())
y = int(input())
if x > 0:
    if y > 0:
        # x est supérieur à 0, y est supérieur à 0
        print("Quadrant I")
    else:
        # x est supérieur à 0, y est inférieur ou égal à 0
        print("Quadrant IV")
else:
    if y > 0:
        # x est inférieur ou égal à 0, y est supérieur à 0
        print("Quadrant II")
    else:
        # x est inférieur ou égal à 0, y est inférieur ou égal à 0
        print("Quadrant III")

Dans cet exemple, nous utilisons les commentaires: le texte explicatif qui n'a aucun effet sur l'exécution du programme. Ce texte commence par le hash # et dure jusqu'à la fin de la ligne.

Habituellement la condition après if a un ou plusieurs des opérateurs suivants:

Par exemple, la condition x * x < 1000 signifie "la valeur de l'expression x * x est inférieure à 1000", et la condition 2 * x != y signifie "la valeur doublée de la variable x n'est pas égale à la valeur de la variable y ".

Les opérateurs de comparaison en Python peuvent être regroupés comme suit: a == b == c ou x <= y >= 10 . C'est une chose rare parmi les langages de programmation.

Lorsque nous additionnons deux objets entiers en utilisant l'opérateur + , comme 2 + 5 , nous obtenons un nouvel objet: 7 . De même, lorsque nous comparons deux entiers en utilisant l'opérateur < , comme 2 < 5 , nous obtenons un nouvel objet: True .

print(2 < 5)
print(2 > 5)

Les objets True et False ont un type spécial appelé bool . Comme chaque nom de type peut être utilisé pour convertir des objets dans ce type, voyons ce que cette distribution donne pour les nombres:

print(bool(-10))    # Vrai
print(bool(0))      # Faux - zéro est le seul faux nombre
print(bool(10))     # Vrai

print(bool(''))     # False - la chaîne vide est la seule fausse chaîne
print(bool('abc'))  # Vrai

Parfois, vous devez vérifier plusieurs conditions à la fois. Par exemple, vous pouvez vérifier si un nombre n est divisible par 2 en utilisant la condition n % 2 == 0 ( n donne un reste 0 en divisant par 2 ). Si vous avez besoin de vérifier que deux nombres n et m sont divisibles tous les deux par 2, vous devez vérifier n % 2 == 0 et m % 2 == 0 . Pour ce faire, vous les rejoignez en utilisant un opérateur and (AND logique): n % 2 == 0 and m % 2 == 0 .

Python a logique ET, OR logique et négation.

Opérateur and est un opérateur binaire qui est évalué à True si et seulement si son côté gauche et son côté droit sont tous deux True .

Opérateur or est un opérateur binaire qui évalue à True si au moins un de ses côtés est True .

L'opérateur not une négation unaire, il est suivi d'une certaine valeur. Il est évalué à True si cette valeur est False et vice versa.

Vérifions qu'au moins l'un des deux nombres se termine par 0:

a = int(input())
b = int(input())
if a % 10 == 0 or b % 10 == 0:
    print('YES')
else:
    print('NO')

Vérifions que le nombre a est positif et le nombre b est non négatif:

if a > 0 and not (b < 0):

Si vous avez plus de deux options à différencier à l'aide de l'opérateur conditionnel, vous pouvez utiliser l'instruction if... elif... else .

Montrons comment cela fonctionne en réécrivant l'exemple avec le point (x, y) sur le plan et les quadrants d'en haut:

x = int(input())
y = int(input())
if x > 0 and y > 0:
    print("Quadrant I")
elif x > 0 and y < 0:
    print("Quadrant IV")
elif y > 0:
    print("Quadrant II")
else:
    print("Quadrant III")

Dans ce cas, les conditions dans if et elif sont vérifiées l'une après l'autre jusqu'à ce que la première condition vraie soit trouvée. Alors seulement le vrai-bloc pour cette condition est exécuté. Si toutes les conditions sont fausses, le bloc 'else' est en cours d'exécution s'il est présent.

# data[].attributes.attachment_link.description
Tous les programmes de la première leçon ont été exécutés séquentiellement, ligne après ligne. Aucune ligne n'a pu être ignorée. Considérons le problème suivant: pour l'entier X, détermine sa valeur absolue. Si X> 0 alors le programme devrait imprimer la valeur X, sinon il devrait imprimer -X.

# data[].attributes.attachment_link.readable_text
Integer and float numbers - Learn Python 3 - Snakify

Nous connaissons déjà les opérateurs suivants qui peuvent être appliqués aux nombres: + , - , * et ** . L'opérateur de division / pour les nombres entiers donne un nombre réel à virgule flottante (un objet de type float ). L'exponentiation ** renvoie également un flottant lorsque la puissance est négative:

print(17 / 3)  # donne 5.66666666667
print(2 ** 4)  # donne 16
print(2 ** -2) # donne 0,25

Il existe une opération spéciale pour la division entière où le reste est ignoré: // . L'opération qui donne le reste d'une telle division ressemble à % . Les deux opérations donnent toujours un objet de type int .

print(17 / 3)   # donne 5.66666666667
print(17 // 3)  # donne 5
print(17 % 3)   # donne 2

Lorsque nous lisons une valeur entière, nous lisons une ligne avec input() , puis nous transtypons une chaîne en entier en utilisant int() . Lorsque nous lisons un nombre à virgule flottante, nous avons besoin de lancer la chaîne pour flotter en utilisant float() :

x = float(input())
print(x)

Les flotteurs de très grande ou très petite valeur absolue peuvent être écrits en utilisant une notation scientifique. Par exemple, la distance entre la Terre et le Soleil est de 1.496 · 10 ¹¹ ou 1.496e11 en Python. La masse d'une molécule de l'eau est de 2,99 · 10 ⁻²³ , ou 2.99e-23 en Python.

On peut lancer des objets flottants dans des objets int en supprimant la partie fraction en utilisant la fonction int() . Cette fonction démontre ce que l'on appelle arrondi vers un comportement nul :

print(int(1.3))   # donne 1
print(int(1.7))   # donne 1
print(int(-1.3))  # donne -1
print(int(-1.7))  # donne -1

Il y a aussi une fonction round() qui effectue l'arrondi habituel:

print(round(1.3))   # donne 1
print(round(1.7))   # donne 2
print(round(-1.3))  # donne -1
print(round(-1.7))  # donne -2

Les nombres réels à virgule flottante ne peuvent pas être représentés avec une précision exacte en raison des limitations matérielles. Cela peut entraîner des effets gênants. Voir les documents Python pour les détails.

print(0.1 + 0.2)  # donne 0.30000000000000004

Python a beaucoup de fonctions auxiliaires pour les calculs avec des flottants. Ils peuvent être trouvés dans le module de math .

Pour utiliser ce module, nous devons d'abord l'importer en écrivant l'instruction suivante au début du programme:

import math

Par exemple, si nous voulons trouver une valeur plafond pour x - le plus petit nombre entier non inférieur à x - nous appelons la fonction appropriée du module math: math.ceil(x) . La syntaxe pour appeler des fonctions à partir de modules est toujours la même: module_name.function_name(argument_1, argument_2, ...)

import math

x = math.ceil(4.2)
print(x)
print(math.ceil(1 + 3.8))

Il existe une autre façon d'utiliser les fonctions des modules: importer les fonctions spécifiques en les nommant:

from math import ceil

x = 7 / 2
y = ceil(x)
print(y)

Certaines des fonctions traitant des nombres - int() , round() et abs() (valeur absolue aka module) - sont intégrées et ne nécessitent aucune importation.

Toutes les fonctions de tout module Python standard sont documentées sur le site officiel de Python. Voici la description du module de mathématiques . La description de certaines fonctions est donnée:

Maintainer: Vitaly Pavlenko ([email protected] )
Credits to: Denis Kirienko, Daria Kolodzey, Alex Garkoosha, Vlad Sterzhanov, Andrey Tkachev, Tamerlan Tabolov, Anthony Baryshnikov, Denis Kalinochkin, Vanya Klimenko, Vladimir Solomatin, Vladimir Gurovic, Philip Guo
🐍 Support us 🐍
Terms and Conditions
Privacy Policy
© 2012-2018

# data[].attributes.attachment_link.description
Integer and float numbers - Learn Python 3 - Snakify Nous connaissons déjà les opérateurs suivants qui peuvent être appliqués aux nombres: + , - , * et ** . L'opérateur de division / pour les nombres entiers donne un nombre réel à virgule flottante (un objet de type float ).

# data[].attributes.attachment_link.readable_text
Blockly Basics

The Blockly library adds an editor to your app that represents coding concepts as interlocking blocks. Blockly generates simple, syntactically-correct code from the blocks in the editor, which your app can use to run games, control robots, or do anything else your imagination can concieve.

The Blockly library adds an editor to your app that represents coding concepts as interlocking blocks. It outputs syntactically correct code in the programming language of your choice. Custom blocks may be created to connect to your own application.

Blockly is being used by hundreds of projects, most of them educational:

Blockly for Web

Blockly in a browser allows web pages to include a visual code editor for any of Blockly's five supported programming languages, or your own. In Blockly Games, pictured here, users can solve a maze using Blockly's editor on the right.

Blockly is...

Pure JavaScript library.

100% client side. No server side dependencies.

Compatible with all major browsers: Chrome, Firefox, Safari, Opera, and IE.

Highly customizable and extensible.

Blockly User Summit 2021

The virtual Blockly User Summit took place April 28-29, 2021.

We had around 80 members of the Blockly community attend with 16 tech talks on Blockly and its applications.

All of the summit talks are available on YouTube.

# data[].attributes.attachment_link.description
A JavaScript library for building visual programming editors.

# data[].attributes.attachment_link.readable_text
Dans les leçons précédentes, nous avons traité des programmes séquentiels et des conditions. Souvent, le programme doit répéter un bloc plusieurs fois. C'est là que les boucles sont utiles. Il existe for et while les opérateurs de boucle en Python, dans cette leçon , nous couvrons for .

for boucle itère sur n'importe quelle séquence. Par exemple, une chaîne en Python est une séquence de ses caractères, afin que nous puissions itérer les utiliser for :

for character in 'hello':
    print(character)

Un autre cas d'utilisation pour une boucle for est d'itérer une variable entière dans l'ordre croissant ou décroissant. Une telle séquence d'entier peut être créée en utilisant la range(min_value, max_value) fonctions range(min_value, max_value) :

for i in range(5, 8):
    print(i, i ** 2)
print('end of loop')
# 5 25
# 6 36
# 7 49
# fin de boucle

La range(min_value, max_value) fonctions range(min_value, max_value) génère une séquence avec les nombres min_value , min_value + 1 , ..., max_value - 1 . Le dernier numéro n'est pas inclus.

Il y a une forme réduite de range () - range(max_value) , auquel cas min_value est implicitement mis à zéro:

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

De cette façon, nous pouvons répéter une action plusieurs fois:

for i in range(2 ** 2):
    print('Hello, world!')

Même comme avec if-else, le retrait est ce qui indique des instructions sont contrôlées par for et qui ne sont pas.

Range () peut définir une séquence vide, comme range(-5) ou range(7, 3) . Dans ce cas le for-block ne sera pas exécuté:

for i in range(-5):
    print('Hello, world!')

Prenons un exemple plus complexe et additionnons les entiers de 1 à n inclusivement.

result = 0
n = 5
for i in range(1, n + 1):
    result += i
    # ce ^^ est le raccourci pour
    # résultat = résultat + i
print(result)

Faites attention à ce que la valeur maximale dans range () soit n + 1 pour rendre i égal à n sur la dernière étape.

Pour itérer sur une séquence décroissante, on peut utiliser une forme étendue de range () avec trois arguments - range(start_value, end_value, step) . Lorsqu'elle est omise, l'étape est implicitement égale à 1. Cependant, elle peut être n'importe quelle valeur non nulle. La boucle inclut toujours start_value et exclut end_value pendant l'itération:

for i in range(10, 0, -2):
    print(i)
# dix
# 8
# 6
# 4
# 2

Par défaut, la fonction print() imprime tous ses arguments en les séparant par un espace et met un symbole de retour à la ligne après lui. Ce comportement peut être modifié à l'aide des arguments de mot-clé sep (séparateur) et de end .

print(1, 2, 3)
print(4, 5, 6)
print(1, 2, 3, sep=', ', end='. ')
print(4, 5, 6, sep=', ', end='. ')
print()
print(1, 2, 3, sep='', end=' -- ')
print(4, 5, 6, sep=' * ', end='.')

# data[].attributes.attachment_link.description
Dans les leçons précédentes, nous avons traité des programmes séquentiels et des conditions. Souvent, le programme doit répéter un bloc plusieurs fois. C'est là que les boucles sont utiles. Il existe for et while les opérateurs de boucle en Python, dans cette leçon , nous couvrons for .

# data[].attributes.attachment_link.readable_text
Chaque programme est finalement un processeur de données, nous devrions donc savoir comment entrer et sortir des données à l'intérieur. Il existe une fonction, print() , pour générer des données à partir de n'importe quel programme Python. Pour l'utiliser, transmettez une liste d'arguments séparés par des virgules que vous souhaitez imprimer dans la fonction print() . Voyons voir un exemple. Appuyez sur "Exécuter" puis "Suivant" pour voir comment le programme est exécuté ligne par ligne:

print(5 + 10)
print(3 * 7, (17 - 2) * 8)
print(2 ** 16)  # deux étoiles sont utilisées pour l&#39;exponentiation (2 à la puissance de 16)
print(37 / 3)  # barre oblique unique est une division
print(37 // 3)  # double barre oblique est une division entière
        # il renvoie seulement le quotient de la division (c&#39;est-à-dire pas de reste)
print(37 % 3)  # signe de pourcentage est un opérateur de module
        # il donne le reste de la valeur de gauche divisé par la bonne valeur

Pour entrer des données dans un programme, nous utilisons input() . Cette fonction lit une seule ligne de texte, sous la forme d'une chaîne.

Voici un programme qui lit le nom de l'utilisateur et les accueille:

print('What is your name?')
name = input()  # lire une seule ligne et la stocker dans la variable &quot;nom&quot;
print('Hi ' + name + '!')

Essayons d'écrire un programme qui entre deux nombres et imprime leur somme. Nous lisons les deux nombres et les stockons dans les variables a et b utilisant l'opérateur d'affectation = . Sur le côté gauche d'un opérateur d'affectation, nous mettons le nom de la variable. Le nom peut être une chaîne de caractères latins ( AZ , az , 0-9 , _ ) mais doit commencer par une lettre de la plage AZ ou az . Sur le côté droit d'un opérateur d'affectation, nous mettons toute expression que Python peut évaluer. Le nom commence à pointer sur le résultat de l'évaluation. Lisez cet exemple, lancez-le et regardez la sortie:

a = input()
b = input()
s = a + b
print(s)

Après avoir exécuté l'exemple, nous pouvons voir qu'il imprime 57 . Comme on nous l'a appris à l'école, 5 + 7 donne 12 . Donc, le programme est mauvais, et il est important de comprendre pourquoi. La chose est, dans la troisième ligne s = a + b Python a "sommé" deux chaînes, plutôt que deux nombres. La somme de deux chaînes en Python fonctionne comme suit: elles sont simplement collées l'une après l'autre. C'est aussi parfois appelé "concaténation de chaînes".

Voyez-vous dans l'inspecteur de variables, sur le côté droit, que les valeurs liées aux variables a et b sont entourées de guillemets? Cela signifie que les valeurs sont des chaînes, pas des nombres. Les chaînes et les nombres sont représentés différemment dans Python.

Toutes les valeurs de Python sont appelées "objets". Chaque objet a un certain type. Le nombre 2 correspond à un objet "numéro 2" de type "int" (c'est-à-dire un nombre entier). La chaîne 'hello' correspond à un objet "string 'hello'" de type "str". Chaque nombre à virgule flottante est représenté comme un objet de type "float". Le type d'un objet spécifie le type d'opérations qui peuvent lui être appliquées. Par exemple, si les deux variables "first" et "second" pointent vers les objets de type int , Python peut les multiplier. Cependant, s'ils pointent vers les objets de type str , Python ne peut pas faire cela:

first = 5
second = 7
print(first * second)

# vous pouvez utiliser des guillemets simples ou doubles pour définir une chaîne
first = '5'
second = "7"
print(first * second)

Pour convertir (convertir) la chaîne de chiffres en un nombre entier, nous pouvons utiliser la fonction int() . Par exemple, int('23') donne un objet int avec la valeur 23 .

Étant donné les informations ci-dessus, nous pouvons maintenant corriger la sortie incorrecte et afficher la somme des deux nombres correctement:

a = int(input())
b = int(input())
s = a + b
print(s)

# data[].attributes.attachment_link.description
Chaque programme est finalement un processeur de données, nous devrions donc savoir comment entrer et sortir des données à l'intérieur. Il existe une fonction, print() , pour générer des données à partir de n'importe quel programme Python. Pour l'utiliser, transmettez une liste d'arguments séparés par des virgules que vous souhaitez imprimer dans la fonction print() .

# data[].attributes.attachment_link.readable_text
while loop répète la séquence d'actions plusieurs fois jusqu'à ce que certaines conditions aient la valeur False . La condition est donnée avant le corps de la boucle et est vérifiée avant chaque exécution du corps de la boucle. En règle générale, l' while boucle est utilisée quand il est impossible de déterminer le nombre exact d'itérations de la boucle à l' avance.

La syntaxe de la while boucle dans le cas le plus simple ressemble à ceci:

while some condition:
    a block of statements

Python vérifie d'abord la condition. Si elle est fausse, la boucle est terminée et le contrôle est passé à l'instruction suivante après while corps de la boucle. Si la condition est True, le corps de la boucle est exécuté, puis la condition est vérifiée à nouveau. Cela continue alors que la condition est vraie. Une fois que la condition devient False, la boucle se termine et le contrôle est passé à l'instruction suivante après la boucle.

Par exemple, le fragment de programme suivant imprime les carrés de tous les entiers de 1 à 10. Ici, on peut remplacer la boucle "while" par la boucle for ... in range(...) :

i = 1
while i <= 10:
    print(i ** 2)
    i += 1

Dans cet exemple, la variable i à l'intérieur de la boucle itère de 1 à 10. Une telle variable dont la valeur change à chaque nouvelle itération de boucle s'appelle un compteur. Notez qu'après avoir exécuté ce fragment, la valeur de la variable i est définie et est égale à 11 , car lorsque i == 11 la condition i <= 10 est fausse pour la première fois.

Voici un autre exemple d'utilisation de la while la boucle pour déterminer le nombre de chiffres d'un nombre entier n :

n = int(input())
length = 0
while n > 0:
    n //= 10  # c&#39;est équivalent à n = n // 10
    length += 1
print(length)  # 4

À chaque itération, nous coupons le dernier chiffre du nombre en utilisant la division entière par 10 ( n //= 10 ). Dans la length variable length nous comptons combien de fois nous l'avons fait.

En Python, il existe un autre moyen plus simple de résoudre ce problème: length = len(str(i)) .

On peut écrire une instruction else: après un corps de boucle qui est exécuté une fois après la fin de la boucle:

i = 1
while i <= 10:
    print(i)
    i += 1
else:
    print('Loop ended, i =', i)

Au premier coup d'œil, cette affirmation ne semble pas avoir de sens, car le corps else: statement peut juste être placé après la fin de la boucle. L'instruction "else" après une boucle n'a de sens que lorsqu'elle est utilisée en combinaison avec la break instruction. Si pendant l'exécution de la boucle, l'interpréteur Python rencontre une break , il arrête immédiatement l'exécution de la boucle et en sort. Dans ce cas, la branche else: n'est pas exécutée. Ainsi, break est utilisé pour annuler l'exécution de la boucle au milieu de toute itération.

Voici un exemple de Black Jack: un programme qui lit les nombres et les somme jusqu'à ce que le total soit supérieur ou égal à 21. La séquence d'entrée se termine par 0 pour que le programme puisse s'arrêter même si la somme totale de tous les nombres est moins de 21.

Voyons comment il se comporte sur les différentes entrées.

Version 1. La boucle est quittée normalement après vérification de la condition, de sorte que la branche "else" est exécutée.

total_sum = 0
a = int(input())
while a != 0:
    total_sum += a
    if total_sum >= 21:
        print('Total sum is', total_sum)
        break
    a = int(input())
else:
    print('Total sum is less than 21 and is equal to', total_sum, '.')

Version 2. La boucle est interrompue par break , donc la branche "else" est ignorée.

total_sum = 0
a = int(input())
while a != 0:
    total_sum += a
    if total_sum >= 21:
        print('Total sum is', total_sum)
        break
    a = int(input())
else:
    print('Total sum is less than 21 and is equal to', total_sum, '.')

La branche "Else" peut également être utilisée avec la boucle "for". Regardons l'exemple quand un programme lit 5 entiers mais s'arrête juste quand le premier entier négatif est rencontré.

Version 1. La boucle est sortie normalement, donc la branche "else" est exécutée.

for i in range(5):
    a = int(input())
    if a < 0:
        print('Met a negative number', a)
        break
else:
    print('No negative numbers met')

Version 2. La boucle est annulée, donc la branche "else" n'est pas exécutée.

for i in range(5):
    a = int(input())
    if a < 0:
        print('Met a negative number', a)
        break
else:
    print('No negative numbers met')

Une autre instruction utilisée pour contrôler l'exécution de la boucle est continue . Si interpréteur Python rencontre continue quelque part au milieu de l'itération de la boucle, il saute toutes les instructions restantes et procède à l'itération suivante.

for num in range(2, 10):
    if num % 2 == 0:
        print("Found an even number", num)
        continue
    print("Found a number", num)

Si la break et continue sont placés à l'intérieur de plusieurs boucles imbriquées, elles n'affectent que l'exécution de la plus secrète. Regardons un exemple plutôt stupide pour le démontrer:

for i in range(3):
    for j in range(5):
        if j > i:
            # ne casse que le pour en ligne 2
            break
        print(i, j)

Les instructions break et continue sont découragées, si vous pouvez implémenter votre idée sans les utiliser. Voici un exemple typique d'une mauvaise utilisation de la break : ce code compte le nombre de chiffres dans un entier.

n = int(input())
length = 0
while True:
    length += 1
    n //= 10
    if n == 0:
        break
print('Length is', length)

Il est plus propre et plus facile à lire pour réécrire cette boucle avec une condition de boucle significative:

n = int(input())
length = 0
while n != 0:
    length += 1
    n //= 10
print('Length is', length)

En Python, il est possible qu'une seule instruction d'affectation modifie la valeur de plusieurs variables. Voyons voir:

L'effet démontré ci-dessus code peut être écrit comme:

La différence entre les deux versions est que l'assignation multiple change les valeurs de deux variables simultanément.

L'affectation multiple est utile lorsque vous devez échanger les valeurs de deux variables. Dans les langages de programmation plus anciens sans le support de l'assignation multiple, ceci peut être fait en utilisant la variable auxiliaire:

a = 1
b = 2
tmp = a
a = b
b = tmp
print(a, b)
# 2 1

En Python, le même échange peut être écrit en une ligne:

a = 1
b = 2
a, b = b, a
print(a, b)
# 2 1

Le côté gauche de "=" devrait avoir une liste de noms de variables séparés par des virgules. Le côté droit peut être n'importe quelle expression, séparée par des virgules. Les listes de gauche et de droite doivent être de même longueur.

# data[].attributes.attachment_link.description
while loop répète la séquence d'actions plusieurs fois jusqu'à ce que certaines conditions aient la valeur False . La condition est donnée avant le corps de la boucle et est vérifiée avant chaque exécution du corps de la boucle.

# data[].attributes.body
Algorithme avec Scratch

# data[].attributes.attachment_link.readable_text
Bonjour,

Tu rencontres un problème technique sur un exercice ?
Tu as remarqué un bug ?
C'est ici qu'il faut le signaler pour que nous puissions t'aider.

Merci d'adopter un langage poli. Sache que ton enseignant a aussi accès à tous les messages que tu nous envoies.

# data[].attributes.attachment_link.title
Séquences d'initiation à l'algorithmique basés sur Scratch - Kwyk

# data[].attributes.attachment_link.description
Tu rencontres un problème technique sur un exercice ?Tu as remarqué un bug ?C'est ici qu'il faut le signaler pour que nous puissions t'aider. Merci d'adopter un langage poli. Sache que ton enseignant a aussi accès à tous les messages que tu nous envoies.

# data[].attributes.attachment_link.readable_text
La présentation de cette page est inspirée par le livre de Gérard Swinnen " Apprendre à programmer avec Python 3 " disponible sous licence CC BY-NC-SA 2.0.

Lorsqu'une tâche doit être réalisée plusieurs fois par un programme avec seulement des paramètres différents, on peut l'isoler au sein d'une fonction. Cette approche est également intéressante si la personne qui définit la fonction est différente de celle qui l'utilise. Par exemple, nous avons déjà utilisé la fonction qui avait été définie par quelqu'un d'autre.
Syntaxe
La syntaxe Python pour la définition d'une fonction est la suivante :

Vous pouvez choisir n'importe quel nom pour la fonction que vous créez, à l'exception des mots-clés réservés du langage, et à la condition de n'utiliser aucun caractère spécial ou accentué (le caractère souligné " _ " est permis). Comme c'est le cas pour les noms de variables, on utilise par convention des minuscules, notamment au début du nom (les noms commençant par une majuscule seront réservés aux classes).
Corps de la fonction
Comme les instructions , et , l'instruction est une instruction composée. La ligne contenant cette instruction se termine obligatoirement par un deux-points , qui introduisent un bloc d'instructions qui est précisé grâce à l'indentation. Ce bloc d'instructions constitue le corps de la fonction.
Exemple
Affichage après exécution :

provoque l'affichage de :
Exemple
Affichage après exécution :
Exemple
Affichage après exécution :
Exemple
Affichage après exécution :

Variables locales, variables globales

Lorsqu'une fonction est appelée, Python réserve pour elle (dans la mémoire de l'ordinateur) un espace de noms. Cet espace de noms local à la fonction est à distinguer de l'espace de noms global où se trouvait les variables du programme principal. Dans l'espace de noms local, nous aurons des variables qui ne sont accessibles qu'au sein de la fonction. C'est par exemple le cas des variables , , et dans l'exemple précédent.

A chaque fois que nous définissons des variables à l'intérieur du corps d'une fonction, ces variables ne sont accessibles qu'à la fonction elle-même. On dit que ces variables sont des variables locales à la fonction. Une variable locale peut avoir le même nom qu'une variable de l'espace de noms global mais elle reste néanmoins indépendante.

Les contenus des variables locales sont stockés dans l'espace de noms local qui est inaccessible depuis l'extérieur de la fonction.

Les variables définies à l'extérieur d'une fonction sont des variables globales. Leur contenu est " visible " de l'intérieur d'une fonction, mais la fonction ne peut pas le modifier.
Exemple
Affichage après exécution :
Explications en vidéo
Affichage après exécution :

" Vraies " fonctions et procédures

Pour les puristes, les fonctions que nous avons décrites jusqu'à présent ne sont pas tout à fait des fonctions au sens strict, mais plus exactement des procédures. Une " vraie " fonction (au sens strict) doit en effet renvoyer une valeur lorsqu'elle se termine. Une " vraie " fonction peut s'utiliser à la droite du signe égale dans des expressions telles que y = sin(a). On comprend aisément que dans cette expression, la fonction sin() renvoie une valeur (le sinus de l'argument) qui est directement affectée à la variable y.

Voici un exemple extrêmement simple:

Valeurs par défaut pour les paramètres

Dans la définition d'une fonction, il est possible de définir un argument par défaut pour chacun des paramètres. On obtient ainsi une fonction qui peut être appelée avec une partie seulement des arguments attendus.
Exemples :
Lorsque l'on appelle cette fonction en ne lui fournissant que le premier argument, le second reçoit tout de même une valeur par défaut. Si l'on fournit les deux arguments, la valeur par défaut pour le deuxième est tout simplement ignorée.

Arguments avec étiquettes

Dans la plupart des langages de programmation, les arguments que l'on fournit lors de l'appel d'une fonction doivent être fournis exactement dans le même ordre que celui des paramètres qui leur correspondent dans la définition de la fonction.

Python autorise cependant une souplesse beaucoup plus grande. Si les paramètres annoncés dans la définition de la fonction ont reçu chacun une valeur par défaut, sous la forme déjà décrite ci-dessus, on peut faire appel à la fonction en fournissant les arguments correspondants dans n'importe quel ordre, à la condition de désigner nommément les paramètres correspondants.
Exemple :
Utilisation des fonctions dans un script

Pour cette première approche des fonctions, nous n'avons utilisé jusqu'ici que des fonctions dans des scripts et pas de programme principal dans le script. Veuillez donc essayer vous-même le petit programme ci-dessous, lequel calcule le volume d'une sphère a l'aide de la formule :

\[V = \frac{4}{3} \pi R^3\]
Exemple :
A bien y regarder, ce programme comporte deux parties :

les deux fonctions cube() et volume_sphere()

le corps principal du programme.

Dans le corps principal du programme, il y a un appel de la fonction volume_sphere().

A l'intérieur de la fonction volume_sphere(), il y a un appel de la fonction cube().

Notez bien que les deux parties du programme ont été disposées dans un certain ordre :

d'abord la définition des fonctions,

et ensuite le corps principal du programme.

Cette disposition est nécessaire, parce que l'interpréteur exécute les lignes d'instructions du programme l'une après l'autre, dans l'ordre où elles apparaissent dans le code source. Dans le script, la définition des fonctions doit donc précéder leur utilisation.

Pour vous en convaincre, intervertissez cet ordre (en plaçant par exemple le corps principal du programme au début), et prenez note du type de message d'erreur qui est affiché lorsque vous essayez d'exécuter le script ainsi modifié.

En fait, le corps principal d'un programme Python constitue lui-même une entité un peu particulière, qui est toujours reconnue dans le fonctionnement interne de l'interpréteur sous le nom réservé __main__ (le mot " main " signifie " principal ", en anglais. Il est encadré par des caractères " souligné " en double, pour éviter toute confusion avec d'autres symboles). L'exécution d'un script commence toujours avec la première instruction de cette entité __main__, où qu'elle puisse se trouver dans le listing. Les instructions qui suivent sont alors exécutées l'une après l'autre, dans l'ordre, jusqu'au premier appel de fonction. Un appel de fonction est comme un détour dans le flux de l'exécution : au lieu de passer à l'instruction suivante, l'interpréteur exécute la fonction appelée, puis revient au programme appelant pour continuer le travail interrompu. Pour que ce mécanisme puisse fonctionner, il faut que l'interpréteur ait pu lire la définition de la fonction avant l'entité __main__, et celle-ci sera donc placée en général à la fin du script.

Dans notre exemple, l'entité __main__ appelle une première fonction qui elle-même en appelle une deuxième. Cette situation est très fréquente en programmation. Si vous voulez comprendre correctement ce qui se passe dans un programme, vous devez donc apprendre à lire un script, non pas de la première à la dernière ligne, mais plutôt en suivant un cheminement analogue à ce qui se passe lors de l'exécution de ce script. Cela signifie concrètement que vous devrez souvent analyser un script en commençant par ses dernières lignes !

# data[].attributes.attachment_link.description
La présentation de cette page est inspirée par le livre de Gérard Swinnen " Apprendre à programmer avec Python 3 " disponible sous licence CC BY-NC-SA 2.0. Lorsqu'une tâche doit être réalisée plusieurs fois par un programme avec seulement des paramètres différents, on peut l'isoler au sein d'une fonction.