Jouer au golf avec Python Import

Quand est-il avantageux d'utiliser l'importation en ligne à usage unique en Python?

Par exemple:

__import__("x").doSomething()

Ce qui précède est-il toujours plus court que le dessous?

import x
x.doSomething()

Ou

from x import*
doSomething()

Cela peut être utile si vous souhaitez utiliser un module une seule fois dans une fonction lambda anonyme, car cela vous permet d'éviter d'écrire une instruction distincte:

lambda x:__import__('SomeModule').foo(x,123)

est un octet plus court que

from SomeModule import*;f=lambda x:foo(x,123)

Si le code est une fonction ou un programme nommé, il __import__est peu probable qu'il aide, sauf dans les circonstances les plus extrêmes ou artificielles.

Lors de l'importation de plusieurs modules avec des noms suffisamment longs, il peut être utile d'affecter la __import__fonction à une variable plus courte et de l'utiliser pour les importations

Exemple:

Instructions d'importation régulières - 97 octets

depuis itertools import *
de l'importation datetime *
imprimer la liste (permutations ("abc"))
print datetime.now ()

Affectation __import__à i- 94 octets:

i = __ import__
imprimer la liste (i ("itertools"). permutations ("abc"))
print i ("datetime"). datetime.now ()

Presque jamais.

__import__("x").doSomething()nécessite plus de 15 caractères x pour faire référence à un module avec un nom de longueur x .

import x\nx.doSomething()nécessite 9 + 2 * x caractères. Ces fonctions se chevauchent à x = 6, donc par rapport à cette façon, tout module avec un nom plus long est préférable d'utiliser __import__, tout ce qui est plus court bénéficie des importations normales:

Cependant, from x import*\ndoSomething()n'a besoin que de 14+ x caractères, donc par rapport à l'importation normale, cela n'en vaut pas la peine à moins que le nom du module ne dépasse 5 caractères:

Tout cela suppose que vous ne faites référence à une fonction / classe / autre qu'une seule fois. Si vous vous y référez plus d'une fois, les formules changent et cette dernière version pourrait devenir la gagnante. Si vous utilisez plusieurs fois un élément long d'un module importé, une autre version l'emporte:

from x import y as zvous donne 18+ x + y + z * ( n +1) caractères pour n utilisations de z , ce qui est une grande amélioration si y est grand, car z peut être fait 1.