基于Neo4j的担保社群型态分析挖掘

已于 2022-03-24 20:26:17 修改
阅读量3.3k 收藏 36
点赞数 8
分类专栏： 图分析与挖掘 文章标签： 算法 python 人工智能 知识图谱
于 2021-12-01 22:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39797176/article/details/121658168
版权

图技术

利用neo4j、networkx、dgl、python做图分析挖掘

【1】最短路径算法dijkstra
【2】基于networkx的隐性集团关系识别模型

基于Neo4j的担保社群型态分析挖掘

一. 前言

对于担保客户群，如何对担保客群型态进行详细的分析挖掘呢？如图一，怎么获取标签，如何打上标签呢？

担保
担保
担保
企业A
企业B
企业C
图一：样例图

采用图技术来计算，可以直接打上三角型标签。

算法步骤

  • 担保关联关系数据清洗；
  • 利用担保关联关系构建担保图谱；
  • 计算担保客户5度全路径；
  • 利用louvain进行社区（客群）分团；
  • 客群内社区型态分析；
  • 担保客户型态汇总。

算法说明

  • 模型输入：担保关系数据；
  • 模型结果：担保客户图谱型态；
  • 模型应用：为每个客户打上型态标签，对于一些异常型态重点关注，防止违规担保，降低风险。

二. 数据说明

demo数据采用python中的faker进行构造，主要生成担保关系数据。

#导入模块包
import warnings
warnings.filterwarnings('ignore')
import random
import pandas as pd
import multiprocessing
import timeit
from faker import Faker
fake = Faker("zh-CN")
import os

#担保关系数据清理
if os.path.isfile('rela_demo.csv'):
    os.remove('rela_demo.csv')

#担保客户数据清理
if os.path.isfile('node_demo.csv'):
    os.remove('node_data.csv')
    
#生成担保关系数据
def demo_data_(edge_num):
    s = []
    for i in range(edge_num):
        #担保公司、被担保公司、担保金额、担保时间
        s.append([fake.company(), fake.company(), random.random(), fake.date(pattern="%Y-%m-%d", end_datetime=None)])
    demo_data = pd.DataFrame(s, columns=['guarantee', 'guarantor', 'money', 'data_date'])
    print("-----demo_data describe-----")
    print(demo_data.info())
    print("-----demo_data head---------")
    print(demo_data.head())
    return demo_data

#判断DataFrame两列是否相等
def if_same(a, b):
    if a==b:
        return 1
    else:
        return 0

#demeo数据处理        
def rela_data_(demo_data):
    print('原始数据记录数', len(demo_data))
    #去除自保
    demo_data['bool'] = demo_data.apply(lambda x: if_same(x['guarantor'], x['guarantee']), axis=1)
    demo_data = demo_data.loc[demo_data['bool'] != 1]
    #去除非空
    demo_data = demo_data[(demo_data['guarantor'] != '')&(demo_data['guarantee'] != '')]
    #按照日期排序删除重复guarantor、guarantee项
    demo_data = demo_data.sort_values(by=['guarantor', 'guarantee', 'data_date'], ascending=False).drop_duplicates(keep='first', subset=['guarantor', 'guarantee']).drop_duplicates().reset_index()
    demo_data[['guarantee', 'guarantor', 'money', 'data_date']].to_csv('rela_demo.csv', index = False)
    return demo_data[['guarantee', 'guarantor', 'money', 'data_date']]
#节点数据
#节点从关系数据中抽
def node_data_(demo_data):
    node_data = pd.concat([demo_data[['guarantor']].rename(columns = {'guarantor':'cust_id'}), demo_data[['guarantee']].rename(columns = {'guarantee':'cust_id'})])[['cust_id']].drop_duplicates().reset_index()
    print('节点数目', len(node_data['cust_id'].unique()))
    node_data[['cust_id']].to_csv('node_data.csv', index = False)
    return node_data[['cust_id']]
    
if __name__ == '__main__':
    #edge_num样本关系条数
    demo_data = demo_data_(edge_num=1000)
    rela_demo = rela_data_(demo_data)
    #node_num样本节点条数
    node_data = node_data_(demo_data)

三. Neo4j介绍

1. Python、Neo4j交互

