[PYTHON] Sprechen Sie über die Funktionen, für die Pandas und ich im Projekt verantwortlich waren

Einführung

Dieses Mal nahm ich in 6 Wochen an einem Projekt von der Teambildung bis zur Produktfreigabe teil. Bitte beachten Sie den Link unten für das gesamte Projekt. Ich möchte, dass Sie die Artikel und früheren Artikel über mich lesen, aber kurz gesagt, ich bin unerfahren und suche einen Ingenieur.

Klicken Sie hier für das Projekt

In diesem Artikel werde ich das ausgeben, was ich bei der Implementierung der Funktionen gelernt habe, für die ich verantwortlich war.

Über Pandas

Eine Art Python-Modul. Wenn Sie dies eingeben, können Sie verschiedene Funktionen zur Datenanalyse und -analyse verwenden. Weitere Informationen finden Sie unter Offizielle Dokumente und Dieser Artikel. ..

Erst als die Produktion beim ersten MTG entschieden wurde, entschied ich mich für Pandas, aber da ich neu bei Pandas war, bat ich sie, eine der sechs Wochen des Projekts als Vorlernen zu verwenden, also ist es grundlegend. Lerne das Ziel Danach habe ich es benutzt, während ich es gemacht und überprüft habe. Ich konnte es jedoch hauptsächlich nicht ernsthaft einsetzen

• Lesen Sie CSV und konvertieren Sie in DataFrame
• Lesen Sie mehrere CSV-Dateien, kombinieren Sie sie und exportieren Sie sie
• Holen Sie sich nur die Informationen des gewünschten Feldes aus der CSV und geben Sie sie zurück
• Bearbeiten Sie CSV

Das ist der grundlegende Teil. Schauen wir uns jeden an.

Was ist überhaupt eine CSV-Datei?

→ Die Kurzgeschichte ist das Format für Tabellenberechnungssoftware mit Zeilen und Spalten wie EXCEL und Tabellenkalkulationen. Sie können Pandas verwenden, um es zu lesen und zu verarbeiten und Python-Datentypen in dieses Format zu konvertieren. Der DataFrame-Typ ist übrigens das, was Pandas konvertiert haben, damit CSV von Python verarbeitet werden kann.

#Preis Verkaufsmenge Lagerbestand
#Apple 300 10 80%
#Mikan 100 2 20%
#Melone 900 6 60%

Wenn Sie den DataFrame mit print () usw. anzeigen, wird er beispielsweise in der obigen Form angezeigt. Du hast diesen Tisch gesehen.

CSV-Datei lesen

Lassen Sie uns tatsächlich Pandas berühren. Lesen Sie zuerst die CSV-Datei. Was ist übrigens eine CSV-Datei?

client_id,client_name
1,Probe B Co., Ltd.
2,Probe I Co., Ltd.
3,Probe F Co., Ltd.
4,Probe D Co., Ltd.
5,Probe E Co., Ltd.
6,Probe C Co., Ltd.
7,Probe G Co., Ltd.
8,Probe A Co., Ltd.
9,Probe H Co., Ltd.

Es wird eine Datei wie diese sein. Definieren Sie die Feldnamen in der ersten Zeile durch Kommas getrennt. Sie können sehen, dass die zweite und die folgenden Zeilen die Daten darstellen, die in das Feld eingefügt werden. Um es tatsächlich zu lesen, schreiben Sie wie folgt.

python

import glob
import pandas as pd

sample_data = pd.read_csv('sample.csv')

#Wenn es mehrere gibt
df = pd.DataFrame() #Erstellen Sie eine leere Instanz
file_list = glob.glob(CSV_PATH) #Geben Sie den Dateipfad an. Mit dem Glob-Modul`sample/data*`Wenn Sie ein Argument wie festlegen, werden alle CSV-Dateien, die die Zeichenfolge "Daten" in diesem Verzeichnis enthalten, als Ziel ausgewählt.


for file_count in file_list:
    dfn = pd.read_csv(file_count)
    df = pd.concat([df, dfn])

Die Methode "read_csv ()" ist eine Methode zum Lesen von CSV, insbesondere eine Methode zum Konvertieren einer CSV-Datei in den DataFrame-Typ. Das Argument ist der Dateipfad. Denken Sie daran, dass Pandas grundsätzlich als "Pandas als pd importieren" importieren und in Form einer pd. Methode verwenden. Und das Wichtigste ist, dass Sie, wenn Sie beispielsweise mehrere CSVs gleichzeitig lesen möchten, möglicherweise mehrere CSV-Dateien nacheinander zu einer Datei kombinieren möchten, wie oben beschrieben. Deshalb machen wir das. Was machst du

1. Erstellen Sie eine leere Instanz
2. Geben Sie den Dateipfad des Verzeichnisses an, das die CSV-Datei in der Variablen enthält
3. Kombinieren Sie sie in der Reihenfolge mit einer for-Anweisung

Es bedeutet das. Da concat () eine Methode zum Kombinieren von CSV-Dateien ist, können Sie sehen, dass CSV nacheinander mit leeren DataFrame-Instanzen zu einer CSV kombiniert wird. Geben Sie eine Liste als Argument an. Der Dateipfad wird in file_list eingegeben. Da jedoch "sample / data *" angegeben ist, wird die Datei mit dem Dateinamen, der die Zeichenfolgendaten unter sample enthält, wiederholt in aufsteigender Reihenfolge eingegeben. Zum Beispiel

sample
  |
  |-----data1.csv
  |-----data2.csv
  |-----data3.csv

