La guida definitiva a Python e Blockchain: parte 2

Ricapitolando la prima parte

Nella prima parte abbiamo imparato le basi di Python. Abbiamo imparato come funzionano if-elif-else e loops nel sistema. Fondamentalmente abbiamo imparato come fare codice semplice su Python. In questa parte, inizieremo a creare la nostra blockchain. Quindi, senza ulteriori indugi, iniziamo!

La guida definitiva a Python e Blockchain: parte 2

Creazione della nostra blockchain Python: presentazione degli elenchi

Va bene, quindi basta con le basi. Ora creiamo la nostra blockchain!

Lo faremo introducendo elenchi. Gli elenchi sono fondamentalmente un gruppo di dati che potrebbero essere di qualsiasi tipo. Sono definiti così:

List_name = [elemento 1, elemento 2, elemento 3 …… elemento n]

Gli elementi, come abbiamo spiegato prima, possono essere di qualsiasi tipo di dato. Potrebbe essere un numero intero, float, stringa o anche un altro elenco (che useremo in seguito). Vediamo come funzionerà. Useremo il nostro terminale per questo:

Alcune cose da notare dal codice sopra.

Pensa ai singoli elementi dell’elenco come blocchi nella blockchain. Non è davvero un granché, ovviamente, lo renderemo più sofisticato in seguito. La lista stessa lega tutti questi dati insieme per dare quell’elemento “catena” della blockchain.

Ora, un’altra cosa che noterai è il numero di indice di ogni elemento. Il primo elemento ha un indice pari a 0. Ecco perché, quando vogliamo stampare il primo elemento, diciamo “blockchain [0]”.

Modifica degli elementi della lista

Un elenco che non può essere modificato è inutile. Sono necessarie disposizioni per aggiungere e rimuovere elementi dall’elenco. Ora, sappiamo che in una blockchain simile a Bitcoin è impossibile rimuovere elementi, tuttavia, al momento abbiamo ancora a che fare con un elenco.

Allora, come lo faremo?

Useremo due funzioni di elenco:

  • aggiungere()
  • pop()

La funzione append aggiunge più elementi all’elenco. Quindi, riporta la nostra vecchia lista:

blockchain = [1, 2, 5.6].

Se vogliamo aggiungere “Blockgeeks”, diremo semplicemente: blockchain.append (“Blockgeeks”)

Ora, quando lo stampiamo, mostra:

[1, 2, 5.6, “Blockgeeks”]

Ora rimuoviamo alcuni dati.

Per questo, useremo la funzione pop (), che rimuoverà l’ultimo elemento dall’elenco. Quindi, se facciamo blockchain.pop [], ora rimuoverà “Blockgeeks” e mostrerà:

[1, 2, 5.6]

Aggiunta di elementi durante il runtime tramite funzioni

Ora, divertiamoci.

Useremo una funzione per aggiungere elementi all’elenco durante il runtime. Considera questo programma:

blockchain = []

def add_list ():

   blockchain.append (3.2)

   stampa (blockchain)

add_list ()

add_list ()

add_list ()

Quindi, abbiamo definito una funzione chiamata “add_list ()” che aggiungerà 3.2 alla lista blockchain ogni volta che viene chiamata. Hai notato come abbiamo dichiarato l’elenco vuoto con: blockchain = []? Ciò è stato fatto in modo che potessimo mostrarti come inserire i dati da zero.

Quindi, se lo stampiamo, questo è come apparirà. Siamo tornati su Visual Studio Code btw.

La guida definitiva a Python e Blockchain: parte 2

Dare alla lista più proprietà simili a blockchain

Fino ad ora abbiamo praticamente affrontato un elenco normale. Tuttavia, deve esserci una connessione più organica tra i blocchi.

Il motivo per cui i blocchi sono collegati tra loro in una vera blockchain è perché includono anche i dati del blocco precedente. Questo è esattamente ciò che faremo aggiungendo i dati dell’ultimo elemento all’ultimo elemento tramite un elenco annidato. In python, puoi ottenere i dati dell’ultimo della lista usando l’indice [-1].

Quindi, se la blockchain ha [1, 2, 3], allora blockchain [-1] ti dà 3.

Comunque, controlliamo il codice, useremo la funzione input () per ottenere il valore dell’elemento della blockchain dall’utente.

element1 = input ("Dai il primo elemento della blockchain ")

