Python Language
Importowanie modułów

Składnia

• import nazwa_modułu
• import nazwa_modułu.submodule_name
• z importu nazwa_modułu *
• od Nazwa_modułu importu submodule_name [, CLASS_NAME, Nazwa_funkcji, ... itd]
• od Nazwa_modułu importu some_name jako NEW_NAME
• od module_name.submodule_name importu CLASS_NAME [, Nazwa_funkcji, ... itd]

Uwagi

Importowanie modułu

Użyj instrukcji import :

>>> import random
>>> print(random.randint(1, 10))
4

import module importu zaimportuje moduł, a następnie umożliwi odwołanie się do jego obiektów - na przykład wartości, funkcji i klas - przy użyciu składni module.name . W powyższym przykładzie random moduł jest importowany, który zawiera funkcję randint . Importując random , możesz wywołać randint pomocą random.randint .

Możesz zaimportować moduł i przypisać go do innej nazwy:

>>> import random as rn
>>> print(rn.randint(1, 10))
4

Jeśli plik main.py znajduje się w tym samym folderze co custom.py . Możesz go zaimportować w następujący sposób:

import custom

Możliwe jest również zaimportowanie funkcji z modułu:

>>> from math import sin
>>> sin(1)
0.8414709848078965

Aby zaimportować określone funkcje głębiej do modułu, operator kropki może być używany tylko po lewej stronie słowa kluczowego import :

from urllib.request import urlopen

W Pythonie mamy dwa sposoby na wywołanie funkcji z najwyższego poziomu. Jeden jest import a drugi pochodzi from . Powinniśmy użyć import gdy mamy możliwość kolizji nazw. Załóżmy, że mamy pliki hello.py i world.py o tej samej funkcji o nazwie function . Wtedy instrukcja import będzie działać dobrze.

from hello import function
from world import function

function() #world's function will be invoked. Not hello's  

Ogólnie rzecz biorąc, import zapewni ci przestrzeń nazw.

import hello
import world

hello.function() # exclusively hello's function will be invoked 
world.function() # exclusively world's function will be invoked

Ale jeśli jesteś tego pewien, w całym projekcie nie ma takiej samej nazwy funkcji, której powinieneś użyć from instrukcji

W tym samym wierszu można wykonać wiele importów:

>>> # Multiple modules
>>> import time, sockets, random
>>> # Multiple functions
>>> from math import sin, cos, tan
>>> # Multiple constants
>>> from math import pi, e

>>> print(pi)
3.141592653589793
>>> print(cos(45))
0.5253219888177297
>>> print(time.time())
1482807222.7240417

Słowa kluczowe i składnia przedstawione powyżej mogą być również używane w kombinacjach:

>>> from urllib.request import urlopen as geturl, pathname2url as path2url, getproxies
>>> from math import factorial as fact, gamma, atan as arctan
>>> import random.randint, time, sys

>>> print(time.time())
1482807222.7240417
>>> print(arctan(60))
1.554131203080956
>>> filepath = "/dogs/jumping poodle (december).png"
>>> print(path2url(filepath))
/dogs/jumping%20poodle%20%28december%29.png

Importowanie określonych nazw z modułu

Zamiast importować cały moduł, możesz importować tylko określone nazwy:

from random import randint # Syntax "from MODULENAME import NAME1[, NAME2[, ...]]"
print(randint(1, 10))      # Out: 5

from random jest potrzebne, ponieważ interpreter Pythona musi wiedzieć, z którego zasobu powinien zaimportować funkcję lub klasę, a import randint określa funkcję lub klasę.

Kolejny przykład poniżej (podobny do powyższego):

from math import pi
print(pi)                  # Out: 3.14159265359

Poniższy przykład zgłosi błąd, ponieważ nie zaimportowaliśmy modułu:

random.randrange(1, 10)    # works only if "import random" has been run before

Wyjścia:

NameError: name 'random' is not defined

Interpretator python nie rozumie, co masz na myśli przez random . Należy to zadeklarować, dodając import random do przykładu:

import random
random.randrange(1, 10)

Importowanie wszystkich nazw z modułu

from module_name import *

na przykład:

from math import *
sqrt(2)    # instead of math.sqrt(2)
ceil(2.7)  # instead of math.ceil(2.7)

Spowoduje to zaimportowanie wszystkich nazw zdefiniowanych w module math do globalnej przestrzeni nazw, innych niż nazwy rozpoczynające się znakiem podkreślenia (co oznacza, że pisarz uważa, że jest on wyłącznie do użytku wewnętrznego).

Ostrzeżenie : jeśli funkcja o tej samej nazwie została już zdefiniowana lub zaimportowana, zostanie zastąpiona . Prawie zawsze importując tylko określone nazwy from math import sqrt, ceil jest zalecanym sposobem :

def sqrt(num):
    print("I don't know what's the square root of {}.".format(num))

sqrt(4)
# Output: I don't know what's the square root of 4.

from math import * 
sqrt(4)
# Output: 2.0

