Python for Data Science

The Engine of Modern Analysis

Python is the undisputed king of data science. Its simplicity and powerful ecosystem of libraries allow analysts to transform millions of raw logs into clear, actionable metrics. For **Netflix**, Python is the engine that processes every click, pause, and hover to understand user intent.

In this chapter, we master the two most important libraries in the ecosystem: **Pandas** for structured data manipulation and **NumPy** for high-performance numerical computing. You will learn how to filter, group, and reshape datasets containing millions of rows in just a few lines of code.

Core Python: Logic & Functions

Before diving into libraries, a data analyst must master Python's core logic. At **Netflix**, raw logs often arrive as JSON-like dictionaries. We use **List Comprehensions** and **Error Handling** to parse these logs safely before they ever reach a database.

PythonRuns entirely in your browser — nothing is sent to a server.

# Netflix Log Parsing: Core Python Logic
class LogParser:
    def __init__(self, raw_logs):
        self.logs = raw_logs

    def extract_watch_events(self):
        print("PYTHON LOGIC: Filtering 'play' events from raw stream...")
        # Using a list comprehension for efficiency
        events = [log for log in self.logs if log.get('event') == 'play']
        
        for e in events:
            user = e.get('user_id', 'Unknown')
            duration = e.get('duration_sec', 0)
            print(" - User {0} watched for {1}s".format(user, duration))
        
        return len(events)

# Scenario: Processing a batch of interaction logs
raw_stream = [
    {"user_id": "U101", "event": "play", "duration_sec": 1200},
    {"user_id": "U102", "event": "hover", "item": "Stranger Things"},
    {"user_id": "U103", "event": "play", "duration_sec": 3600}
]
parser = LogParser(raw_stream)
count = parser.extract_watch_events()
print("\nTotal Playback Events Found: {0}".format(count))

# Netflix Log Parsing: Core Python Logic
class LogParser:
    def __init__(self, raw_logs):
        self.logs = raw_logs

    def extract_watch_events(self):
        print("PYTHON LOGIC: Filtering 'play' events from raw stream...")
        # Using a list comprehension for efficiency
        events = [log for log in self.logs if log.get('event') == 'play']
        
        for e in events:
            user = e.get('user_id', 'Unknown')
            duration = e.get('duration_sec', 0)
            print(" - User {0} watched for {1}s".format(user, duration))
        
        return len(events)

# Scenario: Processing a batch of interaction logs
raw_stream = [
    {"user_id": "U101", "event": "play", "duration_sec": 1200},
    {"user_id": "U102", "event": "hover", "item": "Stranger Things"},
    {"user_id": "U103", "event": "play", "duration_sec": 3600}
]
parser = LogParser(raw_stream)
count = parser.extract_watch_events()
print("\nTotal Playback Events Found: {0}".format(count))

Data Manipulation with Pandas

**Pandas** introduces the **DataFrame**, a powerful 2D table structure. For **Netflix**, Pandas allows analysts to "Join" a table of user demographics with a table of watch history. The real magic happens during **Grouping**: calculating the average watch time per region or the most popular genre per age group.

PythonRuns entirely in your browser — nothing is sent to a server.

# Netflix Analytics: Grouping with Pandas Simulation
class ImpressionAnalyzer:
    def __init__(self, data_dict):
        # In a real scenario, we'd use 'import pandas as pd'
        self.df = data_dict # Representing a DataFrame

    def get_genre_popularity(self):
        print("PANDAS LOGIC: df.groupby('genre')['watch_time'].mean()...) ")
        # Simulating the group-by mean operation
        sums = {}
        counts = {}
        for entry in self.df:
            g = entry['genre']
            t = entry['watch_time']
            sums[g] = sums.get(g, 0) + t
            counts[g] = counts.get(g, 0) + 1
        
        print("AVERAGE WATCH TIME BY GENRE:")
        for g in sorted(sums.keys()):
            avg = sums[g] / counts[g]
            print(" - {0}: {1:.1f} mins".format(g, avg))

