Web3.py Tutorial Python Free For Beginners

Python is one of the most important programming languages to learn for new blockchain developers. Anyone who aspires to build a career in the blockchain industry needs to learn certain programming languages, and Python is one of them. Web3.py is a crucial library that every beginner must know how to use, especially if they want to interact with the Ethereum blockchain.

This exclusive video course will help you learn the basics of Web3.py, understand the projects you can create with the use of this library, connect to the Ethereum network, and perform common tasks, i.e., contract data reading, committing transactions, etc.

So, without further ado, let us get started.

Step 1: Installation

To kick-start the tutorial, you need to install Web3.py using the Python package manager. For this tutorial, you will use pip. Now, you need to open your terminal and run the install command.

pip install web3

Step 2: Import the Library

After installing Web3.py, import this to the interactive console or Python script. Now create a new Python file and just paste the following command into the file:

from web3 import Web3

Step 3: Connect to the Ethereum Network

Now, you need to connect to providers to interact with the Ethereum network. There are several options to make this possible, such as using a third-party remote node provider like Infura or simply running your own local Ethereum node. For this tutorial, you will be using Infura.

You just need to sign up for the account at https://infura.io/, and you will be able to create a new project. This will offer you a project ID that you can connect to the Ethereum network. Here is a code that will help you connect your project ID to Ethereum network.

w3 = Web3(Web3.HTTPProvider('https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID'))

To customize this code, you need to replace YOUR_INFURA_PROJECT_ID with the Infura project ID you received after creating your account.

Step 4: Check the Connection

After establishing the connection, you also need to make sure the connection is successful. For quality assurance, use the w3.net.version property to check the network ID. Here is a code that you can use:

network_id = w3.net.version print(f"Connected to network with ID: {network_id}")

Step 5: Work with Ethereum Accounts

For committing transactions on the Ethereum network, you will need an Ethereum account. You can then manage your account with the help of the account module. Here is a code that can help you create a new account: 

account = Account.create() print(f"New account created: {account.address}") print(f"Private key: {account.privateKey.hex()}")

After generating a new Ethereum account with this code, you will get an account address as well as a private key.

Step 6: Load an Existing Account

In case you have an Ethereum account already, just load it into Web3.py with the help of a private key. Here is a code for doing this with an existing account:

private_key = 'YOUR_PRIVATE_KEY' account=Account.from_key(private_key) print(f"Loaded account: {account.address}")

For customization, you can simply replace YOUR_PRIVATE_KEY with the private key of your account.

Step 7: Retrieve Account Balance

If you want to retrieve the account balance, you can use w3.eth.getBalance() method. Here is a code that you can use for retrieving the account balance:

balance = w3.eth.getBalance(account.address) print(f"Account balance: {w3.fromWei(balance, 'ether')} ETH")

Keep in mind that this code will offer your account balance details in Ether.

Step 8: Interact with Smart Contracts

With Web3.py, you can interact with the smart contracts on the Ethereum network. To interact with smart contracts on the Ethereum network with Web3.py, you'll need the contract's address and ABI (Application Binary Interface). The ABI defines the function of the contract, its arguments, and its return type.

Here is a code that you can use for creating a contract instance:

contract_address = 'CONTRACT_ADDRESS' contract_abi=[...] # Your contract ABI contract=w3.eth.contract(address=contract_address, abi=contract_abi)

To customize the code, you will need your actual contract address and ABI. Now replace CONTRACT_ADDRESS with the contract address that you have and add the contract's ABI as a Python list in the contract_abi variable.

After the contract instance is done, you will get to interact with the functions as well. For instance, if your contract has a getBalance() function that offers you the balance of the address, you can use the following code to call this function. This code will help you retrieve the balance from the smart contract.

balance=contract.functions.getBalance(account.address).call() print(f"Contract balance: {balance}")

Step 9: Send Transactions

Now, you can send transactions to a smart contract. For that, you will be required to sign the transaction via the private key of your account.

If you have the transfer() function in the contract, it will allow you to transfer tokens from one address to another with the use of code.

The code will mainly construct and sign a transaction. It will send the transaction to the Ethereum network. Once the transaction is committed, you will see the transaction hash.

