1. Introduction to Python

• Introduction to the Complete Python Guide
• Course Overview
• Where to Write and Run Python Code
• Practice Installing Python
• Practice - Using the Python Interactive Interpreter

2. Installing and Using Pycharm IDE FREE CHAPTER

• Installing PyCharm
• Getting Familiar with the PyCharm Interface

3. Basics Concepts in Python

• Key Concept in Python
• Main Data Types in Python
• Practice - Working with Main Data Types

4. Introduction to Functions and Built-in Functions in python

• Built-in Functions
• Practice - Defining and Using Functions
• Practice - Using the Return Statement in Functions
• Practice - Exploring Built-in Functions
• Practice - Using the built-in dir() Function
• Practice - Gathering User Input with the built-in input() Function

5. Code formatting and PEP8

• Code Indentations
• Practice - Working with Indentations
• Following PEP 8 Guidelines
• Enabling Auto-Formatting in PyCharm

6. Comments

• Comments
• Practice - Adding Comments to Your Code

7. Expressions and Instructions

• Understanding Expressions
• Understanding Statements
• Practice - Using Expressions
• Practice - Using Statements

8. Variables

• Variables
• Practice - Defining and Using Variables

9. Data Types and structures

• Understanding Dynamic Typing
• Types and Data Structures Overview
• Variables and Objects
• Practice - Using the built-in id() Function
• Practice - Exploring Core Data Classes (str, int, bool, list, dict)
• Practice - Using the built-in isinstance() Function

10. Strings

• Strings
• Practice - String Manipulation
• Practice - String Methods

11. String Concatenation

• String Concatenation
• Practice - Concatenating Strings using the + Operator
• Practice - Using f-strings for String Formatting
• Practice - Alternative String Formatting Methods

12. Numeric Types

• Integers
• Practice - Integers Manipulation
• Float Numbers
• Practice - Floating-Point Numbers Manipulation
• Working with Complex Numbers

13. Boolean Values

• Boolean Values
• Practice - Working with Boolean Values
• Type Conversion

14. Magic Methods

• Magic Methods
• Practice - Utilizing Magic Attributes and Methods

15. Lists

• Lists
• List Methods
• Practice - Working with Lists
• Copying Lists
• Practice - Copying Lists
• TASK - Working with Lists

16. Dictionaries

• Dictionaries
• Practice - Manipulating Dictionaries
• Practice - Dictionary Methods
• Other Operations with Dictionaries
• Practice - Using the get() Method for Dictionaries
• Practice - Converting Other Types to a Dictionary
• TASK - Working with Dictionaries

17. Tuples

• Tuples
• Practice - Tuples Manipulation

18. Sets

• Sets
• Practice - Working with Sets
• Understanding Set Theory
• Set Methods
• Practice - Usage of the Set Methods
• Practice - Calculating Symmetric Difference of Sets
• TASK - Working with Sets

19. Ranges

• Ranges
• Practice - Range Manipulation
• Practice - Range Methods and Attributes

20. Working with Sequences

• Built-in Functions for Sequences
• Built-in zip() Function
• Practice - Working with zip Objects
• Practice - Converting a zip Object to a Dictionary
• Comparison of Different Sequences

21. Modifying Objects in Python

• Understanding Immutable Objects in Python
• Understanding Mutable Objects in Python
• Strategies to Prevent Object Mutation
• Practice - Creating Deep Copies of Objects

22. Functions

• Functions
• Calling Functions. Arguments vs Parameters
• Shortest Function in Python

23. Function Arguments

• Mutable and Immutable Arguments in Function Calls
• Practice - Using Mutable and Immutable Objects as Function Arguments
• Practice - Mandatory and Optional Positional Arguments
• TASK - Functions Manipulation
• Function Arguments

24. Args and kwargs in Functions

• Practice - Using *args to Gather Positional Arguments into a Tuple
• Keyword Arguments
• Practice - Working with Keyword Arguments
• Practice - Using *kwargs to Merge Keyword Arguments in a Dictionary
• TASK - Manipulating Function Arguments
• Args and kwargs
• Practice - Gathering Positional Arguments into the *args Tuple
• Practice - Gathering All Keyword Arguments into the **kwargs Dictionary

25. Default Function Parameters

• Default Function Parameters
• Practice - Using Default Function Parameters

26. Docstrings

• Docstrings
• Practice - Writing and Using Docstrings
• Practice - Exploring Docstrings
• Practice - Adding Docstrings to Functions

27. Callback Functions

