' modul importálása ' vs. ' a modul importfunkciójából '

A modul importálása nem pazarolja el a semmit ; a modul mindig teljesen importálva (a sys.modules leképezésbe), tehát a import sys vagy a from sys import argv nincs esély.

A két állítás között csak az a különbség, hogy mi a név kötött; import sys megköti a sys a modulhoz (tehát sys -> sys.modules["sys"]), míg az from sys import argv köt egy másik név, argv, amely egyenesen a modulban található attribútumra mutat (tehát argv -> sys.modules["sys"].argv). A többi th Az e sys modul még mindig ott van, függetlenül attól, hogy használ-e bármi mást a modulból, vagy sem.

A két megközelítés között szintén nincs teljesítménybeli különbség. Igen, sys.argv két dolgot kell utánanéznie; meg kell keresnie a sys -t a globális névtérben (megtalálja a modult), majd meg kell keresnie az argv attribútumot. És igen, a from sys import argv használatával kihagyhatja az attribútumkeresést, mivel már van közvetlen hivatkozása az attribútumra. De a import utasításnak még mindig ezt a munkát kell végeznie, importáláskor ugyanazt az attribútumot keresi, és csak akkor kell használnia a argv egyszer . Ha a ciklusban ezerszer használnod kell az argv t, az talán változást hozhat, de ebben a konkrét esetben valóban nem .

Ekkor az egyik vagy a másik közötti választás helyett a kódolási stílus t kell alapulnia.

Egy nagy modulban , Minden bizonnyal import sys; a kóddokumentáció számít, és az sys.argv használata valahol egy nagy modulban sokkal világosabbá teszi, hogy mire hivatkozik, mint csak argv valaha.

Ha az egyetlen hely, amelyet argv használ, egy "__main__" blokkban található, hogy felhívhasson egy main() függvény, mindenképpen használja a from sys import argv szolgáltatást, ha ennek jobban örül:

if __name__ == "__main__": from sys import argv main(argv) 

I “d még mindig használom import sys ott magam. Minden dolog egyenlő (és pontosan a teljesítmény szempontjából és az íráshoz használt karakterek száma) , ez a szememre nézve könnyebb.

Ha valami mást importál, akkor talán a teljesítmény játszik szerepet. De csak akkor, ha egy adott nevet használsz egy modul sokszor , például egy kritikus ciklusban. De akkor egy helyi név (egy függvényen belül) létrehozása még mindig gyorsabb lesz:

 import somemodule def somefunction(): localname = somemodule.somefunctionorother while test: # huge, critical loop foo = localname(bar) 

Megjegyzések

• Előfordulhat olyan helyzet is, amikor van olyan csomagod, amely alcsomagokat vagy modulokat tartalmaz, és amely a legfelső szintű csomagban található egyik ilyen alcsomag / modul egyik attribútumát tárja fel. A from...import használata lehetővé teszi, hogy package.attribute helyett package.subpackage_or_module.attribute tegye, ami hasznos lehet, ha logikai vagy fogalmi csoportosításokat tartalmazzon a csomagban, de szeretné kicsit kényelmesebbé tenni a csomag felhasználói számára. (numpy ilyesmit csinál, azt hiszem.)
• A djangóban rengeteg folt van, ahol például from django.core.management.base import BaseCommand jobbak, és bármi más (különösen import django) olvashatatlan kódhoz vezetne. Tehát bár tetszik ez a válasz, azt hiszem, vannak olyan könyvtárak (és különösen néhány keretrendszer), amelyekben az egyezmény sérti a csupasz importot.Mint mindig, használja megítélését arról, hogy mi a legjobb az adott helyzetben. De tévedjen az explicit oldalon (más szóval többnyire egyetértek).
• @JAB: akkor is használhatja a import ... as -t a csomag megtalálásához egy másik név: import package.subpackage_or_module as shortname. from parent import sub lényegében ugyanazt csinálja.
• so wether you use import sys or from sys import argv makes no odds úgy tűnik, hogy ez nem így van az IDLE esetében. csak a modul importálása nem importálja a függvényeit, és csak az < modul > segítségével hívhatom meg az IDLE shellben. < function > név
• @Suncatcher: olvassa el teljes egészében a válaszomat. Az idézett mondat arról beszél, hogy mennyit importálnak, és nem arról, hogy milyen név van kötve. Ezt ‘ máshol is lefedik a válaszban.

