The simplest and best way is the second one, not the first one!

for i in array:
    do_something(i)

Never iterate indices just to index the container, it's needlessly complicating the code:

for i in range(len(array)):
    do_something(array[i])

If you need the index for some reason (usually you don't), then do this instead:

for i, element in enumerate(array):
    print("working with index", i)
    do_something(element)

This is just an error, you will get TypeError: 'int' object is not iterable when trying to unpack one integer into two names:

for i, j in range(len(array)):
    ...

This one might work, assumes the array is "two-dimensional":

for i, j in array:
    ...

An example of a two-dimensional array is a list of pairs:

>>> for i, j in [(0, 1), ('a', 'b')]:
...     print(f"{i=} {j=}")
...     
i=0 j=1
i='a' j='b'

Note: ['these', 'structures'] are called lists in Python, not arrays.

The closest there is to that is using a dictionary:

values = {}

for i in range(3):
    values[i] = int(input(f"Please input the value for item {i + 1}: "))

You can do everything in one loop

how_many = int(input("How many terms are in the equation?"))

terms = {}

for i in range(how_many):
    var = int(input("Enter the coefficient for variable"))
    terms["T{}".format(i)] = var 

And later you can use

 print( terms['T0'] )

But it is probably better to a use list rather than a dictionary

how_many = int(input("How many terms are in the equation?"))

terms = [] # empty list

for i in range(how_many):
    var = int(input("Enter the coefficient for variable"))
    terms.append(var)

And later you can use

 print( terms[0] )

or even (to get first three terms)

 print( terms[0:3] )

Sure you can; it's called a dictionary:

d = {}
for x in range(1, 10):
    d["string{0}".format(x)] = "Hello"

>>> d["string5"]
'Hello'
>>> d
{'string1': 'Hello',
 'string2': 'Hello',
 'string3': 'Hello',
 'string4': 'Hello',
 'string5': 'Hello',
 'string6': 'Hello',
 'string7': 'Hello',
 'string8': 'Hello',
 'string9': 'Hello'}

I said this somewhat tongue in check, but really the best way to associate one value with another value is a dictionary. That is what it was designed for!

If you want the effect of a nested for loop, use:

import itertools
for i, j in itertools.product(range(x), range(y)):
    # Stuff...

If you just want to loop simultaneously, use:

for i, j in zip(range(x), range(y)):
    # Stuff...

Note that if x and y are not the same length, zip will truncate to the shortest list. As @abarnert pointed out, if you don't want to truncate to the shortest list, you could use itertools.zip_longest.

UPDATE

Based on the request for "a function that will read lists "t1" and "t2" and return all elements that are identical", I don't think the OP wants zip or product. I think they want a set:

def equal_elements(t1, t2):
    return list(set(t1).intersection(set(t2)))
    # You could also do
    # return list(set(t1) & set(t2))

The intersection method of a set will return all the elements common to it and another set (Note that if your lists contains other lists, you might want to convert the inner lists to tuples first so that they are hashable; otherwise the call to set will fail.). The list function then turns the set back into a list.

UPDATE 2

OR, the OP might want elements that are identical in the same position in the lists. In this case, zip would be most appropriate, and the fact that it truncates to the shortest list is what you would want (since it is impossible for there to be the same element at index 9 when one of the lists is only 5 elements long). If that is what you want, go with this:

def equal_elements(t1, t2):
    return [x for x, y in zip(t1, t2) if x == y]

This will return a list containing only the elements that are the same and in the same position in the lists.

In Python, you can use the exec() function:

>>> for i in range(1, 6):
...     exec("line_dict_%s = { 'a': 1 }" % i)
... 
>>> line_dict_1
{'a': 1}
>>> line_dict_2
{'a': 1}
>>> line_dict_3
{'a': 1}
>>> line_dict_4
{'a': 1}
>>> line_dict_5
{'a': 1}

Using exec() is not a good idea most of the times, i would rather prefer a dictionary to keep the mappings:

>>> kv = {}
>>> for i in range(1, 6):
...     kv['line_dict_{}'.format(i)] = { 'a': 1 }
... 
>>> kv
{'line_dict_4': {'a': 1}, 'line_dict_5': {'a': 1}, 'line_dict_1': {'a': 1}, 'line_dict_3': {'a': 1}, 'line_dict_2': {'a': 1}}

>>> kv['line_dict_1']
{'a': 1}
>>> kv['line_dict_2']
{'a': 1}
>>> kv['line_dict_3']
{'a': 1}
>>> kv['line_dict_4']
{'a': 1}
>>> kv['line_dict_5']
{'a': 1}