Open Forem: Ramya .C

Day 71 of My Learning Journey !

Ramya .C — Fri, 12 Dec 2025 05:44:39 +0000

🚀 — Working With Upcoming Wednesday Logic

#RamyaAnalyticsJourney

Today’s challenge was a fun mix of logic and SQL date functions.
The task: Create a table with names and appointment dates, then write a query that always returns all appointments scheduled before the upcoming Wednesday, based on the current date.

Even though it sounds simple, the tricky part was calculating the next Wednesday dynamically.

🛠️ Step 1: Create the Table

CREATE TABLE appointments (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100),
    appointment_date DATE
);

🗂️ Step 2: Insert Sample Appointment Data

INSERT INTO appointments (name, appointment_date) VALUES
('John', '2025-01-13'),
('Sarah', '2025-01-15'),
('Michael', '2025-01-10'),
('Anna', '2025-01-14');

🔍 Step 3: Query Appointments Before the Upcoming Wednesday

SELECT name, appointment_date
FROM appointments
WHERE appointment_date < (
    CURRENT_DATE + ((3 - EXTRACT(DOW FROM CURRENT_DATE) + 7) % 7)
);

🧠 How the Logic Works

EXTRACT(DOW FROM CURRENT_DATE) returns the current day of the week (0 = Sunday, 1 = Monday, … 3 = Wednesday, … 6 = Saturday).
(3 - dow + 7) % 7 calculates how many days until the next Wednesday (day 3).
Adding this to CURRENT_DATE gives the date of the upcoming Wednesday.
The query returns all appointments before that date.

This kind of hands-on exercise is perfect for strengthening SQL foundations and learning how to handle dynamic date logic—something you’ll constantly use in real-world data work.

🚀 Wrapping Up

Day by day, challenge by challenge, I’m gaining more confidence in SQL.
Looking forward to what tomorrow brings!

**#SQL #DataEngineering #Database #LearningJourney #WomenInTech #CareerGrowth #DataDriven #RamyaAnalyticsJourney

🚀 Day 70 of My Data Analytics Journey!

Ramya .C — Wed, 10 Dec 2025 13:18:47 +0000

Today marks another step forward in my data analytics learning path. Over the last two days, I focused on working with live data, transforming it, and preparing it for analysis using different tools.

🔧 What I Worked On

Retrieved live data from an API
Converted JSON data to Excel using Power Query
Fetched weather data for four cities: Chennai, Bangalore, Mumbai, and Kolkata
Combined all four city datasets into a single Excel sheet for better comparison and analysis

💡 What I Learned

This task helped me understand more about:

Data extraction and automation
Transforming and cleaning data formats
Consolidating multi-source data into a structured format
Using Excel + Power Query more efficiently

🌱 Moving Forward

Every day I’m becoming more confident with data workflows. I’m excited to continue exploring more real-world projects and strengthening my analytics skills.

If you're on a similar learning journey, keep going—consistent practice leads to real growth!

#RamyaAnalyticsJourney #daybyday

🌤️ Day 69 of My Data Analytics Journey

Ramya .C — Wed, 10 Dec 2025 07:50:45 +0000

Diving Into Live Weather Data with APIs, JSON & Power Query

Today is Day 69 of my Data Analytics journey, and it turned out to be one of the most hands-on learning days so far. I officially started my Weather Data Project, which focuses on collecting real-time weather information, transforming it, and preparing it for future dashboards and analytics.

This project is important for me because it combines multiple skills I’ve been learning:
✔ Working with APIs
✔ Understanding JSON structures
✔ Loading data into Excel
✔ Using Power Query for transformations
✔ Documenting data for analysis

This is the type of real-world workflow data analysts perform daily — so it feels exciting to build something end-to-end.

☁️ Project Overview

The goal of this project is simple:

Connect to a live weather API → Load the JSON data into Excel → Clean, transform, and analyze it.

By the end of the project, I want to build:

