Python Language
Importera moduler

Syntax

• importera modulnamn
• import module_name.submodule_name
• från modulnamnimport *
• från module_name importera submodule_name [, class_name , function_name , ... etc]
• från module_name importera some_name som new_name
• från module_name.submodule_name import class_name [, function_name , ... etc]

Anmärkningar

Importera en modul

Använd import :

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

import module importerar en modul och låter dig sedan referera till dess objekt - värden, funktioner och klasser, till exempel - med hjälp av syntaxen module.name . I exemplet ovan importeras den random modulen, som innehåller randint funktionen. Så genom att importera random du ringa randint med random.randint .

Du kan importera en modul och tilldela den till ett annat namn:

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

Om din python-fil main.py finns i samma mapp som custom.py . Du kan importera det så här:

import custom

Det är också möjligt att importera en funktion från en modul:

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

Importera specifika funktioner djupare ner i en modul, kan punktoperatorn endast användas på vänster sida av import sökord:

from urllib.request import urlopen

I python har vi två sätt att kalla funktion från toppnivå. En är import och en annan from . Vi bör använda import när vi har möjlighet till namnkollision. Anta att vi har hello.py filer och world.py filer med samma funktion som heter function . Då kommer import att fungera bra.

from hello import function
from world import function

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

I allmänhet kommer import att ge dig ett namnutrymme.

import hello
import world

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

Men om du är säker nog, finns det inget sätt i hela ditt projekt med samma funktionsnamn som du bör använda from uttalandet

Flera import kan göras på samma linje:

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

Nyckelorden och syntaxen som visas ovan kan också användas i kombinationer:

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

Importera specifika namn från en modul

Istället för att importera hela modulen kan du importera endast angivna namn:

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

from random behövs, eftersom pytontolkaren måste veta från vilken resurs den ska importera en funktion eller klass och import randint specificerar själva funktionen eller klassen.

Ett annat exempel nedan (liknande det ovan):

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

Följande exempel tar upp ett fel eftersom vi inte har importerat en modul:

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

utgångar:

NameError: name 'random' is not defined

Pytontolkaren förstår inte vad du menar med random . Det måste deklareras genom att lägga till import random till exemplet:

import random
random.randrange(1, 10)

Importerar alla namn från en modul

from module_name import *

till exempel:

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

Detta kommer att importera alla namn som definieras i math till det globala namnområdet, utom namn som börjar med en understruk (vilket indikerar att författaren känner att den endast är för internt bruk).

Varning : Om en funktion med samma namn redan har definierats eller importerats kommer den att skrivas över . Nästan alltid importerar bara specifika namn from math import sqrt, ceil det rekommenderade sättet :

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

Stjärninimport är endast tillåten på modulnivå. Försök att utföra dem i klass- eller funktionsdefinitioner resulterar i en SyntaxError .

def f():
    from math import *

och

class A:
    from math import *

båda misslyckas med:

SyntaxError: import * only allowed at module level

Specialvariabeln __all__

Moduler kan ha en speciell variabel med namnet __all__ att begränsa vilka variabler som importeras när de använder from mymodule import * .

Följande modul:

# mymodule.py

__all__ = ['imported_by_star']

imported_by_star = 42
not_imported_by_star = 21

Endast imported_by_star importeras när man använder 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 emellertid importeras uttryckligen:

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

Programmatisk import

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

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

För äldre versioner av Python, använd imp modulen.

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

Använd INTE __import__() att programmatiskt importera moduler! Det finns subtila detaljer som involverar sys.modules , från fromlist argumentet etc. som är lätta att förbise vilket importlib.import_module() hanterar åt dig.

Importera moduler från en godtycklig filsystemplats

Om du vill importera en modul som inte redan finns som en inbyggd modul i Python Standardbiblioteket eller som sidopaket, kan du göra det genom att lägga till sökvägen till katalogen där din modul hittas i sys.path . Detta kan vara användbart när flera pythonmiljöer finns på en värd.

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

Det är viktigt att du lägger till sökvägen till den katalog som mymodule finns i, inte vägen till själva modulen.

PEP8-regler för import

Några rekommenderade PEP8- stilriktlinjer för import:

1. Importen bör ske på olika linjer:

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

2. Beställ import enligt följande överst i modulen:

   • Standardbibliotekimport
   • Närstående tredjepartsimport
   • Lokal import / biblioteksspecifik import

3. Import av jokertecken bör undvikas eftersom det leder till förvirring i namn i det nuvarande namnområdet. Om du gör from module import * kan det vara oklart om ett specifikt namn i din kod kommer från module eller inte. Detta är dubbelt sant om du har flera from module import * -typsatser.

4. Undvik att använda relativ import; använd uttrycklig import istället.

Importerar undermoduler

from module.submodule import function

Denna import function från module.submodule .

__import __ () -funktion

__import__() kan användas för att importera moduler där namnet endast är känt vid körning

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

# equivalent to import os

Denna funktion kan också användas för att specificera filvägen till en modul

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

Importera en modul igen

När du använder den interaktiva tolkaren kanske du vill ladda om en modul. Det kan vara användbart om du redigerar en modul och vill importera den senaste versionen, eller om du har apat-patched ett element i en befintlig modul och vill återställa dina ändringar.

Observera att du inte bara kan import modulen igen för att återställa:

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

Detta beror på att tolkar registrerar varje modul du importerar. Och när du försöker återimportera en modul ser tolken den i registret och gör ingenting. Så det svåra sättet att återimportera är att använda import efter att ha tagit bort motsvarande objekt från registret:

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

Men det finns mer ett enkelt och enkelt sätt.

Python 2

Använd reload :

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

Python 3

reload funktionen har flyttats till importlib :

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