<< Exemple d'utilisation | PythonIndex | Les fonctions >>

Notions de base

1.  Le résumé de l'épisode précédent et l'aguiche

Ana je t'ai montré précedemment un certain nombre de chose que l'on pouvait faire avec notre serpent python. Comment écrire un programme et l'éxécuter, mais cela ne suffit pas il nous faut maintenant apprendre à parler la langue de cet animal et aussi parfois à nous méfier de ses réponses.

2.  Un peu de calcul

python sait donc calculer. On peut lui demander à l'aide d'un programme, mais aussi au niveau de la console :

 >>> 7 * 3.53
 24.709999999999997

Aie confiance ....
Ana réveille toi, ce résultat ne te semble t-il pas un peu bizarre ? Non tu ne vois pas ! Alors essaye cela :

 >>> 1/9 + 1/9 + 1/9 +1/9 +1/9 +1/9 +1/9 +1/9 +1/9
 1.0000000000000002

"Mais Conda c'est n'importe quoi ! Cela fait 1."

Eh oui, la représentation de certain nombre en machine n'est pas exacte cela génère des petites erreurs. Il faut faire attention à cela, mais rassure toi, cela ne devrait pas nous poser de problème. Tu l'a sans doute remarqué le . remplace notre , habituelle comme sur ta machine à calculer, c'est la notation anglo-saxonne. Les opérateurs sont notés également de la même façon :

Il y a autre dont il faut se méfier c'est l'ordre des opérateurs. Lorsqu'on écrit 2 + 3 * 5, quelle opération est faite en première ?

 >>> 100 * 50 - 50
 4950

python utilise la convention habituelle d'abord la multiplication puis l'addition. L'ordre dans lequel sont faîtes les opérations dépend d'une convention. SI on considère : les parenthèses, l'élévation à une puissance (exposant), la multiplication, la division, l'addition et la soustraction. Il suffit d'appliquer le mot magique PEMDAS.

• Les Parenthèses, elles sont les plus prioritaires. En cas de doute, n'hésite pas à en mettre.

 >>> 100 * (50 - 50)
 0

• Les Exposants ils sont évalués ensuite, avant les autres opérations.

 >>>  3**1+1
 4 
 >> 3*1**10 
 3

• Les Multiplications et les Divisions, qui ont la même priorité.
• Les Additions A et les Soustractions, qui ont la même priorité.
• On ajoute donc en plus une règle, si deux opérateurs ont la même priorité, l'évaluation est effectuée de la gauche vers la droite. Essaye de trouver le résultat de :

 >> 7 - 4 + 3**(2 * 0) + 1

et vérifie ensuite.

3.  Variables

Un ordinateur possède une mémoire pour stocker de l'information. Pour retrouver cette information afin de pouvoir l'utiliser (afficher, modifier, calculer ....), on donne un nom à l'emplacement où cela est stocké. La mémoire c'est un peu comme ton armoire Ana, il y a des boites sur lesquelles tu a écris par exemple cartes et dans lesquelles tu ranges les cartes postales que tu as reçus. La boite sert à stocker, elle a un contenu, et ce qu'il y écrit dessus à retrouver ce même contenu. Eh bien une variable elle a un nom, une valeur et un type. Tu as compris que la valeur c'est ce qui est stocké, pour le type je te vois venir c'est pas un pov'typ, cela fixe la nature de ce qui est stocké. Cela peut être un nombre entier, un nombre réel, une chaîne de caractère (un texte), une liste de nombres ... Je ne vais pas énumérer tout, ce serait trop long et je risque d'en oublier.

On indique à python que l'on va utiliser une variable en la déclarant et en l'initialisant. Initialiser une variable c'est lui donner une première valeur.

 >>> x = 0
 >>> x
 0

On a déclaré et initialisé x avec la valeur 0. Tu peux maintenant interroger python en lui demandant le type (la nature) de x.

 >>> type(x)
 <class 'int'>