Python作为数据分析常用软件，可以利用python对Neo4j的图分析数据进行处理计算，需要下载一个模块包py2neo。

#连接图数据库
from py2neo import Graph, Node, Relationship
def connect_graph():
    graph = Graph("http://*.*.*.*:7474", username = "neo4j", password = ' password')
    return (graph)
#graph = connect_graph()

2. Neo4j入图

  • Neo4j支持多标签入数；
  • Neo4j入数最好选用本地文件导入形式；
def create_graph(graph, load_node_path, load_rel_path, load_node_name, load_rel_name, guarantee_edges):
    guarantee_edges.to_csv(load_rel_path,encoding = 'utf-8', index = False)
    x = guarantee_edges[:]
    x1 = pd.DataFrame(x['Guarantor_Id'][:].drop_duplicates())
    x1.columns = ['Cust_id']
    x2 = pd.DataFrame(x['Guarantee_Id'][:].drop_duplicates())
    x2.columns = ['Cust_id']
    x3 = x1.merge(x2,left_on = 'Cust_id',right_on = 'Cust_id',how = 'inner')[:]
    x1 = x1.append(x3)
    x1 = x1.append(x3)
    x1 = x1.drop_duplicates(keep = False)[:]
    x2 = x2.append(x3)
    x2 = x2.append(x3)
    x2 = x2.drop_duplicates(keep = False)[:]
    x3.insert(loc = 0,column = 'label1',value = 'Cust')
    x3.insert(loc = 0,column = 'label2',value = 'Guarantor')
    x3.insert(loc = 0,column = 'label3',value = 'Guarantee')
    x1.insert(loc = 0,column = 'label1',value = 'Cust')
    x1.insert(loc = 0,column = 'label2',value = 'Guarantor')
    x1.insert(loc = 0,column = 'label3',value = '')
    x2.insert(loc = 0,column = 'label1',value = 'Cust')
    x2.insert(loc = 0,column = 'label2',value = '')
    x2.insert(loc = 0,column = 'label3',value = 'Guarantee')
    x4 = pd.DataFrame(pd.concat([x1, x2, x3]))
    x4 = x4.drop_duplicates()
    x4.to_csv(load_node_path,encoding = 'utf-8', index = False)
    #清除历史关系和节点
    graph.run("MATCH p=()-[r:guarantee]->() delete p")
    graph.run("MATCH (n:Cust) delete n")
    #创建索引
    graph.run("CREATE INDEX ON:Cust(Cust_id)")
    graph.run("CREATE INDEX ON:Guarantor(Cust_id)")
    graph.run("CREATE INDEX ON:Guarantee(Cust_id)")
    #导入节点
    graph.run("USING PERIODIC COMMIT 1000 LOAD CSV WITH HEADERS FROM 'file://%s' AS line MERGE (p:Cust{Cust_id:line.Cust_id}) ON CREATE SET p.Cust_id=line.Cust_id ON MATCH SET p.Cust_id = line.Cust_id WITH p, [line.label1, line.label2, line.label3] AS sz CALL apoc.create.removeLabels(p, apoc.node.labels(p)) YIELD node as n CALL apoc.create.addLabels(p, sz) YIELD node RETURN count(p)" % load_node_path)
    print("%s INFO : 加载%s完毕。" % (time.ctime(), load_node_name))
    #导入关系
    graph.run("USING PERIODIC COMMIT 1000 LOAD CSV WITH HEADERS FROM 'file://%s' AS line match (s:Cust{Cust_id:line.Guarantor_Id}),(t:Cust{Cust_id:line.Guarantee_Id}) MERGE (s)-[r:guarantee{Money:toFloat(line.Money)}]->(t) ON CREATE SET r.Dt = line.Dt, r.Money = toFloat(line.Money), r.link_strength = 1 ON MATCH SET r.Dt = line.Dt, r.Money = toFloat(line.Money), r.link_strength = 1" % load_rel_path)
    print("%s INFO : 加载%s完毕。" % (time.ctime(), load_rel_name))

3. Neo4j图分析

