Python 3- Deep Dive (Part 1 Functional)

Python 3: Deep Dive (Part 1 – Functional), available at $139.99, has an average rating of 4.79, with 161 lectures, based on 11636 reviews, and has 61343 subscribers.

You will learn about An in-depth look at variables, memory, namespaces and scopes A deep dive into Pythons memory management and optimizations In-depth understanding and advanced usage of Pythons 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 Pythons complex Module and Package system Idiomatic Python and best practices Understand Pythons compile-time and run-time and how this affects your code Avoid common pitfalls This course is ideal for individuals who are 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. or Anyone preparing for an in-depth Python technical interview. It is particularly useful 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. or Anyone preparing for an in-depth Python technical interview.

Enroll now: Python 3: Deep Dive (Part 1 – Functional)

Summary

Title: Python 3: Deep Dive (Part 1 – Functional)

Price: $139.99

Average Rating: 4.79

Number of Lectures: 161

Number of Published Lectures: 161

Number of Curriculum Items: 161

Number of Published Curriculum Objects: 161

Original Price: $199.99

Quality Status: approved

Status: Live

What You Will Learn

An in-depth look at variables, memory, namespaces and scopes

A deep dive into Pythons memory management and optimizations

In-depth understanding and advanced usage of Pythons 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 Pythons complex Module and Package system

Idiomatic Python and best practices

Understand Pythons compile-time and run-time and how this affects your code

Avoid common pitfalls

Who Should Attend

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.

Target Audiences

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.

Hello!

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 longer before tackling this series.

On the other hand, if you’ve been studying or programming in Python for a while, and are now starting to ask yourself questions such as:

I wonder how this works?

is there another, more pythonic, 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? How do I write my own?

why do some boolean expressions not return a boolean value? How can I use that to my advantage?

how does the import mechanism in Python work, and why am I getting side effects?

and similar types of question

then this course is for you.

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/theory videos, but lean in for the code videos!

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 (references)

Namespaces and scopes

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)

Closures

Decorators

Imports, modules and packages

Tuples as data structures

Named tuples

Course Prerequisites

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

ifelse  statements

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)

Course Curriculum

Chapter 1: Introduction

Lecture 1: Course Overview

Lecture 2: Pre-Requisites

Lecture 3: Code Projects and Notebooks

Lecture 4: Course Slides

Chapter 2: A Quick Refresher – Basics Review

Lecture 1: Introduction

Lecture 2: The Python Type Hierarchy

Lecture 3: Multi-Line Statements and Strings

Lecture 4: Variable Names

Lecture 5: Conditionals

Lecture 6: Functions

Lecture 7: The While Loop

Lecture 8: Break, Continue and the Try Statement

Lecture 9: The For Loop

Lecture 10: Classes

Chapter 3: Variables and Memory

Lecture 1: Introduction

Lecture 2: Variables are Memory References

Lecture 3: Reference Counting

Lecture 4: Garbage Collection

Lecture 5: Dynamic vs Static Typing

Lecture 6: Variable Re-Assignment

Lecture 7: Object Mutability

Lecture 8: Function Arguments and Mutability

Lecture 9: Shared References and Mutability

Lecture 10: Variable Equality

Lecture 11: Everything is an Object

Lecture 12: Python Optimizations: Interning

Lecture 13: Python Optimizations: String Interning

Lecture 14: Python Optimizations: Peephole

Chapter 4: Numeric Types

Lecture 1: Introduction

Lecture 2: Integers: Data Types

Lecture 3: Integers: Operations

Lecture 4: Integers: Constructors and Bases – Lecture

Lecture 5: Integers: Constructors and Bases – Coding

Lecture 6: Rational Numbers – Lecture

Lecture 7: Rational Numbers – Coding

Lecture 8: Floats: Internal Representations – Lecture

Lecture 9: Floats: Internal Representations – Coding

Lecture 10: Floats: Equality Testing – Lecture

Lecture 11: Floats: Equality Testing – Coding

Lecture 12: Floats: Coercing to Integers – Lecture

Lecture 13: Floats: Coercing to Integers – Coding

Lecture 14: Floats: Rounding – Lecture

Lecture 15: Floats: Rounding – Coding

Lecture 16: Decimals – Lecture

Lecture 17: Decimals – Coding

Lecture 18: Decimals: Constructors and Contexts – Lecture

Lecture 19: Decimals: Constructors and Contexts – Coding

Lecture 20: Decimals: Math Operations – Lecture

Lecture 21: Decimals: Math Operations – Coding

Lecture 22: Decimals: Performance Considerations

Lecture 23: Complex Numbers – Lecture

Lecture 24: Complex Numbers – Coding

Lecture 25: Booleans

Lecture 26: Booleans: Truth Values – Lecture

Lecture 27: Booleans: Truth Values – Coding

Lecture 28: Booleans: Precedence and Short-Circuiting – Lecture

Lecture 29: Booleans: Precedence and Short-Circuiting – Coding

Lecture 30: Booleans: Boolean Operators – Lecture

Lecture 31: Booleans: Boolean Operators – Coding

Lecture 32: Comparison Operators

Chapter 5: Function Parameters

Lecture 1: Introduction

Lecture 2: Argument vs Parameter

Lecture 3: Positional and Keyword Arguments – Lecture

Lecture 4: Positional and Keyword Arguments – Coding

Lecture 5: Unpacking Iterables – Lecture

Lecture 6: Unpacking Iterables – Coding

Lecture 7: Extended Unpacking – Lecture

Lecture 8: Extended Unpacking – Coding

Lecture 9: *args – Lecture

Lecture 10: *args – Coding

Lecture 11: Keyword Arguments – Lecture

Lecture 12: Keyword Arguments – Coding

Lecture 13: **kwargs

Lecture 14: Putting it all Together – Lecture

Lecture 15: Putting it all Together – Coding

Lecture 16: Application: A Simple Function Timer

Lecture 17: Parameter Defaults – Beware!!

Lecture 18: Parameter Defaults – Beware Again!!

Chapter 6: First-Class Functions

Lecture 1: Introduction

Lecture 2: Docstrings and Annotations – Lecture

Lecture 3: Docstrings and Annotations – Coding

Lecture 4: Lambda Expressions – Lecture

Lecture 5: Lambda Expressions – Coding

Lecture 6: Lambdas and Sorting

Lecture 7: Challenge – Randomize an Iterable using Sorted!!

Lecture 8: Function Introspection – Lecture

Lecture 9: Function Introspection – Coding

Lecture 10: Callables

Lecture 11: Map, Filter, Zip and List Comprehensions – Lecture

Lecture 12: Map, Filter, Zip and List Comprehensions – Coding

Lecture 13: Reducing Functions – Lecture

Lecture 14: Reducing Functions – Coding

Lecture 15: Partial Functions – Lecture

Lecture 16: Partial Functions – Coding

Instructors

Dr. Fred Baptiste
Software Engineer and Mathematician

Rating Distribution

1 stars: 29 votes

2 stars: 40 votes

3 stars: 302 votes

4 stars: 2451 votes

5 stars: 8818 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!