In Wirklichkeit beträgt die Aufmerksamkeit und das Interesse der Menschen an der Datenaufbereitung, -berechnung und -visualisierung etwa 1: 4: 5, während das Verhältnis in der Praxis etwa 6: 2: 2 beträgt. Dies ist nur eine Sensation, aber kann man mit Sicherheit sagen, dass der größte Teil der Analyse eine Vorbereitung für das Einrichten der Daten in einem berechenbaren Zustand ist? Aus diesem Grund werde ich heute eine Reihe von Techniken schreiben, die ich häufig in Python verwende und die die Benutzerfreundlichkeit als Klebesprache hervorheben.
Der Inhalt ist nichts Neues, aber das Konvertieren des JSON-Formats ist eine übliche Vorverarbeitung. Ich werde es als Memo hinterlassen, damit ich es nicht vergesse.
In Python können JSON-formatierte Datenstrukturen durch Import json verarbeitet werden. Beim Laden wird es zu einem Datenformat für Wörterbücher (Hash in anderen Sprachen), das auch im JSON-Format vorliegen kann.
Angenommen, eine CSV-Datei ist durch Schlüssel und Wert getrennt. Angenommen, der Wertteil enthält Textdaten im JSON-Format, die von einem anderen System serialisiert wurden. Zum Laden können Sie die Zeichenfolge teilen, indem Sie ein Trennzeichen wie folgt angeben und JSON mit der Methode json.load als Objekt vom Typ Wörterbuch laden.
import json
file = open(self.filename, 'r')
for line in file:
key, value = line.rstrip().split(",")
dic = json.loads(value)
Wenn Sie dagegen ein Objekt vom Typ Wörterbuch in eine Datei oder eine Standardausgabe im JSON-Format schreiben, verwenden Sie json.dumps wie folgt.
import json
json_obj = json.dumps(dic)
print(json_obj)
Es ist einfach.
Die an das Python-Skript übergebenen Argumente werden in sys.argv gespeichert.
import sys
if __name__ == '__main__':
argsmin = 1
if len(sys.argv) > argsmin:
some_instance = SomeClass(sys.argv)
some_instance.some_method()
Wenn Sie es beim Initialisieren der Instanz übergeben, können Sie es verwenden, indem Sie das Argument in der Instanzvariablen speichern.
class SomeClass:
def __init__(self, args):
self.filename = args[1]
Python geht normalerweise davon aus, dass eine Methode eine private Methode ist, indem ihr ein _ vorangestellt wird.
def self._some_method(self):
...
Dies kann sicherlich nicht als some_instance.some_method bezeichnet werden. Sie können es jedoch explizit mit some_instance._some_method aufrufen. Es ist gewohnheitsmäßig und nicht funktional privat.
Verwenden Sie zwei __, um zu verhindern, dass es funktional aufgerufen wird.
def self.__some_method(self):
...
Trotzdem gibt es eine schwierige Möglichkeit, es aufzurufen, und die Testbarkeit der privaten Methode wird verringert, so dass ich es nicht sehr empfehle. Die Tatsache, dass Sie eine private Methode aufrufen können, ist beim Testen mit anderen Worten einfacher.
Es gibt viele verschiedene Test-Frameworks für Python, aber Nase ist relativ einfach zu verwenden. Stellen Sie sich zunächst eine Methode vor, die sich wie folgt verhält.
import factorial
factorial.factorial(10)
#=> 3628800
Angenommen, dieser Python-Code heißt factorial.py und die Methodenimplementierung sieht folgendermaßen aus.
def factorial(n):
if n==1:
return 1
else:
return n * factorial(n-1)
Um dies zu testen, erstellen Sie eine Datei mit dem Namen test_factorial.py und schreiben Sie den Testcode wie folgt:
from nose.tools import * #Laden des Testframeworks
from factorial import * #Testcode wird geladen
def test_factorial(): #Testen der Fakultätsmethode
i=10
e=3628800
eq_(e,factorial(i)) #Überprüfung
Das Obige entspricht äq_ (3628800, Fakultät (10)). Die eq_-Methode überprüft, ob die Werte gleich sind.
Geben Sie nach der Implementierung des Testcodes den Befehl nosetests in der Shell aus.
$ nosetests
.
----------------------------------------------------------------------
Ran 1 test in 0.008s
OK
Es ist einfach, viel Zeit damit zu verbringen, stabile Daten vorzubereiten. Dieses Mal habe ich die Techniken, die in solchen Arbeiten häufig verwendet werden, als Memorandum zusammengefasst.
Recommended Posts