序号图计算
1节点入度
2节点出度
3节点的度
4节点中介度
5节点中心特征向量值
6节点的pagerank值
7节点的5度路径
#计算节点的入度
def guarantee_indegree_(graph):
    x1 = pd.DataFrame(graph.run("call algo.degree.stream('Cust','guarantee',{direction:'incoming'})yield nodeId,score return algo.getNodeById(nodeId).Cust_id as Guarantee_Id,score as guarantee_indegree order by guarantee_indegree desc").data()).drop_duplicates()
    x2 = pd.DataFrame(guarantee_edges['Guarantee_Id']).drop_duplicates()[:]
    guarantee_indegree = pd.merge(x2, x1, how = 'left', on = ['Guarantee_Id']).drop_duplicates()[:]
    if len(guarantee_indegree) == 0:
        guarantee_indegree.insert(loc = 0,column = 'name',value = '')
        guarantee_indegree.insert(loc = 0,column = 'guarantee_indegree',value = '')
    return (guarantee_indegree)
#guarantee_indegree = guarantee_indegree_(graph)
#计算节点的出度
def guarantee_outdegree_(graph):
    x1 = pd.DataFrame(graph.run("call algo.degree.stream('Cust','guarantee',{direction:'out'})yield nodeId,score return algo.getNodeById(nodeId).Cust_id as Guarantor_Id,score as guarantee_outdegree order by guarantee_outdegree desc").data()).drop_duplicates()
    x2 = pd.DataFrame(guarantee_edges['Guarantor_Id']).drop_duplicates()[:]
    guarantee_outdegree = pd.merge(x2, x1, how = 'left', on = ['Guarantor_Id']).drop_duplicates()[:]
    if len(guarantee_outdegree) == 0:
        guarantee_outdegree.insert(loc = 0,column = 'name',value = '')
        guarantee_outdegree.insert(loc = 0,column = 'guarantee_outdegree',value = '')
    return (guarantee_outdegree)
#guarantee_outdegree = guarantee_outdegree_(graph)
#计算节点的度
def guarantee_degree_(graph):
    x1 = pd.DataFrame(guarantee_edges[['Guarantee_Id','Guarantor_Id']]).drop_duplicates()[:]
    x2 = pd.merge(x1, guarantee_indegree, how = 'left', on = ['Guarantee_Id']).drop_duplicates()[:]
    guarantee_degrees = pd.merge(x2, guarantee_outdegree, how = 'left', on = ['Guarantor_Id']).drop_duplicates()[:]
    if len(guarantee_degrees) == 0:
        guarantee_degrees.insert(loc = 0,column = 'name',value = '')
        guarantee_degrees.insert(loc = 0,column = 'guarantee_degrees',value = '')
    return (guarantee_degrees)
#guarantee_degrees = guarantee_degree_(graph)
#计算节点的中介度
def guarantee_btw_(graph):
    guarantee_btw = pd.DataFrame(graph.run("call algo.betweenness.stream('Cust','guarantee',{direction:'outer'}) yield nodeId,centrality return algo.getNodeById(nodeId).Cust_id as name,centrality order by centrality desc").data())
    if len(guarantee_btw) == 0:
        guarantee_btw.insert(loc = 0,column = 'name',value = '')
        guarantee_btw.insert(loc = 0,column = 'centrality',value = '')
    return (guarantee_btw)
#guarantee_btw = guarantee_btw_(graph)
#计算节点的中心特征向量值
def guarantee_eigencentrality_(graph):
    guarantee_eigencentrality = pd.DataFrame(graph.run("call algo.eigenvector.stream('Cust','guarantee',{normalization:'l2norm', weightProperty:'Money'}) yield nodeId,score return algo.getNodeById(nodeId).Cust_id as name,score as eigenvector order by eigenvector desc").data())
    if len(guarantee_eigencentrality) == 0:
        guarantee_eigencentrality.insert(loc = 0,column = 'name',value = '')
        guarantee_eigencentrality.insert(loc = 0,column = 'eigenvector',value = '')
    return (guarantee_eigencentrality)