Importowanie z gwiazdką jest dozwolone tylko na poziomie modułu. Próby wykonania ich w definicjach klas lub funkcji powodują błąd SyntaxError .

def f():
    from math import *

i

class A:
    from math import *

oba kończą się niepowodzeniem z:

SyntaxError: import * only allowed at module level

Zmienna specjalna __all__

Moduły mogą mieć specjalną zmienną o nazwie __all__ aby ograniczyć to, które zmienne są importowane podczas korzystania from mymodule import * .

Biorąc pod uwagę następujący moduł:

# mymodule.py

__all__ = ['imported_by_star']

imported_by_star = 42
not_imported_by_star = 21

Tylko imported_by_star jest importowany przy korzystaniu from mymodule import * :

>>> from mymodule import *
>>> imported_by_star
42
>>> not_imported_by_star
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'not_imported_by_star' is not defined

Jednak not_imported_by_star można importować jawnie:

>>> from mymodule import not_imported_by_star
>>> not_imported_by_star
21

Programowe importowanie

import importlib
random = importlib.import_module("random")

collections_abc = importlib.import_module("collections.abc")

W przypadku starszych wersji Pythona użyj modułu imp .

import imp, sys
def import_module(name):
    fp, pathname, description = imp.find_module(name)
    try:
        return imp.load_module(name, fp, pathname, description)
    finally:
        if fp:
            fp.close()

NIE używaj __import__() do programowego importowania modułów! Istnieją subtelne szczegóły dotyczące sys.modules , argumentu fromlist itp., fromlist łatwo przeoczyć, które obsługuje importlib.import_module() .

Importuj moduły z dowolnej lokalizacji systemu plików

Jeśli chcesz zaimportować moduł, który jeszcze nie istnieje jako moduł wbudowany w Bibliotece standardowej Python ani jako pakiet boczny, możesz to zrobić, dodając ścieżkę do katalogu, w którym znajduje się moduł sys.path Może to być przydatne, gdy na hoście istnieje wiele środowisk Python.

import sys
sys.path.append("/path/to/directory/containing/your/module")
import mymodule

Ważne jest, aby dołączyć ścieżkę do katalogu, w którym znajduje się mymodule , a nie ścieżkę do samego modułu.

Reguły PEP8 dla importów

Niektóre zalecane wytyczne w stylu PEP8 dotyczące importu:

1. Import powinien odbywać się w osobnych wierszach:

    from math import sqrt, ceil      # Not recommended
    from math import sqrt            # Recommended
    from math import ceil
   

2. Zamów import w następujący sposób u góry modułu:

   • Standardowy import biblioteki
   • Powiązany import stron trzecich
   • Lokalne importy specyficzne dla aplikacji / biblioteki

3. Należy unikać importowania symboli wieloznacznych, ponieważ prowadzi to do pomyłek w nazwach w bieżącej przestrzeni nazw. Jeśli robisz to from module import * , może być niejasne, czy konkretna nazwa w kodzie pochodzi od module czy nie. Jest to podwójnie prawdziwe, jeśli masz wiele instrukcji from module import * typu from module import * .

4. Unikaj korzystania z importu względnego; zamiast tego użyj jawnego importu.

Importowanie submodułów

from module.submodule import function

Ta function importuje z module.submodule .

Funkcja __import __ ()

Za __import__() funkcji __import__() można importować moduły, których nazwa jest znana tylko w czasie wykonywania

if user_input == "os":
    os = __import__("os")

# equivalent to import os

Tej funkcji można również użyć do określenia ścieżki pliku do modułu

mod = __import__(r"C:/path/to/file/anywhere/on/computer/module.py")

Ponowny import modułu

Korzystając z interaktywnego interpretera, możesz chcieć ponownie załadować moduł. Może to być przydatne, jeśli edytujesz moduł i chcesz zaimportować najnowszą wersję lub jeśli załatałeś małpy element istniejącego modułu i chcesz przywrócić zmiany.

Pamiętaj, że nie możesz po prostu ponownie import modułu, aby przywrócić:

import math
math.pi = 3
print(math.pi)    # 3
import math
print(math.pi)    # 3

Wynika to z faktu, że interpreter rejestruje każdy importowany moduł. A kiedy próbujesz ponownie zaimportować moduł, tłumacz widzi go w rejestrze i nic nie robi. Tak więc trudnym sposobem na ponowny import jest użycie import po usunięciu odpowiedniego elementu z rejestru:

print(math.pi)    # 3
import sys
if 'math' in sys.modules:  # Is the ``math`` module in the register?
    del sys.modules['math']  # If so, remove it.
import math
print(math.pi)    # 3.141592653589793

Ale jest więcej prosty i prosty sposób.

Python 2

Użyj funkcji reload :

import math
math.pi = 3
print(math.pi)    # 3
reload(math)
print(math.pi)    # 3.141592653589793

Python 3

Funkcja reload została przeniesiona do importlib :

import math
math.pi = 3
print(math.pi)    # 3
from importlib import reload
reload(math)
print(math.pi)    # 3.141592653589793