Django 모델에 목록을 저장하는 가장 효율적인 방법은 무엇입니까?

현재 내 코드에는 다음과 유사한 많은 파이썬 객체가 있습니다.

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

이제 이것을 장고 모델로 바꾸고 싶습니다. 여기서 self.myName은 문자열 필드이고 self.myFriends는 문자열 목록입니다.

from django.db import models

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

목록은 파이썬에서 일반적인 데이터 구조이기 때문에 장고 모델 필드가있을 것으로 예상됩니다. 나는 ManyToMany 또는 OneToMany 관계를 사용할 수 있다는 것을 알고 있지만 코드에서 추가 간접적 인 것을 피하고 싶었습니다.

편집하다:

사람들이 유용하다고 생각하는 관련 질문을 추가했습니다 .

이 관계가 Friends테이블 에 대한 일대 다 외래 키 관계로 더 잘 표현되지 않습니까? 나는 myFriends단지 문자열 이라는 것을 이해 하지만 더 나은 디자인은 Friend모델 을 만들고 MyClass결과 테이블에 대한 외래 키 구현 을 포함하는 것이라고 생각 합니다.

"조기 최적화는 모든 악의 근원입니다."

이를 확실하게 염두에두고이 작업을 수행하십시오! 앱이 특정 지점에 도달하면 데이터의 비정규 화가 매우 일반적입니다. 올바르게 수행하면 약간의 유지 관리 비용으로 많은 고가의 데이터베이스 조회를 절약 할 수 있습니다.

list친구 이름 을 반환하려면 액세스 할 때 목록을 반환하는 사용자 지정 Django Field 클래스를 만들어야합니다.

David Cramer는 자신의 블로그에 SeperatedValueField 작성에 대한 안내서를 게시했습니다. 코드는 다음과 같습니다.

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)

이 코드의 논리는 데이터베이스에서 Python으로 또는 그 반대로 값을 직렬화 및 역 직렬화하는 작업을 처리합니다. 이제 모델 클래스에서 사용자 정의 필드를 쉽게 가져오고 사용할 수 있습니다.

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

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

장고에 목록을 저장하는 간단한 방법은 목록을 JSON 문자열로 변환 한 다음 모델에서 텍스트로 저장하는 것입니다. 그런 다음 (JSON) 문자열을 다시 파이썬 목록으로 변환하여 목록을 검색 할 수 있습니다. 방법은 다음과 같습니다.

"목록"은 다음과 같이 Django 모델에 저장됩니다.

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

뷰 / 컨트롤러 코드에서 :

데이터베이스에 목록 저장 :

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

데이터베이스에서 목록을 검색합니다.

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

개념적으로 다음은 진행중인 작업입니다.

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

Postgres와 함께 Django> = 1.9를 사용하는 경우 ArrayField 장점 을 사용할 수 있습니다

데이터 목록을 저장하는 필드입니다. 대부분의 필드 유형을 사용할 수 있으며 다른 필드 인스턴스를 base_field로 전달하면됩니다. 크기를 지정할 수도 있습니다. 다차원 배열을 저장하기 위해 ArrayField를 중첩 할 수 있습니다.

배열 필드를 중첩 할 수도 있습니다.

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

@ thane-brimhall이 언급했듯이 요소를 직접 쿼리하는 것도 가능합니다. 문서 참조

이것은 오래된 질문이므로 Django 기술은 그 이후로 크게 바뀌었을 것입니다.이 답변은 Django 버전 1.4를 반영하며 v 1.5에 가장 적합합니다.

Django는 기본적으로 관계형 데이터베이스를 사용합니다. 당신은 그들을 사용해야합니다. ManyToManyField를 사용하여 데이터베이스 관계 (외부 키 제한 조건)에 우정을 맵핑하십시오. 그렇게하면 스마트 쿼리 셋을 사용하는 프렌드리스트에 RelatedManagers를 사용할 수 있습니다. 당신은 다음과 같은 가능한 모든 방법을 사용할 수 있습니다 filter또는 values_list.

사용 ManyToManyField관계와 속성 :

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

이 방법으로 사용자의 친구 목록에 액세스 할 수 있습니다.

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

그러나 이러한 관계는 대칭 적입니다. Joseph이 Bob의 친구 인 경우 Bob은 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')

이것은 결국 관계형 데이터베이스에서 끝나야합니다. 관계를 사용 그래서 정말 입니다 이 문제를 해결하는 일반적인 방법. 객체 자체에 목록을 저장해야한다고 주장하는 경우 목록을 쉼표로 구분하여 문자열로 저장 한 다음 문자열을 목록으로 나누는 접근 자 기능을 제공 할 수 있습니다. 이를 통해 최대 문자열 수로 제한되며 효율적인 쿼리가 손실됩니다.

postgres를 사용하는 경우 다음과 같이 사용할 수 있습니다.

class ChessBoard(models.Model):

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

자세한 내용이 필요하면 아래 링크를 참조하십시오. https://docs.djangoproject.com/pt-br/1.9/ref/contrib/postgres/fields/

이 스 니펫에서 Django Pickle Field를 사용하여 거의 모든 객체를 저장할 수 있습니다.

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

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

그리고 당신은 이것을 다음과 같이 부를 수 있습니다 :

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

일대 다 관계 (친구에서 부모 클래스로의 FK)를 사용하면 앱의 확장 성을 높일 수 있습니다 (단순한 이름 이상의 추가 속성으로 친구 개체를 간단하게 확장 할 수 있음). 따라서 이것이 가장 좋은 방법입니다

내 솔루션은 누군가를 도울 수 있습니다.

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)