Introduction aux bases de Python – Blockchain

Le concept de base de la blockchain est simple : une base de données distribuée qui stocke une liste croissante contenant de nombreux enregistrements ordonnés. L'article suivant vous présente principalement les informations pertinentes sur la blockchain pour apprendre Python. L'article le présente en détail à travers un exemple de code. Les amis qui en ont besoin peuvent y jeter un œil ci-dessous.

Avant-propos

Cet article vous donnera une brève introduction aux connaissances pertinentes sur la blockchain (BlockChain), et utilisera Python pour créer un simple mise en œuvre. Sans plus tarder, jetons un œil à l'introduction détaillée :

Qu'est-ce que la blockchain

En bref, la blockchain C'est une solution permanente et irréversible enregistrement modifié généré par superposition (chaînage) de données cryptées (blocs) dans l'ordre chronologique. Plus précisément, la blockchain est composée d'une série de blocs de données générés à l'aide de méthodes cryptographiques. Chaque bloc contient la valeur de hachage du bloc précédent, à partir du bloc de genèse. Commencez à vous connecter au bloc actuel pour former une chaîne de blocs. Chaque bloc est garanti d'être généré après le bloc précédent dans l'ordre chronologique, sinon la valeur de hachage du bloc précédent est inconnue. C’est un concept important dans Bitcoin.

Caractéristiques

La blockchain présente les fonctionnalités suivantes :

• Décentralisation : La blockchain ne s'appuie pas sur un nœud central, mais sur des nœuds distribués.

• Aucun système de confiance requis : la blockchain est basée sur des algorithmes cryptographiques et les données doivent être approuvées par d'autres utilisateurs du réseau, il n'est donc pas nécessaire de recourir à une structure intermédiaire tierce. ou l'approbation d'un organisme de fiducie.

• Sécurité inviolable et cryptée : la blockchain adopte un algorithme de hachage unidirectionnel, et chaque bloc nouvellement généré est strictement avancé dans un ordre linéaire en fonction du temps. L'irréversibilité du temps provoque toute tentative. l'intrusion et la falsification des informations sur les données dans la blockchain peuvent être facilement retracées, conduisant à un rejet par d'autres nœuds, ce qui peut limiter les activités illégales associées.
  

Les caractéristiques ci-dessus font que la blockchain a de plus en plus d'applications dans de nombreux domaines tels que la banque, le marché des valeurs mobilières et la finance.

Comment fonctionne la blockchain

La blockchain est une série de blocs de données cryptés. Ces blocs sont constitués d'un en-tête de bloc contenant des métadonnées, suivi d'une longue liste de transactions qui constituent le corps du bloc. La structure des blocs dans Bitcoin est la suivante :

En-tête du bloc

L'en-tête du bloc contient des informations relatives à d'autres domaines de la blockchain Les informations de connexion, l'horodatage, le nom occasionnel et d'autres informations dans le bloc sont les suivantes :

Identifiant du bloc

Le bloc a deux identifiants, l’un est la valeur de hachage de l’en-tête du bloc et l’autre est la hauteur du bloc. La valeur de hachage de l'en-tête de bloc est un nombre obtenu en effectuant un calcul de hachage secondaire sur l'en-tête de bloc à l'aide de l'algorithme SHA256. La valeur de hachage du bloc identifie un bloc de manière unique et sans ambiguïté, et n'importe quel nœud peut obtenir indépendamment la valeur de hachage du bloc en hachant simplement l'en-tête du bloc. La hauteur du bloc fait référence à la position du bloc dans la blockchain. La hauteur du bloc n'est pas un identifiant unique. Alors qu'un seul bloc aura toujours une hauteur de bloc claire et fixe, l'inverse n'est pas vrai et une hauteur de bloc n'identifie pas toujours un seul bloc. Deux blocs ou plus peuvent avoir la même hauteur de bloc et se disputer la même position dans la blockchain.

Après avoir compris les bases ci-dessus, commençons à utiliser Python pour implémenter une blockchain simple.

Implémentation Python de la blockchain

1 Définir la structure du bloc

Dans [ 16] :

# block.py

import hashlib
import uuid


class Block(object):
 def __init__(self, data=None, previous_hash=None):
  self.identifier = uuid.uuid4().hex # 产生唯一标示
  self.nonce = None     # nonce值
  self.data = data      # 区块内容
  self.previous_hash = previous_hash # 父节点哈希值
  
 def hash(self, nonce=None):
  '''
  计算区块的哈希值
  '''
  message = hashlib.sha256()
  message.update(self.identifier.encode('utf-8'))
  message.update(str(nonce).encode('utf-8'))
  message.update(str(self.data).encode('utf-8'))
  message.update(str(self.previous_hash).encode('utf-8'))

  return message.hexdigest()

 def hash_is_valid(self, the_hash):
  '''
  校验区块哈希值有否有效
  '''
  return the_hash.startswith('0000')

 def __repr__(self):
  return &#39;Block<Hash: {}, Nonce: {}>&#39;.format(self.hash(), self.nonce)

