python适合开发区块链吗,个人可以搭建区块链吗

2022-08-25 23:49:58 分类：python 阅读()

　　python适合开发区块链吗,个人可以搭建区块链吗

　　【相关学习推荐：python教程】

　　你会不会和我一样，对加密数字货币的底层区块链技术非常感兴趣，特别想知道它们的运行机制？

　　但是学习区块链技术并不是一帆风顺的。看了很多视频教程和各种课程，最后的感觉就是实战课程太少了。

　　我喜欢在实践中学习，尤其是基于一个代码去理解整个工作机制。如果你和我一样喜欢这种学习方式，当你读完这篇教程，你就会知道区块链技术是如何工作的。

　　

写在开始之前

请记住，在不可变的、有序的.区块链是一个名为block的记录链，它们可以包含交易、文档或任何您喜欢的数据。但重要的是它们是用一个hash链接在一起的。

　　如果你不熟悉哈希，这里有一个解释。

　　该指南的目的是什么？

　　你可以很舒服的读写基本的Python，因为我们会通过HTTP和区块链讨论，所以你也应该知道HTTP是怎么工作的。

　　我需要准备什么？

　　确保安装了Python 3.6(和pip)。您还需要安装Flask和请求库：

　　安装Flask==0.12.2 Requests==2.18.4对了，你还需要一个支持HTTP的客户端，比如Postman或者cURL，其他都可以。

　　源码在哪儿？

　　你可以点击这里

　　00-1010打开您最喜欢的文本编辑器或IDE。个人比较喜欢PyCharm。创建一个名为blockchain.py的新文件，我们将只使用这一个文件。但如果还是不确定，也可以参考源代码。

　　00-1010我们要创建一个区块链类。它的构造函数创建一个初始化的空列表(存储我们的区块链)，另一个存储事务。下面是我们3360班的一个例子。

　　区块链. py

　　类区块链(对象):

　　def __init__(self):

　　self.chain=[]

　　self.current_transactions=[]

　　def new_block(自身):

　　#创建一个新块并将其添加到链中

　　及格

　　def new_transaction(自身):

　　#将新事务添加到事务列表中

　　及格

　　@静态方法

　　定义哈希(块):

　　#散列一个块

　　及格

　　@属性

　　def last_block(自身):

　　#返回链中的最后一个块

　　我们的区块链类负责管理链式数据。它存储事务，并有一个向链式数据添加新块的方法。让我们开始扩展更多的方法。

　　00-1010每个块都有一个索引、一个时间戳(Unix时间戳)、一个事务列表、一个检查(稍后详述)和前一个块的散列。

　　以下是块的示例：

　　区块链. py

　　block={

　　索引 : 1，

　　时间戳 : 1506057125.900785，

　　交易 : [

　　{

　　发件人 : 8527147 fe1f 5426 f9dd 545 de 4b 27 ee 00 ，

　　收件人 : a 77 F5 cdfa 2934 df 3954 a5 C7 c 7 da 5d f1f :

　　金额 : 5，

　　}

　　],

　　证明 : 324984774000，

　　previous _ hash : 2 cf 24 DBA 5 FB 0 a 30 e

　　26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"

　　}在这一点上，一个 区块链 的概念应该是明显的 - 每个新块都包含在其内的前一个块的 散列 。 这是至关重要的，因为这是 区块链 不可改变的原因：如果攻击者损坏 区块链 中较早的块，则所有后续块将包含不正确的哈希值。

　　这有道理吗？ 如果你还没有想通，花点时间仔细思考一下 - 这是区块链背后的核心理念。

　　

添加交易到区块

我们将需要一个添加交易到区块的方式。我们的 new_transaction() 方法的责任就是这个， 并且它非常的简单：

　　blockchain.py

　　

