EEPW论坛

　　对数字货币的崛起感到新奇的我们，并且想知道其背后的技术——区块链是怎样实现的。

　　但是完全搞懂区块链并非易事，我喜欢在实践中学习，通过写代码来学习技术会掌握得更牢固。通过构建一个区块链可以加深对区块链的理解。下面内容对Python有基本的理解，能读写基本的Python，并且需要对HTTP请求有基本的了解。

　　我们知道区块链是由区块的记录构成的不可变、有序的链结构，记录可以是交易、文件或任何你想要的数据，重要的是它们是通过哈希值（hashes）链接起来的。

　　环境准备环境准备，确保已经安装Python3.5,pip,django,requests，urllib，json，hashlib安装方法：

　　pipinstalldjangorequests

　　同时还需要一个HTTP客户端，比如Postman，cURL或其它客户端，本文以Postman为例。

　　开始创建Blockchain通过django-adminstartprojectblock创建一个block的项目，在项目中创建一个demo项目django-adminstartprojectdemo，目录结构：

　　Blockchain类在views中创建一个Blockchain类，在构造函数中创建了两个列表，一个用于储存区块链，一个用于储存交易。

　　以下是Blockchain类的框架：

　　class

　　Blockchain

　　(

　　object

　　):

　　def

　　__init__(

　　self

　　):

　　self

　　.chain=[]

　　self

　　.current_transactions=[]

　　def

　　new_block(

　　self

　　):

　　#CreatesanewBlockandaddsittothechain

　　pass

　　def

　　new_transaction(

　　self

　　):

　　#Addsanewtransactiontothelistoftransactions

　　pass

　　@staticmethod

　　def

　　hash(block):

　　#HashesaBlock

　　pass

　　@property

　　def

　　last_block(

　　self

　　):

　　#ReturnsthelastBlockinthechain

　　pass

　　Blockchain类用来管理链条，它能存储交易，加入新块等，下面我们来进一步完善这些方法。

　　块结构每个区块包含属性：索引（index），Unix时间戳（timestamp），交易列表（transactions），工作量证明（稍后解释）以及前一个区块的Hash值。

　　以下是一个区块的结构：

　　block={

　　'index'

　　:

　　1

　　,

　　'timestamp'

　　:

　　1506057125.900785

　　,

　　'transactions'

　　:[

　　{

　　'sender'

　　:

　　"8527147fe1f5426f9dd545de4b27ee00"

　　,

　　'recipient'

　　:

　　"a77f5cdfa2934df3954a5c7c7da5df1f"

　　,

　　'amount'

　　:

　　5

　　,

　　}

　　],

　　'proof'

　　:

　　324984774000

　　,

　　'previous_hash'

　　:

　　"2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"

　　}

　　到这里，区块链的概念就清楚了，每个新的区块都包含上一个区块的Hash，这是关键的一点，它保障了区块链不可变性。如果攻击者破坏了前面的某个区块，那么后面所有区块的Hash都会变得不正确。不理解的话，慢慢消化。

　　加入交易接下来我们需要添加一个交易，来完善下new_transaction方法

　　class

　　Blockchain

　　(

　　object

　　):

　　...

　　def

　　new_transaction(

　　self

　　,sender,recipient,amount):

　　"""

　　生成新交易信息，信息将加入到下一个待挖的区块中

　　:paramsender:<str>AddressoftheSender

　　:paramrecipient:<str>AddressoftheRecipient

　　:paramamount:<int>Amount

　　:return:<int>TheindexoftheBlockthatwillholdthistransaction

　　"""

　　self

　　.current_transactions.append({

　　'sender'

　　:sender,

　　'recipient'

　　:recipient,

　　'amount'

　　:amount,

　　})

　　return

　　self

　　.last_block[

　　'index'

　　]+

　　1

　　方法向列表中添加一个交易记录，并返回该记录将被添加到的区块(下一个待挖掘的区块)的索引，等下在用户提交交易时会有用。

