From 0b4996c9ea6f48c34f4d1c6c2cfb8c17818b4900 Mon Sep 17 00:00:00 2001 From: Michael Govaerts <77564511+mgg143@users.noreply.github.com> Date: Fri, 10 Apr 2026 23:14:31 -0700 Subject: [PATCH] added all the code for assignment1 and it passes unit tests --- assignment1/assignment1.py | 228 ++++++++++++++++++++++++++++++++++++- 1 file changed, 227 insertions(+), 1 deletion(-) diff --git a/assignment1/assignment1.py b/assignment1/assignment1.py index fafa187..75dafcb 100644 --- a/assignment1/assignment1.py +++ b/assignment1/assignment1.py @@ -1 +1,227 @@ -# Write your code here. \ No newline at end of file +# Task 1: Hello +''' Write a hello function that takes no arguments and returns Hello!. Now, what matters here is what the function returns. +You can print() whatever you want for debugging purposes, but the tests ignore that, and only check the return value. +''' +import string + + +def hello(): + return "Hello!" + +#Task 2: Greet with a Formatted String +''' Write a greet function. It takes one argument, a name, and returns Hello, Name!. Use a formatted string. +Note that you have to return exactly the right string or the test fails -- but PyTest tells you what didn't match. ''' + +def greet(name): + return f"Hello, {name}!" + +# Task 3: Calculator +''' Write a calc function. It takes three arguments. The default value for the third argument is "multiply". The first two arguments are +values that are to be combined using the operation requested by the third argument, a string that is one of the following add, subtract, +multiply, divide, modulo, int_divide (for integer division) and power. The function returns the result. + +Error handling: When the function is called, it could ask you to divide by 0. That will throw an exception: Which one? You can find out by +triggering the exception in your program or in the Python Interactive Shell. Wrap the code within the calc function in a try block, and put +in an except statement for this exception. If the exception occurs, return the string "You can't divide by 0!". + +More error handling: When the function is called, the parameters that are passed might not work for the operation. For example, you can't +multiply two strings. Find out which exception occurs, catch it, and return the string "You can't multiply those values!". + +Here's a tip. You have to do different things for add, multiply, divide and so on. So you can do a conditional cascade, if/elif/elif/else. +That's perfectly valid. But you might want to use the match-case Python statement instead. Look it up! It just improves code appearance. ''' + +def calc(a, b, operation="multiply"): + try: + match operation: + case "add": + return a + b + case "subtract": + return a - b + case "multiply": + return a * b + case "divide": + return a / b + case "modulo": + return a % b + case "int_divide": + return a // b + case "power": + return a ** b + except ZeroDivisionError: + return "You can't divide by 0!" + except TypeError: + if operation == "multiply": + return "You can't multiply those values!" + +# Task 4: Data Type Conversion +''' +Create a function called data_type_conversion. It takes two parameters, the value and the name of the data type requested, one of float, str, or int. +Return the converted value. +Error handling: The function might be called with a bad parameter. For example, the caller might try to convert the string "nonsense" to a float. +Catch the error that occurs in this case. If this error occurs, return the string 'You can't convert {value} into a {type}.', except you use the value +and data type that are passed as parameters -- so again you use a formatted string. +''' + +def data_type_conversion(value, data_type): + try: + match data_type: + case "float": + return float(value) + case "str": + return str(value) + case "int": + return int(value) + except ValueError: + return f"You can't convert {value} into a {data_type}." + +# Task 5: Grading System, Using *args +''' +Create a grade function. It should collect an arbitrary number of parameters, compute the average, and return the grade. based on the following scale: +A: 90 and above +B: 80-89 +C: 70-79 +D: 60-69 +F: Below 60 + +When you use *args you get access to a variable named args in your function, which is a tuple, an ordered collection of values like a list. + +You'll learn more about tuples and lists in the next lesson. There are some helpful functions you can use at this point: sum(args), len(args), +and so on. One of the curiosities of Python is that these are not methods of any class. They are just standalone functions. + +Handle the error that occurs if the parameters are nonsense. Return the string "Invalid data was provided." in this case. (Typically, you don't +handle every possible exception in your error handling, except if the values in the parameters comes from the end user.) +''' + +def grade(*args): + try: + average = sum(args) / len(args) + if average >= 90: + return "A" + elif average >= 80: + return "B" + elif average >= 70: + return "C" + elif average >= 60: + return "D" + else: + return "F" + except TypeError: + return "Invalid data was provided." + +# Task 6: Use a For Loop with a Range +''' +Create a function called repeat. It takes two parameters, a string and a count, and returns a new string that is the old one repeated count times. + +You can get the test to pass by just returning string * count. That would produce the correct return value. +But, for this task, do it using a for loop and a range. +''' + +def repeat(string, count): + result = "" + for i in range(count): + result += string + return result + +#Task 7: Student Scores, Using **kwargs +''' +Create a function called student_scores. It takes one positional parameter and an arbitrary number of keyword parameters. +The positional parameter is either "best" or "mean". If it is "best", the name of the student with the higest score is returned. +If it is "mean", the average score is returned. + +As you are using **kwargs, your function can access a variable named kwargs, which is a dict. The next lesson explains about dicts. +What you need to know now is the following: + +A dict is a collection of key value pairs. + +You can iterate through the dict as follows: +for key, value in kwargs.items(): + +You can also get kwargs.keys() and kwargs.values(). + +The arbitrary list of keyword arguments uses the names of students as the keywords and their test score as the value for each. +''' + +def student_scores(statistic, **kwargs): + if statistic == "best": + best_student = max(kwargs, key=kwargs.get) + return best_student + elif statistic == "mean": + average_score = sum(kwargs.values()) / len(kwargs) + return average_score + +# Task 8: Titleize, with String and List Operations +''' +Create a function called titleize. It accepts one parameter, a string. The function returns a new string, where the parameter string is + capitalized as if it were a book title. +The rules for title capitalization are: (1) The first word is always capitalized. (2) The last word is always capitalized. (3) All + the other words are capitalized, except little words. For the purposes of this task, the little words are "a", "on", "an", "the", "of", "and", + "is", and "in". + +The following string methods may be helpful: split(), join(), and capitalize(). Look 'em up. +The split() method returns a list. You might store this in the words variable. words[-1] gives the last element in the list. +The in comparison operator: You have seen in used in loops. But it can also be used for comparisons, for example to check to see + if a substring occurs in a string, or a value occurs in a list. + +A new trick: As you loop through the words in the words list, it is helpful to have the index of the word for each iteration. + +You can access that index using the enumerate() function: + + for i, word in enumerate(words): +''' + +def titleize(string): + little_words = ["a", "on", "an", "the", "of", "and", "is", "in"] + words = string.split() + for i, word in enumerate(words): + if i == 0 or i == len(words) - 1 or word not in little_words: + words[i] = word.capitalize() + return " ".join(words) + +# Task 9: Hangman, with more String Operations +''' +Create a function hangman. It takes two parameters, both strings, the secret and the guess. +The secret is some word that the caller doesn't know. So the caller guesses various letters, which are the ones in the guess string. +A string is returned. Each letter in the returned string corresponds to a letter in the secret, except any letters that are not in the guess + string are replaced with an underscore. The others are returned in place. Not everyone has played this kid's game, but it's common in the US. + +Example: Suppose the secret is "alphabet" and the guess is "ab". The returned string would be "a___ab__". + +Note that Python strings are immutable. That means that the following code would give an error: + +secret = "alphabet" +secret[1] = "_" + +On the other hand, you can concatenate strings with the + operator. +''' +def hangman(secret, guess): + result = "" + for letter in secret: + if letter in guess: + result += letter + else: + result += "_" + return result + +# Task 10: Pig Latin, Another String Manipulation Exercise +''' +Pig Latin is a kid's trick language. Each word is modified according to the following rules. (1) If the string starts with a vowel (aeiou), + "ay" is tacked onto the end. (2) If the string starts with one or several consonants, they are moved to the end and "ay" is tacked on after them. + (3) "qu" is a special case, as both of them get moved to the end of the word, as if they were one consonant letter. +Create a function called pig_latin. It takes an English string or sentence and converts it to Pig Latin, returning the result. + We will assume that there is no punctuation and that everything is lower case. +''' +def pig_latin(string): + vowels = "aeiou" + words = string.split() + pig_latin_words = [] + for word in words: + if word[0] in vowels: + pig_latin_words.append(word + "ay") + else: + first_consonant_index = 0 + while first_consonant_index < len(word) and word[first_consonant_index] not in vowels: + first_consonant_index += 1 + if first_consonant_index > 0 and word[first_consonant_index - 1:first_consonant_index + 1] == "qu": + first_consonant_index += 1 + pig_latin_words.append(word[first_consonant_index:] + word[:first_consonant_index] + "ay") + return " ".join(pig_latin_words) \ No newline at end of file