• Callback Functions
• Rules for Working with Functions

28. Global and local Variables

• Scopes
• The Global Keyword
• Practice - Global and Local Variables
• Practice - Using the Global Keyword

29. Operators

• Operators
• Unary and Binary Operators
• Practice - Working with Prefix Unary Operators
• TASK - Operators

30. Falsy and Truthy Values

• Falsy and Truthy Values
• Practice - Falsy and Truthy Values

31. Logical and Comparison Operators

• Logical Operators
• Practice - Short-Circuit OR Operator
• Practice - Short-Circuit AND Operator
• Practice - Combining OR and AND Operators
• Practice - Examples with Logical Operators
• Practice - Comparison Operators
• The del Statement

32. Lambda Functions

• Lambda Functions
• Practice - Returning Lambda Functions from Functions
• Practice - Sorting a List using Lambda Functions
• Practice - Filtering a List using Lambda Functions

33. Error handling

• Error Handling
• Practice - Using Different Error Classes in the Try and Except
• Practice - Using Multiple Error Classes in one Except Block and Parent Exception Class
• Practice - Using Else and Finally Blocks
• Example - Handling File Not Found Errors
• Example - Handling Undefined Variable Errors
• Practice - Raising Custom Errors
• Practice - Handling Raised Errors using Try and Except
• Practice - Specifying Types for Function Parameters
• TASK - Proper Error Handling

34. Sequence Unpacking

• Sequence Unpacking
• Practice - Unpacking Tuples
• Practice - Unpacking a List of Tuples
• Practice - Unpacking Remaining Elements
• Practice - Unpacking Selected Elements
• Practice - Unpacking a List into Positional Arguments
• Practice - Unpacking a Dictionary into Keyword Arguments
• Practice - Flexibility in Function Calls

35. Unpacking Dictionary

• Dictionary Unpacking Operator **:
• Practice - Using the Dictionary Unpacking Operator
• Practice - Merging Two Dictionaries

36. Conditional Statements

• Conditional Statements
• Practice - Working with Multiple if Statements
• The if-else Statement
• The if-elif Statement
• Practice - Combining if, elif, and else Statements
• Practice - Considering the Order of Conditions in if Statements
• Practice - Incorporating if Statements into Functions
• Practice - Using if and return Statements within Functions
• Example - Calculating School Grades using if and return in the Function
• TASK - Conditional Statements

37. Ternary Operator

• Ternary Operator
• Practice - Utilizing the Ternary Operator
• Example - Calculating Discounts with the Ternary Operator
• Example - Data Manipulation using the Ternary Operator
• Example - Calculating School Grades using the Ternary Operator

38. For-In loop

• Loops
• For-In Loop
• Practice - Iterating through Lists and Tuples using For-In Loops
• Practice - Iterating through Dictionaries using For-In Loops
• Practice - Iterating through Ranges, Strings, and Sets with For-In Loops
• TASKS - Working with For-In Loops

39. While Loop

• While Loop
• Practice - Utilizing the While Loop
• Example - Making Selections with the While Loop
• Practice - Using break Statements in While and For-In Loops
• Practice - Using continue and break Statements in While Loops
• TASK - While Loop

40. For-In Expression (Comprehension)

• For-In Expression
• List, Set, and Dictionary Comprehensions
• Practice - Using List Comprehension
• Practice - Using Dictionary Comprehension
• Practice - Utilizing Tuple Comprehension
• Practice - Converting Tuples to Lists
• Example - Constructing Dictionaries from Sequences
• Practice - Short For-In Loops with Conditional Statements
• Example - Converting Dictionary to Another Dictionary
• TASKS - Short For-In Loops
• Example - Chaining For-In Expressions

41. Generators

• Generators in For-In Expressions
• Practice - Generators and Iteration over the Generator

42. Decorator Functions

• Introduction to Decorator Functions
• Example - Verifying User Permissions with Decorator Functions
• Example - Logging using Decorator Functions
• Example - Validating Arguments with Decorator Functions

43. Classes and Objects

• Classes and Objects
• Practice - Understanding Classes and Class Instances
• Practice - Adding Instance Attributes through Dot Notation
• Adding Instance Attributes using the ..init.. Method
• Practice - Incorporating Own Instance Attributes with the ..init.. Method

44. Instance and Class method

• Instance vs Class Methods
• Practice - Inheriting Methods by the Instances
• Static Class Methods
• Practice - Utilizing Static Methods in Classes
• Class Attributes
• Practice - Working with Class Attributes

