Je suis moi-même un débutant, donc je suis désolé de dire "Introduction à la base de données Graph Neo4j pour les débutants en Python". Présentation d'une construction d'environnement pour faire fonctionner Neo4j avec Python et un exemple pour jouer avec des données.

1. Introduction de Neo4j

Commençons par comment déployer Neo4J sur Mac OS X. Puisque mon environnement est Yosemite 10.10.2, je vous serais reconnaissant de bien vouloir me faire savoir dans les commentaires s'il y a des erreurs dues à des différences dans l'environnement.

Tout d'abord, vous avez besoin d'un JDK, mais il semble que cela ne fonctionne pas bien avec Java qui est inclus dans le Mac depuis le début, donc Oracle JDK 7 http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260. Introduire à partir de html.

prochain, http://neo4j.com/download/ Visitez pour télécharger l'édition communautaire Neo4j (version gratuite).

neo4j-community-2.2.0-unix-2.tar sera téléchargé, alors décompressez-le et placez-le dans le dossier.

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

Puis lancez-le.

./bin/neo4j start

C'est très simple à installer! Il existe une interface utilisateur accessible à partir d'un navigateur, alors essayons de l'utiliser. La destination d'accès est http://localhost:7474/browser/ est. Il vous sera demandé de définir l'ID et le mot de passe au premier démarrage, alors définissez-les correctement.

2. Connectez-vous à Neo4j avec Python

Il semble y avoir des bibliothèques Python qui peuvent se connecter à Neo4j, mais ici j'ai décidé d'utiliser Neo4j RestClient pour me connecter de Python à Neo4j. Je vais.

pip install neo4jrestclient

pip c'est super, c'est vraiment facile à installer! : satisfait:

Suivez le didacticiel neo4jRestClient pour l'essayer.

from neo4jrestclient.client import GraphDatabase

url = "http://<ID utilisateur>:<Mot de passe>@localhost:7474/db/data/"
gdb = GraphDatabase(url)

Dans les champs et , écrivez celui que vous avez défini précédemment. Cela vous connectera à Neo4j depuis Python.

Ensuite, ajoutez deux nœuds. Ils sont Alice et Bob du même âge.

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

En fait, Bob connaissait Alice depuis 1980, mais Alice connaissait Bob trois ans plus tard ... Si vous ajoutez le nœud, ce sera comme suit.

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

Montrons ceci. (Continuez en supposant que python s'exécute sur un notebook iPython)

Appuyez sur la requête pour tout afficher, y compris les relations nœud à nœud. De plus, la définition de data_contents = True est la clé, et cela ne fonctionnera pas bien sans cela. (J'ai mis un peu de temps sans le savoir ...)

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

Le graphique est affiché!

Pour voir cela dans votre navigateur, accédez à http: // localhost: 7474 / browser /

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

Et appuyez sur Entrée Le graphique s'affiche: souriant:

2. Jouez avec les données

Supprimez les données jusqu'à ce point une fois.

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

Ajoutez ensuite trois nœuds et relations.

#Ajouter un nœud de personne
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")

#Paramètres de relation
bob.relationships.create("Knows", alice, since=1980)
alice.relationships.create("Knows", bob, since=1983)
alice.relationships.create("Knows", ken, since=2015)

Node fait référence à chaque personne ici, et Relation fait référence à la relation qu'Alice connaît Bob.

Lorsque vous appuyez sur la requête d'affichage sur iPython,

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

Un graphique similaire s'affiche: D

Jetons un coup d'œil au graphique en définissant la personne qui écrit ensuite a un blog et la relation avec ce blog en tant que propriétaire du blog: "Propriétaire", abonné: "S'abonner".

#Ajouter un nœud de blog
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")

#Ajouter une relation
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)

De plus, si vous accédez à http: // localhost: 7474 / browser / avec un navigateur et lancez la requête suivante,

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

Un graphique comme celui-ci s'affiche. Je pense que c'est assez facile à comprendre. C'est pourquoi on dit que les bases de données graphiques sont plus faciles à comprendre les relations que les bases de données relationnelles.

3. Chiffrer la première étape

Permettez-moi de vous donner quelques exemples de l'écriture de base de Cypher.
Les Bob, Alice, Ken suivants indiqués par des cercles rouges sont sélectionnés.

match (n:Person) RETURN n

(* Le cadre rouge est ajouté dans un souci de clarté et n'apparaît pas sur l'écran du navigateur Neo4J.)

Cette fois, le nœud Blog est sélectionné.

match (n:Blog) RETURN n

Cette requête Cypher extrait uniquement Bob.

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

Sélectionnez également la relation. Dans les cas suivants, seuls ceux liés à Own sont applicables.

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

Enfin, générez de manière aléatoire 100 nœuds Personne et 100 nœuds Blog, puis générez et affichez un graphique avec 500 relations d'abonnement.

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])

C'est le chaos! : sourire:

3. Dessinez avec Networkx

Installez iCypher.

pip install ipython-cypher

Vous pouvez le représenter graphiquement avec networkx avec le code ci-dessous.

`neo4j-networkx.py`


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

result = %%cypher http://<ID utilisateur>:<Mot de passe>@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')

Introduction à la base de données Graph Neo4j en Python pour les débutants (pour Mac OS X)