blockchain = [element1]

def add_list ():

   blockchain.append ([blockchain [-1], 3.2])

   stampa (blockchain)

add_list ()

add_list ()

add_list ()

Quindi, ora quando stampi questo, otterrai:

La guida definitiva a Python e Blockchain: parte 2

Ok, finora abbiamo dato un po ‘di carattere alla nostra blockchain, ma ancora non abbiamo nulla di simile al nostro modello di lavoro. Non preoccuparti, verrà risolto presto.

Avvicinarsi a una blockchain funzionante

blockchain = []

“”” Sezione 1 “””

def get_last_value ():

   """ estraendo l’ultimo elemento della lista blockchain """

   ritorno (blockchain [-1])

def add_value (transaction_amount, last_transaction = [1]):

   blockchain.append ([last_transaction, transaction_amount])

“”” Sezione 2 “””

def get_transaction_value ():

   user_value = float (input (‘Immettere l’importo della transazione’))

   restituire user_value

def get_user_choice ():

   user_input = input ("Si prega di dare la vostra scelta qui: ")

   return user_input

“” “Sezione 3” “”

def print_block ():

   per blocco in blockchain:

       Stampa("Ecco il tuo blocco")

       stampa (blocco)

“” “Sezione 4” “”

def verifica_chain ():

   indice = 0

   valido = vero

   per blocco in blockchain:

       se indice == 0:

           indice + = 1

           Continua

       elif block [0] == blockchain [index – 1]:

           valido = vero

       altro:

           valido = Falso

           rompere

       indice + = 1

   ritorno valido

“” “Sezione 5” “”

tx_amount = get_transaction_value ()

add_value (tx_amount)

mentre True:

   Stampa("Scegliere un’opzione")

   print (“Scegli 1 per aggiungere una nuova transazione”)

   print (“Scegli 2 per stampare la blockchain”)

   print (‘Scegli 3 se vuoi manipolare i dati’)

   print (“Scegli qualsiasi altra cosa se vuoi uscire”)

   user_choice = get_user_choice ()

   

   se user_choice == 1:

       tx_amount = get_transaction_value ()

       add_value (tx_amount, get_last_value ())

   

   elif user_choice == 2:

       print_block ()

   

   elif user_choice == 3:

       se len (blockchain) >= 1:

           blockchain [0] = 2

   

   altro:

       rompere

   

   se non verifica_chain ():

       print (‘Blockchain manipolato’)

       rompere

Sì, sappiamo che si tratta di un enorme blocco di codice, tuttavia, abbiamo diviso l’intera cosa in diverse sezioni per aiutarti a capire cosa sta succedendo e ogni parte del codice.

Quello che abbiamo cercato di fare qui è creare un prototipo di blockchain che non dipende dalla dichiarazione statica. Ciò significa che gli utenti possono riempire i dati durante il tempo di esecuzione. Ecco perché, se vedi la prima riga del codice, vedrai che stiamo iniziando con una blockchain vuota.

Va bene, quindi iniziamo a esaminare le sezioni.

Nota: Ti suggeriamo di copiare e incollare il codice sopra e di tenerlo aperto in una nuova finestra o in un file doc. Continueremo a fare riferimento a parti diverse del codice nella spiegazione di seguito e sarà più semplice per te tenerne traccia.

Sezione 1

def get_last_value ():

   """ estraendo l’ultimo elemento della lista blockchain """

   ritorno (blockchain [-1])

def add_value (transaction_amount, last_transaction = [1]):

   blockchain.append ([last_transaction, transaction_amount])

Quindi, questa prima sezione di cui devi essere abbastanza esperto ormai. Stiamo facendo due cose qui:

  • Estrazione dell’ultimo elemento della blockchain
  • Aggiunta dell’ultimo elemento insieme all’elemento corrente in un blocco alla blockchain.

Dai un’occhiata agli argomenti nella funzione add_value:

  • Last_transaction
  • Totale della transazione

Transaction_amount è il valore della transazione che verrà inserita nella blockchain. La variabile last_transaction, d’altra parte, è il valore della transazione nell’ultimo blocco che verrà inserito nel nuovo blocco.

Allora, perché inizializziamo last_transaction su [1]?

