Python - The Practical Guide

Let me introduce you to this module and to what you'll learn inside of it.

Before we start setting up a local environment, let's have a look at the command line, the "REPL", once again. What is the REPL, how does it work and which data types do we actually have in Python?

Variables are a very important core concept not only in Python but in any programming language. Variables are data containers defined by us which allow us to store information in it. Time to find out more about these!

We will use numbers in our Blockchain, so let's see which numbers are supported in Python and how we can work with these!

Operators are very useful when writing our code as they allow us to add, subtract, multiply and divide data in our code. Let's have a look at how we can manage these arithmetic operations in Python!

We understood the basics about numbers but there is one special behaviour that we should also have a look at before we continue: Let me show you how the binary system our computers work with impacts the result of certain calculations!

In addition to numbers, we can of course also work with strings in Python. Fortunately these are really easy to use, so let's have a look!

Numbers and strings are fine but we want to build a Blockchain right? For that we will create a list or an array as you might know it from other programming languages. Let me show you which values lists in Python can hold and how we can access these list items!

Typically you won't hardcode your list items, so we need a way to dynamically add and delete list items. Let me show you how this can easily be done in Python with special built-in functions - ".append" and ".pop"!

The very basics are set - now it's time to work on the Blockchain! Let's leave the REPL for the moment, use a real development environment and start building our Blockchain. But what do we want to achieve, how should our Blockchain work?

For our local environment we want to write code in text files. An IDE (Integrated Development Environment) will make writing code a lot easier and a lot more fun. Let me show you how to get started with Visual Studio Code, the IDE I'll use throughout this course, in this video!

Functions are a very important core concept of any programming language as they allow us to define code which is executed whenever we want. Let me show you the syntax of functions in Python and let's also apply some functions to do the first steps in our Blockchain.

What are "Blocks" in a Blockchain?

We started adding values to our Blockchain, but until now we always refer to the first value in our list. Let me show you how we can easily access the last item in our list, because to make our Blockchain work correctly we need to be able to do so!

We understood how functions work in general but they can do more: Functions can receive arguments. Let me show you why arguments are an important feature of functions and how such arguments can be a big help in our Blockchain!

Let's have a look at another powerful feature of functions: The "return" keyword which allows us to return any value once our function gets called. Let's then also add this keyword to our Blockchain!

We already learned how to use function arguments but we can also use default arguments. These will be used if you call a function without passing the data for that specific argument. Time to find out more about that in this lecture!

We saw that functions are really powerful, but there is one last important feature we should understand: Keyword arguments (kwargs). These arguments allow us to call a function in a different, more flexible way, so let's see why kwargs can be helpful in our Blockchain!

The Blockchain evolves, but wouldn't it be great if the user could actually enter values? Let's see how we can easily implement that feature by adding the "input" function (a special built-in function) to our code!

Currently, we are repeating ourselves as we call the same code again and again. Once we dive into loops in the next module this issue can easily be fixed but we can already improve our code at this stage by creating an additional function. Let's do this!

We achieved a lot up to this point and we implicitly used a special concept: The Variable Scope. This defines where our variable is available in our code, anywhere or only inside the function where it was defined. Time to dive deeper into that!

A lot of the basics were covered and we'll dive a lot deeper throughout the course. In addition to that it's always worth to have a look at the official docs so let me quickly guide you through these!

We had a look at the PEPs and saw that Python comes with best practices regarding the way we should comment our code. Let me show you how to add comments to your code and let's also have a look at Doc Strings.

When working in Python, you might end up with relatively long code. Adding line breaks can be very helpful to bring more structure into your code, so let me show you how to add these!

Let me wrap this module up and summarize what you learned thus far.

Attached to this lecture, you find the module source code. Inside of the lecture, you can find some helpful links.

Let me introduce you to this module and to what you'll learn inside of it.

Loops allow us to repeat code: We write the code once and then we define conditions to run the code multiple times. Let me show you how we can work with loops in Python!

