儘管一些人認為區塊鏈是一個等待問題的解決方案，但毫無疑問，這種新技術是計算機的奇蹟。但是，區塊鏈到底是什麼呢?

區塊鏈

在更一般的術語中，它是一個公共資料庫，新資料儲存在一個名為塊的容器中，並被新增到一個不可變鏈（後來的區塊鏈）中添加了過去的資料。在比特幣和其他加密貨幣的情況下，這些資料是一組交易記錄。當然，資料可以是任何型別的。

區塊鏈技術已經催生了新的、完全數字化的貨幣，如比特幣和萊特幣，這些貨幣並不是由中央政府發行或管理的。因此為那些認為今天的銀行系統是騙局或終將失敗的人帶來了新的自由。區塊鏈所包含的以太坊技術對分散式計算進行了變革創新，它引入了一些有趣的概念，比如智慧合約

。

在本文中，我將用不到50行的Python2程式碼來做一個簡單的區塊鏈。我稱它為SnakeCoin。

首先將定義塊將是什麼樣子。在區塊鏈中，每個塊都儲存一個時間戳和一個索引。在SnakeCoin中，需要把兩者都儲存起來。為了確保整個區塊鏈的完整性，每個塊都有一個自動識別雜湊。與比特幣一樣，每個塊的雜湊將是塊索引、時間戳、資料和前塊雜湊的加密雜湊。資料可以是你想要的任何東西。

import hashlib as hasher

class Block:
  def __init__(self, index, timestamp, data, previous_hash):
    self.index = index
    self.timestamp = timestamp
    self.data = data
    self.previous_hash = previous_hash
    self.hash = self.hash_block()

  def
 
 hash_block(self):
    sha = hasher.sha256()
    sha.update(str(self.index) + 
               str(self.timestamp) + 
               str(self.data) + 
               str(self.previous_hash))
    return sha.hexdigest()

這一步後有塊結構，但現在是建立區塊鏈，所以需要向實際的鏈中新增塊。如前所述，每個塊都需要上一個塊的資訊。但是按照這個說法就有一個問題，區塊鏈的第一個區塊是如何到達那裡的呢？不得不說，第一個塊，或者說是起源塊，它是一個特殊的塊。在很多情況下，它是手動新增的，或者有獨特的邏輯允許新增。

下面將建立一個函式簡單地返回一個起源塊以便產生第一個區塊。這個塊是索引0，它具有任意的資料值和“前一個雜湊”引數中的任意值。

import datetime as date

def create_genesis_block():
  # Manually construct a block with
  # index zero and arbitrary previous hash
  return Block(0, date.datetime.now(), "Genesis Block", "0")

現在已經建立好了起源塊，接下來需要一個函式，以便在區塊鏈中生成後續的塊。這個函式將把鏈中的前一個塊作為引數，建立要生成的塊的資料，並使用適當的資料返回新塊。當新的塊雜湊資訊來自前面的塊時，區塊鏈的完整性會隨著每個新塊而增加。如果不這樣做，外部組織就更容易“改變過去”，用全新的方式取代已有的鏈條。這一系列的雜湊可以作為加密的證據，有助於確保一旦將塊新增到區塊鏈，它就不能被替換或刪除。

def next_block(last_block):
  this_index = last_block.index + 1
  this_timestamp = date.datetime.now()
  this_data = "Hey! I'm block " + str(this_index)
  this_hash = last_block.hash
  return Block(this_index, this_timestamp, this_data, this_hash)

大部分的工作已經完成，現在可以建立區塊鏈了。在這次的示例中，區塊鏈本身是一個簡單的Python列表。列表的第一個元素是起源塊。當然，還需要新增後續的塊，因為SnakeCoin是最小的區塊鏈，這裡只新增20個新的塊。可以用for迴圈來生成新塊。

# Create the blockchain and add the genesis block
blockchain = [create_genesis_block()]
previous_block = blockchain[0]