Here is the code used for the transaction:

to_address = 'RECIPIENT_ADDRESS' amount=100 # Number of tokens to transfer transaction=contract.functions.transfer(to_address, amount).buildTransaction({ 'from': account.address, 'nonce': w3.eth.getTransactionCount(account.address), 'gas': 200000, 'gasPrice': w3.toWei('40', 'gwei') }) signed_txn=w3.eth.account.signTransaction(transaction, account.privateKey) transaction_hash=w3.eth.sendRawTransaction(signed_txn.rawTransaction) print(f"Transaction sent: {transaction_hash.hex()}")

For customizing this code, you need to replace RECIPIENT_ADDRESS with the Ethereum address of the receiver. For the transaction, you also need to change the gas and gasPrice values based on your project requirements.

Step 10: Handle Transaction Receipts

Once the transaction is completed, you will get a receipt with all the information about its status and events emitted by the contract.

Here is a transaction hash that you can use for fetching the receipt:

transaction_receipt = w3.eth.getTransactionReceipt(transaction_hash) print(f"Transaction status: {transaction_receipt['status']}") print(f"Gas used: {transaction_receipt['gasUsed']}")

Once you add the code and run it, you will get transaction status (either 0 or 1) as well as details about the amount of gas used.

Congratulation! You have just finished a web3.py tutorial for interacting with the Ethereum network.

While this tutorial is user-friendly, you still need to customize the code based on real data to run it smoothly.

What is Web3.py?

It is a Python library, used by developers for interacting with the Ethereum blockchain. Web3.py offers a simple and user-friendly interface for interacting with smart contracts. It also helps in managing Ethereum accounts, committing transactions, and reading the blockchain data.

How to Install Web3.py?

Installing web3.py is easier with the Python package manager or pip. You can simply copy and paste the installation command in the command prompt and run this command. Here is the code for installation: pip install web3.

How to Connect to the Ethereum Network with Web3.py?

Connecting with the Ethereum network is easy, you can do it by signing into a third-party connection provider like Infura or launching your local provider. To sign up for the account, just open https://infura.io/, you will be able to create a project and get your Infura project ID.

Now, copy and paste in the command prompt, this code and you will be able to establish the connection.

from web3 import Web3 w3=Web3(Web3.HTTPProvider('https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID'))

The code just offers you a template, so make sure to replace the data of your actual project. In this code, you will be required to replace YOUR_INFURA_PROJECT_ID with the Infura project ID of your account.

How to Check If the Connection to the Ethereum Network Is Successful?

For quality assurance, you can check the network ID using the w3.net.version property.

Here is a code for quality assurance:

network_id = w3.net.version print(f"Connected to network with ID: {network_id}")

How to Interact with Smart Contracts Via Web3.py?

You just need the contract address and Abi to interact with smart contracts. To create the contract instance, here is a code that you can use:

contract = w3.eth.contract(address=contract_address, abi=contract_abi)

For your project, make sure to replace contract_address with the contract address and also add the contract's ABI.

How to send transactions with Web3.py?

For committing a transaction, sign the transaction by using a private key of your Ethereum account. Use the code below and then adjust the details according to the transaction requirement:

transaction = contract.functions.transfer(to_address, amount).buildTransaction({ 'from': account_address, 'nonce': w3.eth.getTransactionCount(account_address), 'gas': 200000, 'gasPrice': w3.toWei('40', 'gwei') }) signed_txn=w3.eth.account.signTransaction(transaction, private_key) transaction_hash=w3.eth.sendRawTransaction(signed_txn.rawTransaction)

For customization, replace to_address with the address of the transaction receiver. Then change the gas and gas price values accordingly, and finally add the account address and sign it off with the private key.

How Can I Retrieve Transaction Receipts Using Web3.Py?

Once the transaction is completed, you can get the transaction receipt with the transaction hash. Here is an example of retrieving the transaction receipt:

transaction_receipt = w3.eth.getTransactionReceipt(transaction_hash)

Within the transaction_receipt object, you will get some basic details like the transaction status and the amount of gas used.