This is Part 1 of a series of courses intended to dive into the inner mechanics and more complicated aspects of Python 3.
This is not a beginner course - if you've been coding Python for a week or a couple of months, you probably should keep writing Python for a bit more before tackling this series.
On the other hand, if you're now starting to ask yourself questions like:
I wonder how this works?
is there another way of doing this?
what's a closure? is that the same as a lambda?
I know how to use a decorator someone else wrote, but how does it work? Can I write my own?
why isn't this boolean expression returning a boolean value?
what does an import actually do, and why am I getting side effects?
and similar types of question...
then this course is for you.
Please make sure you review the pre-requisites for this course (below) - although I give a brief refresh of basic concepts at the beginning of the course, those are concepts you should already be very comfortable with as you being this course.
In this course series, I will give you a much more fundamental and deeper understanding of the Python language and the standard library.
Python is called a "batteries-included" language for good reason - there is a ton of functionality in base Python that remains to be explored and studied.
So this course is not about explaining my favorite 3rd party libraries - it's about Python, as a language, and the standard library.
In particular this course is based on the canonical CPython. You will also need Jupyter Notebooks to view the downloadable fully-annotated Python notebooks.
It's about helping you explore Python and answer questions you are asking yourself as you develop more and more with the language.
In Python 3: Deep Dive (Part 1) we will take a much closer look at:
Variables - in particular that they are just symbols pointing to objects in memory
Namespaces and scope
Python's numeric types
Python boolean type - there's more to a simple or statement than you might think!
Run-time vs compile-time and how that affects function defaults, decorators, importing modules, etc
Functions in general (including lambdas)
Functional programming techniques (such as map, reduce, filter, zip, etc)
Imports, modules and packages
Tuples as data structures
To get the most out of this course, you should be prepared to pause the coding videos, and attempt to write code before I do! Sit back during the concept videos, but lean in for the code videos!
This is an intermediate to advanced Python course.
To have the full benefit of this course you should be comfortable with the basic Python language including:
variables and simple types such as str , bool , int and float types
for and while loops
using simple lists , tuples , dictionaries and sets
defining functions (using the def statement)
writing simple classes using the class keyword and the __init__ method, writing instance methods, creating basic properties using @property decorators
importing modules from the standard library (e.g. import math)
You should also:
have Python 3.6 (or higher) installed on your system
be able to write and run Python programs using either:
the command line, or
a favorite IDE (such as PyCharm),
have Jupyter Notebooks installed (which I use throughout this course so as to provide you fully annotated Python code samples)
Brave hacker labs is a leading provider of ethical hacking and cyber security training,
we teach hacking and security to help people become ethical hackers so
they can test and secure systems from black-hat hackers.
Becoming an ethical hacker is simple but not easy, there are many
resources online but lots of them are wrong and outdated, not only that
but it is hard to stay up to date even if you already have a background
in cyber security.
Our goal is to educate people and increase awareness by exposing methods used by real black-hat hackers and show how to secure systems from these hackers.