45. Magic Methods in Classes

• Magic Methods in Classes
• Practice - Utilizing Magic Methods in Classes

46. Classes Extension

• Inheritance from Other Classes
• Practice - Extending Classes

47. Classes in Practice

• Example - Creating Forum, User, and Post Classes
• Example - Creating Instances of the Forum, User, and Post Classes
• Example - Methods for Finding Users by Username and Email
• Example - Method for Finding All Posts by a Specific User
• Example - Retrieving User Posts by Email
• Example - Adding Parameter Types
• Example - Wrapping up the Forum, Users, and Posts Example

48. Key Principles in Object-Oriented Programming (OOP)

• Encapsulation in Object-Oriented Programming (OOP)
• Inheritance in Object-Oriented Programming (OOP)
• Polymorphism in Object-Oriented Programming (OOP)
• Abstraction in Object-Oriented Programming (OOP)

49. Modules

• Modules
• Practice - Importing Entire Custom Modules
• Practice - Selective Imports from Other Modules
• Practice - Importing between Different Modules
• Practice - Modules in Subfolders

50. Built-in Modules

• Built-in Modules
• Practice - Importing from Built-in Modules

51. What is __name__ and __main__

• Practice - _name_ and _main_
• Example - Executing Functions only when Module is run Directly
• Practice - Packages in Python

52. JavaScript Object Notation (JSON)

• JavaScript Object Notation (JSON)
• Practice - Converting Python Objects to JSON
• Practice - Converting from JSON to Python Objects
• Practice - Formatting Dictionaries using JSON
• TASKS - JSON

53. Working with Files

• Working with Files
• Working with Files and Directories using the os Module
• Removing Files and Directories using the os Module
• Summary of Directory and File Operations using the os Module
• Working with Files and Directories using the Path Class
• Iterating over Directories and Removing Files using the Path Class
• Reading and Writing Files
• Writing and Reading Files using the built-in open Function
• Using the with Statement
• Removing Files using unlink
• TASK - Files

54. Working with zip archives

• Built-in zipfile Module and Creating Zip Archives
• Reading from the Zip Archive

55. Working with CSV Files

• Working with CSV Files
• Iterating over Each Row in the CSV File

56. Working with Dates and Times

• Built-in datetime Module
• Examples - Using the datetime Class
• Examples - Converting Strings to Datetime Objects
• Example - Working with the timedelta Class
• Built-in time Module

57. Generating Random Sequences and Passwords

• Built-in random Module
• Examples - Utilizing choices and shuffle Methods from the random Module
• Built-in secrets Module
• Examples - Generating CSRF Tokens, URL-Safe Tokens, and OTP Passwords
• Example - Generating Strong Passwords

58. Math Module and Recursive Functions

• Built-in math Module
• Recursive Functions

59. Regular Expressions

• Built-in re Module for Regular Expressions
• Example - Creating Patterns for Matching
• Example - Email Validation using Regular Expressions
• Example - Substring Replacement using Regular Expressions
• Example - Removing Excessive Spaces using Regular Expressions
• TASK - Password Verification

60. Sending Emails

• Running smtp4dev SMTP server in a Docker Container
• Sending an Email using SMTP
• Formatting an Email using an HTML Template
• SMTP Wrap-Up and Removing the Docker smtp4dev Container

61. Working with SQLite Database

• Creating an SQLite3 Database and Table
• Writing Data into the SQLite Table
• Reading Data from the SQLite Table
• SQLite Summary

62. Other Built-in Modules

• Built-in array Module
• Saving Arrays to Files and Reading Arrays from Files
• Accessing Program Arguments using the built-in sys Module
• Built-in webbrowser Module

63. Virtual Environments

• Introduction to PIP - Package Manager for Python
• Using a Globally Installed requests Package
• Uninstalling Globally Installed Packages using PIP
• Creating a Python Virtual Environment
• Activation and Deactivation of the Virtual Environment in the Shell
• Installing Packages within the Virtual Environment
• Saving a List of Installed Packages in a Requirements Text File
• Challenges of Package Management using Requirements Files

64. Pipenv for Virtual Environments Management

• Installing pipenv for Virtual Environments Management
• Creating a Virtual Environment using pipenv:
• Installing Packages using pipenv:
• Updating Packages using pipenv:
• Recreating Virtual Environment in the Project Folder using pipenv:
• Using venv for Virtual Environments in PyCharm:
• Using pipenv for Virtual Environments in PyCharm:

65. Introduction to the Django web framework

