Aprenda A Paginar No Django

A paginação é o processo de dividir grandes blocos de dados em várias páginas da Web discretas. Em vez de despejar todos os dados para o usuário, você pode definir o número de registros individuais que deseja exibir por página e enviar de volta os dados que correspondem à página solicitada pelo usuário.

A vantagem de utilizar esse tipo de técnica é que melhora a experiência do usuário, principalmente quando há milhares de registros a serem recuperados. Implementar paginação no Django é bastante fácil, pois o Django fornece uma classe Paginator da qual você pode usar para agrupar conteúdo em diferentes páginas.

A paginação pode ter diferentes sabores dependendo de como é configurada pelo desenvolvedor. Dito isso, neste artigo, veremos como incluir paginação com exibições baseadas em função e classe usando três tipos diferentes de interface do usuário.

Objetivos

Ao final deste artigo, você será capaz de:

1. Explique o que é paginação e por que você pode querer usá-la.
2. Trabalhe com a Paginatorclasse e os Pageobjetos do Django.
3. Implemente a paginação no Django com visualizações baseadas em funções e classes.

Construções Django

Ao implementar a paginação no Django, em vez de reinventar a lógica necessária para a paginação, você trabalhará com as seguintes construções:

1. Paginator - divide um Django QuerySet ou lista em pedaços de Pageobjetos.
2. Página - contém os dados paginados reais junto com os metadados de paginação.

Vejamos alguns exemplos rápidos.

paginador

from django.contrib.auth.models import User


for num in range(43):
    User.objects.create(username=f"{num}")

Aqui, criamos 43 objetos User.

Em seguida, importaremos a Paginatorclasse e criaremos uma nova instância:

from django.contrib.auth.models import User
from django.core.paginator import Paginator

users = User.objects.all()

paginator = Paginator(users, 10)

print(paginator.num_pages)  # => 5

A Paginatorclasse recebe quatro parâmetros:

1. object_list- qualquer objeto com um count()ou __len__()método, como uma lista, tupla ou QuerySet
2. per_page- número máximo de itens a serem incluídos em uma página
3. orphans(opcional) - usado para evitar que a última página tenha poucos itens, o padrão é0
4. allow_empty_first_page(opcional) - como está implícito no nome, você pode gerar um EmtpyPageerro se não permitir que a primeira página fique vazia definindo o argumento como False, o padrão éTrue

Então, no exemplo acima, dividimos os usuários em páginas (ou pedaços) de dez. As primeiras quatro páginas terão dez usuários, enquanto a última página terá três.

A Paginatorclasse tem os seguintes atributos :

1. count- número total de objetos
2. num_pages- número total de páginas
3. page_range- iterador de intervalo de números de página

Para resultados paginados consistentes, o QuerySet ou o modelo devem ser ordenados.

Se você preferir não ter apenas três usuários na página final, você pode usar o argumento orphans assim para adicionar os três usuários finais à página anterior:

from django.contrib.auth.models import User
from django.core.paginator import Paginator

users = User.objects.all()

paginator = Paginator(users, 10, orphans=3)

print(paginator.num_pages)  # => 4

Assim, quando o número de objetos restantes para a última página for menor ou igual ao valor de orphans, esses objetos serão adicionados à página anterior.

Página

Após o Django QuerySet ter sido dividido em Pageobjetos. Podemos então usar o page()método para acessar os dados de cada página passando o número da página para ela:

from django.contrib.auth.models import User
from django.core.paginator import Paginator

users = User.objects.all()

paginator = Paginator(users, 10)

page_obj = paginator.page(1)

print(page_obj)  # => <Page 1 of 5>

Aqui, page_objnos dá um objeto de página que representa a primeira página de resultados. Isso pode ser usado em seus modelos.

Observe que não criamos literalmente uma Pageinstância. Em vez disso, obtivemos a instância da classe Paginator.

O que acontece se a página não existir?

from django.contrib.auth.models import User
from django.core.paginator import Paginator

users = User.objects.all()

paginator = Paginator(users, 10)

page_obj = paginator.page(99)

Você deveria ver:

    raise EmptyPage(_('That page contains no results'))
django.core.paginator.EmptyPage: That page contains no results

Assim, é uma boa ideia capturar uma EmptyPageexceção assim:

from django.contrib.auth.models import User
from django.core.paginator import EmptyPage, Paginator

users = User.objects.all()

paginator = Paginator(users, 10)

try:
    page_obj = paginator.page(99)
except EmptyPage:
    # Do something
    pass

Você pode querer capturar uma PageNotAnIntegerexceção também.

Para saber mais sobre isso, revise a seção Exceções da documentação do Paginator.

