Willem Van Onsem

你可能在找一个 上下文处理器 。这是一个将在每次呈现模板时运行的函数,我们可以使用以下上下文处理器:

# app_name/context_processors.py

def profile_total(request):
    from app_name.models import UserProfile
    return {'profile_total': UserProfile.objects.all().count}

是的 不 打电话给 .count() method [Django-doc] 这里是推迟查询评估的步骤。这样,我们将只在您 提供 profile_total 在模板中。

现在我们可以用注册上下文处理器;

# settings.py

# …

TEMPLATES = [
    {
        # …,
        'OPTIONS': {
            'context_processors': [
                # …,
                'app_name.context_processors.profile_total'
            ],
        },
    },
]

然后我们可以使用 资料(总计) 在所有模板中,如果我们使用 {{ profile_total }} .

我的问题是[我]希望能够将多个图像分配给[一个]单个用户,这应该是可能的,因为 ForeignKey 但(我)似乎无法让它像那样工作。

不 :A 外国钥匙 是一个 多对一 关系:意思是 许多的 Customer s可以指一个,可能是同一个,单 Images .如果你想使用多个 Image 那么你需要写下 外国钥匙 相反的方向,所以:

from django.db import models

class Image(models.Model):

    def upload_path(instance, filename):
        return f'/images/{filename}'

    image = models.ImageField(upload_to=upload_path, blank=True, null=True)
    logits = models.BinaryField()
    customer = models.ForeignKey(
        'Customer',
        on_delete=models.SET_NULL,
        null=True,
        related_name='images'
    )

class Customer(models.Model):
    customer_id = models.BigIntegerField(unique=True)
    first_name = models.CharField(max_length=300)
    last_name = models.CharField(max_length=300)
    
    def __str__(self):
        return f'{self.customer_id}'

你设定了 related_name=… parameter ^[Django-doc] 到 'domains' ,因此,您可以使用以下选项查看背面:

tenant = Client.objects.all()
for t in tenant:
    for i in t.domains.all():
        print(i)

笔记 :无需指定 db_index=True Â ^[Django-doc] 暂时 ForeignKey Â ^[Django-doc] .如文件规定: 在ForeignKey上自动创建数据库索引。 .

你可以用 .filter(…) Â ^[Django-doc] 在这里和你一起工作 publisher_id :

Book.objects.filter(id=1).update(publisher_id=2)

这将阻止首次获取 Book 对象使用不同的查询,因此通常情况下,这将通过对数据库的单个查询运行。

Django有一个内置的 |filesizeformat template filter [Django-doc] 因此,您可以将其用于:

{{ file.size|filesizeformat }}

正如文件所述,这将:

将值格式化为人类可读的文件大小(即。 '13 KB' , '4.1 MB' , '102 bytes' 等等)。

在模型中使用表单字段,而不是Django的 JSONField model field ^[Django-doc] .应该是:

#         models 🖟
from django.db.models import JSONField

class Area(models.model):
    geojson = JSONField()

不过,你可能有兴趣与 spatial field type  ^[Django-doc] ,然后看看 django-geojson  ^[GitHub] 用于GeoJSON功能。

你只需要 ForeignKey 从…起 Book 到 Subject ,所以:

class Subject(models.Model):
    name = models.CharField(max_length=50)
    # no books

class Books(models.Model):
    name = models.CharField(max_length=50)
    subject = models.ForeignKey(Subject, on_delete=models.CASCADE)

然后可以过滤主题,使其只检索 主题 至少有一本书:

def view(request):
    subjects = Subject.objects.filter(books__isnull=False).distinct()
    return render(request, 'my_html.html', {'subjects': subjects})

这将是一个好消息 LEFT OUTER JOIN 在桌子上 书 模型,并检查是否至少有一本书。因此,您不需要在模板中进行筛选(这无论如何都不是一个好主意)。

你可以通过考试 str(…) 关于 timedelta 因此:

result = { 'hour': str(x['duration__sum']) }

使用 .filter(…) 将更有效率:这将执行 一 查询数据库,而解决方案 .get(…) 将运行 N 对数据库的查询,以及 N 中的元素数 ids .

