Archivia semplici impostazioni utente in Python

StackOverflow https://stackoverflow.com/questions/200599

  •  03-07-2019
  •  | 
  •  

Domanda

Sto programmando un sito Web in cui gli utenti avranno una serie di impostazioni, come la scelta della combinazione di colori, ecc. Sono felice di memorizzarli come file di testo semplice e la sicurezza non è un problema.

Il modo in cui lo vedo attualmente è: esiste un dizionario, in cui tutte le chiavi sono utenti e i valori sono dizionari con le impostazioni dell'utente in essi.

Ad esempio, userdb [" bob "] [" colour_scheme "] avrebbe il valore " blue " ;.

Qual è il modo migliore per archiviarlo su file? Decapaggio del dizionario?

Esistono modi migliori per fare ciò che sto cercando di fare?

È stato utile?

Soluzione

L'uso di cPickle sarebbe il mio scelta. I dizionari si adattano perfettamente a questo tipo di dati, quindi, date le vostre esigenze, non vedo alcun motivo per non usarli. Ciò, a meno che tu non stia pensando di leggerli da applicazioni non Python, nel qual caso dovresti usare un formato di testo neutro per la lingua. E anche qui potresti cavartela con il sottaceto e uno strumento di esportazione.

Altri suggerimenti

Vorrei utilizzare il ConfigParser , che produce alcuni output leggibili e modificabili dall'utente per il tuo esempio: 

[bob]
colour_scheme: blue
british: yes
[joe]
color_scheme: that's 'color', silly!
british: no

Il codice seguente produrrebbe il file di configurazione sopra e quindi lo stamperebbe: 

import sys
from ConfigParser import *

c = ConfigParser()

c.add_section("bob")
c.set("bob", "colour_scheme", "blue")
c.set("bob", "british", str(True))

c.add_section("joe")
c.set("joe", "color_scheme", "that's 'color', silly!")
c.set("joe", "british", str(False))

c.write(sys.stdout)  # this outputs the configuration to stdout
                     # you could put a file-handle here instead

for section in c.sections(): # this is how you read the options back in
    print section
    for option in c.options(section):
            print "\t", option, "=", c.get(section, option)

print c.get("bob", "british") # To access the "british" attribute for bob directly

Nota che ConfigParser supporta solo stringhe, quindi dovrai convertirlo come ho fatto sopra per i booleani. Vedi effbot per una buona rassegna delle basi.

Non affronta la domanda quale sia la migliore. Se vuoi gestire file di testo, prenderei in considerazione ConfigParser - modulo . Un altro che potresti provare sarebbe simplejson o yaml . Potresti anche considerare una vera tabella db.

Ad esempio, potresti avere una tabella chiamata userattrs, con tre colonne:

  • Int user_id
  • Stringa nome_attributo
  • Valore attributo stringa

Se ce ne sono solo pochi, è possibile memorizzarli in cookie per un rapido recupero.

Ecco il modo più semplice. Usa variabili semplici e importa il file delle impostazioni.

Chiama il file userprefs.py 

# a user prefs file
color = 0x010203
font = "times new roman"
position = ( 12, 13 )
size = ( 640, 480 )

Nella tua applicazione, devi essere sicuro di poter importare questo file. Hai molte scelte.

  1. Uso di PYTHONPATH . È necessario impostare PYTHONPATH per includere la directory con i file delle preferenze.

    a. Un parametro esplicito della riga di comando per denominare il file (non il migliore, ma semplice)

    b. Una variabile di ambiente per denominare il file.

  2. Estensione di sys.path per includere la home directory dell'utente

Esempio 

import sys
import os
sys.path.insert(0,os.path.expanduser("~"))
import userprefs 
print userprefs.color

Naturalmente per un sito Web basato su database, l'opzione migliore è una tabella db. Presumo che tu non stia facendo la cosa del database.