x est donc de type int, c'est comme cela qu'il note les nombres entiers.

Je peux te proposer d'autres exemples avec une chaîne de caractère, pour changer

 >>> serpent = "Anaconda"
 >>> type(serpent)
 <class 'str'>
 >>> print(serpent)
 Anaconda
 >>>

Une chaîne de caractère se note soit entre guillemets "chaîne" ou entre apostrophes 'chaîne' et si jamais ta chaîne fait plus d'une ligne on utilise alors 3 apostrophes en début et 3 en fin.

 >>> grandeChaine = '''Une chaîne sur 1 ligne
 2 lignes,
 3 lignes.'''
 >>> print(grandeChaine)
 Une chaîne sur 1 ligne
 2 lignes,
 3 lignes.

3.1  Comment choisir le nom de tes variables

Le nom doit être explicite, il doit te parler, x c'est bien mais cela peut représenter n'importe quoi ! Il y a des règles pour donner un nom à une variable, ce sont les suivantes :

• Un nom de variable, on parle d'identificateur est une suite de lettres (a...z , A...Z) et de chiffres (0...9), qui doit toujours commencer par une lettre.
• Le caractère _ (souligné) est autorisé, les lettres accentuées sont autorisées si tu utilises python3, mais je te déconseille. De même attention avec le _ il y a des règles particulières quand il est au début ou à la fin.
• La casse (majuscule/minuscule) est importante. La variable MAJUSCULE ne'st pas la même que Majuscule. On privilégie les identificateurs pour les variables en lettres minuscules.
• Il existe des mots réservés qui sont utilisés par python et que tu ne peux pas utiliser pour donner un nom à tes variables.

3.2  Affectation

python est un langage impératif, cela veut dire que tu peux demander de modifier le contenu d'un emplacement en mémoire représenté par une variable. Cette opération de modification s'appelle l'affectation, et elle est représentée par le signe =.

 >> x = 7

 >> 7 = x # Interdit, on tente de modifier une constante !

Imaginons que tu veilles savoir quelle est la température extérieure aujourd'hui en degré Kelvin (K) et que le thermomètre de la maison mesure cette température en degré Celsius (°C). Tu sais que le zéro absolu (0 K) à pour valeur 273,15 °C, on va donc pouvoir le température d'aujourd'hui en Kelvin à l'aide de python :

 >>> zero_absolu = 273.15                        
 >>> temperature_c = 12                         # fait pas chaud aujourd'hui
 >>> temperature_k = zero_absolu + temperature_c
 >>> print(temperature_k)
 285.15

La variable zero_absolu a été créée, elle à un type flottant (<class 'float'>) permettant de représenter un nombre réel et de ce fait un certain nombre d'opérations sont possibles/autorisées comme l’additionner avec un nombre entier, ce que l'on fait sur la troisième ligne. Elle est initilisée à la constante flottante (au nombre réel) 273.15 .

temperature_k = zero_absolu + temperature_c crée une variable temperature_k dont la valeur initiale est le résultat du calcul de la somme de la valeur de la variable zero_absolu et temperature_c et le type est celui de la nature du résultat donc un flottant (<class 'float'>).

 >>> type(zero_absolu)
 <class 'float'>
 >>> type(temperature_c)
 <class 'int'>
 >>> type(temperature_k)
 <class 'float'>

Pour te montrer l'influence du type maintenant essaye, la petite séquence d'instructions suivante :

 >>> pere = "Conda"
 >>> fille = "Ana"
 >>> pere_et_fille = pere + fille
 >>> fille_et_pere = fille + pere
 >>> print(pere_et_fille, fille_et_pere)
 CondaAna AnaConda

Tu vois le + que l'on a mis, à cause du type des variables pere et fille n'est pas une addition mais une concaténation (mise bout à bout) de deux chaînes de caractère.

