Real-World Applications

Real-World Applications of Python Programming

Master Python's real-world applications with free flashcards and hands-on coding examples. This lesson covers web development with Flask and Django, data analysis using pandas and NumPy, automation scripts for everyday tasks, and machine learning fundamentals—essential skills for building practical Python projects that solve actual problems in industry.

Welcome to Python in Action! 💻🌍

You've learned Python syntax, data structures, and algorithms—but where does Python actually shine in the real world? Python is one of the most versatile programming languages, powering everything from websites and mobile apps to scientific research and artificial intelligence. Understanding real-world applications transforms you from a syntax learner into a problem solver who can build tools that matter.

This lesson explores four major domains where Python excels:

1. Web Development - Building dynamic websites and APIs
2. Data Analysis & Visualization - Extracting insights from data
3. Automation & Scripting - Eliminating repetitive tasks
4. Machine Learning & AI - Creating intelligent systems

By the end, you'll understand not just how to code in Python, but what to build with it.

Core Concepts

1. Web Development with Python 🌐

Python powers millions of websites through frameworks like Flask and Django. These frameworks handle the backend logic—routing requests, managing databases, and serving dynamic content.

Flask: Lightweight and Flexible

Flask is a micro-framework perfect for small to medium projects. Here's a minimal web application:

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def home():
    return render_template('index.html')

@app.route('/api/users/<int:user_id>')
def get_user(user_id):
    # Fetch user from database
    user = {"id": user_id, "name": "Alice"}
    return user

if __name__ == '__main__':
    app.run(debug=True)

The @app.route() decorator maps URLs to Python functions. When someone visits /api/users/42, Flask calls get_user(42) and returns JSON data.

Django: Full-Featured Framework

Django follows the "batteries included" philosophy, providing authentication, admin panels, and ORM (Object-Relational Mapping) out of the box:

# models.py
from django.db import models

