Quelle est une alternative à execfile en Python 3?

Il semble qu'ils aient annulé dans Python 3 tout le moyen facile de charger rapidement un script en supprimant execfile()

Y a-t-il une alternative évidente qui me manque?

Selon la documentation , au lieu de

execfile("./filename") 

Utilisation

exec(open("./filename").read())

Voir:

• Nouveautés de Python 3.0

Vous êtes juste censé lire le fichier et exécuter le code vous-même. 2to3 remplacements actuels

execfile("somefile.py", global_vars, local_vars)

comme

with open("somefile.py") as f:
    code = compile(f.read(), "somefile.py", 'exec')
    exec(code, global_vars, local_vars)

(L'appel de compilation n'est pas strictement nécessaire, mais il associe le nom de fichier à l'objet de code, ce qui facilite le débogage.)

Voir:

• http://docs.python.org/release/2.7.3/library/functions.html#execfile
• http://docs.python.org/release/3.2.3/library/functions.html#compile
• http://docs.python.org/release/3.2.3/library/functions.html#exec

Bien qu'il exec(open("filename").read())soit souvent donné comme alternative à execfile("filename"), il manque des détails importants qui ont été execfilepris en charge.

La fonction suivante pour Python3.x est aussi proche que possible d'avoir le même comportement que l'exécution directe d'un fichier. Cela correspond à la course python /path/to/somefile.py.

def execfile(filepath, globals=None, locals=None):
    if globals is None:
        globals = {}
    globals.update({
        "__file__": filepath,
        "__name__": "__main__",
    })
    with open(filepath, 'rb') as file:
        exec(compile(file.read(), filepath, 'exec'), globals, locals)

# execute the file
execfile("/path/to/somefile.py")

Remarques:

• Utilise la lecture binaire pour éviter les problèmes d'encodage
• Garantie de fermeture du fichier (Python3.x vous en avertit)
• Définit __main__, certains scripts en dépendent pour vérifier s'ils se chargent en tant que module ou non, par exemple.if __name__ == "__main__"
• Le réglage __file__est plus agréable pour les messages d'exception et certains scripts permettent __file__d'obtenir les chemins des autres fichiers par rapport à eux.

• Prend des arguments facultatifs globaux et locaux, les modifiant en place comme le execfilefait - afin que vous puissiez accéder à toutes les variables définies en relisant les variables après l'exécution.

• Contrairement à Python2, execfilecela ne modifie pas l'espace de noms actuel par défaut. Pour cela, vous devez explicitement passer dans globals()& locals().

Comme suggéré récemment sur la liste de diffusion python-dev , le module runpy pourrait être une alternative viable. Citant ce message:

https://docs.python.org/3/library/runpy.html#runpy.run_path

import runpy
file_globals = runpy.run_path("file.py")

Il existe de subtiles différences pour execfile:

• run_pathcrée toujours un nouvel espace de noms. Il exécute le code en tant que module, il n'y a donc pas de différence entre les globaux et les locaux (c'est pourquoi il n'y a qu'un init_globalsargument). Les globaux sont retournés.

  execfileexécuté dans l'espace de noms actuel ou l'espace de noms donné. La sémantique de localset globals, si elle est donnée, était similaire aux sections locales et globales dans une définition de classe.

• run_path peut non seulement exécuter des fichiers, mais aussi des œufs et des répertoires (reportez-vous à sa documentation pour plus de détails).

Celui-ci est meilleur, car il prend les globaux et les locaux de l'appelant:

import sys
def execfile(filename, globals=None, locals=None):
    if globals is None:
        globals = sys._getframe(1).f_globals
    if locals is None:
        locals = sys._getframe(1).f_locals
    with open(filename, "r") as fh:
        exec(fh.read()+"\n", globals, locals)

Vous pouvez écrire votre propre fonction:

def xfile(afile, globalz=None, localz=None):
    with open(afile, "r") as fh:
        exec(fh.read(), globalz, localz)

Si vous aviez vraiment besoin de ...

Si le script que vous souhaitez charger se trouve dans le même répertoire que celui que vous exécutez, peut-être que "import" fera le travail?

Si vous devez importer dynamiquement du code, la fonction intégrée __ import__ et le module imp valent la peine d'être examinés .

>>> import sys
>>> sys.path = ['/path/to/script'] + sys.path
>>> __import__('test')
<module 'test' from '/path/to/script/test.pyc'>
>>> __import__('test').run()
'Hello world!'

test.py:

def run():
        return "Hello world!"

Si vous utilisez Python 3.1 ou une version ultérieure, vous devriez également jeter un œil à importlib .

Voici ce que j'avais ( fileest déjà affecté au chemin d'accès au fichier avec le code source dans les deux exemples):

execfile(file)

Voici ce que je l'ai remplacé:

exec(compile(open(file).read(), file, 'exec'))

Ma partie préférée: la deuxième version fonctionne très bien en Python 2 et 3, ce qui signifie qu'il n'est pas nécessaire d'ajouter une logique dépendante de la version.

Notez que le modèle ci-dessus échouera si vous utilisez des déclarations d'encodage PEP-263 qui ne sont pas ascii ou utf-8. Vous devez trouver l'encodage des données et les encoder correctement avant de les transmettre à exec ().

class python3Execfile(object):
    def _get_file_encoding(self, filename):
        with open(filename, 'rb') as fp:
            try:
                return tokenize.detect_encoding(fp.readline)[0]
            except SyntaxError:
                return "utf-8"

    def my_execfile(filename):
        globals['__file__'] = filename
        with open(filename, 'r', encoding=self._get_file_encoding(filename)) as fp:
            contents = fp.read()
        if not contents.endswith("\n"):
            # http://bugs.python.org/issue10204
            contents += "\n"
        exec(contents, globals, globals)

De plus, bien qu'il ne s'agisse pas d'une solution Python pure, si vous utilisez IPython (comme vous le devriez probablement de toute façon), vous pouvez faire:

%run /path/to/filename.py

Ce qui est tout aussi simple.

Je suis juste un débutant ici, alors c'est peut-être de la chance si je trouve ça:

Après avoir essayé d'exécuter un script à partir de l'invite d'interpréteur >>> avec la commande

    execfile('filename.py')

pour lequel j'ai obtenu un "NameError: le nom 'execfile' n'est pas défini" J'ai essayé un très basique

    import filename

cela a bien fonctionné :-)

J'espère que cela peut être utile et merci à tous pour les excellents conseils, exemples et tous ces morceaux de code magistralement commentés qui sont une grande inspiration pour les nouveaux arrivants!

J'utilise Ubuntu 16.014 LTS x64. Python 3.5.2 (par défaut, 17 novembre 2016, 17:05:23) [GCC 5.4.0 20160609] sur linux

Pour moi, l'approche la plus propre est d'utiliser importlibet d'importer le fichier en tant que module par chemin, comme ceci:

from importlib import util

def load_file(name, path):
    spec = util.spec_from_file_location(name, path)
    module = util.module_from_spec(spec)
    spec.loader.exec_module(module)
    return module

Exemple d'utilisation

Ayons un fichier foo.py:

print('i got imported')
def hello():
    print('hello from foo')

Maintenant, importez-le et utilisez-le comme un module normal:

>>> foo = load_file('foo', './foo.py')
i got imported
>>> foo.hello()
hello from foo

Je préfère cette technique aux approches directes comme exec(open(...))parce qu'elle n'encombre pas vos espaces de noms ou ne gâche pas inutilement $PATH.