Jaka jest alternatywa dla pliku wykonywalnego w Pythonie 3?

Wygląda na to, że anulowali w Pythonie 3 najłatwiejszy sposób szybkiego załadowania skryptu poprzez usunięcie execfile()

Czy brakuje mi oczywistej alternatywy?

Zgodnie z dokumentacją zamiast

execfile("./filename") 

Posługiwać się

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

Widzieć:

• Co nowego w Python 3.0

Po prostu powinieneś przeczytać plik i sam wykonać kod. Prąd 2to3 zastępuje

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

tak jak

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

(Wywołanie kompilacji nie jest absolutnie potrzebne, ale wiąże nazwę pliku z obiektem kodu, co ułatwia debugowanie).

Widzieć:

• 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

Chociaż exec(open("filename").read())jest często podawany jako alternatywa dla execfile("filename"), brakuje ważnych szczegółów, które były execfileobsługiwane.

Poniższa funkcja dla Python3.x jest tak bliska, jak mogłem mieć takie samo zachowanie, jak bezpośrednie uruchamianie pliku. To pasuje do biegania 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")

Uwagi:

• Korzysta z odczytu binarnego, aby uniknąć problemów z kodowaniem
• Gwarantujemy zamknięcie pliku (Python3.x ostrzega przed tym)
• Definiuje __main__, że niektóre skrypty zależą od tego, czy sprawdzają, czy ładują się jako moduł, czy nie, np.if __name__ == "__main__"
• Ustawienie __file__jest lepsze dla komunikatów wyjątków, a niektóre skrypty używają __file__do uzyskania ścieżek innych plików względem nich.

• Pobiera opcjonalne argumenty globals i locals, modyfikując je w miejscu, tak jak to execfilerobi - abyś mógł uzyskać dostęp do dowolnych zdefiniowanych zmiennych poprzez odczytywanie zmiennych po uruchomieniu.

• W przeciwieństwie python2 jest execfileto nie nie zmodyfikować obecną nazw domyślnie. W tym celu musisz jawnie przekazać globals()& locals().

Jak zasugerowano ostatnio na liście mailingowej python-dev , moduł Runpy może być realną alternatywą. Cytując z tej wiadomości:

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

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

Istnieją subtelne różnice w execfile:

• run_pathzawsze tworzy nową przestrzeń nazw. Wykonuje kod jako moduł, więc nie ma różnicy między globalnymi a lokalnymi (dlatego jest tylko init_globalsargument). Globały są zwracane.

  execfilewykonywane w bieżącej przestrzeni nazw lub w podanej przestrzeni nazw. Semantyka localsi globals, jeśli podano, była podobna do miejscowej i globalnej w definicji klasy.

• run_path może nie tylko wykonywać pliki, ale także jajka i katalogi (szczegółowe informacje można znaleźć w jego dokumentacji).

Ten jest lepszy, ponieważ pobiera globalne i lokalne od dzwoniącego:

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)

Możesz napisać własną funkcję:

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

Jeśli naprawdę potrzebujesz ...

Jeśli skrypt, który chcesz załadować, znajduje się w tym samym katalogu, co uruchomiony, być może „import” wykona zadanie?

Jeśli potrzebujesz dynamicznie importować kod, warto przyjrzeć się wbudowanej funkcji __ import__ i imp modułu .

>>> 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!"

Jeśli używasz języka Python 3.1 lub nowszego, powinieneś także zajrzeć na importlib .

Oto, co miałem ( filejest już przypisany do ścieżki do pliku z kodem źródłowym w obu przykładach):

execfile(file)

Oto, co zastąpiłem:

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

Moja ulubiona część: druga wersja działa dobrze zarówno w Pythonie 2, jak i 3, co oznacza, że ​​nie trzeba dodawać logiki zależnej od wersji.

Zauważ, że powyższy wzór nie powiedzie się, jeśli używasz deklaracji kodowania PEP-263, które nie są ascii ani utf-8. Musisz znaleźć kodowanie danych i zakodować je poprawnie przed przekazaniem go do 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)

Ponadto, mimo że nie jest to czyste rozwiązanie w języku Python, jeśli używasz IPython (jak i tak prawdopodobnie powinieneś), możesz:

%run /path/to/filename.py

Co jest równie łatwe.

Jestem tu tylko nowicjuszem, więc może to szczęście, gdybym to znalazł:

Po próbie uruchomienia skryptu z wiersza interpretera >>> za pomocą polecenia

    execfile('filename.py')

dla którego dostałem „NameError: nazwa„ plik wykonywalny ”nie jest zdefiniowana” Próbowałem bardzo prosty

    import filename

działało dobrze :-)

Mam nadzieję, że to może być pomocne i dziękuję wszystkim za wspaniałe wskazówki, przykłady i wszystkie te mistrzowsko skomentowane fragmenty kodu, które są wielką inspiracją dla początkujących!

Używam Ubuntu 16.014 LTS x64. Python 3.5.2 (domyślnie, 17 listopada 2016, 17:05:23) [GCC 5.4.0 20160609] w systemie Linux

Dla mnie najczystszym podejściem jest użycie importlibi zaimportowanie pliku jako modułu według ścieżki:

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

Przykład użycia

Zróbmy plik foo.py:

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

Teraz wystarczy zaimportować i używać go jak zwykłego modułu:

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

Wolę tę technikę od bezpośrednich podejść, takich jak, exec(open(...))ponieważ nie zaśmieca ona twoich przestrzeni nazw lub niepotrzebnie z nimi nie zadziera $PATH.