Il y a d'autres formes d'affectation mais il ne m'a pas semblé indispensable de les développer. On les évoquera éventuellement au fur et à mesure.

4.  Les instructions

Source : http://www.funnelinc.com/instructions Quand tu écris un programme tu cherches à ce que ton ordinateur effectue une série d'actions ou de traitements dans un certain ordre. La description de la suite des actions s'appelle un algorithme, cela ressemble aux recettes de cuisine, de ta mère. Pour écrire cet algorithme et pour qu'il soit compris par ton ordinateur tu utilise un langage, en l’occurrence python. Ce dernier utilise des instructions pour décrire les actions. Les instructions peuvent être conditionnelles ou répétitives (boucles).

Une dernière chose Ana, sauf mention explicite de ma part les instructions s'effectuent séquentiellement, c'est-à-dire les unes après les autres dans l'ordre où elles sont écrites. Il est possible de suivre différents chemins grâce aux instructions conditionnelles.

4.1  Ana des blocs et des blocs encore

Ca va Ana ? Non j'avais un peu peur. Bon alors continuons. Il existe des instructions simples, elles sont seules, il suffit de les réaliser pour effectuer le traitement, mais il existe également des instructions composées, elles sont constituées d'un ensemble d’instructions. En python cet ensemble d'instructions est regroupé dans un bloc qui délimite l'ensemble. Un bloc pour une instruction composée à toujours la même structure :

C'est donc l'indentation (le décalage par rapport à la marge) qui détermine un bloc. Trichons un peu, supposons que je t'ai déjà parlé de l'instruction conditionnelle if.

 >>> a = 0                # instruction simple
 >>> b = 10
 >>> if a !=0:          # en tête du bloc
	x = -b/a          # première instruction du bloc
        print("x =",  x)  # deuxième instruction du bloc
 else:
	print("Ana ! Depuis quand on divise par zéro ?")


 Ana ! Depuis quand on divise par zéro ?

Tu peux essayer avec a = 2 par exemple. Nous allons avoir l'occasion de voir cela de façon plus détaillée par la suite.

4.2  Les tests

Ce sont des instructions conditionnelles, si tu veux pouvoir commencer à écrire des programmes intéressants, il faut pouvoir faire des choix. Ces choix se font en fonction de conditions qui sont vraies ou fausses. Lorsque la condition sera vraie le programme fera quelque chose et lorsqu'elle sera fausse éventuellement rien ou autre chose.

Si la condition est vraie python effectue le bloc d'instructions et ensuite l'instruction suivante si elle existe. Si la condition est fausse python passe directement à l'instruction suivante si elle existe.

Cela est souvent traduit par "Si cela est vrai Alors je fais cela".

 >>>x = -6
 >>> if (x < 0):   # Les parenthèses ne sont pas obligatoire mais je préfère
	print ("x est négatif")

 x est négatif
 >>>
 >>> x = 0
 >>> if (x < 0):
	print ("x est négatif")


 >>>  

Parfois il est également nécessaire d'effectuer un traitement lorsque la condition est fausse. On parle alors de "Si alors sinon". Cela se traduit en python avec la structure d'instruction suivante :

Si la condition est vraie python effectue le bloc d'instructions et ensuite l'instruction suivante si elle existe. Si la condition est fausse python effectue l'autre bloc d'instructions et ensuite l'instruction suivante si elle existe.

 >>> x = 0
 >>> if (x < 0):
	print ("x est négatif")
 else:
	print("x est positif ou nul")


 x est positif ou nul
 >>> 

Il est bien évidemment possible de combiner des instructions if entre-elles.

 >>> x = 0
 >>> if (x < 0):
	print ("x est négatif")
 else:
	if (x == 0):
		print("x est nul")
	else:
		print("x est positif")


 x est nul
 >>> 

Il existe une forme condensée pour écrire cela :

 >>> x = 0
 if (x < 0):
	print ("x est négatif")
 elif(x == 0):
	print("x est nul")
 else:
	print("x est positif")
 x est nul
 >>>

