Python测开28期-偕行-python操作Neo4J数据库

学习笔记
, , ,
1

一、使用python操作neo4j数据库

neo4j,Cypher,驱动之间的关系

  • neo4j 是一个图数据库，专门存储图结构， 图的定义;

  • Cypher 是Neo4J的声明式图形查询语言，类似于传统数据库的 SQL;

  • 驱动： 可以通过驱动来操作连接和操作neo4j数据库；

image
image833×227 11.1 KB

1、python连接neo4j的驱动(库和工具)都有哪些

（1）Neo4j Driver for Python

这是官方提供的Python驱动程序，它使用Cypher查询语言与Neo4j数据库进行交互。您可以使用此驱动程序与Neo4j数据库建立连接，执行查询和管理事务。

低级控制: neo4j-driver 提供了更底层的控制，适用于那些希望以更精细的方式控制与数据库交互的开发者。它更接近于原生的 Cypher 查询语言和 Neo4j 数据库的交互。

性能优化: 由于 neo4j-driver 较为底层，因此在某些情况下可能更适合需要对性能进行微调的场景。

  • 优点：官方提供的驱动程序，支持最新的Neo4j版本，提供完整的驱动API，支持更多的功能，如监控和诊断。
  • 缺点：与其他工具相比，使用Cypher查询语言可能需要一些学习曲线。

（2）py2neo

这是一个Python库，用于与Neo4j数据库进行交互。它提供了许多功能，包括从Python到Neo4j的映射、Cypher查询语言执行以及图数据库的遍历和搜索。

功能丰富: py2neo 提供了更高级的抽象层，使得操作图数据库变得更加简单和方便。它提供了更多的功能，包括图形建模、查询构建和执行、批量导入等。
更高级的抽象: py2neo 的 API 设计更加高级和面向对象，适用于那些希望以面向对象的方式操作图数据的开发者。
可视化支持: py2neo 还提供了一些用于可视化图数据的功能，可以帮助你更好地理解和展示图结构。

  • 优点：易于使用，提供了多种与Neo4j数据库交互的方式，如节点、关系、路径的查询等，也提供了很好的文档和社区支持。
  • 缺点：与其他工具相比，查询语言为Cypher，可能需要一些学习。

image
image836×126 3.88 KB

（3）Neo4jrb

这是一个Ruby on Rails的Neo4j驱动程序，但它也可以通过Python使用。它提供了一个高级的ORM（对象关系映射）层，可以轻松地处理节点、关系和属性。

  • 优点：提供了一个高级的ORM层，使得处理节点、关系和属性更加容易，有很好的文档和社区支持。
  • 缺点：主要针对Ruby on Rails开发者，对于Python开发者可能不是最佳选择。

（4）networkx

这是一个Python包，用于创建、操作和分析复杂网络。您可以使用此包与Neo4j数据库进行交互，以获取和操作网络数据。

优点：是一个通用的网络分析库，可用于创建、操作和分析各种类型的网络，具有灵活性和可扩展性。
缺点：与Neo4j数据库的集成可能不是最直观的，需要一些额外的转换工作。

（5）Graph-tool

这是一个Python库，用于创建、操作和分析图形。您可以使用此库从Neo4j数据库中获取图形数据，并在本地进行处理和分析。

  • 优点：提供了强大的图形操作和分析功能，可以在本地处理和分析从Neo4j数据库获取的图形数据。
  • 缺点：可能需要一些额外的配置和学习，才能与Neo4j数据库进行有效的集成。

二、py2neo第三方库使用

1、py2neo介绍

**注意：**py2neo 目前不支持 neo4j 5.X；
py2neo是一个客户端库和工具包，用于在Python应用程序中使用Neo4j。该库同时支持Bolt和HTTP，并提供了高级API、OGM、管理工具、用于py鸣叫的Cypher lexer，以及许多其他附加功能。

