随着当前加密货币的兴起，区块链在技术界引起了轰动。

这项技术之所以吸引了如此多的关注，主要是因为它具有保证安全，强制分权和加快多个行业(尤其是金融行业)流程的能力。

本质上，区块链是一个公共数据库，它不可逆地记录和认证数字资产的拥有和传输。像比特币和以太坊这样的数字货币就是基于这个概念。

区块链是一项令人兴奋的技术，可用于转换应用程序的功能。

最近，我们看到政府，组织和个人使用区块链技术来创建自己的加密货币。值得注意的是，当Facebook提出自己的加密货币Libra时，这一公告激起了全世界的许多热潮。

如果您也可以效仿并创建自己的加密货币版本，你应该如何着手?

我考虑了这一点，决定开发一种可以创建加密货币的算法。

我决定将加密货币称为fccCoin。

在本教程中，我将逐步说明构建数字货币的过程(我使用了Python编程语言的面向对象概念)。

这是用于创建fccCoin的区块链算法的基本蓝图：

class Block:  
    def __init__():  
    #first block class  
        pass      
    def calculate_hash():      
    #calculates the cryptographic hash of every block          
     
class BlockChain:      
    def __init__(self): 
     # constructor method 
    pass      
    def construct_genesis(self): 
        # constructs the initial block 
        pass  
    def construct_block(self, proof_no, prev_hash): 
        # constructs a new block and adds it to the chain 
        pass  
    @staticmethod 
    def check_validity(): 
        # checks whether the blockchain is valid 
        pass  
    def new_data(self, sender, recipient, quantity): 
        # adds a new transaction to the data of the transactions 
        pass  
    @staticmethod 
    def construct_proof_of_work(prev_proof): 
        # protects the blockchain from attack 
        pass     
    @property 
    def last_block(self): 
        # returns the last block in the chain 
        return self.chain[-1] 

现在，让我解释一下接下来应该怎么做……

1.建立第一个Block类

区块链由几个相互连接的块组成，因此，如果一个块被篡改，则链将变为无效。

在应用上述概念时，我创建了以下初始块类：

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
import hashlib 
import time 
 
class Block: 
 
    def __init__(self, index, proof_no, prev_hash, data, timestamp=None): 
        self.index = index 
        self.proof_no = proof_no 
        self.prev_hash = prev_hash 
        self.data = data 
        self.timestamp = timestamp or time.time() 
 
    @property 
    def calculate_hash(self): 
        block_of_string = "{}{}{}{}{}".format(self.index, self.proof_no, 
                                              self.prev_hash, self.data, 
                                              self.timestamp) 
 
        return hashlib.sha256(block_of_string.encode()).hexdigest() 
 
    def __repr__(self): 
        return "{} - {} - {} - {} - {}".format(self.index, self.proof_no, 
                                               self.prev_hash, self.data, 
                                               self.timestamp) 

从上面的代码中可以看到，我定义了__init __()函数，该函数将在启动Block类时执行，就像在其他任何Python类中一样。

我为启动函数提供了以下参数：

• self-引用Block类的实例，从而可以访问与该类关联的方法和属性;
• 索引—跟踪区块链在区块链中的位置;
• proof_no-这是在创建新块(称为挖矿)期间产生的数量;
• prev_hash —这是指链中上一个块的哈希值;
• 数据-提供所有已完成交易的记录，例如购买数量;
• 时间戳记-为事务放置时间戳记。

类中的第二个方法calculate_hash将使用上述值生成块的哈希。SHA-256模块被导入到项目中，以帮助获得块的哈希值。

将值输入到密码哈希算法后，该函数将返回一个256位字符串，表示该块的内容。

这就是在区块链中实现安全性的方式-每个块都将具有哈希，并且该哈希将依赖于前一个块的哈希。

因此，如果有人试图破坏链中的任何区块，其他区块将具有无效的哈希值，从而导致整个区块链网络的破坏。

最终，一个块将如下所示：

{ 
    "index": 2, 
    "proof": 21, 
    "prev_hash": "6e27587e8a27d6fe376d4fd9b4edc96c8890346579e5cbf558252b24a8257823", 
    "transactions": [ 
        {'sender': '0', 'recipient': 'Quincy Larson', 'quantity': 1} 
    ], 
    "timestamp": 1521646442.4096143 
} 

2.建立区块链类

顾名思义，区块链的主要思想涉及将多个区块相互“链接”。

因此，我将构建一个对管理整个链的工作很有用的Blockchain类。这是大多数动作将要发生的地方。

该Blockchain类将在blockchain完成各种任务的各种辅助方法。

让我解释一下每个方法在类中的作用。

A.构造方法

此方法确保实例化区块链。

class BlockChain: 
 
    def __init__(self): 
        self.chain = [] 
        self.current_data = [] 
        self.nodes = set() 
        self.construct_genesis() 

