En réalité, l'attention et l'intérêt des gens pour la préparation, le calcul et la visualisation des données sont d'environ 1: 4: 5, alors que le rapport en pratique est d'environ 6: 2: 2. C'est juste une sensation, mais est-il sûr de dire que la plupart de l'analyse est une préparation pour mettre les données dans un état calculable? C'est pourquoi aujourd'hui j'écrirai une série de techniques que j'utilise souvent en Python, qui met l'accent sur la convivialité en tant que langage glu.
Il n'y a rien de nouveau sur le contenu, mais la conversion du format JSON est un prétraitement courant. Je vais le laisser comme mémo pour ne pas l'oublier.
En Python, les structures de données au format JSON peuvent être gérées par import json. Une fois chargé, il devient un format de données de dictionnaire (hachage dans d'autres langues), qui peut également être au format JSON.
Supposons un fichier CSV séparé par clé et valeur. Supposons que la partie valeur contienne des données texte au format JSON sérialisées par un autre système. Pour le charger, vous pouvez fractionner la chaîne en spécifiant un délimiteur comme suit et charger JSON en tant qu'objet de type dictionnaire avec la méthode json.load.
import json
file = open(self.filename, 'r')
for line in file:
key, value = line.rstrip().split(",")
dic = json.loads(value)
D'autre part, lors de l'écriture d'un objet de type dictionnaire dans un fichier ou une sortie standard au format JSON, utilisez json.dumps comme suit.
import json
json_obj = json.dumps(dic)
print(json_obj)
C'est facile.
Les arguments passés au script Python sont stockés dans sys.argv.
import sys
if __name__ == '__main__':
argsmin = 1
if len(sys.argv) > argsmin:
some_instance = SomeClass(sys.argv)
some_instance.some_method()
Si vous le transmettez lors de l'initialisation de l'instance, vous pouvez l'utiliser en stockant l'argument dans la variable d'instance.
class SomeClass:
def __init__(self, args):
self.filename = args[1]
Python suppose généralement qu'une méthode est une méthode privée en la préfixant avec un _.
def self._some_method(self):
...
Cela ne peut certainement pas être appelé comme some_instance.some_method. Mais vous pouvez en fait l'appeler explicitement avec some_instance._some_method. C'est habituel et pas fonctionnellement privé.
Utilisez deux __ pour l'empêcher d'être appelé de manière fonctionnelle.
def self.__some_method(self):
...
Cependant, même avec cela, il existe une manière délicate de l'appeler, et la testabilité de la méthode privée sera réduite, donc je ne la recommande pas beaucoup. Le fait que vous puissiez appeler une méthode privée est, en d'autres termes, plus facile lors des tests.
Il existe de nombreux frameworks de test différents pour Python, mais nose est relativement facile à utiliser. Tout d'abord, considérons une méthode qui se comporte comme suit.
import factorial
factorial.factorial(10)
#=> 3628800
Disons que ce code Python s'appelle factorial.py et que l'implémentation de la méthode ressemble à ceci.
def factorial(n):
if n==1:
return 1
else:
return n * factorial(n-1)
Pour tester cela, créez un fichier nommé test_factorial.py et écrivez le code de test comme suit:
from nose.tools import * #Chargement du framework de test
from factorial import * #Chargement du code en cours de test
def test_factorial(): #Tester la méthode factorielle
i=10
e=3628800
eq_(e,factorial(i)) #Vérification
Ce qui précède équivaut à faire eq_ (3628800, factorial (10)). La méthode eq_ vérifie que les valeurs sont égales.
Après avoir implémenté le code de test, exécutez la commande nosetests à partir du shell.
$ nosetests
.
----------------------------------------------------------------------
Ran 1 test in 0.008s
OK
Il est facile de passer beaucoup de temps à préparer des données stables. Cette fois, j'ai résumé les techniques souvent utilisées dans de tels travaux sous la forme d'un mémorandum.
Recommended Posts