# How many blocks should we add to the chain
# after the genesis block
num_of_blocks_to_add = 20

# Add blocks to the chain
for i in range(0, num_of_blocks_to_add):
  block_to_add = next_block(previous_block)
  blockchain.append(block_to_add)
  previous_block = block_to_add
  # Tell everyone about it!
  print "Block #{} has been added to the blockchain!".format(block_to_add.index)
  print "Hash: {}\n".format(block_to_add.hash) 

下面來測試一下目前產生的區塊鏈。

看到了吧，這就是區塊鏈。如果希望在控制檯中檢視更多資訊，可以編輯完整的原始檔並列印每個塊的時間戳或資料。

這就是SnakeCoin要提供的所有東西。為了使SnakeCoin規模達到今天生產區塊鏈的規模，必須新增更多的功能，比如伺服器層，以跟蹤多臺機器上的鏈變化，以及在給定的時間段內限制新增的塊數量的工作演算法。

http://geek.csdn.net/news/detail/228355

原地址：

儘管一些人認為區塊鏈是一個等待問題的解決方案，但毫無疑問，這種新技術是計算機的奇蹟。但是，區塊鏈到底是什麼呢?

區塊鏈

在更一般的術語中，它是一個公共資料庫，新資料儲存在一個名為塊的容器中，並被新增到一個不可變鏈（後來的區塊鏈）中添加了過去的資料。在比特幣和其他加密貨幣的情況下，這些資料是一組交易記錄。當然，資料可以是任何型別的。

區塊鏈技術已經催生了新的、完全數字化的貨幣，如比特幣和萊特幣，這些貨幣並不是由中央政府發行或管理的。因此為那些認為今天的銀行系統是騙局或終將失敗的人帶來了新的自由。區塊鏈所包含的以太坊技術對分散式計算進行了變革創新，它引入了一些有趣的概念，比如智慧合約。

在本文中，我將用不到50行的Python2程式碼來做一個簡單的區塊鏈。我稱它為SnakeCoin。

首先將定義塊將是什麼樣子。在區塊鏈中，每個塊都儲存一個時間戳和一個索引。在SnakeCoin中，需要把兩者都儲存起來。為了確保整個區塊鏈的完整性，每個塊都有一個自動識別雜湊。與比特幣一樣，每個塊的雜湊將是塊索引、時間戳、資料和前塊雜湊的加密雜湊。資料可以是你想要的任何東西。

import hashlib as hasher

class Block:
  def __init__(self, index, timestamp, data, previous_hash):
    self.index = index
    self.timestamp = timestamp
    self.data = data
    self.previous_hash = previous_hash
    self.hash = self.hash_block()

  def hash_block(self):
    sha = hasher.sha256()
    sha.update(str(self.index) + 
               str(self.timestamp) + 
               str(self.data) + 
               str(self.previous_hash))
    return sha.hexdigest()

這一步後有塊結構，但現在是建立區塊鏈，所以需要向實際的鏈中新增塊。如前所述，每個塊都需要上一個塊的資訊。但是按照這個說法就有一個問題，區塊鏈的第一個區塊是如何到達那裡的呢？不得不說，第一個塊，或者說是起源塊，它是一個特殊的塊。在很多情況下，它是手動新增的，或者有獨特的邏輯允許新增。

下面將建立一個函式簡單地返回一個起源塊以便產生第一個區塊。這個塊是索引0，它具有任意的資料值和“前一個雜湊”引數中的任意值。

import datetime as date

def create_genesis_block():
  # Manually construct a block with
  # index zero and arbitrary previous hash
  return Block(0, date.datetime.now(), "Genesis Block", "0")