class Blockchain(object):
　　 ...
　　 def new_transaction(self, sender, recipient, amount):
　　 """
　　 Creates a new transaction to go into the next mined Block
　　 :param sender: <str> Address of the Sender
　　 :param recipient: <str> Address of the Recipient
　　 :param amount: <int> Amount
　　 :return: <int> The index of the Block that will hold this transaction
　　 """
　　 self.current_transactions.append({
　　 'sender': sender,
　　 'recipient': recipient,
　　 'amount': amount,
　　 })
　　 return self.last_block['index'] + 1
new_transaction() 方法添加了交易到列表，它返回了交易将被添加到的区块的索引---讲开采下一个这对稍后对提交交易的用户有用。

　　

创建新的区块

当我们的 Blockchain 被实例化后，我们需要将 创世 区块（一个没有前导区块的区块）添加进去进去。我们还需要向我们的起源块添加一个 证明，这是挖矿的结果(或工作证明)。 我们稍后会详细讨论挖矿。

　　除了在构造函数中创建 创世 区块外，我们还会补全 new_block() 、 new_transaction() 和 hash() 函数：

　　blockchain.py

　　

import hashlib
　　import json
　　from time import time
　　class Blockchain(object):
　　 def __init__(self):
　　 self.current_transactions = []
　　 self.chain = []
　　 # 创建创世区块
　　 self.new_block(previous_hash=1, proof=100)
　　 def new_block(self, proof, previous_hash=None):
　　 """
　　 创建一个新的区块到区块链中
　　 :param proof: <int> 由工作证明算法生成的证明
　　 :param previous_hash: (Optional) <str> 前一个区块的 hash 值
　　 :return: <dict> 新区块
　　 """
　　 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):
　　 """
　　 创建一笔新的交易到下一个被挖掘的区块中
　　 :param sender: <str> 发送人的地址
　　 :param recipient: <str> 接收人的地址
　　 :param amount: <int> 金额
　　 :return: <int> 持有本次交易的区块索引
　　 """
　　 self.current_transactions.append({
　　 'sender': sender,
　　 'recipient': recipient,
　　 'amount': amount,
　　 })
　　 return self.last_block['index'] + 1
　　 @property
　　 def last_block(self):
　　 return self.chain[-1]
　　 @staticmethod
　　 def hash(block):
　　 """
　　 给一个区块生成 SHA-256 值
　　 :param block: <dict> Block
　　 :return: <str>
　　 """
　　 # 我们必须确保这个字典（区块）是经过排序的，否则我们将会得到不一致的散列
　　 block_string = json.dumps(block, sort_keys=True).encode()
　　 return hashlib.sha256(block_string).hexdigest()
上面的代码应该是直白的 --- 为了让代码清晰，我添加了一些注释和文档说明。 我们差不多完成了我们的区块链。 但在这个时候你一定很疑惑新的块是怎么被创建、锻造或挖掘的。

　　

工作量证明算法

使用工作量证明（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 个零开头。

　　

blockchain.py

　　

import hashlib
　　import json
　　from time import time
　　from uuid import uuid4
　　class Blockchain(object):
　　 ...
　　 def proof_of_work(self, last_proof):
　　 """
　　 Simple Proof of Work Algorithm:
　　 - Find a number p' such that hash(pp') contains leading 4 zeroes, where p is the previous p'
　　 - p is the previous proof, and p' is the new proof
　　 :param last_proof: <int>
　　 :return: <int>
　　 """
　　 proof = 0
　　 while self.valid_proof(last_proof, proof) is False:
　　 proof += 1
　　 return proof
　　 @staticmethod
　　 def valid_proof(last_proof, proof):
　　 """
　　 Validates the Proof: Does hash(last_proof, proof) contain 4 leading zeroes?
　　 :param last_proof: <int> Previous Proof
　　 :param proof: <int> Current Proof
　　 :return: <bool> True if correct, False if not.
　　 """
　　 guess = f'{last_proof}{proof}'.encode()
　　 guess_hash = hashlib.sha256(guess).hexdigest()
　　 return guess_hash[:4] == "0000"
衡量算法复杂度的办法是修改零开头的个数。使用 4 个来用于演示，你会发现多一个零都会大大增加计算出结果所需的时间。