而 .filter(过滤) 查询可能需要更长的时间,构造查询、将查询发送到数据库、解码查询、构造执行计划,以及将结果发送回都将使用一次 .filter(过滤) ,而 .得到 解决方案,这将完成 N 时报。

请注意,这两者在语义上是不等价的: .filter(过滤) 将检索 id 存在,存在 .得到 另一方面,如果找不到id,解决方案将出错。

如果要退货的物品数量很大,你应该 不 将这些存储在列表中,但使用 .iterator(…) [Django-doc] 要成批处理项目,请执行以下操作:

for item in queryset.filter(id__in=ids).iterator():
    # do something …

如果将这些项存储在一个列表中,这将无法实现迭代器的目的,因为所有对象都同时处于“活动”状态,因此应该有足够的内存将它们保存在内存中。

请不要允许任意排序:这是一个安全漏洞,因为用户可以根据文章作者的性别进行排序 Post ,这可能是您想要保护的数据。你应该列出一系列可接受的选择,因此:

def get_queryset(self):
    query = self.request.GET.get('q')
    sort = self.request.GET.get('order_by', '-date')
    if sort not in ['date', '-date', 'votes', '-votes']:
        sort = '-date'
    return Post.objects.filter(
        Q(title__icontains=query) | Q(title__icontains=query)
    ).order_by(sort)

然后,url应该如下所示:

<a href="{% url 'search' %}?q={{ query|urlencode }}&amp;order_by=-votes">votes</a>

具有 'search' 指向此视图的路径的名称。

笔记 :也许值得一看 django-filter Â ^[GitHub] 基于 QueryDict 以更具陈述性的方式。

你可以使用 __date lookup ^[Django-doc] 过滤或输入时 F -表达式,或者对于Django的旧版本,可以使用 TruncDate function ^[Django-doc] .

例如,你可以使用过滤器 Comment s代表特定日期,包括:

from datetime import date

Comment.objects.filter(created_date__date=date(2022, 4, 9))

使用 …_date 然而,这并没有多大意义:它是一个 datetime 对象,因此字段的名称提示它是 DateField ,使用它可能更好 created 或 created_timestamp .

你正在使用 blog_title 不 rename_blog_title 在你的 list_display .因此,你应该参考方法,而不是你的研究领域 Blog 型号:

class BlogAdmin(admin.ModelAdmin):
    readonly_fields = ['blog_publish_time', 'blog_update_time']
    list_display = ['rename_blog_title', 'blog_status', 'blog_publish_time', 'blog_update_time']

    def rename_blog_title(self, obj):
        return obj.blog_title[:10]
    rename_blog_title.short_description = 'title'

admin.site.register(Blog, BlogAdmin)

在这种情况下,首先保存两个对象,然后添加 nesave 到 .exercises 属于 npsave .你应该 不 拯救世界 npsave ,自从 ManyToManyField 不是由该模型保存,而是由“隐藏” 通过 型号:

if request.method == 'POST':
    np_form = NewWorkout(request.POST)
    ne_form = NovoExercise(request.POST)
    
    if ne_form.is_valid() and np_form.is_valid():
        nesave = ne_form.save()
        npsave = np_form.save()
        npsave.exercises.add(nesave)

但是如果你 不 想要做一个新的锻炼,但只需添加一个新的锻炼,你可以通过一个包含锻炼主键的视图来完成 Workout :

from django.shortcuts import get_object_or_404

def my_view(request, pk):
    workout = get_object_or_404(Workout, pk=pk)
    if request.method == 'POST':
        ne_form = NovoExercise(request.POST)
        
        if ne_form.is_valid():
            nesave = ne_form.save()
            workout.exercises.add(nesave)

正如错误所说, post.author 期待 Author 对象,而不是用户。因此,您可以通过以下方式检索:

from django.contrib.auth.decorators import login_required

@login_required
def create_post(request):
    if request.method == 'POST':
        form = CreateForm(request.POST, request.FILES)
        if form.is_valid():
            form.instance.author= request.user.author
            form.save()
            return render(request, 'index.html')
    else:
        form = CreateForm()
    return render(request, 'create_post.html', {'form': form})

你也应该 呼叫 这个 is_valid() method ^[Django-doc] 所以 form.is_valid () .

笔记 :您可以将视图限制为具有 @login_required decorator ^[Django-doc] .

