'da X importa una' contro 'importa X; X.a'

Question

Ho visto alcuni programmatori Python usare il seguente stile in modo abbastanza coerente (lo chiameremo stile 1):

import some_module
# Use some_module.some_identifier in various places.

Per supportare questo stile, puoi citare " esplicito è meglio di implicito " maxim. Ho visto altri programmatori usare questo stile (stile 2):

from some_module import some_identifier
# Use some_identifier in various places.

Il vantaggio principale che vedo nello stile 2 è la manutenibilità, in particolare con typing anatra ideali potrei voler scambiare some_module con some_other_module. Sento anche che lo stile 2 guadagna punti con la " conteggi di leggibilità " maxim . Anche se tendo a non essere d'accordo, si può sempre sostenere che cercare e sostituire è un'opzione altrettanto valida quando si utilizza il primo stile.

Addendum: è stato notato che è possibile utilizzare come per risolvere il passaggio da some_module a some_other_module in stile 1. Ho dimenticato di menzionare che è anche comune decidere di implementare some_identifier nel modulo corrente , il che rende la creazione di un some_module equivalente contenitore leggermente imbarazzante.

Answer 1

Ci sono usi per entrambi i casi, quindi non credo che si tratti di uno dei due problemi. Prenderei in considerazione l'utilizzo dal modulo import x, y, z quando:

• Ci sono un numero abbastanza piccolo di cose da importare

• Lo scopo delle funzioni importate è evidente quando divorziato dal nome del modulo. Se i nomi sono abbastanza generici, potrebbero scontrarsi con altri e dirti poco. per esempio. vedere rimuovere ti dice poco, ma os.remove probabilmente suggerirà che hai a che fare con i file.

• I nomi non si scontrano. Simile al precedente, ma più importante. Mai fai qualcosa del tipo:

   from os import open
  

import module [as renamed_module] ha il vantaggio di dare un po 'più contesto a ciò che viene chiamato quando lo usi. Ha lo svantaggio che questo è un po 'più disordinato quando il modulo non fornisce realmente più informazioni ed è leggermente meno performante (2 ricerche invece di 1).

Ha anche vantaggi durante il test (ad es. sostituzione di os.open con un oggetto finto, senza dover cambiare tutti i moduli) e dovrebbe essere usato quando si usano moduli mutabili, ad es.

import config
config.dburl = 'sqlite:///test.db'

In caso di dubbio, sceglierei sempre lo stile module import .

Answer 2

Con l'esistenza della seguente sintassi:

import some_other_module as some_module

l'argomento di manutenibilità dello stile 2 non è più pertinente.

Tendo a usare lo stile 1. Normalmente, trovo che faccio esplicitamente riferimento al nome del pacchetto importato solo poche volte in un tipico programma Python. Tutto il resto sono metodi sull'oggetto, che ovviamente non devono fare riferimento al pacchetto importato.

Answer 3

Di solito uso una soglia per decidere. Se voglio usare molte cose in some_module , userò:

import some_module as sm
x = sm.whatever

Se ci sono solo una o due cose di cui ho bisogno:

from some_module import whatever
x = whatever

Ciò presuppone che non ho bisogno di un qualunque da some_other_module , ovviamente.

Tendo a usare la clausola as sulle importazioni in modo da poter ridurre la mia digitazione e sostituire un altro modulo abbastanza facilmente in futuro.

Answer 4

Preferisco importare X e quindi usare X.a il più possibile.

La mia eccezione è incentrata sui moduli profondamente annidati in un grande framework come Django. I nomi dei loro moduli tendono ad allungarsi e tutti i loro esempi dicono dalle impostazioni di importazione di django.conf per salvarti digitando django.conf.settings.DEBUG ovunque.

Se il nome del modulo è profondamente nidificato, l'eccezione è utilizzare da X.Y.Z importare un .

Answer 5

Trovo che la notazione

from some_module import some_symbol

funziona meglio nella maggior parte dei casi. Inoltre, in caso di scontro tra nomi per il simbolo, puoi usare:

from some_module import some_symbol as other_symbol

Come afferma la domanda, evita di riscrivere il nome del modulo in ogni momento, ogni volta con il rischio di errori di digitazione. Uso la sintassi:

import  module [as other_module]

Solo in due casi:

1. Uso troppe funzioni / oggetti del modulo per importarle tutte
2. Il modulo definisce alcuni simboli che possono cambiare durante l'esecuzione

Answer 6

Personalmente cerco di non rovinare troppo il mio spazio dei nomi, quindi nella maggior parte dei casi lo faccio solo

import module  

o     modulo di importazione come mod

L'unica vera differenza è quando ho un modulo con una singola classe che viene usato molto. Se avessi sottoclassato un tipo di list per aggiungere lì alcune funzionalità, userei

from SuperImprovedListOverloadedWithFeatures import NewLIst
nl = NewList()

ecc.

Answer 7

Tendo a usare solo pochi membri di ciascun modulo, quindi ce ne sono molti

from john import cleese
from terry import jones, gilliam

nel mio codice. Importerò interi moduli (come os o wx ) se mi aspetto di utilizzare la maggior parte del modulo e il nome del modulo è breve. Importerò anche interi moduli se c'è un conflitto di nomi o voglio ricordare al lettore a quale funzione è associata.

import michael
import sarah

import wave

gov_speech = wave.open(sarah.palin.speechfile)
parrot_sketch = wave.open(michael.palin.justresting)

(Potrei usare da wave import open come wave_open , ma immagino che wave.open sarà più familiare al lettore.

Answer 8

Potresti essere interessato alla domanda Stack Overflow Perché 'import x; xy' si comporta in modo diverso da 'from x import y', e il primo fallisce quando il pacchetto x. init non è completato? .

Answer 9

Credo nelle versioni più recenti di Python (2.5+? devo controllare i miei fatti ...) puoi persino fare:

import some_other_module as some_module

Quindi puoi ancora andare con lo stile 1 e scambiare in un modulo diverso in seguito.

Penso che generalmente si associ a quanto vuoi ingombrare il tuo spazio dei nomi. Utilizzerai solo uno o due nomi nel modulo? O tutti ( da x import * non è sempre male, solo in generale)?