an automated Excel dashboard (or Power BI dashboard later),
visualizations showing temperature, humidity, and climate patterns,
and possibly a refreshable daily weather log.

🔧 Step-by-Step Progress Today

1. Identifying a Live Weather API

I started by choosing a weather service that offers:

real-time data,
free API key access,
and JSON response format.

This allowed me to work with a real, constantly changing dataset — perfect for learning.

2. Signing In & Generating My API Key

After registering, I received my personal API key.
This key allows me to:

access authenticated endpoints
request live weather information
customize parameters (city, units, format, etc.)

I stored it safely because API keys should always remain private.

3. Exploring & Understanding the JSON Data

Before loading data anywhere, I copied the API URL into a browser and examined the raw JSON.

This helped me understand:

what fields were available,
how nested the structure was,
and which fields mattered (temperature, humidity, windspeed, etc.)

This step is crucial because JSON can often contain many nested objects and arrays.

4. Loading JSON Data Into Excel Using Power Query

My main tool today was Power Query, which is amazing for data extraction and transformation.

The process I followed:

Go to Data → From Web
Paste the API URL with the key
Power Query identifies the JSON structure
I expanded fields into table columns
Converted data types
Cleaned unnecessary fields

❗ Issue I Faced (Important Learning Moment)

The first time I tried loading the JSON:

Excel refused to open the data
The query wouldn’t load
I kept getting a blank or error output

After researching, I realized my local Excel version needed the Power Query add-in installed.

So I:

Downloaded the standalone Power Query
Signed into my Microsoft account
Restarted Excel
Reconnected to the API

And finally… it worked! 🎉

This was a good reminder that real-world data work also involves environment setup, plugin issues, version compatibility, and troubleshooting.

🧹 5. Data Transformation & Additional Columns

Once the data loaded successfully:

I added new columns (like Celsius → Fahrenheit conversion)
Set correct data types
Added a "Description" column for metadata
Documented what each field means
Cleaned the structure to prepare for analysis

This process helped me understand how important proper documentation is for future dashboards.

🚀 What’s Coming Next?

For the next few days, my plan is to:

🔜 1. Build a clean transformed dataset

Remove unnecessary fields, rename columns, and standardize types.

🔜 2. Create visualizations

Temperature trend charts
Humidity patterns
Wind speed comparison
Daily weather summary

🔜 3. Automate the data refresh

So Excel updates the data whenever I click Refresh.

🔜 4. Write clean documentation

So the workflow is clear and reproducible.

Eventually, I may move this project into Power BI to create a fully interactive weather dashboard.

🌱 Reflections

Day 69 taught me a valuable lesson:

Learning data analytics isn’t just about tools — it’s also about problem-solving, debugging, and understanding how data flows from source to analysis.

I’m proud of today’s progress and excited to keep building!

🏷 Tags

#DataAnalytics #API #JSON #PowerQuery #Excel
#Day69 #LearningInPublic #WeatherData
#WomenInTech #RamyaAnalyticsJourney

🚀 Day 66–67 Learning Log

Ramya .C — Mon, 24 Nov 2025 05:57:14 +0000

Pattern Programs, Email & Password Utilities in Python

#100DaysOfCode • #Python • #BeginnerToPro • #RamyaAnalyticsJourney

Here is a summary of everything I practiced and built during Day 66–67 of my coding journey.
I focused on pattern problems, email utilities, and password utilities — all useful for interviews and real-world coding.

⭐ 1. Pattern Programming (Stars & Numbers)

✔ Star Pyramid

rows = 5
for i in range(1, rows + 1):
    print("* " * i)

✔ Right-Aligned Triangle

rows = 5
for i in range(1, rows + 1):
    print(" " * (rows - i) + "* " * i)

✔ Number Triangle

rows = 5
for i in range(1, rows + 1):
    for j in range(1, i + 1):
        print(j, end=" ")
    print()

✔ Reverse Pattern (using name)

name = "ramya"
length = len(name)