• Introduction to the Django Web Framework and Project Overview
• Model View Controller (MVC) Programming Pattern
• Understanding How MVC Pattern is Implemented in Django
• Creating a New PyCharm Project and Installing Django

66. Creating a Django project

• Creating a New Django Project
• Overview of the manage.py File in Django
• Starting and Verifying the Django Server
• Overview of Settings in the Django Project
• Overview of Default Routing Configuration in Django

67. Creating a Django Application

• Creating the Shop Application in Django
• Explaining the Naming of the Django Project as base
• Exploring the Contents of the Shop Application
• Creating a View Function
• Attaching the View Function to a URL:
• Adding Shop Application Routes to the Global Project Routing Configuration

68. Database and Migrations in Django

• Applying Default Migrations in the Django Project
• Creating an Admin User in the Django Project
• Creating Course and Category Models
• Enabling the Shop Application in the Django Project
• Creating and Applying Migrations for the Shop Application
• Modifying Database Models
• Creating a Category using the Category Model in the Shell
• Creating Courses using the Course Model in the Shell
• Creating Categories and Courses in the Admin Interface
• Modifying How Courses and Categories are Displayed in the Admin Panel
• Sending Course Titles to the Client in the Response

69. Creating Templates in Django

• Creating an HTML Template
• Using an HTML Template in the View Function
• Populating the HTML Template with Data from the Database
• How we Connected Templates, Views, and Models
• Adding the Bootstrap CSS Library to the HTML Template

70. Extending Other Templates in Django

• Creating a Base HTML Template for Reuse in Other Templates
• Adding a Navigation Bar in the Base Template
• TASK - Making the Title of the Web Page Dynamic:
• SOLUTION - Making the Title of the Web Page Dynamic:

71. Creating Multiple routes and View Functions

• Creating a Route for the Single Course Web Page
• Creating a View Function for the Single Course
• TASK - Creating an HTML Template for the Single Course
• SOLUTION - Creating an HTML Template for the Single Course
• Responding with a 404 When Course is Not Found in the Database

72. Routing between Pages in Django

• Setting Up Routing Between Pages Using Relative or Absolute Paths
• Setting Up Routing Based on the Names of the URL Patterns
• Considering Application Names in the Routing Setup:
• Adding a Link to the All Courses Page
• Moving the Templates Folder Out of the Shop Application Folder
• Modifying the Model for the Courses
• Summary of the Django Shop Application
• Installing django-tastypie for the API Django Application

73. Creating an API Django Application

• Creating an API Django Application
• Creating Models for the API Application
• Configuring Routing for the API Application
• Verifying the API Service
• Adding Version for the API
• Installing Postman and Sending GET and DELETE Requests

74. Managing Authentication for API Requests

• Creating an API Key for the User
• Enabling Authentication and Authorization for the Model and Using DELETE Method
• Disabling Authentication Only for GET Requests
• Creating a New Resource Using POST Method
• Properly Connecting the Course to the Category in POST Requests Using Hydrate Method
• Adding Dehydrate Method to Modify Data Before Sending to Client
• Summary for Setting Up GET, POST, and DELETE Requests

75. Django Project Refactoring and Admin Settings

• Refactoring Routing for the API Application
• Setting Up Index Route and Adding Navigation to Navbar
• Modifying Administrative Panel
• Summary of Django Courses Project

76. Creating Games with Pygame

• Introduction to Pygame and Creating the Game Window
• Modifying Background Color of the Game Surface
• Displaying a Rectangle in the Game
• TASK - Placing Rectangle in the Middle of the Game Window
• SOLUTION - Placing Rectangle in the Middle of the Game Window
• Moving Rectangle Using Keyboard Arrows
• Stopping Rectangle from Moving Outside of the Surface

77. Creating a Shooter Game with Pygame

• Final Shooter Game Overview
• Loading Images for the Game and Fighter
• Displaying Fighter on the Surface
• Moving Fighter Left or Right
• Making Fighter Movement Continuous
• Adding the Ball to the Game
• Showing Ball Based on Fighter Position
• Moving the Ball After Firing
• Adding the Alien to the Game
• Moving the Alien Down the Surface

78. Interaction of the Elements in the Pygame

• Detecting Collision Between Alien and Fighter, Ending the Game
• Hitting the Alien with the Ball
• Increasing Alien Speed After Each Hit
• Adding Hit Counter
• Shooter Game Summary

79. Game Refactoring using Classes and OOP

