Python - The Practical Guide

Learn Python from the ground up and use Python to build a hands-on project from scratch!

Start

Want to learn Python "on the job" whilst building an exciting course project? This course is for you!

This is a highly practice-oriented Python course that teaches you Python from scratch - no prior programming experience required!

Python is probably THE most trending programming language you can learn these days!

It's very popular because it's easy to learn and use, runs on all operating systems and allows you to build a broad variety of programs: Be that web applications, desktop applications, utility scripts or using it for data science and machine learning.

In this course, you'll learn Python from scratch - and you'll do so whilst building your own Blockchain and Cryptocurrency. These are of course also highly trending topics and not a lot of people understand what a Blockchain really is. As a nice side-effect, you will know how a Blockchain works once you completed this course. It's an exciting course project that allows you to learn and apply Python to something you know and you can use.

Why Python?

As written above, Python is both easy-to-use and extremely versatile and powerful at the same time. Certainly not the worst combination. If you check it on Google trends (and compare it to other programming languages), you'll see that it's very popular these days.

It's being used by almost any important company - be that Google, Amazon or Facebook. It's used to run web applications, scripts, desktop programs and machine learning algorithms. This course sets the basics for all these use-cases!

Why Blockchain?

I believe that you learn something best if you directly apply it to a real-world project. And the Blockchain technology is an exciting trend which is there to stay. In this course, you'll learn a lot about the core concepts of the Blockchain and you'll see how Python can be used for the many aspects that make up a Blockchain and Cryptocurrency.

In my opinion, a perfect course project is challenging, interesting, something you know from real-life but also not overly complex. And that's all the case for the Blockchain! It poses some nice challenges where a lot of different Python features can be used to overcome them. It also is something we hear about all the time and yet no one knows how it works. And we can dive into the core Blockchain concepts without spending 100+ hours working on it.

As written above, Python is both easy-to-use and extremely versatile and powerful at the same time. Certainly not the worst combination. If you check it on Google trends (and compare it to other programming languages), you'll see that it's very popular these days.

It's being used by almost any important company - be that Google, Amazon or Facebook. It's used to run web applications, scripts, desktop programs and machine learning algorithms. This course sets the basics for all these use-cases!

What's in the course?

Great question! Here's a brief summary:

  • A summary of Python and the Blockchain technology
  • All the base Python syntax you need to know (variables, operators, functions, ...)
  • Loops and conditional statements
  • More complex data structures like tuples or dictionaries
  • A closer look at built-in functions and the standard library Python ships with
  • String manipulation
  • How to work with files
  • Error handling
  • Debugging
  • Object-oriented programming with classes and inheritance
  • Internal & external modules (packages)
  • How to spin up an Http server with the Flask package
  • Handling Http requests (sending & receiving)
  • And more!

Is this course for you?

It's for you if ...

  • You want to get into programming => Python is a great "first language" since it's easy to learn and very versatile
  • You want to broaden your horizon => Are you a web developer? Want to learn something new? Here you go!
  • You're interested in Python for web development => This course will teach you Python in general but there are two modules where we'll also dive into web development a bit
  • You're interested in the Blockchain technology => You'll learn the core concepts of it as a side-effect of this course!
  • You know Python but want to practice it => The course project is challenging and taken from real-life - there probably is no better practice

Section: Getting Started

1. Introduction (1:51) Preview
2. What is Python? (5:07) Preview
3. Setting Up Python (3:11) Preview
4. Writing our First Python Code (5:05) Preview
5. Join our Online Learning Community (1:00) Preview
6. What is the Blockchain? (6:48) Preview
7. Course Outline (4:41) Preview
8. Python Alternatives (3:58) Preview
9. Understanding the Python Versions (2:22) Preview
10. How To Get The Most Out Of This Course (3:27) Preview
11. Useful Resources & Links (1:00) Preview

Section: Diving Into the Basics of Python