命令行工具已从py2neo 2021.2的库中移除。这个功能现在存在于单独的ipy2neo项目中。从2021.1版本开始，py2neo包含了对路由的完全支持，这是由Neo4j集群公开的。这可以使用neo4j://…URI或通过将routing=True传递给Graph构造函数。

类型 链接
Neo4J Developer社区 Using Neo4j from Python - Developer Guides
Author https://twitter.com/technige
Package https://pypi.python.org/pypi/py2neo
Source https://github.com/technige/py2neo
Example https://github.com/neo4j-examples/movies-python-py2neo
Docs http://py2neo.org/
Python 2.7 / 3.4+
Protocols Bolt, Http

image
image1184×454 83.9 KB

安装：

pip install py2neo

2、 py2neo具备哪些功能

py2neo在图形数据库方面有着很强的功能。

  1. 连接和操作Neo4j数据库：
    py2neo允许你连接到Neo4j数据库，并对其中的节点、关系和属性进行操作。

  2. 创建和删除节点和关系：
    使用py2neo，可以轻松地创建、删除和更新图形中的节点和关系。

  3. 执行查询和过滤：
    使用py2neo的Cypher API，可以执行复杂的查询和过滤，以查找节点和关系，并返回所需的结果。

  4. 序列化和反序列化：
    py2neo提供了一些方便的方法，可以将Graph对象转换为JSON或XML格式，并从这些格式中重建图形数据。

  5. 集成Flask和Django框架：
    py2neo提供了与Flask和Django框架的集成，使得在这些框架中使用Neo4j数据库变得更加容易。

  6. 支持高级图算法：
    py2neo支持各种高级图算法，如PageRank、最短路径算法和社区检测算法等。

3、py2neo基本使用

（1）连接数据库

  • 说明： neo4j支持三种协议，对应的默认端口为： bolt端口是7687，http端口是7474，https关口是7473；
  • 前提：必须保证neo4j服务是开启的，不然无法连接到数据库；

image
image938×766 36.6 KB

  • 语法： Graph(profile=None, name=None, **settings)
    • 参数说明：
      • profile：服务器url；
      • name：数据库名；
      • auth：用户名密码认证方式；
        方式一： 使用bolt协议连接；
from py2neo import Graph
# 方式一：使用bolt协议连接
graph = Graph("bolt://localhost:7687", auth=("neo4j", "12345678"),name="neo4j")
print(graph)

# 方式二：使用http协议连接
graph = Graph("http://localhost:7474", auth=("neo4j", "12345678"),name="neo4j")
print(graph)

（2） 增加节点和关系（增）

py2neo允许我们创建节点和关系，并将它们添加到图形数据库中。

  • 增加节点：

    • 1、创建节点：node_ck = Node("ability",name="测试开发")
      • 参数说明：
        • 第一个参数：节点的键；
        • 第二个参数：节点的值；
    • 2、添加节点：graph.create(node_ck)，传入节点；

  • 增加关系：

    • 1、创建关系：ck_db_rel = Relationship(node_ck, "skill", node_db)
      • 参数说明：
        • 第一个参数：第一个节点；
        • 第二个参数：关系名称；
        • 第三个参数：第二个节点；
    • 2、添加关系：graph.create(ck_db_rel)，传入关系；
from py2neo import Graph, Node, Relationship

# 连接服务器
graph = Graph("bolt://localhost:7687", auth=("neo4j", "12345678"),name="neo4j")
print(graph)

# 增加节点
node_ck = Node("ability",name="测试开发")
node_db = Node("sql", name="数据库使用")
node_git = Node("git", name="git代码管理")
graph.create(node_ck)
graph.create(node_db)
graph.create(node_git)
# 添加关系
ck_db_rel = Relationship(node_ck, "skill", node_db)
ck_git_rel = Relationship(node_ck,"skill",node_git)
graph.create(ck_db_rel)
graph.create(ck_git_rel)