現在已經建立好了起源塊，接下來需要一個函式，以便在區塊鏈中生成後續的塊。這個函式將把鏈中的前一個塊作為引數，建立要生成的塊的資料，並使用適當的資料返回新塊。當新的塊雜湊資訊來自前面的塊時，區塊鏈的完整性會隨著每個新塊而增加。如果不這樣做，外部組織就更容易“改變過去”，用全新的方式取代已有的鏈條。這一系列的雜湊可以作為加密的證據，有助於確保一旦將塊新增到區塊鏈，它就不能被替換或刪除。

def next_block(last_block):
  this_index = last_block.index + 1
  this_timestamp = date.datetime.now()
  this_data = "Hey! I'm block " + str(this_index)
  this_hash = last_block.hash
  return Block(this_index, this_timestamp, this_data, this_hash)

大部分的工作已經完成，現在可以建立區塊鏈了。在這次的示例中，區塊鏈本身是一個簡單的Python列表。列表的第一個元素是起源塊。當然，還需要新增後續的塊，因為SnakeCoin是最小的區塊鏈，這裡只新增20個新的塊。可以用for迴圈來生成新塊。

# Create the blockchain and add the genesis block
blockchain = [create_genesis_block()]
previous_block = blockchain[0]

# How many blocks should we add to the chain
# after the genesis block
num_of_blocks_to_add = 20

# Add blocks to the chain
for i in range(0, num_of_blocks_to_add):
  block_to_add = next_block(previous_block)
  blockchain.append(block_to_add)
  previous_block = block_to_add
  # Tell everyone about it!
  print "Block #{} has been added to the blockchain!".format(block_to_add.index)
  print "Hash: {}\n".format(block_to_add.hash) 

下面來測試一下目前產生的區塊鏈。

看到了吧，這就是區塊鏈。如果希望在控制檯中檢視更多資訊，可以編輯完整的原始檔並列印每個塊的時間戳或資料。

這就是SnakeCoin要提供的所有東西。為了使SnakeCoin規模達到今天生產區塊鏈的規模，必須新增更多的功能，比如伺服器層，以跟蹤多臺機器上的鏈變化，以及在給定的時間段內限制新增的塊數量的工作演算法。

http://geek.csdn.net/news/detail/228355

儘管一些人認為區塊鏈是一個等待問題的解決方案，但毫無疑問，這種新技術是計算機的奇蹟。但是，區塊鏈到底是什麼呢?

區塊鏈

在更一般的術語中，它是一個公共資料庫，新資料儲存在一個名為塊的容器中，並被新增到一個不可變鏈（後來的區塊鏈）中添加了過去的資料。在比特幣和其他加密貨幣的情況下，這些資料是一組交易記錄。當然，資料可以是任何型別的。

區塊鏈技術已經催生了新的、完全數字化的貨幣，如比特幣和萊特幣，這些貨幣並不是由中央政府發行或管理的。因此為那些認為今天的銀行系統是騙局或終將失敗的人帶來了新的自由。區塊鏈所包含的以太坊技術對分散式計算進行了變革創新，它引入了一些有趣的概念，比如智慧合約。

在本文中，我將用不到50行的Python2程式碼來做一個簡單的區塊鏈。我稱它為SnakeCoin。

首先將定義塊將是什麼樣子。在區塊鏈中，每個塊都儲存一個時間戳和一個索引。在SnakeCoin中，需要把兩者都儲存起來。為了確保整個區塊鏈的完整性，每個塊都有一個自動識別雜湊。與比特幣一樣，每個塊的雜湊將是塊索引、時間戳、資料和前塊雜湊的加密雜湊。資料可以是你想要的任何東西。

import hashlib as hasher

class Block:
  def __init__(self, index, timestamp, data, previous_hash):
    self.index = index
    self.timestamp = timestamp
    self.data = data
    self.previous_hash = previous_hash
    self.hash = self.hash_block()

  def hash_block(self):
    sha = hasher.sha256()
    sha.update(str(self.index) + 
               str(self.timestamp) + 
               str(self.data) + 
               str(self.previous_hash))
    return sha.hexdigest()