以下是其属性的作用：

• self.chain-此变量保留所有块;
• self.current_data-此变量将所有已完成的事务保留在该块中;
• self.construct_genesis() -此方法将负责构造初始块。

B.构建创世块

区块链需要一个construct_genesis方法来构建链中的初始块。在区块链惯例中，此块是特殊的，因为它象征着区块链的开始。

在这种情况下，让我们通过简单地将一些默认值传递给Construct_block方法来构造它。

尽管您可以提供所需的任何值，但我都给了proof_no和prev_hash一个零值。

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
def construct_genesis(self): 
    self.construct_block(proof_no=0, prev_hash=0) 
 
def construct_block(self, proof_no, prev_hash): 
    block = Block( 
        index=len(self.chain), 
        proof_no=proof_no, 
        prev_hash=prev_hash, 
        data=self.current_data) 
    self.current_data = [] 
 
    self.chain.append(block) 
    return block 

C.建造新的街区

该construct_block 方法用于在blockchain创造新的块。

这是此方法的各种属性所发生的情况：

• 索引-代表区块链的长度;
• proof_nor&prev_hash —调用者方法传递它们;
• 数据-包含节点上任何块中未包含的所有事务的记录;
• self.current_data-用于重置节点上的事务列表。如果已经构造了一个块并将事务分配给该块，则会重置该列表以确保将来的事务被添加到该列表中。并且，该过程将连续进行;
• self.chain.append()-此方法将新构建的块连接到链;
• return-最后，返回一个构造的块对象。

D.检查有效性

该check_validity方法是评估blockchain的完整性，确保异常是绝对重要。

如上所述，散列对于区块链的安全至关重要，因为即使对象发生任何细微变化也将导致生成全新的哈希。

因此，此check_validity 方法使用if语句检查每个块的哈希是否正确。

它还通过比较其哈希值来验证每个块是否指向正确的上一个块。如果一切正确，则返回true;否则，返回true。否则，它返回false。

@staticmethod 
def check_validity(block, prev_block): 
    if prev_block.index + 1 != block.index: 
        return False 
 
    elif prev_block.calculate_hash != block.prev_hash: 
        return False 
 
    elif not BlockChain.verifying_proof(block.proof_no, prev_block.proof_no): 
        return False 
 
    elif block.timestamp <= prev_block.timestamp: 
        return False 
 
    return True 

E.添加交易数据

该NEW_DATA方法用于添加事务的数据的块。这是一种非常简单的方法：它接受三个参数(发送者的详细信息，接收者的详细信息和数量)，并将交易数据附加到self.current_data列表中。

每当创建新块时，都会将该列表分配给该块，并再次按Construct_block方法中的说明进行重置。

将交易数据添加到列表后，将返回要创建的下一个块的索引。

该索引是通过将当前块的索引(即区块链中的最后一个)的索引加1来计算的。数据将帮助用户将来提交交易。

def new_data(self, sender, recipient, quantity): 
    self.current_data.append({ 
        'sender': sender, 
        'recipient': recipient, 
        'quantity': quantity 
    }) 
    return True 

F.添加工作证明

工作量证明是防止区块链滥用的概念。简而言之，其目的是在完成一定数量的计算工作后，确定一个可以解决问题的编号。

如果识别数字的难度很高，则不鼓励发送垃圾邮件和篡改区块链。

在这种情况下，我们将使用一种简单的算法来阻止人们挖掘区块或轻松创建区块。

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
@staticmethod 
def proof_of_work(last_proof): 
    '''this simple algorithm identifies a number f' such that hash(ff') contain 4 leading zeroes 
         f is the previous f' 
         f' is the new proof 
        ''' 
    proof_no = 0 
    while BlockChain.verifying_proof(proof_no, last_proof) is False: 
        proof_no += 1  
    return proof_no 
  
@staticmethod 
def verifying_proof(last_proof, proof): 
    #verifying the proof: does hash(last_proof, proof) contain 4 leading zeroes? 
 
    guess = f'{last_proof}{proof}'.encode() 
    guess_hash = hashlib.sha256(guess).hexdigest() 
    return guess_hash[:4] == "0000" 

G.得到最后一块

最后，latest_block方法是一种帮助程序方法，可帮助获取区块链中的最后一个块。请记住，最后一个块实际上是链中的当前块。

@property 
    def latest_block(self): 
        return self.chain[-1] 

总结

这是用于创建fccCoin加密货币的完整代码。

import hashlib 
import time  
 