• Start of Shooter Refactoring and Creating the Fighter Class
• Adding Methods in the Fighter Class
• Creating an Alien Class
• Adding Methods in the Alien Class
• Creating a Ball Class
• Adding Methods in the Ball Class
• Creating a Game Class
• Adding Methods in the Game Class
• Adding Methods for Drawing Elements and Finalizing Refactoring
• Game Refactoring Summary
• Running the Game After Refactoring

80. Jupyter Notebook

• Installing Jupyter Notebook
• Editing in Jupyter Notebook
• Order of Execution of Cells in Jupyter Notebook
• Adding Markdown, Saving, and Loading Jupyter Notebooks

81. Jupyter Lab

• Installing Jupyter Lab and Editing Notebooks
• Exploring Features of Jupyter Lab
• Installing External Packages in Jupyter Notebook

82. NumPy - Creating Arrays

• Introduction to NumPy and Creating One-Dimensional Arrays
• Two-Dimensional Arrays in NumPy
• Understanding Axes in NumPy
• Arithmetic Operations with NumPy Arrays
• Concatenating NumPy Arrays
• Summary of Basic Operations with NumPy Arrays

83. NumPy – Random Values

• Filling a NumPy Array with Zeroes, Ones, or Random Floats
• Generating Random Elements Using randint and uniform:
• Understanding Seed Number
• NumPy arange, reshape, and flatten Methods

84. NumPy – Examples

• NumPy Examples 1 and 2 (One-Dimensional Array):
• NumPy Examples 3 and 4 (One-Dimensional Array):
• NumPy Example 5 (Two-Dimensional Array):
• NumPy Example 6 (Two-Dimensional Array):
• NumPy Example 7 (Three-Dimensional Array):
• NumPy Summary

85. Pandas – Working with DataFrames and Series

• Introduction to Pandas and Installation
• Creating a DataFrame from a Dictionary
• Basic Operations with DataFrame
• Describing the DataFrame
• Finding Null Values in the DataFrame
• Finding Columns with Specific Data Type
• Series Data Structure in Pandas
• Selecting Part of the DataFrame Using loc and iloc Properties
• Filtering Data in the DataFrame
• Datetime Type in Pandas
• Sorting Data in the DataFrame
• Adding and Removing Columns and Concatenating DataFrames
• Summary of Pandas DataFrames and Series

86. Pandas – Random Data Working with CSV

• Generating Random Data for DataFrames
• Creating a DataFrame Using Random Data
• Saving DataFrames to CSV Files
• Creating DataFrames from CSV Files
• Writing DataFrames to Excel and JSON Files

87. Pandas – Analysing CSV- Loaded DataFrames

• Analyzing CSV-Loaded DataFrames
• Grouping Data in DataFrames
• Displaying Series Data on Plots Using Matplotlib
• Summary of Example with Random CSV Data

88. Matplotlib – Creating Charts

• Examples of Plot and Scatter Diagrams Using Matplotlib
• Examples of Matplotlib Subplots
• Using DataFrames for Creating Diagrams
• Boxplots, Area Plots, and Pie Charts
• Example of a Heatmap in Matplotlib
• Displaying Real-World Data on Various Charts

89. Scikit – Learn - Machine Learning

• Introduction to Scikit-Learn and Installation
• Loading and Analyzing Sample Data for Model Creation
• Handling Null Values in DataFrame
• Attempting to Create a Model for Predicting Target Values
• Encoding Non-Numeric Values in Input Data
• Building and Predicting with Cleaned and Encoded Data
• Summary of Model for Predicting Favorite Transport
• Visualizing DecisionTreeClassifier Model
• Creating Charts for Data from the Built Model
• Evaluating Model Accuracy

90. Machine Learning Model for Real Data

• Loading CSV File with Airline Passenger Satisfaction Data
• Analyzing DataFrame with Passenger Satisfaction Data
• Filling Null Values with Mean Value
• Creating Diagrams for Passenger Data Analysis
• Manually Encoding Non-Numeric Values in DataFrame
• Encoding Non-Numeric Values Using LabelEncoder
• Creating Additional Diagrams After Data Cleaning and Encoding
• Filtering DataFrame with Passenger Data
• Using DecisionTreeClassifier for Model Creation
• Measuring Model Accuracy with DecisionTreeClassifier
• Using Other Classifiers for Model Creation
• Summary of Airline Passenger Satisfaction Project

91. Making Machine Learning Model More Real

• Removing Passenger Votes from DataFrame
• Saving Trained Model for Future Use
• Summary of Realistic Model for Passenger Satisfaction Prediction