#guarantee_eigencentrality = guarantee_eigencentrality_(graph)
#计算节点的pagerank值
def guarantee_pagerank_(graph):
    sum = pd.DataFrame(graph.run("call algo.pageRank.stream('Cust','guarantee',{iterations:1000,dampingFacter:0.85, weightProperty:'Money'})yield nodeId,score return sum(score) as sum").data())['sum'][0]
    guarantee_pagerank = pd.DataFrame(graph.run("call algo.pageRank.stream('Cust','guarantee',{iterations:1000,dampingFacter:0.85, weightProperty:'Money'})yield nodeId,score return algo.getNodeById(nodeId).Cust_id as name,score/%f as pageRank order by pageRank desc" %(sum)).data())
    if len(guarantee_pagerank) == 0:
        guarantee_pagerank.insert(loc = 0,column = 'name',value = '')
        guarantee_pagerank.insert(loc = 0,column = 'pageRank',value = '')
    return (guarantee_pagerank)
#guarantee_pagerank = guarantee_pagerank_(graph)
def all_paths_(graph):
    all_paths = pd.DataFrame(graph.run("MATCH p = (n:Cust{})-[r:guarantee*..5]->(m) where SIZE(apoc.coll.toSet(NODES(p))) = length(p)+1 RETURN m.Cust_id as id, REDUCE(s=[], x in NODES(p) | s + x.Cust_id) as path, length(p) + 1 as path_len, n.Cust_id as start ").data())
    all_paths['path'] = (['->'.join(x) for x in all_paths['path']])
    all_paths = all_paths.drop_duplicates()[:]
    return (all_paths)
#all_paths = all_paths_(graph)

四. 图谱型态

以圈型为例说明：

  • 获取全路径数据；
  • 筛选路径长大于2；
  • 路径数据与关系数据关联，关联上说明存在圈。

补充：三角型可直接引用algo.triangle

def guarantee_cycle_(all_paths):
    x1 = all_paths.drop_duplicates()[:]
    x2 = guarantee_edge[['Guarantor_Id','Guarantee_Id']].drop_duplicates()[:]
    x2.columns = ['id','start']
    x2['cycle_flag'] = 1
    x3 = x1.loc[x1['path_len'] > 2].drop_duplicates()[:]
    x4 = pd.merge(x3, x2, how = 'left',on = ['id','start']).drop_duplicates()[:]
    x5 = x4.loc[x4['cycle_flag'] == 1].drop_duplicates()[:]
    x6 = pd.merge(x1, x5, how = 'left',on = ['id','start','path','path_len']).drop_duplicates()[:]
    x7 = x6.fillna(0).drop_duplicates()[:]
    return (x7)
#三角型态
def triangle_(graph):
    x = pd.DataFrame(graph.run("call algo.triangle.stream('Cust','guarantee',{}) yield nodeA, nodeB, nodeC return algo.getNodeById(nodeA).Cust_id as node1, algo.getNodeById(nodeB).Cust_id as node2, algo.getNodeById(nodeC).Cust_id as node3").data())
    return (x)
#triangle = triangle_(graph)

五. 模型说明

社群型态，需要对客户分团，然后研究团内的客户型态，比如通过节点数、边数、路长等。

六. 模型实例

模型最终形成一张客户型态宽表

客户号社群号路径型态类型社群密度pageRank
A1A->B->C三角1*

型态直接上图说明，分别为：融资、塔、三角、圈

融资型

图二：融资

金字塔型

图三：塔

三角型

图四：三角

圈型

图五：圈

七. 展望

  • 社区型态的研究，可以找出高风险型态的客群；
  • 读者也可以自己刻画型态。

链接: 基于networkx的隐性集团关系识别模型.