Time to add a "for" loop to our Blockchain to loop through our list items!

We added the "for" loop, but what about the "while" loop? Let's use this loop to create a user interface which offers multiple options for our users to choose from.

How to close the REPL properly.

Besides loops, conditionals are another core concept of each programming language. Time to have a look at "if-else" to understand how we can use it to execute different code depending on the user input!

The theory behind "if" is clear now, so let's implement it in our Blockchain!

The "while" loop, including the "if-else", statement only supports two cases at the moment. But what if the user adds invalid input or if we want our users to be able to quit the loop? For that, we need "elif", so let's dive into that!

What if we want to quit the loop upon user input, so before the loop is actually finished? Then we need the "break" keyword. Let's have a look at this and additionally at the "continue" keyword which allows us to skip one iteration only!

We had a closer look at loops and conditionals throughout this module, so let's use this knowledge to make our code a bit leaner and cleaner!

We had a look at Boolean Operators already, but we didn't have a look at all of these. Specifically, let's find out more about "!=", "is" and "in" in this video!

We understood the "is" and "in" keywords, but what if we you just want to check the opposite? Then we can add the "not" keyword, so let's see how this works!

Time to have a look at three additional important features we should know: Let's see how two of these - "and" & "or" - work in this lecture!

In addition to "and" & "or", grouping conditionals is also very important to ensure our conditionals work correctly. Let me show you how this works!

In case you already know other programming languages you might also know the "switch" statement. Can we also use this in Python?

At the moment we can manipulate past transactions in our Blockchain, which definitely shouldn't be possible. Let me show you how we can prevent such manipulations!

It's important that we can ensure the validity of our blockchain. Here's the first important building block.

We added the Blockchain verification, but I also wanted to show you an alternative to the "break" keyword we use in our code. Let's see how we can add conditions to a "while" loop to get rid of "break"!

One additional and good to know feature of "while" and "for" loops is the possibility to specify an "else" case. Time to have a look at that in this lecture!

"for" loops in other programming languages come with a built-in index function. Unfortunately Python doesn't ship with such a feature, but turns out that the "range" function can also get us there!

Let me wrap this module up and summarize what you learned thus far.

Attached to this lecture, you find the module source code. Inside of the lecture, you can find some helpful links.

Let me introduce you to this module and to what you'll learn inside of it.

Before we dive deeper, let's have another look at the general logic of a Blockchain and how transactions should be handled in it. What information should be transferred, how should it be transferred and what about the miners of a new block?

Which data structures do we have? In the end, all data structures will be iterables so let me give you an overview of iterables in this lecture!

The core data structures/ iterables are clear now, but which data structure should we use for our Blockchain? Let's ensure to choose the right one!

Let's go back to our Blockchain and work on our transactions. For that, dictionaries and tuples will be really helpful, so time to have a look at these now!

Transactions are a crucial part of a cryptocurrency blockchain. Here's a brief summary.

We added the tuple to our Blockchain, but now we need to pass on that data. We have multiple ways to do that, unpacking the tuple is one of our options!

The transactions are one important core concept of a Blockchain, the other one is the actual mining of a block. Time to implement the block data structure to our Blockchain!

Let's continue the work on our mine-block functionality. To make our Blockchain work correctly, we need to be able to add the hash of the previous block to our new block. Time to learn how we can do this!

We implemented a basic hashing algorithm, but there is a nice alternative to that. List Comprehensions! Let me show you what these are and how we can use them to create our hashing algorithm.

We understood List Comprehensions, but what are Dict Comprehensions then? Although we won't use them very often, let me also quickly introduce you to these!

Back to List Comprehensions, because wouldn't it be great if we could combine these with "if"? Turns out this is possible!

With our newly gained knowledge, we should go back to our Blockchain now and improve our validation logic!