image
image1865×961 110 KB

多数据案例一：

"""
创建测试开发知识体系知识图谱
主节点：测试开发
标签：frame
关系：skill
二级节点-知识结构节点：测试理论、测试用例、测试计划、数据库、用户端专项测试、linux、shell、python、pytest框架、UI自动化、接口自动化、持续集成、docker、前端开发、后端开发
标签：ability
关系：include
三级节点：具体的知识分类
标签：knowledge
"""
from py2neo import Graph, Node, Relationship

# 连接meo4j服务
graph = Graph(profile="bolt://localhost:7687", auth=("neo4j", "12345678"),name="ckdatabase1")
print(graph)

# 主节点,标签：frame
ck_node = Node("frame",name="测试开发")
# 创建节点
graph.create(ck_node)

# 二级节点,标签：ability
csll_node = Node("ability",name="测试理论")
csyl_node = Node("ability",name="测试用例设计")
csjh_node = Node("ability",name="测试计划")
database_node = Node("ability",name="数据库")
yonghu_node = Node("ability",name="用户端专项测试")
linux_node = Node("ability",name="linux")
shell_node = Node("ability",name="shell")
python_node = Node("ability",name="python")
pytest_node = Node("ability",name="pytest框架")
ui_node = Node("ability",name="UI自动化")
interface_node = Node("ability",name="接口自动化")
cicd_node = Node("ability",name="持续集成")
docker_node = Node("ability",name="docker")
front_node = Node("ability",name="前端开发")
backend_node = Node("ability",name="后端开发")

# 创建节点
graph.create(csll_node)
graph.create(csyl_node)
graph.create(csjh_node)
graph.create(database_node)
graph.create(yonghu_node)
graph.create(linux_node)
graph.create(shell_node)
graph.create(python_node)
graph.create(pytest_node)
graph.create(ui_node)
graph.create(interface_node)
graph.create(cicd_node)
graph.create(docker_node)
graph.create(front_node)
graph.create(backend_node)

# 主节点和二级点关系，关系：skill
ck_csll_rel = Relationship(ck_node,"skill",csll_node)
ck_csyl_rel = Relationship(ck_node,"skill",csyl_node)
ck_csjh_rel = Relationship(ck_node,"skill",csjh_node)
ck_yonghu_rel = Relationship(ck_node,"skill",yonghu_node)
ck_database_rel = Relationship(ck_node,"skill",database_node)
ck_linux_rel = Relationship(ck_node,"skill",linux_node)
ck_shell_rel = Relationship(ck_node,"skill",shell_node)
ck_python_rel = Relationship(ck_node,"skill",python_node)
ck_pytest_rel = Relationship(ck_node,"skill",pytest_node)
ck_ui_rel = Relationship(ck_node,"skill",ui_node)
ck_nterface_rel = Relationship(ck_node,"skill",interface_node)
ck_cicd_rel = Relationship(ck_node,"skill",cicd_node)
ck_docke_rel = Relationship(ck_node,"skill",docker_node)
ck_front_rel = Relationship(ck_node,"skill",front_node)
ck_backend_rel = Relationship(ck_node,"skill",backend_node)

# 创建关系
graph.create(ck_csll_rel)
graph.create(ck_csyl_rel)
graph.create(ck_csjh_rel)
graph.create(ck_yonghu_rel)
graph.create(ck_database_rel)
graph.create(ck_linux_rel)
graph.create(ck_shell_rel)
graph.create(ck_python_rel)
graph.create(ck_pytest_rel)
graph.create(ck_ui_rel)
graph.create(ck_nterface_rel)
graph.create(ck_cicd_rel)
graph.create(ck_docke_rel)
graph.create(ck_front_rel)
graph.create(ck_backend_rel)