這一步後有塊結構，但現在是建立區塊鏈，所以需要向實際的鏈中新增塊。如前所述，每個塊都需要上一個塊的資訊。但是按照這個說法就有一個問題，區塊鏈的第一個區塊是如何到達那裡的呢？不得不說，第一個塊，或者說是起源塊，它是一個特殊的塊。在很多情況下，它是手動新增的，或者有獨特的邏輯允許新增。

下面將建立一個函式簡單地返回一個起源塊以便產生第一個區塊。這個塊是索引0，它具有任意的資料值和“前一個雜湊”引數中的任意值。

import datetime as date

def create_genesis_block():
  # Manually construct a block with
  # index zero and arbitrary previous hash
  return Block(0, date.datetime.now(), "Genesis Block", "0")

現在已經建立好了起源塊，接下來需要一個函式，以便在區塊鏈中生成後續的塊。這個函式將把鏈中的前一個塊作為引數，建立要生成的塊的資料，並使用適當的資料返回新塊。當新的塊雜湊資訊來自前面的塊時，區塊鏈的完整性會隨著每個新塊而增加。如果不這樣做，外部組織就更容易“改變過去”，用全新的方式取代已有的鏈條。這一系列的雜湊可以作為加密的證據，有助於確保一旦將塊新增到區塊鏈，它就不能被替換或刪除。

def next_block(last_block):
  this_index = last_block.index + 1
  this_timestamp = date.datetime.now()
  this_data = "Hey! I'm block " + str(this_index)
  this_hash = last_block.hash
  return Block(this_index, this_timestamp, this_data, this_hash)

大部分的工作已經完成，現在可以建立區塊鏈了。在這次的示例中，區塊鏈本身是一個簡單的Python列表。列表的第一個元素是起源塊。當然，還需要新增後續的塊，因為SnakeCoin是最小的區塊鏈，這裡只新增20個新的塊。可以用for迴圈來生成新塊。

# Create the blockchain and add the genesis block
blockchain = [create_genesis_block()]
previous_block = blockchain[0]

# How many blocks should we add to the chain
# after the genesis block
num_of_blocks_to_add = 20

# Add blocks to the chain
for i in range(0, num_of_blocks_to_add):
  block_to_add = next_block(previous_block)
  blockchain.append(block_to_add)
  previous_block = block_to_add
  # Tell everyone about it!
  print "Block #{} has been added to the blockchain!".format(block_to_add.index)
  print "Hash: {}\n".format(block_to_add.hash) 

下面來測試一下目前產生的區塊鏈。

看到了吧，這就是區塊鏈。如果希望在控制檯中檢視更多資訊，可以編輯完整的原始檔並列印每個塊的時間戳或資料。

這就是SnakeCoin要提供的所有東西。為了使SnakeCoin規模達到今天生產區塊鏈的規模，必須新增更多的功能，比如伺服器層，以跟蹤多臺機器上的鏈變化，以及在給定的時間段內限制新增的塊數量的工作演算法。

http://geek.csdn.net/news/detail/228355

儘管一些人認為區塊鏈是一個等待問題的解決方案，但毫無疑問，這種新技術是計算機的奇蹟。但是，區塊鏈到底是什麼呢?

區塊鏈

在更一般的術語中，它是一個公共資料庫，新資料儲存在一個名為塊的容器中，並被新增到一個不可變鏈（後來的區塊鏈）中添加了過去的資料。在比特幣和其他加密貨幣的情況下，這些資料是一組交易記錄。當然，資料可以是任何型別的。

區塊鏈技術已經催生了新的、完全數字化的貨幣，如比特幣和萊特幣，這些貨幣並不是由中央政府發行或管理的。因此為那些認為今天的銀行系統是騙局或終將失敗的人帶來了新的自由。區塊鏈所包含的以太坊技術對分散式計算進行了變革創新，它引入了一些有趣的概念，比如智慧合約。