class BlogPost(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    published_date = models.DateTimeField(auto_now_add=True)
    
    def __str__(self):
        return self.title

# views.py
from django.shortcuts import render
from .models import BlogPost

def blog_list(request):
    posts = BlogPost.objects.all().order_by('-published_date')
    return render(request, 'blog/list.html', {'posts': posts})

Django's ORM lets you interact with databases using Python objects instead of raw SQL. The line BlogPost.objects.all() translates to SELECT * FROM blog_post.

💡 Tip: Use Flask for APIs and microservices; use Django for content-heavy sites with admin requirements.

Real-World Use Cases:

• Instagram (Django) - Photo sharing with billions of users
• Pinterest (Django + Flask) - Visual discovery engine
• Spotify (Flask APIs) - Music streaming backend services

2. Data Analysis & Visualization 📊

Python dominates data science thanks to pandas, NumPy, and matplotlib. These libraries turn raw data into actionable insights.

Pandas: Data Manipulation Powerhouse

Pandas provides DataFrames—spreadsheet-like structures for data analysis:

import pandas as pd

# Load sales data
df = pd.read_csv('sales_data.csv')

# Filter high-value transactions
high_value = df[df['amount'] > 1000]

# Group by region and calculate totals
regional_sales = df.groupby('region')['amount'].sum()

# Find top 5 products
top_products = df.groupby('product')['quantity'].sum().nlargest(5)

print(regional_sales)

Key Operations:

Operation	Pandas Method	Purpose
Filtering	df[df['col'] > value]	Select rows matching criteria
Grouping	df.groupby('col').sum()	Aggregate data by category
Sorting	df.sort_values('col')	Order rows
Missing Data	df.fillna(0)	Handle null values

NumPy: Numerical Computing

NumPy provides efficient array operations for mathematical computations:

import numpy as np

# Create array of sensor readings
temperatures = np.array([22.1, 23.5, 21.8, 24.2, 23.9])

# Statistical analysis
mean_temp = np.mean(temperatures)
std_dev = np.std(temperatures)

# Vectorized operations (no loops needed!)
celsius_temps = np.array([0, 10, 20, 30, 40])
fahrenheit_temps = (celsius_temps * 9/5) + 32
print(fahrenheit_temps)  # [32. 50. 68. 86. 104.]

Vectorization means operations apply to entire arrays at once—much faster than Python loops.

Visualization with Matplotlib

import matplotlib.pyplot as plt

# Create line chart
months = ['Jan', 'Feb', 'Mar', 'Apr', 'May']
revenue = [45000, 52000, 48000, 61000, 58000]

plt.figure(figsize=(10, 6))
plt.plot(months, revenue, marker='o', linewidth=2, color='#2E86DE')
plt.title('Monthly Revenue Growth', fontsize=16)
plt.xlabel('Month')
plt.ylabel('Revenue ($)')
plt.grid(True, alpha=0.3)
plt.show()

🤔 Did you know? Netflix uses Python with pandas to analyze viewer behavior and recommend shows. Their recommendation engine processes billions of data points daily!

Real-World Use Cases:

• Finance - Stock market analysis, risk modeling
• Healthcare - Patient outcome predictions, epidemic tracking
• E-commerce - Customer segmentation, sales forecasting

3. Automation & Scripting 🤖

Python excels at automation—writing scripts that handle repetitive tasks. This saves hours of manual work.

File Management Automation

import os
import shutil
from pathlib import Path

# Organize downloads folder by file type
def organize_downloads():
    downloads = Path.home() / 'Downloads'
    
    # Create category folders
    categories = {
        'Images': ['.jpg', '.png', '.gif', '.svg'],
        'Documents': ['.pdf', '.docx', '.txt', '.xlsx'],
        'Videos': ['.mp4', '.avi', '.mkv'],
        'Archives': ['.zip', '.tar', '.gz']
    }
    
    for category, extensions in categories.items():
        category_path = downloads / category
        category_path.mkdir(exist_ok=True)
        
        for ext in extensions:
            for file in downloads.glob(f'*{ext}'):
                shutil.move(str(file), str(category_path / file.name))
    
    print("Downloads organized!")

organize_downloads()

This script automatically sorts files into folders—run it once and save hours of manual dragging and dropping.

Web Scraping with Beautiful Soup

Web scraping extracts data from websites:

import requests
from bs4 import BeautifulSoup

# Scrape product prices
url = 'https://example-store.com/products'
response = requests.get(url)
soup = BeautifulSoup(response.content, 'html.parser')

# Find all product elements
products = soup.find_all('div', class_='product-card')

for product in products:
    name = product.find('h3', class_='product-name').text
    price = product.find('span', class_='price').text
    print(f"{name}: {price}")

⚠️ Important: Always check a website's robots.txt file and terms of service before scraping. Respect rate limits!

Email Automation

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

def send_report(recipient, report_data):
    msg = MIMEMultipart()
    msg['From'] = 'automation@company.com'
    msg['To'] = recipient
    msg['Subject'] = 'Daily Sales Report'
    
    body = f"""
    Sales Summary:
    Total Revenue: ${report_data['revenue']}
    Orders: {report_data['orders']}
    Top Product: {report_data['top_product']}
    """
    
    msg.attach(MIMEText(body, 'plain'))
    
    with smtplib.SMTP('smtp.gmail.com', 587) as server:
        server.starttls()
        server.login('automation@company.com', 'password')
        server.send_message(msg)

# Schedule this to run daily
report_data = {'revenue': 12450, 'orders': 89, 'top_product': 'Widget Pro'}
send_report('manager@company.com', report_data)

💡 Tip: Combine automation scripts with cron jobs (Linux/Mac) or Task Scheduler (Windows) to run them automatically at specific times.

Real-World Use Cases:

• System Administration - Log analysis, backup scripts
• Marketing - Social media post scheduling, email campaigns
• Testing - Automated quality assurance, regression testing

4. Machine Learning & AI 🧠

Machine learning enables computers to learn from data without explicit programming. Python's scikit-learn and TensorFlow make AI accessible.

Supervised Learning: Predictions from Data

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
import numpy as np

# Predict house prices based on square footage
# Features: [square_feet, bedrooms, age]
X = np.array([
    [1200, 2, 10],
    [1800, 3, 5],
    [2400, 4, 2],
    [1500, 3, 15],
    [2100, 3, 8]
])

# Target: price in thousands
y = np.array([250, 380, 520, 290, 450])

# Split data: 80% training, 20% testing
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Train model
model = LinearRegression()
model.fit(X_train, y_train)

# Make predictions
predictions = model.predict(X_test)
print(f"Predicted prices: {predictions}")
print(f"Actual prices: {y_test}")

# Evaluate accuracy
mse = mean_squared_error(y_test, predictions)
print(f"Mean Squared Error: {mse}")

Key ML Concepts:

Concept	Definition	Example
Training Data	Examples the model learns from	Historical house sales
Features	Input variables	Square feet, bedrooms
Target	Output to predict	House price
Model	Algorithm that learns patterns	Linear Regression

Classification: Categorizing Data

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

# Classify emails as spam (1) or not spam (0)
# Features: [word_count, link_count, caps_ratio]
X_train = np.array([
    [50, 0, 0.1],
    [200, 5, 0.8],
    [100, 1, 0.2],
    [300, 10, 0.9]
])
y_train = np.array([0, 1, 0, 1])  # 0=not spam, 1=spam

# Train classifier
clf = RandomForestClassifier(n_estimators=100)
clf.fit(X_train, y_train)

# Classify new email
new_email = np.array([[150, 7, 0.7]])
prediction = clf.predict(new_email)
print("Spam" if prediction[0] == 1 else "Not Spam")

Deep Learning with TensorFlow

import tensorflow as tf
from tensorflow import keras

# Build neural network for image classification
model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dropout(0.2),
    keras.layers.Dense(10, activation='softmax')
])

