Conway's Game of Life without objects
You're representing the cells mainly using a dictionary of coordinates, converting to a two-dimensional array only for the purposes of printing the output.  That is a good representation for sparse boards, but not so much for crowded boards.

The algorithm that you use, though, is cumbersome, particularly illustrated by these few lines:


for item in cells.keys():
    checking = [ x for x in list_to_check(item[0],item[1]) if x not in to_check and x not in cells ]
    to_check += checking



In other words, make a list of the neighbors of each cell, but make sure that each coordinate is listed just once.  Then, once you have that list to_check, what do you do with it?


for item in to_check:
    if neighbors_count(item[0],item[1],cells) == 3:
        to_add[(item[0],item[1])] = 1



You count each cell's neighbors!  But the number of neighbors is precisely the amount of overlapped processing that would have occurred had you not bothered to deduplicate the to_check list to begin with!  So, instead of drawing a list of interesting cells and counting their neighbors, why not just have each existing cell increment the neighbor count of each neighboring coordinate?

In addition to the change in algorithm, I also recommend:


Take advantage of list/set/dict comprehensions more.
Represent the board as a set of live cells, rather than a dict.
Rename list_to_check() to neighbors().
Rename print_grid() to grid(), since it actually doesn't print anything.
Construct the next state from scratch rather than by mutation: test_array_dict = tick(test_array_dict)


I'd rewrite three functions as follows (and eliminate neighbors_count(), next_state(), and add_to_grid_alive():

def tick(live_cells):
    """ Takes a set of coordinates of live cells, and returns a set of
    coordinates of the live cells in the next generation. """
    neighbor_count = {}
    for xy in live_cells:
        for neighbor in neighbors(*xy):
            neighbor_count[neighbor] = 1 + neighbor_count.get(neighbor, 0)
    return set(xy for xy in neighbor_count
                   if neighbor_count[xy] == 3
                   or xy in live_cells and neighbor_count[xy] == 2)

def grid(size, cells):
    return [[int((x, y) in cells) for x in range(size)] for y in range(size)]

def load_list(inputs):
    return set(inputs)


Actually, tick() would be even better written using a collections.Counter.  I don't know if you consider that "using an object".