Ich bin selbst Anfänger und muss leider "Einführung in die Graphendatenbank Neo4j für Anfänger in Python" sagen. Einführung einer Umgebungskonstruktion für den Betrieb von Neo4j mit Python und eines Beispiels für das Spielen mit Daten.

1. Einführung von Neo4j

Beginnen wir mit der Bereitstellung von Neo4J unter Mac OS X. Da meine Umgebung Yosemite 10.10.2 ist, wäre ich Ihnen dankbar, wenn Sie mich in den Kommentaren darüber informieren könnten, ob aufgrund von Unterschieden in der Umgebung Fehler vorliegen.

Zunächst benötigen Sie ein JDK, aber es scheint, dass es mit Java, das von Anfang an auf dem Mac enthalten ist, nicht gut funktioniert. Oracle JDK 7 http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260. Aus HTML einführen.

Nächster, http://neo4j.com/download/ Besuchen Sie, um die Neo4j Community Edition (kostenlose Version) herunterzuladen.

neo4j-community-2.2.0-unix-2.tar wird heruntergeladen. Entpacken Sie es und legen Sie es in den Ordner.

tar zvf neo4j-community-2.2.0-unix-2.tar
cd neo4j-community-2.2.0

Dann starten Sie es.

./bin/neo4j start

Es ist sehr einfach zu installieren! Es gibt eine Benutzeroberfläche, auf die über einen Browser zugegriffen werden kann. Versuchen wir es also. Das Zugangsziel ist http://localhost:7474/browser/ ist. Sie werden beim ersten Start aufgefordert, die ID und das Kennwort festzulegen. Stellen Sie sie daher entsprechend ein.

2. Stellen Sie mit Python # eine Verbindung zu Neo4j her

Es scheint einige Python-Bibliotheken zu geben, die eine Verbindung zu Neo4j herstellen können, aber hier habe ich beschlossen, Neo4j RestClient zu verwenden, um eine Verbindung von Python zu Neo4j herzustellen. Ich werde.

pip install neo4jrestclient

pip ist großartig, es ist wirklich einfach zu installieren! : zufrieden:

Folgen Sie dem neo4jRestClient Tutorial, um es auszuprobieren.

from neo4jrestclient.client import GraphDatabase

url = "http://<Benutzer-ID>:<Passwort>@localhost:7474/db/data/"
gdb = GraphDatabase(url)

Schreiben Sie in die Felder und die zuvor festgelegte. Dadurch werden Sie von Python aus mit Neo4j verbunden.

Fügen Sie als Nächstes zwei Knoten hinzu. Sie sind Alice und Bob im gleichen Alter.

alice = gdb.nodes.create(name="Alice", age=30)
bob = gdb.nodes.create(name="Bob", age=30)

Eigentlich wusste Bob von 1980 über Alice Bescheid, aber Alice kannte Bob drei Jahre später ... Wenn Sie den Knoten hinzufügen, sieht dieser wie folgt aus.

bob.relationships.create("Knows", alice, since=1980)
alice.relationships.create("Knows", bob, since=1983)

Lassen Sie uns dies anzeigen. (Gehen Sie davon aus, dass Python auf dem iPython-Notebook ausgeführt wird.)

Klicken Sie auf die Abfrage, um alle anzuzeigen, einschließlich der Knoten-zu-Knoten-Beziehungen. Außerdem ist das Setzen von data_contents = True der Schlüssel, und ohne dies funktioniert es nicht gut. (Ich habe ein wenig Zeit gebraucht, ohne das zu wissen ...)

gdb.query("MATCH (n)-[r]-(m) RETURN n, r, m", data_contents=True)

Die Grafik wird angezeigt!

Um dies in Ihrem Browser anzuzeigen, gehen Sie zu http: // localhost: 7474 / browser /

MATCH (n)-[r]-(m) RETURN n, r, m

Und drücken Sie die Eingabetaste Die Grafik wird angezeigt: grinsend:

2. Spielen Sie mit den Daten

Löschen Sie die Daten bis zu diesem Zeitpunkt einmal.

# All Delete
gdb.query("MATCH (n) OPTIONAL MATCH (n)-[r]-() DELETE n,r", data_contents=True)

Fügen Sie dann drei Knoten und Beziehungen hinzu.

#Personenknoten hinzufügen
alice = gdb.nodes.create(name="Alice", age=30)
bob   = gdb.nodes.create(name="Bob", age=30)
ken   = gdb.nodes.create(name="Ken", age=35)

alice.labels.add("Person")
bob.labels.add("Person")
ken.labels.add("Person")

#Beziehungseinstellungen
bob.relationships.create("Knows", alice, since=1980)
alice.relationships.create("Knows", bob, since=1983)
alice.relationships.create("Knows", ken, since=2015)