Questo viene fatto esclusivamente per evitare errori durante il runtime. Pensa a questo, se abbiamo a che fare con il primo blocco della blockchain, allora non avrà alcuna “ultima_transazione”, giusto? Avrai bisogno di almeno due blocchi affinché il concetto di “ultima_transazione” esista. Questo è il motivo per cui, per rimuovere la possibilità di qualsiasi errore nel primo blocco, last_transaction viene inizializzato a [1].

Sezione 2

def get_transaction_value ():

   user_value = float (input (‘Immettere l’importo della transazione’))

   restituire user_value

def get_user_choice ():

   user_input = input ("Si prega di dare la vostra scelta qui: ")

   return user_input

Chiamiamo questa sezione la sezione di input. Abbiamo due funzioni qui:

  • get_transaction_value ()
  • get_user_choice ()

Nella prima funzione, chiediamo all’utente di inserire il valore dell’importo della transazione che vuole inserire nella blockchain. Ora ricorda, la funzione input () restituisce un valore stringa. Quindi, usiamo la funzione float () per cambiare quel numero in un numero mobile.

Nella seconda funzione, chiederemo all’utente di inserire la propria scelta.

Ora, potresti chiederti: “Di quale scelta stai parlando?”

Bene, prendi una sezione 5. In particolare il ciclo while. Vedi l’opzione che stiamo chiedendo lì?

Stampa("Scegliere un’opzione")

print (“Scegli 1 per aggiungere una nuova transazione”)

print (“Scegli 2 per stampare la blockchain”)

print (‘Scegli 3 se vuoi manipolare i dati’)

print (“Scegli qualsiasi altra cosa se vuoi uscire”)

Quindi, la funzione get_user_choice () viene utilizzata per accettare la scelta dell’utente per aiutarlo a capire cosa vuole fare.

Sezione 3

def print_block ():

   per blocco in blockchain:

       Stampa("Ecco il tuo blocco")

       stampa (blocco)

Questa è una sezione molto semplice. Stiamo usando il ciclo for per stampare ogni blocco della blockchain.

Sezione 4

def verifica_chain ():

   indice = 0

   valido = vero

   per blocco in blockchain:

       se indice == 0:

           indice + = 1

           Continua

       elif block [0] == blockchain [index – 1]:

           valido = vero

       altro:

           valido = Falso

           rompere

       indice + = 1

   ritorno valido

Ora questo è qualcosa che non abbiamo fatto finora.

In questa sezione, stiamo verificando la validità della blockchain. Cosa intendiamo esattamente con questo.

Come forse saprai, una blockchain dovrebbe essere immutabile. Dal momento che non stiamo ancora utilizzando alcuna funzione hash, usiamo qualcos’altro per mostrare che la catena è stata manomessa. Questo è il motivo per cui in questa funzione stiamo usando una funzione verify_chain.

Allora, cosa ci facciamo qui?

Innanzitutto, abbiamo due variabili:

  • Indice = Un contatore che useremo per passare attraverso i blocchi nella blockchain
  • Valid = Una variabile booleana che restituirà True o False come valore finale di questa funzione

Dopodiché, stiamo usando un ciclo for per passare attraverso la blockchain, abbastanza simile alla sezione precedente in cui abbiamo usato un ciclo per stampare i blocchi. All’interno del ciclo stiamo utilizzando tre istruzioni condizionali, esaminiamo ciascuna di esse:

La sottosezione if

Questo controlla se l’indice è 0 o meno. Se lo è, l’indice aumenta di 1

La sottosezione elif

Questa è la parte in cui controlliamo se è stata eseguita o meno una manomissione. Per capire come funziona, immagina questo scenario.

La guida definitiva a Python e Blockchain: parte 2

Quindi, come puoi vedere, il primo elemento del Blocco B è il contenuto del suo blocco precedente. Quindi, in questa sottosezione, stiamo controllando se il primo elemento del Blocco è uguale agli elementi del blocco precedente. Se è allora questa funzione è True, altrimenti restituisce False.

Sezione 5

tx_amount = get_transaction_value ()

add_value (tx_amount)

mentre True:

   Stampa("Scegliere un’opzione")

   print (“Scegli 1 per aggiungere una nuova transazione”)

   print (“Scegli 2 per stampare la blockchain”)

   print (‘Scegli 3 se vuoi manipolare i dati’)

   print (“Scegli qualsiasi altra cosa se vuoi uscire”)

   user_choice = get_user_choice ()

   

   se user_choice == 1:

       tx_amount = get_transaction_value ()

       add_value (tx_amount, get_last_value ())

   

   elif user_choice == 2:

       print_block ()

   

   elif user_choice == 3:

       se len (blockchain) >= 1:

           blockchain [0] = 2

   

   altro:

       rompere

   

   se non verifica_chain ():

       print (‘Blockchain manipolato’)

       Rompere

