Pagination in Python mit Flask und SQLite ohne SQLAlchemy

VonSchip

Eine Pagination auf einer Webseite ist sinnvoll, wenn eine große Anzahl von Elementen angezeigt werden soll, die auf mehrere Seiten aufgeteilt werden können, um eine bessere Benutzerfreundlichkeit und Performance zu gewährleisten.

Ohne Pagination müsste der Benutzer möglicherweise durch eine große Anzahl von Elementen scrollen, um das gewünschte Element zu finden, was unpraktisch und zeitaufwändig sein kann. Pagination ermöglicht es dem Benutzer, die Elemente in kleineren Mengen zu durchsuchen und schnell zwischen den Seiten zu navigieren.

Die grundsätzliche programmatische Lösung für Pagination besteht darin, die Datenquelle, z. B. eine Datenbanktabelle, abzufragen und die Ergebnisse basierend auf den Parametern „Seitennummer“ und „Elemente pro Seite“ zu filtern. Dies kann mit SQL-Abfragen, ORM-Abfragen oder anderen Methoden erfolgen.

Nachdem die Ergebnisse gefiltert wurden, müssen sie im richtigen Format an das Front-End übergeben werden, das die Pagination generiert und die Ergebnisse auf der Seite anzeigt. Die Pagination selbst kann durch HTML und CSS erstellt werden oder durch eine Bibliothek wie Bootstrap oder Materialize implementiert werden.

Es gibt viele Möglichkeiten, Pagination auf einer Webseite zu implementieren, einschließlich numerischer Pagination, Endless Scrolling, Infinite Scroll und mehr. Die Wahl der Methode hängt von den Anforderungen und dem Design der Webseite ab.

Pagination in Flask App erstellen

Um eine Pagination in Python mit Flask und SQLite ohne SQLAlchemy zu erstellen, musst du den folgenden Code ausführen:

from flask import Flask, request, jsonify
import sqlite3

app = Flask(__name__)

@app.route('/items')
def get_items():
    page = int(request.args.get('page', 1))
    per_page = int(request.args.get('per_page', 10))

    conn = sqlite3.connect('database.db')
    cursor = conn.cursor()

    cursor.execute("SELECT COUNT(*) FROM items")
    count = cursor.fetchone()[0]

    pages = count // per_page
    if count % per_page > 0:
        pages += 1

    offset = (page - 1) * per_page
    cursor.execute("SELECT * FROM items LIMIT ? OFFSET ?", (per_page, offset))

    items = cursor.fetchall()

    conn.close()

    return jsonify({'items': items, 'pages': pages})

if __name__ == '__main__':
    app.run(debug=True)

In diesem Beispiel erstellen wir eine Flask-App und definieren eine Route /items, um eine Liste von Elementen mit Pagination zu erhalten.

Die Parameter page und per_page werden aus der Abfragezeichenfolge ausgelesen und in Integer umgewandelt. Wenn die Parameter nicht angegeben werden, werden die Standardwerte page=1 und per_page=10 verwendet.

Wir verbinden uns mit der SQLite-Datenbank und holen die Gesamtzahl der Elemente in der Tabelle items mit einer SQL-Abfrage ab. Wir berechnen dann die Anzahl der Seiten, indem wir die Gesamtzahl der Elemente durch die Anzahl der Elemente pro Seite teilen und durch Aufrunden auf die nächste ganze Zahl den Wert auf die nächste ganze Seite runden.

Wir berechnen den Offset für die SQL-Abfrage basierend auf der aktuellen Seite und der Anzahl der Elemente pro Seite. Wir führen dann die SQL-Abfrage aus, um die Elemente für die angegebene Seite abzurufen. Schließlich schließen wir die Verbindung zur Datenbank und geben die Ergebnisse als JSON zurück.

Beachte, dass dies ein einfaches Beispiel ist und es verschiedene Möglichkeiten gibt, eine Pagination in Flask und SQLite ohne SQLAlchemy zu implementieren. Es gibt auch Bibliotheken wie Flask-SQLite3 oder sqlite-web, die die Verbindung mit der SQLite-Datenbank und die Verarbeitung von SQL-Abfragen erleichtern.

Ausgeben der Pagination im Jinja2 Template

Um die Pagination mit Bootstrap im Jinja2 Template zu rendern, kannst du den folgenden Code verwenden:

{% if pages > 1 %}
<nav>
  <ul class="pagination">
    {% if page != 1 %}
    <li class="page-item">
      <a class="page-link" href="?page={{ page - 1 }}&per_page={{ per_page }}">Previous</a>
    </li>
    {% endif %}
    {% for p in range(1, pages + 1) %}
    {% if p == page %}
    <li class="page-item active">
      <span class="page-link">{{ p }}</span>
    </li>
    {% else %}
    <li class="page-item">
      <a class="page-link" href="?page={{ p }}&per_page={{ per_page }}">{{ p }}</a>
    </li>
    {% endif %}
    {% endfor %}
    {% if page != pages %}
    <li class="page-item">
      <a class="page-link" href="?page={{ page + 1 }}&per_page={{ per_page }}">Next</a>
    </li>
    {% endif %}
  </ul>
</nav>
{% endif %}

Dieser Code überprüft zuerst, ob es mehr als eine Seite gibt. Wenn ja, wird die Pagination gerendert.

Die Pagination wird als HTML-Liste mit der Bootstrap-Klasse „pagination“ erstellt. Wir beginnen mit einem Link „Previous“, wenn wir uns nicht auf der ersten Seite befinden. Der Link führt zur vorherigen Seite mit denselben Parametern page und per_page.

Dann wird eine Schleife durchlaufen, um alle Seitennummern anzuzeigen. Wenn wir uns auf der aktuellen Seite befinden, wird der Eintrag mit der Bootstrap-Klasse „active“ gekennzeichnet. Andernfalls wird der Eintrag als Link gerendert, der zur entsprechenden Seite mit denselben Parametern per_page und page führt.

Zum Schluss wird ein Link „Next“ hinzugefügt, wenn wir uns nicht auf der letzten Seite befinden. Der Link führt zur nächsten Seite mit denselben Parametern page und per_page.

Dieser Code kann angepasst werden, um den Stil und das Layout der Pagination nach Bedarf zu ändern.

Übrigens: Wir haben ebenfalls einen Artikel dazu erstellt, wie man mit Python und Flask sowie SQLAlchemy eine Pagination erstellen kann.

Ähnliche Beiträge