在本文中，我將用不到50行的Python2程式碼來做一個簡單的區塊鏈。我稱它為SnakeCoin。

首先將定義塊將是什麼樣子。在區塊鏈中，每個塊都儲存一個時間戳和一個索引。在SnakeCoin中，需要把兩者都儲存起來。為了確保整個區塊鏈的完整性，每個塊都有一個自動識別雜湊。與比特幣一樣，每個塊的雜湊將是塊索引、時間戳、資料和前塊雜湊的加密雜湊。資料可以是你想要的任何東西。

import hashlib as hasher

class Block:
  def __init__(self, index, timestamp, data, previous_hash):
    self.index = index
    self.timestamp = timestamp
    self.data = data
    self.previous_hash = previous_hash
    self.hash = self.hash_block()

  def hash_block(self):
    sha = hasher.sha256()
    sha.update(str(self.index) + 
               str(self.timestamp) + 
               str(self.data) + 
               str(self.previous_hash))
    return sha.hexdigest()

這一步後有塊結構，但現在是建立區塊鏈，所以需要向實際的鏈中新增塊。如前所述，每個塊都需要上一個塊的資訊。但是按照這個說法就有一個問題，區塊鏈的第一個區塊是如何到達那裡的呢？不得不說，第一個塊，或者說是起源塊，它是一個特殊的塊。在很多情況下，它是手動新增的，或者有獨特的邏輯允許新增。

下面將建立一個函式簡單地返回一個起源塊以便產生第一個區塊。這個塊是索引0，它具有任意的資料值和“前一個雜湊”引數中的任意值。

import datetime as date

def create_genesis_block():
  # Manually construct a block with
  # index zero and arbitrary previous hash
  return Block(0, date.datetime.now(), "Genesis Block", "0")

現在已經建立好了起源塊，接下來需要一個函式，以便在區塊鏈中生成後續的塊。這個函式將把鏈中的前一個塊作為引數，建立要生成的塊的資料，並使用適當的資料返回新塊。當新的塊雜湊資訊來自前面的塊時，區塊鏈的完整性會隨著每個新塊而增加。如果不這樣做，外部組織就更容易“改變過去”，用全新的方式取代已有的鏈條。這一系列的雜湊可以作為加密的證據，有助於確保一旦將塊新增到區塊鏈，它就不能被替換或刪除。

def next_block(last_block):
  this_index = last_block.index + 1
  this_timestamp = date.datetime.now()
  this_data = "Hey! I'm block " + str(this_index)
  this_hash = last_block.hash
  return Block(this_index, this_timestamp, this_data, this_hash)

大部分的工作已經完成，現在可以建立區塊鏈了。在這次的示例中，區塊鏈本身是一個簡單的Python列表。列表的第一個元素是起源塊。當然，還需要新增後續的塊，因為SnakeCoin是最小的區塊鏈，這裡只新增20個新的塊。可以用for迴圈來生成新塊。

# Create the blockchain and add the genesis block
blockchain = [create_genesis_block()]
previous_block = blockchain[0]

# How many blocks should we add to the chain
# after the genesis block
num_of_blocks_to_add = 20

# Add blocks to the chain
for i in range(0, num_of_blocks_to_add):
  block_to_add = next_block(previous_block)
  blockchain.append(block_to_add)
  previous_block = block_to_add
  # Tell everyone about it!
  print "Block #{} has been added to the blockchain!".format(block_to_add.index)
  print "Hash: {}\n".format(block_to_add.hash) 

下面來測試一下目前產生的區塊鏈。

看到了吧，這就是區塊鏈。如果希望在控制檯中檢視更多資訊，可以編輯完整的原始檔並列印每個塊的時間戳或資料。

這就是SnakeCoin要提供的所有東西。為了使SnakeCoin規模達到今天生產區塊鏈的規模，必須新增更多的功能，比如伺服器層，以跟蹤多臺機器上的鏈變化，以及在給定的時間段內限制新增的塊數量的工作演算法。

