Zip a list of lists and a second list as keys and values.

There are several points I would like to address concerning the code and the situation.

Firstly lets just get a mild syntatic issue out of the way. The use of list as a variable is dubious. There is a built-in function by the name of list that is responsible for transforming other collections into lists.

print list((1, 2, 3))
> [1, 2, 3]

Due to the fact that list is a built in function, we would want to avoid naming variables list. The code you have written won't cause any collisions via shadowing. In this case the issue doesn't manifest but if you had defined list as a function instead and tried to invoke it, it could cause issues. To that effect, I recommend renaming your list variable lst just to avoid confusion.

def makealist(row, column):
    lst = [[random.randint(0, 100) for x in range(row)] for y in range(column)]
    return lst

Secondly lets discuss what we need to accomplish for part 2 and 3:

1. Create a list of values based on the random numbers. Specifically, determine whether the number is even or odd and then append it to a new list.
2. Create a dictionary out of these two lists. The number is the key and odd/even string is the value. Of course, the number cannot appear more than once.

We can accomplish this task in a simple two step process. The first thing to do is recognize that we shouldn't be concerned with zipping lists of lists. This creates undo complications. A mantra I've come to live by in my coding is Keep your datastructures as simple as possible until otherwise necessary. Considering the logical flow of operations suggested we want to transform your data first

def even_odd:
  return [(x, 'even' if x % 2 == 0 else 'odd') for x in lst]
test = [1,2,3,4]
print even_odd(test)
> ['odd', 'even', 'odd', 'even']

Then filter the resultant data. However, then we have to deal with lists nested in lists and tuples. It is simpler flatten our data into a single list without duplicates then perform the transformation.

To flatten the list and remove duplicates we have an excellent built-in collection called a set. Now, I'm not sure if everyone who may read this knows how sets work so I'll include a brief explaination here. Sets are essentially lists of elements that CANNOT include duplicates.

list(1,2,3)
> [1, 2, 3]
list (1,2,3,3)
> [1, 2, 3, 3]
set([1,2,3])
> set([1, 2, 3])
set([1,2,3,3])
> set([1, 2, 3])

By using a set, we totally remove the opportunity for duplicates. Sets are a mathematical construct so they have other properties in addition to the non-duplication factor that can be used in other circumstances. However the python documentation and its deprecated version provide documentation on the possible functionality that is included in python. Now we can use sets to remove duplicates while flattening the list:

def flatten_and_deduplicate(lst):
  set_of_vals = set()
  for sublist in lst:
    for item in sublist:
      set_of_vals.add(item)
    return [x for x in set_of_vals] #Converting the set to a list

test = [[1,2,3],[1,2],[1,2,3,4]]
print test
> [[1, 2, 3], [1, 2], [1, 2, 3, 4]] 
print flatten_and_deduplicate(test)
> [1, 2, 3, 4]

Next we'll take advantadge of a technique not heavily discussed in the Treehouse courses which is dictionary comprehensions. Dictionary comprehensions are basically the same as list comprehensions except they allow us to build dictionaries in the same way we build list comprehensions. For some examples:

# Creating a list w/ key, value structure
test = [('name', 'Jim'), ('occupation', 'wizard of wizardry'), ('pet', 'lopsided goldfish')]
{ key : value for (key, value) in test}
> {'name': 'Jim', 'occupation': 'wizard of wizardry', 'pet': 'lopsided goldfish'}
# Manipulating elements into more complicated forms
test = [1, 2, 3, 4]
{ key : key * 2 for key in test}
> {1: 2, 2: 4, 3: 6, 4: 8}

We can then use this approach in combination with the guts of our even_odd function from earlier in ordet to develop a dictionary comprehension that uses the number as the key and provides the evenness/oddness as the value.

def dictionary_of_evenodd(lst):
  return { key: 'even' if x % 2 == 0 else 'odd' for x in lst}
test = [1,2,3,4]
print dictionary_of_evenodd(test)
> {1: 'odd', 2: 'even', 3: 'odd', 4: 'even'}

Since we reduced the list of lists earlier into a single list, we don't have to worry about the complicated implementation details of the lists of lists. Furthermore, we don't have to worry about tuples or duplicates. As they say: simplify THEN calculate. Combining our techniques into a singular function we wind up with the following:

def labelValues(lst):
  set_of_vals = set()
  for sublist in lst:
    for listitem in sublist:
      set_of_vals.add(listitem)
  out_dict = {key: "even" if key % 2 == 0 else "odd" for key in set_of_vals}
  return out_dict

Now that's not to say in terms of code-golf this is the most 'optimized' nor pythonic way of handling this. However, it effectively handles our convoluted lists of lists pretty well. Combining everything into a final form we have.

import random
def makealist(row, column):
    lst = [[random.randint(0, 100) for x in range(row)] for y in range(column)]
    return lst


def printlist(lst):
    for item in lst:
        print(item[0], ', '.join(map(str, item[1:])))
        return lst


def labelValues(lst):
  set_of_vals = set()
  for sublist in lst:
    for listitem in sublist:
      set_of_vals.add(listitem)
  out_dict = {key: "even" if key % 2 == 0 else "odd" for key in set_of_vals}
  return out_dict

list = makealist(10, 10)
print labelValues(list)
#Example output
> {2: 'even', 3: 'odd', 4: 'even', 5: 'odd', 6: 'even', 7: 'odd', 9: 'odd', 10: 'even', 
13: 'odd', 14:'even', 15: 'odd', 16: 'even', 17: 'odd', 20: 'even', 21: 'odd', 25: 'odd', 
26: 'even', 27: 'odd', 28:'even', 30: 'even', 31: 'odd', 32: 'even', 33: 'odd', 34: 'even',
35: 'odd', 36: 'even', 38: 'even', 39: 'odd', 40: 'even', 42: 'even', 47: 'odd', 48: 'even',
49: 'odd', 50: 'even', 51: 'odd', 52: 'even', 54: 'even', 55: 'odd', 56: 'even', 60: 'even',
61: 'odd', 62: 'even', 63: 'odd', 64: 'even', 66: 'even', 69: 'odd', 72: 'even', 73: 'odd',
74: 'even', 75: 'odd', 77: 'odd', 82: 'even', 83: 'odd', 84: 'even', 87: 'odd', 89: 'odd', 
91: 'odd', 92: 'even', 93: 'odd', 94: 'even', 95: 'odd', 97: 'odd'}

Hope this helps! Please let me know if there are any typos/corrections/clarifications needed. Cheers!