Module 1

A Primer on OOP Concepts

Procedural Programming vs OOP

• When should you choose OOP over procedural paradigm in your code
• Understanding structured programming, modularity, extensibility, and delegation of concerns

Essential Traits of OOP-based Design

• Instantiability
• Extensibility
• Modularity
• Comprehensibility
• Introspectability

OOP Design Concepts Explained

• Abstraction
• Encapsulation
• Generalization
• Composition
• Delegation
• Polymorphism
• Contracts / Protocols / Interfaces
• Dynamic Dispatch

Module 2

OOP Using Python – Basic Concepts

• Python Language OOP Design Features
• All about names, values, objects, and types
• Everything in Python as an object
• Accessing objects using references
• Functions, classes, and methods as objects
• Variables vs Attributes
• Scope of a variable vs attribute resolution
• Modules and namespaces
• Objects as values in different contexts: numeric, boolean, string, containers, and iterables
• Python Objects Memory Model
• Python 3 Type and Object Hierarchy
• Introspecting Objects in Python:
• id(), type(), dir()
• hasattr(), getattr(), setattr(), and delattr()
• isinstance(), vars()
• str(), repr(), bool()
• callable(), iter(), reversed(), len()

Module 3

Creating Custom Classes and Objects in Python Code

• Defining classes and instantiating objects.
• Variables vs Attributes: how are they different in Python.
• Significance of defining and using classes
• When should you avoid defining your own classes
• An overview on class attributes:
• __name__, __bases__, __doc__, __dict__, __class__.
• Instances and instance attributes.
• Class-Instance relationship: rules and bindings.
• Instance methods, class-methods, static-methods, and singleton-instance methods.
• Sub-classing, Inheritance, and Generalization
• Ducktyping vs Generalization
• Understanding Monkey-patching techniques with use-case examples.

Module 5

Special Methods Part 2: Custom Implementation of Common Data-Types

• Implementing custom numeric types:
• Arithmetic support: __add__(), __sub__(), __mul__(), __mod__(), __truediv__(), and __pow__() methods
• Bitwise operation support: __or__(), __and__(), __xor__(), __lshift__(), and __rshift() methods.
• Using the operator module – use-case examples.
• Implementing custom container/collection types:
• __len__(), __contains__(), and __iter__() methods.
• An overview of the iterator protocol.
• Implementing sequence container objects:
• __getitem__(), __add__(), __mul__(), and __reversed__(), count(), and index() methods.
• Mutable sequence emulation using __setitem__(), __delitem__(), __iadd__(), __imul__(), append(), extend(), insert(), remove(), pop(), copy(), clear(), sort(), reverse() methods.
• Implementing custom set and mapping containers.
• Implementing custom attribute accessors:
• __getattr__(), __setattr__(), __delattr__(), __dir__() methods.
• Implementing object attributes using __slots__ support.
• Implementing attribute accessors methods using property() function and decorator.

Module 6

Decorators and AOP Features

• An overview on Decorator patterns and AOP
• Using python annotation syntax to create decorators
• Creating decorators with arguments (parameterized decorators).
• Chaining decorators.
• Dependency injection features: before, after, and around filters.
• Implementing decorators using classes.
• Decorating classes and methods of a class.
• Decorating python modules.
• Use-case examples and best practices for implementing decorators.

Module 7

Beyond OOP: Functional Programming Features in Python

• An overview on functional programming
• Functions as first-class citizen
• Pure functions vs Functions with side-effects
• Lambda expressions in Python
• Higher-order functions – examples and use-cases
• Monads – the pythonic way
• Partials and Currying functions in Python
• A tour into features provided by the functools module with examples

Module 8

Concurrent Programming in Python: Using Generators and Co-routines

• A gentle introduction to concurrent programming
• Understanding the concurrency problem while using imperative programming style.
• Implementing concurrency using generators in Python.
• Creating a generator using yield statement.
• Interesting generator patterns in the itertools module.
• Creating custom iterators for collections.
• Creating co-routines using yield expressions.
• Using async and await features to implement co-routines.
• Designing concurrent execution pipe-lines
• An overview on the asyncio library.

Module 9

A Pythonic Approach Towards Applying Map, Filter and Reduce Operations on Datasets

• An overview on map(), filter(), and functools.reduce() functions
• A gentle introduction to comprehensions
• Creating lists, tuples, sets, and dictionary using comprehensions
• Applying map and filter operations using comprehensions
• Generator comprehensions.
• Use-case examples for applying comprehensions for various problem-statements