Vos recrutements informatiques

700 000 développeurs, chefs de projets, ingénieurs, informaticiens...

Contactez notre équipe spécialiste en recrutement

FAQ PythonConsultez toutes les FAQ

Nombre d'auteurs : 14, nombre de questions : 269, dernière mise à jour : 10 septembre 2014  Ajouter une question

 

Cette FAQ a été réalisée à partir des questions posées sur le forum Python complétées par d'autres questions qui pouvaient nous sembler intéressantes de traiter. Toutefois il se peut que les réponses apportées contiennent des erreurs, imprécisions ... Vous pouvez dans ce cas contacter un des membres de la rédaction pour lui faire part de vos remarques.

L'équipe Python de Developpez.


Sommaire36 Q/R Python et Tkinter pour passer son Bac !Questions Python (12)
précédent sommaire suivant
 

R : Pensez aux en-têtes standards pour vos scripts Python !

Prenez l'habitude de toujours commencer vos scripts Python avec les mentions suivantes :

Pour Python2 :

Code python : Sélectionner tout
1
2
#!/usr/bin/env python 
# -*- coding: utf-8 -*-

Pour Python3 :

Code python : Sélectionner tout
1
2
#!/usr/bin/env python3 
# -*- coding: utf-8 -*-

Je veux comprendre :

Dans certains cas de figure, il est possible d'appeler un script Python sans préciser formellement dans la console :

Code shell : Sélectionner tout
python mon_script.py

ou pour Python3 :

Code shell : Sélectionner tout
python3 mon_script.py

Par exemple, sous Linux, vous pouvez appeler n'importe quel script - rendu exécutable par chmod +x mon_script.py - en invoquant son nom précédé des caractères './', par exemple :

Code shell : Sélectionner tout
./mon_script.py

Avec une invocation automatique, dite aussi self-launch, le système va regarder la toute première ligne du fichier script en question et va chercher ce qu'on appelle un shebang (contraction de sharp bang et parfois de shell bang - page web en anglais ), c'est-à-dire les deux caractères '#!' suivis généralement d'indications sur l'emplacement de l'interpréteur du script. Cette technique permet d'aller chercher n'importe quel interpréteur pour n'importe quel langage de script (pas seulement Python), puis de lui affecter le fichier de script en entrée d'interprétation.

Sous MS-Windows®, vous avez un cas similaire lorsque vous utilisez :

Code shell : Sélectionner tout
py mon_script.py

En effet, l'exécutable py.exe procède un peu de la même manière : il regarde la toute première ligne du script et tente de déterminer quelle version de Python il doit appeler.

S'il n'y a pas d'en-têtes Python standards, vous risquez d'avoir une erreur au lancement du script.

Pour en savoir plus, jetez un œil à la PEP 0263 de Python (en anglais).

Mis à jour le 28 août 2014

Plus d'infos sur cette page de tutoriel.

R : Vous êtes très certainement sous Python2 et ses problèmes récurrents de caractères Unicode.

Mettez ceci en début de script et vous devriez résoudre 99 % de vos problèmes liés à Unicode :

Code python : Sélectionner tout
1
2
3
4
#!/usr/bin/env python 
# -*- coding: utf-8 -*- 
  
from __future__ import unicode_literals

Je veux comprendre :

L'une des différences très marquantes entre Python2 et Python3 est la prise en charge native des caractères Unicode.

Les caractères Unicode permettent de couvrir tous les alphabets et tous les signes existant sur Terre, mais en programmation informatique, il n'y a aucune obligation de les utiliser comme encodage par défaut dans un langage donné, c'est même assez rare quand c'est le cas.

L'équipe Python a décidé de prendre cette option : autant Python2 gère les caractères Unicode comme étant juste un encodage parmi d'autres, autant Python3 a adopté l'idée de pouvoir scripter directement en Unicode UTF-8 - et bien plus encore.

Si vous ne voulez pas galérer avec les problèmes Unicode, je ne puis que vous conseiller d'installer Python3 sur votre machine et de l'utiliser pour écrire vos scripts, vous y gagnerez.

Lien de téléchargement : https://www.python.org/downloads/ (en anglais).

