# Tasty Lab Hints ## Hint 2 If we have thought about this a bit, we might hit on the idea that a dictionary might work well: ```python tasks = {} # creates an empty dictionary tasks['Buy Milk'] = 'not yet' tasks['Start Lab'] = 'completed' tasks['Finish Lab'] = 'not yet' # now there are three tasks in the dictionary # how to test if a task is complete? task_name = 'Buy Milk' if tasks[task_name] == 'not yet': # task is unfinished pass else: # task is 'complete' pass # to list all the tasks for task_name, status in tasks.items(): print("- ", task_name, status) ``` Paste this block of code into the python interpreter and observe what happens. Read the code, does it make sense how we are using the task_name as the _key_ and the task_status as the _value_? We need to think about how to put thse ideas _into the class Tasty_. We might... ```python class Tasty: def __init__(self): self.tasks = {} def add_task(self, task_name): """ Add a new task to the user tasks. """ if task_name not in self.tasks: self.tasks[task_name] = "not yet" else: print("Task already added.") def display_tasks(self): for task_name, status in self.tasks.items(): print("- ", task_name, status) ``` See how those things went from just trial code to _methods_ in the class? Yes, and... the `self` variable is how you know that thing is a _method_ and not just a _function_. That's an example of how I might use the rough class here. ```python def display_tasks(self): for task_name, status in self.tasks.items(): print("- ", task_name, status) ``` ## Hint 3 Student Asks: _I'm struggling to see where we take the user input for the task name._ If we have `command = input('Tasty> ')` So the `command` variable will have `exit` or whatever, after the user types something in and taps <return>, right? And the `new <task>` command/line when entered, will actually look like `new Buy Milk` when user types the command to be processed by the program. so take the string inputted and split it into a list of strings, breaking each string on the <space> character. ```python txt = "command typed by user" x = txt.split() print(x) # x will be a list: ['command', 'typed', 'by', 'user'] ``` If we want to extend this to make two new strings: - command (the first string, perhaps "new") - and rest (the rest of the split strings glued back together with spaces in between...) ```python txt = "new Buy Milk" t = txt.split() print(t) # t will be: ["new", "Buy", "Milk"] command = t[0] # command will be "new" rest = t[1:] # carefully: Slice the array, from t[1] to end of list # rest will be ["Buy", "Milk"] rest = " ".join(rest) # now rest will be "Buy Milk" print(command, ' - ', rest) ``` and after hacking a bit in the python interpreter, you may end up with ```python line = input(prompt) #print(line) while not line: line = input(prompt) # this causes input to wait until # line is not an empty string words = line.split() #print(words) command = words[0] #print(command) rest = words[1:] rest = " ".join(rest) #print(rest) ``` and maybe the right thing to do is to change the `command = input("Tasty> ")` to something like `command, rest = tasty.prompt_user("Tasty> ")` then all the "words" after the "new" will be what you pull together to name the task? so `prompt-user(self, prompt)` becomes a method which asks for the user's input (using input(prompt)) ```python def prompt_user(self, prompt): inp = input(prompt) # insert the stuff up there about how to # split words into a list and process into two parts. ``` ### Saving/Loading to a JSON file JSON is just a structured text format for data. Very Handy. ## saving? a Hint ```python with open("saved_data.json", "w") as fp: json.dump(self.tasks,fp) ``` ## loading? a Hint ```python with open(filename) as json_file: self.tasks = json.load(json_file) ``` And you should embed these two ideas into a method. When you get to the point where you are puzzling over how to save/load multiple dicts (say, _tasks_, _trash_, and _important_), you might consider putting all this in another dictionary and just saving that. You still have to _load_ the one dict and then split it into three for use by the methods. This should be done in _load tasks_ method. The data structure might be created by ```python dict_to_save = { "tasks": self.tasks, "trash": self.trash, "impt": self.important } ``` You can now _json.dump_ the `dict_to_save` to a file. Loading it will be the opposite, you end up with one `loaded_dicts` which have to be split like: `self.tasks = loaded_dicts['tasks']` Easy Peasy