In diesem Fall wird es in der Reihenfolge von "data1.csv" verarbeitet. Da concat () nicht gleichzeitig kombiniert werden kann, handelt es sich um einen solchen Prozess. Übrigens gibt es auch eine Methode namens merge () zum Zusammenführen, die jedoch zum Zusammenführen von Dateien verwendet wird, die denselben Primärschlüssel, aber unterschiedliche Spalten haben.

Versuchen Sie, die CSV-Datei zu einem Python-Wörterbuchtyp zu machen

Als nächstes machen wir die gelesene CSV mit Python bearbeitbar.

import pandas as pd

CSV_COLUMN = ['date','sales','client_id','staff_id']

#Definieren Sie eine leere Liste
data = []
field_names = CSV_COLUMN
#Lesen Sie die Datei ohne zu schreiben.
with open(file_path, 'r', encoding='utf-8') as f:
    #Holen Sie sich jedes Feld im Wörterbuchtyp und fügen Sie es zeilenweise zu den Daten hinzu
    for row in csv.DictReader(f, fieldnames=field_names):
        data.append(row)

Der definierte Feldname wird "CSV_COLUMN" zugewiesen. Verwenden Sie dann with open () as f:, um die schreibgeschützte CSV-Datei zu lesen. Diese Syntax ist nicht auf CSV beschränkt, sondern wird beim Lesen einer Datei verwendet. Die vorherige bestand darin, sie in einen DataFrame-Typ zu konvertieren. Diesmal wird jedoch einfach der Inhalt der Datei abgerufen. Das Argument enthält den Dateipfad, die Optionen und die Codierungseinstellungen, und der gelesene Inhalt wird der Variablen f zugewiesen. Dieses Mal wird es, wie oben erwähnt, als schreibgeschützt im utf-8-Format gelesen. Diesmal wird der Inhalt der gelesenen Datei mit einer for-Anweisung extrahiert. csv.DictReader () ist eine Methode zum Abrufen einer CSV-Datei als Wörterbuch. Ein Beispiel für die Verarbeitung ist wie folgt.

#Wenn Sie eine solche CSV-Datei lesen

date,sales,client_id,staff_id
2020-01-01,8390,8,9
2020-01-02,8712,1,8
2020-01-03,8146,6,8

#Es wird in solchen Daten gespeichert

[([('date', '2020-01-01'), ('sales', '8390'), ('client_id', '8'), ('staff_id', '9')]),
([('date', '2020-01-02'), ('sales', '8712'), ('client_id', '1'), ('staff_id', '8')]),
([('date', '2020-01-03'), ('sales', '8146'), ('client_id', '6'), ('staff_id', '8')])]

Versuchen Sie, die Daten des Wörterbuchtyps zu bearbeiten

Fügen wir den vorherigen Daten ein Feld hinzu.

#Die erste Zeile wird dort als Feldname behandelt`tax_salse`Fügen Sie ein Feld mit dem Namen hinzu
data[0]['tax_sales'] = 'tax_sales'

#Als nächstes die zweite und nachfolgende Zeile(=Der Realwertteil jedes Feldes)Geben Sie den Wert in das neu hinzugefügte Feld mit der for-Anweisung ein.
for row in data[1:]:
    #Zeile Zeile Steuer_Geben Sie den Wert ein, der durch Multiplizieren des Verkaufsfelds mit dem Steuersatz im Feld salse erhalten wurde.
    row['tax_sales'] = int(row['sales']) * (1.0 + TAX_RATE)

Versuchen Sie, verschiedene CSV-Dateien mit Zusammenführungs- und Ausgabe-CSV zu kombinieren

import pandas as pd

CSV_COLUMN_ADD = ['date','sales','tax_sales','client_id', 'client_name','staff_id','staff_name']

#Konvertieren Sie die Daten jedes Wörterbuchtyps in den DataFrame-Typ.
sales_data = pd.DataFrame(sales_data)
client_data = pd.DataFrame(client_data)
staff_data = pd.DataFrame(staff_data)

#verschmelzen
merge1 = pd.merge(sales_data, client_data, how='outer')
merge2 = pd.merge(merge1, staff_data, how='outer')
#Argument CSV_COLUMN_Sortieren Sie die Felder in der Reihenfolge HINZUFÜGEN
merge_data_result = merge2.loc[:,CSV_COLUMN_ADD]
#Index löschen
merge_data_result = merge_data_result.drop(merge_data_result.index[0])

