tite fractale

Memento Python

Aller directement à :

Sinon, vous cherchez peut-être l’activité de prise en main de Python.

Table des matières complète :

1. Erreurs de syntaxe fréquemment rencontrées

Lorsque que Python vous donne un message d’erreur, il faut souvent commencer par lire la dernière ligne, qui donne le type d’erreur.

1.1. Invalid syntax

Plusieurs raisons sont possibles :

Exemple :

>>> if True
  File "<stdin>", line 1
    if True
          ^
SyntaxError: invalid syntax

1.2. Expected an indented block

Une ligne n’est pas correctement indentée.

Les blocs de code étant délimités par l’indentation, Python s’attend au moins à ce que la première ligne d’un bloc (après par exemple if, else, while, for…) soit indentée.

>>> if True:
... print("vrai")
  File "<stdin>", line 2
    print("vrai")
        ^
IndentationError: expected an indented block

1.3. EOL while scanning string literal

Une chaîne de caractère est mal délimitée, il manque sûrement des guillemets (simples ou doubles).

>>> "bla
  File "<stdin>", line 1
    "bla
       ^
SyntaxError: EOL while scanning string literal

2. Erreurs d’exécution fréquemment rencontrées

Lorsque que Python vous donne un message d’erreur, il faut souvent commencer par lire la dernière ligne, qui donne le type d’erreur.

2.1. Not defined

>>> print(ma_varialbe)
NameError: name 'ma_varialbe' is not defined

>>> # solutions:
...
>>> ma_varialbe = "truc"  # initialiser
truc
>>> print(ma_variable)    # bien écrire le nom de la variable

Il faut aussi connaître l’orthographe des constantes prédéfinies comme True et False (notez la majuscule).
Notez aussi que les mots-clés sont en minuscule.

2.2. Can't convert…

>>> print("bla" + 1)
TypeError: Can't convert 'int' object to str implicitly
>>>
>>> # solutions:
...
>>> print("bla", 1)        # séparer par une virgule (deux arguments)
bla 1
>>> print("bla" + str(1))  # concaténer une chaîne avec une chaîne
bla1

Voir Problèmes dus aux types.

2.3. Can't assign to operator

>>> x-depart = 0
SyntaxError: can't assign to operator
>>> 
>>> # solutions:
... 
>>> x_depart = 0     # les noms de variables ne peuvent pas contenir -
>>> 
>>> x = 42
>>> depart = 0
>>> x - depart == 0  # si vous voulez tester l’annulation d’une différence
False

2.4. Indent error

Vérifier que l’indentation est bien faite par paquets de 4 espaces, sans tabulations.

2.5. Non-ASCII character...

SyntaxError: Non-ASCII character '\xc3' in file /tmp/test.py on line 1,
             but no encoding declared;
             see http://www.python.org/peps/pep-0263.html for details

Cette erreur ne devrait pas apparaître si vous utilisez Python 3.

Deux solutions :

2.6. Division by zero

>>> 1/0
ZeroDivisionError: division by zero

2.7. Not all arguments converted during string formatting

>>> m,n = "17","3"
>>> m % n
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  TypeError: not all arguments converted during string formatting

L’opérateur % n’a pas la même signification quand il est utilisé avec des chaînes de caractères. Vous avez sans doute voulu utiliser cet opérateur avec une entrée de l’utilisateur m = input(). Convertissez vos nombres en vrais nombres avec int : m = int(input()).

Voir aussi les problèmes dus aux types :

>>> 3 % "10"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for %: 'int' and 'str'

2.8. Fleuve rouge lors de l’utilisation des doctests

Traceback (most recent call last):
  File "C:/Python32/dt.py", line 6, in <module>
    doctest.testmod()
  File "C:\Python32\lib\doctest.py", line 1869, in testmod
    for test in finder.find(m, name, globs=globs, extraglobs=extraglobs):
  File "C:\Python32\lib\doctest.py", line 864, in find
    self._find(tests, obj, name, module, source_lines, globs, {})
  File "C:\Python32\lib\doctest.py", line 906, in _find
    test = self._get_test(obj, name, module, globs, source_lines)
  File "C:\Python32\lib\doctest.py", line 990, in _get_test
    filename, lineno)
  File "C:\Python32\lib\doctest.py", line 600, in get_doctest
    return DocTest(self.get_examples(string, name), globs,
  File "C:\Python32\lib\doctest.py", line 614, in get_examples
    return [x for x in self.parse(string, name)
  File "C:\Python32\lib\doctest.py", line 576, in parse
    self._parse_example(m, name, lineno)
  File "C:\Python32\lib\doctest.py", line 634, in _parse_example
    self._check_prompt_blank(source_lines, indent, name, lineno)
  File "C:\Python32\lib\doctest.py", line 721, in _check_prompt_blank
    line[indent:indent+3], line))
