Pybites Platform

Back

Movie data analysis

Pybites

Level: Intermediate (score: 3)

In this Bite we are going to parse a csv movie dataset to identify the directors with the highest rated movies.

Write get_movies_by_director: use csv.DictReader to convert movie_metadata.csv into a (default)dict of lists of Movie namedtuples. Convert/filter the data:
- Only extract director_name, movie_title, title_year and imdb_score, ignoring movies without all of these fields.
- Type conversions: title_year -> int / imdb_score -> float
- Discard any movies older than 1960.
Here is an extract:
```
....
{ 'Woody Allen': [
    Movie(title='Midnight in Paris', year=2011, score=7.7),
    Movie(title='The Curse of the Jade Scorpion', year=2001, score=6.8),
    Movie(title='To Rome with Love', year=2012, score=6.3),  ....
    ], ...
}
```
Write the calc_mean_score helper that takes a list of Movie namedtuples and calculates the mean IMDb score, returning the score rounded to 1 decimal place.
Complete get_average_scores which takes the directors data structure returned by get_movies_by_director (see 1.) and returns a list of tuples (director, average_score) ordered by highest score in descending order. Only take directors into account with >= MIN_MOVIES

See the tests for more info. This could be tough one, but we really hope you learn a thing or two. Good luck and keep calm and code in Python!

defaultdict movie data sorting data analysis mean namedtuple

Code
Tests

import csv
from collections import defaultdict, namedtuple
import os
from urllib.request import urlretrieve

BASE_URL = 'https://bites-data.s3.us-east-2.amazonaws.com/'
TMP = os.getenv("TMP", "/tmp")

fname = 'movie_metadata.csv'
remote = os.path.join(BASE_URL, fname)
local = os.path.join(TMP, fname)
urlretrieve(remote, local)

MOVIE_DATA = local
MIN_MOVIES = 4
MIN_YEAR = 1960

Movie = namedtuple('Movie', 'title year score')

def get_movies_by_director():
    """Extracts all movies from csv and stores them in a dict,
    where keys are directors, and values are a list of movies,
    use the defined Movie namedtuple"""
    pass

def calc_mean_score(movies):
    """Helper method to calculate mean of list of Movie namedtuples,
       round the mean to 1 decimal place"""
    pass

def get_average_scores(directors):
    """Iterate through the directors dict (returned by get_movies_by_director),
       return a list of tuples (director, average_score) ordered by highest
       score in descending order. Only take directors into account
       with >= MIN_MOVIES"""
    pass

from collections import defaultdict

import pytest

from directors import (get_movies_by_director, get_average_scores,
                       calc_mean_score, Movie)

@pytest.fixture(scope="module")
def movies():
    return get_movies_by_director()

@pytest.fixture(scope="module")
def scores(movies):
    return get_average_scores(movies)

def test_get_movies_by_director(movies):
    assert 'Sergio Leone' in movies
    assert len(movies['Sergio Leone']) == 4
    assert len(movies['Peter Jackson']) == 12

def test_director_movies_data_structure(movies):
    assert type(movies) in (dict, defaultdict)
    assert type(movies['Peter Jackson']) == list
    assert type(movies['Peter Jackson'][0]) == Movie

def test_calc_mean_score(movies):
    movies_sergio = movies['Sergio Leone']
    movies_nolan = movies['Christopher Nolan']
    assert calc_mean_score(movies_sergio) == 8.5
    assert calc_mean_score(movies_nolan) == 8.4

def test_get_average_scores_top_directors(scores):
    expected = [('Sergio Leone', 8.5),
                ('Christopher Nolan', 8.4),
                ('Quentin Tarantino', 8.2),
                ('Hayao Miyazaki', 8.2),
                ('Frank Darabont', 8.0),
                ('Stanley Kubrick', 8.0),
                ('James Cameron', 7.9),
                ('Joss Whedon', 7.9)]
    assert scores[0:8] == expected

@pytest.mark.parametrize("director", [
    'Quentin Tarantino', 'Hayao Miyazaki',
    'Frank Darabont', 'Stanley Kubrick',
    'James Cameron', 'Joss Whedon',
    'Alejandro G. Iñárritu',
])
def test_director_in_top_scores(director, scores):
    # order / score might slightly change depending the way the mean
    # is calculated so only test director names in top scores
    top_scores = scores[2:13]
    directors = {score[0] for score in top_scores}
    assert director in directors

def test_ignore_older_movies(movies):
    """Lowell Sherman's Black and White is from 1933 and should
       be skipped"""
    assert len(movies["Lowell Sherman"]) == 0