One feature we didn't consider so far is the fact that we want to manage a list of participants - so senders and recipients. Because in the end, our Blockchain should become a network, so let's work on that list now!

We can output our participants, but wouldn't it be great if we would know how many coins each participant has? Additionally, we have a little flaw in our code as we never reset our transactions. Time to change that!

Our transaction structure works now, but one very important thing is missing: We don't have any coins in our system up to now! We should definitely change that so let's make sure that miners receive a reward for mining a block. And this reward should be coins!

We added the mining reward and we can get the balance for our participants but we should also make sure to verify our transactions! 

The Blockchain takes shape, time for some theory now: Lists in Python are copied by reference and not by value - what does that mean and which implications does this have for your code? Let me explain the difference between copying "by reference and "by value" in this lecture!

We used the "range" selector to copy our list. Let's have a closer look at some additional application areas of this selector!

One more thing about "by reference" vs "by value": What happens if we have a complex data structure which includes other complex data structures? Then we need to understand the difference between shallow and deep copies!

Do you remember the "is" & "==" boolean operators from the last module? How do these behave in relation to "by reference" and "by value"? Let me show you an example to make sure we understand this!

Let's go back to the official docs: There we can find a lot of methods that we can use to call a list and manipulate it. Let's apply some of these methods and see how we can use them in practice.

Two more important functions before we are almost done with this module: "all" & "any". Let me show you how these work and what we can use them for in this lecture!

We learned a lot about iterables/ data structures. Let me summarize what we learned about these and what we can use them for!

Let me wrap this module up and summarize what you learned thus far.

Attached to this lecture, you find the module source code. Inside of the lecture, you can find some helpful links.

Let me introduce you to this module and to what you'll learn inside of it.

Before we dive deeper, let's have a look at the differences between strings and lists. Both might seem equal in some cases, but actually both are totally different data structures.

With the differences between strings and lists understood, it's time to have a look at a very important string method: "format". As the name indicates, this method helps us to output nicely formatted text, definitely something very useful for our Blockchain!