class Block: 
 
    def __init__(self, index, proof_no, prev_hash, data, timestamp=None): 
        self.index = index 
        self.proof_no = proof_no 
        self.prev_hash = prev_hash 
        self.data = data 
        self.timestamp = timestamp or time.time() 
 
    @property 
    def calculate_hash(self): 
        block_of_string = "{}{}{}{}{}".format(self.index, self.proof_no, 
                                              self.prev_hash, self.data, 
                                              self.timestamp) 
 
        return hashlib.sha256(block_of_string.encode()).hexdigest() 
 
    def __repr__(self): 
        return "{} - {} - {} - {} - {}".format(self.index, self.proof_no, 
                                               self.prev_hash, self.data, 
                                               self.timestamp) 
  
class BlockChain: 
 
    def __init__(self): 
        self.chain = [] 
        self.current_data = [] 
        self.nodes = set() 
        self.construct_genesis() 
 
    def construct_genesis(self): 
        self.construct_block(proof_no=0, prev_hash=0) 
 
    def construct_block(self, proof_no, prev_hash): 
        block = Block( 
            index=len(self.chain), 
            proof_no=proof_no, 
            prev_hash=prev_hash, 
            data=self.current_data) 
        self.current_data = [] 
 
        self.chain.append(block) 
        return block 
 
    @staticmethod 
    def check_validity(block, prev_block): 
        if prev_block.index + 1 != block.index: 
            return False 
 
        elif prev_block.calculate_hash != block.prev_hash: 
            return False 
 
        elif not BlockChain.verifying_proof(block.proof_no, 
                                            prev_block.proof_no): 
            return False 
 
        elif block.timestamp <= prev_block.timestamp: 
            return False 
 
        return True 
 
    def new_data(self, sender, recipient, quantity): 
        self.current_data.append({ 
            'sender': sender, 
            'recipient': recipient, 
            'quantity': quantity 
        }) 
        return True 
 
    @staticmethod 
    def proof_of_work(last_proof): 
        '''this simple algorithm identifies a number f' such that hash(ff') contain 4 leading zeroes 
         f is the previous f' 
         f' is the new proof 
        ''' 
        proof_no = 0 
        while BlockChain.verifying_proof(proof_no, last_proof) is False: 
            proof_no += 1 
 
        return proof_no 
 
    @staticmethod 
    def verifying_proof(last_proof, proof): 
        #verifying the proof: does hash(last_proof, proof) contain 4 leading zeroes? 
 
        guess = f'{last_proof}{proof}'.encode() 
        guess_hash = hashlib.sha256(guess).hexdigest() 
        return guess_hash[:4] == "0000" 
 
    @property 
    def latest_block(self): 
        return self.chain[-1] 
 
    def block_mining(self, details_miner): 
 
        self.new_data( 
            sender="0",  #it implies that this node has created a new block 
            receiver=details_miner, 
            quantity= 
            1,  #creating a new block (or identifying the proof number) is awarded with 1 
        ) 
 
        last_block = self.latest_block 
 
        last_proof_no = last_block.proof_no 
        proof_no = self.proof_of_work(last_proof_no) 
 
        last_hash = last_block.calculate_hash 
        block = self.construct_block(proof_no, last_hash) 
 
        return vars(block) 
 
    def create_node(self, address): 
        self.nodes.add(address) 
        return True 
 
    @staticmethod 
    def obtain_block_object(block_data): 
        #obtains block object from the block data 
 
        return Block( 
            block_data['index'], 
            block_data['proof_no'], 
            block_data['prev_hash'], 
            block_data['data'], 
            timestamp=block_data['timestamp']) 

现在，让我们测试我们的代码，看看它是否有效。

blockchain = BlockChain() 
 
print("***Mining fccCoin about to start***") 
print(blockchain.chain) 
 
last_block = blockchain.latest_block 
last_proof_no = last_block.proof_no 
proof_no = blockchain.proof_of_work(last_proof_no) 
 
blockchain.new_data( 
    sender="0",  #it implies that this node has created a new block 
    recipient="Quincy Larson",  #let's send Quincy some coins! 
    quantity= 
    1,  #creating a new block (or identifying the proof number) is awarded with 1 
) 
 
last_hash = last_block.calculate_hash 
block = blockchain.construct_block(proof_no, last_hash) 
 
print("***Mining fccCoin has been successful***") 
print(blockchain.chain) 

有效!

这是挖掘过程的输出：

***Mining fccCoin about to start*** 
[0 - 0 - 0 - [] - 1566930640.2707076] 
***Mining fccCoin has been successful*** 
[0 - 0 - 0 - [] - 1566930640.2707076, 1 - 88914 - a8d45cb77cddeac750a9439d629f394da442672e56edfe05827b5e41f4ba0138 - [{'sender': '0', 'recipient': 'Quincy Larson', 'quantity': 1}] - 1566930640.5363243] 

结论

以上就是使用Python创建自己的区块链的方式。

如果按原样部署该代币，它将无法满足当前市场对稳定，安全且易于使用的加密货币的需求。

因此，仍可以通过添加其他功能来增强其挖掘和发送财务交易的功能，从而对其进行改进。