笔记 :通常最好利用 settings.AUTH_USER_MODEL  ^[Django-doc] 参考用户模型,而不是使用 User model ^[Django-doc] 直接地有关更多信息,请参见 referencing the User model section of the documentation .

分配 perform_create 充当 perform_update

class ArticleView(viewsets.ModelViewSet):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer

    def perform_create(self, serializer):
        author = get_object_or_404(Author, id=self.request.data['author']['id'])
        return serializer.save(author=author)

    perform_update = perform_create

你需要 呼叫 这个 .count() method ^[Django-doc]

total_frontend_order = request.user.user_frontend_order.all().count()
total_backend_order = request.user.user_backend_order.all().count()
total_complete_website_order = request.user.user_complete_website_order.all().count()
a = total_frontend_order+1

您可以使用以下选项进行筛选:

from datetime import timedelta
from django.db.models.functions import Now

Product.objects.filter(
    status="PENDING", created__lt=Now()-timedelta(hours=1)
).order_by('-created')

你可以用Django的 test client  ^[Django-doc] :

from django.test import TestCase
from django.contrib.auth import get_user_model

class MyTests(TestCase):
    
    @classmethod
    def setUpTestData(cls):
        self.user = get_user_model().objects.create_user(
            username='foo',
            password='bar'
        )

    def test1(self):
        self.client.force_login(self.user)
        response = self.client.get('/admin/')
        self.assertContains(response, 'Tags')

你不需要去拿 Item 这不是 invoice_number 关于 Invoice .你只需要把发票交给 user_profile ,也可以预取 项目 s:

def list_invoices(request, userprofile_id):
    user_profile = get_object_or_404(Account, pk=userprofile_id)
    all_invoices = Invoice.objects.filter(
        invoice_user=user_profile
    ).prefetch_related('items')

    context = {
        'all_invoices': all_invoices,
        'user_profile': user_profile
    }
    return render(request, 'invoices/list-invoices.html', context)

然后在模板中,您可以访问 .items ,所以:

<ul>
{% for invoice in all_invoices %}
    <li> {{ invoice.invoice_number }}</li>
    <ul>
    {% for item in invoice.items.all %}
        <li>{{ item.quantity }} {{ item.title }}</li>
    {% endfor %}
    </ul>
{% endfor %}
</ul>

Django引发了以下验证错误: { "customer_phone": [ "This customer_phone has already been registered." ] }

发生这种情况的原因是,同一个字段可以 倍数 错误。例如,密码字段可以要求至少包含八个字符,并且至少包含一个数字。通过使用列表,它可以列出一个 或者更多 同一领域的问题。从建模的角度来看,这是一种报告错误的更合理的方法。

你可以实现 custom exception handling  ^[drf-doc] 要对每个字段仅使用第一项,请执行以下操作:

# app_name/utils.py

from rest_framework.views import exception_handler
from rest_framework.exceptions import ValidationError

def custom_exception_handler(exc, context):
    if isinstance(exc, ValidationError) and isinstance(exc.detail, dict):
        data = {
            k: vs[0]
            for k, vs in exc.detail.items()
        }
        exc = ValidationError(detail=data)
    
    return exception_handler(exc, context)

然后将异常处理程序设置为:

# settings.py

REST_FRAMEWORK = {
    # …,
    'EXCEPTION_HANDLER': 'app_name.utils.custom_exception_handler'
}

但我认为这是 不 好主意。一个字段可能会有多个问题,从而引发多个验证错误。

应该是的 view_appointment/{{a.id}} 不 adminview_appointment/{{a.id}} ,但最好利用 {% url … %} template tag ^[Django-doc] 。您可以为视图命名:

path('view_appointment/<int:id>/', viewAppointment_view, name='view_appointment'),

然后在模板中引用:

<a href="{% url 'view_appointment' id=a.id %}">Client name:{{a.client_dog_name}}</a><br>

自从你使用 app_name = 'buttonpython2' ,你应该 前缀 带有 app_name ,所以:

{% url 'buttonpython2:script' %}

然而,这将 不 触发 output 视图,因为模式(完全)与 button 自 按钮 路径是在 script 路径,它将触发 按钮 视图。因此,您应该为 views.output .

问题是 不 成功URL,它是表单发布到的方法。你应该向 post_new 看法你的 <form> 因此,应具体说明:

<form method="POST" action="{% url 'post_new' %}">
    …
</form>

你应该把它保存到 self.userId :

def save(self, *args, **kwargs):
    if self.userId.startswith('user#'):
        self.userId = self.userId[5:]
    super().save(*args, **kwargs)

前缀检查是必要的,否则将删除前五个字符 每个 保存对象时,字符串最终将为空。

尽管如此,Django ORM并不总是调用 .save(…) 保存一个对象。实际上,大量创建/更新项目的操作不会调用用户。

如果我用散列查询对象( # ),它将返回正确的项:

>>> User.objects.create(userId='foo#bar')
<User: User object (1)>
NameError: name 'Unit' is not defined
>>> User.objects.filter(userId='foo#bar')
<QuerySet [<User: User object (1)>]>

你可以在两者之间建立一个模型,并将其用作 through=… [Django-doc] 模型在这个模型中,我们使用 ForeignKey 到 Product A. 外国钥匙 到 Cart ,以及 IntegerField 数量:

class Product(models.Model):
    name = models.TextField()
    description = models.TextField()
    price = models.FloatField()
    quantity = models.FloatField()
    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)

class Cart(models.Model):
    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    products = models.ManyToManyField(
        Product,
        related_name='carts',
        through='CartProduct'
    )

class CartProduct(models.Model):
    product = models.ForeignKey(Product, on_delete=models.CASCADE)
    cart = models.ForeignKey(Cart, on_delete=models.CASCADE)
    quantity = models.IntegerField(default=1)

    class Meta:
        constraints = [
            models.UniqueField(fields=['product', 'cart'], name='unique_product_cart')
        ]

因此,您可以通过创建(或更新) CartOrder 在给定的情况下 product 和 cart .如果购物车和产品的组合已经存在,您可以增加其数量。

您还可以在 mycart.cardproduct_set.all() queryset要获取数量,我们可以打印产品名称及其数量,例如:

mycart = …  # some cart
for cartproduct in mycart.cartproduct_set.select_related('product'):
    print(f'{cartproduct.product.name}: {cartproduct.quantity}')

在你的 <form> 您可以附加当前页面,例如:

<form action="{% url 'name-of-some-url' %}?page={{ page_obj.number }}" method="post">
    …
</form>

然后我们可以重定向到正确的页面:

from django.urls import reverse

class ApproveCommentPage(PermissionRequiredMixin,UpdateView):
    # …

    def get_success_url(self):
        res = reverse('blog-admin')
        if 'page' in self.request.GET:
            res += f"?page={self.request.GET['page']}"
        return res

创建一个HTML数据列表,而不是使用以下数据框:

dataframes_list_html = []
for i in range(file_count):
    temp_df = pd.read_csv(path+files[i])
    dataframes_list_html.append(temp_df.to_html(index=False))
return render(request,'blog/view_datasets.html',{'dataframes': dataframes_list_html})

然后枚举模板中的列表并呈现数据帧:

<div class="content-section">
{% for dataframe in dataframes %}
    Output: {{ dataframe|safe }}
{% endfor %}
</div>

您可以通过 self.kwargs ,这是一个将参数名称映射到其值的字典,因此:

class DNSSettingsUpdateView(UpdateView):
    model = Domain
    form_class = NsRecordModelForm
    template_name = "engine/dns_settings.html"

    def get_object(self, queryset=None):
        return Domain.objects.get(name=self.kwargs['domain_name'])

    def get_success_url(self):
        return reverse("my-domains")

它不起作用的原因是 ManyToManyField 指的是 User 模型,因此:

ShoppingList.objects.filter(owners=…)

期望 ,查找 __user 是无效的,因为您已经在 user ,以及 用户 模型没有 用户 用户 .

因此,您可以使用:

shopping_list = ShoppingList.objects.filter(
    owners=request.user
).order_by('id').first()

另一种选择是加入 做你自己。然后,你首先要了解 ListOwner 通过使用 ForeignKey related_query_name=… parameter [Django-doc] ,默认情况下为模型的小写名称。这就是你在第二个解决方案中所做的。

截至 django-2.2 ,您可以使用 .bulk_create(..) [Django-doc]