　　创建新块

　　当Blockchain实例化后，我们需要构造一个创世块（没有前区块的第一个区块），并且给它加上一个工作量证明。每个区块都需要经过工作量证明，俗称挖矿，稍后会继续讲解。

　　为了构造创世块，我们还需要完善newblock(),newtransaction()和hash()方法：

　　class

　　Blockchain

　　(

　　object

　　):

　　def

　　__init__(

　　self

　　):

　　self

　　.chain=[]

　　self

　　.current_transactions=[]

　　self

　　.new_block(previous_hash=

　　1

　　,proof=

　　100

　　)

　　self

　　.nodes=

　　set

　　()

　　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()

　　通过上面的代码和注释可以对区块链有直观的了解，接下来我们看看区块是怎么挖出来的。

　　理解工作量证明新的区块依赖工作量证明算法（PoW）来构造。PoW的目标是找出一个符合特定条件的数字，这个数字很难计算出来，但容易验证。这就是工作量证明的核心思想。

　　为了方便理解，举个例子：

　　假设一个整数x乘以另一个整数y的积的Hash值必须以0结尾，即hash(x*y)=ac23dc…0。设变量x=5，求y的值？

　　用Python实现如下：

　　from

　　hashlib

　　import

　　sha256

　　x=

　　5

　　y=

　　0

　　while

　　sha256(str(x*y).encode()).hexdigest()[:

　　4

　　]!=

　　"0000"

　　:

　　y+=

　　1

　　print

　　(y,sha256(str(x*y).encode()).hexdigest()[:

　　4

　　])

　　print

　　(y)

　　在比特币中，使用称为Hashcash的工作量证明算法，它和上面的问题很类似。矿工们为了争夺创建区块的权利而争相计算结果。通常，计算难度与目标字符串需要满足的特定字符的数量成正比，矿工算出结果后，会获得比特币奖励。当然，在网络上非常容易验证这个结果。

　　实现工作量证明让我们来实现一个相似PoW算法，规则是：寻找一个数p，使得它与前一个区块的proof拼接成的字符串的Hash值以4个零开头。

　　import

　　hashlib

　　import

　　json

　　from

　　time

　　import

　　time

　　from

　　uuid

　　import

　　uuid4

　　class

　　Blockchain

　　(

　　object

　　):

　　...

　　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=str(last_proof*proof).encode()

　　guess_hash=hashlib.sha256(guess).hexdigest()

　　return

　　guess_hash[:

　　5

　　]==

　　"00000"

　　衡量算法复杂度的办法是修改零开头的个数。使用4个来用于演示，你会发现多一个零都会大大增加计算出结果所需的时间。

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

　　Blockchain作为API接口我们将使用Pythondjango框架，这是一个轻量Web应用框架，它方便将网络请求映射到Python函数，现在我们来让来试一下：

　　我们将创建三个接口：

　　/transactions/new创建一个交易并添加到区块

　　/mine告诉服务器去挖掘新的区块

　　/chain返回整个区块链

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

　　node_identifier=str(uuid4()).replace(

　　'-'

　　,

　　''

　　)

　　#InstantiatetheBlockchain

　　blockchain=

　　Blockchain

　　()

　　def

　　mine(request):

　　last_block=blockchain.last_block

　　last_proof=last_block[

　　'proof'

　　]

　　proof=blockchain.proof_of_work(last_proof)

　　print

　　(proof)

　　blockchain.new_transaction(

　　sender=

　　"0"

　　,

　　recipient=node_identifier,

　　amount=

　　1

　　,

　　)

　　#ForgethenewBlockbyaddingittothechain

　　block=blockchain.new_block(proof)

　　response={

　　'message'

　　:

　　"NewBlockForged"

　　,

　　'index'

　　:block[

　　'index'

　　],

　　'transactions'

　　:block[

　　'transactions'

　　],

　　'proof'

　　:block[

　　'proof'

　　],

　　'previous_hash'

　　:block[

　　'previous_hash'

　　],

　　}