model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# Train on MNIST handwritten digits
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
x_train = x_train / 255.0  # Normalize pixel values

model.fit(x_train, y_train, epochs=5)

# Evaluate
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Test accuracy: {test_acc:.2f}")

🧠 Mnemonic for ML Pipeline: "CTPM" = Collect data, Train model, Predict, Measure accuracy.

🤔 Did you know? Python powers ChatGPT's backend, Google's search algorithms, and Tesla's Autopilot. The entire AI revolution runs on Python!

Real-World Use Cases:

• Healthcare - Disease diagnosis from medical images
• Finance - Fraud detection, algorithmic trading
• Retail - Recommendation engines ("Customers who bought...")
• Transportation - Self-driving car perception systems

Detailed Examples with Explanations

Example 1: Building a REST API with Flask 🔌

Scenario: You're building a task management app. The frontend (React) needs a backend API to create, read, update, and delete tasks.

from flask import Flask, jsonify, request
from datetime import datetime

app = Flask(__name__)

# In-memory database (use real DB in production)
tasks = [
    {"id": 1, "title": "Learn Python", "completed": False},
    {"id": 2, "title": "Build API", "completed": True}
]

# GET all tasks
@app.route('/api/tasks', methods=['GET'])
def get_tasks():
    return jsonify(tasks)

# GET single task
@app.route('/api/tasks/<int:task_id>', methods=['GET'])
def get_task(task_id):
    task = next((t for t in tasks if t['id'] == task_id), None)
    if task:
        return jsonify(task)
    return jsonify({"error": "Task not found"}), 404

# POST create new task
@app.route('/api/tasks', methods=['POST'])
def create_task():
    data = request.get_json()
    new_task = {
        "id": max(t['id'] for t in tasks) + 1,
        "title": data['title'],
        "completed": False
    }
    tasks.append(new_task)
    return jsonify(new_task), 201

# PUT update task
@app.route('/api/tasks/<int:task_id>', methods=['PUT'])
def update_task(task_id):
    task = next((t for t in tasks if t['id'] == task_id), None)
    if task:
        data = request.get_json()
        task['title'] = data.get('title', task['title'])
        task['completed'] = data.get('completed', task['completed'])
        return jsonify(task)
    return jsonify({"error": "Task not found"}), 404

