Programming Assignment 2: Sentiment Analysis


Sentiment Analysis is the problem of determining the general attitude expressed by some text. For instance,
we would like to have a program that could look at the text “The film was a breath of fresh air” and realize that
it was a positive statement while “It made me want to poke out my eyeballs” is negative.

One algorithm that we can use for this problem is to assign a numeric value to each word based on how
positive or negative that word is and then score the text as a whole based on the average sentiment value
of the individual words. The challenge here is in finding a way to assign positive or negative values to
individual words.

For the purposes of this project we will assign values to words by analyzing a large collection of movie
reviews collected from the Rotten Tomatoes website:

This file contains 8529 movie reviews along with their scores. The text of each movie review is
accompanied by a human-generated evaluation of whether the review is positive or negative overall.

The first few lines of the file look like this:

1 A series of escapades demonstrating the adage that what is good for the goose is also good for the gander , some of which occasionally amuses but none of which amounts to much of a story .  
4 This quiet , introspective and entertaining independent is worth seeking .    
1 Even fans of Ismail Merchant 's work , I suspect , would have a hard time sitting through this one .  
3 A positively thrilling combination of ethnography and all the intrigue , betrayal , deceit and murder of a Shakespearean tragedy or a juicy soap opera .  
1 Aggressive self-glorification and a manipulative whitewash .  
4 A comedy-drama of nearly epic proportions rooted in a sincere performance by the title character undergoing midlife crisis .  
1 Narratively , Trouble Every Day is a plodding mess .

Note that each review starts with a number 0 through 4 with the following meaning:

  • 0 : negative
  • 1 : somewhat negative
  • 2 : neutral
  • 3 : somewhat positive
  • 4 : positive

Individual words will be scored by computing the average rating of all of the reviews that contain that
word. For example, if we were only working with the reviews included above, the word “and” would be
assigned the score (4+3+1)/3=2.6: it appears in the 2nd, 4th, and 5th reviews which have scores of
4, 3, and 1 respectively.

Honor Code

This is an individual assignment. All of the work that you submit must be written by you, based on
your own understanding of the material. Representing someone else’s work as your own, in any form,
constitutes an honor code violation.


The finished application must read a file of movie reviews provided as a command-line argument,
then allow the user to enter text for sentiment analysis. The following interaction illustrates the
expected behavior:

$ python movie_reviews.txt
Enter your text (blank to exit): This movie is rotten!
The sentiment score for this text is: 1.58
This text is NEGATIVE.

Enter your text (blank to exit): Best. Movie. Ever. (BEST)
The sentiment score for this text is: 2.48
This text is POSITIVE

Enter your text (blank to exit):

In this example the normal text was produced by the program and the bold text represents
user input. The displayed numeric score must be rounded to two decimal places. The last line of the
output must be based on the numeric score: If the score is below 1.95 the output should be
“This text is NEGATIVE.” If the score greater than or equal to 1.95 and less 2.05 the output
should be “This text is NEUTRAL.” If the score is greater than or equal to 2.05 the output should
be “This text is POSITIVE.”


You will need to submit the following files:

  • Part A - Due Monday 4/25
    • - Code for the Review class. See the UML diagram below.
    • - Unit tests for the Review class. For full credit, these tests
      must provide 100% statement coverage of
  • Part B - Due Monday 5/2
    • - Code for the SentimentAnalyzer class. See the UML
      diagram below.
    • - Command-line sentiment analysis application. This application
      must provide the functionality described above.

(Note that it isn’t standard practice in Python to create a separate file for each class. We are
doing it here to facilitate code submission and grading.)


The Review and SentimentAnalyzer classes must match the following UML diagram:


