'De X importação um' versus 'importação X; X.a'

Question

Eu vi alguns programadores Python usar o seguinte estilo bastante consistente (vamos chamá-lo estilo 1):

import some_module
# Use some_module.some_identifier in various places.

Para suporte deste estilo, você pode citar a "explícito é melhor do que implícito "maxim . Eu vi outros programadores usar este estilo (estilo 2):

from some_module import some_identifier
# Use some_identifier in various places.

A principal vantagem que vejo em grande estilo 2 é manutenção - especialmente com pato digitação ideais que pode querer some_module swap para some_other_module. Eu também sinto estilo 2 pontos vitórias com os "legibilidade conta" Maxim. Embora eu tendem a discordar, sempre se pode argumentar que a busca e substituir é tão bom uma opção quando se utiliza o primeiro estilo.

Adenda: foi observado que você poderia usar as para resolver a mudança de some_module para some_other_module em grande estilo 1. Eu esqueci de mencionar que também é comum para decidir implementar some_identifier em sua atual módulo, que torna a criação de um recipiente some_module equivalente ligeiramente estranho.

Answer 1

Há usos para ambos os casos, então eu não acho que este é um ou-ou questão. Eu considerar o uso de import x,y,z módulo quando:

• Há um relativamente pequeno número de coisas a import

• O objetivo das funções importadas é óbvio quando se divorciou do nome do módulo. Se os nomes são bastante genéricos, eles podem colidir com os outros e dizer-lhe pouco. por exemplo. vendo remove diz-lhe pouco, mas os.remove provavelmente vai sugerir que você está lidando com arquivos.

• Os nomes não se chocam. Semelhante ao anterior, mas o mais importante. Nunca fazer algo como:

   from os import open
  

import module [as renamed_module] tem a vantagem que lhe dá uma mais contexto pouco sobre o que está sendo chamado quando você usá-lo. Tem a desvantagem de que este é um pouco mais confuso quando o módulo não está realmente dando mais informação, e é ligeiramente menos eficaz (2 pesquisas em vez de 1).

Ele também tem vantagens quando se testa no entanto (por exemplo. Substituindo os.open com um objecto simulado, sem ter que mudar a cada módulo), e deve ser utilizado quando se usa módulos mutáveis, por exemplo.

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

Em caso de dúvida, eu sempre ir com o estilo import module.

Answer 2

Com a existência da seguinte sintaxe:

import some_other_module as some_module

o argumento de manutenção do estilo 2 não é mais relevante.

I tendem a usar o estilo 1. Normalmente, eu acho que eu referir-se explicitamente o nome do pacote importado apenas algumas vezes em um programa típico Python. Tudo o resto é métodos no objeto, o que naturalmente não precisa fazer referência ao pacote importado.

Answer 3

Eu costumo usar um limiar para decidir isso. Se eu quiser usar um monte de coisas dentro some_module, eu vou usar:

import some_module as sm
x = sm.whatever

Se há apenas uma ou duas coisas que eu preciso:

from some_module import whatever
x = whatever

Isso supondo que eu não preciso de um whatever de some_other_module, é claro.

I tendem a usar a cláusula as sobre as importações para que eu possa reduzir minha digitação e substitue outro módulo com bastante facilidade no futuro.

Answer 4

Eu prefiro import X e depois usar X.a, tanto quanto possível.

Os meus centros de exceção nos módulos profundamente aninhadas em um grande quadro como Django. Seus nomes de módulos tendem a ficar longo, e os seus exemplos todos digamos from django.conf import settings para salvá-lo digitando django.conf.settings.DEBUG em todos os lugares.

Se o nome do módulo está profundamente aninhados, em seguida, a exceção é usar from X.Y.Z import a.

Answer 5

Eu acho que a notação

from some_module import some_symbol

funciona melhor na maioria dos casos. Além disso, em caso de embate nome para o símbolo, você pode usar:

from some_module import some_symbol as other_symbol

como a questão estados, evita reescrever o nome do módulo todo o tempo, cada vez com um risco de erros de digitação-lo. Eu uso a sintaxe:

import  module [as other_module]

Apenas em dois casos:

1. Eu uso muitas das funções do módulo / objetos para importá-los todos
2. O módulo define algum símbolo que pode mudar durante a execução

Answer 6

Eu pessoalmente não tentar mexa muito com a minha namespace, por isso na maioria das situações eu só faço

import module  

ou módulo de importação como mod

Apenas real diffrence é quando eu tenho um módulo com uma única classe que é usado muito. Se eu tivesse sublclassed um tipo list para adicionar alguma funcionalidade lá, eu usaria

from SuperImprovedListOverloadedWithFeatures import NewLIst
nl = NewList()

etc.

Answer 7

I tendem a usar apenas alguns membros de cada módulo, por isso há uma grande quantidade de

from john import cleese
from terry import jones, gilliam

no meu código. Vou importar módulos inteiros (como os ou wx) se eu esperar para estar usando a maior parte do módulo e o nome do módulo é curto. Eu também vou importar módulos inteiros se houver um conflito de nome ou quero lembrar ao leitor o que essa função está associado.

import michael
import sarah

import wave

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

(eu poderia usar from wave import open as wave_open, mas eu figura que wave.open será mais familiar para o leitor.

Answer 8

Você pode estar interessado em questão Stack Overflow Por que 'import x; xy' se comportam diferente de 'a partir x importação y', ea primeira falha quando pacote x. init não está concluída? .

Answer 9

Eu acredito em versões mais recentes do Python que você mesmo pode fazer (2.5+ deve verificar meus fatos ...?):

import some_other_module as some_module

Então, você ainda pode ir com estilo 1 e swap em um módulo diferente mais tarde.

Eu acho que geralmente mapeia para o quanto você quer encher o seu namespace. Você vai apenas estar usando um ou dois nomes no módulo? Ou todos eles (from x import * não é allways ruim, apenas em geral)?