Dito isto, se você preferir não lidar com as exceções EmptyPageou PageNotAnIntegerexplicitamente, você pode usar o método get_page() em vez de page():

from django.contrib.auth.models import User
from django.core.paginator import Paginator

users = User.objects.all()

paginator = Paginator(users, 10)

page_obj = paginator.get_page(99)

print(page_obj)  # => <Page 5 of 5>

Assim, mesmo que o número 99esteja fora do intervalo, a última página será retornada.

Além disso, se a página não for um número válido get_page()retornará, por padrão, a primeira página:

from django.contrib.auth.models import User
from django.core.paginator import Paginator

users = User.objects.all()

paginator = Paginator(users, 10)

page_obj = paginator.get_page('foo')

print(page_obj)  # => <Page 1 of 5>

Portanto, ambos os métodos -- page()ou get_page()-- podem ser usados ​​dependendo de suas preferências. Os exemplos mostrados neste artigo usarão page().

O Pageobjeto tem vários atributos e métodos que podem ser usados ​​durante a construção do seu template:

1. number- mostra o número da página para uma determinada página
2. paginator- exibe o Paginatorobjeto associado
3. has_next()- retorna Truese houver uma próxima página
4. has_previous()- - retorna Truese houver uma página anterior
5. next_page_number()- retorna o número da próxima página
6. previous_page_number()- retorna o número da página anterior

Visualizações baseadas em função

Em seguida, vamos ver como trabalhar com paginação em visualizações baseadas em função:

from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
from django.shortcuts import render

from . models import Employee


def index(request):
    object_list = Employee.objects.all()
    page_num = request.GET.get('page', 1)

    paginator = Paginator(object_list, 6) # 6 employees per page


    try:
        page_obj = paginator.page(page_num)
    except PageNotAnInteger:
        # if page is not an integer, deliver the first page
        page_obj = paginator.page(1)
    except EmptyPage:
        # if the page is out of range, deliver the last page
        page_obj = paginator.page(paginator.num_pages)

    return render(request, 'index.html', {'page_obj': page_obj})

Aqui nós:

1. Definiu uma page_numvariável da URL.
2. Instanciou a Paginatorclasse passando para ela os parâmetros necessários, o employeesQuerySet e o número de funcionários a serem incluídos em cada página.
3. Gerou um objeto de página chamado page_obj, que contém os dados do funcionário paginados junto com os metadados para navegar para as páginas anterior e seguinte.

https://github.com/testdrivedio/django-pagination-example/blob/main/employees/views.py

Visualizações baseadas em classe

Exemplo de implementação de paginação em uma visualização baseada em classe:

from django.views.generic import ListView

from . models import Employee


class Index(ListView):
    model = Employee
    context_object_name = 'employees'
    paginate_by = 6
    template_name = 'index.html'

https://github.com/testdrivedio/django-pagination-example/blob/main/employees/views.py

Modelos

Trabalhar com paginação no template é onde as coisas começam a ficar interessantes, pois existem várias implementações diferentes. Neste artigo, veremos três implementações diferentes, cada uma mostrando uma maneira diferente de navegar para as páginas anterior e seguinte.

Você pode encontrar o código para cada exemplo na pasta templates no repositório django-pagination-example no GitHub.

Sabor 1

Este é o primeiro sabor que implementa a interface do usuário de paginação.

Portanto, neste exemplo, temos links "Anterior" e "Próximo" nos quais o usuário final pode clicar para mover de uma página para outra.

index.html :

<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/css/bootstrap.min.css">
    <title>Pagination in Django</title>
  </head>
  <body>
    <div class="container">
      <h1 class="text-center">List of Employees</h1>
      <hr>

      <ul class="list-group list-group-flush">
        {% for employee in page_obj %}
          <li class="list-group-item">{{ employee }}</li>
        {% endfor %}
      </ul>

      <br><hr>

     {% include "pagination.html" %}
    </div>
  </body>
</html>

paginação.html :

<div>
  <span>
    {% if page_obj.has_previous %}
      <a href="?page={{ page_obj.previous_page_number }}">Previous</a>
    {% endif %}
    <span>
      Page {{ page_obj.number }} of {{ page_obj.paginator.num_pages }}.
    </span>
    {% if page_obj.has_next %}
      <a href="?page={{ page_obj.next_page_number }}">Next</a>
    {% endif %}
  </span>
</div>

Lembre-se de que o modelo pagination.html pode ser reutilizado em muitos modelos.

Sabor 2

paginação.html :

{% if page_obj.has_previous %}
 <a href="?page={{ page_obj.previous_page_number }}">Previous</a>
{% else %}
  <a>Previous</a>
{% endif %}