ValueError: line 1 of the docstring for __main__ lacks blank after >>>: '>>>test()'

Tout est dans la dernière ligne : il manque une espace entre les chevrons et l’instruction à tester.

2.9. Can't assign to function call

>>> tab(0) = 0
SyntaxError: can't assign to function call

Si vous voulez affecter une valeur dans une case de tableau, il faut utiliser des crochets.

2.10. Argument must be a string or a number

>>> n = int(input)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: int() argument must be a string or a number, not 'builtin_function_or_method'

int attend une chaîne de caractères ou un nombre, pas une fonction.
Il manque les parenthèses. Il faut taperint(input()) afin d’appeler la procédure input plutôt que seulement la nommer.

2.11. Maximum recursion depth exceeded

Python permet la récursivité, mais n’optimise pas les appels terminaux (et son créateur a de bonnes raisons pour avoir choisi de ne pas le faire, article en anglais). Pour ne pas faire déborder le système, une limite est fixée, et on peut y accéder en lecture et en écriture.

Ainsi, si vous rencontrez RuntimeError: maximum recursion depth exceeded, vous pouvez vous en sortir ainsi :

import sys
sys.setrecursionlimit(10000)

2.12. Local variable 'ma_var' referenced before assignment

Erreur subtile qui peut apparaître quand on cherche à utiliser une variable globale sans la déclarer global. Voir cet article en anglais.

3. Singularités de Python

1) Python peut-être utilisé interactivement (si on dispose de l’invite >>>) ou en exécutant les instructions lues dans un fichier. La plupart des petits exemples sur ce site utiliseront le style interactif.

2) Pas de point virgule ; en fin de ligne, mais des doubles points : à la fin des lignes contenant if, else, elif, while, for (voire même def et class). : se dit colon en anglais.

L’utilisation des deux points en Python est une controverse.

Vous trouverez des détails historiques et des références sur des études sur la lisibilité dans les langages de programmation ici, ainsi qu’une discussion informelle (mais intéressante) sur le sujet ici.

3) Blocs de codes délimités par indentation et non par accolades.

4) Pas de parenthèses autour des conditions de test.

5) Les boucles POUR se font par parcours de la variable dans une liste.

>>> for i in range(3):           # range(n) -> [0, 1, ..., n-1]
...     print(i)
... 
0
1
2
>>> liste = ["bla", 0, 3.14]
>>> for element in liste:        # l'element parcourt la liste
...     print(element)
...
bla
0
3.14
>>> for i in range(len(liste)):  # i parcourt les indices de la liste
...     print(liste[i])
...
bla
0
3.14

Voir la section range pour plus d’informations sur la génération de liste de nombres.

6) Déclarations de variables inutiles. int(0) est 0 converti en entier (c’est-à-dire 0). Ni plus ni moins.

7) L’initialisation d’une variable se fait lors de la première affectation, et avant toute lecture de la valeur de la variable, sinon c’est le not defined.

4. Conventions

Un des credos du créateur de Python est que le code est plus souvent lu que tapé. Le PEP8 (voir la traduction en français) propose des conventions d’écriture qui assurent une certaine lisibilité. Ces conventions, associées au découpage des blocs par l’indentation, assurent une certaine homogénéité des fichiers Python, même si les personnes qui les ont tapés n’avaient pas prévu de travailler ensemble.

5. Calculs

5.1. Puissance

Il y a au moins deux façons de calculer n au carré :

Il est aisé de généraliser à n à la puissance m en remplaçant 2 par m.

5.2. Autres

L’accès à des fonctions plus spéciales peut se faire par exemple en important le module math (taper import math en tête de fichier ou dans l’interpréteur interactif). Exemple 

>>> math
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    math
NameError: name 'math' is not defined
>>> import math
>>> math
<module 'math' (built-in)>
>>> math.sqrt(2)
1.4142135623730951

Voir la documentation en suivant ce lien :
http://docs.python.org/3.2/library/numeric.html

6. Valeurs aléatoires