for i in range(length, 0, -1):
    for j in range(0, i):
        print(name[j], end=" ")
    print()

📧 2. Email Generator

name = input("Enter your name: ").lower().replace(" ", "")
domain = "gmail.com"

email = name + "@"+ domain
print("Generated Email:", email)

✔ 3. Email Validator (Regex)

import re

email = input("Enter email: ")

pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$'

if re.match(pattern, email):
    print("Valid Email")
else:
    print("Invalid Email")

🔐 4. Password Generator

import random
import string

length = 10
password = ''.join(random.choice(string.ascii_letters + string.digits + string.punctuation) 
                   for _ in range(length))

print("Generated Password:", password)

🔍 5. Password Validator

import re

password = input("Enter password: ")

pattern = r'^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@$!%*?&])[A-Za-z\\d@$!%*?&]{8,}$'

if re.match(pattern):
    print("Strong Password ✔")
else:
    print("Weak Password ❌")

📝 What I Learned

Strengthened logical thinking
Improved nested loops & regex
Built practical utilities
Gained confidence for interview-style problems

🔗 GitHub Project Link

👉 GitHub:https://github.com/ramyacse21/python-workspace/blob/main/python%20practice%20(spl%20class).py

Python #CodingJourney #RamyaAnalyticsJourney #LearningLog #WomenInTech #CodeNewbie #Developers

Day 65: Web Development & Version Control Progress 🚀

Ramya .C — Tue, 18 Nov 2025 12:13:27 +0000

Today, I made significant strides in enhancing my web development skills and understanding of version control:

HTML: Learned about various tags, elements, and their types, along with how to use them effectively.
Web Structure: Gained insights into structuring web pages using <header>, <body>, and <footer>.
CSS: Started exploring how to style web pages for better visual appeal.
VS Code & GitLab: Learned how to connect VS Code with GitLab for streamlined development.
GitLab Skills: Practiced cloning repositories and creating groups to organize projects efficiently.

Excited about progressing further and building more dynamic, styled websites! 💻✨

📊NumPy Practice !

Ramya .C — Sun, 16 Nov 2025 08:28:27 +0000

🔢 Building Strong Data Analytics Foundations 🚀

Today I focused on improving my Python skills by practicing NumPy, one of the most powerful libraries used in Data Analytics and Machine Learning.
NumPy makes numerical operations faster, cleaner, and more efficient—especially when working with large datasets.

🔍 What I Practiced

✔️ Basic Array Operations

Creating arrays: array(), arange(), linspace()
Indexing & slicing (1D, 2D, 3D)
Mathematical & statistical operations
Broadcasting
Reshaping arrays with reshape()

✔️ Intermediate Operations

Horizontal & vertical stacking
Boolean filtering
Using the random module:

  np.random.rand()
  np.random.randn()
  np.random.randint()

Vectorization for fast computations

🔥 Additional Advanced Practice

📌 Matrix Multiplication

np.dot(a, b)
np.matmul(a, b)

📌 Conditional Selection

np.where(condition, value_if_true, value_if_false)

📌 Sorting & Unique Values

np.sort(arr)
np.unique(arr)

📌 Loading CSV Files

np.genfromtxt("data.csv", delimiter=",")

📌 Performance Practice

Compared memory usage of Python lists vs NumPy arrays
Used %timeit in Jupyter Notebook for speed comparison

🧠 Why NumPy Matters in Data Analytics?

Extremely fast numerical operations
Clean, simple, and vectorized code
Foundation for Pandas, Matplotlib, Scikit-Learn
Widely used in data preprocessing and ML models

🔗 GitHub Repository

You can check my NumPy practice code here:
👉 GitHub: https://github.com/ramyacse21/numpy_workspace

📊 Day 64 of My Data Analytics Journey!

Ramya .C — Sun, 16 Nov 2025 08:20:31 +0000

— Learning Matplotlib (All Charts Explained!)

Today, I worked with Matplotlib, the most fundamental Python library for data visualization.
It allows you to turn raw data into meaningful graphs that help in understanding patterns, trends, and insights.

