Eu sempre uso esse método:
from sys import argv
e use argv
com apenas argv . Mas há uma convenção de usar isso:
import sys
e usando o argumento sys.argv
O segundo método torna o código auto-documentado e eu (realmente) adiro a ele. Mas a razão pela qual prefiro o primeiro método é que é rápido porque estamos importando apenas a função necessária em vez de importar o módulo inteiro (que contém mais funções inúteis que o python perderá tempo importando). Note que eu preciso apenas do argv e todas as outras funções do sys são inúteis para mim.
Então, minhas perguntas são. O primeiro método realmente torna o script rápido? Qual método é o preferido? Por quê?
from … import …
sintaxe em PythonRespostas:
A importação do módulo não desperdiça nada ; o módulo é sempre totalmente importado (para o
sys.modules
mapeamento), portanto, se você usaimport sys
oufrom sys import argv
não faz nenhuma diferença.A única diferença entre as duas instruções é qual nome é vinculado;
import sys
vincula o nomesys
ao módulo (entãosys
->sys.modules['sys']
), enquantofrom sys import argv
vincula um nome diferenteargv
, apontando diretamente para o atributo contido dentro do módulo (entãoargv
->sys.modules['sys'].argv
). O restante dosys
módulo ainda está lá, se você usa mais alguma coisa do módulo ou não.Também não há diferença de desempenho entre as duas abordagens. Sim,
sys.argv
tem que procurar duas coisas; ele tem que olhar-sesys
no espaço de nomes global (encontra o módulo), em seguida, procurar o atributoargv
. E sim, usandofrom sys import argv
você pode pular a pesquisa de atributo, pois você já tem uma referência direta ao atributo. Mas aimport
instrução ainda precisa fazer esse trabalho, ela procura o mesmo atributo ao importar e você só precisará usarargv
uma vez . Se você tivesse que usarargv
milhares de vezes em um loop, talvez pudesse fazer a diferença, mas nesse caso específico, na verdade não.A escolha entre um ou outro então deve basear-se no estilo de codificação .
Em um módulo grande , eu certamente usaria
import sys
; a documentação do código é importante e o usosys.argv
em algum lugar de um módulo grande torna muito mais claro o que você está se referindo do queargv
jamais faria.Se o único lugar que você usa
argv
é em um'__main__'
bloco para chamar umamain()
função, use-ofrom sys import argv
se você se sentir mais feliz com isso:Eu ainda usaria
import sys
lá. Todas as coisas são iguais (e são, exatamente, em termos de desempenho e número de caracteres usados para escrevê-lo), isso é apenas mais fácil para mim.Se você estiver importando outra coisa , talvez o desempenho entre em jogo. Mas somente se você usar um nome específico em um módulo várias vezes , em um loop crítico, por exemplo. Mas a criação de um nome local (dentro de uma função) será ainda mais rápida:
fonte
from...import
permite que você façapackage.attribute
mais do quepackage.subpackage_or_module.attribute
, o que pode ser útil se você tem agrupamentos lógicos ou conceituais dentro do pacote, mas quer fazer as coisas um pouco mais conveniente para os usuários de seu pacote. (numpy
Faz algo assim, eu acredito.)from django.core.management.base import BaseCommand
são melhores, e qualquer outra coisa (especialmenteimport django
) levaria a um código ilegível. Então, enquanto eu gosto dessa resposta, acho que existem algumas bibliotecas (e especialmente algumas estruturas) nas quais a convenção é violar a importação simples. Como sempre, use seu julgamento sobre o que é melhor em uma determinada situação. Mas erre do lado explícito (em outras palavras, concordo na maior parte).import ... as
para encontrar o pacote para um nome diferente:import package.subpackage_or_module as shortname
.from parent import sub
faz, essencialmente, a mesma coisa.Há duas razões a favor do uso, em
import module
vez defrom module import function
.Primeiro é o espaço para nome. Importar uma função para o espaço para nome global corre o risco de colisões de nomes.
Segundo, isso não é relevante para os módulos padrão, mas é significativo para os seus próprios módulos, especialmente durante o desenvolvimento. É a opção para
reload()
um módulo. Considere isto:Por outro lado
Quanto à velocidade ...
Se você importa um módulo ou importa uma função de um módulo, o Python analisa o módulo inteiro. De qualquer maneira, o módulo é importado. "Importar uma função" nada mais é do que vincular a função a um nome. De fato,
import module
é menos trabalho para intérprete do quefrom module import func
.fonte
Uso
from import
s sempre que melhora a legibilidade. Por exemplo, eu prefiro (ponto e vírgula é apenas para economizar espaço aqui):ao invés de:
O último é mais difícil de ler (e escrever) para mim porque contém muitas informações redundantes. Além disso, é útil saber com antecedência quais partes de um módulo estou usando.
Prefiro
import
s regulares se estiver usando muitos nomes abreviados de um módulo:Ou, se um nome é tão genérico que não faz sentido fora do seu espaço para nome:
fonte
Na minha opinião, o uso regular
import
melhora a legibilidade. Ao revisar o código Python, gosto de ver de onde vem a determinada função ou classe, exatamente onde é usada. Isso me impede de rolar para a parte superior do módulo para obter essas informações.Quanto aos nomes longos dos módulos, apenas uso a
as
palavra - chave e dou a eles apelidos curtos:Como exceção, eu sempre uso a
from module import something
notação ao lidar com o__future__
módulo. Você não pode fazer isso de outra maneira quando deseja que todas as strings sejam unicode por padrão no Python 2, por exemplofonte
Embora
import sys
efrom sys import agrv
tanto importar todo osys
módulo, este último usa o nome de ligação tão somente oargv
módulo é acessível para resto do código.Para algumas pessoas, esse seria o estilo preferido, pois apenas torna acessível a função que você declarou explicitamente.
No entanto, apresenta possíveis conflitos de nome. E se você tivesse outro módulo chamado
argv
? Observe que você também pode importar explicitamente a função e renomear comfrom sys import argv as sys_argv
, uma convenção que atende à importação explícita e é menos provável que tenha causado colisões no espaço de nome.fonte
if sys_argv:
melhor do queif sys.argv:
? Eu sei o que a segunda declaração significa, não tenho idéia do que a primeira forma significa sem voltar para a importação bizarra.Recentemente, fiz essa pergunta para mim mesmo. Eu cronometrei os diferentes métodos.
biblioteca de solicitações
biblioteca bonita
biblioteca json
biblioteca sys
Parece-me que há uma pequena diferença no desempenho.
fonte
import module
comfrom module import name
corretamente, adicione essa pesquisa de nome aoimport module
caso. Por exemplo, adicione a linhasys.argv
aoar
teste, etc. Ainda haverá uma diferença, porque o trabalho realizado é um pouco diferente, pois diferentes bytes de código são gerados e diferentes caminhos de código são executados.import sys
e usarsys.argv
milhares de vezes em um loopfrom sys import argv
e usar apenasargv
. Mas você não. Para coisas que você faz apenas uma vez no nível global do seu módulo, você realmente deve otimizar a legibilidade, não as diferenças microscópicas nos tempos.Analisar fragmentos de código publicados, importar módulos inteiros e fazer referência a eles
module.function
é praticamente o padrão, pelo menos para módulos padrão. A única exceção parece serdatetime
então você pode dizer em
datetime.now()
vez dedatetime.datetime.now()
.Se você está preocupado com o desempenho, sempre pode dizer (por exemplo)
e faça seu código crítico de desempenho, já que a pesquisa do módulo já foi concluída. No entanto, embora isso funcione com funções / métodos, a maioria dos IDEs ficará confusa e não exibirá (por exemplo) um link / assinatura de origem para a função quando ela estiver atribuída a uma variável.
fonte
Eu só quero acrescentar que se você fizer algo como
(ou qualquer outra biblioteca interna como
sys
ouposix
),sin
será incluída na documentação do seu módulo (por exemplo, quando você faz>>> help(mymodule)
ou$ pydoc3 mymodule
.) Para evitar isso, importe usando:PS: uma biblioteca interna é aquela que é compilada a partir do código C e incluída no Python.
argparse
,os
Eio
não são built-in pacotesfonte