Voir http://docs.python.org/3.2/library/random.html.

>>> import random
>>> random.randint(1, 6)
2
>>> random.randint(1, 6)
6

7. Listes

7.1. Liste vide

[]

7.2. Liste non vide

[0, 3.14, "bla", None, ma_var, ["une", "liste", "dans", "une", "liste"]

7.3. Accès en lecture et écriture d’un élément

liste[n]

7.4. range

range permet, en Python2, de générer une liste de nombres. En Python3, elle permet de générer une séquence de nombres, donc pas vraiment une liste au sens propre, mais on s’en sert de la même façon dans les boucles for.

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]
>>> list(range(0, 10, 3))
[0, 3, 6, 9]
>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> list(range(0))
[]
>>> list(range(1, 0))
[]

7.5. Sous-listes

liste[n:m]

C’est la sous-liste [liste[i] for i in range(n, m)] où les indices i sont tels que n <= i < m.

Si n est omis, on part du début de la liste, si m est omis, on va jusqu’à la fin de la liste. Les deux peuvent être omis et dans ce cas on récupère une copie de la liste.

7.6. Longueur

len(liste) donne le nombre d’éléments de liste.

7.7. Concaténation

On utilise le symbole +.

Au passage, liste * n est compatible avec l’utilisation de + car on obtient la concaténation de liste avec elle-même, liste apparaissant n fois.

7.8. Ajout

liste.append(elt) ajoute elt à la fin de liste.

En cas de défaillance de mémoire, on peut aussi taper :
liste = liste + [elt]
C’est moins pythonique, mais ça fonctionne.

7.9. Recherche

elt in liste retourne True ou False suivant l’existence d’un élément de liste qui est égal à elt.

liste.index(elt) retourne l’indice du premier élément de liste égal à elt ou une erreur s’il n’y a pas de tel élément.

8. Chaînes de caractères

8.1. Délimiteurs

chaine1 = 'lorem ipsum'
chaine2 = "lorem ipsum"
chaine3 = '''sur
    plusieurs lignes'''
chaine3 = """sur
    plusieurs lignes"""

8.2. Manipulations

8.2.1. Les chaînes sont des listes

>>> "bonjour"[0]
'b'
>>> "bonjour"[1]
'o'
>>> "bonjour"[-1]
'r'
>>> "bonjour"[-2]
'u'
>>> "bonjour"[2:4]
'nj'
>>> "bonjour"[2:]
'njour'
>>> "bonjour"[:4]
'bonj'

>>> len("bonjour")
7

>>> "abc" + "def"
'abcdef'
>>> 3 * "abc"
'abcabcabc'
>>> "abc" * 3
'abcabcabc'

>>> txt = "bonjour"
>>> txt.append("non")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'str' object has no attribute 'append'

>>> "b" in txt
True
>>> "a" in txt
False
>>> txt.index("b")
0
>>> txt.index("a")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

8.2.2. Patrons

>>> patron = "Bonjour %s !"
>>> prenom = "Ursule"
>>> patron % prenom
'Bonjour Ursule !'
>>> patron = "Bonjour %s, je te trouve %s !"
>>> prenom = "Kevina"
>>> adjectif = "super"
>>> patron % (prenom, adjectif)
'Bonjour Kevina, je te trouve super !'

9. Tableaux

Voir le module tableaux qui simule cette structure de données que Python n’a pas par défaut.

10. La procédure print

10.1. En général

En Python3, print doit être utilisée avec des parenthèses. Par défaut, un retour à la ligne est ajouté à la fin.

>>> print
<built-in function print>
>>> print "bonjour"
  File "<stdin>", line 1
      print "bonjour"
                        ^
SyntaxError: invalid syntax
>>> print("bonjour")
bonjour
>>> print()

>>>

10.2. Rester sur une même ligne

Pour afficher différentes choses sur une même ligne, plusieurs méthodes :

La concaténation, mais on ne peut concaténer que des chaînes de caractères, et il faut penser aux espaces pour la présentation.

>>> print("liste numéro" + 1 + ":" + [1, 2, 4, 8, 16])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't convert 'int' object to str implicitly
>>> print("liste numéro" + str(1) + ":" + str([1, 2, 4, 8, 16]))
liste numéro1:[1, 2, 4, 8, 16]
>>> print("liste numéro " + str(1) + " : " + str([1, 2, 4, 8, 16]))
liste numéro 1 : [1, 2, 4, 8, 16]

