Führen Sie Python-Dateien mit Django aus HTML aus
Hier schreiben
Dieser Artikel beschreibt "Wie man mit Django eine auf dem Server vorbereitete Python-Datei von einer Webseite aus ausführt und die von HTML an eine CSV-Datei übergebenen Daten ausgibt".
Auch die Schreibumgebung ist Betriebssystem: macOS Catalina Version 10.15.4 Python：3.7.6 Django：3.0.3 Es ist geworden.
Über Django
In Vorheriger Artikel habe ich über den Ablauf von der Installation von Django bis zur Anzeige von HTML geschrieben. Weitere Informationen zur Einführung von Django finden Sie hier. Siehe.
Vorbereitung der Python-Datei
Erstellen einer Python-Datei
Bereiten Sie zunächst die Python-Datei vor, die Sie auf dem Server von Django ausführen möchten. Bereiten Sie diesmal zur Erklärung die folgende Python-Datei vor.
write_data.py
# coding:utf-8
import os
import csv
#Zeichnen Sie Daten von HTML in eine CSV-Datei auf
def write_csv(data):
datas = [data]
with open(os.getcwd()+'/myapp/application/'+'data.csv','a') as f:
writer = csv.writer(f, lineterminator='\n')
writer.writerow(datas)
Dadurch werden diese Daten in data.csv geschrieben, indem sie aufgerufen werden, indem sie an das Argument write_csv () übergeben werden. Beachten Sie, dass hier davon ausgegangen wird, dass die Python-Datei im Ordner <Anwendungsname> / application``` abgelegt wird und die CSV-Datei ausgegeben wird, also os.getcwd () + '/ myapp / application /' Obwohl es sich um + 'data.csv'`` handelt, lesen Sie diesen Teil je nach Umgebung entsprechend.
Platzierung von Python-Dateien
Platzieren Sie die vorbereitete Python-Datei auf dem Server von Django. Wenn Sie die Python-Datei in den Ordner `` `
<Projektname>
- db.sqlite3
- manage.py
- <Projektname>
- __init__.py
- asgi.py
- settings.py
- urls.py
- wsgi.py
- __pycashe__
- (.Mehrere Pyc-Dateien)
- <App Name>
- __init__.py
- admin.py
- apps.py
- models.py
- tests.py
- urls.py
- views.py
- migrations
- __init__.py
- application #Ordner erstellt
- write_data.py #Vorbereitete Python-Datei
- templates
- static
Natürlich müssen Sie es nicht hier ablegen, damit Sie die Datei überall platzieren können.
Ermöglichen Sie die Ausführung von Python-Dateien über HTML
Nachdem Sie die Datei vorbereitet und angeordnet haben, führen Sie die Python-Datei tatsächlich aus HTML aus und erstellen eine CSV-Datei. Vorher denke ich, dass es einfacher ist, zu arbeiten, nachdem ich verstanden habe, wie der Datenfluss aussieht. Daher möchte ich den diesmal angenommenen Datenfluss schreiben.
Ich habe es mit Powerpo geschafft, es tut mir leid für die grobe Figur,
Es gibt viele Teile, die sich der Einfachheit halber vom Programm unterscheiden, aber der Datenfluss bis zum Schreiben in die CSV-Datei sieht folgendermaßen aus. Ich würde mich freuen, wenn das Bild irgendwie vermittelt werden könnte.
html(index.html) → Senden Sie Daten an call_write_data () in myapp / views.py → Führen Sie die Methode write_csv () von application / write_data.py in call_write_data () aus. → Die übergebenen Daten werden in die CSV-Datei geschrieben.
In Worten ausgedrückt sieht es so aus. Auf dieser Grundlage werden wir jede Datei so bearbeiten, dass wir die Python-Datei ab dem nächsten tatsächlich aus HTML ausführen können.
html: Senden Sie Daten mit ajax an views.py
Um die Daten an die Methode call_write_data () in views.py zu übergeben, möchte ich die Daten mit Ajax auf HTML senden. Ich denke, es gibt verschiedene Methoden dafür, also verwenden Sie bitte die Methode, die zu Ihrer Anwendung passt.
index.html
{% load static %}
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<title>HTML</title>
<link rel='stylesheet' type='text/css' href="{% static 'style.css' %}"/>
<script type="text/javascript" src="{% static 'script.js' %}"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
</head>
<body>
<span>Drücken Sie die Taste nach Eingabe der Zeichen</span>
<br>
<input type="text" size="50" id="input_form">
<button type="button" onclick="clickBtn()">Senden</button>
<script>
function clickBtn() {
var txt = document.getElementById("input_form").value;
$.ajax({
url: "{% url 'myapp:call_write_data' %}",
method: 'GET',
data: {"input_data": txt},
dataType: "text",
contentType: "application/json",
beforeSend: function(xhr, settings) {
if (!csrfSafeMethod(settings.type) && !this.crossDomain) {
xhr.setRequestHeader("X-CSRFToken", csrf_token);
}
},
error: function(xhr, status, error) {
console.log("error")
}
})
.done(function(data) {
console.log("Success");
});
// csrf_Wird verwendet, um Token zu erhalten
function getCookie(name) {
var cookieValue = null;
if (document.cookie && document.cookie !== '') {
var cookies = document.cookie.split(';');
for (var i = 0; i < cookies.length; i++) {
var cookie = jQuery.trim(cookies[i]);
// Does this cookie string begin with the name we want?
if (cookie.substring(0, name.length + 1) === (name + '=')) {
cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
break;
}
}
}
return cookieValue;
}
//Csrf in der Kopfzeile_Funktion, die Token gewährt
function csrfSafeMethod(method) {
// these HTTP methods do not require CSRF protection
return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));
};
}
</script>
</body>
</html>
Wenn Sie die Senden-Taste drücken, wird clickBtn () ausgeführt und die Daten werden von Ajax gesendet. Der URL-Teil ist `` `myapp: call_write_data```, der die Daten an die in views.py beschriebene Methode call_write_data () sendet.
Der Datenteil ist `data: {" input_data ": txt}`, und die Datenempfangsseite kann die Zieldaten durch Angabe von "input_data" erfassen. Hier wird nur eines verwendet, aber Sie können das Datenformat wie Anzahl und Art der Daten wie "Daten: {" Daten1 ": txt1," Daten2 ": txt2}" "frei einstellen. ..
myapp / views.py: Geben Sie die Python-Datei und -Methode an, die Sie ausführen und ausführen möchten
myapp/views.py
from django.shortcuts import render
from django.http import HttpResponse
# application/write_data.Import py
from .application import write_data
# Create your views here.
def index(req):
return render(req, 'index.html')
#Methode angegeben durch URL in Ajax
def call_write_data(req):
if req.method == 'GET':
# write_data.py schreiben_csv()Rufen Sie die Methode auf.
#Von den von Ajax gesendeten Daten"input_data"Um durch Angabe zu bekommen.
write_data.write_csv(req.GET.get("input_data"))
return HttpResponse()
Hier erhalten wir die von Ajax gesendeten Daten, übergeben sie an die Methode der Python-Datei, die wir ausführen möchten, und rufen sie auf.
myapp / urls.py: Ermöglicht HTML, Daten an call_write_data () in views.py zu senden
myapp/urls.py
from django.urls import path
from . import views
app_name = 'myapp'
urlpatterns = [
path(r'', views.index, name='index'),
#Fügen Sie Folgendes hinzu(views.py Anruf_write_data()Ermöglicht das Senden von Daten an)
path("ajax/", views.call_write_data, name="call_write_data"),
]
Durch Übergeben des Pfads können Sie mithilfe der Ajax-Kommunikation Daten von HTML an die angegebene Methode von views.py senden.
Überprüfen Sie, ob es tatsächlich in die CSV-Datei geschrieben wurde
Damit ist die erforderliche Bearbeitung abgeschlossen.
$ python manage.py runserver
Starten Sie den Server mit, greifen Sie auf die angezeigte Adresse zu (HTML anzeigen), geben Sie die entsprechenden Zeichen in das Eingabeformular ein und drücken Sie die Senden-Taste.
- <App Name>
- __init__.py
...
- application
- write_data.py
- data.csv #Generierte CSV-Datei
Wenn die CSV-Datei in dem auf diese Weise in der Anwendung erstellten Anwendungsordner generiert und die eingegebene Zeichenfolge in der Datei aufgezeichnet wird, werden die Daten problemlos gesendet und die Python-Datei ausgeführt.
Ergänzung
Dieses Mal erklärte ich, wie man eine Python-Datei aus HTML ausführt und die gesendeten Daten in eine CSV-Datei schreibt, aber umgekehrt.
Der Einfachheit halber möchte ich "Die von write_data.py in views.py übergebenen Daten abrufen und zur Anzeige an HTML übergeben". Im Folgenden werden nur die Dateien mit Änderungen aufgeführt.
myapp/application/write_data.py Fügen Sie eine Methode namens return_text () hinzu.
myapp/application/write_data.py
# coding:utf-8
import os
import csv
#Zeichnen Sie Daten von HTML in eine CSV-Datei auf
def write_csv(data):
datas = [data]
with open(os.getcwd()+'/myapp/application/'+'data.csv','a') as f:
writer = csv.writer(f, lineterminator='\n')
writer.writerow(datas)
#Fügen Sie Folgendes hinzu(return_text()Wenn du anrufst"Hello!!"Ist zurück gekommen)
+ def return_text():
+ return "Hello!!"
myapp/views.py
Rufen Sie return_text () auf, das in write_data.py hinzugefügt wurde, um die zurückgegebene Zeichenfolge abzurufen (in Daten speichern). Übergeben Sie diese Daten mit `HttpResponse ()` an HTML.
myapp/views.py
from django.shortcuts import render
from django.http import HttpResponse
# application/write_data.Import py
from .application import write_data
# Create your views here.
def index(req):
return render(req, 'index.html')
#Methode angegeben durch URL in Ajax
def call_write_data(req):
if req.method == 'GET':
# write_data.py schreiben_Rufen Sie die CSV-Methode auf.
#Von den von Ajax gesendeten Daten"input_data"Um durch Angabe zu bekommen.
write_data.write_csv(req.GET.get("input_data"))
# write_data.Neu geschriebene Methode in py(return_text())Anrufen.
+ data = write_data.return_text()
#Übergeben Sie die empfangenen Daten an HTML.
+ return HttpResponse(data)
index.html
Wenn die Ajax-Kommunikation erfolgreich ist, wird das von HttpResponse () übergebene Argument an den Teil `.done (function (data) {` übergeben, sodass die Daten auf der Seite angezeigt werden.
index.html
{% load static %}
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<title>HTML</title>
<link rel='stylesheet' type='text/css' href="{% static 'style.css' %}"/>
<script type="text/javascript" src="{% static 'script.js' %}"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
</head>
<body>
<span>Drücken Sie die Taste nach Eingabe der Zeichen</span>
<br>
<input type="text" size="50" id="input_form">
<button type="button" onclick="clickBtn()">Senden</button>
<!-- views.Zeigen Sie die von py übergebene Zeichenfolge an.-->
+ <br>
+ <span id="text"></span>
<script>
function clickBtn() {
var txt = document.getElementById("input_form").value;
$.ajax({
url: "{% url 'myapp:call_write_data' %}",
method: 'GET',
data: {"input_data": txt},
dataType: "text",
contentType: "application/json",
beforeSend: function(xhr, settings) {
if (!csrfSafeMethod(settings.type) && !this.crossDomain) {
xhr.setRequestHeader("X-CSRFToken", csrf_token);
}
},
error: function(xhr, status, error) {
console.log("error")
}
})
.done(function(data) {
// views.py Anruf_write_data()HttpResponse kehrte zurück(data)Daten können hier erhalten werden.
//Schreiben Sie den Inhalt des am unteren Rand des Formulars hinzugefügten Bereichs neu.
+ document.getElementById("text").textContent = data;
console.log("Success");
});
// csrf_Wird verwendet, um Token zu erhalten
function getCookie(name) {
var cookieValue = null;
if (document.cookie && document.cookie !== '') {
var cookies = document.cookie.split(';');
for (var i = 0; i < cookies.length; i++) {
var cookie = jQuery.trim(cookies[i]);
// Does this cookie string begin with the name we want?
if (cookie.substring(0, name.length + 1) === (name + '=')) {
cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
break;
}
}
}
return cookieValue;
}
//Csrf in der Kopfzeile_Funktion, die Token gewährt
function csrfSafeMethod(method) {
// these HTTP methods do not require CSRF protection
return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));
};
}
</script>
</body>
</html>
Wenn die Senden-Schaltfläche gedrückt und die Python-Datei korrekt ausgeführt wird, wird die Zeichenfolge "Hallo !!" an HTML übergeben, und wenn die Zeichenfolge "Hallo !!" an den unteren Teil des Eingabeformulars übergeben wird, wird sie angezeigt. Überlegen.
Auf diese Weise ist es möglich, die Python-Datei auf dem Server auszuführen, die Daten der Datei auf dem Server zu lesen und zu schreiben und die Daten in HTML wiederzugeben.
Recommended Posts