　　现在 Blockchain 类基本已经完成了，接下来使用 HTTP Requests 来进行交互。

　　

Step 2: Blockchain 作为 API 接口

我们将使用 Python Flask 框架，这是一个轻量 Web 应用框架，它方便将网络请求映射到 Python 函数，现在我们来让 Blockchain 运行在基于 Flask web 上。

　　我们将创建三个接口：

　　

  • /transactions/new 创建一个交易并添加到区块
  • /mine 告诉服务器去挖掘新的区块
  • /chain 返回整个区块链

创建节点

我们的 Flask 服务器 将扮演区块链网络中的一个节点。我们先添加一些框架代码：

　　blockchain.py

　　

import hashlib
　　import json
　　from textwrap import dedent
　　from time import time
　　from uuid import uuid4
　　from flask import Flask
　　class Blockchain(object):
　　 ...
　　# Instantiate our Node（实例化我们的节点）
　　app = Flask(__name__)
　　# Generate a globally unique address for this node（为这个节点生成一个全球唯一的地址）
　　node_identifier = str(uuid4()).replace('-', '')
　　# Instantiate the Blockchain（实例化 Blockchain类）
　　blockchain = Blockchain()
　　@app.route('/mine', methods=['GET'])
　　def mine():
　　 return "We'll mine a new Block"
　　@app.route('/transactions/new', methods=['POST'])
　　def new_transaction():
　　 return "We'll add a new transaction"
　　@app.route('/chain', methods=['GET'])
　　def full_chain():
　　 response = {
　　 'chain': blockchain.chain,
　　 'length': len(blockchain.chain),
　　 }
　　 return jsonify(response), 200
　　if __name__ == '__main__':
　　 app.run(host='0.0.0.0', port=5000)
简单的说明一下以上代码：

　　

  • 第 15 行：实例化节点。阅读更多关于 Flask 内容。
  • 第 18 行：为节点创建一个随机的名称。.
  • 第 21 行：实例化 Blockchain 类。
  • 第 24--26 行：创建 /mine 接口，GET 方式请求。
  • 第 28--30 行：创建 /transactions/new 接口，POST 方式请求，可以给接口发送交易数据。
  • 第 32--38 行：创建 /chain 接口，返回整个区块链。
  • 第 40--41 行：服务器运行端口 5000 。

发送交易

发送到节点的交易数据结构如下：

　　

{
　　 "sender": "my address",
　　 "recipient": "someone else's address",
　　 "amount": 5
　　}
因为我们已经有了添加交易的方法，所以基于接口来添加交易就很简单了。让我们为添加事务写函数：

　　blockchain.py

　　

import hashlib
　　import json
　　from textwrap import dedent
　　from time import time
　　from uuid import uuid4
　　from flask import Flask, jsonify, request
　　...
　　@app.route('/transactions/new', methods=['POST'])
　　def new_transaction():
　　 values = request.get_json()
　　 # Check that the required fields are in the POST'ed data
　　 required = ['sender', 'recipient', 'amount']
　　 if not all(k in values for k in required):
　　 return 'Missing values', 400
　　 # Create a new Transaction
　　 index = blockchain.new_transaction(values['sender'], values['recipient'], values['amount'])
　　 response = {'message': f'Transaction will be added to Block {index}'}
　　 return jsonify(response), 201

挖矿

挖矿正是神奇所在，它很简单，做了一下三件事：

　　

  1. 计算工作量证明 PoW
  2. 通过新增一个交易授予矿工（自己）一个币
  3. 构造新区块并将其添加到链中
blockchain.py

　　

