Chapter 1: Introduction to Python Programming
- Lesson 1: History of Python
- Lesson 2: Features of Python
- Lesson 3: Advantages of Python
- Lesson 4: Main Uses of Python
- Lesson 5: Python Job Markets
Chapter 2: Installing Python and the IDE
- Lesson 1: Installing Python on Windows
- Lesson 2: Installing Python on Linux
- Lesson 3: Installing Visual Studio Code
- Lesson 4: Installing PyCharm
- Lesson 5: Installing Notepad++ and Sublime
- Lesson 6: Installing VS Code on Ubuntu
Chapter 3: Variables
- Lesson 1: Defining Variables
- Lesson 2: Variable Naming Rules
- Lesson 3: Assigning Multiple Variables Simultaneously
- Lesson 4: Displaying Variables in Output
- Lesson 5: Global and Local Variables
Chapter 4: Data Types
- Lesson 1: Introducing Data Types
- Lesson 2: Determining the Data Type of a Variable
Chapter 5: Data Types | Numeric Data
- Lesson 1: Introducing Numeric Data Types
- Lesson 2: Converting Numeric Types to Each Other
Chapter 6: Data Types | String Data Type
- Lesson 1: Introduction to Strings
- Lesson 2: Strings as Arrays
- Lesson 3: Detecting the Presence of a Character in a String
- Lesson 4: Concatenation of Strings
- Lesson 5: Formatting Strings
- Lesson 6: Escape Characters
- Lesson 7: Methods Available for Strings | strip(), lower(), upper(), replace(), split()
- Lesson 8: Methods Available for Strings | capitalize(), casefold(), center(), count(), encode()
- Lesson 9: Methods Available for Strings | endswith(), expandtabs(), find(), format_map()
- Lesson 10: Methods Available for Strings | index(), isalnum(), isalpha(), isdecimal(), isdigit()
- Lesson 11: Methods Available for Strings | isidentifier(), islower(), isupper(), isprintable()
- Lesson 12: Available methods for Strings | isspace(), istitle(), isnumeric(), join(), ljust()
- Lesson 13: Available methods for Strings | istrip(), maketrans(), partition(), rfind(), rindex()
- Lesson 14: Available methods for Strings | rjust(), rpartition(), rsplit(), rstrip(), splitlines()
- Lesson 15: Available methods for Strings | startswith(), swapcase(), title(), translate(), zfill()
Chapter 7: Data Types | Logical Data Type
- Lesson 1: Introduction to Logical Data Type
- Lesson 2: True or False Values
- Lesson 3: Logical Values as Function Output
Chapter 8: Data Types | Mutable Sequential Data Type (Lists)
- Lesson 1: Introducing Sequential Data Types and Lists
- Lesson 2: Accessing List Members
- Lesson 3: Navigating List Members
- Lesson 4: Adding or Removing an element from a list
- Lesson 5: Copying a list
- Lesson 6: List methods count(), extend(), index(), reverse(), sort()
Chapter 9: Data types | Immutable Sequential Data Type (tuples)
- Lesson 1: Introduction to tuples
- Lesson 2: Accessing tuple members
- Lesson 3: Changing the value of tuple elements
- Lesson 4: Iterating through elements of a tuple
- Lesson 5: Adding or removing an element from a tuple
- Lesson 6: Concatenating two tuples
- Lesson 7: Tuple methods | count(), index()
Chapter 10: Data types | Unordered Data Type (sets)
- Lesson 1: Introduction to sets
- Lesson 2: Accessing members of a set
- Lesson 3: Changing members of a set
- Lesson 4: Concatenating two sets
- Lesson 5: Set methods | copy(), difference(), difference_update()
- Lesson 6: Set methods | intersection(), intersection_update(), isdisjoint()
- Lesson 7: Set methods | issubset(), issuperset()
- Lesson 8: Set methods | symmetric_difference(), symmetric_difference_update()
Chapter 11: Data Types | Mapping Data Type (Dictionaries)
- Lesson 1: Introduction to Dictionaries
- Lesson 2: Accessing Elements of a Dictionary
- Lesson 3: Changing Values of a Dictionary
- Lesson 4: Iterating Through Elements of a Dictionary
- Lesson 5: Adding or Removing Elements from a Dictionary
- Lesson 6: Creating a Copy of a Dictionary
- Lesson 7: Nested Dictionaries
- Lesson 8: Methods available for dictionaries | fromkeys(), keys(), setdefault(), update()
Chapter 12: Operators
- Lesson 1: Introduction to Operator Types
- Lesson 2: Arithmetic Operators
- Lesson 3: Assignment Operators
- Lesson 4: Comparison Operators
- Lesson 5: Logical Operators
- Lesson 6: Identity Operators
- Lesson 7: Membership Operators
- Lesson 8: Bitwise Operators
- Lesson 9: Operator Precedence
Chapter 13: Program Control Structures | Conditional Expressions
- Lesson 1: Introduction to Conditional Expressions
- Lesson 2: Abbreviated Conditional Expressions
- Lesson 3: The and and or Keywords
- Lesson 4: Nested Conditional Expressions
Chapter 14: Program Control Structures | Loops
- Lesson 1: Introduction to Loops
- Lesson 2: The while loop
- Lesson 3: The for loop
- Lesson 4: The range() function
- Lesson 5: Nested loops
- Lesson 6: The pass keyword
- Lesson 7: The zip() method
- Lesson 8: The magic methods __iter__() and __next__()
Chapter 15: Functions
- Lesson 1: Introduction to Functions
- Lesson 2: Input Parameters of a Function
- Lesson 3: Function Output
- Lesson 4: Getting Input from the User
- Lesson 5: Functions with More Than One Output
- Lesson 6: Custom Functions Versus Built-In Functions
- Lesson 7: Passing a List as an Input Argument
- Lesson 8: Arbitrary input arguments or *args
- Lesson 9: Recursive Functions
- Lesson 10: Writing Docstrings for Functions
- Lesson 11: The Yield Keyword
Chapter 16: Exception Handling
- Lesson 1: Introduction to Exceptions
- Lesson 2: Types of Exceptions
- Lesson 3: Creating a Custom Exception
Chapter 17: Working with Files
- Lesson 1: Introduction to Working with Files
- Lesson 2: The readline() Method
- Lesson 3: The seek(), strip(), rstrip(), and lstrip() Methods
- Lesson 4: The Difference Between the readline() and readlines() Methods
- Lesson 5: Closing Files with the close() Method
- Lesson 6: Writing to Files with the write() Method
- Lesson 7: Creating and Deleting a File
- Lesson 8: Other Ways to Open a File
Chapter 18: Lambda Functions
- Lesson 1: Introduction to Lambda Functions
- Lesson 2: Supplementary Exercises for Lambda Functions
Chapter 19: Modules in Python
Chapter 20: Built-in Utility Modules | Part 1
- Lesson 1: datetime module
- Lesson 2: csv module
- Lesson 3: json module
- Lesson 4: xml module
Chapter 21: Built-in Utility Modules | Part 2
- Lesson 1: sys module
- Lesson 2: io module
- Lesson 3: os module
- Lesson 4: itertools module
- Lesson 5: functools module
Chapter 22: Partial Functions
- Lesson 1: Introduction to partial functions
- Lesson 2: How to pass arguments to partial functions
- Lesson 3: Other features of partial functions
Chapter 23: Built-in Utility Functions | Part 1
- Lesson 1: enumerate() function
- Lesson 2: any() function
- Lesson 3: all() function
- Lesson 4: bin() function
Chapter 24: Built-in Utility Functions | Part 2
- Lesson 1: map() function
- Lesson 2: filter() function
- Lesson 3: reduce() function
Chapter 25: Built-in Utility Functions | Part 3
- Lesson 1: eval() function
- Lesson 2: exec() function
- Lesson 3: compile() function
Chapter 26: Built-in Utility Functions | Part 4
- Lesson 1: format() function
- Lesson 2: globals() function
- Lesson 3: locals() function
Chapter 27: Built-in Utility Functions | Part 5
- Lesson 1: reversed() function
- Lesson 2: slice() function
- Lesson 3: sorted() function
- Lesson 4: vars() function
Chapter 28: How to Create a Virtual Environment
- Lesson 1: Introduction to Virtual Environments
- Lesson 2: Benefits of Using Virtual Environments
- Lesson 3: Creating a Virtual Environment with venv
- Lesson 4: Activating and Deactivating a Virtual Environment
- Lesson 5: Managing Dependencies in a Virtual Environment
- Lesson 6: Working with pip Inside a Virtual Environment
- Lesson 7: Best Practices for Virtual Environment Usage
Chapter 29: Receiving Input from the Command Line (Command Line Arguments)
- Lesson 1: Introduction to Command Line Arguments
- Lesson 2: Understanding sys.argv
- Lesson 3: Parsing Command Line Arguments Using argparse
- Lesson 4: Using Default Values and Validations with argparse
- Lesson 5: Handling Optional and Positional Arguments
- Lesson 6: Supplementary Exercises for Command Line Arguments
Chapter 30: Supplementary Exercises for Introductory Python
Chapter 1: Advanced Data Structures
- Lesson 1: Introduction to Advanced Data Structures
- Lesson 2: Understanding Named Tuples and Deques
- Lesson 3: Working with Defaultdict and OrderedDict
- Lesson 4: Introduction to Counters and ChainMap
- Lesson 5: Advanced Uses of Sets and Frozensets
Chapter 2: Iterators and Generators
- Lesson 1: Deep Dive into Iterators
- Lesson 2: Advanced Generator Functions
- Lesson 3: Generator Expressions and Performance Benefits
- Lesson 4: Coroutines and Their Applications
- Lesson 5: Using itertools for Complex Iteration Patterns
Chapter 3: Object-Oriented Programming
- Lesson 1: Introduction to Object-Oriented Programming Principles
- Lesson 2: Advanced Class Design Patterns
- Lesson 3: Encapsulation: Principles and Practices
- Lesson 4: Understanding and Implementing Inheritance
- Lesson 5: Multiple Inheritance and the MRO (Method Resolution Order)
- Lesson 6: Polymorphism: Concepts and Applications
- Lesson 7: Abstract Classes and Interfaces
- Lesson 8: Operator Overloading and Magic Methods
- Lesson 9: Using Class and Static Methods Effectively
- Lesson 10: Metaclasses and Their Applications
- Lesson 11: Designing Reusable and Scalable Classes
- Lesson 12: Practical Exercises on Advanced OOP Concepts
Chapter 4: Python Decorators
- Lesson 1: Introduction to Decorators
- Lesson 2: Writing Custom Decorators
- Lesson 3: Property Decorator
- Lesson 4: Understanding functools.wraps
- Lesson 5: Practical Use Cases of Decorators
- Lesson 6: Chaining Multiple Decorators
Chapter 5: Advanced Functionality with Python Functions
- Lesson 1: Closures and Their Applications
- Lesson 2: Higher-Order Functions
- Lesson 3: Callable Objects in Python
- Lesson 4: Implementing Memoization
Chapter 6: Context Managers and the with Statement
- Lesson 1: Basics of Context Managers
- Lesson 2: Writing Custom Context Managers
- Lesson 3: Using contextlib for Simplifying Context Management
- Lesson 4: Practical Use Cases for Context Managers
Chapter 7: Advanced Error and Exception Handling
- Lesson 1: Nested Exception Handling
- Lesson 2: Exception Chaining and the raise from Statement
- Lesson 3: Custom Exceptions with Extended Features
- Lesson 4: Using else and finally Effectively in try Blocks
Chapter 8: Working with Modern Python Features
- Lesson 1: New Features in Python 3.10 to 3.12
- Lesson 2: Pattern Matching with match-case
- Lesson 3: Structural Pattern Matching Use Cases
- Lesson 4: Type Hinting and Type Checking
- Lesson 4: The walrus Operator (:=) and Its Applications
Chapter 9: Concurrency and Parallelism
- Lesson 1: Introduction to Threading and Multiprocessing
- Lesson 2: Asynchronous Programming with asyncio
- Lesson 3: Using async/await Effectively
- Lesson 4: Understanding GIL and Its Implications
- Lesson 5: Best Practices for Concurrency in Python
Chapter 10: Working with APIs and Web Scraping
- Lesson 1: Introduction to APIs
- Lesson 2: Making API Calls Using requests
- Lesson 3: Authentication and Error Handling in APIs
- Lesson 4: Web Scraping Basics with BeautifulSoup
Chapter 11: Multithreading in Python
- Lesson 1: Understanding the Basics of Multithreading
- Lesson 2: Thread Lifecycle and Management
- Lesson 3: Creating Threads Using the threading Module
- Lesson 4: Synchronizing Threads with Locks
- Lesson 5: Using Semaphores and Conditions
- Lesson 6: Thread Communication and Shared Resources
- Lesson 7: Thread Pools and Concurrent Execution
- Lesson 8: Debugging Multithreaded Programs
- Lesson 9: Real-World Applications of Multithreading
- Lesson 10: Multithreading vs. Multiprocessing: Key Differences
Chapter 12: Writing Efficient Python Code
- Lesson 1: Understanding Time and Space Complexity
- Lesson 2: Profiling and Benchmarking Python Code
- Lesson 3: Optimizing Code Using Built-in Modules
- Lesson 4: Writing Pythonic Code
- Lesson 5: Leveraging Cython for Speed Improvements
Chapter 13: Advanced Testing and Debugging
- Lesson 1: Writing Unit Tests with unittest and pytest
- Lesson 2: Mocking and Patching in Tests
- Lesson 3: Debugging Python Code with pdb
- Lesson 4: Using Logging for Debugging
- Lesson 5: Continuous Integration and Testing
Chapter 14: Packaging and Deploying Python Applications
- Lesson 1: Structuring Python Projects
- Lesson 2: Creating and Publishing Python Packages
- Lesson 3: Managing Dependencies with pip and Poetry
- Lesson 4: Version Control with Git
- Lesson 5: Deploying Applications Using Docker
Chapter 15: Design Patterns in Python
- Lesson 1: What are Design Patterns?
- Lesson 2: Creational Patterns: Singleton, Factory Method, Abstract Factory, Builder, Prototype
- Lesson 3: Structural Patterns: Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy
- Lesson 4: Behavioral Patterns: Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, Visitor
Chapter 16: Supplementary Exercises for Advanced Python