data = [{'id': 0, 'price': 20}, {'id': 1, 'price': 10}]

Match.objects.bulk_update([Match(**kv) for kv in data], ['price'])

我们就这样建造 Match 然后传递给 bulk_update

不能用双花括号将变量包围在模板标记中。大括号用于呈现模板中的变量,而不是传递模板标记中的参数。因此,您可以这样写:

<form action="{% url 'add_participant' id=event.id %}" method="POST">

是的 . 你可以使用 limit_choices_to=… parameter [Django-doc] ForeignKey . 例如:

from django.db.models import Q

class MyModel(models.Model):
    gateway = models.ForeignKey(
        Gateway,
        on_delete=models.CASCADE,
        limit_choices_to=Q(status=True)
    )

所以我们在这里过滤候选集 Gateway 因此 status 字段应该是 True

你可以构造一个 Q(..) 对象:

Q(price__gte=price_from, price__lte=price_to)

或者你可以 排除

Q(price__gt=price_from, price__lt=price_to)

price_from 或 price_to None ,从而构造 Q 带夸尔格的对象:

if 'search_filter' in request.GET:
    search_params = request.GET.dict()
    search_params.pop('search_filter')
    price_from = search_params.pop('price_from', None)
    price_to = search_params.pop('price_to', None)
    q_list = [
        Q(('{}__icontains'.format(k), v))
        for k, v in search_params.items()
        if v is not None
    ]
    price = { 'price__gte': price_from, 'price__lte': price_to }
    q_list.append(Q(**{k: int(v) for k, v in price.items() if v is not None}))
    # ...

但是, file 是MySQL中的保留关键字。

db_column=… parameter [Django-doc] 在数据库级别使用其他名称。

例如:

class DataFile(models.Model):
    file = models.FileField(upload_to=get_file_upload_path, db_column='filepath')

所以现在您可以使用 my_data_file.file ,但在数据库端,列名为 filepath . Django将对 文件路径

你在混淆 Markdownx Form Field 形式 与 MarkdownxField 模型字段。您应该将模型重写为:

# models.py

from os.path import splitext
from uuid import uuid4
from django.db import models
from markdownx.models import MarkdownxField

def hashImageFilename(instance, name):
    ext = splitext(name)[1]
    return "images/{}{}".format(uuid4(), ext)


class Article(models.Model):
    title = models.CharField(("title"), max_length=100)
    content = MarkdownxFormField()
    description = models.TextField(("description"), default='')
    uploadDate = models.DateTimeField(("uploadDate"), auto_now=True)
    lastModified = models.DateTimeField(("uploadDate"), auto_now=True)
    publicationDate = models.DateField("publicationDate")
    image = models.ImageField("image", upload_to=hashImageFilename)

    def __str__(self):
        return self.title

这个 MarkdownxFormField 用于 形式 ,因此它将使用特定的小部件等呈现。为了在数据库中存储内容,您需要一个模型 .

如果你想拥有 Applicant 有一个 position 为了这个 Position ,您可以通过以下方式获得:

class PositionUpdateForm(forms.ModelForm):
    candidate = forms.ModelChoiceField(queryset=Applicant.objects.empty())

    def __init__(self, *args, **kwargs):
        super(PositionUpdateForm, self).__init__(*args, **kwargs)
        self.fields['candidate'].queryset = Applicant.objects.filter(position=self.instance)

或者我们可以用相反的关系:

class PositionUpdateForm(forms.ModelForm):
    candidate = forms.ModelChoiceField(queryset=Applicant.objects.empty())

    def __init__(self, *args, **kwargs):
        super(PositionUpdateForm, self).__init__(*args, **kwargs)
        self.fields['candidate'].queryset = self.instance.applicants.all()

请注意,您只能在 更新 一 职位 模型,否则没有相关的 申请人 当然是唱片。

这个 第一个表达式 会导致 一 数据库查询。事实上,它会质疑:

SELECT a.*
FROM a
INNER JOIN a_b ON a_b.a_id = a.id
WHERE a_b.b_id = 5

这个 第二个表达式 会导致 二 询问。实际上,第一个Django将查询以获取 B 对象的查询如下:

SELECT b.*
FROM b
WHERE b.id = 5

然后它将执行完全相同的查询来检索相关的 A 物体。