🔥 What I Learned — Matplotlib Chart Types

Below are the essential chart types every Data Analyst should know:

1️⃣ Line Chart

Used to show trends over time.
Use case: Monthly sales trend.

import matplotlib.pyplot as plt

x = [1,2,3,4,5]
y = [10, 20, 15, 25, 30]

plt.plot(x, y)
plt.title("Line Chart")
plt.xlabel("Months")
plt.ylabel("Sales")
plt.show()

2️⃣ Bar Chart

Used to compare categories.

categories = ["A", "B", "C"]
values = [20, 35, 30]

plt.bar(categories, values)
plt.title("Bar Chart")
plt.show()

3️⃣ Histogram

Shows the distribution of data.

data = [22,25,29,21,28,30,27,26,32,24]

plt.hist(data, bins=5)
plt.title("Histogram")
plt.show()

4️⃣ Scatter Plot

Used to find the relationship between two variables.

x = [1,2,3,4,5]
y = [5,20,15,25,30]

plt.scatter(x, y)
plt.title("Scatter Plot")
plt.show()

5️⃣ Pie Chart

Used to show parts of a whole.

sizes = [30,25,20,25]
labels = ["A","B","C","D"]

plt.pie(sizes, labels=labels, autopct="%1.1f%%")
plt.title("Pie Chart")
plt.show()

6️⃣ Box Plot

Helps identify data spread and outliers.

data = [22,25,29,21,28,30,27,26,32,24]

plt.boxplot(data)
plt.title("Box Plot")
plt.show()

7️⃣ Area Chart

Shows cumulative progress.

x = [1,2,3,4,5]
y = [3,8,2,10,5]

plt.fill_between(x, y)
plt.title("Area Chart")
plt.show()

8️⃣ Heatmap (Using seaborn for better visuals)

Helps show patterns between variables.

import seaborn as sns
import numpy as np

data = np.random.rand(5,5)
sns.heatmap(data, annot=True)
plt.title("Heatmap")
plt.show()

✨ Additional Things I Practiced

Customized chart colors and styles
Adjusted figure sizes
Added labels, legends, and titles
Created multiple plots using subplot()
Saved charts as images

These visualizations help communicate insights clearly — a must-have skill for Data Analysts.

🚀 Consistency is my strength. Day 64 completed.

RamyaAnalyticsJourney

🔗 GitHub Link:

https://github.com/ramyacse21/matplotlib_python/blob/main/practice%20matplotlib%20pie%20chart.py
https://github.com/ramyacse21/matplotlib_python/blob/main/practice%20matplotlib.py

Day 63 of My Data Analytics Journey!

Ramya .C — Thu, 13 Nov 2025 17:47:02 +0000

🧠 Day 63 of My #RamyaAnalyticsJourney — Exception Handling in Python

Hello everyone! 👋
Today marks Day 63 of my Data Analytics learning journey.
I explored an important concept in Python — Exception Handling — which helps make our programs more reliable and user-friendly.

💡 What is Exception Handling?

In Python, Exception Handling is a way to manage errors that occur during program execution.
Instead of letting the program crash when an error happens, Python allows us to catch and handle those errors gracefully.

An exception is an event that disrupts the normal flow of a program.
For example, dividing a number by zero, opening a non-existent file, or converting invalid input to an integer — all these can cause exceptions.

⚙️ Why Exception Handling is Important

✅ Prevents program crashes
✅ Helps debug errors easily
✅ Makes code cleaner and more professional
✅ Improves user experience by providing clear error messages

🧩 Basic Syntax

try:
    # Code that might cause an error
    x = 10 / 0
except ZeroDivisionError:
    # Code that runs if an error occurs
    print("Error: You can’t divide by zero!")
else:
    # Code that runs if no error occurs
    print("Division successful!")
finally:
    # Code that always runs
    print("Execution completed.")

🧠 Output:

Error: You can’t divide by zero!
Execution completed.

🧰 Raising Custom Exceptions

We can also raise our own exceptions using the raise keyword.

age = int(input("Enter your age: "))

if age < 18:
    raise ValueError("You must be at least 18 years old.")
else:
    print("You are eligible!")

If the user enters a number less than 18, Python will raise a custom error message.

🧾 Summary

Keyword	Description
`try`	Block where you place the code that may throw an exception
`except`	Handles the exception if it occurs
`else`	Executes if no exception occurs
`finally`	Executes whether an exception occurs or not
`raise`	Used to throw an exception manually

🚀 My Takeaway

Understanding Exception Handling is crucial for writing clean, safe, and professional Python code — especially in data analytics projects where errors can appear from data input, file reading, or API requests.

Every small concept learned builds confidence towards becoming a Data Analyst 💪

Python #DataAnalytics #Coding #ExceptionHandling #RamyaAnalyticsJourney #LearnToCode

Day 62 of My Data Analytics Journey !

Ramya .C — Sat, 08 Nov 2025 15:37:20 +0000

SQL Mock Interview Experience

Today, I attended a mock interview focused on SQL. It was a great experience that tested both my theoretical understanding and practical skills.
Here are the questions I faced and how I answered them 👇

💬 1. Self Introduction

I introduced myself as Ramya, a budding Data Analyst, currently learning SQL, Python, and visualization tools. I mentioned my goal — to become a professional Data Analyst and share my daily learning journey online.

🗂️ 2. What databases have you used?

✅ I have worked with:

MySQL – for structured data and query practice.
PostgreSQL – for advanced queries and joins.
SQLite – for small projects and data analysis tasks.

🔗 3. What are Joins in SQL?

Joins combine data from two or more tables based on a related column.

Type	Description
INNER JOIN	Returns only matching rows between both tables.
LEFT JOIN	Returns all rows from the left table and matched rows from the right.
RIGHT JOIN	Returns all rows from the right table and matched rows from the left.
FULL JOIN	Returns all rows when there’s a match in either table.

🧩 Example:

SELECT students.name, departments.dept_name
FROM students
INNER JOIN departments
ON students.dept_id = departments.dept_id;

🪟 4. What is a Window Function?

A window function performs calculations across a set of rows related to the current row — like ranking or cumulative totals.

Example:

SELECT student_name, department,
       RANK() OVER (PARTITION BY department ORDER BY marks DESC) AS rank
FROM students;

👉 This gives the rank of each student within their department.

⚙️ 5. What is a Stored Procedure?

A stored procedure is a pre-written SQL code that can be saved and reused.

Example:

CREATE PROCEDURE GetStudents()
BEGIN
   SELECT * FROM students;
END;

Then we can call it using:

CALL GetStudents();

👩‍🎓 6. Find how many students in each department

Query:

SELECT department, COUNT(student_id) AS total_students
FROM students
GROUP BY department;

🧠 This query uses the GROUP BY clause to count students department-wise.

📈 7. What is Indexing?

An index speeds up data retrieval from a database table.
It works like a book index — helps find information faster.

Example:

CREATE INDEX idx_student_name ON students(student_name);

🧩 8. What is Partitioning?

Partitioning divides a large table into smaller, manageable pieces while keeping them as one logical table.
It improves performance and maintenance.

Example:

CREATE TABLE sales (
  id INT,
  amount DECIMAL(10,2),
  sale_date DATE
)
PARTITION BY RANGE (YEAR(sale_date)) (
  PARTITION p2024 VALUES LESS THAN (2025),
  PARTITION p2025 VALUES LESS THAN (2026)
);

🔑 9. Difference between Primary Key and Foreign Key

Key Type	Description	Example
Primary Key	Uniquely identifies each record in a table.	`student_id` in `students` table
Foreign Key	Refers to the primary key of another table.	`dept_id` in `students` referring to `departments`

🌱 My Takeaway