Ana remarque bien le elif qui replace le else: if (x == 0): et également l'indentation.

Avant d'aller plus loin, je dois reconnaître que j'ai un peu triché. Je n'ai pas présenté les opérateurs de comparaison et pourtant j'en ai déjà utilisés.

Il y a également les opérateurs logiques. Mais avant il faut que je te parle d'un ensemble de deux valeurs, il s'agit de l'ensemble des booléens. Cet ensemble contient deux valeurs ce sont True et False. Le résultat d'une condition (expression conditionnelle) est soit True, soit False. Une branche des mathématiques appelée la logique travaille avec ces éléments et les booléens en sont les briques de base. On combine les booléens avec des connecteurs and or et la négation not. Pour savoir si x est compris entre 10 et 15, on peut écrire :

 >>> x = 11
 >>> if (x >=10 and x <=19):
	print("x est compris entre 10 et 15")

 x est compris entre 10 et 15

Quand nous aurons avancé je reviendrai aussi sur ces points, car python considère que tout ce qui n'est 0, '', [], (), {} et None est vrai enfin je veux dire True.

Ana, je te propose de terminer sur un exemple. Supposons que nous voulions écrire tous les deux un petit programme qui calcule les solutions d'une équation du second degré de la forme : {$ ax^2 + bx + c = 0$}, avec {$ x $} l'inconnue et {$ a\neq 0, b , c $} les coefficients. Dans l'ensemble des réels, une telle équation admet deux solutions, une solution ou pas de solution. On détermine cela à l'aide du discriminant noté {$ \Delta = b^2 - 4ac$}. Si

• {$ \Delta < 0$} il n'y a pas de solution dans les réels.
• {$ \Delta > 0$} il y a deux racines : {$ x_1 = \frac{-b - \sqrt{\Delta}}{2a} \quad \text{et}\quad x_2 = \frac{-b + \sqrt{\Delta}}{2a} $}.
• {$ \Delta = 0$} une racine double {$ x_1 = x_2 = \frac{-b}{2a} $}

Tu peux compléter en calculant la solution si elle existe, dans le cas d'une équation du premier degré.

4.3  Des boucles, il faut répéter

Les boucles servent à répéter plusieurs fois un même traitement. Ana maintenant tu vas m'écrire 8 fois à l'écran :

L'idée qui vient est d'écrire le programme suivant :

Imagine maintenant qu'il faille l'écrire 20 ou 30 fois. ^_^ C'est long fastidieux et pas très intéressant, heureusement qu'il existe le copier-coller. On va essayer de faire mieux.

Il existe deux sortes de boucles en python : les boucles while et les boucles for. Pour les premières les instructions sont répétés tant qu'une condition est vraie. Pour les secondes tant qu'il y a des éléments dans la séquence que l'on a fixée par avance.

Les boucles while

Cette boucle fonctionne de la façon suivante : tant que la condition est vraie le bloc d'instructions est effectué. Quand la condition est fausse on passe à l'instruction suivante. La condition est une expression booléenne True ou False. Si l'on revient à nos pythons de la phytonisse. On va fixer le nombre_de_fois où l'on fait le traitement, et à chaque fois qu'on le fait on va diminuer de 1 ce nombre. La boucle devra alors s’arrêter lorsque notre variable nombre_de_fois vaudra 0.

"Mais Conda cela ne fait pas ce que tu as demandé". Tu as raison Ana, il manque le nombre de python. On va le rajouter :

Tu te rappelles on avait déjà utilisé la tortue, on peut recommencer pour faire une jolie rosace, par exemple.

Les boucles for