Documentation officielle Python (2 et 3) : https://www.python.org/doc/ (en anglais).

Si vous n'avez pas le choix et que vous êtes obligé(e) de rester sous Python2, jetez un œil attentif au Unicode HOWTO de Python (en anglais).

Pour en savoir plus, jetez un œil à la PEP 0263 de Python (en anglais).

Mis à jour le 29 août 2014

Plus d'infos sur cette page de tutoriel.

R : Vous êtes très certainement sous Python2 et ses problèmes récurrents de caractères Unicode.

Mettez ceci en début de script et vous devriez résoudre 99 % de vos problèmes liés à Unicode :

Code python : Sélectionner tout
1
2
3
4
#!/usr/bin/env python 
# -*- coding: utf-8 -*- 
  
from __future__ import unicode_literals

Je veux comprendre :

C'est le même problème que celui expliqué dans la question « J'ai des caractères bizarres qui s'affichent dans ma console. Comment ça se fait ? »

Mis à jour le 29 août 2014

Plus d'infos sur cette page de tutoriel.

R : Lisez la dernière ligne du message d'erreur en premier.

Lisez la dernière ligne du message d'erreur puis remontez le message à rebours jusqu'à ce que vous ayez trouvé le ou les indices qui vous permettront de résoudre votre problème.

Je veux comprendre :

Armez-vous aussi de patience. Les messages d'erreur sont (presque) toujours en anglais et presque toujours pas franchement faciles à comprendre.

En général, si vous ne vous laissez pas impressionner par la tonne de textes qui vous inonde lors d'un message d'erreur et que vous prenez bien le temps d'éplucher ce qui s'y dit en partant de la dernière ligne du message et en le remontant à rebours, vous devriez trouver la réponse à votre problème.

Dans Python, un message d'erreur se lit en partant de la dernière ligne et en remontant à rebours jusqu'à trouver le ou les indices qui permettront de résoudre le problème.

Au pire, si vraiment vous n'y comprenez rien, le forum Développez.net (DVP) est là pour vous aider, mais essayez tout de même de faire l'effort d'analyser vos messages d'erreur par vous-mêmes, vous verrez, c'est très instructif et on apprend beaucoup comme ça.

Vous trouverez des explications succinctes sur chaque type d'erreur (appelé aussi « exception ») sur cette page de documentation officielle Python (en anglais).

Mis à jour le 29 août 2014

Plus d'infos sur cette page de tutoriel.

R : L'erreur de syntaxe se cache en réalité plus haut dans le script.

Il faut remonter le script à rebours à partir du point d'erreur signalé par l'interpréteur Python et bien regarder attentivement : la plupart du temps, on oublie une parenthèse fermante quelque part ou une bêtise d'inattention de ce genre.

Je veux comprendre :

Un interpréteur lit les lignes d'un script séquentiellement, les unes après les autres, selon des schémas qui lui sont propres. Ces schémas s'appellent la syntaxe du langage.

Si on oublie une parenthèse fermante par exemple, ce qui est un cas très fréquent qui arrive à tout le monde, l'interpréteur continue de lire les lignes suivantes croyant qu'elles appartiennent à l'expression comprise entre parenthèses, vu qu'il n'a pas encore rencontré de parenthèse fermante.

Pensez aux parenthèses fermantes oubliées dans les lignes précédentes.

Mais comme les lignes suivantes n'ont syntactiquement rien à voir avec une expression entre parenthèses, l'interpréteur lève une erreur SyntaxError pour se plaindre de ce qu'il prend pour une incohérence, quand bien même les lignes incriminées seraient justes, cela n'a pas d'importance.

Exemple :

Code python : Sélectionner tout
1
2
3
4
5
6
7
8
#!/usr/bin/env python 
# -*- coding: utf-8 -*- 
  
a = 0 
  