12. Module Introduction (2:16) Preview
13. Understanding the REPL and Data Types (4:25) Preview
14. Working with Variables (4:46)
15. Working with Numbers (5:36)
16. Using Operators (3:48)
17. Understanding a "Special" Behaviour when Working with Numbers (3:35)
18. Working with Strings (2:18)
19. Working with Lists (5:09)
20. Adding & Removing List Items (3:02)
21. Preparing the Blockchain - The Theory (2:02)
22. Installing our IDE (5:17)
23. Using Functions to Add List Items (6:45)
24. Accessing the Last List Item (3:24)
25. Adding Arguments to Functions (2:36)
26. Understanding the "return" Keyword (3:57)
27. Using Default Arguments (4:06)
28. Working with Keyword Arguments (2:59)
29. Using the "input" Function (3:00)
30. Avoiding Repetitive Code Execution (2:06)
31. Understanding the Variable Scope (6:49)
32. Exploring the Official Documentation (2:25)
33. Adding Comments and Doc Strings (4:20)
34. Structuring Multi Line Code in Python (1:56)
35. Assignment - Basics (Problem) (1:34)
36. Assignment - Basics (Solution) (11:24)
37. Wrap Up (3:28)
38. Useful Resources & Links (1:00)

Section: Working with Loops & Conditionals

39. Module Introduction (1:38)
40. Understanding Loops - Theory (2:55)
41. Creating a "for" Loop (3:02)
42. Creating a "while" Loop (3:33)
43. Closing the REPL (1:00)
44. Understanding Conditionals - Theory (2:01)
45. Adding "if-else" to our Blockchain (7:45)
46. Working with "elif" (3:43)
47. Understanding "break" & "continue" (3:31)
48. Improving our Code with Loops & Conditionals (6:39)
49. Understanding Boolean Operators - "is" & "in" (3:37)
50. The "not" Keyword (1:17)
51. Understanding "and" and "or" (2:26)
52. Grouping Conditionals (3:22)
53. What About "switch" in Python? (0:41)
54. Verifying our Blockchain (13:10)
55. Blockchain Theory: Understanding Blockchain Verification (1:00)
56. Using Conditions inside the "while" Loop (1:56)
57. Using "else" in Loops (2:07)
58. Adding the "range" Function (7:09)
59. Assignment - Loops & Conditionals (Problem) (2:50)
60. Assignment - Loops & Conditionals (Solution) (7:52)
61. Wrap Up (3:11)
62. Useful Resources & Links (1:00)

Section: Understanding Complex Data Structures

63. Module Introduction (2:50)
64. Understanding the Required Data Structure for our Blockchain (7:03)
65. Working with Iterables (5:01)
66. Choosing the Right Datastructure (2:55)
67. Transactions with Dictionaries & Tuples (7:46)
68. Blockchain Theory: Understanding Transactions (1:00)
69. Unpacking the Tuple (3:20)
70. Mining Blocks (6:16)
71. Hashing Previous Blocks (6:23)
72. Understanding List Comprehensions (5:48)
73. And What are Dict Comprehensions? (1:39)
74. Combining List Comprehensions & "if" (2:53)
75. Improving the Blockchain Validation Logic (8:20)
76. Managing a List of Participants in the Blockchain (3:33)
77. Calculating Balances (7:46)
78. Rewarding the Miners of our Blockchain (3:23)
79. Verifying Transactions (5:45)
80. Understanding Reference vs Value Copying (7:07)
81. Working with the Range Selector (5:42)
82. Understanding Shallow vs Deep Copies (2:42)
83. Comparing "is" & "==" (1:36)
84. Diving Deeper Into Iterable Methods (7:27)
85. Understanding the "all" & "any" Functions (7:35)
86. Comparing Iterables (6:46)
87. Assignment - Complex Datastructures (Problem) (1:27)
88. Assignment - Complex Datastructures (Solution) (7:17)
89. Wrap Up (3:17)
90. Useful Resources & Links (1:00)

Section: Working with Functions & Strings

