Qual é a maneira mais eficiente de armazenar uma lista nos modelos do Django?

Atualmente, tenho muitos objetos python no meu código semelhantes aos seguintes:

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

Agora eu quero transformar isso em um modelo do Django, onde self.myName é um campo de string e self.myFriends é uma lista de strings.

from django.db import models

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

Como a lista é uma estrutura de dados tão comum em python, eu meio que esperava que houvesse um campo de modelo do Django para ela. Eu sei que posso usar um relacionamento ManyToMany ou OneToMany, mas esperava evitar esse indireção extra no código.

Editar:

Eu adicionei esta pergunta relacionada , que as pessoas podem achar útil.

Esse relacionamento não seria melhor expresso como um relacionamento de chave estrangeira um para muitos em uma Friendstabela? Entendo que myFriendssão apenas strings, mas eu pensaria que um design melhor seria criar um Friendmodelo e MyClassconter uma relação de chave estrangeira na tabela resultante.

"Otimização prematura é a raiz de todo o mal."

Com isso em mente, vamos fazer isso! Depois que seus aplicativos atingem um determinado ponto, a desnormalização de dados é muito comum. Feito corretamente, ele pode salvar inúmeras pesquisas caras no banco de dados, ao custo de um pouco mais de limpeza.

Para retornar um nome listde amigo, precisamos criar uma classe Django Field personalizada que retornará uma lista quando acessada.

David Cramer postou um guia para criar um SeperatedValueField em seu blog. Aqui está o código:

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)

A lógica desse código lida com os valores de serialização e desserialização do banco de dados para Python e vice-versa. Agora você pode facilmente importar e usar nosso campo personalizado na classe de modelo:

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

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

Uma maneira simples de armazenar uma lista no Django é apenas convertê-la em uma string JSON e salvá-la como Texto no modelo. Em seguida, você pode recuperar a lista convertendo a sequência (JSON) novamente em uma lista python. Aqui está como:

A "lista" seria armazenada no seu modelo do Django da seguinte forma:

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

Na sua visão / código do controlador:

Armazenando a lista no banco de dados:

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()

Recuperando a lista do banco de dados:

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

Conceitualmente, aqui está o que está acontecendo:

>>> 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'>

Se você estiver usando Django> = 1.9 com o Postgres, poderá usar as vantagens do ArrayField

Um campo para armazenar listas de dados. A maioria dos tipos de campo pode ser usada; você simplesmente passa outra instância de campo como o base_field. Você também pode especificar um tamanho. ArrayField pode ser aninhado para armazenar matrizes multidimensionais.

Também é possível aninhar campos de matriz:

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,
    )

Como o @ thane-brimhall mencionou, também é possível consultar elementos diretamente. Referência da documentação

Como esta é uma pergunta antiga, e as técnicas do Django devem ter mudado significativamente desde então, esta resposta reflete a versão 1.4 do Django e é provavelmente aplicável à versão 1.5.

O Django por padrão usa bancos de dados relacionais; você deve usá-los. Mapeie amizades para relações de banco de dados (restrições de chave estrangeira) com o uso de ManyToManyField. Isso permite que você use o RelatedManagers para listas de amigos, que usam conjuntos de consultas inteligentes. Você pode usar todos os métodos disponíveis, como filterou values_list.

Usando ManyToManyFieldrelações e propriedades:

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())

Você pode acessar a lista de amigos de um usuário desta maneira:

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

Observe, no entanto, que essas relações são simétricas: se Joseph é amigo de Bob, então Bob é amigo 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')

Lembre-se de que isso eventualmente acaba em um banco de dados relacional. Portanto, usar relações é realmente a maneira mais comum de resolver esse problema. Se você absolutamente insistir em armazenar uma lista no próprio objeto, poderá fazê-lo, por exemplo, separado por vírgula, armazená-lo em uma sequência e fornecer funções de acessador que dividem a sequência em uma lista. Com isso, você ficará limitado a um número máximo de strings e perderá consultas eficientes.

Caso esteja usando o postgres, você pode usar algo como isto:

class ChessBoard(models.Model):

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

se você precisar de mais detalhes, pode ler no link abaixo: https://docs.djangoproject.com/pt-br/1.9/ref/contrib/postgres/fields/

Você pode armazenar praticamente qualquer objeto usando um campo Django Pickle, exceto este trecho:

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

Armazenando uma lista de strings no modelo 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

e você pode chamar assim:

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."      

Minha solução, pode ser que ajude alguém:

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)

O uso da relação um para muitos (FK de Friend para a classe pai) tornará seu aplicativo mais escalável (como você pode estender trivialmente o objeto Friend com atributos adicionais além do nome simples). E assim, este é o melhor caminho