Cách hiệu quả nhất để lưu trữ một danh sách trong các mô hình Django là gì?

Hiện tại tôi có rất nhiều đối tượng python trong mã của mình tương tự như sau:

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

Bây giờ tôi muốn biến mô hình này thành mô hình Django, trong đó self.myName là trường chuỗi và self.myFriends là danh sách các chuỗi.

from django.db import models

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

Vì danh sách này là một cấu trúc dữ liệu phổ biến trong python, nên tôi dự kiến ​​sẽ có một trường mô hình Django cho nó. Tôi biết tôi có thể sử dụng mối quan hệ ManyToMany hoặc OneToMany, nhưng tôi đã hy vọng tránh được sự gián tiếp thêm đó trong mã.

Biên tập:

Tôi đã thêm câu hỏi liên quan này , mà mọi người có thể thấy hữu ích.

Mối quan hệ này sẽ không được thể hiện tốt hơn dưới dạng mối quan hệ một-nhiều-ngoại đối với một Friendsbảng? Tôi hiểu rằng đó myFriendschỉ là các chuỗi nhưng tôi nghĩ rằng một thiết kế tốt hơn sẽ là tạo ra một Friendmô hình và có MyClasschứa một thực tế khóa ngoại cho bảng kết quả.

"Tối ưu hóa sớm là gốc rễ của mọi tội lỗi."

Với ý nghĩ chắc chắn, hãy làm điều này! Khi ứng dụng của bạn đạt đến một điểm nhất định, dữ liệu không chuẩn hóa là rất phổ biến. Hoàn thành chính xác, nó có thể tiết kiệm rất nhiều tra cứu cơ sở dữ liệu đắt tiền với chi phí cho việc dọn phòng nhiều hơn một chút.

Để trả về listtên bạn bè, chúng tôi cần tạo một lớp Django Field tùy chỉnh sẽ trả về danh sách khi được truy cập.

David Cramer đã đăng một hướng dẫn để tạo SeperatedValueField trên blog của mình. Đây là mã:

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)

Logic của mã này liên quan đến các giá trị tuần tự hóa và giải tuần tự hóa từ cơ sở dữ liệu sang Python và ngược lại. Bây giờ bạn có thể dễ dàng nhập và sử dụng trường tùy chỉnh của chúng tôi trong lớp mô hình:

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

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

Một cách đơn giản để lưu trữ một danh sách trong Django là chỉ cần chuyển đổi nó thành một chuỗi JSON, sau đó lưu nó dưới dạng Văn bản trong mô hình. Sau đó, bạn có thể truy xuất danh sách bằng cách chuyển đổi chuỗi (JSON) trở lại danh sách python. Đây là cách thực hiện:

"Danh sách" sẽ được lưu trữ trong mô hình Django của bạn như vậy:

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

Trong mã xem / mã điều khiển của bạn:

Lưu trữ danh sách trong cơ sở dữ liệu:

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

Lấy danh sách từ cơ sở dữ liệu:

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

Về mặt khái niệm, đây là những gì đang diễn ra:

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

Nếu bạn đang sử dụng Django> = 1.9 với Postgres, bạn có thể sử dụng các lợi thế của ArrayField

Một trường để lưu trữ danh sách dữ liệu. Hầu hết các loại trường có thể được sử dụng, bạn chỉ cần chuyển một thể hiện trường khác là base_field. Bạn cũng có thể chỉ định một kích thước. ArrayField có thể được lồng nhau để lưu trữ các mảng đa chiều.

Cũng có thể lồng các trường mảng:

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

Như @ thane-brimhall đã đề cập, cũng có thể truy vấn các phần tử trực tiếp. Tài liệu tham khảo

Vì đây là một câu hỏi cũ và các kỹ thuật Django phải thay đổi đáng kể từ đó, câu trả lời này phản ánh phiên bản Django 1.4, và rất có thể áp dụng cho phiên bản 1.5.

Django theo mặc định sử dụng cơ sở dữ liệu quan hệ; bạn nên tận dụng chúng. Ánh xạ mối quan hệ bạn bè với các mối quan hệ cơ sở dữ liệu (các ràng buộc khóa ngoài) với việc sử dụng ManyToManyField. Làm như vậy cho phép bạn sử dụng Trình quản lý liên quan cho danh sách bạn bè, sử dụng truy vấn thông minh. Bạn có thể sử dụng tất cả các phương thức có sẵn như filterhoặc values_list.

Sử dụng ManyToManyFieldquan hệ và tài sản:

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

Bạn có thể truy cập danh sách bạn bè của người dùng theo cách này:

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

Tuy nhiên, lưu ý rằng các mối quan hệ này là đối xứng: nếu Joseph là bạn của Bob, thì Bob là bạn của 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')

Hãy nhớ rằng điều này cuối cùng phải kết thúc trong một cơ sở dữ liệu quan hệ. Vì vậy, sử dụng quan hệ thực sự là cách phổ biến để giải quyết vấn đề này. Nếu bạn hoàn toàn khăng khăng lưu trữ một danh sách trong chính đối tượng, bạn có thể làm cho nó được phân tách bằng dấu phẩy và lưu nó trong một chuỗi, sau đó cung cấp các hàm truy cập chia chuỗi thành một danh sách. Cùng với đó, bạn sẽ bị giới hạn số lượng chuỗi tối đa và bạn sẽ mất các truy vấn hiệu quả.

Trong trường hợp bạn đang sử dụng postgres, bạn có thể sử dụng một cái gì đó như thế này:

class ChessBoard(models.Model):

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

nếu bạn cần biết thêm chi tiết, bạn có thể đọc trong liên kết dưới đây: https://docs.djangoproject.com/pt-br/1.9/ref/contrib/postgres/fields/

Bạn có thể lưu trữ hầu như bất kỳ đối tượng nào bằng cách sử dụng Django Pickle Field, ala đoạn trích này:

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

Lưu trữ một danh sách các chuỗi trong mô hình 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

và bạn có thể gọi nó như thế này:

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

Giải pháp của tôi, có thể là nó giúp được ai đó:

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)

Sử dụng mối quan hệ một-nhiều (FK từ lớp Bạn đến lớp cha) sẽ giúp ứng dụng của bạn có khả năng mở rộng hơn (vì bạn có thể mở rộng đối tượng Bạn bè một cách tầm thường với các thuộc tính bổ sung ngoài tên đơn giản). Và do đó, đây là cách tốt nhất