⚠

Privacy Notice: When you sign in with GitHub, your quiz attempts are stored in Google Firebase so you can track your progress. This data is only accessible to the course instructor, is not otherwise shared, and will be deleted at the end of the semester. For earlier deletion, contact the instructor. Prefer to stay anonymous? Use guest mode or a GitHub account without your real name.

● Progress is being saved

02 Exercise: PEP 8 Violation Spotting

Score: 0 / 16

Question Overview

Pending Correct Incorrect

Instructions

This interactive quiz tests your ability to spot PEP 8 violations in Python code. The questions are based on the Level 2 PEP 8 exercises and cover:

Naming conventions (snake_case, PascalCase, UPPER_CASE)
Whitespace rules (spaces around operators, after commas, after colons)
Import organization (one import per line, removing unused imports)
Compound statements (avoid multiple statements on one line)
Line length (79-88 character limit)
Resource management (using with for file handling)

Read each code snippet carefully and try to identify all the violations before selecting your answer. Good luck!

Question1 Counting Violations

How many PEP 8 violations are in this code?

import sys,os
import numpy as np

def ProcessData(input_list,threshold=10):
    result=[]
    for item in input_list:
        if item>threshold:result.append(item*2)
    return result

Question2 Spotting Violations

Select ALL PEP 8 violations present in this code:

import sys,os
import numpy as np

def ProcessData(input_list,threshold=10):
    result=[]
    for item in input_list:
        if item>threshold:result.append(item*2)
    return result

Select all that apply:

A) Multiple imports on one line (`sys,os`) B) Function name uses PascalCase instead of snake_case (`ProcessData`) C) Missing spaces around the assignment operator (`result=[]`) D) The `for` loop should use `enumerate()` instead of iterating directly E) Compound statement on one line (`if item>threshold:result.append(...)`) F) Using `numpy` as `np` is a PEP 8 violation

Question3 Naming Conventions

What naming convention should the function ProcessData use according to PEP 8?

A) `process_data` (snake_case) — function names should be lowercase with underscores B) `processData` (camelCase) — this is the standard for all Python identifiers C) `ProcessData` (PascalCase) — it is already correct for functions D) `PROCESS_DATA` (UPPER_CASE) — functions should stand out like constants

Question4 Counting Violations

How many PEP 8 violations are in this code?

from dash import Dash,html,dcc
import numpy as np
import sys

def generate_road_profile(num_points=100,x_max=80):
    x=np.linspace(0,x_max,num_points)
    y=0.015*x**3+0.3*np.sin(2*np.pi*x)
    return x,y

camera_position={'x':0,'y':2.0,'z':1.5}
MAX_distance=100

Question5 Spotting Violations

Select ALL PEP 8 violations present in this code snippet:

camera_position={'x':0,'y':2.0,'z':1.5}
MAX_distance=100

Select all that apply:

A) Missing spaces after colons in the dictionary (`'x':0` should be `'x': 0`) B) Inconsistent constant naming (`MAX_distance` should be `MAX_DISTANCE`) C) Missing spaces around the assignment operator (`camera_position=`) D) The variable name `camera_position` should use UPPER_CASE because it is a module-level variable E) Dictionaries should use double quotes instead of single quotes F) Missing spaces after commas between dictionary entries

Question6 Naming Conventions

What is wrong with the variable name MAX_distance according to PEP 8?

A) It mixes UPPER_CASE and lowercase — module-level constants should be fully UPPER_CASE (`MAX_DISTANCE`) B) It should use camelCase: `maxDistance` C) The word `MAX` is reserved and cannot be used in variable names D) There is nothing wrong — partial caps is acceptable for constants

Question7 Spotting Violations

Select ALL PEP 8 violations present in this code:

import numpy as np
from typing import List

def HelperFunction(val):
    result=val*2
    return result

def another_helper(x,y,z): return x+y+z

def calculate_distance(point1,point2):
    dx=point2[0]-point1[0]
    dy=point2[1]-point1[1]
    return np.sqrt(dx**2+dy**2)

# This is a very long comment that definitely exceeds the recommended 79 character limit for code readability

Select all that apply:

A) Function name `HelperFunction` uses PascalCase instead of snake_case B) Missing spaces around operators in `result=val*2` C) Compound statement on one line: `def another_helper(x,y,z): return x+y+z` D) Missing spaces after commas in parameter lists (`x,y,z` and `point1,point2`) E) Comment on the last line exceeds the recommended line length limit F) The `List` import from `typing` is unused G) Using `np.sqrt` instead of `math.sqrt` is a PEP 8 violation

Question8 Compound Statements

Why does PEP 8 discourage the compound statement def another_helper(x,y,z): return x+y+z?

A) It makes the code harder to read and debug — the function body should be on its own indented line B) Python does not allow return statements on the same line as def C) Compound statements cause syntax errors in Python 3 D) Functions must always have at least two lines of code

Question9 Spotting Violations

Select ALL PEP 8 violations present in this code:

import sys,os,json

class DataProcessor:
    def __init__(self,data,config=None):
        self.data=data
        self.config=config if config else {}

    def Process(self,threshold=0):
        filtered=[x for x in self.data if x>threshold]
        return filtered

    def GetStats(self):
        return {'mean':np.mean(self.data),'std':np.std(self.data)}

max_items=1000

Select all that apply:

A) Multiple imports on one line and all three are unused (`sys,os,json`) B) Method names `Process` and `GetStats` use PascalCase instead of snake_case C) Missing spaces around assignment operators (`self.data=data`, `filtered=`, etc.) D) Missing spaces after colons in the dictionary (`'mean':np.mean(...)`, `'std':np.std(...)`) E) Module-level variable `max_items` should use UPPER_CASE (`MAX_ITEMS`) F) The class name `DataProcessor` should use snake_case G) Missing spaces after commas in parameter lists (`self,data,config` and `self,threshold`)

Question10 Naming Conventions

According to PEP 8, what naming convention should the methods Process and GetStats use?

A) snake_case: `process` and `get_stats` B) camelCase: `process` and `getStats` C) PascalCase is correct for methods — they are already named properly D) UPPER_CASE: `PROCESS` and `GET_STATS`

Question11 Beyond PEP 8

This code has a bonus issue that is not strictly a PEP 8 violation but would cause a runtime error. What is it?

import sys,os,json

class DataProcessor:
    def __init__(self,data,config=None):
        self.data=data
        self.config=config if config else {}

    def GetStats(self):
        return {'mean':np.mean(self.data),'std':np.std(self.data)}

A) `np` (NumPy) is used in `GetStats` but never imported — this would cause a `NameError` B) The `config` parameter defaults to `None` which causes a `TypeError` C) `self.data` might be empty, causing a `ZeroDivisionError` in `np.mean` D) The class is missing a `__str__` method which will cause an `AttributeError`

Question12 Spotting Violations

Select ALL PEP 8 violations present in this code:

from typing import List,Tuple
import numpy as np

def find_intersection(x_road,y_road,angle_degrees,camera_x=0,camera_y=1.5):
    angle_rad=np.radians(angle_degrees)
    ray_dx=np.cos(angle_rad)
    ray_dy=np.sin(angle_rad)

    for i in range(len(x_road)-1):
        x1,y1=x_road[i],y_road[i]
        x2,y2=x_road[i+1],y_road[i+1]

        t=((camera_y-y1)*ray_dx-(camera_x-x1)*ray_dy)/((x2-x1)*ray_dy-(y2-y1)*ray_dx)

        if 0<=t<=1:
            x_intersect=x1+t*(x2-x1)
            return x_intersect,y1+t*(y2-y1)

    return None,None

Select all that apply:

A) Missing spaces after commas in function parameters (`x_road,y_road,angle_degrees,...`) B) Missing spaces around assignment operators (`angle_rad=`, `ray_dx=`, `t=`, `x_intersect=`, etc.) C) Missing spaces around comparison operators (`0<=t<=1` should be `0 <= t <= 1`) D) Missing spaces after commas in tuple unpacking and returns (`x1,y1=`, `return None,None`) E) The complex expression for `t` is too long and should be broken into intermediate variables F) The function name `find_intersection` should use PascalCase G) Using `range(len(...))` is a PEP 8 violation

Question13 Line Length

The following line from Exercise 2.5 is too long. What is the BEST way to fix it according to PEP 8 best practices?

t=((camera_y-y1)*ray_dx-(camera_x-x1)*ray_dy)/((x2-x1)*ray_dy-(y2-y1)*ray_dx)

A) Break it into named intermediate variables like `numerator` and `denominator` for clarity B) Use a backslash (`\`) to continue the expression on the next line C) Shorten all variable names to single letters to fit within the line limit D) Remove the spaces around operators so the line becomes shorter

Question14 Spotting Violations

Select ALL PEP 8 violations present in this code:

import json,sys
from pathlib import Path

class ConfigManager:
    def __init__(self,config_file="config.json"):
        self.config_file=config_file
        self.data=self.load_config()

    def load_config(self):
        if Path(self.config_file).exists():return json.load(open(self.config_file))
        return {}

    def get_value(self,key,default=None):
        return self.data.get(key,default)

    def update_config(self,updates):
        self.data.update(updates)
        with open(self.config_file,"w") as f:json.dump(self.data,f)

DEFAULT_timeout=30
max_retries=3

Select all that apply:

A) Multiple imports on one line and unused import (`json,sys` — `sys` is unused) B) Compound statements: `if ...:return` and `as f:json.dump(...)` put multiple statements on one line C) Missing spaces after commas in parameter lists throughout the class D) Missing spaces around assignment operators (`self.config_file=`, `self.data=`) E) Inconsistent constant naming (`DEFAULT_timeout` and `max_retries` should both be UPPER_CASE) F) The class name `ConfigManager` should use snake_case G) File opened without a context manager in `load_config` (`open(self.config_file)` without `with`)

Question15 Compound Statements

What is the correct way to rewrite this compound statement from Exercise 2.6?

if Path(self.config_file).exists():return json.load(open(self.config_file))

A) Split into multiple lines AND use a `with` statement for proper file handling B) Just add a newline after the colon — no other changes needed C) Replace with a ternary expression: `return json.load(open(self.config_file)) if Path(self.config_file).exists() else {}` D) Use a semicolon instead of a colon to separate the statements

Question16 Naming Conventions

How should the following module-level variables be renamed according to PEP 8?

DEFAULT_timeout=30
max_retries=3

A) `DEFAULT_TIMEOUT = 30` and `MAX_RETRIES = 3` B) `default_timeout = 30` and `max_retries = 3` (all lowercase) C) `DefaultTimeout = 30` and `MaxRetries = 3` (PascalCase) D) `DEFAULT_timeout = 30` is already correct; only `max_retries` needs changing

02 Exercise: PEP 8 Violation Spotting

Instructions

Quiz Complete!