　　print

　　(response)

　　return

　　HttpResponse

　　(json.dumps(response))

　　def

　　new_transaction(request):

　　values=json.loads(request.body.decode(

　　'utf-8'

　　))

　　required=[

　　'sender'

　　,

　　'recipient'

　　,

　　'amount'

　　]

　　if

　　not

　　all(k

　　in

　　values

　　for

　　k

　　in

　　required):

　　return

　　'Missingvalues'

　　index=blockchain.new_transaction(values[

　　'sender'

　　],values[

　　'recipient'

　　],values[

　　'amount'

　　])

　　print

　　(index)

　　response={

　　'message'

　　:

　　'TransactionwillbeaddedtoBlock%s'

　　%index}

　　return

　　HttpResponse

　　(json.dumps(response))

　　def

　　full_chain(request):

　　response={

　　'chain'

　　:blockchain.chain,

　　'length'

　　:len(blockchain.chain),

　　}

　　return

　　HttpResponse

　　(json.dumps(response))

　　添加url路由节点：运行服务

　　from

　　demo

　　import

　　views

　　urlpatterns=[

　　url(r

　　'^admin/'

　　,admin.site.urls),

　　url(r

　　'^mine'

　　,views.mine),

　　url(r

　　'^transactions/new/'

　　,views.new_transaction),

　　url(r

　　'^chain/'

　　,views.full_chain),

　　url(r

　　'^register'

　　,views.register_nodes),

　　url(r

　　'^resolve'

　　,views.consensus),

　　]

　　运行服务

　　pythonmanage.pyrunserver

　　127.0

　　.

　　0.1

　　:

　　8000

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

　　{

　　"sender"

　　:

　　"myaddress"

　　,

　　"recipient"

　　:

　　"someoneelse'saddress"

　　,

　　"amount"

　　:

　　5

　　}

　　向服务添加一个交易

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

　　1、计算工作量证明PoW

　　2、通过新增一个交易授予矿工（自己）一个币

　　3、构造新区块并将其添加到链中

　　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=str(last_proof*proof).encode()

　　guess_hash=hashlib.sha256(guess).hexdigest()

　　return

　　guess_hash[:

　　5

　　]==

　　"00000"

　　注意交易的接收者是我们自己的服务器节点，我们做的大部分工作都只是围绕Blockchain类方法进行交互。到此，我们的区块链就算完成了，我们来实际运行下

　　运行区块链使用Postman去和API进行交互

　　让我们通过请求http://127.0.0.1:8000/mine来进行挖矿

　　在挖了两次矿之后，就有3个块了，通过请求http://localhost:8000/chain可以得到所有的块信息。

　　{

　　"chain"

　　:[

　　{

　　"transactions"

　　:[],

　　"proof"

　　:

　　100

　　,

　　"timestamp"

　　:

　　1520314374.7261052

　　,

　　"index"

　　:

　　1

　　,

　　"previous_hash"

　　:

　　1

　　},

　　{

　　"transactions"

　　:[

　　{

　　"sender"

　　:

　　"0"

　　,

　　"recipient"

　　:

　　"27d4aae55b2848dcae52bc722d86e0c3"

　　,

　　"amount"

　　:

　　1

　　}

　　],

　　"proof"

　　:

　　1771087

　　,

　　"timestamp"

　　:

　　1520314389.5019505

　　,

　　"index"

　　:

　　2

　　,

　　"previous_hash"

　　:

　　"32fa73f48240160257e95fdf8422c6df734b5d7e8ceb69a41a5578643c1d36fb"

　　},

　　{

　　"transactions"

　　:[

　　{

　　"sender"

　　:

　　"d4ee26eee15148ee92c6cd394edd9705"

　　,

　　"recipient"

　　:

　　"5"

　　,

　　"amount"

　　:

　　500

　　},

　　{

　　"sender"

　　:

　　"0"

　　,

　　"recipient"

　　:

　　"27d4aae55b2848dcae52bc722d86e0c3"

　　,

　　"amount"

　　:

　　1

　　}

　　],

　　"proof"

　　:

　　100

　　,

　　"timestamp"

　　:

　　1520314592.4745598

　　,

　　"index"

　　:

　　3

　　,

　　"previous_hash"

　　:

　　"e6b1be488e0ed20fe3ec51135e5fafb4dfffaa28a190967106a5dd3e89e4b3aa"

　　}

　　],

　　"length"

　　:

　　3

　　}

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

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