{% for i in page_obj.paginator.page_range %}
  {% if page_obj.number == i %}
    <a href="#">{{ i }} </a>
  {% else %}
    <a href="?page={{ i }}">{{ i }}</a>
  {% endif %}
{% endfor %}

{% if page_obj.has_next %}
  <a href="?page={{ page_obj.next_page_number }}">Next</a>
{% else %}
  <a>Next</a>
{% endif %}

Esse tipo apresenta todos os números de página na interface do usuário, facilitando a navegação para diferentes páginas.

Sabor 3

paginação.html :

{% if page_obj.has_previous %}
  <a href="?page={{ page_obj.previous_page_number }}">« Previous page</a>

  {% if page_obj.number > 3 %}
    <a href="?page=1">1</a>
    {% if page_obj.number > 4 %}
      <span>...</span>
    {% endif %}
  {% endif %}
{% endif %}

{% for num in page_obj.paginator.page_range %}
  {% if page_obj.number == num %}
    <a href="?page={{ num }}">{{ num }}</a>
  {% elif num > page_obj.number|add:'-3' and num < page_obj.number|add:'3' %}
    <a href="?page={{ num }}">{{ num }}</a>
  {% endif %}
{% endfor %}

{% if page_obj.has_next %}
  {% if page_obj.number < page_obj.paginator.num_pages|add:'-3' %}
    <span>...</span>
    <a href="?page={{ page_obj.paginator.num_pages }}">{{ page_obj.paginator.num_pages }}</a>
  {% elif page_obj.number < page_obj.paginator.num_pages|add:'-2' %}
    <a href="?page={{ page_obj.paginator.num_pages }}">{{ page_obj.paginator.num_pages }}</a>
  {% endif %}

  <a href="?page={{ page_obj.next_page_number }}">Next Page »</a>
{% endif %}

Se você tiver um grande número de páginas, talvez queira dar uma olhada neste terceiro e último sabor.

Conclusão

Isso conclui o artigo sobre implementação de paginação no Django. Aqui estão os principais pontos a serem lembrados:

1. Implementar paginação no Django é bastante fácil devido às classes auxiliares Paginatore fornecidas de fábrica.Page
2. Uma vez que a visualização é criada, você simplesmente devolve o objeto de página, com os dados paginados, a serem usados ​​no modelo.

Fonte:  https://testdrive.io

#django 

What is GEEK

Buddha Community

Django admin full Customization step by step

Welcome to my blog , hey everyone in this article you learn how to customize the Django app and view in the article you will know how to register  and unregister  models from the admin view how to add filtering how to add a custom input field, and a button that triggers an action on all objects and even how to change the look of your app and page using the Django suit package let’s get started.

Database

Custom Titles of Django Admin

Exclude in Django Admin

Fields in Django Admin

#django #create super user django #customize django admin dashboard #django admin #django admin custom field display #django admin customization #django admin full customization #django admin interface #django admin register all models #django customization

How model queries work in Django

How model queries work in Django

Welcome to my blog, hey everyone in this article we are going to be working with queries in Django so for any web app that you build your going to want to write a query so you can retrieve information from your database so in this article I’ll be showing you all the different ways that you can write queries and it should cover about 90% of the cases that you’ll have when you’re writing your code the other 10% depend on your specific use case you may have to get more complicated but for the most part what I cover in this article should be able to help you so let’s start with the model that I have I’ve already created it.

**Read More : **How to make Chatbot in Python.

Read More : Django Admin Full Customization step by step

let’s just get into this diagram that I made so in here:

Describe each parameter in Django querset

we’re making a simple query for the myModel table so we want to pull out all the information in the database so we have this variable which is gonna hold a return value and we have our myModel models so this is simply the myModel model name so whatever you named your model just make sure you specify that and we’re gonna access the objects attribute once we get that object’s attribute we can simply use the all method and this will return all the information in the database so we’re gonna start with all and then we will go into getting single items filtering that data and go to our command prompt.

Here and we’ll actually start making our queries from here to do this let’s just go ahead and run** Python manage.py shell** and I am in my project file so make sure you’re in there when you start and what this does is it gives us an interactive shell to actually start working with our data so this is a lot like the Python shell but because we did manage.py it allows us to do things a Django way and actually query our database now open up the command prompt and let’s go ahead and start making our first queries.

#django #django model queries #django orm #django queries #django query #model django query #model query #query with django

Main Pros and Cons of Django As A Web Framework for Python Developers

Django depicts itself as “the web system for fussbudgets with cutoff times”. It was intended to help Python engineers take applications from idea to consummation as fast as could be expected under the circumstances.

It permits fast turn of events on the off chance that you need to make a CRUD application with batteries included. With Django, you won’t need to rehash an already solved problem. It just works and lets you center around your business rationale and making something clients can utilize.