Passer plusieurs arguments, ce qui est souvent plus élégant.

>>> print("liste numéro", 1, ":", [1, 2, 4, 8, 16])
liste numéro 1 : [1, 2, 4, 8, 16]

Supprimer le retour à la ligne en ajoutant un dernier argument end="". Pratique si on ne peut pas faire un seul print.

>>> print("bonjour", end="")
bonjour>>> for i in range(10): print(i, end="")
...
0123456789>>>

11. La procédure input

En Python3, input retourne une chaîne de caractères. Si vous demandez un nombre à l’utilisateur, vous pouvez écrire :

print("Donnez un nombre: ")
n = int(input())

ou

print("Donnez un nombre: ")
txt = input()
n = int(txt)

Sinon, Python vous donnera des résultats inattendus comme :

>>> "2" + "2"
'22'

Ou renverra une erreur comme :
Not all arguments converted during string formatting (voir plus bas).

12. Python 2 et Python 3

12.1. Généralités

Le créateur et leader de Python, Guido van Rossum, a un jour décidé de nettoyer son langage (pour plus de détails, voir les sections correspondantes sur Wikipedia).

C’est un choix réfléchi que de rendre Python3 incompatible avec Python2, les améliorations ayant semblé plus importantes que la perte de rétro-compatibilité.

Pour plus de détails sur les différences entre ces deux versions et le choix de celle qu’il vous faut, voir la page correspondante sur le wiki de Python (en anglais).

J’ai choisi d’apprendre Python3 à mes élèves.

12.2. Différences à notre niveau

12.2.1. print

En Python 2, l’affichage d’une expression ne nécessite pas de parenthèses. Si on en met, on affiche :

 

>>> print 0
0
>>> print(0)
0
>>> print("valeur", 0)
('valeur', 0)

En Python 3, l’affichage d’une expression nécessite des parenthèses. La séparation par des virgules correspond donc à un appel de print avec plusieurs arguments, et les arguments seront élégament séparés lors de l’affichage.

>>> print 0
  File "<stdin>", line 1
    print 0
          ^
SyntaxError: invalid syntax
>>> print(0)
0
>>> print("valeur", 0)
valeur 0

Finalement, l’utilisation de parenthèses permet un code source compatible Python2/Python3, si on supporte l’affichage des tuples en Python 2.

12.2.2. Division

En Python 2, n/m et n//m donnent le quotient entier si n et m sont des entiers (attention, 0.0 n’est pas un entier). Il faut convertir un des nombres en flottant pour obtenir un résultat flottant. Il y a pour cela deux méthodes :

 

>>> 1/2
0
>>> 1//2
0
>>> 1./2
0.5
>>> 1/2.
0.5
>>> 1./2.
0.5
>>> float(1)/2
0.5

En Python 3, n/m donne le quotient flottant, et n//m donne le quotient entier (mêmes remarques que pour Python2 avec . et float).

>>> 1/2
0.5
>>> 1//2
0
>>> 1.//2
0.0

Finalement, pour un code compatible, il est préférable d’utiliser // pour la division entière, et d’utiliser float et / sinon.

12.2.3. input et raw_input

Python2 possédait raw_input() en plus de input().

Dans Python3, raw_input() a été renommé input(), et l’ancien input() peut être obtenu en le passant dans eval().

Pas de possibilité de code compatible avec les versions brutes.

12.2.4. range

En Python2 (voir la doc officielle) :

>>> range(5)         # Retourne une liste.
[0, 1, 2, 3, 4]

En Python3 (voir la doc officielle) :

>>> range(5)         # Retourne un objet d’un type spécial.
range(0, 5)
>>> list(range(5))   # Que l’on peut tout de même convertir en liste,
[0, 1, 2, 3, 4]      # mais c’est totalement inutile dans un 'for'.

13. Les avantages de Python

13.1. Philosophie de Python

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one -- and preferably only one -- obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than right now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Tiré de http://python.org/dev/peps/pep-0020/.

Pour plus de détails, voir cet article par le créateur de Python.

Le reste est en cours de rédaction (doubles inégalités, paradigme fonctionnel, popularité, bibliothèques…).

14. Les inconvénients de Python

En cours de rédaction…




Christophe Gragnic, le 26/09/2014, 15h05'58".






Page générée le 04/12/2016, 10h08'07" (source).
historique de la page
historique global

 TogetherJS