Python ha qualcosa come C++ usando la parola chiave?

Question

In C++ spesso è possibile migliorare drasticamente la leggibilità del codice da un attento utilizzo della parola chiave "usando", per esempio:

void foo() 
{ 
    std::vector< std::map <int, std::string> > crazyVector; 
    std::cout << crazyVector[0].begin()->first; 
} 

diventa

void foo() 
{ 
    using namespace std; // limited in scope to foo 
    vector< map <int, string> > crazyVector; 
    cout << crazyVector[0].begin()->first; 
} 

fa qualcosa di esistere simile per Python, o devo qualificare pienamente tutto?

Aggiungerò la dichiarazione di non responsabilità che so che l'utilizzo presenta le sue insidie ​​e che dovrebbe essere di portata opportunamente limitata.

Answer 1

Come ha detto Bill, Python ha la costruzione

from X import * 

ma si può anche esplicitamente specificare quali nomi che si desidera importato dal modulo (namespace):

from X import foo, bar, blah 

questo tende a rendere il codice più leggibile ancora/più facile da capire, dato che qualcuno vedendo un identificatore nel codice non lo fa n eed per cacciare attraverso tutti i moduli importati per vedere da dove proviene. Ecco una domanda correlata: Namespace Specification In Absence of Ambuguity

EDIT: in risposta al commento di Pax, citerò che si può anche scrivere le cose come

import X.foo 

ma allora avrete bisogno di scrivere

X.foo.moo() 

invece di

foo.moo() 

Questo non è necessariamente un aspetto negativo, ovviamente. Di solito uso una combinazione dei moduli from X import y e import X.y, qualunque cosa ritenga possa rendere più chiaro il mio codice. È certamente una cosa soggettiva in una certa misura.

Answer 2

import X 

o

from X import * 

o

from X import a, b, c 

Dove X è il modulo Python che si desidera utilizzare.

Sarebbe utile per voi fornirci un esempio di codice Python che ritenete necessario ripulire.

Answer 3

Certo, il dinamismo di Python lo rende banale. Se tu avessi una classe sepolto in un namespace: foo.bar.baz.blah, si può fare:

def foo: 
    f = foo.bar.baz.blah 
    f1 = f() 

Answer 4

Nota che

from foo import bar 

funziona anche se bar è un modulo nel pacchetto foo.Ciò consente di limitare l'inquinamento dello spazio dei nomi senza dover denominare ogni funzione/classe in foo.bar che si potrebbe desiderare di utilizzare. Aiuta anche i lettori del tuo codice, perché vedranno una chiamata a bar.baz() e avranno un'idea migliore da dove proviene lo baz.

Answer 5

Oltre alla risposta di David:

1. Si dovrebbe utilizzare le parentesi tonde in from X import (foo, bar, blah) per un bene di PEP8.
2. La sintassi completa consente di rinominare (rebinding) i nomi dei pacchetti nei nuovi identificatori nell'ambito del modulo corrente come in from foo import bar as baz.

vi consiglio di guardare il manuale per il import keyword, il __import__ incorporato e spiegazione per sys.modules come ulteriori approfondimenti.