Pros of Django

“Batteries included” theory

The standard behind batteries-included methods normal usefulness for building web applications accompanies the system, not as isolated libraries.

Django incorporates much usefulness you can use to deal with normal web advancement undertakings. Here are some significant level functionalities that Django gives you, which else you need to stay together if you somehow happened to utilize a small scale structure:

ORM

Database relocations

Client validation

Administrator board

Structures

Normalized structure

Django as a system proposes the right structure of an undertaking. That structure helps designers in making sense of how and where to execute any new component.

With a generally acknowledged venture structure that is like numerous tasks, it is a lot simpler to discover online good arrangements or approach the network for help. There are numerous energetic Python designers who will assist you with comprehending any issue you may experience.

Django applications

Django applications (or applications for short) permit designers to separate a task into numerous applications. An application is whatever is introduced by putting in settings.INSTALLED_APPS. This makes it simpler for engineers to add usefulness to the web application by coordinating outer Django applications into the venture.

There are many reusable modules and applications to accelerate your turn of events learn through Online Django Class and Check the Django website.

Secure of course

Django gives great security assurance out of the crate and incorporates avoidance components for basic assaults like SQL Injection (XSS) and Cross-site Request Forgery (CSRF). You can discover more subtleties in the official security diagram control.

REST structure for building APIs

Django REST Framework, commonly condensed “DRF”, is a Python library for building APIs. It has secluded and adaptable engineering that functions admirably for both straightforward and complex web APIs.

DRF gives a lot of verification and authorization strategies out of the case. It is an adaptable, full-included library with measured and adjustable engineering. It accompanies nonexclusive classes for CRUD tasks and an implicit API program for testing API endpoints.

GraphQL structure for building APIs

Huge REST APIs regularly require a lot of solicitations to various endpoints to recover every single required datum. GraphQL it’s a question language that permits us to share related information in a lot simpler design. For a prologue to GraphQL and an outline of its ideas, if it’s not too much trouble allude to the authority GraphQL documentation.

Graphene-Django gives reflections that make it simple to add GraphQL usefulness to your Django venture. Ordinary Django models, structures, validation, consent arrangements, and different functionalities can be reused to manufacture GraphQL blueprint. It additionally gives an implicit API program for testing API endpoints.

Cons of Django

Django ORM

Django ORM, made before SQLAlchemy existed, is currently much sub-par compared to SQLAlchemy. It depends on the Active Record design which is more regrettable than the Unit of Work design embraced by SQLAlchemy. This implies, in Django, models can “spare” themselves and exchanges are off as a matter of course, they are a bit of hindsight. Peruse more in Why I kind of aversion Django.

Django advances course popularity increses day by day:

Django is huge and is viewed as strong bit of programming. This permits the network to create several reusable modules and applications yet has additionally restricted the speed of advancement of the Django. On head of that Django needs to keep up in reverse similarity, so it advances gradually.

Rundown - Should I use Django as a Python designer?

While Django ORM isn’t as adaptable as SQLAlchemy and the enormous environment of reusable modules and applications hinders structure advancement - plainly Django ought to be the best option web system for Python engineers.

Elective, light systems, similar to Flask, while offering a retreat from Django huge biological system and designs, in the long haul can require substantially more additional libraries and usefulness, in the end making many experienced Python engineers winding up wishing they’d began with Django.

Django undertaking’s security and network have become enormously over the previous decade since the system’s creation. Official documentation and instructional exercises are probably the best anyplace in programming advancement. With each delivery, Django keeps on including huge new usefulness.

#django online training #django online course #online django course #django course #django training #django certification course

4 key Features of Django Framework that Make it the Best Amongst all!

Django is one of the popular python based open-source web frameworks mainly used by the developers who like to have rapid development along with the clean pragmatic design.

Read this blog to know the various Django Features with details.

#django framework #django web development #django development company #django development services #python django development company #python django development

What is Django Used For? The Six Most Common Applications | Hacker Noon

Django is a web app framework based upon Python, but is not a part of Python. Python being open-source language, easy to learn and adapt, has become the programming language of choice for beginners as well as seasoned developers in recent years. Django was created to support web application development, web APIs, web services. Thanks to rising popularity of Python, Django too became a framework of choice for python developers.

But, why Django specifically? Why are popular social networking sites, online magazines and e-commerce sites using Django? Why is it so popularly used by developers? Let’s find out what Django is used for.

6 Ways Developers are Using Django

• For scalable web applications
• Django is used for applications with multiple user roles
• For building speedy SaaS applications
• Secure E-commerce and Enterprise applications
• Django is Used for a building low cost MVP
• For building Cross-platform applications

#django #django-in-mvp #django-in-saas #resize-image-in-django #django-tips