7-Day Agenda in Python This is a personal project of mine.  I made a simple seven day agenda program in Python that stores tasks as a string, saves it into a .dat file, and returns that task when you input a day of the week.  This works on a terminal.  I'm new to programming in general.
This is Python 3.8.2, 32 bit, and in a virtual environment.
# Pickle module allows you to save data after program closes
import pickle

week = {&quot;Sunday&quot;: [], &quot;Monday&quot;: [], &quot;Tuesday&quot;: [],
        &quot;Wednesday&quot;: [], &quot;Thursday&quot;: [], &quot;Friday&quot;: [], &quot;Saturday&quot;: []}


def agenda():
    option = input(
        &quot;What would you like to do?  (A - look at agenda, B - create task, C - clear list, or D - quit) &quot;).upper()
    if option == &quot;A&quot;:
        look_at_agenda()
    elif option == &quot;B&quot;:
        create_task()
    elif option == &quot;C&quot;:
        clear_list()
    elif option == &quot;D&quot;:
        print(&quot;Have a nice day!&quot;)
    else:
        print(&quot;Invalid option.&quot;)
        agenda()

# global allows day variable in other functions to work even without declaring it


def valid_days():
    global day
    day = input(&quot;Which day? &quot;).capitalize()
    week_list = [day_list for day_list in week.keys()]
    if day not in week_list:
        print(&quot;Invalid day.&quot;)
        valid_days()


# Loads whatever string from week.dat file
def look_at_agenda():
    see_all = input(&quot;See entire week? Y - yes, N - no. &quot;).upper()
    if see_all == &quot;Y&quot;:
        week = pickle.load(open(&quot;week.dat&quot;, &quot;rb&quot;))
        print(week)
    elif see_all == &quot;N&quot;:
        valid_days()
        week = pickle.load(open(&quot;week.dat&quot;, &quot;rb&quot;))
        print(week[day])
    else:
        print(&quot;Invalid option.&quot;)
        look_at_agenda()
    agenda()


def create_task():
    valid_days()
    task = input(&quot;Describe your task. &quot;)
    # Loads string from week.dat file; when program restarts, it allows you to create a task without deleting the saved ones
    week = pickle.load(open(&quot;week.dat&quot;, &quot;rb&quot;))
    week[day].append(task)
    # Saves string into week.dat file so it remembers when you open the program again
    pickle.dump(week, open(&quot;week.dat&quot;, &quot;wb&quot;))
    agenda()


def clear_list():
    clear_all = input(&quot;Clear all lists? Y - yes, N - no &quot;).upper()
    if clear_all == &quot;N&quot;:
        valid_days()
        week[day].clear()
        print(f&quot;List cleared for {day}!&quot;)
        # saves the new list into a week.dat file
        pickle.dump(week, open(&quot;week.dat&quot;, &quot;wb&quot;))
    elif clear_all == &quot;Y&quot;:
        [week[day].clear() for day in week]
        # saves the now empty list into a week.dat file
        pickle.dump(week, open(&quot;week.dat&quot;, &quot;wb&quot;))
    else:
        print(&quot;Invalid option.&quot;)
        clear_list()
    agenda()

agenda()
Welcome to the code review community. The code looks clean, and follows the PEP8 style guide. Here are a few suggestions/modifications you can make though:

Do not use global variables.

Instead of calling agenda() at the end, put it inside the if __name__ block.

Since you're working with python 3.8+, you may also add type hinting for function arguments.

For user input/validation, you can make use of a while loop:
 from typing import List

 def read_user_input_from_options(message: str, valid_inputs: List = None):
     &quot;&quot;&quot;
     Show `message` in the console while asking for user input.

     If `valid_inputs` is not provided, returns the value from user as is.
     &quot;&quot;&quot;
     if valid_inputs:
         valid_inputs = map(lambda x: x.upper(), valid_inputs)
     while True:
         user_input = input(message)
         if not valid_inputs:
             return user_input
         user_input = user_input.upper()
         if user_input in valid_inputs:
             return user_input
         print(&quot;Invalid option chosen. Try again.&quot;)

The above is an example suited for your case, where all the input option you need are capitalised alphabets. It can be extended to support other validators as per requirements.

Use multiline strings. Makes it more readable. It is more a personal preference than rules to live by.

You can map the option to a function call (see below):
 def quit_program():
     print(&quot;Have a nice day!&quot;)
     return


 def main():
     OPTION_TO_FUNCTION = {
         &quot;A&quot;: look_at_agenda,
         &quot;B&quot;: create_task,
         &quot;C&quot;: clear_list,
         &quot;D&quot;: quit_program,
     }
     option = read_user_input_from_options(
         &quot;&quot;&quot;
         What would you like to do?
         A - look at agenda
         B - create task
         C - clear list
         D - quit
         &quot;&quot;&quot;,
         valid_inputs=[&quot;a&quot;, &quot;b&quot;, &quot;C&quot;, &quot;d&quot;],
     )
     return OPTION_TO_FUNCTION[option]()

where main is the function called from inside your if __name__ == &quot;__main__&quot; block.

Make use of a class to keep the state of current execution. This would accompany my point about avoiding globals as well.