# DELETE task
@app.route('/api/tasks/<int:task_id>', methods=['DELETE'])
def delete_task(task_id):
    global tasks
    tasks = [t for t in tasks if t['id'] != task_id]
    return '', 204

if __name__ == '__main__':
    app.run(debug=True, port=5000)

Explanation:

• @app.route() defines URL endpoints
• methods=['GET', 'POST'] specifies allowed HTTP methods
• jsonify() converts Python dictionaries to JSON
• request.get_json() parses incoming JSON data
• HTTP status codes: 200 (OK), 201 (Created), 404 (Not Found), 204 (No Content)

Test the API using curl:

# Get all tasks
curl http://localhost:5000/api/tasks

# Create task
curl -X POST http://localhost:5000/api/tasks \
  -H "Content-Type: application/json" \
  -d '{"title": "Deploy app"}'

Example 2: Data Analysis - Sales Dashboard 📈

Scenario: Analyze an e-commerce store's sales data to find trends and top performers.

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

# Load data
df = pd.read_csv('sales.csv')
# Columns: date, product, category, quantity, price, region

# 1. Calculate total revenue
df['revenue'] = df['quantity'] * df['price']
total_revenue = df['revenue'].sum()
print(f"Total Revenue: ${total_revenue:,.2f}")

# 2. Top 10 products by revenue
top_products = df.groupby('product')['revenue'].sum().nlargest(10)
print("\nTop 10 Products:")
print(top_products)

# 3. Regional performance
regional_sales = df.groupby('region').agg({
    'revenue': 'sum',
    'quantity': 'sum'
}).sort_values('revenue', ascending=False)

print("\nRegional Performance:")
print(regional_sales)

# 4. Time series analysis
df['date'] = pd.to_datetime(df['date'])
df['month'] = df['date'].dt.to_period('M')
monthly_sales = df.groupby('month')['revenue'].sum()

# 5. Visualization
fig, axes = plt.subplots(2, 2, figsize=(15, 10))

# Revenue by category
category_revenue = df.groupby('category')['revenue'].sum()
axes[0, 0].bar(category_revenue.index, category_revenue.values, color='#3498db')
axes[0, 0].set_title('Revenue by Category')
axes[0, 0].set_xlabel('Category')
axes[0, 0].set_ylabel('Revenue ($)')
axes[0, 0].tick_params(axis='x', rotation=45)

# Monthly trend
axes[0, 1].plot(monthly_sales.index.astype(str), monthly_sales.values, 
                marker='o', linewidth=2, color='#2ecc71')
axes[0, 1].set_title('Monthly Revenue Trend')
axes[0, 1].set_xlabel('Month')
axes[0, 1].set_ylabel('Revenue ($)')
axes[0, 1].tick_params(axis='x', rotation=45)

# Regional comparison
axes[1, 0].pie(regional_sales['revenue'], labels=regional_sales.index, 
               autopct='%1.1f%%', startangle=90)
axes[1, 0].set_title('Revenue Distribution by Region')

# Top 5 products
top_5 = df.groupby('product')['revenue'].sum().nlargest(5)
axes[1, 1].barh(top_5.index, top_5.values, color='#e74c3c')
axes[1, 1].set_title('Top 5 Products')
axes[1, 1].set_xlabel('Revenue ($)')

plt.tight_layout()
plt.savefig('sales_dashboard.png', dpi=300)
plt.show()

# 6. Statistical insights
print("\nStatistical Summary:")
print(f"Average Order Value: ${df['revenue'].mean():.2f}")
print(f"Median Order Value: ${df['revenue'].median():.2f}")
print(f"Revenue Std Dev: ${df['revenue'].std():.2f}")

# 7. Identify best day of week
df['day_of_week'] = df['date'].dt.day_name()
day_sales = df.groupby('day_of_week')['revenue'].sum().sort_values(ascending=False)
print("\nBest Day for Sales:")
print(day_sales)

Key Pandas Operations Used:

• groupby() - Aggregate data by categories
• agg() - Apply multiple aggregation functions
• nlargest() - Get top N values
• dt accessor - Extract date components
• to_period() - Convert to monthly periods

