Python Full Course for free 🐍

This section introduces Python programming, guiding beginners through installing the Python interpreter and an Integrated Development Environment (IDE) like PyCharm. It covers writing your first Python program, performing print statements, and understanding comments.

Learn about the four fundamental data types in Python: strings (text), integers (whole numbers), floats (decimal numbers), and booleans (true/false). This part explains how to declare and use variables, showcasing their behavior and utility in basic programming.

This segment explains type casting—converting variables from one data type to another—and how to accept user input using the `input()` function. It emphasizes the importance of type casting user input for arithmetic operations, with practical exercises like calculating rectangle area and a shopping cart program.

Create an interactive Mad Libs game to practice user input. This part also delves into basic arithmetic operators (addition, subtraction, multiplication, division, exponentiation, modulus) and augmented assignment operators, along with built-in math functions and the `math` module for advanced calculations (circumference, area of a circle, hypotenuse).

Learn how to use `if`, `elif`, and `else` statements for decision-making in Python programs. Examples include age verification for credit card sign-ups and interactive responses to user choices (e.g., food preferences).

Develop a simple calculator program utilizing `if` statements and type casting to perform basic arithmetic based on user-selected operators. Subsequently, build a weight converter that converts between kilograms and pounds, reinforcing conditional logic.

Create a temperature conversion program for Celsius and Fahrenheit. This section also introduces logical operators (`or`, `and`, `not`) to evaluate multiple conditions, demonstrated through examples like event cancellations based on weather and temperature ranges.

Explore conditional expressions as a concise one-line shortcut for `if-else` statements. Followed by an overview of useful string methods like `len()`, `find()`, `rfind()`, `capitalize()`, `upper()`, `lower()`, `isdigit()`, `isalpha()`, `count()`, and `replace()`, with an exercise on validating user input for usernames.

Understand string indexing to access specific characters or substrings using square brackets, including slice notation with start, end, and step values. Also, learn about format specifiers for precise control over string output, including decimal precision, alignment, and zero-padding.

Master `while` loops for repeating code blocks as long as a condition remains true. This section includes an exercise to build a compound interest calculator, demonstrating how to use `while` loops for input validation and to calculate future balances.

Learn about `for` loops for iterating over sequences and ranges, including counting forward and backward, using `break` and `continue` statements. The concept of nested loops is introduced to create patterns like rectangles from user-defined symbols.

This section details Python's fundamental collection types: lists (ordered, changeable, duplicates allowed), sets (unordered, immutable, no duplicates), and tuples (ordered, unchangeable, duplicates allowed, faster than lists). It covers their creation, access methods, and common operations.

Develop a shopping cart program using lists to manage items and prices. This is followed by an exploration of 2D collections (lists of lists, tuples of tuples) for representing grids of data, exemplified by creating a 2D numpad.

Build an interactive quiz game using tuples for questions and answers, and lists for guesses, incorporating conditional logic and score calculation. This naturally leads to an explanation of dictionaries—collections of key-value pairs—and their methods like `get()`, `update()`, `pop()`, and iteration over keys, values, or items.

Create a concession stand program to practice working with dictionaries, mapping menu items to prices. This introduces the `random` module for generating random numbers and making random choices, vital for games.

Implement a number guessing game, a Rock Paper Scissors game, and a dice roller program. These projects utilize random number generation, input validation, and conditional logic, with the dice roller also incorporating ASCII art for visual representation.

A comprehensive dive into functions: defining them, passing arguments (positional, default, keyword, arbitrary), and using `return` statements to send results back. Examples include a happy birthday song and an invoice generator.

Further explore function arguments: default arguments for flexibility and reducing argument count, keyword arguments for readability and order independence, and arbitrary arguments (`*args` and `**kwargs`) for handling varying numbers of inputs, demonstrated with a phone number generator and shipping label printer.

Understand iterables as objects that can return elements one at a time, allowing for iteration with `for` loops. This includes lists, tuples, sets, strings, and dictionaries. Membership operators (`in` and `not in`) are explained for checking if a value exists within an iterable, with examples like a secret word game and searching student grades.

Learn list comprehensions for concise list creation, including applying expressions and conditional logic. Match-case statements are introduced as a cleaner alternative to multiple `elif` statements for conditional execution, like determining the day of the week or weekend status.