The interview gave me confidence and helped me realize areas I can improve — especially in explaining SQL logic more clearly.

#Day62 #RamyaAnalyticsJourney #DataAnalytics #SQL #MockInterview #LearningInPublic #Database #Joins #WindowFunctions #StoredProcedure #Indexing #PrimaryKey #ForeignKey #Partitioning

📊 Day 61 of My Data Analytics Journey!

Ramya .C — Thu, 06 Nov 2025 16:10:31 +0000

Today I focused on improving my data visualization skills using Matplotlib, one of the most powerful Python libraries for creating charts and plots.

Visualization is an important part of Data Analytics because it helps to communicate patterns, trends, and insights clearly. Today, I explored how to add labels, titles, colors, and shapes, and also learned about different types of charts used in data analysis.

🎯 What I Learned Today

🏷️ Adding Titles and Labels

A chart without a title or labels can be confusing.

Title explains what the chart is about.
X-label and Y-label tell what each axis represents.

import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5]
y = [10, 20, 25, 30, 35]

plt.plot(x, y)
plt.title("Sales Growth Over 5 Months")     # Chart title
plt.xlabel("Month")                         # X-axis label
plt.ylabel("Sales (in thousands)")          # Y-axis label
plt.show()

🎨 Changing Colors and Shapes

Color helps in highlighting key insights. You can change line style, marker, and color easily.

plt.plot(x, y, color='orange', marker='o', linestyle='--')
plt.title("Customized Line Chart")
plt.xlabel("Month")
plt.ylabel("Sales (in thousands)")
plt.show()

You can experiment with:

Colors: 'red', 'blue', 'green', 'purple'
Markers: 'o', 's', '^', 'D'
Line Styles: '-', '--', ':', '-. '

📊 Types of Charts I Explored

Line Chart – Best for showing trends over time.
Bar Chart – Great for comparing categories or groups.
Pie Chart – Shows proportion or percentage of categories.
Scatter Plot – Useful for showing relationships between two variables.

Example:

# Bar Chart
categories = ['A', 'B', 'C', 'D']
values = [23, 45, 56, 78]

plt.bar(categories, values, color='teal')
plt.title("Category Comparison")
plt.xlabel("Category")
plt.ylabel("Values")
plt.show()

💡 Key Takeaways

Labels and titles make charts more readable.
Choosing the right color and shape improves visual impact.
Each chart type has its own purpose — use them wisely!
Visualization turns raw data into visual stories that are easy to understand.

I’m feeling more confident in creating meaningful visuals and understanding how presentation can make a big difference in data storytelling.
Can’t wait to explore more advanced charts like histograms, box plots, and heatmaps next! 🔥

#DataAnalytics #Matplotlib #Python #DataVisualization #LearningJourney #RamyaAnalyticsJourney

Day 60 of My Data Analytics Journey !

Ramya .C — Wed, 05 Nov 2025 15:33:21 +0000

📊 Introduction to Matplotlib in Python

Hey everyone!
Today marks Day 60 of my Data Analytics journey, and I started exploring Matplotlib in Python. Super happy to finally step into the world of data visualization! 🚀

✅ What is Matplotlib?

Matplotlib is one of the most popular Python libraries used to create visualizations like:

Line charts
Bar charts
Scatter plots
Histograms
Pie charts

It helps transform raw data into meaningful visual insights. In simple words, Matplotlib helps us see what the data is trying to say.

🎯 Why do we use Matplotlib?

Reason	Description
Data Understanding	Helps identify trends & patterns easily
Easy to Use	Simple functions to plot charts
Customizable	Colors, labels, styles, everything can be edited
Widely Used	Popular in Data Analytics, ML, Finance, Research

Data visualization is a crucial skill for every Data Analyst, and Matplotlib gives a strong foundation.

🧪 Getting Started with Matplotlib

✔️ Step 1: Install Matplotlib (if not installed)

pip install matplotlib

✔️ Step 2: Import the library

import matplotlib.pyplot as plt

