Quelle est la manière la plus efficace de stocker une liste dans les modèles Django?

Actuellement, j'ai beaucoup d'objets python dans mon code similaires à ce qui suit:

class MyClass():
  def __init__(self, name, friends):
      self.myName = name
      self.myFriends = [str(x) for x in friends]

Maintenant, je veux transformer cela en un modèle Django, où self.myName est un champ de chaîne et self.myFriends est une liste de chaînes.

from django.db import models

class myDjangoModelClass():
    myName = models.CharField(max_length=64)
    myFriends = ??? # what goes here?

Étant donné que la liste est une structure de données si commune en python, je m'attendais à ce qu'il y ait un champ de modèle Django pour cela. Je sais que je peux utiliser une relation ManyToMany ou OneToMany, mais j'espérais éviter cette indirection supplémentaire dans le code.

Éditer:

J'ai ajouté cette question connexe , que les gens peuvent trouver utile.

Cette relation ne serait-elle pas mieux exprimée comme une relation de clé étrangère un-à-plusieurs à une Friendstable? Je comprends que ce ne myFriendssont que des chaînes, mais je pense qu'une meilleure conception serait de créer un Friendmodèle et de MyClasscontenir une relation de clé étrangère vers la table résultante.

"L'optimisation prématurée est la racine de tout Mal."

Avec cela fermement à l'esprit, faisons ceci! Une fois que vos applications ont atteint un certain point, la dénormalisation des données est très courante. Fait correctement, il peut économiser de nombreuses recherches coûteuses dans la base de données au prix d'un peu plus d'entretien.

Pour renvoyer un listdes noms d'amis, nous devrons créer une classe Django Field personnalisée qui renverra une liste lors de l'accès.

David Cramer a publié un guide pour créer un SeperatedValueField sur son blog. Voici le code:

from django.db import models

class SeparatedValuesField(models.TextField):
    __metaclass__ = models.SubfieldBase

    def __init__(self, *args, **kwargs):
        self.token = kwargs.pop('token', ',')
        super(SeparatedValuesField, self).__init__(*args, **kwargs)

    def to_python(self, value):
        if not value: return
        if isinstance(value, list):
            return value
        return value.split(self.token)

    def get_db_prep_value(self, value):
        if not value: return
        assert(isinstance(value, list) or isinstance(value, tuple))
        return self.token.join([unicode(s) for s in value])

    def value_to_string(self, obj):
        value = self._get_val_from_obj(obj)
        return self.get_db_prep_value(value)

La logique de ce code traite de la sérialisation et de la désérialisation des valeurs de la base de données vers Python et vice versa. Maintenant, vous pouvez facilement importer et utiliser notre champ personnalisé dans la classe de modèle:

from django.db import models
from custom.fields import SeparatedValuesField 

class Person(models.Model):
    name = models.CharField(max_length=64)
    friends = SeparatedValuesField()

Un moyen simple de stocker une liste dans Django consiste simplement à la convertir en chaîne JSON, puis à l'enregistrer en tant que texte dans le modèle. Vous pouvez ensuite récupérer la liste en reconvertissant la chaîne (JSON) en une liste python. Voici comment:

La "liste" serait stockée dans votre modèle Django comme ceci:

class MyModel(models.Model):
    myList = models.TextField(null=True) # JSON-serialized (text) version of your list

Dans votre vue / code contrôleur:

Stockage de la liste dans la base de données:

import simplejson as json # this would be just 'import json' in Python 2.7 and later
...
...

myModel = MyModel()
listIWantToStore = [1,2,3,4,5,'hello']
myModel.myList = json.dumps(listIWantToStore)
myModel.save()

Récupération de la liste de la base de données:

jsonDec = json.decoder.JSONDecoder()
myPythonList = jsonDec.decode(myModel.myList)

Conceptuellement, voici ce qui se passe:

>>> myList = [1,2,3,4,5,'hello']
>>> import simplejson as json
>>> myJsonList = json.dumps(myList)
>>> myJsonList
'[1, 2, 3, 4, 5, "hello"]'
>>> myJsonList.__class__
<type 'str'>
>>> jsonDec = json.decoder.JSONDecoder()
>>> myPythonList = jsonDec.decode(myJsonList)
>>> myPythonList
[1, 2, 3, 4, 5, u'hello']
>>> myPythonList.__class__
<type 'list'>

Si vous utilisez Django> = 1.9 avec Postgres, vous pouvez profiter des avantages d' ArrayField