Wie concat () gibt auch merge () zwei Dateien an, die Sie zu Argumenten kombinieren möchten. Wie können Sie angeben, wie Sie beitreten möchten? how = 'Outer' betrachtet denSchlüssel in der Outer Join-Spezifikation und verbindet sich so, dass alle Daten, die sich nur in einer Tabelle befinden, übrig bleiben. Wenn merge () ausgeführt wird, wird der Feldname als Index in der zweiten Zeile hinzugefügt und kann mit der 0. Zeile dupliziert werden, sodass er diesmal mit der drop () -Methode gelöscht wird. Sie können auf den Spaltennamen mitarray name.loc []verweisen. Wenn Sie diesmal dieses Mal anwenden, indem Sie:, CSV_COLUMN_ADD` festlegen, werden alle Spalten in der Reihenfolge CSV_COLUMN_ADD sortiert. ..

Dies ist die grundlegende Verwendung von Pandas und Python.

Erweiterte Version

Lassen Sie uns nun sehen, wie Sie Django verwenden, während Sie tatsächlich mit der Datenbank interagieren. Zum Beispiel, wenn Sie das folgende Modell haben und diese Art der Verarbeitung entsprechend durchführen möchten.

from django.db import models
from accounts.models import CustomUser


class MutualFund(models.Model):
    class Meta:
        db_table = 'MutualFund'
        verbose_name_plural = 'Informationen zum Investment Trust'

    DELETE_FLAG = ((0, 'Nicht gelöscht'), (1, 'Löschen'))

    # id = AutoField(primary_key=True)  #Keine Definition erforderlich, da diese automatisch hinzugefügt wird
    url = models.CharField('Fonds-URL', max_length=255, null=True, blank=True)
    fund_name = models.CharField(
        'Fondsname', max_length=255, null=True, blank=True)
    company = models.CharField('Name der Firma', max_length=255, null=True, blank=True)
    category_obj = models.ForeignKey(
        Category,
        verbose_name='Kategorie',
        on_delete=models.CASCADE
    )
    rate = models.IntegerField('Gesamtwertung', null=True, blank=True)
    return_percent = models.FloatField('Rücklaufquote(3 Jahre)', null=True, blank=True)
    risk = models.FloatField('Risikowert(3 Jahre)', null=True, blank=True)
    fee = models.FloatField('Treuhandgebühren usw. (inklusive Steuern)', null=True, blank=True)
    net_assets = models.IntegerField('Nettovermögen (Millionen Yen)', null=True, blank=True)
    delete_flag = models.IntegerField('Flag löschen', choices=DELETE_FLAG, default=0)

    def __str__(self):
        return self.fund_name

from django.db import models
import sys
import pathlib
# base.Ermitteln Sie den absoluten Pfad des Verzeichnisses, in dem sich py befindet
# current_dir = pathlib.Path(__file__).resolve().parent
# #Pfad mit Modul hinzufügen
# sys.path.append( str(current_dir) + '/../' )

# print(sys.path)
from accounts.models import CustomUser
from fund.models import MutualFund


#Informationen werden von jedem Modell referenziert.
# customuser_obj und gegenseitig_fund_obj ist mit Referrer-Informationen gepackt.

class Portfolio(models.Model):
    customuser_obj = models.ForeignKey(CustomUser, on_delete=models.CASCADE)
    mutual_fund_obj = models.ForeignKey(MutualFund, on_delete=models.CASCADE)
    amount = models.IntegerField(null=True, blank=True)

# risk_col und zurück_Vorläufige Definition von col
risk_col = 0
return_col = 0

#Funktion zum Ermitteln des Risikodifferenz


def risk_differ(x):
    return risk_col - x.loc["risk"]


#Funktion zum Ermitteln der Rückgabedifferenz


def return_differ(x):
    return return_col - x.loc["return_percent"]


def find_fund_near_risk(fund_id, num_fund_obj):
    """
Konvertieren Sie den erfassten Datensatz in DataFrame, erstellen Sie ein neues Feld, speichern Sie die Risikodifferenz mit der angegebenen Marke als absoluten Wert, sortieren Sie sie und geben Sie sie zurück

    Arguments:
        fund_id : str
Handelsname.
        num_fund_obj : int
Anzahl der Akquisitionen.

    Returns:
        brand_risk_near : DataFrame
    """
    #Holen Sie sich Datensätze im Wörterbuchtyp.
    brand_info = MutualFund.objects.values(
        "id", "company", "fund_name", "risk")

    #In DataFrame konvertieren
    brand_info_df = pd.DataFrame(brand_info)

    #Extrahieren Sie Risikofelder ausgewiesener Aktien aus DF
    find_obj = brand_info_df[brand_info_df["id"] == fund_id]
    risk_col = find_obj["risk"]

    #Erstellen Sie ein Feld, um das Berechnungsergebnis der Risikodifferenz einzugeben
    brand_info_df["differ"] = np.nan

    #Speichern Sie den Wert der Risikodifferenz im Feld differ und machen Sie den Wert absolut.
    brand_info_df["differ"] = brand_info_df.apply(risk_differ, axis=1).abs()

    #Löschen Sie die durch das Argument angegebene Informationszeile der Marke
    deleterow = brand_info_df.index[brand_info_df["id"] == fund_id]
    brand_info_df = brand_info_df.drop(deleterow)

    #Sortieren Sie in aufsteigender Reihenfolge und entfernen Sie Differenz- und ID-Felder
    brand_info_df = brand_info_df.sort_values("differ")
    brand_info_df = brand_info_df.drop(columns=["id", "differ"])

    #Nummernlimit
    brand_risk_near = brand_info_df.head(num_fund_obj)

    return brand_risk_near

Es ist jedoch schwer zu verstehen, also lassen Sie uns zuerst überprüfen, wie DB in Django betrieben wird. Einzelheiten und kompliziertere Spezifikationen finden Sie in dem Dokument oder Referenzartikel, da diese leicht verständlich organisiert waren. Ich werde hier einen kurzen Blick darauf werfen.

Erhalten

Es gibt zwei Muster für die Erfassung: Erfassung aller Fälle und Erfassung durch Suche. In allen Fällen erhält models.objects.all () alle Datensätze dieses Modells. Als nächstes wird das Muster gesucht und abgerufen, aber Sie werden die Methode get () oder die Methode filter () verwenden, aber im Grunde werden Sie sie richtig verwenden, da die Rückgabewerte unterschiedlich sind. get () gibt nur einen Datensatz zurück, der dem Argument als ** Objekt ** entspricht. So wird beispielsweise "models.objects.get (pk = 1)" verwendet, wenn Sie nur bestimmte Daten abrufen möchten. Im Gegensatz dazu gibt filter () die übereinstimmenden Datensätze als ** Liste von Objekten ** zurück. Im Grunde wird es also beim Abrufen von Datensätzen verwendet, von denen erwartet wird, dass sie mehrfach registriert werden, z. B. "models.objects.filter (name =" sample ")". Da der Rückgabewert eine Liste von Objekten ist, kann er natürlich nicht so verarbeitet werden, wie er ist. Daher wird die später beschriebene Methode "values ()" verwendet. Wenn Sie etwas wie "get ()" mit "filter ()" ausführen möchten, folgen Sie "filter ()" mit der Methode "first ()". first () gibt den ersten der abgerufenen Abfragesätze als Objekt zurück.

Konvertieren Sie den abgerufenen Datensatz

Möglicherweise möchten Sie, dass einige der erfassten Datensätze vom Typ Wörterbuch oder Liste sind. Verwenden Sie in diesem Fall die Methode values () und ihre abgeleitete Methodevalues_list ().

Verwenden Sie es beispielsweise wie folgt.

#Extrahieren Sie Datensätze aus dem Modell, in dem der Wert des Namensfelds als Beispiel angegeben ist
query = models.objects.filter(name='sample')

#Ruft den ID-Feldwert in einer Liste aus den extrahierten Datensätzen ab
models_column_id_list = query.values_list('id')

#Holen Sie sich ID-, Name- und E-Mail-Felddatensätze in einer Liste von Wörterbüchern direkt aus dem Modell
models_column_dict_list = models.objects.values("id", "name", "email")

Illustration

Kehren wir nun zum Code am Anfang zurück. Dieses Mal habe ich die Risiko- oder Ertragsdifferenz zwischen Aktien als absoluten Wert festgelegt und in aufsteigender Reihenfolge sortiert. Ich habe eine Funktion implementiert, um die Aktien aufzulisten, deren Risiko (Rendite) der angegebenen Aktie ähnlich ist, aber das ist der folgende Code am Anfang.

from fund.models import MutualFund
from portfolio.models import Portfolio
import pandas as pd
import numpy as np
from django.db.models import Count


# risk_col und zurück_Vorläufige Definition von col
risk_col = 0
return_col = 0

#Funktion zum Ermitteln des Risikodifferenz


def risk_differ(x):
    return risk_col - x.loc["risk"]


#Funktion zum Ermitteln der Rückgabedifferenz


def return_differ(x):
    return return_col - x.loc["return_percent"]


def find_fund_near_risk(fund_id, num_fund_obj):
    """
Konvertieren Sie den erfassten Datensatz in DataFrame, erstellen Sie ein neues Feld, speichern Sie die Risikodifferenz mit der angegebenen Marke als absoluten Wert, sortieren Sie sie und geben Sie sie zurück

    Arguments:
        fund_id : str
Handelsname.
        num_fund_obj : int
Anzahl der Akquisitionen.

    Returns:
        brand_risk_near : DataFrame
    """
    #Holen Sie sich Datensätze im Wörterbuchtyp.
    brand_info = MutualFund.objects.values(
        "id", "company", "fund_name", "risk")

    #In DataFrame konvertieren
    brand_info_df = pd.DataFrame(brand_info)

    #Extrahieren Sie Risikofelder ausgewiesener Aktien aus DF
    find_obj = brand_info_df[brand_info_df["id"] == fund_id]
    risk_col = find_obj["risk"]

    #Erstellen Sie ein Feld, um das Berechnungsergebnis der Risikodifferenz einzugeben
    brand_info_df["differ"] = np.nan

    #Speichern Sie den Wert der Risikodifferenz im Feld differ und machen Sie den Wert absolut.
    brand_info_df["differ"] = brand_info_df.apply(risk_differ, axis=1).abs()

    #Löschen Sie die durch das Argument angegebene Informationszeile der Marke
    deleterow = brand_info_df.index[brand_info_df["id"] == fund_id]
    brand_info_df = brand_info_df.drop(deleterow)

    #Sortieren Sie in aufsteigender Reihenfolge und entfernen Sie Differenz- und ID-Felder
    brand_info_df = brand_info_df.sort_values("differ")
    brand_info_df = brand_info_df.drop(columns=["id", "differ"])

    #Nummernlimit
    brand_risk_near = brand_info_df.head(num_fund_obj)

    return brand_risk_near

#Holen Sie sich Datensätze im Wörterbuchtyp.
    brand_info = MutualFund.objects.values(
        "id", "company", "fund_name", "risk")

    #In DataFrame konvertieren
    brand_info_df = pd.DataFrame(brand_info)

In diesem Teil wird der Datensatz durch Angabe des von der Datenbank zu erfassenden Felds erfasst und nach der Erstellung in eine Liste von Wörterbüchern in den DataFrame-Typ konvertiert. In brand_info_df sind die Spalten dann eine Tabelle, die Datensätze in jedem Feld und jeder Zeile darstellt. Dieses Mal müssen wir die Differenz zwischen Risiko und Rendite zwischen den designierten Aktien und anderen Aktien berechnen, damit wir vorerst alle erwerben können.

python

 #Extrahieren Sie Risikofelder ausgewiesener Aktien aus DF
    find_obj = brand_info_df[brand_info_df["id"] == fund_id]
    risk_col = find_obj["risk"]

Bearbeiten Sie dann den DataFrame. Dieses Mal enthält das ID-Feld den Wert des Primärschlüssels. Dies bedeutet, dass das ID-Feld von brand_info_df die Zeile identifiziert, die mit der fund_id übereinstimmt. Und dieses Mal möchte ich die Informationen des Risikofelds aus der angegebenen Zeile, also werde ich sie weiter extrahieren.

python

    #Erstellen Sie ein Feld, um das Berechnungsergebnis der Risikodifferenz einzugeben
    brand_info_df["differ"] = np.nan

    #Speichern Sie den Wert der Risikodifferenz im Feld differ und machen Sie den Wert absolut.
    brand_info_df["differ"] = brand_info_df.apply(risk_differ, axis=1).abs()

    #Löschen Sie die durch das Argument angegebene Informationszeile der Marke
    deleterow = brand_info_df.index[brand_info_df["id"] == fund_id]
    brand_info_df = brand_info_df.drop(deleterow)

    #Sortieren Sie in aufsteigender Reihenfolge und entfernen Sie Differenz- und ID-Felder
    brand_info_df = brand_info_df.sort_values("differ")
    brand_info_df = brand_info_df.drop(columns=["id", "differ"])

    #Nummernlimit
    brand_risk_near = brand_info_df.head(num_fund_obj)

    return brand_risk_near

Hier werden wir ernsthaft Operationen vom Typ DataFrame ausführen. Mit dieser Funktion müssen Sie ** den absoluten Wert des angegebenen Problems und anderer im Datensatz registrierter Probleme berechnen und in aufsteigender Reihenfolge sortieren **. Ich konnte den Prozess jedoch nicht nur mit dem Abfragesatz schreiben (Zauber, der Daten aus der Datenbank abruft), daher implementiere ich ihn auf diese Weise mit Pandas. Vielleicht ist das nicht besser, also nimm es nicht zu viel, und wenn du Code hast, der diesen Prozess nur mit dem Abfragesatz ausdrücken kann, wäre es hilfreich.

Ruhiges Gespräch, schauen wir uns den Code an.

Da das ursprüngliche Modell kein Feld hat, das einen absoluten Wert darstellt, fügen wir es zunächst dem DataFrame hinzu. Erstellen Sie ein neues Feld, indem Sie "np.nan" der Bibliothek mit dem Namen "numpy" verwenden und vorerst fehlende Werte in das erstellte Feld einfügen. Ersetzen Sie als nächstes den fehlenden Wert durch einen absoluten Wert. Die Methode apply () ist eine Methode, die eine Funktion auf einen DataFrame anwendet. Das Argument hat die Form "anwenden (Funktion anwenden, Ort anwenden)". Der anzuwendende Ort kann als Element, Spalte und Zeile angegeben werden. Wenn beispielsweise "Achse = 1" wie diesmal festgelegt ist, wird er auf jede Zeile von DataFrame angewendet. abs () ist eine Methode, die einen absoluten Wert zurückgibt. In Bezug auf risk_differ

python

def risk_differ(x):
    return risk_col - x.loc["risk"]

Ist definiert als. Da risk_col den Risikowert des angegebenen Bestands enthält, sollten Sie den Risikowert des Datensatzes jeder Zeile davon abziehen. Dies fügt in jede Zeile einen absoluten Wert in brand_info_df [" differ "] ein.

An diesem Punkt müssen Sie nur noch das Erscheinungsbild festlegen. Wenn dies unverändert bleibt, werden die ausgewiesenen Bestände weiterhin in die Tabelle aufgenommen. Diesmal ist der Unterschied im Risiko (Rendite) der designierten Aktie gering = der Prozess besteht darin, Aktien mit ähnlichem Risiko (Rendite) für die designierte Aktie aufzulisten. Die Zeile der angegebenen Marke wird gelöscht. Weisen Sie zunächst die extrahierte Zeile der angegebenen Marke der Variablen "Zeile löschen" zu. Dieses Mal wird der Index der Methode get_loc () verwendet, um die Zeilennummer der angegebenen Marke abzurufen und zu ersetzen. Wenn Sie es dann dem Argument der Methode drop () zuweisen, wird der Löschvorgang abgeschlossen.

Als nächstes wird sortiert. Es gibt verschiedene Möglichkeiten, einen DataFrame zu sortieren. Dieses Mal möchten wir jedoch anhand der Werte sortieren. Daher verwenden wir die Methode sort_values (), mit der die Elemente sortiert werden. Das Argument gibt das Feld an, das Sie sortieren möchten. Wenn Sie übrigens in absteigender Reihenfolge sortieren möchten, geben Sie es im zweiten Argument als "ascending = False" zurück. Danach werden die unnötigen Felder bei der Anzeige auf dem tatsächlichen Bildschirm mit der vorherigen drop () Methode gelöscht. Verwenden Sie abschließend die Methode head (), um die angegebene Anzahl von Elementen von Anfang an abzurufen und mit return zurückzugeben. Wenn Sie danach eine Rückgabeversion davon erstellen, ist die Arbeit abgeschlossen.

In diesem Projekt habe ich gelernt, dass es möglich ist, die von der Datenbank erfassten Informationen in einen DataFrame zu konvertieren und die verarbeitete zurückzugeben.

Anwendung 2

Bis zu diesem Punkt haben wir den DataFrame verarbeitet. Wenn Sie jedoch auf das Feld für den erfassten Datensatz verweisen und die Aggregationsverarbeitung durchführen, können Sie dies auch in der Kategorie DB-Operation tun. Als Beispiel ist die Verarbeitung wie folgt.

python

def find_fund_popular_user(fund_id, num_fund_obj):
    """
Extrahieren Sie andere Marken, die die Person besitzt, der die Argumentmarke gehört

    Arguments:
        fund_id : int
        num_fund_obj : int

    Returns:
        fund_list : list
    """
    #Durchsuchen Sie das Portfolio-Modell aus der Ausgabe des Arguments und extrahieren Sie die Benutzer, die die Ausgabe des Arguments haben
    query = Portfolio.objects.filter(mutual_fund_obj__id__exact=fund_id)

    #Benutzeridentifikation(customuser_obj)Nur in Liste extrahieren
    query = query.values_list('customuser_obj', flat=True)

    #Extrahieren Sie alle Datensätze, die die extrahierte ID enthalten
    customuser_obj_id_list = Portfolio.objects.filter(customuser_obj__in=query)

    #Spielen Sie die Marke des Arguments
    customuser_obj_id_list = Portfolio.objects.exclude(
        mutual_fund_obj__id__exact=fund_id)

    #Diesmal Fonds_id(mutual_fund_obj)Extraktion
    mutual_fund_obj_list = customuser_obj_id_list.values('mutual_fund_obj')

    #Aggregieren Sie die Anzahl der Vorkommen und erhalten Sie die Anzahl der Argumente von oben
    fund_count = mutual_fund_obj_list.annotate(portfolio_fund_count=Count(
        expression='mutual_fund_obj'))

    fund_count_list = fund_count.order_by(
        '-portfolio_fund_count')[0:num_fund_obj]

    #mit for, fund_count_Ruft die entsprechenden MutualFund-Objekte für die Anzahl der Listen ab, speichert sie in einer leeren Liste und gibt sie zurück.
    fund_list = []
    for fund_record in fund_count_list:
        fund = MutualFund.objects.get(pk=fund_record['mutual_fund_obj'])
        fund_list.append(fund)

    return fund_list

python

    #Durchsuchen Sie das Portfolio-Modell aus der Ausgabe des Arguments und extrahieren Sie die Benutzer, die die Ausgabe des Arguments haben
    query = Portfolio.objects.filter(mutual_fund_obj__id__exact=fund_id)

    #Benutzeridentifikation(customuser_obj)Nur in Liste extrahieren
    query = query.values_list('customuser_obj', flat=True)

    #Extrahieren Sie alle Datensätze, die die extrahierte ID enthalten
    customuser_obj_id_list = Portfolio.objects.filter(customuser_obj__in=query)

    #Spielen Sie die Marke des Arguments
    customuser_obj_id_list = Portfolio.objects.exclude(mutual_fund_obj__id__exact=fund_id)

    #Diesmal Fonds_id(mutual_fund_obj)Extraktion
    mutual_fund_obj_list = customuser_obj_id_list.values('mutual_fund_obj')

Erstens hat dieser Teil einen ähnlichen Fluss wie zuvor. Der Unterschied besteht darin, dass die Informationen aus den zugehörigen Modellen stammen. Das "Portfolio" -Modell ist mit dem "MutualFund" -Modell und dem "CustomUser" -Modell verwandt, auf die in diesem Prozess nicht verwiesen wird. Das "Portfolio" -Modell ist die Seite, die auf jedes Modell verweist. Sehen Sie sich das Bild unten an, um zu sehen, was passiert.

Wie Sie sehen können, sind die Felder "Customuser obj" und "Mutual Fund obj" Pulldown-Menüs. Dies bedeutet, dass das Feld "Customuser obj" Informationen über das "CustomUser" -Modell enthält, auf die der externe Schlüssel verweist, und das Feld "Mutual Fund obj" auch auf den "MutualFund" des externen Schlüssels verweist. Es zeigt, dass alle Informationen der Aufzeichnung von gepackt sind. Mit anderen Worten, wenn Sie den externen Schlüssel kennen, können Sie die Informationen des "MutualFund" -Modells aus dem "Portfolio" -Modell abrufen. Das macht die erste Codezeile oben.

Dieses Mal möchte ich zunächst Benutzer extrahieren, die eine Marke mit "pk = fund_id" im Modell "MutualFund" haben, die eine Marke als Argument = registrierte Marke hat. Dies bedeutet, nach dem Wert von id im Feld "Investmentfondsobjekt" zu filtern. Zu diesem Zeitpunkt, wenn Sie auf den Wert des referenzierten Felds verweisen möchten Es hat die Form eines Feldnamens, der die referenzierten Informationen enthält. Der Feldname, auf den Sie sich beziehen möchten. Da "genau" eine Option ist, die als exakte Übereinstimmung bezeichnet wird, extrahieren wir dieses Mal die Option, die genau mit fund_id übereinstimmt. Anschließend werden die Benutzer mit der angegebenen Marke extrahiert. Verwenden Sie dieses Mal die Methode value_list (), um das Customuser obj zu extrahieren, das voller Benutzerinformationen in der Liste ist.

An dieser Stelle möchte ich die Marken der extrahierten Benutzer extrahieren, damit ich das Portfolio-Modell erneut filtern kann. Hier habe ich zuvor "Customuser obj" aus der Liste extrahiert, um es als Suchbedingung für Filter zu verwenden. Wenn Sie die Referenznotation früher anwenden, können Sie die Suchbedingung auf setzen, wenn das referenzierte Feld ~ enthält, indem Sie den Feldnamen __in = ～ festlegen, der mit den referenzierten Informationen gefüllt ist. .. Wenn Sie es extrahieren, ist natürlich auch die Marke des Arguments enthalten. Schließen Sie es daher mit der Methode exclude ()` aus. Zu diesem Zeitpunkt konnten wir andere Probleme als die von Benutzern mit dem angegebenen Problem angegebenen extrahieren. Da wir jedoch nur das Feld "Mutual_Fund_obj" für die Aggregation benötigen. Konvertieren Sie abschließend das Feld "Mutual_Fund_obj" in den Wörterbuchtyp.

