Discussion :

[clavier12AZQSWX]

bonjour,


Vaut-il mieux déclarer un import (import string par exemple) tout le temps tout en haut du fichier .py ou bien quand on en a juste besoin (par exemple dans une fonction ou dans une boucle if )

qu'en pensez-vous ?

y-a-t-il des coups supplémentaires à cela ?

[PauseKawa]

Bonjour,

ben... Si vous en avais besoin autant l'importer. Non ?
Le coût ? La lecture d'un fichier. Suivant le module cela pourrais être lourd.
Une contre-indication ?, La portée

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
class Foo:
     def __init__(self):
        import os
        print(locals())
 
f = Foo()
print(globals(), locals())

Une indication ? La compatibilité du code ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
class ScreenCap(object):
    def __init__(self):
        """Screenshot class"""
        if sys.platform == 'linux2':
            self.grab = self._GarbLinux
        elif sys.platform == 'win32':
            import Image, ImageGrab
            self.grab = self._GrabWin
        elif sys.platform == 'darwin':
            self.grab = self._GrabMac
        else:
            sys.exit(1)
        self._currentf = None
 
    def _FicNormalyze(self, name):
        """Internal Function for generate temp file.
           Use home user directory for rights.
        """
        if name:
            if os.path.basename(name) == name:
                _grabfile = os.path.join(os.path.expanduser('~'), name)
            else:
                _grabfile = name
        else:
            # default name
            _grabfile = os.path.join(os.path.expanduser('~'), 'scrcap.jpg')
        self._currentf = _grabfile
        return _grabfile
 
    def _GarbLinux(self, name=None):
        """Internal function for screen capture under Linux
           Use ImageMagick import utility
        """
        _grabfile = self._FicNormalyze(name)
        _grabcommand = "import -silent -window root " + _grabfile
        os.system(_grabcommand)
        return _grabfile
 
    def _GrabWin(self, name=None):
        """Internal function for screen capture under Windows.
           Use PIL ImageGrab.
        """
        try:
            import ImageGrab
        except:
            # Experimental import for PIL under Python 3.
            from PIL import ImageGrab
        _grabfile = self._FicNormalyze(name)
        ImageGrab.grab().save(_grabfile, "JPEG")
        return _grabfile
 
    def _GrabMac(self, name=None):
        """Internal function for screen capture under Mac.
           Use screencapture command.
        """
        _grabfile = self._FicNormalyze(name)
        _grabcommand = "screencapture -m -x -t jpg " + _grabfile
        os.system(_grabcommand)
        return _grabfile
...

@+

Note pour ce qui est de l'import dans une fonction: Les variables locales sont mises en place lors de l'interprétation du code.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
>>> def foo():
...     from os import *
... 
<stdin>:1: SyntaxWarning: import * only allowed at module level

The from form with * may only occur in a module scope. If the wild card form of import — import * — is used in a function and the function contains or is a nested block with free variables, the compiler will raise a SyntaxError.

Il est assez rare que des 'protections' soit mise en place pour le souligner

[rambc]

Bonjour.

Il me semble qu'il vaut mieux toujours indiquer les imports en début de script. C'est pour moi une bonne pratique à suivre à la lettre.

[wiztricks]

Salut,

Il me semble qu'il vaut mieux toujours indiquer les imports en début de script. C'est pour moi une bonne pratique à suivre à la lettre.

Par défaut, c'est préférable.

N'empêche qu'au plus le programme est gros au plus il contiendra de fonctions utilisées dans des cas assez particuliers qui pourront se retrouver en tas dans un script.

Mettre les import dans le "block" permet de documenter ces codes et de faciliter leur réorganisation.

Côté maintenabilité et optimisation la question peut se poser, mais les réponses sont toujours discutables car le "contexte" n'est jamais "clair".

- W

[fred1599]

La réponse est dans la PEP 8

Imports are always put at the top of the file, just after any module comments and docstrings, and before module globals and constants.

[wiztricks]

La réponse est dans la PEP 8

PEP 8 définit des recommandations applicables aux modules de la "Python Standard Library" et aux codes de l'interpréteur Python.
Les autres programmeurs Python peuvent l'utiliser pour "standardiser" leurs codes ou s'appliquer à suivre d'autres "standards".

note: l'intérêt de ce type de "standard" est comme celui d'une FAQ, avoir des réponses "good enough" applicables à des questions de bases évitant de refaire des réunions/discussions sans fin à chaque fois.

Ceci dit, des recommandations n'ont pas force de "lois".
Et des dimensions optimisation et maintenabilité peuvent donner lieu à ne pas appliquer une recommandation de façon bête. Ce qui suppose pouvoir motiver le "pourquoi" procéder différemment dans certains cas.

- W

[rambc]

N'empêche qu'au plus le programme est gros au plus il contiendra de fonctions utilisées dans des cas assez particuliers qui pourront se retrouver en tas dans un script.

Dans ce cas, j'aurais tendance à casser le script en plusieurs morceaux, cela me parait bien plus efficace côté maintenance : un script --> "une" fonctionnalité --> une liste de modules à importer.