http://geek.csdn.net/news/detail/228355

儘管一些人認為區塊鏈是一個等待問題的解決方案，但毫無疑問，這種新技術是計算機的奇蹟。但是，區塊鏈到底是什麼呢?

區塊鏈

在更一般的術語中，它是一個公共資料庫，新資料儲存在一個名為塊的容器中，並被新增到一個不可變鏈（後來的區塊鏈）中添加了過去的資料。在比特幣和其他加密貨幣的情況下，這些資料是一組交易記錄。當然，資料可以是任何型別的。

區塊鏈技術已經催生了新的、完全數字化的貨幣，如比特幣和萊特幣，這些貨幣並不是由中央政府發行或管理的。因此為那些認為今天的銀行系統是騙局或終將失敗的人帶來了新的自由。區塊鏈所包含的以太坊技術對分散式計算進行了變革創新，它引入了一些有趣的概念，比如智慧合約。

在本文中，我將用不到50行的Python2程式碼來做一個簡單的區塊鏈。我稱它為SnakeCoin。

首先將定義塊將是什麼樣子。在區塊鏈中，每個塊都儲存一個時間戳和一個索引。在SnakeCoin中，需要把兩者都儲存起來。為了確保整個區塊鏈的完整性，每個塊都有一個自動識別雜湊。與比特幣一樣，每個塊的雜湊將是塊索引、時間戳、資料和前塊雜湊的加密雜湊。資料可以是你想要的任何東西。

import hashlib as hasher

class Block:
  def __init__(self, index, timestamp, data, previous_hash):
    self.index = index
    self.timestamp = timestamp
    self.data = data
    self.previous_hash = previous_hash
    self.hash = self.hash_block()

  def hash_block(self):
    sha = hasher.sha256()
    sha.update(str(self.index) + 
               str(self.timestamp) + 
               str(self.data) + 
               str(self.previous_hash))
    return sha.hexdigest()

這一步後有塊結構，但現在是建立區塊鏈，所以需要向實際的鏈中新增塊。如前所述，每個塊都需要上一個塊的資訊。但是按照這個說法就有一個問題，區塊鏈的第一個區塊是如何到達那裡的呢？不得不說，第一個塊，或者說是起源塊，它是一個特殊的塊。在很多情況下，它是手動新增的，或者有獨特的邏輯允許新增。

下面將建立一個函式簡單地返回一個起源塊以便產生第一個區塊。這個塊是索引0，它具有任意的資料值和“前一個雜湊”引數中的任意值。

import datetime as date

def create_genesis_block():
  # Manually construct a block with
  # index zero and arbitrary previous hash
  return Block(0, date.datetime.now(), "Genesis Block", "0")

現在已經建立好了起源塊，接下來需要一個函式，以便在區塊鏈中生成後續的塊。這個函式將把鏈中的前一個塊作為引數，建立要生成的塊的資料，並使用適當的資料返回新塊。當新的塊雜湊資訊來自前面的塊時，區塊鏈的完整性會隨著每個新塊而增加。如果不這樣做，外部組織就更容易“改變過去”，用全新的方式取代已有的鏈條。這一系列的雜湊可以作為加密的證據，有助於確保一旦將塊新增到區塊鏈，它就不能被替換或刪除。

def next_block(last_block):
  this_index = last_block.index + 1
  this_timestamp = date.datetime.now()
  this_data = "Hey! I'm block " + str(this_index)
  this_hash = last_block.hash
  return Block(this_index, this_timestamp, this_data, this_hash)

大部分的工作已經完成，現在可以建立區塊鏈了。在這次的示例中，區塊鏈本身是一個簡單的Python列表。列表的第一個元素是起源塊。當然，還需要新增後續的塊，因為SnakeCoin是最小的區塊鏈，這裡只新增20個新的塊。可以用for迴圈來生成新塊。