Wenn Sie zu diesem Punkt kommen, ist der Rest der Aggregationsprozess.

Es gibt verschiedene Möglichkeiten, Abfragen und Abfragesätze zu aggregieren, aber das diesmal verwendete annotate () ist eine Methode, die gegen Abfragesätze aggregiert. Es gibt eine andere Methode, die für einen Abfragesatz aggregiert: "aggregat ()", aber "annotate ()" wird für Modelle mit Beziehungen verwendet. Insbesondere scheint es verwendet zu werden, wenn Sie für das Feld aggregieren möchten, das die Informationen des referenzierten Modells enthält. Dieses Mal möchte ich eine Funktion implementieren, die ** andere Marken von Benutzern mit dem angegebenen Argument Marke in der Reihenfolge ihrer Beliebtheit sortiert und anzeigt (die meisten Benutzer haben diese Marke) **. Wie wir uns bisher in diesem Prozess vorbereitet haben, möchten wir die Aggregationsverarbeitung für "Mutual_Fund_obj" durchführen, daher verwenden wir "Annotate ()". Der eigentliche Codeteil lautet wie folgt: Überprüfen wir ihn.

python

    #Aggregieren Sie die Anzahl der Vorkommen und erhalten Sie die Anzahl der Argumente von oben
    fund_count = mutual_fund_obj_list.annotate(portfolio_fund_count=Count(
        expression='mutual_fund_obj'))

    fund_count_list = fund_count.order_by(
        '-portfolio_fund_count')[0:num_fund_obj]

    #mit for, fund_count_Ruft die entsprechenden MutualFund-Objekte für die Anzahl der Listen ab, speichert sie in einer leeren Liste und gibt sie zurück.
    fund_list = []
    for fund_record in fund_count_list:
        #Ich möchte Markendaten, also finanzieren_count_Fonds mit für in Liste gespeichert_Gegenseitig in die Aufzeichnung abgerufen_fund_Holen Sie sich mit obj gegen MutualFund()multiplizieren
        fund = MutualFund.objects.get(pk=fund_record['mutual_fund_obj'])
        fund_list.append(fund)

    return fund_list