MO2T
关注
专栏目录
Neo4j系列-图分析
爱米粒的博客
08-20 4730
1、人物数量 万事以简单开始。先看看上图上由有多少人物： MATCH (c:Person) RETURN count(c) 2、概要统计 统计每个角色接触的其它角色的数目： MATCH (c:person)-[:INTERACTS]->() WITH c, count(*) AS num RETURN min(num) AS min, max(num) AS max, ...
使用Neo4j进行关系挖掘实践
qq_35824427的博客
02-26 686
使用Neo4j进行关系挖掘实践，基于企业和老板的关系数据
NetworkX-Neo4j 项目教程
最新发布
gitblog_00717的博客
09-03 261
NetworkX-Neo4j 项目教程 networkx-neo4j NetworkX API for Neo4j Graph Algorithms.项目地址:https://gitcode.com/gh_mirrors/ne/networkx-neo4j 1. 项目介绍 NetworkX-Neo4j 是一个 Python 库，旨在通过 NetworkX 风格的命令与 Neo4j 图数据库进行交...
在 Python 中使用 Neo4j
木东的博客
09-28 4506
Neo4j是面向对象基于Java的 ，被设计为一个建立在Java之上、可以直接嵌入应用的数据存储。此后，其他语言和平台的支持被引入，Neo4j社区获得持续增长，获得了越来越多的技术支持者。目前已支持.NET、Ruby、Python、Node.js及PHP等。因此，不管是什么项目，没有理由不引入Neo4j。 本文重点介绍Python，这门语言的哲学与Java大大不同，同时展示py2neo库如何
中国娱乐圈关系挖掘
石磊
10-13 1212
中国娱乐圈关系挖掘 文章最后有系统的传送门 作者博客的传送门 ，小弟在校学生，初来乍到，第一次发博客，请请喷。我希望能不断的学习，然后提高自己。 题目描述中国的娱乐圈关系网十分庞大，存在着紧密的联系。在学习完田老师的复杂网络课程之后，我们对中国的中国娱乐圈关系挖掘产生了浓厚的兴趣。在这次的大作业中，我们将会探索中国娱乐圈中任何两个人之间的关系，测试六度分割理论，并进行更深入的尝试！数据采集关系
py2neo+Neo4j初体验
老毛的博客
04-12 876
这里写目录标题简介安装与沙箱使用py2neo问题记录 简介 图数据库是做知识图谱的好东东。当然，还可以做很多东西： 数据可视化、复杂网络不社会网络分析等 目前市面上有很多种，排名可以参考这里。 Neo4j作为图数据库中的头牌，当然有其独到之处， Desktop相当于管理数据库的客户端可以不用装，因为有web管理界面 还有一个auraDB好像是云上的数据库，一般也用不上 这里简单记录第一次使用Neo4j的一些注意事项 安装与沙箱使用 Windows下安装很简单，下载下来的是一个压缩包： 这里选择当然是免费的
基于SparkGraphx+Neo4j实现用户社群发现
02-24
有了这样的社群之后，我们就可以基于社群维度分析设备及用户行为的异常，比如单个设备登陆过多的用户，设备一直处于充电状态，所有用户行为高度一致等，同时可以计算社群用户作弊率来通过已知作弊用户来发
基于neo4j搭建金融风控图谱.rar
11-19
基于neo4j搭建金融风控图谱.rar基于neo4j搭建金融风控图谱.rar基于neo4j搭建金融风控图谱.rar基于neo4j搭建金融风控图谱.rar基于neo4j搭建金融风控图谱.rar基于neo4j搭建金融风控图谱.rar基于neo4j搭建金融风控图谱....
基于图数据库Neo4j的话单分析研究_黄冰倩.pdf
05-18
### 基于图数据库Neo4j的话单分析研究 #### 概述 《基于图数据库Neo4j的话单分析研究》一文由黄冰倩等人撰写，主要探讨了如何运用Neo4j这一图形数据库技术来进行话单分析，进而辅助公安机关获取有价值的破案线索。...
Python基于Neo4j图数据库的医疗知识图谱智能问答机器人源码+项目使用说明+超详细注释.zip
05-15
Python基于Neo4j图数据库的医疗知识图谱智能问答机器人源码+项目使用说明+超详细注释.zip个人经导师指导并认可通过的高分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。...
neo4j 欺诈检测 实践
08-10
用neo4j做欺诈检测的实践案例。用neo4j做欺诈检测的实践案例。
Neo4j的使用-1
摆渡者
08-20 845
节点：表示一个实体记录，就像关系数据库当中一条记录，一个节点包含多个属性和标签 关系：关系用于将节点关联起来构成图，关系也称为图论的边 属性：节点和关系都可以有多个属性，属性是由键值对组成的，就像JAVA中的哈希 标签：标签指示一组拥有相同属性的节点，但不强制要求相同，一个节点可以有多个标签 路径：图中任意两个节点都存在由关系组成的路径，路径有长短之分   Cypher查询语言 Cy...
【Neo4j】第 6 章：节点重要性
sikh_0529的博客
10-13 1764
在本章中，我们将讨论节点重要性，也称为中心性算法. 正如您将发现的那样，基于给定图形和给定问题的重要性定义，已经开发了几种技术。我们将了解最著名的技术，从度中心性和 Google 使用的 PageRank 算法开始。对于后者，我们将通过一个示例实现并在一个简单的图表上运行它，以充分了解它的工作原理以及何时可以使用它。在发现其他类型的中心性算法（例如中介中心性）之后，我们将在本章结束时解释如何在欺诈检测的上下文中使用中心性算法。在此示例中，我们将首次使用 GDS 中提供的工具从 Cypher 创建投影图，以便
有向图中任意两点的路径
万物皆可图
03-23 1895
【图技术】有向图中任意两点的路径 基于networkx的隐性集团关系识别模型 基于Neo4j的担保社群型态分析挖掘 前言 随着人工智能的不断发展，图这门技术也越来越重要，很多人都开启了学习图技术，本文就介绍了图技术中的计算任意两点的路径。 一、任意两点的路径 如下图所示，求企业A与企业B的路径 #mermaid-svg-LsSYbMchu1x1tfzm {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#3
一文读懂知识图谱的主要技术
热门推荐
04-20 1万+
导读：知识图谱主要技术包括知识获取、知识表示、知识存储、知识建模、知识融合、知识理解、知识运维等七个方面知识图谱主要技术包括知识获取、知识表示、知识存储、知识建模、知识融合、知识理解、知识运维等七个方面，通过面向结构化、半结构化和非结构化数据构建知识图谱为不同领域的应用提供支持，具体的技术架构如图4.1所示。一、知识获取知识图谱中的知识来源于结构化、半结构化和非结构化的信...
task01笔记
qq_38048065的博客
01-11 353
Datawhale 知识图谱组队学习 之 Task 1 知识图谱安装和介绍 以下笔记均参考DataWhale知识图谱组队学习所提供的笔记 目录 Datawhale 知识图谱组队学习 之 Task 1 知识图谱介绍 目录 一、Neo4J 介绍与安装 1.1 引言 1.2 Neo4J 下载 1.3 Neo4J 安装 1.4 Neo4J Web 界面 介绍 1.5 Cypher查询语言 二、Neo4J 实战 2.1 引言 2.2 创建节点 2.3 创建关系 2.4 创建 出生地关系 2.5 图数据
Neo4j：入门基础—插件
满腹的小不甘
11-14 851
Neo4j图数据库插件：APOC
networkx实践
shlhhy的博客
01-07 490
最近研究知识图谱相关的构建与推理应用，一个坑的问题在于neo4j中可以存储图数据，查询与可视化也做得不错，但是计算功能比较弱，而neo4j的查询结果不能直接导入networkx进行计算，需要根据查询结果构建图ε=(´ο｀*))) 1. networkx创建图 G.add_node(node) G.add_edge(link[0], link[1]) 2. networkx常用计算 获取节点/边列表 G.nodes() G.edges() 获取节点的度/入度、出度（有向图） G.degree(
用 NetworkX + Gephi + Nebula Graph 分析＜权力的游戏＞人物关系（上篇）
weixin_44324814的博客
08-19 1721
我们都知道《权利的游戏》在全世界都很多忠实的粉丝，除去你永远不知道剧情下一秒谁会挂这种意外“惊喜”，当中复杂交错的人物关系也是它火爆的原因之一，而本文介绍如何通过 NetworkX 访问开源的分布式图数据库 Nebula Graph，并借助可视化工具—— Gephi 来可视化分析《权力的游戏》中的复杂的人物图谱关系。 数据集 本文的数据集来源：冰与火之歌第一卷(至第五卷)[1] 人物集 (点集）：书中每个角色建模为一个点，点只有一个属性：姓名 关系集（边集）：如果两个角色在书中发生过直接或间接的交互，则.
使用SparkGraphx和Neo4j进行用户社群挖掘
总结来说，这篇文章提供了一个基于Spark GraphX和Neo4j的用户社群发现框架，强调了社群分析在反作弊和市场策略中的价值，并简要概述了社群发现的基本步骤和技术。通过这个框架，可以有效识别和理解用户网络中的群体...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值