Explore Python modules for organizing code into reusable files, covering built-in modules like `math` and creating custom modules. This leads into variable scope (local, enclosed, global, built-in) and the LEGB rule for scope resolution.

Unravel the `if __name__ == '__main__'` idiom for controlling script execution when imported vs. run directly. This transitions into the foundational concepts of OOP: objects (bundles of attributes and methods) and classes (blueprints for objects), using a `Car` class as an example.

Understand class variables (shared among all instances) versus instance variables (unique to each object). Inheritance is introduced as a core OOP principle, allowing child classes to inherit attributes and methods from parent classes, demonstrated with `Animal`, `Dog`, `Cat`, and `Mouse` classes.

Dive deeper into inheritance with multiple inheritance (inheriting from multiple parents) and multi-level inheritance (inheriting through a chain of classes). The `super()` function is explained for calling parent class methods within a child class, enhancing method overriding and constructor reuse in shape classes.

Explore polymorphism in Python, explaining how objects can take on many forms through inheritance and duck typing. Duck typing is detailed as treating objects based on their methods and attributes rather than their class, exemplified by `Animal`, `Dog`, `Cat`, and `Car` classes demonstrating their 'speak' or 'horn' methods.

Differentiate between static methods (belong to the class, no `self`), class methods (operate on class-level data, use `cls`), and instance methods (operate on instance data, use `self`). Magic methods (dunder methods like `__init__`, `__str__`, `__eq__`, `__lt__`, `__add__`, `__contains__`, `__getitem__`) are introduced for customizing object behavior with built-in Python operations.

Learn about the `@property` decorator to access methods as attributes, providing getter, setter, and deleter functionality for controlled attribute access with additional logic. Exception handling (`try-except-finally`) is covered to gracefully manage program interruptions caused by errors like `ZeroDivisionError`, `ValueError`, `FileNotFoundError`, and `PermissionError`.

Master file handling in Python, starting with `os.path` for file detection (existence check, `is_file`, `is_dir`). Progress to writing various file types (plain text, JSON, CSV) using `with open()` and the `json` and `csv` modules, then reading corresponding files and extracting data.

Introduction to working with dates and times using Python's `datetime` module. Learn to create `date`, `time`, and `datetime` objects, format their string representation, and compare date-time objects to check if a target date has passed.

Build a functional alarm clock using `pygame` for sound, `datetime` for time tracking, and `time` for delays. The application prompts the user for an alarm time in military format and plays an MP3 file when the current time matches the set alarm.

Discover `multi-threading` to perform multiple tasks concurrently, ideal for I/O-bound operations. Learn how to create and manage `Thread` objects, pass arguments to target functions, and use `join()` to ensure threads complete before the main program proceeds, demonstrated with chore completion tasks.

Learn how to connect to web APIs using the `requests` library. The PokeAPI is used as a practical example to fetch Pokémon data (name, ID, height, weight), handle API responses (HTTP status codes), and parse JSON data into Python dictionaries.

An introduction to building graphical user interfaces (GUIs) with PyQt5. This expansive section covers creating basic windows, adding text labels, displaying images using QPixmap, and organizing widgets with vertical, horizontal, and grid layouts (QVBoxLayout, QHBoxLayout, QGridLayout). It also details setting window titles, geometry, and icons for a well-structured interface.

Further PyQt5 GUI development, focusing on interactive elements: creating and handling QPushButtons (connecting signals to slots, enabling/disabling), QCheckBoxes (managing checked states), QRadioButtons (grouping and determining selection), and QLineEdit widgets (text input and retrieval). This portion also provides an in-depth explanation of setting dynamic stylesheets with CSS-like properties for individual widgets or entire classes, including selectors and pseudo-classes for advanced styling.

Build a functional digital clock widget using PyQt5, incorporating QTimer for updating time every second, QTime for time tracking, and custom fonts for aesthetic appeal. This is followed by the creation of a sophisticated stopwatch program, detailing the implementation of start, stop, and reset functionalities with precise time formatting and responsive button interactions.

The culminating project: a real-time weather application built with PyQt5. This comprehensive segment walks through integrating external APIs (OpenWeatherMap) to fetch weather data, handling API keys, parsing JSON responses, performing temperature conversions (Kelvin to Celsius/Fahrenheit), and dynamically updating GUI elements (temperature, weather description, emojis) based on the retrieved data. It also emphasizes robust error handling for API requests and input validation for a user-friendly experience.