Creazione di una classe Python per "una sola istanza"?

Question

Sto ponendo questa domanda riguardo a Python, sebbene sia probabilmente applicabile alla maggior parte delle lingue OOP.

Quando mi aspetto di utilizzare il modello di dati solo una volta in qualsiasi programma, potrei creare una classe con metodi/attributi statici di classe o semplicemente creare una classe regolare e creare un'istanza una sola volta e utilizzare solo quella copia. In questo caso, quale metodo è migliore e perché?

Con python, potrei anche scrivere un modulo e usarlo come farei in una classe. In questo caso, qual è il modo migliore e perché?

Esempio: voglio avere una struttura dati centrale per accedere/salvare dati in file. modo

Modulo:

data.py

attributes = something 
... 
def save(): 
... 

main.py

import data 
data.x = something 
... 
data.save() 

modo Classe:

class Data: 
    attributes = something 
    @classmethod 
    def save(cls): 

Data.x = something 
Data.save() 

modo istanza

class Data: 
    def save(self): 

data = Data() 
data.x = something 
data.save() 

Answer 1

Un modulo ha lo scopo di racchiudere strutture comuni in uno "spazio dei nomi". Ma veramente in Python un modulo è solo un file e puoi organizzarli come vuoi. Alcune persone mettono molte funzionalità in un modulo. Alcune persone li distribuiscono su pacchetti o sotto-pacchetti. Dipende dalla riusabilità che vuoi. Se un modulo ha un sacco di dipendenze e si vorrà riutilizzare solo una piccola quantità, ha senso dividerle.

Una classe consente di definire tipi che possono essere ereditati come sottotipi. Inoltre ti permettono di definire uno stato con ogni istanza di quella classe.

Quando la classe non ha uno stato e solo metodi statici/metodi di classe, è probabile che non sia necessario un corso. Hai solo bisogno di funzioni.

Inoltre, non è possibile creare un modulo e utilizzarlo come una classe. Un modulo non può avere sottoclassi. Hanno solo un modulo di base init una volta sul carico e poi un ambito di oggetti.

Se ciò che cerchi sono costanti, nel senso che sono definite una volta per tutta la vita dell'app, quindi basta creare un modulo constants.py con un gruppo di tipi primitivi come stringhe, dict ed elenchi.

Answer 2

L'implementazione del modulo casuale standard ha una buona progettazione che mostra sia la creazione di istanze di livello modulo che l'uso senza forzare un singleton su qualsiasi utente.

Ad esempio se chiamo random.random() utilizza un'istanza nascosta di classe Random che è stata inizializzata al momento dell'importazione. Se non sono soddisfatto con il default, posso

my_random = random.Random() 
my_random.seed('not needed but illustrative seed call') 
coin_toss = my_random.random() 

e poi hanno un generatore che non condivide lo stato con l'istanza nascosta. Se sei interessato a questo approccio, leggi random.py che è molto ben documentato; ci sono solo alcune righe di codice rilevanti che non sono poi così complicate.

Questo approccio offre un'interessante svolta Pythonica sui singleton: costruisci uno in importazione automaticamente ma non impedirmi di creare più istanze se voglio.