Laboratory Exercise 1
CSci 227: Programming Methods
Department of Computer Science
Hunter College, City University of New York
Spring 2024

Learning Objectives: Students will be able to:

Use a style checker ("linter") to format code in good style.
Successfully submit programs to the Gradescope platform.
Use knowledge of list, strings, and tuples from CSCI 127 to write code fragments with built-in methods.
Incorporate the collection data type, dictionary, into programs.

Software Tools Needed: Web browser to access textbook and an IDE (on-line or on own machine) with core Python 3.6+ loaded.

Lab Notes: Download the outline and focus questions to guide you while working through this lab. These are a useful tool for note taking and as well as studying for the quizzes and final exam.

Submitting & Style-Checking Tools

To start this week's lab, we will write the canonical Hello World program and successfully pass the style and correctness tests on Gradescope.

Linting

Good style accounts for 30% of the program grade. We are following the standard PEP 8 style guide for Python code. As part of the autograder scripts, your program is run through a static code analyser (aka a "linter").

We are using Pylint which reports warnings and errors, including message codes, and then scores the code on a scale from 0 to 10. We multiply your percentage score by 3 (25% of the total) to determine the style grade. For example, if pylint scores your program 9, your style grade is (9/10) * 2.5 = 2.25
See the Pylint website for tutorials, FAQ's and standard warnings.
PEP 8 specifies that variable names should be at least 3 characters long, but it is long standing convention that DataFrames are named df. For the autograders, we have included df in the "good-names" that are accepted. This can be done locally with .pylintrc files or using the command-line option pylint --good-names=df.
Most IDE's have linting available: for example, see pylint in PyCharm and Linting Python in VSCode.

Let's write the first program (see Program 1) which asks that you print:

Hello, World!

to the screen.

Open up your favorite IDE, and write the line of code that will print the message. Run your program to make sure it produces the correct output.

Next, let's check how the program does for style by running pylint:

We ran the pylint program from the command line, but you can also invoke it inside most IDE's. The message says we are missing the documentation string (e.g. the introductory comment) from the start of the file.

Add a multi-line string comment that includes the information required by the autograder: your name, email, and resources used. For example, for the student, Thomas Hunter, the opening comment of his first program might be:


  """
  Name:  Thomas Hunter
  Email: thomas.hunter1870@hunter.cuny.edu
  Resources:  Used python.org as a reminder of Python 3 print statements.
  """

When we run pylint again, the message says the code is rated a perfect score (10.0/10).

Now that we have tested it both for correctness and good style, we are ready to submit to Gradescope.

Gradescope

We will be using the Gradescope platform for submitting programs. An account for this course will be set up automatically for all students registered on 24 January (check your spam folder, since myhunter email often moves it there). If you registered after that date, this course is not appearing in your Gradescope course list, or you would like to use a different email address (we use the one in Blackboard), send email to csci227@hunter.cuny.edu with your full name, EmplID, and preferred email and access will be added manually.

To submit the first program:

Go to the class page on Gradescope and click on Program 1: Hello.
Upload your .py file. The autograders are expecting this format and will not accept .ipynb files).
The autograder will report back your correctness and style scores, as well as any bonus points for submitting early.

Using LeetCode & HackerRank

A course goal is mastery of core data structures and algorithms (ds&a) so that students can successfully complete technical challenges at the summer internship skills level. Throughout the semester, we will use two industry standards, LeetCode and HackerRank, as sources for problems in classwork and for coding reviews.

HackerRank

If you didn't do so in lecture, work through the first 7 challenges from HackerRank: Prepare Python that recap Python learned in CSCI 127:

list of first 7 HR Python Challenges

LeetCode

We didn't have a chance to introduce LeetCode in lecture, but it is similar to HackerRank in that it has a bank of questions to prepare (and often used) in technical interviews. HackerRank is primarily used for interviewing and has fewer questions to practice. LeetCode has thousands of questions for practice. When trying them, make sure to choose Python 3 as the language. Here's a couple to try now:

Note that the template in LeetCode, for both of these challenges, uses annotations, or hints as to what the types of the parameters and return values are. For example, for Fizz Buzz:

the function has been set up inside a class. We will talk more about setting up classes in a few weeks, but for now, we will ignore the first argument (self) to the function, and look at the second (n). It is annotated with int which means that its expected type is an integer. The end of the line has the annotation, List[str], which means that the expected return type of the function is a list of strings.

Collections Data Types

Next, work through the following section of the textbook:

Section 1.8.2 (Built-in Collection Data Types)

Before going on, work through the outline and focus questions on collection data types.

We will focus today dictionaries. Dictionaries, often referred to as lookup tables, maps, hashmaps, or associative arrays, are incredibly useful for efficient storage and retrieval.

Let's use a dictionary to approach the design challenge from classwork in Lecture 1:

Are there two students with the same first name? Devise an algorithm to find duplicate names. Include your input and output for your algorithm. Outline the process for finding duplicates.

Let's use a dictionary to store how many times we have seen a name. For example, if we have a list of names, names, we can loop through the name list. If it's the first time the name has occurred, we can add it to our dictionary. If it has already occurred, we can up the count. Let's first write the pseudocode:

Initialize the dictionary: seen = {}. For each name in names: if name is in the seen dictionary: seen[name] += 1 else: seen[name] = 1

When this loop finishes, the dictionary, seen, will contain all the names and the number of times they have occurred.

Next, think about the following:

How do you rewrite the pseudocode in Python?
Using only the dictionary, how can you tell a name is a duplicate? How can you extract the duplicates?

When you have solved the above, see Program 3.

Quizzes and Code Reviews

There are weekly written quizzes and code reviews in 1001G. Make sure to sign up for Quiz 1 and Code Review 1 which need to be completed by Thursday, 8 February.

Additional Practice

For additional practice on core Python, see the HackerRank prepare series:

HackerRank: Prepare Python

Click the Easy option on the right hand menu, and work through their Python challenges.

For more practice on using dictionaries to solve problems, here are some popular ones from LeetCode where using dictionaries is an efficient approach:

Laboratory Exercise 1 CSci 227: Programming Methods Department of Computer Science Hunter College, City University of New York Spring 2024