Két oka van annak, hogy a import module -t használja a from module import function helyett.

Az első a névtér. A függvény globális névtérbe történő importálása a névütközések kockázatát jelentheti.

A második nem a szabványos modulok szempontjából releváns, de az Ön számára fontos, különösen a fejlesztés során. Ez a lehetőség reload() modul. Fontolja meg ezt:

from module import func ... reload(module) # func still points to the old code 

Másrészt

import module ... reload(module) # module.func points to the new code 

Ami a sebességet illeti .. .

csak a szükséges funkciót importáljuk, ahelyett, hogy a teljes modult importálnánk (amely több haszontalan függvényt tartalmaz, amelyek a python elvesztegetni fogja az idejét az importálásukkal) / p>

Akár importál egy modult, akár egy függvényt importál egy modulból, a Python elemzi az egész modult. Bármelyik módon is importálja a modult. A “függvény importálása” nem más, mint a függvény névhez kötése. Valójában a import module kevesebb munka a tolmács számára, mint a from module import func.

Megjegyzések

• a reload () a Python 2 beépített része volt; ez már nem a Python 3 esetében van.
• Úgy gondoltam, hogy a körkörös importfüggőségekkel is összefüggések vannak?

A from import s elemeket mindig használom, amikor javítja az olvashatóságot. Például jobban szeretem (a pontosvesszők itt csak helyet takarítanak meg):

from collections import defaultdict from foomodule import FooBar, FooBaz from twisted.internet.protocol import Factory defaultdict(); FooBar(); FooBaz(); Factory() 

a következő helyett:

import collections import foomodule import twisted.internet.protocol collections.defaultdict(); foomodule.FooBar(); foomodule.FooBaz() twisted.internet.protocol.Factory() 

Ez utóbbi számomra nehezebben olvasható (és írható), mert annyi felesleges információt tartalmaz. Hasznos idő előtt tudni, hogy a modul mely részeit használom.

Inkább a rendszeres import seket kedvelem, ha sokakat használok rövid nevek egy modulból:

import sys sys.argv; sys.stderr; sys.exit() 

Vagy ha egy név annyira általános, hogy nincs értelme a névterén kívül:

import json json.loads(foo) from json import loads loads(foo) # potentially confusing 

Megjegyzések

• Ez a kedvenc válaszom. A ‘ Az explicit jobb, mint az implicit. A ‘ néha ütközik az olvashatósággal, az egyszerűséggel és a SZÁRAZSAL. Különösen akkor, ha olyan keretrendszert használunk, mint a Django.

Véleményem szerint a rendszeres import javítja az olvashatóságot. A Python-kód áttekintésekor szívesen látom, hogy az adott függvény vagy osztály honnan származik ott, ahol használják. Megtakarít, hogy a modul tetejére görgessem ezeket az információkat.

Ami a hosszú modulneveket illeti, csak a as kulcsszót használom, és rövidet adok nekik. álnevek:

import collections as col import foomodule as foo import twisted.internet.protocol as twip my_dict = col.defaultdict() foo.FooBar() twip_fac = twip.Factory() 

Kivételként mindig a from module import something jelölést használom, amikor a __future__ modul. Csak nem teheti meg más módon, ha azt szeretné, hogy az összes karakterlánc alapértelmezés szerint unicode legyen a Python 2-ben, pl.

from __future__ import unicode_literals from __future__ import print_function 

Megjegyzések

• Ámen! ” import, mivel ” nyerő kombináció 🙂

Bár import sys és from sys import agrv mindkettő a teljes sys modult importálja, utóbbi névkötést használ, így csak a argv modul érhető el a kód többi részéhez.

Néhány ember számára ez lenne az előnyben részesített stílus, mivel csak az Ön által kifejezetten megadott funkciót teszi elérhetővé.