Wie war Mutual_Fund_obj_list?

    #Spielen Sie die Marke des Arguments
    customuser_obj_id_list = Portfolio.objects.exclude(mutual_fund_obj__id__exact=fund_id)

    #Diesmal Fonds_id(mutual_fund_obj)Extraktion
    mutual_fund_obj_list = customuser_obj_id_list.values('mutual_fund_obj')

Es war so. Wenn Sie auf dieser Grundlage zuerst "annotate ()" erklären

mutual_fund_obj_list.annotate(portfolio_fund_count=Count(expression='mutual_fund_obj'))

Erstellen Sie in diesem Teil ein Feld "Portfolio_Fund_Count" im Portfolio-Objekt und denken Sie, dass das Ausführungsergebnis der Methode "Count ()" dort eingefügt wird. Ich habe mit DataFrame ein neues Feld erstellt und das Berechnungsergebnis eingefügt, aber das Bild ist ähnlich. Count (expression = 'Investment_Fund_obj') ist der Prozess des Zählens, wie viele Mutual_Fund_objs erschienen sind. Zu diesem Zeitpunkt sind die Informationen, die aggregiert werden, die Informationen, die sich auf den Inhalt von "Mutual_Fund_obj" beziehen. Um es grob auszudrücken

Marke A gehört 5 Benutzern
Marke B gehört 3 Benutzern

