创建节点和关系

In [1]:

from neo4j.v1 import GraphDatabase
uri = "bolt://localhost:7687"
driver = GraphDatabase.driver(uri, auth=("neo4j", "ecust"))
def cyphertx(cypher):
    with driver.session() as session:
        with session.begin_transaction() as tx:
            return tx.run(cypher)

In [11]:

s1 = "create (n:Person { name: 'Tom Hanks', born: 1956 }) return n;"
result1 = cyphertx(s1)
result1.data()

Out[11]:

[{u'n': <Node id=1 labels=set([u'Person']) properties={u'born': 1956, u'name': u'Tom Hanks'}>}]

In [12]:

s2 = "create (n:Person { name: 'Robert Zemeckis', born: 1951 }) return n;"
result2 = cyphertx(s2)
result2.data()

Out[12]:

[{u'n': <Node id=22 labels=set([u'Person']) properties={u'born': 1951, u'name': u'Robert Zemeckis'}>}]

In [13]:

s3 = "create (n:Movie { title: 'Forrest Gump', released: 1951 }) return n;"
result3 = cyphertx(s3)
result3.data()

Out[13]:

[{u'n': <Node id=23 labels=set([u'Movie']) properties={u'released': 1951, u'title': u'Forrest Gump'}>}]

查询节点¶

In [14]:

#查询整个图形数据库
s4 = "match(n) return n;"
result4 = cyphertx(s4)
result4.data()

Out[14]:

[{u'n': <Node id=1 labels=set([u'Person']) properties={u'born': 1956, u'name': u'Tom Hanks'}>},
 {u'n': <Node id=22 labels=set([u'Person']) properties={u'born': 1951, u'name': u'Robert Zemeckis'}>},
 {u'n': <Node id=23 labels=set([u'Movie']) properties={u'released': 1951, u'title': u'Forrest Gump'}>}]

In [15]:

#查询born属性小于1955的节点
s5 = "match(n) where n.born<1955 return n;"
result5 = cyphertx(s5)
result5.data()

Out[15]:

[{u'n': <Node id=22 labels=set([u'Person']) properties={u'born': 1951, u'name': u'Robert Zemeckis'}>}]

In [16]:

#查询具有指定Lable的节点
s6 = "match(n:Movie) return n;"
result6 = cyphertx(s6)
result6.data()

Out[16]:

[{u'n': <Node id=23 labels=set([u'Movie']) properties={u'released': 1951, u'title': u'Forrest Gump'}>}]

In [17]:

#查询具有指定属性的节点
s7 = "match(n{name:'Tom Hanks'}) return n;"
result7 = cyphertx(s7)
result7.data()

Out[17]:

[{u'n': <Node id=1 labels=set([u'Person']) properties={u'born': 1956, u'name': u'Tom Hanks'}>}]

创建关系¶

In [18]:

#创建没有任何属性的关系
s8 = """MATCH (a:Person),(b:Movie)
WHERE a.name = 'Robert Zemeckis' AND b.title = 'Forrest Gump'
CREATE (a)-[r:DIRECTED]->(b)
RETURN r;"""
result8 = cyphertx(s8)
result8.data()

Out[18]:

[{u'r': <Relationship id=0 start=22 end=23 type=u'DIRECTED' properties={}>}]

In [19]:

#创建关系，并设置关系的属性
s9 = """MATCH (a:Person),(b:Movie)
WHERE a.name = 'Tom Hanks' AND b.title = 'Forrest Gump'
CREATE (a)-[r:ACTED_IN { roles:'Forrest' }]->(b)
RETURN r;"""
result9 = cyphertx(s9)
result9.data()

Out[19]:

[{u'r': <Relationship id=20 start=1 end=23 type=u'ACTED_IN' properties={u'roles': u'Forrest'}>}]

查询关系¶

In [20]:

#查询整个图形数据库
s10 = "match(n) return n;"
result10 = cyphertx(s10)
result10.data()

Out[20]:

[{u'n': <Node id=1 labels=set([u'Person']) properties={u'born': 1956, u'name': u'Tom Hanks'}>},
 {u'n': <Node id=22 labels=set([u'Person']) properties={u'born': 1951, u'name': u'Robert Zemeckis'}>},
 {u'n': <Node id=23 labels=set([u'Movie']) properties={u'released': 1951, u'title': u'Forrest Gump'}>}]

In [21]:

#查询跟指定节点有关系的节点
s11 = "match(n)--(m:Movie) return n;"
result11 = cyphertx(s11)
result11.data()

Out[21]:

[{u'n': <Node id=1 labels=set([u'Person']) properties={u'born': 1956, u'name': u'Tom Hanks'}>},
 {u'n': <Node id=22 labels=set([u'Person']) properties={u'born': 1951, u'name': u'Robert Zemeckis'}>}]

In [23]:

#查询有向关系的节点
s12 = "MATCH (:Person { name: 'Tom Hanks' })-->(movie) RETURN movie;"
result12 = cyphertx(s12)
result12.data()

Out[23]:

[{u'movie': <Node id=23 labels=set([u'Movie']) properties={u'released': 1951, u'title': u'Forrest Gump'}>}]

In [24]:

#为关系命名，通过[r]为关系定义一个变量名，通过函数type获取关系的类型
s13 = """MATCH (:Person { name: 'Tom Hanks' })-[r]->(movie) 
RETURN r,type(r);"""
result13 = cyphertx(s13)
result13.data()

Out[24]:

[{u'r': <Relationship id=20 start=1 end=23 type=u'ACTED_IN' properties={u'roles': u'Forrest'}>,
  u'type(r)': u'ACTED_IN'}]

In [25]:

#查询特定的关系类型，通过[Variable:RelationshipType{Key:Value}]指定关系的类型和属性
s14 = """MATCH (:Person { name: 'Tom Hanks' })-[r:ACTED_IN{roles:'Forrest'}]->(movie)
RETURN r,type(r);"""
result14 = cyphertx(s14)
result14.data()

Out[25]:

[{u'r': <Relationship id=20 start=1 end=23 type=u'ACTED_IN' properties={u'roles': u'Forrest'}>,
  u'type(r)': u'ACTED_IN'}]

更新图形¶

In [26]:

#创建一个完整的Path
s15 = """CREATE p =(vic:Worker:Person{ name:'vic',title:"Developer" })-[:WORKS_AT]->(neo)<-[:WORKS_AT]-(michael:Worker:Person { name: 'Michael',title:"Manager" })
RETURN p"""
result15 = cyphertx(s15)
result15.data()

Out[26]:

[{u'p': <Path start=24 end=26 size=2>}]

In [28]:

#为节点增加属性
s16 = """match (n)
where id(n)=25
set n.name = 'neo'
return n;"""
result16 = cyphertx(s16)
result16.data()

Out[28]:

[{u'n': <Node id=25 labels=set([]) properties={u'name': u'neo'}>}]

In [29]:

#为节点增加标签
s17 = """match (n)
where id(n)=25
set n:Company
return n;"""
result17 = cyphertx(s17)
result17.data()

Out[29]:

[{u'n': <Node id=25 labels=set([u'Company']) properties={u'name': u'neo'}>}]

In [30]:

#为关系增加属性
s18 = """match (n)<-[r]-(m)
where id(n)=25 and id(m)=24
set r.team='Azure'
return n;"""
result18 = cyphertx(s18)
result18.data()

Out[30]:

[{u'n': <Node id=25 labels=set([u'Company']) properties={u'name': u'neo'}>}]

In [ ]:

鲁文算法¶

In [31]:

#创建节点
"""MERGE (nAlice:User {name:'Alice'})
MERGE (nBridget:User {name:'Bridget'})
MERGE (nCharles:User {name:'Charles'})
MERGE (nDoug:User {name:'Doug'})
MERGE (nMark:User {name:'Mark'})
MERGE (nMichael:User {name:'Michael'})

MERGE (nAlice)-[:FRIEND]->(nBridget)
MERGE (nAlice)-[:FRIEND]->(nCharles)
MERGE (nMark)-[:FRIEND]->(nDoug)
MERGE (nBridget)-[:FRIEND]->(nMichael)
MERGE (nCharles)-[:FRIEND]->(nMark)
MERGE (nAlice)-[:FRIEND]->(nMichael)
MERGE (nCharles)-[:FRIEND]->(nDoug);"""

Louvain = """CALL algo.louvain('User', 'FRIEND',
  {write:true, writeProperty:'community'})
YIELD nodes, communityCount, iterations, loadMillis, computeMillis, writeMillis;"""

In [ ]:

Louvain = """CALL algo.louvain(
  'MATCH (p:User) RETURN id(p) as id',
  'MATCH (p1:User)-[f:FRIEND]-(p2:User)
   RETURN id(p1) as source, id(p2) as target,f.weight as weight',
  {graph:'cypher',write:true,writeProperty:'community'})
  YIELD nodes, communityCount, iterations, loadMillis, computeMillis, writeMillis;"""

In [ ]: