updated code

Author: Henry

.github/workflows/run-program.yml

@@ -1,5 +1,11 @@
 # 🐍 Henry’s Python Learning Journey
 
+## 📅 Progress
+
+```diff
+[⬜⬜-----------------------] 2%
+```
+
 ### `print("On a Python Learning Journey, Eyo ✌🏾")`
 
 Hey there! 👋  
@@ -10,6 +16,4 @@ Each one is a small step toward becoming a full-stack developer.
 
 ## 📆 Day Counter
 
-<!-- PYTHON_DAY_COUNTER -->
-Day 0 of Python Coding
-<!-- PYTHON_DAY_COUNTER_END -->
+✨ **Day 7 of Learning Python** ✨

.idea/.gitignore

@@ -0,0 +1,190 @@
+### ✅ Class
+"""
+A class in python is a blueprint for creating objects.
+It groups related data (attributes) and actions (methods) together.
+Think of a class like a template;
+where it defines characteristics like color, size, etc...
+"""
+class Book:
+    pass
+
+
+### ✅ Object:
+"""
+An object is an instance of a class in Python. It represents a specific 
+example of the blueprint defined by class. Now with our Dog; 
+If Dog is a class, then `variable` my_dog could be an object representing a specific dog with
+it's details or functions, like name or age.
+"""
+
+class Dog:
+    def __init__(self, name, age):
+        self.name = name
+        self.age = age
+
+# Object of the Dog class
+my_dog = Dog("Schrodinger", 5)
+
+
+### ✅ Inheritance
+"""
+Inheritance allows you to create a new class that uses the features of 
+an already existing class without necessarily changing it.
+
+This lets you build on existing functionality while keeping the original 
+class intact.
+"""
+
+class Animal:
+    def __init__(self, name):
+        self.name = name
+
+    def spreche(self):
+        print(f"{self.name} sagst: Sei zufrienden")
+
+#Derived class
+class Dog(Animal):
+    def spreche(self):
+        print(f"{self.name} bellst")
+
+
+# Creating an object for the dog class
+my_dog =Dog("Arf")
+my_dog.spreche()  # Output: Arf bellst
+'''
+Dog is a derived class which inherits from Animal class.
+---
+Overrides spreche(speak) method to provide a behaviour for parsed in (Animal).
+'''
+
+
+### ✅ Encapsulation
+"""
+In Python's Object-Oriented Programming (OOP), we can restrict access 
+to methods and variables to prevent direct modification, 
+especially when dealing with multiple lines of codes all performing various functions.
+This is referred to as encapsulation.
+"""
+
+class Person:
+    def __init__(self, name, age):
+        self.name = name
+        self.__age = age    #Private attribute
+
+    def get_age(self):
+        return self.__age   #Accessor method
+
+person = Person("Alice", 30)
+print(person.get_age())     #Gives an output of 30
+
+'''
+It's noted from this example that the 'the__age attribute is private,
+and can only be accessed by calling the get_age() method.
+'''
+
+
+### ✅ Polymorphism:
+"""
+Polymorphism really means "more than one forms." In programming (python🤧),
+polymorphism allows a single entity (like a method, operator, or object)
+to take on different forms and behave differently in various scenarios, as needed. 
+"""
+
+class Pferd:
+    def speak(self):
+        print("Neigh")
+
+class Eule:
+    def speak(self):
+        print("Hoot")
+
+def animal_speak(animal):
+    animal.speak()
+
+# Using polymorphism
+pferd = Pferd()
+eule = Eule()
+
+animal_speak(pferd)  # Neigh
+animal_speak(eule)   # Hoot
+
+
+
+        ### Try Area
+
+## Basic Functions
+'''
+functions are simple, and does'nt include any aparameters or return values
+and performs a single task, like so...;
+'''
+def greet():
+    print("Hallo, Leute!")
+
+
+## Functions with parameters
+#: functions accepting parameters are more flexible and readable.
+def greet(name):
+    print(f"Hallo, {name}")
+
+
+## Functions with Return Values
+'''
+functions return values, used instead of printing,
+allowing caller to use the result, return ends the code and starts outside the function(def).
+'''
+def add(a, b):
+    return a + b
+result = add(3, 5)
+print(result)
+
+
+## Functions with Default Parameters
+#: Introducing default parameters makes the function to be more versatile.
+def greet(name="Welt"):
+    print(f"Hallo, {name}!")
+greet()
+greet("Henify_") # Replaces name="..." value to Henify_
+
+
+## Functions with Variable Arguments
+'''
+Using " *args and **kwargs" in python lets 
+functions to handle variable number arguments.
+'''
+
+def add_all(*args):       # With *args
+    return sum(args)
+print(add_all(1, 2, 3, 4, 5))
+
+def print_info(**kwargs)  # With **kwargs
+    for key, value in kwargs.items():
+        print(f"{key}: {value}")
+
+print_info(name="Henry", age=17)
+
+
+## Intermediate Functions (Higher_Order_Functions, Lambdas, and Decorators)
+'''
+Higher level functions; these functions take other functions as arguments or return them.
+Lambdas; Anonymous, inline functions.
+Decorators: Modifies behaviour of other functions
+'''
+
+def apply_functions(func, value):
+    return func(value)
+print(apply_functions(lambda x: x**2, 5))
+
+def decorator(func):
+    def wrapper():
+        print("Before function call")
+        func()
+        print("After function call")
+    return wrapper()
+
+@decorator  #Decorator
+def say_hello():
+    print("Hallo ✌🏾")
+say_hello()
+
+
+