Example 3: Automation - Batch Image Resizer 🖼️

Scenario: You have 1000 product images that need to be resized for web display.

from PIL import Image
import os
from pathlib import Path

def batch_resize_images(input_folder, output_folder, target_size=(800, 600)):
    """
    Resize all images in a folder to target dimensions.
    
    Args:
        input_folder: Path to original images
        output_folder: Path to save resized images
        target_size: Tuple of (width, height) in pixels
    """
    # Create output folder
    output_path = Path(output_folder)
    output_path.mkdir(exist_ok=True)
    
    # Supported formats
    image_extensions = {'.jpg', '.jpeg', '.png', '.gif', '.bmp'}
    
    # Process each image
    processed = 0
    errors = []
    
    for filename in os.listdir(input_folder):
        file_path = Path(input_folder) / filename
        
        # Check if it's an image
        if file_path.suffix.lower() not in image_extensions:
            continue
        
        try:
            # Open image
            with Image.open(file_path) as img:
                # Convert RGBA to RGB if needed (for JPEG)
                if img.mode == 'RGBA' and file_path.suffix.lower() in {'.jpg', '.jpeg'}:
                    rgb_img = Image.new('RGB', img.size, (255, 255, 255))
                    rgb_img.paste(img, mask=img.split()[3])
                    img = rgb_img
                
                # Resize maintaining aspect ratio
                img.thumbnail(target_size, Image.Resampling.LANCZOS)
                
                # Save optimized image
                output_file = output_path / filename
                img.save(output_file, optimize=True, quality=85)
                
                processed += 1
                print(f"Processed: {filename} ({img.size})")
        
        except Exception as e:
            errors.append((filename, str(e)))
            print(f"Error processing {filename}: {e}")
    
    # Summary
    print(f"\n{'='*50}")
    print(f"Successfully processed: {processed} images")
    print(f"Errors: {len(errors)}")
    
    if errors:
        print("\nFailed files:")
        for filename, error in errors:
            print(f"  - {filename}: {error}")

# Usage
if __name__ == '__main__':
    batch_resize_images(
        input_folder='./original_images',
        output_folder='./resized_images',
        target_size=(800, 600)
    )

Why This Matters: Manually resizing 1000 images would take hours. This script does it in minutes.

Enhancements:

• Add watermarks
• Convert formats (PNG → JPEG)
• Generate thumbnails
• Rename files with sequential numbers

Example 4: Machine Learning - Sentiment Analysis 😊😡

Scenario: Analyze customer reviews to determine if they're positive or negative.

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, confusion_matrix
import pandas as pd
import numpy as np

# Sample training data
reviews = [
    "This product is amazing! Love it!",
    "Terrible quality, broke after one day",
    "Great value for money, highly recommend",
    "Worst purchase ever, total waste",
    "Excellent service and fast shipping",
    "Poor quality, not as described",
    "Absolutely fantastic, exceeded expectations",
    "Very disappointed, would not buy again"
]

sentiments = [1, 0, 1, 0, 1, 0, 1, 0]  # 1=positive, 0=negative

# Convert text to numerical features
vectorizer = TfidfVectorizer(max_features=100, stop_words='english')
X = vectorizer.fit_transform(reviews)

# Split data
X_train, X_test, y_train, y_test = train_test_split(
    X, sentiments, test_size=0.25, random_state=42
)

# Train classifier
classifier = MultinomialNB()
classifier.fit(X_train, y_train)

# Evaluate
y_pred = classifier.predict(X_test)
print("Classification Report:")
print(classification_report(y_test, y_pred, target_names=['Negative', 'Positive']))

# Predict new reviews
def predict_sentiment(review_text):
    review_vector = vectorizer.transform([review_text])
    prediction = classifier.predict(review_vector)[0]
    probability = classifier.predict_proba(review_vector)[0]
    
    sentiment = "Positive" if prediction == 1 else "Negative"
    confidence = max(probability) * 100
    
    return sentiment, confidence

# Test with new reviews
test_reviews = [
    "This is the best thing I ever bought!",
    "Completely useless, don't waste your money",
    "It's okay, nothing special"
]