x,y = (10, 20   # l'erreur se trouve ici (parenthèse fermante manquante) 
  
z = 2**3 + 10*2.35 - 45//89

Qui provoque l'erreur :

Code shell : Sélectionner tout
1
2
3
4
  File "./forum.py", line 8 
    z = 2**3 + 10*2.35 - 45//89 
    ^ 
SyntaxError: invalid syntax

Alors que la ligne en question est parfaitement juste. C'est le cas typique d'une parenthèse fermante oubliée quelque part dans les lignes qui précèdent.

C'est donc un truc à bien se remémorer : quand vous avez une erreur de syntaxe dans votre script et que la ligne en question semble parfaitement juste, c'est à coup sûr parce que l'erreur se trouve dans les lignes qui précèdent la ligne incriminée par l'interpréteur, vous devez donc remonter l'examen des lignes à rebours jusqu'à trouver ce qui manque - parenthèse fermante ? - ou ce qui ne va pas.

Mis à jour le 29 août 2014

Plus d'infos sur cette page de tutoriel.

R : Vous utilisez un nom de variable AVANT de l'avoir explicitement défini.

Pensez à toujours bien initialiser vos variables dès le départ, quitte à les modifier ensuite.

Je veux comprendre :

C'est un peu comme si vous parliez à quelqu'un de choses qu'il ne connaît pas. Automatiquement, il va vous interrompre pour vous demander de lui expliquer ces choses.

Il en va de même pour un interpréteur Python : s'il ne sait pas de quoi vous parlez, il va vous signaler que vous ne lui avez pas défini ce que vous entendez par le nom de variable que vous utilisez.

Comme pour un interlocuteur humain, vous allez donc devoir lui expliquer de quoi il en retourne précisément, sauf que Python utilise un langage mathématique, il faut donc lui définir les choses mathématiquement.

Par exemple, ceci est incorrect et provoque une erreur NameError :

Code python : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
#!/usr/bin/env python 
# -*- coding: utf-8 -*- 
  
def f(x): 
  
    print a     # d'où sort ce 'a' ? vouliez-vous dire 'x' plutôt ? 
  
# end def 
  
# début du programme 
  
f(0)

Alors que ceci est correct :

Code python : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#!/usr/bin/env python 
# -*- coding: utf-8 -*- 
  
def f(x): 
  
    print a     # appel à une variable globale 'a' en lecture seule 
  
# end def 
  
# début du programme 
  
a = 0   # on définit 'a' dès le départ 
  
# on appelle ensuite seulement la fonction 
f(0)

Aller plus loin avec les conventions de nommage de la PEP 8 de Python (en anglais).

Mis à jour le 29 août 2014

Plus d'infos sur cette page de tutoriel.

R : Vous faites appel à une variable locale qui n'a pas été définie au bon endroit.

Définissez toujours vos variables locales à une fonction donnée au début de la fonction et en-dehors de toute condition.

Je veux comprendre :

Cette erreur arrive souvent lorsque l'on définit une variable locale à une fonction à l'intérieur d'un bloc conditionnel if …: bloc else: bloc sans l'avoir définie au préalable dans le code de la fonction et que l'on fait appel à cette variable avec la certitude qu'elle sera définie en temps voulu.

Voici un cas d'école typique :

Code python : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#!/usr/bin/env python 
# -*- coding: utf-8 -*- 
  
def f(x): 
    if x % 4 == 0: 
        a = 10.584 
    elif x % 4 == 1: 
        a = 12.352 
    elif x % 4 == 2: 
        a = 24.689 
    elif x % 4 == 3: 
        a = 39.547 
    # end if 
    # on retourne le résultat de notre traitement 
    return a 
# end def 
  
# test 
  
x = 100.235 
  
print "ajustement de la valeur de %f : %f" % (x, f(x))

Résultat console :

Code shell : Sélectionner tout
1
2
3
4
5
6
Traceback (most recent call last): 
  File "./forum.py", line 22, in <module> 
    print "ajustement de la valeur de %f : %f" % (x, f(x)) 
  File "./forum.py", line 15, in f 
    return a 
UnboundLocalError: local variable 'a' referenced before assignment

Saurez-vous trouver où se cache l'erreur ?

Réponse :

A priori, x % 4 signifie x modulo 4 et fournit bien les valeurs (0, 1, 2, 3) attendues en résultat de ce modulo, donc la variable locale 'a' devrait toujours être initialisée, n'est-ce pas ?

Eh bien, non.

Ouvrez une console Python (ou IDLE) et tapez ce qui suit :

Code shell : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
>>> 100 % 4 
0 
>>> 100 % 4 == 0 
True 
>>> 100.235 % 4 
0.23499999999999943 
>>> 100.235 % 4 == 0 
False 
>>> 100.235 % 4 == 1 
False

Note : les symboles '>>> ' représentent l'invite de commande de la console Python et ne doivent pas être saisis au clavier. N'entrez que ce qui suit ces symboles.

Qu'est-ce qu'on remarque ici ? Eh oui, le calcul du modulo pour un nombre à virgule flottante à décimales non nulles produit en résultat un nombre à virgule flottante et non pas un entier !

Ce qui implique qu'aucun test dans la fonction f(x) ne sera juste et donc que la variable 'a' ne sera jamais initialisée en-dehors de ces tests.

D'où l'erreur au moment de se référer à cette variable dans le return a en fin de fonction.

Comment corrigeriez-vous ce bout de code pour qu'il fonctionne correctement ?

Réponse courante :

Code python : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#!/usr/bin/env python 
# -*- coding: utf-8 -*- 
  
def f(x): 
    # on force 'x' à n'être qu'un entier 
    x = int(x) 
    # et le reste devrait suivre... 
    if x % 4 == 0: 
        a = 10.584 
    elif x % 4 == 1: 
        a = 12.352 
    elif x % 4 == 2: 
        a = 24.689 
    elif x % 4 == 3: 
        a = 39.547 
    # end if 
    # on retourne le résultat de notre traitement 
    return a 
# end def 
  
# test 
  
x = 100.235 
  
print "ajustement de la valeur de %f : %f" % (x, f(x))

Résultat console :

Code shell : Sélectionner tout
ajustement de la valeur de 100.235000 : 10.584000

Mis à jour le 29 août 2014

Plus d'infos sur cette page de tutoriel.

R : Vous avez oublié de déclarer « global ... » au début de la fonction.

Si pour une variable globale donnée 'ma_variable', vous ne déclarez pas global ma_variable en début de fonction où vous l'utilisez, vous ne pourrez utiliser cette variable qu'en lecture seule et vous ne pourrez pas la modifier.

Je veux comprendre :

Dans une fonction, l'interpréteur Python a besoin du mot-clé réservé global en début de fonction pour bien faire la distinction entre le nom d'une variable locale à cette fonction et le même nom provenant d'une variable globale.

Par exemple, si vous modifiez une variable globale 'ma_variable' dans une fonction et que vous omettez de déclarer global en début de fonction, Python va croire que vous définissez une variable locale nommée elle aussi 'ma_variable' et il lui donnera donc la priorité dans le code de la fonction.

Pour éviter ce genre de confusion, vous devez donc recourir à la mention global :

Code python : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#!/usr/bin/env python3 
# -*- coding: utf-8 -*- 
  
def f(x): 
    # ici ON NE PEUT PAS modifier notre variable globale 
    if x > 5: 
        ma_variable = 1 # Python SUPPOSE que c'est une variable LOCALE 
# end def 
  
def g(x): 
    global ma_variable  # ici ON PEUT modifier notre variable globale 
    if x > 5: 
        ma_variable = 1 # Python SAIT que c'est une variable globale 
# end def 
  
# début du programme 
  
ma_variable = 250 
f(1) 
print("f(1):\t ma_variable =", ma_variable) 
f(10) 
print("f(10):\t ma_variable =", ma_variable) 
g(1) 
print("g(1):\t ma_variable =", ma_variable) 
g(10) 
print("g(10):\t ma_variable =", ma_variable)

Résultat console :

Code shell : Sélectionner tout
1
2
3
4
f(1):     ma_variable = 250 
f(10):     ma_variable = 250 
g(1):     ma_variable = 250 
g(10):     ma_variable = 1

Mis à jour le 29 août 2014

Plus d'infos sur cette page de tutoriel.

R : Collision de noms de variables avec des noms de fonctions.

Utilisez toujours des noms explicites aussi bien pour vos variables que pour vos fonctions.

Je veux comprendre :

À force d'utiliser des abréviations ou des noms de fonctions et de variables trop courts, vous finissez par utiliser des variables et des fonctions qui ont le même nom. Selon l'endroit du code où vous vous trouvez, il est possible que l'interpréteur Python râle parce que vous avez utilisé une variable à la place d'une fonction.

Cas d'école typique :

Code python : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#!/usr/bin/env python 
# -*- coding: utf-8 -*- 
  
def f(x):   # <-- notre fonction s'appelle f ! 
    # init variables GLOBALES 
    global f, g, h 
    # init variables LOCALES 
    y = f * x + g   # on utilise une variable globale f ou une fonction f ? 
    z = h * x + y 
    # on modifie quelques globales 
    # pour le prochain appel de f(x) 
    f = f + 2   # idem ici: globale f ou fonction f ? 
    g = g * 3 
    h = h - 5 
    # résultat du calcul 
    return (x, y, z) 
# end def 
  
# début du programme 
  
# init variables globales 
f = 4   # collision ! on a déjà une fonction qui s'appelle f ! 
g = 10 
h = 12 
  
# init test 
x = 30 
  
# boucle essais 
for i in range(10): 
    print "Pour x = %d, coordonnées (x, y, z) = %s" % (x, f(x)) # boum ! 
# end for 
  
# fin du programme

Résultat console :

Code shell : Sélectionner tout
1
2
3
4
Traceback (most recent call last): 
  File "./forum.py", line 31, in <module> 
    print "Pour x = %d, coordonnées (x, y, z) = %s" % (x, f(x)) # boum ! 
TypeError: 'int' object is not callable

La solution consiste ici à prendre l'habitude, dès le départ, de donner des noms explicites à vos variables comme à vos fonctions :

  • pour les variables : donnez un nom commun représentatif de ce que contient la variable e.g. ne nommez pas 'choucroute' une variable appelée à contenir le rayon d'un cercle, appelez-la tout simplement 'rayon' (voire 'rayon_cercle'), ce sera forcément plus parlant ;
  • pour les fonctions : en maths, on note les fonctions avec une seule lettre ; en informatique, on note les fonctions avec une action, un verbe, qui essaie d'illustrer au mieux ce que fait la fonction e.g. évitez les f(x) et consorts, utilisez par exemple interpoler(x) ou tracer(x) pour expliciter vos intentions.


Un nom commun pour une variable, un verbe pour une fonction.

La PEP 8 (en anglais) de Python énonce quelques règles de nommage (en anglais) que vous n'êtes pas obligés de suivre, mais dont vous devriez néanmoins fortement vous inspirer, notamment :

  • les noms de variables et de fonctions s'écrivent toujours en minuscules, avec les lettres a-z de l'alphabet anglais (donc non accentuées), avec le signe souligné ('_') dit underscore et les chiffres 0-9 ;
  • un nom débute par une lettre a-z ou le signe souligné ('_'), mais pas par un chiffre e.g. 'x_1' est valide, '_x1' est valide aussi, mais pas '1_x' ;
  • dans un nom de variable ou de fonction, on sépare les mots par le signe souligné ('_') : par exemple, on préférera écrire 'tracer_courbe()' que 'tracerCourbe()' ou 'tracercourbe()' ;
  • les notations commençant par deux underscores - exemple __rayon_cercle ou __multiplier__ (a, b) - sont à éviter tant que vous ne maîtrisez pas Python un tant soit peu : ces notations sont réservées aux identificateurs dits private ou aux fonctions magiques ;
  • les noms de CONSTANTES suivent les mêmes règles que pour les noms de variables sauf qu'on les note en majuscules : par exemple, on écrira plutôt PAGE_NOT_FOUND = 404 que page_not_found = 404, même s'il n'existe pas de type de données spécifique pour les constantes en Python, ce n'est ici qu'une convention de notation pour faire ressortir les constantes dans le code ;
  • les noms de classes s'écrivent en notation CamelCase c'est-à-dire en plaçant une majuscule à chaque mot différent dans le nom, le reste étant toujours en minuscules ; quelques exemples : 'Canvas', 'LabelFrame', 'MatrixDisplayHook', '_TkInterfaceManager', '__FactorySubclass', 'Tk2048Game', etc.

Toutes ces règles de nommage visent un objectif pratique : rendre le code lisible, intelligible et facile à cartographier. Si on respecte bien ces règles, on peut retrouver du premier coup d'œil les classes utilisées, les constantes, etc.

Mis à jour le 29 août 2014

Plus d'infos sur cette page de tutoriel.

R : On n'est jamais mieux servi(e) que par soi-même !

C'est l'occasion rêvée pour apprendre à déboguer votre programme.

Je veux comprendre :

Oui, déboguer un programme, c'est une discipline qui s'apprend.

Savoir déboguer est aussi important que savoir coder.

Quelques pistes :

  • commencez par décortiquer les messages d'erreur : jetez donc un œil à la question « J'ai un message d'erreur « Traceback... », mais je n'y comprends rien ! Vous pouvez m'aider ? » ;
  • faites des tests dans une console Python (même version de Python que votre script, n'ajoutez pas de la difficulté à la difficulté, SVP) : certaines assertions de votre code ne sont peut-être pas aussi justes que vous le pensez ; voir le cas typique cité dans la question « J'ai ce message : « UnboundLocalError: local variable '...' referenced before assignment ». Ça veut dire quoi ? » ;
  • faites des tests en fichier séparé : créez un nouveau fichier de test à part e.g. test.py et mettez-y une simulation simplifiée du problème que vous voulez résoudre ; il arrive souvent que l'on rencontre un problème précis dans des projets comportant plusieurs milliers de lignes de code : au lieu de fouiller dans toutes ces lignes, le plus simple reste encore de copier/coller juste la séquence qui vous intéresse dans un fichier à part, puis de tester ce qui ne va pas pour cette séquence précisément ; on appelle cela « faire un test sur un coin de table » ;
  • utilisez les outils de débogage inclus dans IDLE, l'éditeur fourni d'office avec Python : jetez un œil à ce tutoriel intéressant ;
  • passez par un logiciel de débogage : il existe des logiciels spécialisés dans le traçage et le débogage de scripts, mais il n'est pas dit que vous ne perdrez pas plus de temps à essayer de comprendre comment on utilise de tels logiciels plutôt qu'à déboguer vous-même votre script.


Voyez aussi ce qui se dit à ce sujet dans la documentation officielle Python (en anglais).

Mis à jour le 29 août 2014

Plus d'infos sur cette page de tutoriel.

R : C'est quand une fonction s'appelle elle-même.

La récursivité est un concept intéressant pour certaines fonctionnalités, mais elle demeure gourmande en ressources mémoire et en temps machine, surtout si la fonction engendre un grand nombre de récursions pour obtenir un résultat - voir le cas très célèbre du calcul de la fonction factorielle.

Une fonction récursive est une fonction qui s'appelle elle-même.

Il vaut donc mieux recourir à la récursivité une fois que l'on s'est assuré(e) qu'il n'existe pas d'autres alternatives beaucoup plus performantes.

Le sujet est expliqué plus en détail dans cette page de tutoriel.

Mis à jour le 29 août 2014

R : Oui, mais c'est assez ardu.

Il va falloir plonger dans les arcanes de cx_Freeze ou de Py2exe.

Je veux comprendre :

La philosophie du langage Python est plutôt tournée vers le partage de code source ouvert que vers la notion de code propriétaire, aussi, la démarche de créer un exécutable pour MS-Windows® - qui implique de fermer le code pour l'empaqueter dans un exécutable n'est pas prévue nativement.

En général, cette étape n'est pas vraiment nécessaire. Pour utiliser des logiciels Python, il suffit de récupérer les scripts et de les exécuter tels quels, sans autre forme de procès.

Maintenant, si vous tenez absolument à enfermer votre code dans un exécutable, vous allez devoir faire quelques efforts et vous documenter sur cx_Freeze et Py2exe.

Voir aussi ce qui se dit sur Python et Windows® dans la documentation officielle Python (en anglais).

Mis à jour le 29 août 2014

Plus d'infos sur cette page de tutoriel.

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2017 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
Contacter le responsable de la rubrique Python