What if we have two equal characters in our string with two different meanings, a single quotation mark (') for example? How can we tell Python when the single quotation mark is supposed to open/ close the string and when it should behave like a normal single quotation mark does, for example when writing 'I'm Max'?

You're probably using Python 3.6 and thankfully this version comes with a very convenient way to format strings. Let me show you which way this is in that lecture!

With the basics of string formatting being set, it's time to also apply it to our Blockchain. The balance output for example is not formatted nicely at the moment, so let's work on that!

Do you remember List Comprehensions, which for example allowed us to apply a specific operation to all items in a list? In this lecture we'll have a look at the "map" function, an alternative to these List Comprehensions.

You might have heard about Lambda functions in other programming languages. We can also use Lambda functions in Python so let me show you how these work in this lecture!

With the Lamba function in mind, we can also have a look at a very useful built-in function in Python: The "reduce" function, which allows us to reduce lists, for example by summing up the values of a list. Let's dive deeper into that!

We already used the "format" function, but isn't it strange that we can pass as many arguments as we want to that method? Let's see how we can write such a method on our own!

Before we conclude this module, we have to fix a little bug: Currently our block holds more than one value in case multiple transactions occur. Using the "sum" function will easily fix this for us!

Let me wrap this module up and summarize what you learned thus far.

Attached to this lecture, you find the module source code. Inside of the lecture, you can find some helpful links.

Let me introduce you to this module and to what you'll learn inside of it.

Let's start this module by having a look at the Python Standard Library, where we will see that Python ships with a ton of default built-in packages & features. Time to understand how we can use these packages in our project!

We imported one package, but what happened behind the scenes when we imported it? Time to have a closer look at that!

We are already creating a pseudo-hash, but at the moment this hash is readable, so we should work on that. Let's learn how we can use "hashlib" (another standard library package) to create a more secure hash now!

What's a Hash? Let's take a closer look.

We already learned that we have different ways to import packages. So far we always import the package names and then we're calling the functions we want to use from these packages. Time to have a look at other methods!

The Proof of Work is a very important Blockchain concept as it makes mining new blocks more challenging. Let's dive deeper into the Proof of Work, how it works and how it makes our Blockchain more secure!

Here's a written summary of the "Proof of Work" concept.

We understood the theory behind the Proof of Work, let me now show you how we can add it to our Blockchain!

With the Proof of Work being added, we now should use it whenever we mine a new block. Let's do that!

We improved the way our hash is generated, but the mechanism we apply has one important flaw. Time to fix that in this lecture!

We learned a lot about importing packages throughout this module, but exporting is of course also possible. Let's improve the structure of our code and split it up into separate ".py" files!

Let me wrap this module up and summarize what you learned thus far.

Attached to this lecture, you find the module source code. Inside of the lecture, you can find some helpful links.

Let me introduce you to this module and to what you'll learn inside of it.

Accessing files in Python thankfully is really simple. Let's learn how we can open files with the "open" method and also how we can write data to a file in this lecture!

Opening files and writing data to a file works now, but of course we also want to be able to read data. Time to learn how to do this by changing the "mode"!

So far we only added single line content to our file, but you also might want to add multi-line content. Let's understand how we can easily do that by adding a special escape character!

In case our program continues after accessing the file, we have to make sure to call the "close" method. Turns out that there is a more convenient helper keyword which manages the file opening and closing for us - "with". Time to add that! 

We learned all about the basics regarding file access. Time to use this knowledge in our Blockchain!

Up to now, we are only storing string data in our file and converting it back to Python data unfortunately is an issue. Thankfully we already know a library which can help us here - the .json library!

Besides .json we have an alternative approach to write and load data to and from a text file: Pickle converts Python data to binary data which is stored in a file and vice versa. Let's also see how this works!

We have the .json library and we have Pickle but which one should we use? Let's compare both in this lecture!

We will use the .json library in our Blockchain, so let's change our code back to this library!

In the next module we'll dive into debugging and error handling. Let me show you one flaw which already indicates why proper error handling definitely is an important topic!

Let me wrap this module up and summarize what you learned thus far.

Attached to this lecture, you find the module source code. Inside of the lecture, you can find some helpful links.

Let me introduce you to this module and to what you'll learn inside of it.

Official debugging solutions are very helpful when it comes to finding logical errors in our code. Let's see how we can use these at the example of Visual Studio Code!

Using the debugger is great for finding logical errors, but we might also have syntax errors. Let's see how we can find these!

Another error type that can occur are runtime errors. Let's see how we can work on these by adding the "try" block statement offered by Python! 

We learned how we can handle errors, but which errors should we actually handle? Because handling any type of error is probably not the best idea. Let me show you why!

We learned a lot about errors, so now it's time to also add error handlers to our project!

There's one type of error we're not handling yet ...

Let me wrap this module up and summarize what you learned thus far.

Attached to this lecture, you find the module source code. Inside of the lecture, you can find some helpful links.

Let me introduce you to this module and to what you'll learn inside of it.

Before we dive deeper: What is Object Oriented Programming (OOP) actually? Let me introduce you to the topic to understand our current code implementation and why OOP will help us to improve the current status.

We learned that classes are very important in OOP. Therefore it's time to dive deeper into classes in this lecture!

Let's dive into the basics of classes in a practical example!

What's the difference between a class, an instance and a dictionary? At first sight these might look quite similar, so let's take a closer look to understand the differences between these concepts!

We learned that we can create multiple instances of a class. Time to dive deeper into class attributes in this lecture!

We learned that classes have a lot of advantages and that we are also able to create multiple instances of a class. Let me now explain why it is also important to understand what constructor & instance attributes are!

Let me introduce some special methods which allow us to look into the content of our objects and to print information to the console according to our needs!

Time to dive into a more advanced concept which is related to private and public attributes in a class. Let me introduce "encapsulation" in this lecture!

Let's have a look at another core concept of OOP - "inheritance" - in this lecture!

We understood the theory, but wouldn't it be better to apply these concepts to our Blockchain? I think it would, so let's plan our Blockchain classes in this lecture!

We have to add a lot of classes to our project so time to start with the first one in this lecture: The "Block" class!

There is an issue with our current "Block" class implementation.

We cannot hash our block as we cannot turn objects into .json. Let's fix this issue by converting the block into a supported data type!

With the "Block" class being added, it's time to do the same for the "Transaction" class. This class is strongly connected to the blocks and actually the core part of the data we are using. So let's continue!

Before we continue adding other classes, let's see what we can improve in our Blockchain. In connection with that, we'll also see why the previously learned concept of "inheritance" can be very helpful...

Let's move onwards and create a "Verification" class. This should become a helper class bundling some verification/ utility related methods used in the Blockchain which can be outsourced!

"Node" is the next class to be added to our code. This class should include the entire "interactions" in our Blockchain, so our "while" loop and all functions related to fetching user input. Let's do it!

Until now, the Blockchain is one file within a couple of functions and variables. Time to change that by turning the entire Blockchain into a class!

We already initialised the "Node" class, but we have to make some adjustments to it. Let's do that in this video!

Working with classes means we have different choices regarding types but also regarding the methods and attributes of these classes. Let's have a look at the difference between "Instance", "Class" and "Static Methods" & "Attributes" in this lecture!

With the theory out of the way, it's time to apply the previously learned methods to our project!

We already talked about private attributes. Let's see if we can also use these in our project!

We worked on private attributes in the last lecture, which brings us to another interesting class-related feature: Attributes vs properties. Let me show you the differences between these two in this lecture!

Let me wrap this module up and summarize what you learned thus far.

Attached to this lecture, you find the module source code. Inside of the lecture, you can find some helpful links.

Let me introduce you to this module and to what you'll learn inside of it.

Before we dive deeper, let's have a look at our code and see if we can reorganize it. Because maybe we can put certain files into their own folder, which we can then actually treat like a module...

We already have a "__pycache__" folder, which was generated automatically by Python. Let me explain why we have this folder and why it's important for Python to work correctly!

When working with multiple files or modules and when creating helper packages you might want to comment your modules. Let me show you how you can do this!

How can we control what is exported by a module? In Python this is a bit difficult, so let me lighten things up in this lecture!

Let's dive into another very important variable offered by Python: The "__name__" variable!

Enough about our own modules, let's have a look at third party modules and what we could use these for. For example, we are currently not checking whether our added or mined transactions are valid. Maybe a private and a public key might fix this issue... 

We want to add a new package, giving us the cryptography features we need to verify our transactions. Let's learn how we can use the official Python package manager ("pip") to install a new package on our system!

More on virtual environments and how to use them.

With "pycrypto" being installed, it's time to use it in our project. This also means that we basically add a wallet to our project, so let's dive into it!

Generating keys is working fine, but we should also present our keys to the user who runs/ owns the node. Let's add that feature!

The wallet basically works, but at the moment we are passing our wallet with both a private and a public key of "none" to the Blockchain if we don't want to create a key. This behaviour should be prevented!

At the moment we are creating keys, but once we shut our application down they are gone as the keys are only created in memory. Let's store the keys in files and add the code needed for that in this lecture!

We got our public key, but we are not signing anything yet. Let's add two methods in our wallet, one for creating a signature to sign the transaction and one for verifying these!

We are receiving a signature, now it's time to also use it in our transactions!

We are almost done with this module, now it's time to ensure that we can also verify our transaction. Let's do that in this lecture!

Let's add two more improvements to ensure our verification logic works correctly!

Let me wrap this module up and summarize what you learned thus far.

Attached to this lecture, you find the module source code. Inside of the lecture, you can find some helpful links.