# Scenario: Netflix 'Taste Community' Analysis
mock_df = [
    {"user": "A", "genre": "Sci-Fi", "watch_time": 45},
    {"user": "B", "genre": "Drama", "watch_time": 90},
    {"user": "C", "genre": "Sci-Fi", "watch_time": 55},
]
analyzer = ImpressionAnalyzer(mock_df)
analyzer.get_genre_popularity()

# Netflix Analytics: Grouping with Pandas Simulation
class ImpressionAnalyzer:
    def __init__(self, data_dict):
        # In a real scenario, we'd use 'import pandas as pd'
        self.df = data_dict # Representing a DataFrame

    def get_genre_popularity(self):
        print("PANDAS LOGIC: df.groupby('genre')['watch_time'].mean()...) ")
        # Simulating the group-by mean operation
        sums = {}
        counts = {}
        for entry in self.df:
            g = entry['genre']
            t = entry['watch_time']
            sums[g] = sums.get(g, 0) + t
            counts[g] = counts.get(g, 0) + 1
        
        print("AVERAGE WATCH TIME BY GENRE:")
        for g in sorted(sums.keys()):
            avg = sums[g] / counts[g]
            print(" - {0}: {1:.1f} mins".format(g, avg))

# Scenario: Netflix 'Taste Community' Analysis
mock_df = [
    {"user": "A", "genre": "Sci-Fi", "watch_time": 45},
    {"user": "B", "genre": "Drama", "watch_time": 90},
    {"user": "C", "genre": "Sci-Fi", "watch_time": 55},
]
analyzer = ImpressionAnalyzer(mock_df)
analyzer.get_genre_popularity()

Numerical Computing with NumPy

**NumPy** is the foundation for almost every AI library. It uses **Vectorization** to perform math on entire arrays at once, rather than looping through elements. For **Netflix**, this is used to calculate "User Similarity Vectors"—comparing your habits to millions of other users in milliseconds.

PythonRuns entirely in your browser — nothing is sent to a server.

# Netflix Personalization: NumPy Vectorization Simulation
class ViewtimeOptimizer:
    def __init__(self, view_matrix):
        self.matrix = view_matrix # A list of lists representing a 2D array

    def apply_normalization(self, factor):
        print("NUMPY LOGIC: matrix * factor (Broadcasting multiplication)")
        # Simulating vectorization (multiplying whole array by a scalar)
        optimized = [[round(val * factor, 2) for val in row] for row in self.matrix]
        
        print("Original View Matrix Row 1: {0}".format(self.matrix[0]))
        print("Optimized Matrix Row 1 : {0}".format(optimized[0]))
        print("\nInsight: NumPy performs this across billions of cells using C-level optimization.")

# Scenario: Adjusting view weights for trending content
weights = [[0.8, 0.9, 0.4], [0.1, 0.5, 0.9]]
engine = ViewtimeOptimizer(weights)
engine.apply_normalization(factor=1.1)

# Netflix Personalization: NumPy Vectorization Simulation
class ViewtimeOptimizer:
    def __init__(self, view_matrix):
        self.matrix = view_matrix # A list of lists representing a 2D array

    def apply_normalization(self, factor):
        print("NUMPY LOGIC: matrix * factor (Broadcasting multiplication)")
        # Simulating vectorization (multiplying whole array by a scalar)
        optimized = [[round(val * factor, 2) for val in row] for row in self.matrix]
        
        print("Original View Matrix Row 1: {0}".format(self.matrix[0]))
        print("Optimized Matrix Row 1 : {0}".format(optimized[0]))
        print("\nInsight: NumPy performs this across billions of cells using C-level optimization.")

# Scenario: Adjusting view weights for trending content
weights = [[0.8, 0.9, 0.4], [0.1, 0.5, 0.9]]
engine = ViewtimeOptimizer(weights)
engine.apply_normalization(factor=1.1)

Practice Questions

Question 1

Why is a Pandas GroupBy operation more efficient than writing a manual loop for 10 million rows?

It uses better colors in the UI
It is written in highly optimized C and uses vectorized operations under the hood
It only works on Netflix data
It deletes empty rows automatically

Question 2

In the NumPy example, what is 'Broadcasting'?

Sending emails to users
The ability of NumPy to perform math between arrays of different shapes (like an array and a single number)
A way to show videos on Netflix
A security protocol for Visa