print("\nPredictions on new reviews:")
for review in test_reviews:
    sentiment, confidence = predict_sentiment(review)
    print(f"Review: '{review}'")
    print(f"Sentiment: {sentiment} (Confidence: {confidence:.1f}%)\n")

# Feature importance (most predictive words)
feature_names = vectorizer.get_feature_names_out()
positive_features = np.argsort(classifier.feature_log_prob_[1])[-10:]
negative_features = np.argsort(classifier.feature_log_prob_[0])[-10:]

print("Most positive words:")
print([feature_names[i] for i in positive_features])
print("\nMost negative words:")
print([feature_names[i] for i in negative_features])

How It Works:

1. TfidfVectorizer converts text to numbers (word importance scores)
2. MultinomialNB (Naive Bayes) learns patterns in word usage
3. Model predicts sentiment of new reviews with confidence scores

Real Application: Amazon, Yelp, and Twitter use similar models to analyze millions of reviews and tweets.

Common Mistakes to Avoid ⚠️

1. Not Handling Exceptions in Production Code

❌ Wrong:

response = requests.get(url)
data = response.json()  # What if request fails?

✅ Right:

try:
    response = requests.get(url, timeout=10)
    response.raise_for_status()
    data = response.json()
except requests.exceptions.RequestException as e:
    print(f"Error fetching data: {e}")
    data = None

2. Using Global State in Web Applications

❌ Wrong:

user_sessions = {}  # Shared across all users!

@app.route('/login')
def login():
    user_sessions[request.form['username']] = True

✅ Right:

from flask import session

@app.route('/login')
def login():
    session['username'] = request.form['username']  # Per-user

3. Not Normalizing Data in ML

❌ Wrong:

# Features with vastly different scales
X = [[1000000, 3],  # Income: millions, bedrooms: single digits
     [50000, 2]]
model.fit(X, y)  # Model will be biased!

✅ Right:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
model.fit(X_scaled, y)

4. Reading Entire Large Files into Memory

❌ Wrong:

with open('10GB_file.txt') as f:
    data = f.read()  # Memory overflow!

✅ Right:

with open('10GB_file.txt') as f:
    for line in f:  # Read line by line
        process(line)

5. Hardcoding Sensitive Information

❌ Wrong:

db_password = "mySecretPassword123"  # Exposed in code!

✅ Right:

import os
from dotenv import load_dotenv

load_dotenv()
db_password = os.getenv('DB_PASSWORD')

6. Not Validating User Input

❌ Wrong:

@app.route('/user/<user_id>')
def get_user(user_id):
    query = f"SELECT * FROM users WHERE id = {user_id}"  # SQL injection!

✅ Right:

@app.route('/user/<int:user_id>')  # Type validation
def get_user(user_id):
    query = "SELECT * FROM users WHERE id = ?"
    cursor.execute(query, (user_id,))  # Parameterized query

Key Takeaways 🎯

1. Python's versatility spans web development, data science, automation, and AI
2. Flask and Django power modern web applications with different philosophies (micro vs. batteries-included)
3. Pandas and NumPy transform data analysis from tedious to elegant
4. Automation scripts eliminate repetitive tasks—if you do it twice, automate it
5. Machine learning with scikit-learn makes AI accessible without needing a PhD
6. Real-world projects combine multiple domains (web + ML, automation + data analysis)
7. Error handling separates hobby code from production-ready applications
8. Libraries do the heavy lifting—don't reinvent the wheel

💡 Next Steps:

• Build a portfolio project combining 2+ domains (e.g., web app with ML backend)
• Contribute to open-source Python projects on GitHub
• Deploy your applications using Heroku, AWS, or DigitalOcean
• Learn asynchronous Python (asyncio) for high-performance applications

📚 Further Study

1. Real Python Tutorials - https://realpython.com/ - Comprehensive guides on all Python topics with real-world examples
2. Flask Mega-Tutorial - https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-i-hello-world - Complete web development course
3. Kaggle Learn - https://www.kaggle.com/learn - Interactive machine learning and data science courses with real datasets