Python 3: Deep Dive (Part 1 – Functional)
Filesize : 9.72 GB
What you’ll learn
An in-depth look at variables, memory, namespaces and scopes
A deep dive into Python’s memory management and optimizations
In-depth understanding and advanced usage of Python’s numerical data types (Booleans, Integers, Floats, Decimals, Fractions, Complex Numbers)
Advanced Boolean expressions and operators
Advanced usage of callables including functions, lambdas and closures
Functional programming techniques such as map, reduce, filter, and partials
Create advanced decorators, including parametrized decorators, class decorators, and decorator classes
Advanced decorator applications such as memoization and single dispatch generic functions
Use and understand Python’s complex Module and Package system
Idiomatic Python and best practices
Understand Python’s compile-time and run-time and how this affects your code
Avoid common pitfalls
Expand all 158 lectures44:38:14
Code Projects and Notebooks
–A Quick Refresher – Basics Review
The Python Type Hierarchy
Multi-Line Statements and Strings
The While Loop
Break, Continue and the Try Statement
The For Loop
–Variables and Memory
Variables are Memory References
Dynamic vs Static Typing
Function Arguments and Mutability
Shared References and Mutability
Everything is an Object
Python Optimizations: Interning
Python Optimizations: String Interning
Python Optimizations: Peephole
Integers: Data Types
Integers: Constructors and Bases – Lecture
Integers: Constructors and Bases – Coding
Rational Numbers – Lecture
Rationals Numbers – Coding
Floats: Internal Representations – Lecture
Floats: Internal Representations – Coding
Floats: Equality Testing – Lecture
Floats: Equality Testing – Coding
Floats: Coercing to Integers – Lecture
Floats: Coercing to Integers – Coding
Floats: Rounding – Lecture
Floats: Rounding – Coding
Decimals – Lecture
Decimals – Coding
Decimals: Constructors and Contexts – Lecture
Decimals: Constructors and Contexts – Coding
Decimals: Math Operations – Lecture
Decimals: Math Operations – Coding
Decimals: Performance Considerations
Complex Numbers – Lecture
Complex Numbers – Coding
Booleans: Truth Values – Lecture
Booleans: Truth Values – Coding
Booleans: Precedence and Short-Circuiting – Lecture
Booleans: Precedence and Short-Circuiting – Coding
Booleans: Boolean Operators – Lecture
Booleans: Boolean Operators – Coding
Argument vs Parameter
Positional and Keyword Arguments – Lecture
Positional and Keyword Arguments – Coding
Unpacking Iterables – Lecture
Unpacking Iterables – Coding
Extended Unpacking – Lecture
Extended Unpacking – Coding
*args – Lecture
*args – Coding
Keyword Arguments – Lecture
Keyword Arguments – Coding
Putting it all Together – Lecture
Putting it all Together – Coding
Application: A Simple Function Timer
Parameter Defaults – Beware!!
Parameter Defaults – Beware Again!!
Docstrings and Annotations – Lecture
Docstrings and Annotations – Coding
Lambda Expressions – Lecture
Lambda Expressions – Coding
Lambdas and Sorting
Challenge – Randomize an Iterable using Sorted!!
Function Introspection – Lecture
Function Introspection – Coding
Map, Filter, Zip and List Comprehensions – Lecture
Map, Filter, Zip and List Comprehensions – Coding
Reducing Functions – Lecture
Reducing Functions – Coding
Partial Functions – Lecture
Partial Functions – Coding
The operator Module – Lecture
The operator Module – Coding
–Scopes, Closures and Decorators
Global and Local Scopes – Lecture
Global and Local Scopes – Coding
Nonlocal Scopes – Lecture
Nonlocal Scopes – Coding
Closures – Lecture
Closures – Coding
Closure Applications – Part 1
Closure Applications – Part 2
Decorators (Part 1) – Lecture
Decorators (Part 1) – Coding
Decorator Application (Timer)
Decorator Application (Logger, Stacked Decorators)
Decorator Application (Memoization)
Decorators (Part 2) – Lecture
Decorators (Part 2) – Coding
Decorator Application (Decorator Class)
Decorator Application (Decorating Classes)
Decorator Application (Dispatching) – Part 1
Decorator Application (Dispatching) – Part 2
Decorator Application (Dispatching) – Part 3
–Tuples as Data Structures and Named Tuples
Tuples as Data Structures – Lecture
Tuples as Data Structures – Coding
Named Tuples – Lecture
Named Tuples – Coding
Named Tuples – Modifying and Extending – Lecture
Named Tuples – Modifying and Extending – Coding
Named Tuples – DocStrings and Default Values – Lecture
Named Tuples – DocStrings and Default Values – Coding
Named Tuples – Application – Returning Multiple Values
Named Tuples – Application – Alternative to Dictionaries
–Modules, Packages and Namespaces
What is a Module?
How does Python Import Modules?
Imports and importlib
Import Variants and Misconceptions – Lecture
Import Variants and Misconceptions – Coding
What are Packages? – Lecture
What are Packages ? – Coding
Structuring Packages – Part 1
Structuring Packages – Part 2
Importing from Zip Archives
Python 3.6 Highlights
Python 3.6 – Dictionary Ordering
Python 3.6 – Preserved Order of kwargs and Named Tuple Application
Python 3.6 – Underscores in Numeric Literals
Python 3.6 – f-Strings
Timing code using *timeit*
Don’t Use *args and **kwargs Names Blindly
Command Line Arguments
Sentinel Values for Parameter Defaults
Simulating a simple switch in Python
Basic introductory knowledge of Python programming (variables, conditional statements, loops, functions, lists, tuples, dictionaries, classes).
You will need Python 3.6 or above, and a development environment of your choice (command line, PyCharm, Jupyter, etc.)
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 – 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!
And after you have seen a code video, pause the course, and try things out yourself – explore, experiment, play with code, and see how things work (or don’t work! – that’s also a great way to learn!)
Who this course is for:
Anyone with a basic understanding of Python that wants to take it to the next level and get a really deep understanding of the Python language and its data structures.
Anyone preparing for an in-depth Python technical interview.
Click here for more Business & Marketing Courses.