Ez azonban potenciális névütközéseket hoz létre. Mi lenne, ha lenne egy másik modulja, neve argv? Ne feledje, hogy a függvényt kifejezetten importálhatja és átnevezheti a from sys import argv as sys_argv névvel is, amely egyezmény megfelel a kifejezett importálásnak, és kevésbé valószínű, hogy adjon névteret ütközések.

Megjegyzések

• Tehát if sys_argv: hogyan jobb mint if sys.argv:? Tudom, mit jelent a második állítás, fogalmam sincs, mit jelent az első forma, anélkül, hogy visszalépnék a bizarr importhoz.

Nemrég tettem fel magamnak ezt a kérdést. Időzítettem a különböző módszereket.

könyvtárat kér

def r(): import requests return "hello" timeit r() # output: 1000000 loops, best of 3: 1.55 µs per loop def rg(): from requests import get return "hello" timeit rg() # output: 100000 loops, best of 3: 2.53 µs per loop 

beautifulsoup könyvtár

def bs(): import bs4 return "hello" timeit bs() # output: 1000000 loops, best of 3: 1.53 µs per loop def be(): from bs4 import BeautifulSoup return "hello" timeit be() # output: 100000 loops, best of 3: 2.59 µs per loop 

json könyvtár

def js(): import json return "hello" timeit js() # output: 1000000 loops, best of 3: 1.53 µs per loop def jl(): from json import loads return "hello" timeit jl() # output: 100000 loops, best of 3: 2.56 µs per loop 

sys könyvtár

def s(): import sys return "hello" timeit s() # output: 1000000 loops, best of 3: 1.55 µs per loop def ar(): from sys import argv return "hello" timeit ar() # output: 100000 loops, best of 3: 2.87 µs per loop 

Úgy tűnik, hogy nekem, hogy van egy kis különbség a teljesítményben.

Megjegyzések

• Hozzáad egy attribútumkereséshez. A import module és a from module import name megfelelő összehasonlításához adja hozzá ezt a névkeresést a import module eset. Például. adja hozzá a sys.argv sort a ar teszthez stb. Még mindig lesz különbség, mert az elvégzett munka kissé más, mivel különböző byte-kód generálódik és különböző kódutak futtatásra kerülnek.
• Ne feledje, hogy a válaszomban közvetlenül foglalkozom ezzel a különbséggel; különbség lesz a import sys, majd a ciklusban az sys.argv több ezer idő és a from sys import argv, majd csak a argv parancsot használja. De nem ‘ t. Olyan dolgok miatt, amelyeket csak egyszer tesz a modul globális szintjén, valóban az olvashatóságra kell optimalizálnia, nem pedig az időzítés mikroszkopikus különbségeire.
• Ahhhh! És azt hittem, valamivel foglalkozom! 🙂 Csak a válaszodat soványítottam el. Úgy tűnik, hogy ráugrottam a fegyverre. Jólesik, ha megalázkodunk.

A közzétett kódrészletek megtekintése, teljes modulok importálása és a module.function nagyjából a szabvány, legalábbis a standard modulok esetében. Az egyetlen kivétel úgy tűnik, hogy datetime

from datetime import datetime, timedelta 

, így mondhatja: datetime.now() helyett datetime.datetime.now().

Ha aggódsz a teljesítmény miatt, mindig mondhatsz (például)

argv = sys.argv 

, majd végezze el a teljesítménykritikus kódot, mivel a modul keresése már megtörtént. Bár ez a funkciókkal / módszerekkel működni fog, az IDE-k többsége összezavarodik, és nem fog (például) egy forrás linket / aláírást megjeleníteni a függvényhez, amikor azt egy változóhoz rendelték.

Csak annyit szeretnék hozzáfűzni, hogy ha ilyet csinál,

from math import sin 

(vagy bármely más beépített könyvtár, például sys vagy posix), akkor sin szerepeljen a modul dokumentációjában (azaz amikor >>> help(mymodule) vagy $ pydoc3 mymodule műveletet hajt végre. Ennek elkerülése érdekében importálja a következőket:

import math from math import sin as _sin 

PS: a beépített könyvtár egy, amelyet C-kódból állítanak össze és a Python is tartalmaz. argparse, os és a io nem beépített csomagok