#acl Formateurs:read,write,revert All:read

= Initiation à Python 3 =

Le langage de programmation fixé comme référence pour cette
formation est Python, en version 3. Ce premier TP a pour but de vous
donner des bases de programmation suffisantes pour transcrire
n’importe quel algorithme travaillant sur des types de données
simples : nombres, chaînes de caractères et listes. Il ne s’agit pas d’être
virtuose, mais simplement que le langage ne soit pas un obstacle à la mise en
pratique.

Si vous connaissez déjà bien Python, ne vous attardez pas trop.
Le choix de l’environnement de développement (ici IDLE) n’est qu’une
suggestion : faites comme à la maison.

Si vous connaissez déjà un autre langage de programmation, c’est l’occasion
d’en découvrir un nouveau, peut-être assez différent.

Dans ces deux cas, ce sujet ne devrait pas trop poser de problème, et
vous pourrez vous attaquer à un authentique TP de programmation tout de suite après.

Et si c’est votre premier contact avec la programmation, pas d’inquiétude, on avancera pas à pas.

<<TableOfContents()>>

== Lancer un interpréteur ==

{{{#!wiki tip
Si ce n’est déjà fait, il faut bien sûr commencer par installer Python :
 * si vous travaillez sous Windows ou Mac, les fichiers nécessaires sont accessibles sur le site [[http://www.python.org/]] : choisir la dernière version stable (Python 3.?.?) ;
 * sous GNU/Linux, installez simplement les paquets python3 et idle3 en utilisant le gestionnaire de paquet de votre distribution.

Avec un peu de chance, ces instructions sont inutiles dans la salle informatique
du site de formation. :-)
}}}

Un programme Python est un simple fichier de texte qui contient les instructions
à faire exécuter par la machine, ou plutôt l’interpréteur Python. Par exemple :
{{{#!highlight python
def discriminant(a,b,c):
	return b*b-4*a*c

def nbracines(a,b,c):
	d = discriminant(a,b,c)
	if d>0:
		return 2
	elif d<0:
		return 0
	else:
		return 1

print("Le polynome 2X^2+3X-3 a", nbracines(2,3,-3), "racines réelles.")
}}}
On pourrait
donc se contenter de taper ce code source dans un éditeur de texte (ce qui est
différent d’un logiciel de traitement de texte), puis le faire exécuter par
l’interpréteur. Mais l’interpréteur peut également être utilisé de manière
interactive. C’est ce que nous ferons pour les premiers pas qui suivent.

Lançons donc l’environnement graphique IDLE. On se retrouve devant une fenêtre
comme celle-ci :

{{attachment:IDLE.png}}

L’invite {{{>>>}}} nous… invite à taper des instructions Python.
Ce que nous allons nous empresser de faire.

== Python comme calculatrice ==

Lorsque vous tapez une instruction, l’interpréteur affiche la valeur
éventuellement produite.

Par exemple :
{{{#!highlight python
>>> 42
42
}}}
(j’ai tapé « {{{42}}} », puis fait « Entrée » et l’interpréteur a affiché {{{42}}}).

On peut bien sûr former des expressions arithmétiques plus compliquées.
Testez par exemple les expressions suivantes et essayez de deviner ce que ça
calcule, si possible avant de le taper :
{{{#!highlight python
21+21
32*(42+10)
2**3
2**4
2**5
2.5*2
2/3
1/1
2//3
13.0//6
13%6
1//1
}}}
Si vous connaissez Python 2, certains des résultats précédents vous ont
peut-être surpris. On les expliquera sur place.

Et si vous avez le moindre doute sur ce qui vient de se passer, il faut le dire !

{{{#!wiki tip
À tout moment, vous pouvez revenir sur une ligne précédente (en cliquant dessus ou en utilisant les flèches du clavier) et appuyer sur
« Entrée » pour recopier automatiquement son contenu : pratique quand on a fait
une erreur de frappe ou quand on tape des lignes un peu répétitives.
}}}

{{{#!wiki important
À ce stade, que pouvez-vous dire de la manière dont Python 3 gère les nombres ?
}}}

=== Python comme calculatrice scientifique ===

On n’est bien sûr pas limités aux opérations arithmétiques. Python est en fait
un langage assez prisé dans le monde du calcul scientifique moderne, en
particulier parce qu’il fournit des bibliothèques de calcul aux fonctionnalités avancées.
Il n’en sera pas question ici, mais on peut déjà trouver pas mal de choses dans
la bibliothèque standard.

Essayez ce qui suit :
{{{#!highlight python
from math import * # On fait ici un peu de magie, qui sera expliquée plus tard
sqrt(2)
pi
log(1)
log(e)
cos(pi/3)
log(1024,2)
}}}

== Fonctions ==

La manière recommandée de travailler l’algorithmique en Python est d’identifier
la notion d’algorithme avec celle de ''fonction'': un bout de programme qui porte
un nom (disons `f`), attend un certain nombre d’arguments 
(disons `x1`, `x2`, …), et dont l’évaluation retourne un `résultat`.

En Python, ça correspond à la construction `def`:
{{{#!highlight python
def f (x1, x2, ...):
	... des instructions ...
	return resultat
}}}
définit une nouvelle fonction qui, partant des valeurs initiales 
de `x1, x2, ...` effectue les instructions requises, et renvoie 
la valeur de l’expression `resultat`. Si on n’utilise pas l’instruction
`return` finale, ça fonctionne aussi sauf que rien n’est renvoyé (cas d’une
procédure).

{{{#!wiki tip
Jusqu’ici nos programmes ne comportaient qu’une seule instruction, qu’on tapait directement 
dans l’interpréteur.

Dès qu’on veut dépasser le stade de la calculatrice, il est bien plus pratique
de taper du code dans une fenêtre d’édition, et de faire tourner ce code dans 
l’interpréteur.

Avec IDLE, ça demande quelques étapes de préparation :
 * créer un nouveau fichier à travers le menu `File -> New File`, ce qui ouvre une nouvelle fenêtre d’édition
 * taper notre code dans la fenêtre d’édition, par exemple les fonctions `discriminant` et `nbracines` données au début de cette page
 * lancer le programme en appuyant sur la touche `F5` (c’est un raccourci pour le menu `Run -> Run Module`)
 * un dialogue nous indique que pour lancer un programme python, il faut d’abord le sauvegarder dans un fichier : faisons ça, par exemple sous le nom `test.py` dans notre dossier personnel ou sur le bureau (il faut terminer le nom par `.py` pour indiquer au système que c’est du python
 * l’interpréteur est alors redémarré et notre programme chargé : les fonctions définies dans le programme sont maintenant disponibles dans l’interpréteur
 * testez votre code en appelant par exemple `nbracines(1,0,-1)` ou `nbracines(1,2,1)` depuis l’interpréteur

Notez que les fonctions `print()` et `input()` que vous connaissez peut-être
deviennent inutiles avec ce type de fonctionnement : les entrées et l’affichage
sont gérées par l’interpréteur, et on peut se concentrer sur le contenu
algorithmique.
}}}

'''Exercez-vous:''' Écrivez une fonction
{{{#!highlight python
def moy(a,b):
	...
}}}
qui renvoie la moyenne des arguments (en supposant qu’il s’agit de nombres).
Vous pouvez vous contenter d’ajouter la définition de votre fonction 
au fichier déjà créé ci-dessus. Testez ensuite votre fon

Si tout fonctionne comme prévu, vous pouvez arrêter de suivres ces notes, et commencez à 
[[Algorithmique élémentaire en Python|vous exercer sur des problèmes classiques]]:
posez des questions ou revenez ici dès qu’il vous manque des éléments pour les traiter.

== Chaînes de caractères ==

Bien sûr Python n’est pas limité au calcul numérique : le cœur de
l’informatique moderne (disons à partir des années 70), ce sont les chaînes de
caractères. En Python, une chaîne littérale est indifféremment entourée d’apostrophes droites « `'` »
ou de guillemets droits « `"` ».

Tentons un laconique :
{{{#!highlight python
'Bonjour.'
}}}
Notez que les apostrophes restent présentes dans la sortie : l’interpréteur
nous signale que nous avons bien construit une chaîne.
Même chose avec :
{{{#!highlight python
"Bonjour."
}}}

L’opération de base sur les chaînes est la concaténation :
{{{#!highlight python
'Bon' + "jour."
}}}
Oui, ça se note comme une somme.

On peut aussi calculer la longueur d’une chaîne :
{{{#!highlight python
len('Bon' + "jour.")
}}}

Notez que Python 3 n’est pas inquiété par tous les caractères bizarres que vous
pourrez entrer :
{{{#!highlight python
'Considérons la fonction φ : x ↦ x³.'
len('1 €')
}}}
(par contre, votre navigateur peut l’être).

Ces deux dernières lignes en étonneront peut-être certains (qui savent que les caractère dits bizarres sont souvent codés sur plusieurs octets) : les caractères de Python 3 sont ceux de la norme Unicode.

Pour afficher une chaîne, on utilise l’instruction `print` :
{{{#!highlight python
print('Bonjour.')
}}}
Cherchez la différence avec :
{{{#!highlight python
'Bonjour.'
}}}

{{{{#!wiki important
La question de l’affichage revient souvent dans les formations, mais elle n’a en fait pas beaucoup d’intérêt :
ce qui nous intéresse ici, c’est comment '''calculer''' un résultat, d’une manière correcte et modulaire ;
c’est-à-dire qu’on veut pouvoir '''utiliser''' ce résultat dans un calcul ultérieur.

Afficher un résultat d’une manière agréable et lisible, c’est le travail d’une interface utilisateur :
ce n’est qu’une utilisation possible parmi d’autres.
Et surtout ça ne concerne ''a priori'' que le résultat final.
En pratique, afficher quelque chose de manière prématurée est une source d’erreurs : on aura l’occasion d’en rediscuter plus bas.
}}}}

== Variables et types ==

Un élément essentiel de l’écriture d’algorithmes est la possibilité
de stocker des informations intermédiaires dans des ''variables'' : cette
notion est omniprésente en programmation.

En Python, le nom d’une variable est nécessairement constitué de caractères alphanumériques, 
plus éventuellement le caractère « souligné » `"_"`. Le premier caractère doit être une lettre.

Des exemples :
{{{
x
x1
ma_variable_preferee
}}}

L’affectation d’une valeur à une variable est notée par le signe d’égalité « `=` », un
choix mathématiquement regrettable mais assez répandu. Essayons :
{{{#!highlight python
x = 32
y = 52
somme = x+y
produit = x*y
}}}

On peut afficher une valeur numérique de la même manière qu’une chaîne :
{{{#!highlight python
print(somme)
print(produit)
}}}

Et on peut afficher plusieurs choses sur la même ligne :
{{{#!highlight python
print('x :',x,'y :',y,'Somme :',somme,'Produit :',produit)
}}}

Continuons :
{{{#!highlight python
x = -1
print('x :',x,'y :',y,'Somme :',somme,'Produit :',produit)
}}}

{{{#!wiki important
Quelles remarques pouvez-vous déjà faire sur l’utilisation des variables en Python ?
Pouvez-vous expliquer ce qui se passe ?
}}}

Continuons :
{{{#!highlight python
x = 'Ceci est une chaîne !'
print('x :',x,'y :',y,'Somme :',somme,'Produit :',produit)
}}}
Le résultat vous surprend peut-être : la variable `x` était d’abord un nombre,
voilà que c’est une chaîne.  Pourtant, pas de message d’erreur !
On pourrait croire que Python ignore l’information de type. C’est plus subtil.
 
En Python, toute ``valeur`` a un type bien déterminé. D’ailleurs,
l’interpréteur peut nous le donner :
{{{#!highlight python
type(1)
type(0.5)
type('a')
type('un mot')
type('€uro')
}}}
Par contre les variables ne sont pas typées a priori : une variable n’est qu’un `nom`
auquel on peut associer temporairement une valeur, de type quelconque. 
{{{#!highlight python
x=1
type(x)
x='a'
type(x)
}}}
En particulier, en Python, ''on ne déclare pas les variables''.

De plus, les opérations sont surchargées : on a vu que le `+` est défini entre
deux nombres ou entre deux chaînes, et que le type de retour pouvait être adapté.

Tentons :
{{{#!highlight python
print('Le résultat est '+42)
}}}
Que se passe-t-il ? Ce cas n’est pas visiblement pas prévu.

Il est facile de convertir un nombre en la chaîne qui le représente, et réciproquement :
{{{#!highlight python
str(42)
int('100')
float('1')
}}}
On peut aussi forcer la conversion entre types de nombres de la même manière :
{{{#!highlight python
float(1)
int(100.0**100)
}}}

{{{{#!wiki important
Si `x` est de type `float`, `int(x)` renvoie l’entier le plus proche.
Attention, pour les négatifs, ce n’est pas la partie entière:
celle-ci s’obtient par la fonction `float` du module `math`
(disponible après l’invocation `from math import *`).
}}}}


Plus étonnant peut-être :
{{{#!highlight python
100**100
100**100-100**99
100.0**100
100.0**100-100**99
2**2**2
2**2**2**2
2**2**2**2**2 # C’est peut-être un peu risqué !
2**2**2**2**2**2 # À tous les coups ça plante…
}}}

{{{#!wiki tip
Si le programme a l’air bloqué, vous pouvez interrompre l’exécution 
avec la combinaison de touches « `Ctrl+C` ».
}}}


Une utilisation standard :
{{{#!highlight python
entree = input('Entrez un nombre entier N : ')
N = int(entree)
print('N² = '+str(N*N))
}}}

La fonction `input` affiche son argument, puis récupère ce qui est entré 
par l’utilisateur : c’est une chaîne, qu’il faut convertir si on veut 
l’utiliser comme un nombre.


{{{{#!wiki important
Là encore : demander une valeur à l’utilisateur, c’est l’affaire d’une interface, ça n’a rien avoir avec l’algorithme sous-jacent.

Et il y a bien d’autres manières d’obtenir des valeurs d’entrée sur lesquelles faire travailler nos algorithmes.

Quand on débute, cet aspect interactif est parfois amusant, mais il est bien plus important de savoir comment utiliser une valeur d’entrée de manière '''générique'''.
}}}}


== Booléens ==

Un dernier type de base, que nous n’avons pas encore croisé : les booléens.
C’est le type à deux valeurs : vrai et faux.
{{{#!highlight python
True
False
type(True)
}}}

On fabrique des booléens avec des tests :
{{{#!highlight python
1 > 0
1 < 0
1 >= 1
1 <= 0
1 != 0
1 == 0 # Attention, on double le signe = pour le distinguer de l’affectation
'a' == 'b'
'a' + 'a' == 'aa'
}}}
Et on peut les composer via les opérations booléennes `and`, `or`, `not` :
{{{#!highlight python
'toto' == '' or len('toto') > 2 
}}}

== Algorithmique de base ==

Jusque là, on a parlé des opérations de base du calcul. 
Reste à introduire l’algorithmique à proprement parler.

Le branchement conditionnel prend la forme `if `''condition''`: `''instruction''.
Vous pouvez deviner ce que fait :
{{{#!highlight python
if x<0:
  x=-x
}}}
Si le branchement comprend une alternative, on utilise `else` :
{{{#!highlight python
if x<0:
  y=0 
else:
  y=x
}}}
Si plusieurs instructions doivent suivre, on les met ligne par ligne '''''en respectant l’indentation''''' :
{{{#!highlight python
a, b, c = 1, -2, 1 # On utilise un raccourci pour l’affectation simultanée de plusieurs variables
b = -b / 2
delta = b * b - a * c
if delta > 0:
	n  = 2
	x1 = (b - sqrt(delta)) / a
	x2 = (b + sqrt(delta)) / a
else: 
	if delta == 0:
		n  = 1
		x  = b/a
	else:
		n = 0
}}}
Cette convention trouble souvent les programmeurs de langages comme C ou Java. 
Elle a pourtant le mérite d’être concise, lisible et d’éviter la frappe de 
délimiteurs.


La structure `else: if:` imbriquée, peut-être abrégée en `elif`, ce qui
économise un niveau d’indentation :
{{{#!highlight python
if delta > 0:
	n  = 2
	x1 = (b - sqrt(delta)) / a
	x2 = (b + sqrt(delta)) / a
elif delta == 0:
	n  = 1
	x  = b/a
else:
	n = 0
}}}

La boucle ''tant que'' s’écrit naturellement sur le même modèle 
`while `''condition'': 
{{{#!highlight python
n = 0
while n<10:
	print(n)
	n = n+1
}}}


{{{{#!wiki tip
Une source très courante d’erreurs en Python est le non respect des contraintes d’indentation.
Précisons donc.

L’indentation est la nature et le nombre des caractères ''blancs'' (espaces et tabulations)
situés avant le premier caractère d’une ligne de texte.
Au lieu d’avoir des caractères de délimitation (comme `{` et `}` en `C` ou `Java`),
Python définit un bloc d’instructions comme une suite de lignes avec la même
indentation.
Les sous-blocs d’une instruction structurée (branche, boucle, etc.)
doivent avoir une indentation compatible et supérieure à celle de l’instruction.

Comparez:
{{{
n=0
i=0
while i<10:
  n = n + i
  i = i + 1
  print(n)
}}}
avec
{{{
n=0
i=0
while i<10:
  n = n + i
  i = i + 1
print(n)
}}}
}}}}


== Quelques subtilités ==

Essayez la chose suivante :
{{{#!highlight python
def incremente(a):
	a = a+1
	print('Nouvelle valeur de a : '+str(a))

a = 1
incremente(a)
print(a)
}}}

{{{#!wiki important
Que se passe-t-il ?
Que pouvez-vous dire sur la ''portée'' des variables en Python ?
Quelles autres expériences proposez-vous pour mieux comprendre ?

Un excellent outil pour étudier le fonctionnement de vos programmes est [[http://pythontutor.com/|Python Tutor]]:
celui-ci vous fournit en direct une représentation de la mémoire à chaque étape d’exécution.

}}}



== Listes, chaînes, n-uplets ==

On a déjà décrit le cœur algorithmique, les opérations sur les types de base et
le mécanisme d’affectation des variables.
Légitimement, on pourrait s’arrêter là : on a déjà un modèle de calcul complet.

Mais Python, comme tout langage contemporain, nous permet de composer ces types de base 
en introduisant des types dits séquentiels : listes et n-uplets. Ceux-ci
rassemblent un nombre quelconque de valeurs au sein d’un même objet composé.
On forme un n-uplet avec des parenthèses :
{{{#!highlight python
z = (1,2,3)
}}}
une liste avec des crochets :
{{{#!highlight python
l = ['a','b','c']
}}}
On obtient des objets de types `tuple` et `list` respectivement.

En fait, les parenthèses ne sont pas nécessaires autour d’un n-uplet : c’est la virgule qui sert de constructeur.
{{{#!highlight python
zz = 1,2,3
z == zz
}}}

La longueur se calcule comme pour les chaînes:
{{{#!highlight python
len(z)
}}}

On peut fabriquer des séquences vides:
{{{#!highlight python
()
[]
}}}
et des singletons:
{{{#!highlight python
1,
[1]
}}}
(notez la virgule nécessaire pour le 1-uplet).
On accède aux éléments d’une séquence avec les crochets :
{{{#!highlight python
print(z[1])
print(l[0])
print(l[1])
print(l[2])
print(l[3])
}}}
Que remarquez-vous ?

Et au fait, que se passe-t-il avec
{{{#!highlight python
print(l[-1])
}}}
?

Les séquences sont la solution idéale pour renvoyer un nombre variable de résultats:
{{{#!highlight python
def discriminant(a,b,c):
	return b * b - a * c

def resout1(a,b):
	# résout l'équation ax+b=0 si a est non nul
	return -b/a

def resout (a,b,c):
	# renvoie la liste des solutions de l'équation ax²+bx+c=0 si a ou b est non nul
	b = -b / 2
	if a == 0:
		return [resout1(b,c)]
	delta = discriminant(a,b,c)
	if delta > 0:
		x = (b - sqrt(delta)) / a
		y = (b + sqrt(delta)) / a
		return [x,y]
	elif delta == 0:
		return [b/a]
	else:
		return[]

def  nbsol(a,b,c):
	return len(resout(a,b,c))

}}}

On peut concaténer les séquences avec le `+`, comme dans :
{{{#!highlight python
l = l + ['d']
}}}


On peut également fabriquer une sous-séquence, en donnant un intervalle plutôt qu’un numéro de case:
{{{#!highlight python
l[1:3]
"bonjour"[2:5]
(1,2,3)[2:2]
}}}
Notez que `machin[a:b]`, est la sous-séquence de `machin`, de la position `a` incluse à la position `b` non incluse.
On peut aussi utiliser des positions négatives, et si on oublie une borne, ça va jusqu’au bout.
Ainsi on peut définir:
{{{#!highlight python
def découpe(sequence):
    n = len(sequence)//2
    début = sequence[:n]
    fin = sequence[n:]
    return début,fin
}}}
qui découpe une séquence en deux morceaux de longueur à peu près égales.


La différence entre les deux types `list` et `tuple`, c’est qu’on peut changer les éléments d’une liste, 
mais pas ceux d’un n-uplet :
{{{#!highlight python
l[0] = 'A'
z[0] = '0' # ça plante
}}}
On dit que les éléments d’une liste sont ''mutables''.

En fait, les chaînes de caractères sont en partie de la même nature que les n-uplets :
ce sont des suites… de caractères. Et on ne peut pas les changer.
{{{#!highlight python
s = 'Bonjour.'
s[0]
s[0]='b' # ça plante
}}}

{{{{#!wiki caution
La valeur d’une liste, c’est l’adresse en mémoire du tableau qui contient ces valeurs!
Ainsi, si on écrit
{{{#!highlight python
l = list("bonjour")
m = l
}}}
non seulement les valeurs de `m` sont les mêmes que celles de `l`, mais quand on fait
{{{#!highlight python
m[0] = "B"
}}}
on a aussi `l[0] == "B"`.

La représentation des listes [[https://pythontutor.com/|Python Tutor]] est particulièrement éclairante.
Testez-y le programme suivant:
{{{#!highlight python
def zero_partout(l):
    for i in range(len(l)):
        l[i] = 0
    return l
une_liste = [1, 2, 3]
une_autre_liste = zero_partout(une_liste)
}}}
et essayez d’expliquer la valeur de `une_liste` à la fin du programme.

Le programme de seconde n’insiste pas sur la notion de liste: on pourra se contenter de les voir comme une manière pratique de manipuler
un ensemble de valeurs, et non pas comme des objets qu’on a envie de générer ou modifier de manière algorithmique.
En particulier, à ce niveau, on peut passer sous silence le concept même d’affectation d’une nouvelle valeur à un élément de liste.

Une autre manière de modifier une liste ''en place'', c’est d’utiliser les méthodes `append`, `pop`, ''etc.''
Par exemple :
{{{#!highlight python
def mon_range(n):
    l = []
    i = 0
    while i<n:
        l.append(i*i)
        i = i+1
}}}
est une manière un peu tordue de générer la liste des entiers de `0` à `n-1`.

L’intérêt de ces méthodes est leur efficacité en temps et en mémoire. Quand on écrit :
{{{#!highlight python
l.append(a)
}}}
la valeur de `a` est ajoutée dans une nouvelle case à la fin de `l`,
tandis que quand on écrit
{{{#!highlight python
l = l + [a]
}}}
on construit une nouvelle liste, qui contient les éléments de `l` plus le nouvel élément, puis on donne ça comme nouvelle valeur de `l`.
Pour visualiser la différence, omparez dans  [[https://pythontutor.com/|Python Tutor]] ce que font les deux programmes :
{{{#!highlight python
l = [1,2,3]
m = l + [4]
}}}
et
{{{#!highlight python
l = [1,2,3]
m = l
m.append(4)
}}}

Encore une fois, tout ça (et en particulier les méthodes) est exclu du programme de seconde.


}}}}

La boucle `for` de Python permet de répéter un bloc d’instructions pour chacun 
des éléments d’une séquence. Par exemple :
{{{#!highlight python
for k in 1,2,3:
	print(k)
s = ''
for k in 'Un truc.':
	s = s + k + k
print(s)
}}}

En fait, on peut librement mélanger les types au sein d’une séquence :
{{{#!highlight python
for k in 1, 'a', 100.0**.5 :
	print(k)
}}}

Et on peut même imbriquer les séquences :
{{{#!highlight python
def mat22 (a,b,c,d):
	return((a,b),(c,d))
M=mat22(1,2,3,4)
M[1][0]
def affiche22 (M):
	for l in M:
		print(l)
affiche22(M)
}}}

La fonction `range`, très souvent utile, permet de générer une valeur qui se comporte comme 
une liste d’entiers consécutifs. Essayez-la :
{{{#!highlight python
for i in range(10):
	print(i)
for i in range(1,10):
	print(i)
}}}
Notez que certains arguments des fonctions fournies par Python peuvent être optionnels. Pour
l’instant, on s’en tiendra à la non-explication « magique »: `range` peut recevoir un ou deux arguments, et `print` peut en recevoir un nombre quelconque.


On peut obtenir une liste triée des éléments de n’importe quelle séquence avec la fonction `sorted`:
{{{#!highlight python
sorted([3,1,2])==[1,2,3]
}}}

Enfin, une curiosité pythonesque : les listes en compréhension.
On peut construire une liste (ou un tuple) en énumérant les valeurs prises par une expression
lorsqu’on fait varier un paramètre, possiblement en sélectionnant les valeurs du paramètre qui satisfont un test :
{{{#!highlight python
[i*i*i for i in range(10)]
}}}
est la liste des cubes des entiers de `0` à `9`
et 
{{{#!highlight python
[i*i*i for i in range(10) if i%3>0]
}}}
est la liste des cubes des entiers de `0` à `9` qui ne sont pas des multiples de 3.

== Fin ==

Si vous êtes arrivés jusque là, vous avez toutes les
briques pour traiter l’algorithmique courante (et même plus) en Python 3. :)
Reste à pratiquer, avec les [[Algorithmique élémentaire en Python|exercices]] que vous n’auriez pas encore traités.