# 三级节点，标签：knowledge
# 测试理论
rjsmzq_node = Node("knowledge",name="软件生命周期")
kflc_node = Node("knowledge",name="软件开发流程")
csff_node = Node("knowledge",name="测试方法")
bug_node = Node("knowledge",name="什么是bug")
# 测试用例设计
djl_node = Node("knowledge",name="等价类")
bjz_node = Node("knowledge",name="边界值")
pdb_node = Node("knowledge",name="判定表")
cwtd_node = Node("knowledge",name="错误推断法")
# 数据库
mysql_node = Node("knowledge",name="mysql")
redis_node = Node("knowledge",name="redis")
mongodb_node = Node("knowledge",name="mongodb")
neo4j_node = Node("knowledge",name="neo4j")

# 创建关系
graph.create(rjsmzq_node)
graph.create(kflc_node)
graph.create(csff_node)
graph.create(bug_node)
graph.create(djl_node)
graph.create(bjz_node)
graph.create(pdb_node)
graph.create(cwtd_node)
graph.create(mysql_node)
graph.create(redis_node)
graph.create(mongodb_node)
graph.create(neo4j_node)

# 二级节点和三级节点关系：include
# 测试理论关系
csll_rjsmzq_rel = Relationship(csll_node,"include",rjsmzq_node)
csll_kflc_rel = Relationship(csll_node,"include",kflc_node)
csll_csff_rel = Relationship(csll_node,"include",csff_node)
csll_bug_rel = Relationship(csll_node,"include",bug_node)
# 测试用例设计关系
csyl_djl_rel = Relationship(csyl_node,"include",djl_node)
csyl_bjz_rel = Relationship(csyl_node,"include",bjz_node)
csyl_pdb_rel = Relationship(csyl_node,"include",pdb_node)
csyl_cwtd_rel = Relationship(csyl_node,"include",cwtd_node)
# 数据库关系
db_mysql_rel = Relationship(database_node,"include",mysql_node)
db_redis_rel = Relationship(database_node,"include",redis_node)
db_mongodb_rel = Relationship(database_node,"include",mongodb_node)
db_neo4j_rel = Relationship(database_node,"include",neo4j_node)

# 创建关系
graph.create(csll_rjsmzq_rel)
graph.create(csll_kflc_rel)
graph.create(csll_csff_rel)
graph.create(csll_bug_rel)
graph.create(csyl_djl_rel)
graph.create(csyl_bjz_rel)
graph.create(csyl_pdb_rel)
graph.create(csyl_cwtd_rel)
graph.create(db_mysql_rel)
graph.create(db_redis_rel)
graph.create(db_mongodb_rel)
graph.create(db_neo4j_rel)

image
image1865×961 92.4 KB

三、neo4j官方驱动库使用

1、neo4j官方推荐驱动介绍

neo4j官方驱动支持Python语言，驱动程序主要包含 Driver Objects 和 Cypher sessions；

  • Driver Object 驱动程序对象包含Neo4j数据库的详细信息，包括主机url、安全验证等配置，还管理着连接池（Connection Pool）；

  • Cypher Session对象是执行事务单元的逻辑上下文，事务是在Session的上下文中执行的。真正执行Cypher语句的地方。由于Session不是线程安全的，并能够从Driver对象管理的连接池中回收利用（Recycle）连接，因此，Session对象是轻量级的（lightweight），用完之后应立即销（disposable）。

  • Driver对象和Session对象的关系：Driver对象负责管理连接池，从连接池中分配连接创建Session对象；Session对象在单个线程中接收Cypher和启动事务，在事务执行完成之后，立即销毁Session对象；Driver对象负责回收连接，等待为下一个Session对象分配连接。

类型 链接
Package https://pypi.python.org/pypi/neo4j
Source https://github.com/neo4j/neo4j-python-driver
Docs Build applications with Neo4j and Python - Neo4j Python Driver Manual
API Neo4j Python Driver 5.14 — Neo4j Python Driver 5.14

安装：

pip install neo4j

image
image1865×961 86.8 KB