import hashlib
　　import json
　　from time import time
　　from uuid import uuid4
　　from flask import Flask, jsonify, request
　　...
　　@app.route('/mine', methods=['GET'])
　　def mine():
　　 # We run the proof of work algorithm to get the next proof...
　　 last_block = blockchain.last_block
　　 last_proof = last_block['proof']
　　 proof = blockchain.proof_of_work(last_proof)
　　 # We must receive a reward for finding the proof.
　　 # The sender is "0" to signify that this node has mined a new coin.
　　 blockchain.new_transaction(
　　 sender="0",
　　 recipient=node_identifier,
　　 amount=1,
　　 )
　　 # Forge the new Block by adding it to the chain
　　 previous_hash = blockchain.hash(last_block)
　　 block = blockchain.new_block(proof, previous_hash)
　　 response = {
　　 'message': "New Block Forged",
　　 'index': block['index'],
　　 'transactions': block['transactions'],
　　 'proof': block['proof'],
　　 'previous_hash': block['previous_hash'],
　　 }
　　 return jsonify(response), 200
注意交易的接收者是我们自己的服务器节点，我们做的大部分工作都只是围绕 Blockchain 类方法进行交互。到此，我们的区块链就算完成了，我们来实际运行下。

　　

Step 3: 运行区块链

你可以使用 cURL 或 Postman 去和 API 进行交互

　　启动 Server：

　　

$ python blockchain.py
　　* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
让我们通过请求 http://localhost:5000/mine （ GET ）来进行挖矿：

　　用 Postman 发起一个 GET 请求.

　　创建一个交易请求，请求 http://localhost:5000/transactions/new （POST）,如图

　　如果不是使用 Postman，则用一下的 cURL 语句也是一样的：

　　

$ curl -X POST -H "Content-Type: application/json" -d '{
　　 "sender": "d4ee26eee15148ee92c6cd394edd974e",
　　 "recipient": "someone-other-address",
　　 "amount": 5
　　}' "http://localhost:5000/transactions/new"
在挖了两次矿之后，就有 3 个块了，通过请求 http://localhost:5000/chain 可以得到所有的块信息

　　

{
　　 "chain": [
　　 {
　　 "index": 1,
　　 "previous_hash": 1,
　　 "proof": 100,
　　 "timestamp": 1506280650.770839,
　　 "transactions": []
　　 },
　　 {
　　 "index": 2,
　　 "previous_hash": "c099bc...bfb7",
　　 "proof": 35293,
　　 "timestamp": 1506280664.717925,
　　 "transactions": [
　　 {
　　 "amount": 1,
　　 "recipient": "8bbcb347e0634905b0cac7955bae152b",
　　 "sender": "0"
　　 }
　　 ]
　　 },
　　 {
　　 "index": 3,
　　 "previous_hash": "eff91a...10f2",
　　 "proof": 35089,
　　 "timestamp": 1506280666.1086972,
　　 "transactions": [
　　 {
　　 "amount": 1,
　　 "recipient": "8bbcb347e0634905b0cac7955bae152b",
　　 "sender": "0"
　　 }
　　 ]
　　 }
　　 ],
　　 "length": 3
　　}

Step 4: 一致性（共识）

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

　　

注册节点

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

　　

  1. /nodes/register 接收 URL 形式的新节点列表.
  2. /nodes/resolve 执行一致性算法，解决任何冲突，确保节点拥有正确的链.
我们修改下 Blockchain 的 init 函数并提供一个注册节点方法：

　　blockchain.py

　　

...
　　from urllib.parse import urlparse
　　...
　　class Blockchain(object):
　　 def __init__(self):
　　 ...
　　 self.nodes = set()
　　 ...
　　 def register_node(self, address):
　　 """
　　 Add a new node to the list of nodes
　　 :param address: <str> Address of node. Eg. 'http://192.168.0.5:5000'
　　 :return: None
　　 """
　　 parsed_url = urlparse(address)
　　 self.nodes.add(parsed_url.netloc)
我们用 set 来储存节点，这是一种避免重复添加节点的简单方法.

　　

实现共识算法

就像先前讲的那样，当一个节点与另一个节点有不同的链时，就会产生冲突。 为了解决这个问题，我们将制定最长的有效链条是最权威的规则。换句话说就是：在这个网络里最长的链就是最权威的。 我们将使用这个算法，在网络中的节点之间达成共识。

　　blockchain.py

　　

