色丁香婷婷五月在线视频,日本一视频一区视频二区,无人区乱码1区2区3区不用下载

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類

區塊鏈由幾個相互連接的塊組成，因此，如果一個塊被篡改，則鏈將變為無效。

在應用上述概念時，我創建了以下初始塊類：

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一個零值。

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.添加工作證明

工作量證明是防止區塊鏈濫用的概念。簡而言之，其目的是在完成一定數量的計算工作后，確定一個可以解決問題的編號。

如果識別數字的難度很高，則不鼓勵發送垃圾郵件和篡改區塊鏈。

在這種情況下，我們將使用一種簡單的算法來阻止人們挖掘區塊或輕松創建區塊。

@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]