Je dessine souvent des graphiques à partir de ** Python ** en utilisant ** matplotlib **. Les données sont générées par l'application ** Python **, formatées et générées par le graphique ** matplotlib **.
À ce moment-là, j'avais les problèmes suivants.
Le code que vous écrivez ** visualise les données ** et le code que vous écrivez ** gère la conception ** Je pensais que c'était parce qu'il était écrit dans une seule application.
J'ai essayé de séparer le code pour ** gérer la conception ** en tant que ** fichier de configuration **.
Parmi les trois problèmes répertoriés, la «conception graphique n'est pas unifiée» est Cela signifie que la ** taille de l'étiquette **, la ** légende **, les ** points tracés **, etc. affectés aux axes vertical et horizontal ne sont pas unifiés.
Ceci est également lié à la deuxième tâche, car j'ai fait une ** description similaire ** dans un autre fichier Python.
Le problème était qu'il n'était pas ** unifié **, et je faisais une ** copie ** en me référant aux anciens fichiers Python sur place.
La raison pour laquelle ** copier-coller ** est répété est que le ** design ** et le ** code ** que je recherche Je pense que c'est parce que ce n'est pas lié, du moins pas intuitif. Cela conduit au troisième défi.
Je pensais que la raison de ces trois défis était que ** les données ** et la ** conception ** n'étaient pas ** séparées **.
Si tel est le cas, l'histoire est simple: séparez le ** design ** dans un ** fichier de configuration **.
J'ai essayé de faire correspondre le design et le mot comme indiqué dans le tableau ci-dessous.
La signification de chaque élément est
est.
-** Position ** - subplot --Où placer le graphique - pyplot.figure.add_subplot(subplot) - legend_location
Pour le fichier de paramètres, nous avons considéré plusieurs méthodes d'expression, telles que json et yaml.
En conséquence, j'ai décidé d'utiliser le standard ** [configparser] 1 ** pour Python.
Je pense que json et yaml sont bien, mais j'ai pensé qu'il serait préférable de ** utiliser intuitivement ** plutôt que de l'exprimer de manière hiérarchique.
Le fichier de configuration est représenté par ** configparser ** comme suit.
config.ini
[Size]
figure_x=8
figure_y=8
font_title=20
font_x_label=18
font_y_label=18
font_tick=10
font_legend=15
marker=10
[Position]
subplot=111
legend_location=upper right
[Markers]
0=D
1=>
2=.
3=+
4=|
[Color]
0=red
1=blue
2=green
3=black
4=yellow
Les éléments qui correspondent à la ** classification de conception ** sont placés entre ** crochets ** tels que ** [Taille] **. C'est ce qu'on appelle la ** section **. En dessous, écrivez ** paramètre = valeur ** du fichier de paramètres. C'est ce qu'on appelle la ** clé **.
En plus de ** Taille ** et ** Position **, le fichier de configuration ci-dessus comprend également ** Marqueurs (type de marqueurs à tracer) ** et ** Couleur (couleur des marqueurs et des lignes à tracer) **. C'est exprimé.
Pour accéder aux paramètres du fichier de configuration, écrivez le code comme suit:
import configparser
rule_file = configparser.ConfigParser()
rule_file.read("chemin du fichier de configuration", "UTF-8")
hogehoge = rule_file["Nom de la section"]["Nom de la clé"]
Notez que la valeur lue sera une ** chaîne **.
Le code ci-dessous crée un graphique en lignes de pliage basé sur les ** données transmises ** et le ** fichier de configuration de conception **.
make_line_graph.py
"""Fonction de création de graphique linéaire
Dessinez un graphique linéaire en utilisant les données transmises et enregistrez-le comme données d'image.
"""
import configparser
import matplotlib.pyplot as plt
def make_line_graph(data, config="config.ini"):
"""Dessin graphique linéaire
Créez un graphique linéaire en utilisant les données transmises.
Lisez la conception à partir d'un autre fichier de configuration.
Args:
data(dict):Contient des données à tracer
config(str):Le nom du fichier de configuration
Returns:
bool:Si True, la création est terminée, si False, la création échoue
Note:
La clé et la valeur à inclure dans les données d'argument sont décrites ci-dessous.
key : value
------------------------
title(str):Nom du titre du graphique
label(list):Description de la légende
x_data(list):données de l'axe des x
y_data(list):données de l'axe y
x_ticks(list):Valeur à afficher dans la mémoire de l'axe x
y_ticks(list):Valeur à afficher dans la mémoire de l'axe y
x_label(str):nom de l'axe des x
y_label(str):nom de l'axe y
save_dir(str):Enregistrer le chemin du fichier
save_name(str):Enregistrer le nom du fichier
file_type(str):Enregistrer le format de fichier
"""
rule_file = configparser.ConfigParser()
rule_file.read("./conf/{0}".format(config), "UTF-8")
fig = plt.figure(figsize=(int(rule_file["Size"]["figure_x"]), int(rule_file["Size"]["figure_y"])))
ax = fig.add_subplot(int(rule_file["Position"]["subplot"]))
ax.set_xlabel(data["x_label"], fontsize=int(rule_file["Size"]["font_x_label"]))
ax.set_ylabel(data["y_label"], fontsize=int(rule_file["Size"]["font_y_label"]))
for index in range(len(data["x_data"])):
ax.plot(data["x_data"][index],
data["y_data"][index],
label=data["label"][index],
color=rule_file["Color"][str(index)],
marker=rule_file["Markers"][str(index)],
markersize=int(rule_file["Size"]["marker"]))
plt.title(data["title"], fontsize=int(rule_file["Size"]["font_title"]))
if "x_ticks" in data.keys():
plt.xticks(data["x_ticks"][0], data["x_ticks"][1])
if "y_ticks" in data.keys():
plt.yticks(data["y_ticks"][0], data["y_ticks"][1])
plt.tick_params(labelsize=int(rule_file["Size"]["font_tick"]))
plt.legend(fontsize=rule_file["Size"]["font_legend"], loc=rule_file["Position"]["legend_location"])
plt.savefig("".join([data["save_dir"], "/", data["save_name"], ".", data["file_type"]]))
Le fichier Python qui transmet les données ressemble à ceci:
main.py
from make_line_graph import make_line_graph
data = {
"title": "hogehoge",
"label": ["A", "B"],
"x_data": [x_data1, x_data2],
"y_data": [y_data1, y_data2],
"x_ticks": [x_ticks1, x_ticks2],
"y_ticks": [y_ticks1, y_ticks2],
"x_label": "hogehoge",
"y_label": "hogehoge",
"save_dir": "Chemin du dossier que vous souhaitez enregistrer",
"save_name": "Nom du fichier que vous souhaitez enregistrer",
"file_type": "extension",
}
make_line_graph(data, config="config.ini")
Le design est plus facile à changer. En particulier, différentes tailles de police varient en fonction des données à tracer et du nombre de caractères à inclure dans l'étiquette.
De plus, en dupliquant et en personnalisant le fichier de paramètres, la quantité de fichiers Python change lorsque vous souhaitez modifier la conception du graphique a été réduite. Il vous suffit de modifier le nom du fichier de paramètres à lire.
Étant donné que la conception du graphe et le fichier de paramètres sont liés, il est prudent d'oublier quelle conception correspond à quel code.
Il est difficile de le rendre polyvalent.
Le ** make_line_graph.py ** que j'ai créé est une fonction de création de graphique linéaire, mais je ne veux pas avoir plus de fichiers Python similaires, donc je l'ai rendu aussi polyvalent que possible. Cependant, cela ne dessine pas bien le graphe, et si une autre fonction de création de graphe linéaire est encombrée pour y correspondre, il semble qu'elle reviendra au dessin.
Je me demande s'il n'y a pas de fin compte tenu de sa polyvalence.
Recommended Posts