Quindi, questa è una sezione lunga, motivo per cui dovremo differenziarla in diverse sottosezioni (di nuovo).

Sottosezione 1: inizializzazione

tx_amount = get_transaction_value ()

add_value (tx_amount

Iniziamo inizializzando il primo blocco della blockchain. Otteniamo il valore dell’importo della transazione (tx_amount) e quindi inseriamo il valore nel blocco della blockchain.

Sottosezione 2: Dare una scelta

mentre True:

   Stampa("Scegliere un’opzione")

   print (“Scegli 1 per aggiungere una nuova transazione”)

   print (“Scegli 2 per stampare la blockchain”)

   print (‘Scegli 3 se vuoi manipolare i dati’)

   print (“Scegli qualsiasi altra cosa se vuoi uscire”)

   user_choice = get_user_choice ()

Ok, quindi dalla sottosezione 1 in poi, tutte le altre sottosezioni verranno eseguite all’interno di questo ciclo while. Quindi, la prima cosa che stiamo facendo è dare agli utenti la possibilità di scegliere esattamente cosa vogliono fare:

  • Aggiungi una nuova transazione
  • Stampa la blockchain
  • Manipola i dati
  • Esci dal processo

Successivamente, user_choice memorizza i dati dell’utente

Sottosezione 3: if-elif-elif-else

Quindi, a seconda della scelta, abbiamo 4 possibilità. Il codice ha questo aspetto:

se user_choice == 1:

       tx_amount = get_transaction_value ()

       add_value (tx_amount, get_last_value ())

   

   elif user_choice == 2:

       print_block ()

   

   elif user_choice == 3:

       se len (blockchain) >= 1:

           blockchain [0] = 2

   altro:

       rompere

  • Per prima cosa, aggiungiamo la transazione alla blockchain. Compiliamo l’input dell’utente e lo memorizziamo in tx_amount. Una volta ottenuto il valore della transazione, lo aggiungiamo, insieme al valore degli elementi dall’ultimo blocco nella blockchain
  • In secondo luogo, invochiamo la funzione di stampa per stampare la blockchain
  • Terzo, è la funzione di manipolazione. Lo abbiamo incorporato solo per mostrarti come reagirà questa blockchain se i dati vengono manipolati. Quindi, quello che succede qui è che cambiamo il primo elemento della blockchain in 2. Funziona solo se la blockchain ha più di 1 elemento (la condizione if lo verifica)

    Controlla la seguente sottosezione per sapere cosa succede dopo

  • L’ultima parte è piuttosto semplice. Se l’utente invia qualche altra opzione, si attiva il blocco else che utilizza semplicemente “break” per uscire dal ciclo while

Sottosezione 4: chiamata di verifica

se non verifica_chain ():

       print (‘Blockchain manipolato’)

       Rompere

Se l’utente sceglie di manipolare la blockchain, questa sottosezione ne viene influenzata. Ora ricorda, la verify_chain () restituisce un valore booleano:

  • Vero
  • Falso

Verify_chain () restituisce False se la manipolazione è stata eseguita.

Ora, questa sottosezione utilizza l’estensione non parola chiave, che trasforma False in True. Questo a sua volta attiva la funzione di stampa all’interno del blocco if per stampare “Blockchain manipolato”.

Risultati del programma

Va bene, quindi ora sappiamo come funziona il programma. Diamo un’occhiata agli output.

La guida definitiva a Python e Blockchain: parte 2

Quindi, per esaminare ciò che abbiamo fatto sopra

Abbiamo inserito 3 valori nella nostra blockchain: 23.5, 43,1 e 5.89

Abbiamo quindi stampato la blockchain che dà questo:

La guida definitiva a Python e Blockchain: parte 2

Abbiamo quindi provato a manipolare la nostra blockchain modificando un dato, ma il nostro sistema di verifica integrato lo ha rilevato e ha fornito questo output:

La guida definitiva a Python e Blockchain: parte 2

Bene, quindi finora abbiamo una struttura abbastanza buona. Tuttavia, dobbiamo ancora incorporare hashing e funzionalità di prova del lavoro al nostro codice. Quindi, poiché sappiamo già cosa sono gli elenchi, familiarizziamo con tuple e dizionari.

Tuple e dizionari

Tuple e dizionari sono strutture di dati insieme a elenchi. Confrontiamo questi tre e scopriamo come funzionano.

La guida definitiva a Python e Blockchain: parte 2

Le tuple sono abbastanza simili alle liste, tuttavia, non possono essere modificate una volta create. I dizionari, d’altra parte, hanno identificatori univoci come NAME1 AND NAME2 nel nostro esempio sopra che memorizzano i valori. Possono essere modificati una volta creati.

Useremo queste strutture di dati nella nostra nuova e migliorata blockchain.

Potresti chiederti: “Qual è lo scopo di farlo?”

Bene, le transazioni, i blocchi ecc. Contengono molti metadati che devono essere archiviati. Pensa a tutti i metadati che possono essere archiviati in una transazione:

  • ID mittente
  • ID destinatario
  • Data della transazione
  • Totale della transazione

L’aggiunta di tutti questi dati ci aiuta a tenere traccia delle nostre transazioni.

Aggiunta di funzionalità di data mining e prova di lavoro

Quindi, la prima cosa che dobbiamo fare è aggiungere funzionalità di mining e proof of work. Il mining è il processo mediante il quale i miner risolvono enigmi crittograficamente complessi per trovare blocchi da aggiungere alla blockchain. Per l’estrazione di questi blocchi, i minatori ricevono una ricompensa chiamata ricompensa del blocco.

D’altra parte, il proof-of-work è il metodo di mining e consenso utilizzato in molte criptovalute come Bitcoin. Useremo la prova di lavoro nella nostra blockchain.

Se dovessimo riassumere come funziona il protocollo Proof Of Work con la blockchain.

  • I minatori risolvono enigmi crittografici per “minare” un blocco da aggiungere alla blockchain.
  • Questo processo richiede un’enorme quantità di energia e un utilizzo computazionale. I puzzle sono stati progettati in un modo che rende difficile e faticoso per il sistema.
  • Quando un minatore risolve il puzzle, presenta il blocco alla rete per la verifica.
  • Verificare se il blocco appartiene o meno alla catena è un processo estremamente semplice.

Va bene, quindi diamo un’occhiata al nostro codice:

“”” Sezione 1 “””

importa hashlib

import json

ricompensa = 10.0

genesis_block = {

   ‘precedente_hash’: ”,

   ‘indice’: 0,

   “transazione”: [],

   ‘nonce’: 23

}

blockchain = [genesis_block]

open_transactions = []

owner = “Blockgeeks”

def hash_block (blocco):

   return hashlib.sha256 (json.dumps (block) .encode ()). hexdigest ()

“”” Sezione 2 “””

def valid_proof (transazioni, last_hash, nonce):

   indovina = (str (transazioni) + str (last_hash) + str (nonce)). encode ()

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

   print (guess_hash)

   return guess_hash [0: 2] == ’00’

def pow ():

   last_block = blockchain [-1]

   last_hash = hash_block (last_block)

   nonce = 0

   mentre non è valid_proof (open_transactions, last_hash, nonce):

       nonce + = 1

   return nonce

“” “Sezione 3” “”

def get_last_value ():

   """ estraendo l’ultimo elemento della lista blockchain """

   ritorno (blockchain [-1])

def add_value (destinatario, mittente = proprietario, importo = 1.0):

   transazione = {‘mittente’: mittente,

   “destinatario”: destinatario,

   ‘importo’: importo}

   open_transactions.append (transazione)

“” “Sezione 4” “”

def mine_block ():

   last_block = blockchain [-1]

   hashed_block = hash_block (last_block)

   nonce = pow ()

   reward_transaction = {

           “mittente”: “MINING”,

           ‘destinatario’: proprietario,

           ‘importo’: ricompensa

       }

   open_transactions.append (reward_transaction)

   blocco = {

       ‘previous_hash’: hashed_block,

       ‘indice’: len (blockchain),

       ‘transazione’: open_transactions,

       ‘nonce’: nonce

   }

   blockchain.append (blocco)

“” “Sezione 5” “”

def get_transaction_value ():

   tx_recipient = input (‘Inserisci il destinatario della transazione:’)

   tx_amount = float (input (‘Inserisci l’importo della transazione’))

   return tx_recipient, tx_amount

def get_user_choice ():

   user_input = input ("Si prega di dare la vostra scelta qui: ")

   return user_input

“” “Sezione 6” “”

def print_block ():

   per blocco in blockchain:

       Stampa("Ecco il tuo blocco")

       stampa (blocco)

“” “Sezione 7” “”

mentre True:

   Stampa("Scegliere un’opzione")

   print (“Scegli 1 per aggiungere una nuova transazione”)

   print (‘Scegli 2 per estrarre un nuovo blocco’)

   print (“Scegli 3 per stampare la blockchain”)

   print (“Scegli qualsiasi altra cosa se vuoi uscire”)

   user_choice = get_user_choice ()

   

   se user_choice == 1:

       tx_data = get_transaction_value ()

       destinatario, importo = tx_data

       add_value (destinatario, importo = importo)

       print (open_transactions)

   elif user_choice == 2:

       mine_block ()

   elif user_choice == 3:

       print_block ()

   

   altro:

       rompere

Ok, quindi analizziamo il codice.

Sezione 1

importa hashlib

import json

ricompensa = 10.0

genesis_block = {

   ‘precedente_hash’: ”,

   ‘indice’: 0,

   “transazione”: [],

   ‘nonce’: 23

}

blockchain = [genesis_block]

open_transactions = []

owner = “Blockgeeks”

def hash_block (blocco):

   return hashlib.sha256 (json.dumps (block) .encode ()). hexdigest ()

La prima cosa che stiamo facendo qui è importare le librerie hash. Stiamo specificatamente importando:

  • hashlib: per usare le loro funzioni di hashing
  • json: Abbiamo bisogno di questo pacchetto per convertire il blocco da dizionario a stringa.

Dopodiché, dichiariamo “ricompensa”, una variabile globale che memorizzerà la ricompensa del blocco minerario che daremo ai nostri minatori per il mining di un blocco.

Successivamente abbiamo il nostro blocco di genesi. Il blocco genesis è il primo blocco nella blockchain. Stiamo usando 4 metadati nel nostro blocco:

  • Previous_hash: Memorizza l’hash del blocco precedente. Questa sarà una stringa vuota poiché il blocco genesis non avrà alcun hash precedente.
  • Indice: Questo è l’indice del blocco nella blockchain. Poiché il blocco genesisèil primo blocco, il suo indiceèinizializzato a 0. Ricorda nella terminologia di programmazione, il primo elemento in una listaènella posizione 0
  • Transazione: La transazione archiviata nella blockchain. Poiché questo non ne ha, è un elenco vuoto.
  • Nonce: Lo spiegheremo più tardi. Viene inizializzato a 23 che è un valore fittizio.

Dopo che il blocco genesis è stato inizializzato, viene aggiunto alla blockchain nel passaggio successivo tramite blockchain = [genesis_block].

Open_transactions: Un elenco che gestisce tutte le transazioni in sospeso nella blockchain. All’inizio è una lista vuota.

Poiché siamo il proprietario e il mittente di questa transazione, l’abbiamo inizializzata all’inizio

Successivamente abbiamo la funzione hash hash_block ()

Al suo interno restituiamo l’hash del blocco usando questa espressione:

hashlib.sha256 (json.dumps (block) .encode ()). hexdigest ()

Quindi, vediamo cosa stiamo facendo qui:

  • Utilizzando l’algoritmo di hash sha256 di hashlib.
  • La funzione json.dumps entra quindi in gioco e converte il blocco che è un dizionario in una stringa formattata json. Tuttavia, l’hashlib non può leggerlo, quindi la prossima volta abbiamo ….
  • La funzione encode (). Questo converte la stringa formattata json in una stringa UTF-8 che è leggibile da hashlib.
  • L’output di hashlib è un hash di byte. Quindi finalmente utilizziamo il metodo hexdigest () per convertirlo in una stringa normale.

Sezione 2

def valid_proof (transazioni, last_hash, nonce):

   indovina = (str (transazioni) + str (last_hash) + str (nonce)). encode ()

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

   print (guess_hash)

   return guess_hash [0: 2] == ’00’

def pow ():

   last_block = blockchain [-1]

   last_hash = hash_block (last_block)

   nonce = 0

   mentre non è valid_proof (open_transactions, last_hash, nonce):

       nonce + = 1

   return nonce

Nella sezione 2 abbiamo due funzioni:

  • Valid_proof
  • La funzione pow

valid_proof ()

def valid_proof (transazioni, last_hash, nonce):

   indovina = (str (transazioni) + str (last_hash) + str (nonce)). encode ()

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

   print (guess_hash)

   return guess_hash [0: 2] == ’00’

Quindi, la funzione valid_proof () ha tre argomenti:

  • Transazioni: le transazioni all’interno del blocco
  • Ultimo hash: l’hash dell’ultimo blocco
  • Nonce

Ok, allora cos’è esattamente il nonce? Ben prima di ciò, dobbiamo sapere cosa significa difficoltà. La “difficoltà” è l’idea di rendere il mining il più difficile possibile. Se il mining non è difficile, tutte le monete nel sistema verranno pompate facilmente, rendendole assolutamente inutili.

Quindi, il modo in cui calcoliamo l’hash del sistema è concatenando le transazioni, l’hash dell’ultimo blocco e il nonce in una singola stringa e poi li hashing. L’hash è accettabile solo se le prime due lettere sono zero.

È così che stiamo mettendo in difficoltà. È impossibile prevedere come sarà l’hashish ed è più un’estrazione fortunata. Questo è il motivo per cui è estremamente difficile ottenere un hash che inizi con uno schema specifico (come 2 0).

La funzione restituisce True se il programma ha un hash valido e False in caso contrario.

La funzione pow ()

Successivamente abbiamo la prova di lavoro o la funzione pow ().

def pow ():

   last_block = blockchain [-1]

   last_hash = hash_block (last_block)

   nonce = 0

   mentre non è valid_proof (open_transactions, last_hash, nonce):

       nonce + = 1

   return nonce

Questa funzione è piuttosto semplice:

  • Per prima cosa stiamo estraendo l’ultimo blocco dalla blockchain e inserendolo in last_block
  • Quindi eseguiamo l’hashing di last_block e li inseriamo in last_hash
  • Il ciclo while continua a funzionare finché la funzione valid_proof non restituisce TRUE. (Il non convert convertirà il VERO in FALSO e quindi uscirà dal ciclo)
  • Il nonce viene quindi restituito.

Sezione 3

def get_last_value ():

   """ estraendo l’ultimo elemento della lista blockchain """

   ritorno (blockchain [-1])

def add_value (destinatario, mittente = proprietario, importo = 1.0):

   transazione = {‘mittente’: mittente,

   “destinatario”: destinatario,

   ‘importo’: importo}

   open_transactions.append (transazione)

In questa sezione abbiamo ancora due funzioni:

  • get_last_value
  • aggiungere valore

Il get_last_value ()

Questo è abbastanza semplice. Estrae l’ultimo blocco della blockchain.

aggiungere valore()

La funzione prende i metadati della transazione, ovvero:

  • Nome del mittente
  • Nome destinatario
  • Importo della transazione

Successivamente, la transazione viene aggiunta all’elenco open_transactions.

Sezione 4

def mine_block ():

   last_block = blockchain [-1]

   hashed_block = hash_block (last_block)

   nonce = pow ()

   reward_transaction = {

           “mittente”: “MINING”,

           ‘destinatario’: proprietario,

           ‘importo’: ricompensa

       }

   open_transactions.append (reward_transaction)

   blocco = {

       ‘previous_hash’: hashed_block,

       ‘indice’: len (blockchain),

       ‘transazione’: open_transactions,

       ‘nonce’: nonce

   }

   blockchain.append (blocco)

In questa sezione abbiamo una funzione, la funzione mine_block () che ti consentirà di minare i blocchi

Quindi, in questa funzione, accadrà quanto segue:

  • Estrai l’ultimo blocco della blockchain e inseriscilo in last_block
  • Hash l’ultimo blocco
  • Usa la funzione pow () per estrarre il nonce
  • Crea una reward_transaction che premia il minatore, cioè noi con l’importo della ricompensa che abbiamo impostato in precedenza (10.0 monete)
  • La reward_transaction viene aggiunta all’elenco open_transaction
  • Infine, con il nuovo nonce approvato, abbiamo finalmente un nuovo blocco, che ci aiuta a ottenere i metadati del nuovo blocco,
  • Il nuovo blocco viene aggiunto alla blockchain

Sezione 5

def get_transaction_value ():

   tx_recipient = input (‘Inserisci il destinatario della transazione:’)

   tx_amount = float (input (‘Inserisci l’importo della transazione’))

   return tx_recipient, tx_amount

def get_user_choice ():

   user_input = input ("Si prega di dare la vostra scelta qui: ")

   return user_input

In questa sezione abbiamo due funzioni:

  • get_transaction_value ()
  • get_user_choice ()

# 1 get_transaction_value ()

Questa funzione accetta i metadati della transazione come il nome del destinatario e l’importo della transazione.

Allo stesso tempo, dai un’occhiata alla dichiarazione di reso.

return tx_recipient, tx_amount

Questa funzione restituisce una tupla (abbiamo parlato di tuple prima che ricordi?)

# 2 get_user_choice

Questa funzione fondamentalmente prende la scelta dell’utente e la restituisce. Questo è abbastanza simile alla funzione get_user_choice () nel programma precedente.

Sezione 6

def print_block ():

   per blocco in blockchain:

       Stampa("Ecco il tuo blocco")

       stampa (blocco)

Simile all’ultimo programma, questa è la funzione di stampa che stampa la blockchain.

Sezione 7

mentre True:

   Stampa("Scegliere un’opzione")

   print (“Scegli 1 per aggiungere una nuova transazione”)

   print (‘Scegli 2 per estrarre un nuovo blocco’)

   print (“Scegli 3 per stampare la blockchain”)

   print (“Scegli qualsiasi altra cosa se vuoi uscire”)

   user_choice = get_user_choice ()

   

   se user_choice == 1:

       tx_data = get_transaction_value ()

       destinatario, importo = tx_data

       add_value (destinatario, importo = importo)

       print (open_transactions)

   elif user_choice == 2:

       mine_block ()

   elif user_choice == 3:

       print_block ()

   

   altro:

       rompere

Anche questo è simile all’ultimo programma. L’utente può scegliere tra:

  • Immettere una transazione
  • Mine a block
  • Stampa la blockchain

Vediamo ora i risultati del programma.

Output del programma

Innanzitutto, scegliamo l’opzione 2 ed estraiamo un blocco. Quando lo fai, otteniamo il seguente blocco di hash:

La guida definitiva a Python e Blockchain: parte 2

Sembra sbalorditivo, finché non presti maggiore attenzione e controlli l’ultimo hash:

“001f946e8c2172affa830ef27761270aab2de515ffac8ae90e5de95b48dc366c”

Vedi cosa c’è di così speciale in questo hashish?

Ricordi la difficoltà che abbiamo impostato in precedenza? Stavamo cercando specificamente un hash che iniziasse con “00”. Questo è il motivo per cui il computer ha eseguito più hash cambiando il nonce fino a quando non è finalmente incappato in un hash che soddisfaceva i criteri di difficoltà indicati.

Va bene, quindi ora aggiungiamo una transazione. Supponiamo di voler inviare Sam, 2.4 monete, sceglieremo l’opzione 1 e otterremo il seguente output:

La guida definitiva a Python e Blockchain: parte 2

Presta attenzione all’ultima riga. Mostra le due transazioni che abbiamo fatto finora.

Aspetta … due transazioni? Ne abbiamo appena fatto uno giusto?

Non proprio. Ricordi che abbiamo estratto un blocco prima di questo, giusto? Quindi qui viene mostrata anche la transazione della ricompensa del blocco.

Infine, stampiamo la blockchain.

La guida definitiva a Python e Blockchain: parte 2

Quindi, abbiamo due blocchi:

  • In primo luogo, abbiamo il blocco genesi che ci siamo dichiarati. Il nonce era qualcosa che abbiamo messo in noi stessi, ovvero 23
  • Successivamente, abbiamo il secondo blocco, che include la transazione mineraria e la transazione che noi stessi abbiamo fatto con “Sam”. Il nonce del blocco è 93

Conclusione

Così il gioco è fatto. Almeno abbiamo un po ‘di lavoro blockchain codificato tramite Python. Se sei interessato a saperne di più, continua la tua ricerca. Riteniamo che Python sia un linguaggio che dovresti padroneggiare se vuoi entrare nello sviluppo. È una lingua estremamente divertente e facile da imparare che può aprire le porte a opportunità illimitate.

Mike Owergreen Administrator
Sorry! The Author has not filled his profile.
follow me