appel direct de fonction refusé !

Je travaille toujours dans IDLE sous Windows XP et avec le même fichier d'essais _essai.py.

Je suis débutant en Python (version 2.6.4).
Je connais l'utilisation du module math dans le cadre d'un import :
par exemple :
from math import sqrt
racine = math.sqrt(3)
print racine
répond bien (après sauvegarde et appui sur la touche F5):
>>>
1.73205080757
>>>

En revanche, l'appel direct (sans import préalable) est refusé :
Si j'écris dans mon script :
racine = math.sqrt(3)
j'obtiens alors le message (toujours dans IDLE sous Windows XP) :
>>>
racine = math.sqrt(3)
NameError: name 'math' is not defined
>>>

Il en est de même pour tout autre module ; si j'écris par exemple, sans importer le module sys :
sys.exit()
J'obtiens le même type de refus :
>>>
sys.exit()
NameError: name 'sys' is not defined
>>>

Voilà à toute fin utile ce que j'obtiens si j'écris :
from sys import *
print path
résultat :
>>>
['E:\\GP\\Technique\\Python', 'C:\\Python26\\Lib\\idlelib', 'C:\\Python26', 'C:\\WINDOWS.0\\system32\\python26.zip', 'C:\\Python26\\DLLs', 'C:\\Python26\\lib', 'C:\\Python26\\lib\\plat-win', 'C:\\Python26\\lib\\lib-tk', 'C:\\Python26\\lib\\site-packages']
>>>

Quelqu'un peut-il me dire ce que je n'ai pas compris ?

Bonsoir,

Citation:

---

Quelqu'un peut-il me dire ce que je n'ai pas compris ?

---

Non.

Ce que vous décrivez est parfaitement normal et c’est ce qui est attendu de tout le monde.
Si vous y voyez quelque chose d’anormal, expliquez nous quoi parce que personne ne comprend ce qui vous chagrine.

Vous semblez attendre de pouvoir utiliser un module sans l’avoir importé. Mais à quoi servirait donc d’importer un module s’il était utilisable sans être importé ?



Pour être utilisable dans un module, un composant du langage doit faire partie de l’espace de nom de ce module. S’il n’en fait pas partie naturellement , c’est à dire s’il n’est pas built-in dans ce module, il faut l’importer dans ce module; l’importation consiste à lier son nom à l’espace de nom du module dans lequel on veut l’utiliser.

Quand on fait tourner un programme, même le plus simple, il y a toujours un module qui existe: il s’agit du module général d’un script, dans lequel tout se passe, qui s’appelle __main__



Intéressant à lire:
http://docs.python.org/reference/exe...ng-and-binding

En fait, j'ai l'impression que tu confonds l'instruction import avec un un raccourci de portée, comme les

Code:

---

using namespace xxx

---

du C++.