# Create the blockchain and add the genesis block
blockchain = [create_genesis_block()]
previous_block = blockchain[0]

# How many blocks should we add to the chain
# after the genesis block
num_of_blocks_to_add = 20

# Add blocks to the chain
for i in range(0, num_of_blocks_to_add):
  block_to_add = next_block(previous_block)
  blockchain.append(block_to_add)
  previous_block = block_to_add
  # Tell everyone about it!
  print "Block #{} has been added to the blockchain!".format(block_to_add.index)
  print "Hash: {}\n".format(block_to_add.hash) 

下面來測試一下目前產生的區塊鏈。

看到了吧，這就是區塊鏈。如果希望在控制檯中檢視更多資訊，可以編輯完整的原始檔並列印每個塊的時間戳或資料。

這就是SnakeCoin要提供的所有東西。為了使SnakeCoin規模達到今天生產區塊鏈的規模，必須新增更多的功能，比如伺服器層，以跟蹤多臺機器上的鏈變化，以及在給定的時間段內限制新增的塊數量的工作演算法。

http://geek.csdn.net/news/detail/228355

儘管一些人認為區塊鏈是一個等待問題的解決方案，但毫無疑問，這種新技術是計算機的奇蹟。但是，區塊鏈到底是什麼呢?

區塊鏈

在更一般的術語中，它是一個公共資料庫，新資料儲存在一個名為塊的容器中，並被新增到一個不可變鏈（後來的區塊鏈）中添加了過去的資料。在比特幣和其他加密貨幣的情況下，這些資料是一組交易記錄。當然，資料可以是任何型別的。

區塊鏈技術已經催生了新的、完全數字化的貨幣，如比特幣和萊特幣，這些貨幣並不是由中央政府發行或管理的。因此為那些認為今天的銀行系統是騙局或終將失敗的人帶來了新的自由。區塊鏈所包含的以太坊技術對分散式計算進行了變革創新，它引入了一些有趣的概念，比如智慧合約。

在本文中，我將用不到50行的Python2程式碼來做一個簡單的區塊鏈。我稱它為SnakeCoin。

首先將定義塊將是什麼樣子。在區塊鏈中，每個塊都儲存一個時間戳和一個索引。在SnakeCoin中，需要把兩者都儲存起來。為了確保整個區塊鏈的完整性，每個塊都有一個自動識別雜湊。與比特幣一樣，每個塊的雜湊將是塊索引、時間戳、資料和前塊雜湊的加密雜湊。資料可以是你想要的任何東西。

import hashlib as hasher

class Block:
  def __init__(self, index, timestamp, data, previous_hash):
    self.index = index
    self.timestamp = timestamp
    self.data = data
    self.previous_hash = previous_hash
    self.hash = self.hash_block()

  def hash_block(self):
    sha = hasher.sha256()
    sha.update(str(self.index) + 
               str(self.timestamp) + 
               str(self.data) + 
               str(self.previous_hash))
    return sha.hexdigest()

這一步後有塊結構，但現在是建立區塊鏈，所以需要向實際的鏈中新增塊。如前所述，每個塊都需要上一個塊的資訊。但是按照這個說法就有一個問題，區塊鏈的第一個區塊是如何到達那裡的呢？不得不說，第一個塊，或者說是起源塊，它是一個特殊的塊。在很多情況下，它是手動新增的，或者有獨特的邏輯允許新增。

下面將建立一個函式簡單地返回一個起源塊以便產生第一個區塊。這個塊是索引0，它具有任意的資料值和“前一個雜湊”引數中的任意值。

import datetime as date

def create_genesis_block():
  # Manually construct a block with
  # index zero and arbitrary previous hash
  return Block(0, date.datetime.now(), "Genesis Block", "0")