Knoten bezieht sich hier auf jede Person, und Beziehung bezieht sich auf die Beziehung, die Alice Bob kennt.

Wenn Sie die Anzeigeabfrage auf iPython drücken,

gdb.query("MATCH (n)-[r]-(m) RETURN n, r, m", data_contents=True)

Ein ähnliches Diagramm wird angezeigt: D.

Schauen wir uns das Diagramm an, indem wir die Person definieren, die als Nächstes ein Blog schreibt, und die Beziehung zu diesem Blog als Blogbesitzer: "Eigentümer" und Abonnent: "Abonnieren".

#Blog-Knoten hinzufügen
cam_blog  = gdb.nodes.create(name="Camera Blog")
comp_blog = gdb.nodes.create(name="Computer Blog")
trav_blog = gdb.nodes.create(name="Travel Blog")
gour_blog = gdb.nodes.create(name="Gourmet Blog")

cam_blog.labels.add("Blog")
comp_blog.labels.add("Blog")
trav_blog.labels.add("Blog")
gour_blog.labels.add("Blog")

#Beziehung hinzufügen
alice.relationships.create("Own", cam_blog)
bob.relationships.create("Own", comp_blog)
ken.relationships.create("Own", trav_blog)

alice.relationships.create("Subscribe", trav_blog)
alice.relationships.create("Subscribe", gour_blog)
bob.relationships.create("Subscribe", cam_blog)
ken.relationships.create("Subscribe", comp_blog)

Wenn Sie mit einem Browser auf http: // localhost: 7474 / browser / zugreifen und die folgende Abfrage auslösen:

MATCH (n)-[r]-(m) RETURN n, r, m

Ein solches Diagramm wird angezeigt. Ich denke, es ist ziemlich leicht zu verstehen. Aus diesem Grund wird gesagt, dass Graphendatenbanken Beziehungen leichter verstehen als relationale Datenbanken.

3. Cypher Erster Schritt

Lassen Sie mich einige Beispiele für das grundlegende Schreiben von Cypher geben.
Die folgenden durch rote Kreise gekennzeichneten Bob, Alice, Ken werden ausgewählt.

match (n:Person) RETURN n

(* Der rote Rahmen wurde der Übersichtlichkeit halber hinzugefügt und erscheint nicht auf dem Neo4J-Browserbildschirm.)

Diesmal ist der Blog-Knoten ausgewählt.

match (n:Blog) RETURN n

Diese Cypher-Abfrage extrahiert nur Bob.

MATCH (b:Person {name:'Bob'}) RETURN b

Wählen Sie auch die Beziehung aus. In den folgenden Fällen gelten nur diejenigen, die sich auf Own beziehen.

MATCH (p:Person)-[r:Own]->(b:Blog) RETURN p,r,b;

Generieren Sie schließlich zufällig 100 Personenknoten und 100 Blogknoten und generieren Sie anschließend ein Diagramm mit 500 Abonnementbeziehungen und zeigen Sie es an.

import numpy.random as rd

l = 100

person_list = []
blog_list = []
for i in range(l):
    
    p = gdb.nodes.create(name="person_%d"%i)
    p.labels.add("Person")
    
    b  = gdb.nodes.create(name="Blog_%d"%i)
    b.labels.add("Blog")
    
    person_list.append(p)
    blog_list.append(b)

r1 = range(len(person_list))
rd.shuffle(r1)

for i in range(len(blog_list)):
    blog_list[i].relationships.create("Own", person_list[r1[i]])


r2 = range(l) * 5
rd.shuffle(r2)
r3 = range(l) * 5
rd.shuffle(r3)
                
for i,j in zip(r2, r3):
    person_list[i].relationships.create("Subscribe", blog_list[j])

Es ist Chaos! : grinsen:

3. Zeichnen Sie mit Networkx

Installieren Sie iCypher.

pip install ipython-cypher

Sie können es mit networkx mit dem folgenden Code grafisch darstellen.

`neo4j-networkx.py`


%load_ext cypher
%matplotlib inline
import networkx as nx
import matplotlib.pyplot as plt

result = %%cypher http://<Benutzer-ID>:<Passwort>@localhost:7474/db/data/ MATCH (n)-[r]-(m) RETURN n,r,m;
node_map ={'Person':'#22FF99', 'Blog': '#6622FF' }
node_label={'Person':'Person', 'Blog': 'Blog' }

g = result.get_graph()
pos=nx.get_node_attributes(g,'pos')
plt.figure(figsize=(15,15))
nx.draw(g, node_color=[node_map[g.node[n]['labels'][0]] for n in g],node_size=80, width=0.5, edge_color='#999999')

Einführung in die Graph Database Neo4j in Python für Anfänger (für Mac OS X)