91. Module Introduction (1:30)
92. Comparing Strings & Lists (3:57)
93. Understanding the "format" Method (8:11)
94. Escaping Characters (1:47)
95. Formatting Strings Conveniently with "f" (1:27)
96. Adding String Formatting to our Project (2:00)
97. Understanding the "map" Function (2:53)
98. Working with Lambda Functions (2:13)
99. Reducing Lists (7:40)
100. Unpacking Function Arguments (6:32)
101. Assignment - Functions & Strings (Problem) (2:13)
102. Assignment - Functions & Strings (Solution)) (5:07)
103. Fixing a Bug (4:13)
104. Wrap Up (1:30)
105. Useful Resources & Links (1:00)

Section: Working with the Python Standard Library

106. Module Introduction (1:42)
107. Exploring the Python Standard Library (2:12)
108. Importing Packages - Theory (4:18)
109. Importing "hashlib" to Create a Unique Hash (7:14)
110. Using Other Import Syntaxes (1:47)
111. The "Proof of Work" (6:53)
112. Blockchain Theory: Understanding the "Proof of Work" (1:00)
113. Adding the Proof of Work to our Blockchain (5:48)
114. Including the Proof of Work in our Mining Function (7:49)
115. Fixing a Hash Order Fault (6:22)
116. Splitting Up our Code (4:33)
117. Assignment -The Standard Library (Problem) (1:41)
118. Assignment -The Standard Library (Solution) (3:46)
119. Wrap Up (2:02)
120. Useful Resources & Links (1:00)

Section: Working with Files

121. Module Introduction (1:44)
122. Handling File Access (5:44)
123. Reading Data From a File (2:33)
124. Reading Multi-Line Content (5:52)
125. Using the "with" Block Statement (2:57)
126. Adding File Access to our Blockchain (8:39)
127. Converting Strings Into Python Objects (16:01)
128. Storing Data with Pickle (6:05)
129. Comparing Pickle & JSON (1:05)
130. Changing the Project Back to JSON (2:30)
131. Why we need Proper Error Handling (0:46)
132. Assignment - Working with Files (Problem) (1:49)
133. Assignment - Working with Files (Solution) (10:21)
134. Wrap Up (1:17)
135. Useful Resources & Links (1:00)

Section: Handling Errors

136. Module Introduction (0:57)
137. Finding Logical Errors with the Debugger (5:53)
138. Finding Syntax Errors (1:40)
139. Using "try" to Find Runtime Errors (4:33)
140. Which Errors Should you Handle? (3:01)
141. Adding Error Handlers to our Blockchain (2:32)
142. Handling Empty File Errors (1:00)
143. Wrap Up (1:49)
144. Useful Resources & Links (1:00)

Section: Object Oriented Programming

145. Module Introduction (1:12)
146. What is Object Oriented Programming? (2:12)
147. Understanding Classes (1:24)
148. Creating a Class (5:09)
149. Comparing Classes, Instances & Dictionaries (2:44)
150. Understanding Class Attributes (3:37)
151. Constructor & Instance Attributes (4:20)
152. Printing Classes with Special Methods (6:04)
153. Private & Public Attributes (4:39)
154. Understanding Inheritance (8:46)
155. Planning Blockchain Classes (1:32)
156. Adding a "Block" Class to the BlockchainAdding a "Block" Class to the Blockchain (11:06)
157. An Issue with Default Arguments (1:00)
158. Saving Custom Class Objects via .json (4:49)
159. Adding a "Transaction" Class (17:46)
160. Inheritance in Action (5:43)
161. Adding a "Verification" Helper Class (10:03)
162. Initialising the "Node" Class (4:51)
163. Turning the Blockchain Into a Class (7:30)
164. Adding a "Node" Class (11:11)
165. Understanding "Instance" vs "Class" vs "Static Methods" & "Attributes" (3:39)
166. Using "Static" & "Class" Methods on the "Verification" Class (3:44)
167. Using Private Attributes in the Blockchain (3:43)
168. Properties vs Attributes (5:20)
169. Assignment - Object Oriented Programming (Problem) (1:45)
170. Assignment - Object Oriented Programming (Solution) (9:44)
171. Wrap Up (2:15)
172. Useful Resources & Links (1:00)