　　1、/register接收URL形式的新节点列表

　　2、/resolve执行一致性算法，解决任何冲突，确保节点拥有正确的链我们修改下Blockchain的init函数并提供一个注册节点方法：

　　from

　　urllib.parse

　　import

　　urlparse

　　...

　　class

　　Blockchain

　　(

　　object

　　):

　　def

　　__init__(

　　self

　　):

　　...

　　self

　　.nodes=

　　set

　　()

　　...

　　def

　　register_node(

　　self

　　,address):

　　parsed_url=urlparse(address)

　　self

　　.nodes.add(parsed_url.netloc)

　　我们用set来储存节点，这是一种避免重复添加节点的简单方法。

　　实现共识算法前面提到，冲突是指不同的节点拥有不同的链，为了解决这个问题，规定最长的、有效的链才是最终的链，换句话说，网络中有效最长链才是实际的链。

　　我们使用一下的算法，来达到网络中的共识

　　class

　　Blockchain

　　(

　　object

　　):

　　def

　　__init__(

　　self

　　):

　　...

　　def

　　valid_chain(

　　self

　　,chain):

　　last_block=chain[

　　0

　　]

　　current_index=

　　1

　　while

　　current_index<len(chain):

　　block=chain[current_index]

　　if

　　block[

　　'previous_hash'

　　]!=

　　self

　　.hash(last_block):

　　return

　　False

　　#CheckthattheProofofWorkiscorrect

　　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

　　(

　　'http://%s/chain'

　　%node)

　　if

　　response.status_code==

　　200

　　:

　　length=json.loads(response)[

　　'length'

　　]

　　chain=json.loads(response)[

　　'chain'

　　]

　　#Checkifthelengthislongerandthechainisvalid

　　if

　　length>max_length

　　and

　　self

　　.valid_chain(chain):

　　max_length=length

　　new_chain=chain

　　#Replaceourchainifwediscoveredanew,validchainlongerthanours

　　if

　　new_chain:

　　self

　　.chain=new_chain

　　return

　　True

　　return

　　False

　　第一个方法valid_chain()用来检查是否是有效链，遍历每个块验证hash和proof.

　　第2个方法resolve_conflicts()用来解决冲突，遍历所有的邻居节点，并用上一个方法检查链的有效性，如果发现有效更长链，就替换掉自己的链

　　在url中添加两个路由，一个用来注册节点，一个用来解决冲突。

　　from

　　demo

　　import

　　views

　　urlpatterns=[

　　url(r

　　'^register'

　　,views.register_nodes),

　　url(r

　　'^resolve'

　　,views.consensus),

　　]

　　你可以在不同的机器运行节点，或在一台机机开启不同的网络端口来模拟多节点的网络，这里在同一台机器开启不同的端口演示，在不同的终端运行一下命令，就启动了两个节点：http://127.0.0.1:8000和http://127.0.0.1:8100

　　然后在节点8100节点上挖两个块，确保是更长的链，然后在节点8000节点上访问接口/resolve,这时节点8100的链会通过共识算法被节点8000节点的链取代。

　　最后想要了解更多关于Python发展前景趋势，请关注扣丁学堂python培训官网、微信等平台，扣丁学堂IT职业在线学习教育平台为您提供最新的Python视频教程系统，通过千锋扣丁学堂金牌讲师在线录制的Python视频教程课程，让你快速掌握Python从入门到精通开发实战技能。扣丁学堂Python技术交流群：816572891