Python Language
Modules importeren

Syntaxis

• moduulnaam importeren
• import module_naam.submodule_naam
• van module_naam import *
• van module_naam import submodule_naam [, class_name , function_name , ... etc]
• van module_name invoer some_name als NEW_NAME
• van module_name.submodule_name invoer class_name [, function_name, ... etc]

Opmerkingen

Module importeren

Gebruik de import :

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

import module importeert een module en laat u vervolgens verwijzen naar de objecten - waarden, functies en klassen bijvoorbeeld - met behulp van de syntaxis van module.name . In het bovenstaande voorbeeld wordt de random module geïmporteerd, die de randint functie bevat. Dus door random importeren kun je randint met random.randint .

U kunt een module importeren en aan een andere naam toewijzen:

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

Als uw python-bestand main.py zich in dezelfde map bevindt als custom.py . Je kunt het als volgt importeren:

import custom

Het is ook mogelijk om een functie uit een module te importeren:

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

Om specifieke functies dieper in een module te importeren, mag de puntoperator alleen aan de linkerkant van het import worden gebruikt:

from urllib.request import urlopen

In python hebben we twee manieren om functie vanaf het hoogste niveau aan te roepen. Een daarvan is import en een andere is from . We moeten import wanneer we een mogelijkheid hebben om naamsbotsingen te voorkomen. Stel dat we hello.py bestanden en world.py bestanden hebben met dezelfde functie genaamd function . Dan zal de import goed werken.

from hello import function
from world import function

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

In het algemeen geeft import u een naamruimte.

import hello
import world

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

Maar als u zeker genoeg bent, is er in uw hele project geen manier om dezelfde functienaam te gebruiken die u from instructie moet gebruiken

Meerdere import kan op dezelfde regel worden uitgevoerd:

>>> # 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

De bovenstaande zoekwoorden en syntaxis kunnen ook in combinaties worden gebruikt:

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

Specifieke namen uit een module importeren

In plaats van de volledige module te importeren, kunt u alleen opgegeven namen importeren:

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

from random is nodig, omdat de python-interpreter moet weten uit welke bron hij een functie of klasse moet importeren en import randint specificeert de functie of klasse zelf.

Nog een voorbeeld hieronder (vergelijkbaar met het bovenstaande):

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

Het volgende voorbeeld zal een fout veroorzaken, omdat we geen module hebben geïmporteerd:

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

uitgangen:

NameError: name 'random' is not defined

De python-interpreter begrijpt niet wat u met random bedoelt. Het moet worden aangegeven door import random te voegen aan het voorbeeld:

import random
random.randrange(1, 10)

Alle namen uit een module importeren

from module_name import *

bijvoorbeeld:

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

Hiermee worden alle namen geïmporteerd die in de math gedefinieerd in de globale naamruimte, behalve de namen die beginnen met een onderstrepingsteken (wat aangeeft dat de schrijver denkt dat het alleen voor intern gebruik is).

Waarschuwing : als een functie met dezelfde naam al is gedefinieerd of geïmporteerd, wordt deze overschreven . Bijna altijd het importeren van alleen specifieke namen from math import sqrt, ceil is de aanbevolen manier :

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

Import met ster is alleen toegestaan op moduleniveau. Pogingen om ze uit te voeren in klasse- of functiedefinities resulteren in een SyntaxError .

def f():
    from math import *

en

class A:
    from math import *

beide falen met:

SyntaxError: import * only allowed at module level

De speciale variabele __all__

Modules kunnen een speciale variabele met de naam __all__ om te beperken welke variabelen worden geïmporteerd bij gebruik from mymodule import * .

Gegeven de volgende module:

# mymodule.py

__all__ = ['imported_by_star']

imported_by_star = 42
not_imported_by_star = 21

Alleen imported_by_star wordt geïmporteerd bij gebruik 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

not_imported_by_star kan echter expliciet worden geïmporteerd:

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

Programmatisch importeren

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

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

Gebruik voor oudere versies van Python de imp module.

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()

Gebruik __import__() NIET om programmatisch modules te importeren! Er zijn subtiele details met betrekking tot sys.modules , het fromlist argument, enz. Die gemakkelijk te overzien zijn welke importlib.import_module() voor u afhandelt.

Importeer modules van een willekeurige bestandssysteemlocatie

Als u een module wilt importeren die nog niet bestaat als een ingebouwde module in de Python Standard Library of als een nevenpakket, kunt u dit doen door het pad toe te voegen aan de map waar uw module zich bevindt in sys.path . Dit kan handig zijn als er meerdere python-omgevingen op een host aanwezig zijn.

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

Het is belangrijk dat u het pad mymodule aan de map waarin mymodule wordt gevonden, niet het pad naar de module zelf.

PEP8-regels voor import

Enkele aanbevolen PEP8- stijlrichtlijnen voor import:

1. De invoer moet op afzonderlijke regels gebeuren:

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

2. Bestel invoer als volgt bovenaan de module:

   • Standaard bibliotheekimport
   • Gerelateerde invoer door derden
   • Lokale toepassing / bibliotheek-specifieke invoer

3. Het importeren van jokertekens moet worden vermeden, omdat dit tot verwarring in namen in de huidige naamruimte leidt. Als u dit doet from module import * , kan het onduidelijk zijn of een specifieke naam in uw code afkomstig is van de module of niet. Dit is dubbel waar als u meerdere instructies van het type from module import * .

4. Vermijd relatieve invoer; gebruik in plaats daarvan expliciete invoer.

Submodules importeren

from module.submodule import function

Dit importeert function uit module.submodule .

__import __ () functie

De functie __import__() kan worden gebruikt om modules te importeren waarvan de naam alleen bekend is tijdens runtime

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

# equivalent to import os

Deze functie kan ook worden gebruikt om het bestandspad naar een module op te geven

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

Een module opnieuw importeren

Wanneer u de interactieve tolk gebruikt, wilt u misschien een module opnieuw laden. Dit kan handig zijn als u een module bewerkt en de nieuwste versie wilt importeren, of als u een element van een bestaande module hebt gepatcht en uw wijzigingen wilt terugdraaien.

Merk op dat je de module niet zomaar opnieuw kunt import om terug te zetten:

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

Dit komt omdat de tolk elke module registreert die u importeert. En wanneer u probeert een module opnieuw te importeren, ziet de tolk deze in het register en doet niets. Dus de moeilijke manier om opnieuw te importeren is door import te gebruiken nadat het overeenkomstige item uit het register is verwijderd:

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

Maar er is meer een eenvoudige en eenvoudige manier.

Python 2

Gebruik de reload :

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

Python 3

De reload is verplaatst naar importlib :

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