Ce qui précède est une structure de blocs. Ce qui est implémenté ici est une version simplifiée, qui ne correspond pas entièrement aux blocs de Bitcoin. Le bloc contient ici un identifiant unique, la valeur de hachage du nœud parent, la valeur occasionnelle et le champ de contenu du bloc. Vous pouvez voir que la valeur de hachage d'un bloc doit remplir certaines conditions pour être valide, comme commencer par 0000. Ensuite, initialisez cette structure de bloc.

Dans [37] :

# 创建一个内容为hello world的内容块

block = Block('Hello World')
block

Sortie[37] :

Block<Hash: 238a65a101c8829d7fc406eb78a71cfc19ad702b437e2c1be8d9061ddb81e900, Nonce: None>

Bien que le bloc ci-dessus ait été créé, sa valeur de hachage n'est pas valide.

Dans [38] :

block.hash_is_valid(block.hash())

Sortie[38] :

False

Modifiez la valeur du nonce pour obtenir une nouvelle valeur de hachage.

Dans [39] :

block.hash(1)

Sortie[39] :

'a6431938ba10270dfcfdf7a2371312446914fedadf79632c2c0adb3b463f4838'

La valeur de hachage est mise à jour, mais ce n'est pas encore une valeur de hachage valide. Afin d'obtenir une valeur de hachage valide, il s'agit d'un processus de mise à jour constante de la valeur occasionnelle, ou d'un processus d'exploration de données. Ajoutez une fonction mine ci-dessous pour obtenir une valeur occasionnelle appropriée.

In [78]:

# block.py

import hashlib
import uuid


class Block(object):
 def __init__(self, data=None, previous_hash=None):
  self.identifier = uuid.uuid4().hex # 产生唯一标示
  self.nonce = None     # nonce值
  self.data = data      # 区块内容
  self.previous_hash = previous_hash # 父节点哈希值
  
 def hash(self, nonce=None):
  '''
  计算区块的哈希值
  '''
  message = hashlib.sha256()
  message.update(self.identifier.encode('utf-8'))
  message.update(str(nonce).encode('utf-8'))
  message.update(str(self.data).encode('utf-8'))
  message.update(str(self.previous_hash).encode('utf-8'))

  return message.hexdigest()

 def hash_is_valid(self, the_hash):
  '''
  校验区块哈希值有否有效
  '''
  return the_hash.startswith('0000')

 def __repr__(self):
  return &#39;Block<Hash: {}, Nonce: {}>&#39;.format(self.hash(self.nonce), self.nonce)
 
 
 &#39;&#39;&#39;
  新增挖矿函数
 &#39;&#39;&#39;
 def mine(self):
  # 初始化nonce为0
  cur_nonce = self.nonce or 0

  # 循环直到生成一个有效的哈希值
  while True:
   the_hash = self.hash(nonce=cur_nonce)
   if self.hash_is_valid(the_hash): # 如果生成的哈希值有效
    self.nonce = cur_nonce   # 保持当前nonce值
    break       # 并退出
   else:
    cur_nonce += 1 # 若当前哈希值无效，更新nonce值，进行加1操作

In [75]:

block = Block('Hello World')

# 挖矿，循环直至找到合适的nonce
block.mine()

# 打印
block

Out[75]:

Block<Hash: 000087359d5264153d624556f0a0c6f25cba06e453975c1c02587862e823911b, Nonce: 64751>

至此，第一个有效的区块生成完成，下面开始定义区块链。

二、定义区块链结构

In [81]:

class BlockChain(object):
 def __init__(self):
  self.head = None # 指向最新的一个区块
  self.blocks = {} # 包含所有区块的一个字典

 '''
  添加区块函数
 '''
 def add_block(self, new_block):
  previous_hash = self.head.hash() if self.head else None
  new_block.previous_hash = previous_hash

  self.blocks[new_block.identifier] = {
   'block': new_block,
   'previous_hash': previous_hash,
   'previous': self.head,
  }
  self.head = new_block

 def __repr__(self):
  num_existing_blocks = len(self.blocks)
  return &#39;Blockchain<{} Blocks, Head: {}>&#39;.format(
   num_existing_blocks,
   self.head.identifier if self.head else None
  )

定义好区块链结构后，下面就开始初始化一条区块链。

In [82]:

# 初始化
chain = BlockChain()

# 打印
chain

Out[82]:

Blockchain<0 Blocks, Head: None>

In [83]:

# 添加区块
chain.add_block(block)

# 打印
chain

Out[83]:

Blockchain<1 Blocks, Head: 364c0cf963384ca28a2763499a140405>

In [84]:

# 添加更多的区块

for i in range(6):
 new_block = Block(i)
 new_block.mine()
 chain.add_block(new_block)
 
# 打印
chain

Out[84]:

Blockchain<7 Blocks, Head: e7cb24ec7acd42a4aaebe7faee9e0713>

以上就是一个简单区块链，后面还会涉及到区块链的有效性。当区块链中一个区块被改变后，这个区块的哈希就会改变，从而影响到这块区块之后的区块，致使这个区块链不再有效。这些将在后续继续深入。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!