……

Wird aggregiert. (Das obige Beispiel ist nur ein Bild) Danach können Sie die aggregierten Ergebnisse in aufsteigender Reihenfolge nach "order_by" sortieren. Für den Teil von "[0: num_fund_obj]" wird die Anzahl der Erfassungen in "num_fund_obj" eingegeben.

Wenn dies erledigt ist, verwenden Sie die for-Anweisung für die endgültige fund_count_list, um die Daten an die Vorlage zu übergeben, und speichern Sie die Daten in einer leeren Liste, um die Arbeit abzuschließen.

(pk=fund_record['mutual_fund_obj'])

Dieser Teil gibt pk mit den Informationen von Mutual_Fund_obj an, die durch die for-Anweisung extrahiert wurden. Das liegt daran, dass Mutual_Fund_obj natürlich Informationen über den Primärschlüssel der Marke enthält.

Erstellen eines Prozesses (Views.py) zum Übergeben von Daten an eine Vorlage

Sobald die Daten fertig sind, schreiben wir den Prozess der Übergabe an die Vorlage zur Anzeige auf dem Bildschirm. Der Code ist unten.

class FundDetail(LoginRequiredMixin, View):

    """
- Informieren Sie sich über Aktien mit ähnlichen Risiken und Aktien mit ähnlichen Renditen.
・ Extrahieren Sie andere Marken, die die Person besitzt, der die Argumentmarke gehört
    """

    def get(self, request, fund_id, *args, **kwargs):

        #Einstellung der Erfassungsnummer
        num_fund_obj = 5

        #Ersetzen Sie eine Liste von Aktien mit ähnlichen Risiken und Erträgen durch Variablen
        brand_risk_near_list = find_fund_near_risk(fund_id, num_fund_obj)
        brand_return_near_list = find_fund_near_return(fund_id, num_fund_obj)

        #DataFrame-Header-Informationen
        brand_risk_near_header = brand_risk_near_list.columns.tolist()
        brand_return_near_header = brand_return_near_list.columns.tolist()

        #Informationen zum DataFrame-Inhalt
        brand_risk_near_contents = brand_risk_near_list.values.tolist()
        brand_return_near_contents = brand_return_near_list.values.tolist()

        #Holen Sie sich die anderen Marken, die der Benutzer mit dem Argument Marke hat, vom Anfang der registrierten Nummer
        fund_popular_list = find_fund_popular_user(fund_id, num_fund_obj)

        context = {
            'risk_header': brand_risk_near_header,
            'risk_contents': brand_risk_near_contents,
            'return_header': brand_return_near_header,
            'return_contents': brand_return_near_contents,
            'popular_user_funds': fund_popular_list,
        }
        return render(request, 'fund/fund_detail.html', context=context)