Section: Modules

173. Module Introduction (1:41)
174. Creating Packages - Module Bundles (4:40)
175. The "pycache" Folder (0:43)
176. Module Docstrings (0:51)
177. Controlling Exports (5:36)
178. Understanding Execution Context & "__name__" (4:11)
179. Why we Need a Private & Public Key Transaction Protection (4:25)
180. Using Anaconda to Install Third Party Packages (6:23)
181. Using Virtual Environments (1:00)
182. Use Pycryptodome instead of PyCrypto (1:00)
183. Generating Keys with a Third Party Package (6:21)
184. Connecting the Node & the Wallet (6:15)
185. Generating Keys on the Node (4:06)
186. Saving & Loading Keys to Files (8:24)
187. Creating Transaction Signatures (6:24)
188. Adding a Signature to our Transactions (2:42)
189. Verifying Signatures (6:49)
190. Improving the Verification Logic (5:41)
191. Wrap Up (1:21)
192. Useful Resources & Links (1:00)

Section: Adding HTTP with Flask

193. Module Introduction (2:04)
194. HTTP Requests - The Basics (5:40)
195. Understanding API-Endpoints/ URLs (3:32)
196. Data Formats (3:18)
197. Planning our API (2:04)
198. Setting Up our Environment with Flask (10:08)
199. Adding our First Route (10:09)
200. Installing Postman (2:20)
201. Adding a POST Request (7:21)
202. Setting Up Routes to Manage our Wallet (8:23)
203. Returning Funds (5:43)
204. Adding Transactions (11:26)
205. Fetching Open Transactions (3:14)
206. Testing the Public Key (1:46)
207. Adding a User Interface (2:41)
208. Optional: Configuring our UI - Creating a Wallet (13:17)
209. Optional: Configuring our UI - Loading a Wallet and Adding Mining & Transactions (11:58)
210. Exploring our UI (2:45)
211. Wrap Up (1:52)
212. Useful Resources & Links (1:00)

Section: The Node Network

213. Module Introduction (1:42)
214. Adding Node Management Methods to the Blockchain (7:18)
215. Setting Up Routes to Add Nodes (7:40)
216. Adding a Remove Node Route (5:17)
217. Adding "get_Nodes" to get all Nodes (1:19)
218. Attaching a Node User Interface (11:07)
219. Running Multiple Nodes (11:19)
220. Sending Requests from within Python (10:36)
221. Broadcasting Transactions - Adding the Function & Route (12:06)
222. Broadcasting Transactions - Testing & Fixing Errors (5:51)
223. Broadcasting New Blocks: Adding the Function & Route (11:12)
224. Broadcasting New Blocks: Informing the Peer Nodes (9:53)
225. Broadcasting Transactions: Testing (3:28)
226. Solving Conflicts (5:32)
227. Understanding Consensus (3:28)
228. Finding Conflicts (9:34)
229. Implementing a Consensus Algorithm (17:20)
230. Testing Consensus (5:49)
231. Wrap Up (1:01)
232. Useful Resources & Links (1:00)

Section: Next Steps and Course Roundup

233. Module Introduction (0:46)
234. Don't Forget PEP 8 (2:46)
235. Using PEP 8 (8:29)
236. Using Comments (1:01)
237. Diving Deeper Into Python (5:07)
238. Improving the Blockchain (10:02)
239. Congratulations (0:57)
240. Further Links (1:00)

Course Instructor

Image

Maximilian Schwarzmüller

As a self-taught professional I really know the hard parts and the difficult topics when learning new or improving on already-known languages. This background and experience enable me to focus on the most relevant key concepts and topics. My track record of many 5-star rated courses, more than 1,000,000 students worldwide as well as a successful YouTube channel is the best proof for that.

The most rewarding experience for me is to see how people find new, better jobs, build awesome web applications, work on amazing projects or simply enjoy their hobby with the help of my content. That's why, together with Manuel Lorenz, I founded Academind to offer the best possible learning experience and to share the pleasure of learning with our students.