現在已經建立好了起源塊，接下來需要一個函式，以便在區塊鏈中生成後續的塊。這個函式將把鏈中的前一個塊作為引數，建立要生成的塊的資料，並使用適當的資料返回新塊。當新的塊雜湊資訊來自前面的塊時，區塊鏈的完整性會隨著每個新塊而增加。如果不這樣做，外部組織就更容易“改變過去”，用全新的方式取代已有的鏈條。這一系列的雜湊可以作為加密的證據，有助於確保一旦將塊新增到區塊鏈，它就不能被替換或刪除。

def next_block(last_block):
  this_index = last_block.index + 1
  this_timestamp = date.datetime.now()
  this_data = "Hey! I'm block " + str(this_index)
  this_hash = last_block.hash
  return Block(this_index, this_timestamp, this_data, this_hash)

大部分的工作已經完成，現在可以建立區塊鏈了。在這次的示例中，區塊鏈本身是一個簡單的Python列表。列表的第一個元素是起源塊。當然，還需要新增後續的塊，因為SnakeCoin是最小的區塊鏈，這裡只新增20個新的塊。可以用for迴圈來生成新塊。

# Create the blockchain and add the genesis block
blockchain = [create_genesis_block()]
previous_block = blockchain[0]

# How many blocks should we add to the chain
# after the genesis block
num_of_blocks_to_add = 20

# Add blocks to the chain
for i in range(0, num_of_blocks_to_add):
  block_to_add = next_block(previous_block)
  blockchain.append(block_to_add)
  previous_block = block_to_add
  # Tell everyone about it!
  print "Block #{} has been added to the blockchain!".format(block_to_add.index)
  print "Hash: {}\n".format(block_to_add.hash) 

下面來測試一下目前產生的區塊鏈。

看到了吧，這就是區塊鏈。如果希望在控制檯中檢視更多資訊，可以編輯完整的原始檔並列印每個塊的時間戳或資料。

這就是SnakeCoin要提供的所有東西。為了使SnakeCoin規模達到今天生產區塊鏈的規模，必須新增更多的功能，比如伺服器層，以跟蹤多臺機器上的鏈變化，以及在給定的時間段內限制新增的塊數量的工作演算法。

儘管一些人認為區塊鏈是一個等待問題的解決方案，但毫無疑問，這種新技術是計算機的奇蹟。但是，區塊鏈到底是什麼呢?

區塊鏈

在更一般的術語中，它是一個公共資料庫，新資料儲存在一個名為塊的容器中，並被新增到一個不可變鏈（後來的區塊鏈）中添加了過去的資料。在比特幣和其他加密貨幣的情況下，這些資料是一組交易記錄。當然，資料可以是任何型別的。

區塊鏈技術已經催生了新的、完全數字化的貨幣，如比特幣和萊特幣，這些貨幣並不是由中央政府發行或管理的。因此為那些認為今天的銀行系統是騙局或終將失敗的人帶來了新的自由。區塊鏈所包含的以太坊技術對分散式計算進行了變革創新，它引入了一些有趣的概念，比如智慧合約。

在本文中，我將用不到50行的Python2程式碼來做一個簡單的區塊鏈。我稱它為SnakeCoin。

首先將定義塊將是什麼樣子。在區塊鏈中，每個塊都儲存一個時間戳和一個索引。在SnakeCoin中，需要把兩者都儲存起來。為了確保整個區塊鏈的完整性，每個塊都有一個自動識別雜湊。與比特幣一樣，每個塊的雜湊將是塊索引、時間戳、資料和前塊雜湊的加密雜湊。資料可以是你想要的任何東西。

import hashlib as hasher

class Block:
  def __init__(self, index, timestamp, data, previous_hash):
    self.index = index
    self.timestamp = timestamp
    self.data = data
    self.previous_hash = previous_hash
    self.hash = self.hash_block()

  def hash_block(self):
    sha = hasher.sha256()
    sha.update(str(self.index) + 
               str(self.timestamp) + 
               str(self.data) +