Dieses Mal übergeben wir Daten und Objekte vom Typ DataFrame, aber die Übergabemethode ist für jede unterschiedlich. Zunächst werden im Fall des DataFrame-Typs Daten für den Header (Feldinformationen) und den Inhalt (Wert jedes Felds) in views.py getrennt übergeben. Im Falle eines Objekts wird es so übergeben, wie es ist. Nachdem Sie diese Daten in Variablen gespeichert haben, definieren Sie sie so, dass sie von der Vorlage im Kontext aufgerufen werden können. Wenn Sie beispielsweise "brand_risk_near_header" in der Vorlage aufrufen möchten, schreiben Sie "ris_header". Wenn Sie diesen Punkt erreicht haben, können Sie die Render-Methode verwenden, um "Kontext" an die Vorlage zu übergeben und mit "für" abzurufen.

Die Vorlage lautet wie folgt.

<div class="row">
    {% comment %}Liste der Bestandsinformationen mit ähnlichen Risiken{% endcomment %}
    <div class="col">
        <h5>Aktien mit ähnlichem Risiko wie diese Aktie</h5>
        <div class="">
            <table class="table">
                    <thead>
                    <tr>{% for row in risk_header %}
                        <th>{{ row }}</th>{% endfor %}</tr>
                    </thead>
                    <tbody>
                    {% for i in risk_contents %}
                        <tr>{% for row1 in i %}
                            <td>{{ row1 }}</td>{% endfor %}</tr>
                    {% endfor %}
                    </tbody>
                </table>
            </div>
        </div>
            {% comment %}Liste der Bestandsinformationen mit ähnlichen Renditen{% endcomment %}
        <div class="col">
            <h5>Aktien mit ähnlichen Renditen wie diese Aktie</h5>
            <div class="">
                <table class="table">
                    <thead>
                    <tr>{% for row in return_header %}
                        <th>{{ row }}</th>{% endfor %}</tr>
                    </thead>
                    <tbody>
                    {% for i in return_contents %}
                        <tr>{% for row1 in i %}
                            <td>{{ row1 }}</td>{% endfor %}</tr>
                    {% endfor %}
                    </tbody>
                </table>
            </div>
        </div>
    </div>
            <div class="">
            <h5>Leute, die diese Marke kaufen, kaufen auch diese Marke</h5>
            <div class="">
                <table class="table">
                    <thead>
                    <tr>
                        <th>Fondsname</th>
                        <th>Rückkehr</th>
                        <th>Risiko</th>
                    </tr>
                    </thead>

                    <tbody>
                    {% for fund in popular_user_funds %}
                        <tr>
                            <th>
                                <a href=" /fund/detail/{{ fund.id }} ">{{ fund.fund_name }}</a>
                            </th>
                            <th>{{ fund.return_percent }}</th>
                            <th>{{ fund.risk }}</th>
                        </tr>
                    {% endfor %}

                    </tbody>
                </table>
            </div>
        </div>
    </div>