但是找回 一个 对象在这里是不必要的(除非你当然需要它在其他地方)。因此,您将生成一个无用的数据库查询。

我的问题是按模型对象上的id进行筛选会花费很多时间?因为有数百万个模型对象。

数据库通常在外键字段上存储索引。这意味着它将有效过滤。的总数 一个 对象通常不相关(因为它使用数据结构来加速搜索,就像 B-tree [wiki] ). wiki页面有一个部分 named An index speeds the search 这就解释了它的工作原理。

你可以利用两个 JOIN 在这里,比如:

Chat.objects.filter(
    participants__sender=user_a,
    participants__receiver=user_b
).filter(
    participants__sender=user_b,
    participants__receiver=user_a
)

这将导致如下查询:

SELECT chat.id, chat.created
FROM chat
INNER JOIN participant ON chat.id = participant.chat_id
INNER JOIN participant T5 ON chat.id = T5.chat_id
WHERE participant.receiver_id = user_b AND participant.sender_id = user_a
  AND T5.receiver_id = user_a AND T5.sender_id = user_b

因此它将返回所有 Chat 两个这样的对象 Participant 对象存在。

不过,上述情况并不理想,因为我们做了两个 加入 s、 如果有 unique_together 对参与者的约束,如:

class Participant(models.Model):
    chat = models.ForeignKey(Chat, on_delete=models.CASCADE, related_name='participants')
    sender = models.ForeignKey(CustomUser, on_delete=models.CASCADE)
    receiver = models.ForeignKey(CustomUser, on_delete=models.CASCADE)

    class Meta:
        unique_together = ['sender', 'receiver']

我们可以数一数 参与者 对象,例如:

from django.db.models import Count, Q

Chat.objects.filter(
    Q(participants__sender=user_a, participants__receiver=user_b) |
    Q(participants__sender=user_b, participants__receiver=user_a)
).annotate(
    nparticipants=Count('participants')
).get(
    nparticipants=2
)

这将使用以下查询:

SELECT chat.id, chat.created, COUNT(participant.id) AS nparticipants
FROM chat
INNER JOIN participant ON chat.id = participant.chat_id
WHERE (participant.receiver_id = user_b AND participant.sender_id = user_a)
   OR (participant.receiver_id = user_a AND participant.sender_id = user_b)
GROUP BY chat.id
HAVING COUNT(participant.id) = 2

我们可以利用 .get(..) 这里,因为 独一无二 约束,保证最多有一个 聊天 对象,该对象将存在。这样我们就可以用 Chat.DoesNotExist 例外。

不过,我并不真的相信以上的模型是理想的。首先记录的数量将按比例增加 二次型 参加人数:三人有六项记录。此外 聊天 从概念上讲可能不是“定向的”:没有发送方和接收方,有两个或更多的对等方共享信息。

你定义了 answer 在你的 Meta 类,但在定义小部件时,这不在范围内。

可以参照模型中的选项,例如:

from .models import ProValue
from django import forms


class SchoolInput(forms.ModelForm):
    school_name = forms.CharField(
        max_length=255, required=True, widget=forms.TextInput(
            attrs={
                'class': 'input'
            }
    ))
    level_of_grades = forms.IntegerField(min_value=1, required=True)
    num_of_days = forms.IntegerField(min_value=1, max_value=7, required=True)
    division_check = forms.ChoiceField(
        label='Do you have multiple divisions for your grades?',
        choices=ProValue.answer,
        widget=forms.RadioSelect
    )

    class Meta:
        model = ProValue
        fields = [
            'school_name',
            'level_of_grades',
            'num_of_days',
            'division_check',
        ]

这是 预期 行为。您的url是:

static/media/img_background.jpg

使用 相对的 路径。所以如果地点在 foo.com/bar/qux ,然后它将浏览 foo.com/bar/static/media/img_background.jpg .

因此,可以通过在路径前面加上斜线来避免这种情况,例如:

/static/media/img_background.jpg

但在这里最好利用Django的 staticfiles support [Django-doc] . 配置之后,可以使用 {% static … %} template tag [Django-doc] 计算网址。

注意,在部署模式下,您需要将服务器配置为 服务 静态文件本身。但你仍然可以使用 {% static … %} 计算URL,从而减少出错的可能性。