this is my code: def read$\_$pokedata$($poke$\_$file$)$:

poke$\_$file $=$ open$($poke$\_$file, $\text{'}$r$\text{'})$

poke$\_$data $=\{\}$

$"""$takes parameter poke$\_$file and returns a dictionary of the records of each pokemon with

pokemon name as the key and data as its value

poke$\_$file: file consisting of pokemons name, type and location $"""$

for line in poke$\_$file:

# split any newline characters in the file

spaces $=$ line.strip$()$

# separate each value that has a comma and turn it into list

items $=$ spaces.split$(\text{'},\text{'})$

# name, type and location based on the indexes of the list

pokemon$\_$name $=$ items$[0]$

pokemon$\_$type $=$ items$[1]$

pokemon$\_$location $=\text{'},\text{'}.$join$($items$[2$:$])$

# pokemon name as the key with separate dictionary of pokemon type and locations as value

poke$\_$data$[$pokemon$\_$name$]=\{\text{'}$pokemon type': pokemon$\_$type, 'location$($s$)\text{'}$: pokemon$\_$location $\}$

return poke$\_$data

#poke$\_$data $=$ read$\_$pokedata$($poke$\_$file$)$

def find$\_$continents$($poke$\_$data$)$:

$"""$ defines function find$\_$continents with parameter poke$\_$data and returns list of different

locations pokemon's can be found in$.$

poke$\_$data: dictionary consisting of pokemon name its key and separate dictionary with type and locations as value $"""$

# for pokemon name and data within that name turn the values within data into list

continent$\_$list $=[]$

for name, data in poke$\_$data.items$()$:

# for each continent in the second index of that value location$($s$)$

for location in data$[\text{'}$location$($s$)\text{'}].$split$(\text{'},\text{'})$:

# append unique continent into continent$\_$list if its not already in the list

if location.strip$()$ not in continent$\_$list:

continent$\_$list.append$($location$.$strip$())$

return continent$\_$list

def pokemon$\_$in$\_$continent$($poke$\_$data, continent$\_$list$)$:

$"""$takes function pokemon$\_$in$\_$continent and returns list of pokemons in every continent within continent list

poke$\_$data: dictionary of pokemon name with pokemon type and location

content$\_$list: list of continents pokemons are in $"""$

continent$\_$pokemons $=[]$

# for each continent in continent list and each name and data in dictionary

# if the continent is in the 'location$($s$)\text{'}$ of a specific pokemon, append that pokemon name in continent$\_$pokemons list

for continent in continent$\_$list:

for name, data in poke$\_$data.items$()$:

if continent in data$[\text{'}$location$($s$)\text{'}]$:

continent$\_$pokemons.append$($name$)$

return continent$\_$pokemons

def count$\_$types$($poke$\_$data, continent$\_$pokemons$)$:

$"""$defines function count$\_$types with two parameters and returns dictionary of number of types within each continent

poke$\_$data: takes dictionary of poke$\_$data

continent$\_$pokemons: takes list of pokemons present in the continent $"""$

poke$\_$types $=\{\}$

# for each pokemon in continent$\_$pokemons list

for pokemon in continent$\_$pokemons:

pokemon$\_$type $=$ poke$\_$data$[$pokemon$][\text{'}$pokemon type'$]$

# if the pokemon type is in poke$\_$types update it by $1$

if pokemon$\_$type in poke$\_$types:

poke$\_$types$[$pokemon$\_$type$]+=1$

# if the pokemon type is not in poke$\_$types count it by $1$

else:

poke$\_$types$[$pokemon$\_$type$]=1$

return poke$\_$types

poke$\_$data $=$ read$\_$pokedata$($poke$\_$file$)$

continents $=$ find$\_$continents$($poke$\_$data$)$

# for each continent in continents

for continent in continents:

# defines variable that takes all pokemons inesting Part $1($read$\_$pokedata$())$: Since this function reads data from a file, your test inputs must

in fact consist of different files! Thus, for each test, create an input file with the same format as

pokemonLocations.txt$.$ Your test files will likely be MUCH smaller than the provided file. Do not bother

testing with files that are not correctly formatted, focus instead on the diversity of possible valid files.

$$ Testing Part $2($find$\_$continents$())$: The inputs to this function is a database of Pokemon information.

It is ok to use your read$\_$pokedata$()$ function to create the database rather than typing in database

literals $($so long as you confident that function works thanks to testing it$!),$ in which case your test inputs

will again consist of input files. Careful! The pokemon in your database might be processed in any

order $($because it$$s a dictionary!$)$ and we don$$t care about the ORDER of the continents in the resulting

list. You can deal with this by SORTING the resulting list before comparing it to the expected result!

$$ Testing Part $3($pokemon$\_$in$\_$continent$())$: Again this function requires a database, and it is again ok

to use your read$\_$pokedata$()$ funtion to create it if you find this less tedious. The continent name for

each test should however be picked manually. And again, you$$ll want to sort the resulting list before

testing.

$$ Testing Part $4($count$\_$types$())$: Again this function requires a database, and it is again ok to use your

read$\_$pokedata$()$ funtion to create it if you find this less tedious. The list of pokemon names should be created manually.