Ce n'est pas le cas : l'instruction import permet de charger un module. Si tu n'importes pas le module math, aucune de ses fonctions n'est disponible.
(un peu comme l'inclusion des headers en C et C++). Il faut donc faire

Code:

---

1 2 3 4 5 6 7

Python 2.6.4 (r264:75706, Oct 27 2009, 06:16:59) [GCC 4.4.1] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> import math >>> math.sqrt(3) 1.7320508075688772 >>>

---

Par contre, il est possible également de spécifier à la fonction import les fonctions que tu veux placer dans ta portée :

Code:

---

1 2 3 4

>>> from math import sqrt >>> sqrt(3) 1.7320508075688772 >>>

---

Dans ce cas, je n'ai pas eu besoin de faire math.sqrt().

Enfin, il est possible grâce à

Code:

---

from math import *

---

d'avoir accès directement à TOUTES les fonctions du module math.
Néanmoins, ce genre d'importation est à déconseiller, car si on importe des modules qui ont des fonctions du même nom, on ne sait plus trop avec quelle fonction on travaille :?

Bonsoir,

Les subtilités entre:

1. import math
2. from math import sqrt

sont difficiles à appréhender.

Personnellement, je m'en sors en disant que l'espace de noms du programme en cours d'exécution est adressable.
Les adresses sont de la forme:

<nom_module1>.<nom_module2>....

Cette forme d'adresse est similaire à un arbre:

<nom_module1> à pour fils <nom_module2>,...

Pensez à une arborescence de répertoires/sous répertoire | fichiers.

Cette structure d'arbre est quelque chose utilisé par le contexte d'exécution de votre programme.
Il servira à "trouver" les différents objets qui doivent être accédés pendant l'exécution. Lorsque cette exécution rencontre "from ... import..." ou "import...", notre arbre est modifié pour que l'interprétation des instructions à venir sachent quoi faire lorsqu'elles rencontrent certains noms.

L'interprétation de:

Code:

---

from math import sqrt

---

ordonne l'ajout d'une variable nommé "sqrt" dans l'espace de noms locals et de lui faire correspondre la fonction math.sqrt.

Comme les chemins non préfixés sont, par défaut, ceux du module courant.

Code:

---

print sqrt(4)

---

trouve ses petits et fonctionne.

Lorsqu'on écrit: li = [ 1, 2, 3, 4 ], on ne fait rien d'autre.
Sauf qu'une liste n'est pas une fonction: l'instruction est différente.

Nous avons aussi une opération bizarre dans notre arbre: la redirection de "sqrt" vers "math.sqrt".
Dans le cas des répertoires, nous avons crée un "raccourcis" ou un "soft link".
L'objet original "sqrt" n'a pas bougé, nous avons ajouté une adresse dans l'espace de noms "locals" pour y accéder directement.

L'interprétation de :

Code:

---

import math

---

est différente.
Nous ajoutons le module math et son contenu dans l'espace adressable du programme.

Pour adresser les fonctions de ce module, il faudra les préfixer par math.
Nous avons ajouté une branche aux modules accédés par le contexte d'exécution du programme.

En espérant que vous ayez pu en comprendre quelque chose.
- W

Bonjour
Tout d'abord un grand merci à vous trois : wiztricks, valAa et eyquem

Ma confusion venait du fait que j'ai mal interprété l'exemple de la page 262 de l'excellent cours téléchargeable de Gérard Swinnen où l'on trouve (paragraphe 16.3.4 ligne 6 du script - programme principal) une instruction sys.exit() non précédée d'un import sys.

Voici, en résumé, ce que je crois avoir compris de vos explications :

Je prends toujours l'exemple du calcul de la racine carrée de 3.

Méthode 1 :

Code:

---

1 2	from math import * print sqrt(3)

---

Méthode 2 :

Code:

---

1 2	from math import sqrt print sqrt(3)

---

Méthode 3 :

Code:

---

1 2	import math print math.sqrt(3)

---

Ces trois méthodes fonctionnent, mais elles ne présentent pas les mêmes avantages et inconvénients :

- la méthode 1 est syntaxiquement la plus légère mais c'est la plus consommatrice de ressources

- la méthode 2 est syntaxiquement un peu plus lourde mais elle consomme peu de ressources (elle n'utilise du module math que la fonction sqrt) ; on peut d'ailleurs importer dans une seule même instruction plusieurs fonctions :

par exemple :

Code:

---

from math import sqrt, atan2

---

- la méthode 3 est syntaxiquement la plus lourde mais elle consomme un minimum de ressources et, en outre, elle seule permet d'éviter l'écueil de la confusion éventuelle entre 2 fonctions (ou procédures ou méthodes ou classes) de même nom mais appartenant à des modules importés (ou non) différents.

Par exemple cosh qui figure à la fois dans les modules math et cmath, comme je le découvre en parcourant la précieuse page de ce site :
http://python.developpez.com/cours/d...nindex-all.php

Est-ce bien cela ?

Papy_77

Bonsoir,

Au delà de la confusion apportée par toutes ces façon d'importer des modules,
la règle est d'utiliser par défaut "import X"...
I.e. avoir de bonnes raisons pour faire autre chose.
Préférez la précision "from X import a, b, c" à "from X import *": vous écrasez l'espace de nom local.

Faites attention dans ce cas, à la nature des a, b, c.

from X import a: crée a et lui associe la valeur à l'instant de l'import mais il n'est plus connecté à X.a. Si un autre module change X.a....

import X : vous force à utiliser X.a et le module X devient une sorte de singleton.

- W