La boucle for est capable d'itérer sur tout objet susceptible d'être indicés. "QUOI" ! Euh oui, des trucs dans lequel on range des éléments et où on peut retrouver ces éléments à l'aide d'un indice. On demande par exemple le premier élément. Regarde une chaîne de caractère, je peux demander la deuxième lettre pour exemple c'est x. Le for de python peut utiliser des chaînes, des listes, des tuples et d'autres objets encore. Bon d'accord le for c'est un peu trop fort pour le moment, mais on peut se contenter d'en voir qu'une partie.

Une boucle for commence par une première ligne dans laquelle on fixe la variable de boucle qui va prendre successivement la valeur des éléments contenus dans l'objet fourni et le bloc d'instructions associé est alors effectué.

Prenons un exemple :

 >>> objet = "Exemple"
 >>> for var_boucle in objet:
	print(var_boucle)


 E
 x
 e
 m
 p
 l
 e

La variable var_boucle prend la valeur du premier élément le caractère 'E'. Le bloc d'instructions est ensuite exécuté. Puis la variable var_boucle est mise à jour avec le deuxième caractère et le bloc d'instructions à nouveau exécuté... Le bloc d'instructions est exécuté une dernière fois lorsqu'on arrive à la dernière lettre 'e'. Souvent ces boucles sont utilisées pour pouvoir effectuer des traitements un nombre de fois connu à l'avance et qui ne dépend donc pas d'une condition. Par exemple, le programme concernant les pythons de la phytonisse, nous voulons que le traitement se fasse 8 fois. Pour cela il faut générer un objet itérable de 8 valeurs comprise entre 2 et 8. La fonction range() permet de réaliser cela.

 range(x)                    # de 0 à x - 1
 range(debut, fin)           # de debut à fin - 1
 range(debut, fin, pas)      # debut, debut + pas, debut + 2 * pas < fin

Rejouons avec la tortue, pour tracer sin(x)

Tu peux améliorer cela, en centrant par exemple la courbe et en traçant des axes.

5.  Pour s'amuser (ou pas)

Je te propose de calculer la suite de Syracuse. C'est une conjecture mathématique, c'est donc une assertion (affirmation) mathématique dont on ne connaît pas encore la démonstration mais que l'on soupçonne d'être vraie. Elle s'énonce de la manière suivante : soit un nombre N entier strictement positif, s’il est pair, on le divise par 2 et N devient alors N/2, s’il est impair, on le multiplie par 3 et on ajoute 1 et N devient N*3 + 1. On répète cela et on construit une suite d'entiers positifs dont chacun ne dépend que de son prédécesseur. De façon plus formelle, pour {$ N \in \mathbb{N}^* $}

• {$ u_0 = N $}
• et pour tout entier {$n \geq 0 : u_{n+1} = \begin{cases} \dfrac{u_n}{2}& \mbox{si } u_n \mbox{ est pair}\\ 3u_n + 1 & \mbox{si } u_n \mbox{ est impair} \end{cases} $}

La conjecture affirme que, pour tout {$ N > 0 $} , il existe un indice n tel que {$ u_n = 1 $}.

Un petit programme python va nous permettre de vérifier que c'est vrai pour une valeur de {$N$}.

On peut s'amuser à tracer l'évolution de la suite de Syracuse avec la tortue. C'est pas encore terrible mais cela montre comment elle évolue.

Tu peux chercher à compléter le programme en déterminant :

• le temps de vol : c'est le plus petit indice {$ n $} tel que {$ u_n = 1 $} ;
• le temps de vol en altitude : c'est le plus petit indice {$ n $} tel que {$ u_{n+1} < u_0 $} ;
• l'altitude maximale : c'est la valeur maximale de la suite.

Examine donc le cas de 27. Le dernier record de temps de vol en 2013 a été obtenu pour 2.361.235.441.021.745.907.775 par le projet 3x+1@home, il est de 2284.

On peut par exemple se poser la question du nombre compris entre 1 et 1 000 000 qui détient le plus grand temps de vol ? Il est conseillé pour faire cela de réduire l'affichage.

<< Exemple d'utilisation | PythonIndex | Les fonctions >>