Qual è il vantaggio di determinare staticamente gli ambiti e di utilizzarli dinamicamente in caso di Python?

Question

Qual è il vantaggio di determinare staticamente gli ambiti e di utilizzarli dinamicamente in caso di Python?

#1 da (5 voti)

4

In primo luogo lasciatemi chiarire che conosco C e sto imparando Python. Quindi il mio OOPS è un po 'brutto.

Stavo leggendo il tutorial ufficiale e ho trovato questo

Although scopes are determined statically, they are used dynamically. At any time during execution, there are at least three nested scopes whose namespaces are directly accessible:

the innermost scope, which is searched first, contains the local names

the scopes of any enclosing functions, which are searched starting with the nearest enclosing scope, contains non-local, but also non-global names

the next-to-last scope contains the current module’s global names the outermost scope (searched last) is the namespace containing built-in names

Capisco gli spazi dei nomi. Penso che gli ambiti siano la stessa cosa. Ma non riuscivo a capire cosa significa la frase sugli obiettivi? Qual è il vantaggio di un simile accordo?

Capisco la frase ma non riesco a visualizzarla. Quindi per favore non dire che questo è un problema con il mio inglese.

object-oriented python python-3.x scope

posta Aseem Bansal 22.07.2013 - 20:53

fonte

1 risposta

Leggi altre domande sui tag object-oriented python python-3.x scope

Progettazione database - Ottimizza le relazioni Una domanda sull'utilizzo di diversi livelli di accesso ai dati per diversi provider di database

score 5 · Accepted Answer

Ti consente di aggirare le funzioni che utilizzano i nomi del contesto circostante nel loro comportamento.

Lo vedi molto quando definisci i decoratori:

def make_bold(func):
    def wrapper(*args, **kw):
        return '<b>{}</b>'.format(func(*args, **kw))
    return wrapper

@make_bold
def hello(name):
    return 'Hello {}!'.format(name)

hello('World')  # returns '<b>Hello World!</b>'

Qui la funzione wrapper accede a func dall'ambito della funzione genitore; func è una variabile locale nella funzione make_bold . wrapper è una chiusura ; wrapper chiude func .

Puoi ampliare ulteriormente questo aspetto rendendo il decoratore configurabile:

def format(tag):
    def decorator(func):
        def wrapper(*args, **kw):
            return '<{0}>{1}</{0}>'.format(tag, func(*args, **kw))
        return wrapper
    return decorator

@format('b')
@format('i')
def hello(name):
    return 'Hello {}!'.format(name)

hello('World')  # returns '<b><i>Hello World!</i></b>'

Ora abbiamo due livelli di scoping; tag deriva dallo spazio dei nomi locale di format() , mentre func è un argomento per la funzione decorator() ; entrambi sono usati da wrapper() .