精华内容
下载资源
问答
  • Python区块链应用-源码

    2021-02-10 02:49:57
    Python区块链应用 具有UI的完整区块链应用程序。 可以添加多个节点,每个节点都有自己的本地存储的区块链,一个公钥和一个私钥。 区块链存储在本地的.txt文件中。 钱包保存,加载和交易签名验证 块的真实SHA256...
  • easychain: 一个简单的python区块链分类ledger
  • python 区块链程序

    2018-03-24 20:23:00
    python 区块链程序 学习了:https://mp.weixin.qq.com/s?__biz=MzAxODcyNjEzNQ==&mid=2247484921&idx=1&sn=fd7a0b10fce7b5d78c477438a0c7040e&pass_ticket=VRQ4Gl2qVWVdx9L7zKnwzmZ%2F3afkWrOb1mO8...

    python 区块链程序

    学习了:https://mp.weixin.qq.com/s?__biz=MzAxODcyNjEzNQ==&mid=2247484921&idx=1&sn=fd7a0b10fce7b5d78c477438a0c7040e&pass_ticket=VRQ4Gl2qVWVdx9L7zKnwzmZ%2F3afkWrOb1mO8UAgklOnyOh1LnDAzTkLvyduPgzWb

    进行postman的post方法提交的时候,注意选择Body > raw 选择JSON(application/json)

    pip 进行install的时候选择国内的源;

     测试的时候使用pipenv 没有生效,后来改为修改文件,重写文件,然后启动两次;

    源文件:

    import hashlib
    import json
    from time import time
    from uuid import uuid4
    from flask import Flask, jsonify, request
    from urllib.parse import urlparse
    import requests
    
    
    class Blockchain(object):
        def __init__(self):
            self.chain = []
            self.current_transactions = []
            self.new_block(previous_hash=1, proof=None)
            self.nodes = set()
    
        def register_node(self, address):
            parsed_url = urlparse(address)
            self.nodes.add(parsed_url.netloc)
    
        def valid_chain(self, chain):
            last_block = chain[0]
            current_index = 1
            while current_index < len(chain):
                block = chain[current_index]
                print(f'{last_block}')
                print(f'{block}')
                print('\n---------------\n')
                if block['previous_hash'] != self.hash(last_block):
                    return False
                if not self.valid_proof(last_block['proof'], block['proof']):
                    return False
                last_block = block
                current_index += 1
            return True
    
        def resolve_conflicts(self):
            neighbours = self.nodes
            new_chain = None
            max_length = len(self.chain)
            for node in neighbours:
                response = requests.get(f'http://{node}/chain')
                if response.status_code == 200:
                    length = response.json()['length']
                    chain = response.json()['chain']
                    if length > max_length and self.valid_chain(chain):
                        max_length = length
                        new_chain = chain
            if new_chain:
                self.chain = new_chain
                return True
            return False
    
        def new_block(self, proof, previous_hash=None):
            block = {
                'index': len(self.chain) + 1,
                'timestamp': time(),
                'transactions': self.current_transactions,
                'proof': proof,
                'previous_hash': previous_hash or self.hash(self.chain[-1])
            }
            self.current_transactions = []
            self.chain.append(block)
            return block
    
        def new_transaction(self, sender, recipient, amount):
            self.current_transactions.append({
                'sender': sender,
                'recipient': recipient,
                'amount': amount
            })
            return self.last_block['index'] + 1
    
        @staticmethod
        def hash(block):
            block_string = json.dumps(block, sort_keys=True).encode()
            return hashlib.sha256(block_string).hexdigest()
    
        @property
        def last_block(self):
            return self.chain[-1]
    
        def proof_of_work(self, last_proof):
            proof = 0
            while self.valid_proof(last_proof, proof) is False:
                proof += 1
            return proof
    
        @staticmethod
        def valid_proof(last_proof, proof):
            guess = f'{last_proof}{proof}'.encode()
            guess_hash = hashlib.sha256(guess).hexdigest()
            return guess_hash[:4] == "0000"
    
    
    app = Flask(__name__)
    node_identifier = str(uuid4()).replace('-', '')
    blockchain = Blockchain()
    
    
    @app.route('/mine', methods=['GET'])
    def mine():
        last_block = blockchain.last_block
        last_proof = last_block['proof']
        proof = blockchain.proof_of_work(last_proof)
        blockchain.new_transaction(
            sender="0",
            recipient=node_identifier,
            amount=1
        )
        block = blockchain.new_block(proof)
        response = {
            'message': "New Block Forged",
            'index': block['index'],
            'transactions': block['transactions'],
            'proof': block['proof'],
            'previous_hash': block['previous_hash']
        }
        return jsonify(response), 200
    
    
    @app.route('/transactions/new', methods=['POST'])
    def new_transactions():
        values = request.get_json()
        print('*' * 20, values)
        required = ['sender', 'recipient', 'amount']
        if not all(k in values for k in required):
            return "Missing Values", 400
        index = blockchain.new_transaction(values['sender'], values['recipient'], values['amount'])
        response = {'message': f'Transaction will be added to Block{index}'}
        return jsonify(response), 201
    
    
    @app.route('/chain', methods=['GET'])
    def full_chain():
        response = {
            'chain': blockchain.chain,
            'length': len(blockchain.chain)
        }
        return jsonify(response), 200
    
    
    @app.route('/nodes/register', methods=['POST'])
    def register_nodes():
        values = request.get_json()
        nodes = values.get('nodes')
        if nodes is None:
            return "Error: Please supply a valid list of nodes", 400
        for node in nodes:
            blockchain.register_node(node)
        response = {
            'message': 'New nodes have been added',
            'total_nodes': list(blockchain.nodes)
        }
        return jsonify(response), 201
    
    @app.route('/nodes/resolve', methods=['GET'])
    def consensus():
        replaced = blockchain.resolve_conflicts()
        if replaced:
            response = {
                'message': 'Our chain was replaced',
                'new_chain': blockchain.chain
            }
        else:
            response = {
                'message': 'Our chain is authoritative',
                'chain': blockchain.chain
            }
        return jsonify(response), 200
    
    if __name__ == '__main__':
        app.run('0.0.0.0', port=5001)

     

    转载于:https://www.cnblogs.com/stono/p/8641292.html

    展开全文
  • Python 区块链学习(二)

    千次阅读 2019-03-02 19:56:04
    python 区块链学习(一) python 区块链学习(三) 0x01 链扩展 继续上一篇,由于区块链是建立在互联网上的各个节点之间的协议,所以我们需要将之前的单链扩展到各个节点之间。首先我们需要对init()函数追加一...

    python 区块链学习(一)

    python 区块链学习(三)

    0x01 链扩展

    继续上一篇,由于区块链是建立在互联网上的各个节点之间的协议,所以我们需要将之前的单链扩展到各个节点之间。首先我们需要对init()函数追加一个属性node,用一个set()来存放。node用来存放当前节点获取到的周围节点的ip地址,通过这种方式使得各个节点可以知道相互的存在,最终各个节点都可以连接起来。

    tips:python中的set()数据结构用来存放一组数据,其中的每一项都不相同。且set()不能用序号来访问,且不能排序。

    例子如下:

    >>> set('hello')
    {'o', 'e', 'l', 'h'}

    首先更改init()函数结构,追加node属性

        def __init__(self):
            self.chain = []
            self.current_transactions = []
            self.node = set()
    
            self.new_block(previous_hash=1, proof=100)

      以及添加node节点的函数

        def register_node(self, address):
            parsed_url = urlparse(address)
            self.node.add(parsed_url.netloc)

    0x02 共识体系

    我们已经有了一个基本的区块链可以接受交易和挖矿。但是区块链系统应该是分布式的。既然是分布式的,那么我们究竟拿什么保证所有节点有同样的链呢?这就是一致性问题,我们要想在网络上有多个节点,就必须实现一个一致性的算法

    在实现一致性算法之前,我们需要找到一种方式让一个节点知道它相邻的节点。每个节点都需要保存一份包含网络中其它节点的记录。因此让我们新增几个接口:

    /nodes/register 接收 URL 形式的新节点列表.
    /nodes/resolve 执行一致性算法,解决任何冲突,确保节点拥有正确的链.
     

     @app.route('/register/node', methods=['POST']) #注册节点
        def register_node():
            values = request.get_json()
            nodes = values.get('nodes')    
    
            if nodes is None:
                return 'Error:nodes err', 400
    
            for node in nodes:
                blockchain.register_node(node)
    
            response = {
                'message': 'Nodes have been added',
                'total_nodes': list(blockchain.node)
            }
    
            return jsonify(response), 200
    
        @app.route('/nodes/resolve', methods=['GET'])   #判断链是否正确 正确返回True
        def consensus():
            result = blockchain.resolve_conflicts()
    
            if result:
                response = {
                    'message': 'The chain has been updated.',
                    'new_chain': blockchain.chain,
                }
    
            else:
                response = {
                    'message': 'Our chain is authoritative',
                    'chain': blockchain.chain,
                }
    
            return jsonify(response), 200

    就像先前讲的那样,当一个节点与另一个节点有不同的链时,就会产生冲突。 为了解决这个问题,我们将制定最长的有效链条是最权威的规则。换句话说就是:在这个网络里最长的链就是最权威的。 我们将使用这个算法,在网络中的节点之间达成共识。其中判别是否合法的函数valid_chain() 以及更新自己的链的函数resolve_conflicts()的实现如下:

        def valid_chain(self, chain):    #验证链是否正确
            current_index = 1
            last_block = chain[0]
    
            while current_index < len(chain):
                block = chain[current_index]
                print(f'block:{block}, last_block:{last_block}')
    
                if block['previous_hash'] != self.hash(last_block): #判断块的hash是否正确
                    return False
                if not self.valid_proof(block['proof'],last_block['proof']): #判断proof正确
                    return False
    
                last_block = block
                current_index +=1
    
            return True
    
        def resolve_conflicts(self):  #判别是否和自己的链相同 相同返回FALSE
            neighbors = self.node
            new_chain = None
    
            max_length = len(self.chain)
    
            for node in neighbors:
                response = requests.get(f'http://{node}/chain')
    
                if response.status_code == 200:
                    length = response.json()['length']
                    chain = response.json()['chain']
    
                    if length > max_length and self.valid_chain(chain):
                        new_chain = chain
                        max_length = length
    
            if new_chain:
                self.chain = new_chain
                return True
    
            return False

    到此我们的节点就已经完成了。接下来进入到测试阶段。

     

    展开全文
  • python 区块链学习(二) python 区块链学习(三) 0x00 系统环境 本次使用的为Python3.6.5 需要用到的库包括hashlib,flask(0.12.2),time 0x01 区块链结构 这个部分看了一些的资料,慢慢理清了结...

    最近在纠结以后的研究方向,就先看了看云链。即一种云计算+区块链+物联网设备的架构模式。虽然还是雨里雾里,还是决定先把区块链的编程落实一下。

    python 区块链学习(二)

    python 区块链学习(三)

    0x00 系统环境

    本次使用的为Python3.6.5 需要用到的库包括hashlib,flask(0.12.2),time

    0x01 区块链结构

    这个部分看了一些的资料,慢慢理清了结构。所谓区块链就是一条链(chain),在python里用一个很长的链表list表示。列表里每一项分别为一个交易记录(transactions)。而每个交易记录里又包括这个交易的各种信息:交易的标号(index),交易创建的时间(timestamp),交易内容(transactions),工作证明/挖矿(proof),前一个块的哈希值(previous_hash)。再其中,交易内容又包括:接收者(recepient),发送者(sender),交易金额(amount)。这样看起来太复杂了,用一个图来呈现一下吧。

    0x02 区块链逻辑

     整个区块链根据结构可以大致分为几个模块:

    1.区块链的初始化     2.新块(block)的建立      3.新交易的建立(transactions)   4.工作证明算法

    ①  首先是区块链的建立,之前介绍了区块链在python中就是一个很长的列表,其中存放了一个一个的节点(block)。

    初始化区块链很简单,就是申请一个新的列表。

    class Blockchain(object):
    
        def __init__(self):
            self.chain = []
    

    ②  有了链以后我们就可以添加节点(block)了。区块链的每个节点是用来记录每次的交易记录的,其中包括了节点序号、时间等参数。在python中节点用一个字典表示,分别记录各个参数。

    class Blockchain(object):
    
        def __init__(self):
            self.chain = []
            self.current_transactions = []
    
            self.new_block(previous_hash=1, proof=100)   # 创建初始区块
    
        def new_block(self, proof, previous_hash=None):
            block = {
                'index': len(self.chain) + 1,            # 序号
                'timestamp': time(),
                'transactions': self.current_transactions,
                'proof': proof,                            # 工作证明(挖矿)
                'previous_hash': previous_hash or self.hash(self.chain[-1]),  # 前一个哈希
            }
    
            self.current_transactions = []
    
            self.chain.append(block)
            return block

    这里注意,创建了新的节点,就要清空当前的交易记录,以方便记录下一个节点的交易记录。这个current_transactions也是一个列表,用来记录当前节点的交易记录。接下来详细介绍。

    ③  交易记录是一个列表,里面存放一个个的字典,来存放当前块的每笔交易。每个块可以存放多个交易记录。接下来为创建新记录的函数 以及计算哈希值的函数。

        def new_transaction(self,recepient,sender,amount):     # 创建新的交易
            self.current_transactions.append({
                'sender':sender,            # 接收者
                'recepient':recepient,      # 发送者
                'amount':amount,            # 金额
            })
    
            return self.last_block['index'] + 1
        
        @staticmethod
        def hash(block):
            block_string = json.dumps(block, sort_keys=True).encode()
            return hashlib.sha256(block_string).hexdigest()
    
        @property                                  # 直接获取return的值
        def last_block(self):
            return self.chain[-1]

    ④ 最后是工作证明,也被称作为挖矿。

    使用工作量证明(PoW)算法,来证明是如何在区块链上创建或挖掘新的区块。PoW 的目标是计算出一个符合特定条件的数字,这个数字对于所有人而言必须在计算上非常困难,但易于验证。这是工作证明背后的核心思想。

    我们将看到一个简单的例子帮助你理解:

    假设一个整数 x 乘以另一个整数 y 的积的 Hash 值必须以 0 结尾,即 hash(x * y) = ac23dc...0。设 x = 5,求 y ?用 Python 实现:

    from hashlib import sha256
    x = 5
    y = 0  # We don't know what y should be yet...
    while sha256(f'{x*y}'.encode()).hexdigest()[-1] != "0":
        y += 1
    print(f'The solution is y = {y}')

    结果是: y = 21。因为,生成的 Hash 值结尾必须为 0。

    hash(5 * 21) = 1253e9373e...5e3600155e860

    在比特币中,工作量证明算法被称为 Hashcash ,它和上面的问题很相似,只不过计算难度非常大。这就是矿工们为了争夺创建区块的权利而争相计算的问题。 通常,计算难度与目标字符串需要满足的特定字符的数量成正比,矿工算出结果后,就会获得一定数量的比特币奖励(通过交易)。

    验证结果,当然非常容易。

    让我们来实现一个相似 PoW 算法。规则类似上面的例子:

    找到一个数字 P ,使得它与前一个区块的 proof 拼接成的字符串的 Hash 值以 4 个零开头。

        def proof_of_work(self, last_proof):
            proof = 0
    
            while self.valid_proof(proof, last_proof) is False:
                proof += 1
    
            return proof
    
        @staticmethod
        def valid_proof(proof, last_proof):
            guess = f'{last_proof}{proof}'.encode()
            guess_hash = hashlib.sha256(guess).hexdigest()
    
            return guess_hash[:4] == "0000"

    0x03 区块链实验

    我们采用python的flask框架,将我们写好的区块链放在服务器上运行。先附上代码

    def main():
        app = Flask(__name__)
        node_identifier = str(uuid4()).replace('-', '')
        blockchain = Blockchain()
    
        @app.route('/mine', methods=['GET'])
        def mine():
            last_block = blockchain.last_block
            last_proof = last_block['proof']
            proof = blockchain.proof_of_work(last_proof)
    
            blockchain.new_transaction(
                sender = '0',
                recepient = node_identifier,
                amount = 1,
            )
    
            last_hash = blockchain.hash(last_block)
            block = blockchain.new_block(proof, last_hash)
    
            response = {
                'message':'New Blcok Forged',
                'index': block['index'],
                'transactions': block['transactions'],
                'proof': block['proof'],
                'previous_hash': block['previous_hash'],
            }
    
            return jsonify(response), 200
    
    
        @app.route('/transactions/new', methods=['POST'])
        def new_transaction():
            values = request.get_json()
            required = ['sender','recepient','amount']
    
            if not all(k in values for k in required):
                return 'Missing values', 400
    
            index = blockchain.new_transaction(values['recepient'], values['sender'], values['amount'])
    
            response = {'message':f'transactions have been added to {index}'}
    
            return jsonify(response), 201
    
        @app.route('/chain', methods=['GET'])
        def full_chain():
            response = {
                'chain': blockchain.chain,
                'length': len(blockchain.chain),
            }
    
            return jsonify(response), 200
           # return f'<h1>{response}</h1>'
    
        app.run(host = '0.0.0.0', port=5000)

    其中,通过访问 http://localhost:5000/mine 新建一个区块的页面,通过请求,创建一个新的区块,其中交易金额为1,即通过挖矿,我们找到了一个新的区块,系统(sender=0)奖励给我们(recepient=node_identifier)一个币。这就是整个挖矿的逻辑实现。如下

    然后,http://ocalhost:5000/transactions/new 我们可以添加一笔交易记录。

    最后,http://ocalhost:5000/chain 我们可以请求到整个链。

    随着创建的节点的增多,我们查看到的链就越长。

    关于单条连的学习就到此为止,由于区块链是在整个网络上 各个设备之间都存在的架构。接下来将进入到多台设备的学习中。

    展开全文
  • Python不是主流的区块链...本文介绍了10个最流行的Python区块链项并提供了相应的源代码下载地址。 区块链开发教程链接:以太坊 | 比特币 | EOS | Tendermint | Hyperledger Fabric | Omni/USDT | Ripple 1、web3....

    Python不是主流的区块链底层平台开发语言,但是在DApp开发、区块链仿真与数据分析、智能合约安全分析等领域,Python依然是不错的选择。本文介绍了10个最流行的Python区块链项并提供了相应的源代码下载地址。

    区块链开发教程链接:以太坊 | 比特币 | EOS | Tendermint | Hyperledger Fabric | Omni/USDT | Ripple

    1、web3.py - 以太坊的Python开发接口

    web3.py是访问以太坊区块链及相关生态的Python接口,可以视为web3.js的Python版本的实现,它需要Python 3.6+运行环境。

    在这里插入图片描述

    2、mythril - 以太坊智能合约安全分析工具

    Mythril是以太坊虚拟机字节码的安全分析工具,它支持EVM兼容区块链的智能合约的安全分析,例如以太坊、hedera、quorum、vechain、roostock、tron等。

    在这里插入图片描述

    • Python源码下载:https://github.com/ConsenSys/mythril

    3、Python-blockchain-sim - 适合学习与科研的仿真区块链

    使用Python开发一个多节点的仿真区块链,并基于该仿真区块链网络开发一个去中心化的数据分享应用。 适合进行区块链原理性研究,或者在自己的笔记本上仿真区块链网络并进行研究性实验,例如毕业设计项目或课题研究。本项目代码完整的教程请访问博客Python仿真区块链

    在这里插入图片描述

    • Python源码下载:https://github.com/ezpod/python-blockchain-sim

    4、SimpleCoin - 仿比特币区块链

    一个简单的仿比特币的区块链实现,采用Python开发。项目的目的是创建一种可用的区块链货币,并且尽可能的简单,因此可以用于教学目的。

    在这里插入图片描述

    • Python源码下载:https://github.com/cosme12/SimpleCoin

    5、CrackCoin - 无链数字货币的PoC实现

    Crackcoin是一个无区块链数字加密货币的概念验证实现,采用Python开发。它最大的特点就是没有使用区块链作为加密货币的实现基础,其灵感来自于这篇论文:Blockchain-Free Cryptocurrencies: A Framework for Truly Decentralised Fast Transactions

    在这里插入图片描述

    • Python源码下载:https://github.com/DutchGraa/crackcoin

    6、cert-issuer - 基于区块链的毕业证书签发与验证

    cert-issuer是一个基于比特币或以太坊区块链签发毕业证书的项目,采用Python实现。利用cert-issuer,签发机构通过向区块链提交一个包含证书哈希的交易实现毕业证书的签发,并利用该链上哈希实现毕业证书的验证。

    在这里插入图片描述

    • Python源码下载:https://github.com/blockchain-certificates/cert-issuer

    7、Fabric-sdk-py - 超级账本Fabric区块链的Python开发包

    Fabric-SDK-Py 是Hyperledger Fabric区块链的Python SDK,目前支持Fabric 1.4.x。

    在这里插入图片描述

    • Python源码下载:https://github.com/hyperledger/fabric-sdk-py

    8、octopus

    octopus是一个用于webassembly模块以及区块链智能合约的安全分析工具,其目的是提供一个分析闭源的webassembly模块以及智能合约字节码的简单方法以便更深入的了解这些WASM模块或智能合约的内部行为。

    在这里插入图片描述

    • Python源码下载:https://github.com/pventuzelo/octopus

    9、python-bitcoin-blockchain-parser

    Python-bitcoin-blockchain-parser是一个python 3的比特币区块链原始数据解析器。它可以监测输出类型以及输出中的地址、解析比特币脚本、支持segwit、支持区块排序解析。

    • Python源码下载:https://github.com/alecalve/python-bitcoin-blockchain-parser

    10、Orbit

    Orbit是一个区块链交易调查工具,它通过递归地抓取交易历史来探索区块链网络,然后将数据渲染为图来展示源、目的以及可疑的连接。
    在这里插入图片描述

    • Python源码下载:https://github.com/s0md3v/Orbit

    原文链接:10个最流行的Python区块链项目 — 汇智网

    展开全文
  • python 区块链学习(一) python 区块链学习(二) 0x01 测试环境 上一节完成了区块链的节点编程,现在进入到网络调试阶段。此次实现环境为两个节点,分别运行在同一台机器上的不同端口。 分别为 ...
  • 上回已经给出了简单python区块链postman交互代码,现在则来演示一下使用requests库的交互操作过程。 首先打开powershell 。键入“cd 文件所在地址链接名”。回车,再键入“python 文件名”。我这里的文件名定为了...
  • python区块链的开发

    2018-05-31 23:43:36
    至此,已经完成了:交易记录,区块的开发,现在进行区块链的开发就比较容易了。实现代码如下: from Block import InvalidBlock, Block from Message import InvalidMessage, DaDaMessage from Transaction import...
  • Python区块链仿真实现教程及源码

    千次阅读 2020-04-02 09:33:12
    区块链或数字货币领域,Python并不是主流的开发语言。但是如果你的目的是研究区块链技术的原理,或者需要在自己的笔记本上仿真一个区块链网络并进行一些研究性的实验,比如完成自己的毕业设计项目或科研课题,那么...
  • 学习一门技术最好的方法就是自己做一个,水平有限,手敲了一遍这个代码,边敲边学,在这个过程中对区块链有了更加全面的认识,同时也学习了一些python知识。 区块链基本概念区块链是一个分布式账本,每个参与挖矿的...
  • 上回已经给出了简单区块链python代码,现在则来演示一下postman交互的操作过程。 首先打开powershell 。键入“cd 文件所在地址链接名”。回车,再键入“python 文件名”。我这里的文件名定为了try.py 如下图,一...
  • 铋自述 警告:此存储库不再维护,将在此处继续维护: : 执照: 该程序是免费软件; 您可以根据自由软件基金会发布的GNU通用公共许可证的条款重新分发和/或修改它; 许可的版本2,或(由您选择)任何更高的版本。...
  • 区块链学习随笔(1) 用python读取Excel并输出表格新表格 1、读取csv数据 import pandas as pd #第三方库,专门用于数据分析,处理表格数据 #读取数据 df = pd.read_csv('BTC_history.csv', #此处为数据文件地址 ...
  • 首先是区块链的总的代码: https://blog.csdn.net/qq_41938259/article/details/86376407 接着关于RSA加密算法的总结与讲解: 1)拉宾米勒模块:https://blog.csdn.net/qq_41938259/article/details/86675887 ...
  • 铋自述 警告:出于生产目的,请仅使用“发行版”页面中的代码,该页面未处于发行前状态。 官方网站: 浏览器: 钱包: 超节点网站: 相关资料库: 链接: 铋基金会: 社交: CI:
  • 区块链blockchain_go的python实现
  • 通过Python入门区块链

    2018-03-29 20:47:44
    通过Python入门区块链 本文翻译自 Adil Moujahid 的文章 A Practical Introduction to Blockchain with Python原文地址:http://adilmoujahid.com/posts/2018/03/intro-blockchain-bitcoin-python/ 区块链可能...
  • 主要介绍了python简单区块链模拟详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Python编写区块链

    2018-07-27 22:41:15
    本项目是之前听普林斯顿区块链项目公开课时做的区块链项目练习,使用python语言编写。但是我对于python的flask的框架和网络编程有些不熟悉,加上由于考研时间比较紧张,因此一直没能完善网络编程部分,在这里希望有...
  • python搭建区块链

    2019-10-02 20:03:12
    /usr/bin/env python # encoding: utf-8 ''' 我们要创建一个 Blockchain 类 ,他的构造函数创建了一个初始化的空列表(要存储我们的区块链),并且另一个存储交易。 我们的 Blockchain 类负责管理链式数据,它...
  • python 入门区块链

    2019-08-15 20:59:17
    区块链可能是继互联网之后最重大和最具突破性的技术。它是比特币和其他加密货币背后的核心技术,在近几年可谓赚足了人们的眼球。 本质上讲,区块链是一种不需第三方权威机构,直接在两者之间点对点交易的分布式...
  • 区块链Python HD(分层确定性)钱包可以允许从单个种子短语生成许多crpyto钱包。这是一个从根节点开始的公共/私有密钥树,该根节点是主节点。任何节点都可以有多个子代。主私钥的唯一目的是重新生成钱包树,并且...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,527
精华内容 1,010
关键字:

python区块链

python 订阅