Se non ti interessano i formati leggibili dall'uomo, allora pickle è un modo semplice e diretto di procedere. Ho anche sentito buone notizie su simplejson .

Se la leggibilità umana è importante, si presentano due semplici opzioni:

Modulo: basta usare un modulo. Se tutto ciò che serve sono pochi globi e niente di speciale, allora questa è la strada da percorrere. Se sei davvero disperato, potresti definire classi e variabili di classe per emulare sezioni. Il rovescio della medaglia qui: se il file verrà modificato a mano da un utente, gli errori potrebbero essere difficili da rilevare ed eseguire il debug.

Formato INI: sto usando ConfigObj per questo, con un bel po 'di successo. ConfigObj è essenzialmente un sostituto di ConfigParser, con supporto per sezioni nidificate e molto altro. Facoltativamente, è possibile definire i tipi o i valori previsti per un file e convalidarlo, fornendo una rete di sicurezza (e un importante feedback sugli errori) per utenti / amministratori.

Vorrei usare shelve o un < a href = "http://www.python.org/doc/2.5.2/lib/module-sqlite3.html" rel = "nofollow noreferrer"> sqlite se dovessi archiviare queste impostazioni su il file system. Anche se, poiché stai costruendo un sito web, probabilmente usi un qualche tipo di database, quindi perché non usarlo?

Il modulo sqlite3 incorporato probabilmente sarà molto più semplice della maggior parte delle alternative e ti preparerà ad aggiornare a un RDBMS completo nel caso tu abbia mai desiderato o necessario.

Se la leggibilità umana dei file di configurazione è importante, un'alternativa potrebbe essere il modulo ConfigParser che consente di leggere e scrivere file come .ini. Ma poi sei limitato a un livello di nidificazione.

Se si dispone di un database, potrei suggerire di memorizzare le impostazioni nel database. Tuttavia, sembra che i file ordinari potrebbero adattarsi meglio al tuo ambiente.

Probabilmente non vuoi archiviare tutte le impostazioni degli utenti nello stesso file, perché potresti avere problemi con l'accesso simultaneo a quel file. Se hai memorizzato le impostazioni di ciascun utente come dizionario nel proprio file in decapaggio, potrebbero agire in modo indipendente.

Il decapaggio è un modo ragionevole per archiviare tali dati, ma sfortunatamente il formato dei dati di pickle è notoriamente non leggibile dall'uomo. Potrebbe essere meglio memorizzarlo come repr (dizionario) che sarà un formato più leggibile. Per ricaricare le impostazioni dell'utente, usa eval (open (" file "). Read ()) o qualcosa del genere.

C'è qualche motivo particolare per cui non stai usando il database? sembra la cosa normale e naturale da fare - o memorizzare un pickle delle impostazioni nel db digitato sull'id utente o qualcosa del genere.

Non hai descritto i modelli di utilizzo del sito Web, ma stai solo pensando a un sito Web generale, ma penso che mantenere le impostazioni in un database comporterebbe molto meno I / O del disco rispetto all'utilizzo dei file.

OTOH, per le impostazioni che potrebbero essere utilizzate dal codice lato client, archiviarle come javascript in un file statico che può essere memorizzato nella cache sarebbe utile, a spese di avere più posti in cui potresti avere delle impostazioni. (Probabilmente memorizzerei quelle impostazioni nel db e ricostruirei i file statici se necessario)

Sono d'accordo con la risposta sull'utilizzo del dizionario decapato. Molto semplice ed efficace per la memorizzazione di dati semplici in una struttura di dizionario.

Se non ti interessa poter modificare tu stesso il file e desideri un modo rapido per mantenere gli oggetti Python, vai con pickle . Se desideri che il file sia leggibile da un essere umano o leggibile da un'altra app, usa ConfigParser . Se hai bisogno di qualcosa di più complesso, scegli una sorta di database, sia esso relazionale ( sqlite ) o orientato agli oggetti ( axiom , zodb ).

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top