How do I fix: "TypeError: cannot unpack non-iterable NoneType object"

Question

I've been searching through stackoverflow and other various sites, but I've been unable to resolve this error for about a week now.

I'm trying the get the minimum and maximum values from each country within the dictionary. The key of the dictionary is the region. I'm unsure of where the type error is but, I'd appreciate it if someone could help.

Here's the error:

        min_tup, max_tup = get_min_max(D,region,option)
  File "proj08.py", line 107, in get_min_max
    return min[0], max[0]
UnboundLocalError: local variable 'min' referenced before assignment

Here's the sample input: Region,option: North America , 2

Here's the documentation explaining the function and .csv https://www.cse.msu.edu/~cse231/Online/Projects/Project08/Project08.pdf https://www.cse.msu.edu/~cse231/Online/Projects/Project08/data_short.csv

Here's the code:

import csv
from operator import itemgetter
# do NOT import sys

REGION_LIST = ['East Asia & Pacific',
           'Europe & Central Asia',
           'Latin America & Caribbean',
           'Middle East & North Africa',
           'North America',
           'South Asia',
           'Sub-Saharan Africa']

PROMPT = "\nSpecify a region from this list or 'q' to quit -- \nEast 
Asia & Pacific,Europe & Central Asia,Latin America & Caribbean,Middle 
East & North 
Africa,North America,South Asia,Sub-Saharan Africa: "


def open_file():
# Opens a file
while True:
    try:
        file = input("Input a file: ")
        fp = open(file, "r")
        return fp
    except FileNotFoundError:
        print("Invalid filename, please try again.")


def read_file(fp):

# Sets read Csv file to a variable
reader = csv.reader(fp)
# Skips the header
next(reader, None)

# Country List
country_list = []
# sets a dictionary
Dict = dict()
for line in reader:
    try:
        skipper = ""
        if skipper in line:
            continue
        else:
            region = line[6]
            country = line[0].strip()
            electricty = float(line[2])
            fertility = float(line[3])
            gdp = float(line[4])
            life_expectancy = float(line[5])

            country_list = [country, electricty, fertility, GDP, 
life_expectancy]

            if region in Dict.keys():
                Dict[region].append(country_list)
            elif region not in Dict.keys():
                Dict[region] = [country_list]
            else:
                continue
                
    except KeyError:
        continue
    except ValueError:
        continue

return Dict


def get_min_max(Dict, region, option):
lis = []
for k, v in Dict.items():
    if region in k[0]:
        if option == 1:
            electricity = v[1]

            tup = tuple(k, electricity)
            lis.append(tup)

            min = sorted(lis, key=itemgetter(1))
            max = sorted(lis, key=itemgetter(1), reverse=True)

        if option == 2:
            fertility = v[2]

            tup = tuple(k, fertility)
            lis.append(tup)

            min = sorted(lis, key=itemgetter(1))
            max = sorted(lis, key=itemgetter(1), reverse=True)

        if option == 3:
            gdp = v[3]

            tup = tuple(k, gdp)
            lis.append(tup)

            min = sorted(lis, key=itemgetter(1))
            max = sorted(lis, key=itemgetter(1), reverse=True)

        if option == 4:
            life_expectancy = v[4]

            tup = tuple(k, life_expectancy)
            lis.append(tup)
            min = sorted(lis, key=itemgetter(1))
            max = sorted(lis, key=itemgetter(1), reverse=True)

return min[0], max[0]


def display_all_countries(D, region):

if region in REGION_LIST:

    if region == 'all':
        print("\nDisplaying {} Region:\n".format(region))
        print("{:32s}{:>20s}{:>20s}{:>17s}{:>18s}".format(
            "Country", "Electricity Access", "Fertility rate", "GDP 
per capita", "Life expectancy"))
        for k, v in D.items():
            if region in v[0]:
                country = v[0]
                electricity = v[1]
                fertility = v[2]
                gdp = v[3]
                life = v[4]
                tup = (country, electricity, fertility, gdp, life)

                sorted(tup, key=itemgetter(0), reverse=True)
                print("{:32s}{:>20.2f}{:>20.2f}{:>17.2f} 
{:>18.2f}".format(
                    tup[0], tup[1], tup[2], tup[3], tup[4]))

if region not in REGION_LIST:
    return None


def get_top10(D):
    pass


def display_options():
    """
    DO NOT CHANGE
    Display menu of options for program
    """
    OPTIONS = """\nMenu
    1: Minimum and Maximum Countries Access to Electricity
    2: Minimum and Maximum Countries Fertility Rate
    3: Minimum and Maximum Countries GDP per Capita
    4: Minimum and Maximum Countries Life Expectancy
    5: List of countries in a region
    6: Top 10 Countries in the world by GDP per Capita\n"""
    print(OPTIONS)


def main():
    file = open_file()
    # while True:
    #     if user == 'East Asia & Pacific' or user == 'Europe & 
    Central Asia' or user == 'Middle East & North Africa' or user == 
   'Latin America & Caribbean' or user == 'North America' or user == 
   'South Asia' or user == 'Sub-Saharan Africa':
#         print("\nRegion: ".format(user))
#         display_options()

#     if user == "Q" or user == "q":
#         break
#     else:
#         user = input(PROMPT)
region = 'North America'
option = '2'
superD = read_file(file)
mina = get_min_max(superD, region, option)

#print(mina)

if __name__ == '__main__':
    main()

Answer 1

The error is telling you that you can't use unpacking assignment such as

x, y = function()

Because the function returned something that can't be unpacked (None, in this case) This means that your function returned None somehow. We can't say for sure without a reusable example, but I would guess that its because of the first if condition in your function, which can return None.

Although it is allowed, it is generally not a great idea to have multiple different return types in a python function. This is because the caller has to know how to handle different things that the function might do, instead of being able to trust that the function will work and give them a good answer (assuming of course, that they are using correct inputs.)