📈 Example 1: Simple Line Chart

import matplotlib.pyplot as plt

# Sample data
x = [1, 2, 3, 4, 5]
y = [10, 20, 15, 25, 30]

# Line chart
plt.plot(x, y)
plt.title("Simple Line Chart")
plt.xlabel("X Axis")
plt.ylabel("Y Axis")
plt.show()

✅ This code will plot a simple line showing values increasing and dropping.

📊 Example 2: Bar Chart

import matplotlib.pyplot as plt

students = ['Ramya', 'Priya', 'Kavi', 'Asha', 'Meena']
scores = [85, 90, 75, 95, 80]

plt.bar(students, scores)
plt.title("Student Score Comparison")
plt.xlabel("Students")
plt.ylabel("Scores")
plt.show()

This compares marks of students using a bar graph.

🔵 Example 3: Scatter Plot

import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5]
y = [5, 10, 8, 15, 12]

plt.scatter(x, y)
plt.title("Simple Scatter Plot")
plt.xlabel("X Values")
plt.ylabel("Y Values")
plt.show()

Scatter plots help analyze relationships between variables.

🎉 Conclusion

Learning Matplotlib feels like unlocking a superpower for data storytelling!
Understanding graphs is essential for Data Analytics, and this is just the beginning. Excited to explore histograms, pie charts, subplots, and styling features next. 🚀

🚀 Day 59 of My Data Analytics Journey !

Ramya .C — Sun, 02 Nov 2025 15:56:09 +0000

💥Understanding OOP in Python

Today I explored Object-Oriented Programming (OOP) in Python — a very important concept in software development and data analytics.

OOP helps us write clean, reusable, and scalable code, especially when building data pipelines and machine learning projects.

🧠 What is OOP?

OOP is a programming approach where we organize code using Classes and Objects.

✅ Class

A class is a blueprint/template for objects.

✅ Object

An object is an instance of a class.

📌 Example

class Student:
    def __init__(self, name):
        self.name = name

s1 = Student("Ramya")
print(s1.name)

🏛️ Four Pillars of OOP With Examples

1️⃣ Encapsulation

Encapsulation means wrapping data (variables) and methods together, and controlling access.

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance   # private variable

    def deposit(self, amount):
        self.__balance += amount

    def get_balance(self):
        return self.__balance

acc = BankAccount(5000)
acc.deposit(2000)
print(acc.get_balance())

Why useful: Hides sensitive data like user credentials or balance.

2️⃣ Inheritance

Inheritance allows one class to acquire properties of another class.

class Animal:
    def sound(self):
        print("Animals make sound")

class Dog(Animal):
    def sound(self):
        print("Dog barks")

d = Dog()
d.sound()

Why useful: Helps reuse code — no repeating functions.

3️⃣ Polymorphism

Polymorphism means same function name, different behavior.

class Shape:
    def area(self):
        pass

class Square(Shape):
    def area(self):
        return "Area = side * side"

class Circle(Shape):
    def area(self):
        return "Area = π * r * r"

print(Square().area())
print(Circle().area())

Why useful: Makes code flexible — same function works differently depending on object.

4️⃣ Abstraction

Abstraction means hiding implementation details and showing only necessary information.

from abc import ABC, abstractmethod

class Vehicle(ABC):
    @abstractmethod
    def start(self):
        pass

class Car(Vehicle):
    def start(self):
        print("Car engine starts")

c = Car()
c.start()

Why useful: Simplifies complex code, improves security.

💡 Why OOP is useful in Data Analytics?

✅ Reusable data preprocessing functions
✅ Cleaner code for ML pipelines
✅ Object models for datasets, features, models
✅ Better collaboration & scalability

👣 My Progress Continues

Today was all about foundations, and these concepts are key for becoming a professional Data Analyst and understanding machine learning frameworks like Scikit-Learn, PyTorch, etc.

More learning every day… one step at a time 💪

🏷️ Tags

#python #beginners #dataanalytics #learning #oop #devto