...
　　import requests
　　class Blockchain(object)
　　 ...
　　 def valid_chain(self, chain):
　　 """
　　 Determine if a given blockchain is valid
　　 :param chain: <list> A blockchain
　　 :return: <bool> True if valid, False if not
　　 """
　　 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")
　　 # Check that the hash of the block is correct
　　 if block['previous_hash'] != self.hash(last_block):
　　 return False
　　 # Check that the Proof of Work is correct
　　 if not self.valid_proof(last_block['proof'], block['proof']):
　　 return False
　　 last_block = block
　　 current_index += 1
　　 return True
　　 def resolve_conflicts(self):
　　 """
　　 This is our Consensus Algorithm, it resolves conflicts
　　 by replacing our chain with the longest one in the network.
　　 :return: <bool> True if our chain was replaced, False if not
　　 """
　　 neighbours = self.nodes
　　 new_chain = None
　　 # We're only looking for chains longer than ours
　　 max_length = len(self.chain)
　　 # Grab and verify the chains from all the nodes in our network
　　 for node in neighbours:
　　 response = requests.get(f'http://{node}/chain')
　　 if response.status_code == 200:
　　 length = response.json()['length']
　　 chain = response.json()['chain']
　　 # Check if the length is longer and the chain is valid
　　 if length > max_length and self.valid_chain(chain):
　　 max_length = length
　　 new_chain = chain
　　 # Replace our chain if we discovered a new, valid chain longer than ours
　　 if new_chain:
　　 self.chain = new_chain
　　 return True
　　 return False
第一个方法 valid_chain() 负责检查一个链是否有效，方法是遍历每个块并验证散列和证明。

　　resolve_conflicts() 是一个遍历我们所有邻居节点的方法，下载它们的链并使用上面的方法验证它们。 如果找到一个长度大于我们的有效链条，我们就取代我们的链条。

　　我们将两个端点注册到我们的API中，一个用于添加相邻节点，另一个用于解决冲突：

　　blockchain.py

　　

@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
在这一点上，如果你喜欢，你可以使用一台不同的机器，并在你的网络上启动不同的节点。 或者使用同一台机器上的不同端口启动进程。 我在我的机器上，不同的端口上创建了另一个节点，并将其注册到当前节点。 因此，我有两个节点：http://localhost:5000 和 http://localhost:5001。 注册一个新节点：

　　然后我在节点 2 上挖掘了一些新的块，以确保链条更长。 之后，我在节点1上调用 GET /nodes/resolve，其中链由一致性算法取代：

　　这是一个包，去找一些朋友一起，以帮助测试你的区块链。

　　我希望本文能激励你创造更多新东西。我之所以对数字货币入迷，是因为我相信区块链会很快改变我们看待事物的方式，包括经济、政府、档案管理等。

　　更新：我计划在接下来的第2部分中继续讨论区块链交易验证机制，并讨论一些可以让区块链进行生产的方法。

　　

相关推荐：编程视频课程

　　

以上就是使用Python 搭建自己的区块链的详细内容，更多请关注盛行IT软件开发工作室其它相关文章！

　　

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

标签： python

相关文章阅读

  • python命令函数 python函数教学
  • python简单函数编程 如何用python编写函数
  • python随机函数种子 python随机数种子怎么用
  • python画兔子代码，python语言绘制小兔子源代码怎么运行
  • range函数是从0开始吗,python中range(0)
  • python多线程坑,python多线程阻塞
  • python怎么画k线,python绘制k线及均线
  • python调用安卓so库,python .so文件
  • python赋值运算符-=的作用是,在Python中关系运算符中,表示“不等于”
  • python语言是一种脚本编程语言,python属于脚本语言还是编程语言
  • python想获取字符串str的长度,python str转char
  • python从键盘不断输入整数,python控制键盘输入数字
  • python输入姓名输出姓,python输入名字输出你好代码
  • python怎么实现黑客攻击,python网络攻防
  • python@property,python中的property函数
    • 留言与评论（共有 条评论）
       
    验证码：