Un champ pour stocker des listes de données. La plupart des types de champ peuvent être utilisés, vous passez simplement une autre instance de champ comme base_field. Vous pouvez également spécifier une taille. ArrayField peut être imbriqué pour stocker des tableaux multidimensionnels.

Il est également possible d'imbriquer des champs de tableau:

from django.contrib.postgres.fields import ArrayField
from django.db import models

class ChessBoard(models.Model):
    board = ArrayField(
        ArrayField(
            models.CharField(max_length=10, blank=True),
            size=8,
        ),
        size=8,
    )

Comme @ thane-brimhall l'a mentionné, il est également possible d'interroger des éléments directement. Référence de la documentation

Comme il s'agit d'une vieille question et que les techniques de Django ont dû changer considérablement depuis, cette réponse reflète Django version 1.4, et est probablement applicable pour la v 1.5.

Django utilise par défaut des bases de données relationnelles; vous devriez les utiliser. Mappez les amitiés aux relations de base de données (contraintes de clé étrangère) avec l'utilisation de ManyToManyField. Cela vous permet d'utiliser RelatedManagers pour les listes d'amis, qui utilisent des ensembles de requêtes intelligents. Vous pouvez utiliser toutes les méthodes disponibles telles quefilter ou values_list.

En utilisant ManyToManyField relations et des propriétés:

class MyDjangoClass(models.Model):
    name = models.CharField(...)
    friends = models.ManyToManyField("self")

    @property
    def friendlist(self):
        # Watch for large querysets: it loads everything in memory
        return list(self.friends.all())

Vous pouvez accéder à la liste d'amis d'un utilisateur de cette façon:

joseph = MyDjangoClass.objects.get(name="Joseph")
friends_of_joseph = joseph.friendlist

Notez cependant que ces relations sont symétriques: si Joseph est un ami de Bob, alors Bob est un ami de Joseph.

class Course(models.Model):
   name = models.CharField(max_length=256)
   students = models.ManyToManyField(Student)

class Student(models.Model):
   first_name = models.CharField(max_length=256)
   student_number = models.CharField(max_length=128)
   # other fields, etc...

   friends = models.ManyToManyField('self')

N'oubliez pas que cela doit finir par aboutir dans une base de données relationnelle. Donc, utiliser les relations est vraiment le moyen le plus courant de résoudre ce problème. Si vous insistez absolument pour stocker une liste dans l'objet lui-même, vous pouvez la créer, par exemple, séparée par des virgules, et la stocker dans une chaîne, puis fournir des fonctions d'accesseur qui divisent la chaîne en une liste. Avec cela, vous serez limité à un nombre maximum de chaînes et vous perdrez des requêtes efficaces.

Si vous utilisez postgres, vous pouvez utiliser quelque chose comme ceci:

class ChessBoard(models.Model):

    board = ArrayField(
        ArrayField(
            models.CharField(max_length=10, blank=True),
            size=8,
        ),
        size=8,
    )

si vous avez besoin de plus de détails, vous pouvez lire le lien ci-dessous: https://docs.djangoproject.com/pt-br/1.9/ref/contrib/postgres/fields/

Vous pouvez stocker pratiquement n'importe quel objet en utilisant un Django Pickle Field, ala cet extrait:

http://www.djangosnippets.org/snippets/513/

Stockage d'une liste de chaînes dans le modèle Django:

class Bar(models.Model):
    foo = models.TextField(blank=True)

    def set_list(self, element):
        if self.foo:
            self.foo = self.foo + "," + element
        else:
            self.foo = element

    def get_list(self):
        if self.foo:
            return self.foo.split(",")
        else:
            None

et vous pouvez l'appeler comme ceci:

bars = Bar()
bars.set_list("str1")
bars.set_list("str2")
list = bars.get_list()
if list is not None:
    for bar in list:
        print bar
else:
    print "List is empty."      

L'utilisation de la relation un-à-plusieurs (FK de la classe Friend vers la classe parente) rendra votre application plus évolutive (car vous pouvez étendre trivialement l'objet Friend avec des attributs supplémentaires au-delà du simple nom). Et c'est donc la meilleure façon

Ma solution, peut-être qu'elle aide quelqu'un:

import json
from django.db import models


class ExampleModel(models.Model):
    _list = models.TextField(default='[]')

    @property
    def list(self):
        return json.loads(self._list)

    @list.setter
    def list(self, value):
        self._list = json.dumps(self.list + value)