Giocare a golf con Python Import

Quando è utile utilizzare l'importazione in linea monouso in Python?

Per esempio:

__import__("x").doSomething()

Quanto sopra è mai più corto di quello sotto?

import x
x.doSomething()

O

from x import*
doSomething()

Ciò può essere utile se si desidera utilizzare un modulo una sola volta in una funzione lambda anonima, in quanto consente di evitare di scrivere un'istruzione separata:

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

è un byte più breve di

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

Se il codice è una funzione o un programma denominato, __import__è improbabile che ti aiuti se non nelle circostanze più estreme o forzate.

Quando si importano più moduli con nomi sufficientemente lunghi, può essere utile assegnare la __import__funzione a una variabile più corta e utilizzarla per le importazioni

Esempio:

Dichiarazioni di importazione regolari - 97 byte

da itertools import *
dall'importazione datetime *
elenco di stampa (permutazioni ("abc"))
stampa datetime.now ()

Assegnando __import__a i- 94 byte:

i = __ import__
elenco di stampa (i ("itertools"). permutations ("abc"))
print i ("datetime"). datetime.now ()

Quasi mai.

__import__("x").doSomething()necessita di oltre 15 caratteri x per fare riferimento a un modulo con un nome di lunghezza x .

import x\nx.doSomething()richiede 9 + 2 * x caratteri. Queste funzioni si sovrappongono a x = 6, quindi rispetto a questo modo qualsiasi modulo con un nome più lungo è meglio usare __import__, qualsiasi cosa più breve trae vantaggio dalle normali importazioni:

Tuttavia, from x import*\ndoSomething()richiede solo 14+ caratteri x , quindi rispetto alla normale importazione non ne vale la pena a meno che il nome del modulo non sia più lungo di 5 caratteri:

Tutto questo presuppone che ti riferisci a una funzione / classe / qualunque cosa una sola volta. Se ti riferisci ad esso più di una volta, le formule cambiano e quest'ultima versione potrebbe diventare il vincitore. Nel caso in cui usi più volte qualcosa di lungo da un modulo importato, vince un'altra versione:

from x import y as zti mette a segno 18+ x + y + z * ( n +1) caratteri per n usi di z , il che è un grande miglioramento se y è grande, perché z può essere fatto 1.