Eine Sache, bei der Sie vorsichtig sein müssen, ist das Abrufen von "risk_contents". Dies enthält den Wert jedes Feldes im DataFrame, das in eine Liste mit "values.tolist ()" konvertiert und übergeben wird. Die diesmal ausgetauschten Daten haben Zeilen und Spalten wie unten gezeigt ... Das ist in Ordnung.

#       col1  col2  col3
# row1     0     1     2
# row2     3     4     5

#Df den obigen DataFrame.values.tolist()Wenn es in gespeichert ist, wird es wie folgt

# [[0, 1, 2], [3, 4, 5]]

#Übrigens Spalten in diesem DataFrame.tolist()Wird wie folgt gespeichert

# # ['col1', 'col2', 'col3']

Dann möchte ich zum Beispiel die Daten von row1 abrufen! Selbst wenn dies der Fall ist, gibt es drei Arten von "col1 ~ 3". Wenn Sie umgekehrt die Daten von "col1" abrufen möchten, haben Sie möglicherweise "row1 ~ 2". In diesem Fall ist die Art und Weise, wie in der Liste gespeichert wird, nicht das primäre Array wie das Ergebnis in "columns.tolist ()", kann jedoch nur dann gut abgerufen werden, wenn es sich um ein sekundäres Array handelt. Speichern Sie es daher wie im obigen Beispiel. Stellen Sie sich vor, Sie sind.

Das Abrufen eines Objekts in einer Vorlage entspricht der normalen for-Anweisung. Zunächst übergibt "{% für Fonds in popular_user_funds%}" jeden "Mutual_Fund_obj" an die Variable "Fonds". Danach ist, wie ich wiederholt erwähnt habe, das "Mutual_Fund_obj" des Portfolio-Modells, das dieses Mal übergeben wurde, mit "MutualFund" verbunden. Es ist also in Ordnung, wenn Sie es in Form von "Fund" schreiben. Informationen zum Feld des MutualFund-Modells, das Sie extrahieren möchten. Wird sein.

Referenz

Zeilen- und Spaltennummern für pandas.DataFrame abrufen sort_values, sort_index zum Sortieren von pandas.DataFrame, Series [Flask] Übergeben Sie pandas.Series und pandas.DataFrame an die Client-Seite Konvertieren Sie die Standardliste pandas.DataFrame, Series und Python ineinander Pandas grundlegende Operation, die häufig in der Datenanalyse verwendet wird Zusammenfassung der Django-Datenbankoperationen Django-Dokument 1 Django-Dokument 2 Django Reverse Pull Cheet Sheet (Abfragesatz) Gesamtverarbeitung mit Django