Review Class

  • Constructor: Note that there are two different constructors listed in the UML above.
    The Python language doesn’t support this directly: there can be only one __init__ method.
    We can provide the effect of multiple constructors by using the *args parameter to
    implement arbitrary argument lists. This is described in Section 11.2 of our textbook.
    As an example, imagine we want to create a two-dimensional Point class that can be
    initialized either by explicitly providing x and y values or by copyting the x and y values
    from an existing Point object. The following code would work:

    class Point:
    def __init__(self, *args):
        if len(args) == 1:      # Point object
            self.x = args[0].x
            self.y = args[0].y
        elif len(args) == 2:    # x and y values
            self.x = args[0]
            self.y = args[1]
            print("Error!  Incorrect number of arguments.")

    The caller is now free to think of this as a class with two different constructors:

    p1 = Point(2.0, 3.0)  # Construct from x, y
    p2 = Point(p1)        # Construct from an existing point
    • Two-argument Review constructor: The two-argument constructor must assign the
      provided rating and text to the appropriate instance variables. It must also initialize
      the words instance variable to be a set of words containing lower-case copies of each
      distinct word that appears in the review text. For example, if the text of the review
      is “This is a very very very bad movie!” then the words set would contain the
      elements "this", "is", "a", "very", "bad" and "movie". The set must not include
      any of the punctuation from the original review. The following code snippet shows
      an example of how we can remove punctuation from a string in Python:

      import string
      text = "I'm not 'pleased'... she said!"
      text = text.translate(str.maketrans('', '', string.punctuation))
      print(text)  # Prints Im not pleased she said
    • Single-argument constructor: The single-argument constructor must take a line
      of text in the same format as the lines in the movie_reviews.txt file and extract
      the necessary information to initialize the three required instance variables.
      For example:

      review = Review("1 Narratively , Trouble Every Day is a plodding mess .")

      The first character here corresponds to the rating, the next space is ignored, and
      the rest of the string should be stored in text. The logic for generating the words
      set will be the same regardless of which constructor is used.

  • __str__ - This method must return a string representation of the review that matches
    the format in movie_reviews.txt, except that the overall length must be capped
    at 70 characters, with '...' appended in cases where the review has been truncated.
    For example, reviews created from the corresponding examples above would generate
    the following strings:

    "1 Narratively , Trouble Every Day is a plodding mess ."
    "4 This quiet , introspective and entertaining independent is worth ..."
    Note that the second string is exactly 70 characters long, including the ellipses.
  • __eq__ - Two reviews must be considered equal if they have the same rating and same text.

SentimentAnalyzer Instance Variables

  • review_counts - This dictionary must contain a mapping from individual (lower-case)
    words to a count of the total number of reviews that contain those words. For example,
    given the sample reviews above, "and" would be mapped to 3, because it appears in
    exactly three reviews.
  • word_rating_totals - This dictionary must contain a mapping from individual (lower-case)
    words to the sum of the ratings of all reviews that contain that word. For example,
    given the sample reviews above, "and" would be mapped to 8, because that is the sum
    of the ratings of the reviews containing "and".

    Along with review_counts, this instance variable will allow us to calculate the sentiment
    value associated with any particular word: It will be the rating total divided by the count.
  • reviews - This must be a list containing all Review objects that have been added
    through calls to the add_review method or the load_reviews method.

SentimentAnalyzer Methods

  • Constructor - The constructor must initialize the three instance variables to contain
    empty collection objects of the appropriate types.
  • add_review - This method must add the provided review to the reviews list and
    must update review_counts and word_rating_totals with the information
    from the provided review.
  • load_reviews - This method must load all of the reviews from the indicated text file.
    You may assume that the formatting will match the formatting of movie_reviews.txt.
  • save_reviews - This method must save the current collection of reviews to a file with
    the indicated name. The format must match the format of movie_reviews.txt.
  • word_sentiment - This method must return the word sentiment associated with the
    provided word. Case must be ignored. If the word does not appear in any reviews,
    then this method must return 2.0.
  • analyze - This method will take an arbitrary string of text and return the average
    sentiment value of the individual words. Each word must be included in the average,
    including repeats. Capitalization and punctuation must be ignored.


  • Submission A:
    • Full test coverage from and passes all
      student tests: 20%
    • passes instructor Gradescope submission tests: 20%
    Note that it will not be possible to receive any credit for passing the instructor
    unit tests if your submission doesn’t pass your own tests with full coverage.
  • Submission B:
    • passes instructor tests: 20%
    • passes instructor tests: 20%
  • Instructor Style Points: 20%

    Instructor style points will be based on issues like:
    • Appropriate variable names
    • Meaningful and informative docstrings
    • Clean, readable code that is not overly complex and doesn’t include
      do-nothing statements


The idea for this assignment was presented by Eric Manley and Timothy Urness at
the 2016 SIGCSE nifty assignment session. This project uses their data files and borrows some
text from their write-up. The Rotten Tomatoes data was originally collected for the
Stanford sentiment analysis project.

Back to Top