Is there a way to simplify this function and how does this may look like?

I'm a total noob and I need some help here:

I will always input (into AttributeList) a 2 dimensional nested list into this function.

def CombineAttributes(AttributeList):

	

    NumAttributes = len(AttributeList)
    
    	print("Got the following AttributeList: {}  , it has got {} Attributes in it and im going to Combine Everything now".format(AttributeList, NumAttributes) )
    
    
    
    	if( NumAttributes > 10):
    		print("MAXIMUM NUMBER OF 10 ATTRIBUTES REACHED")
    	elif( NumAttributes == 1 ):
    		List = [str(a) for a in AttributeList[0]]
    	elif( NumAttributes == 2 ):
    		List = [[str(a)+str(b) for a in AttributeList[0]] for b in AttributeList[1]]
    	elif( NumAttributes == 3 ):
    		List = [[str(a)+str(b)+str(c) for a in AttributeList[0]] for b in AttributeList[1] for c in AttributeList[2]]
    	elif( NumAttributes == 4 ):
    		List = [[str(a)+str(b)+str(c)+str(d) for a in AttributeList[0]] for b in AttributeList[1] for c in AttributeList[2] for d in AttributeList[3]]
    	elif( NumAttributes == 5 ):
    		List = [[str(a)+str(b)+str(c)+str(d)+str(e) for a in AttributeList[0]] for b in AttributeList[1] for c in AttributeList[2] for d in AttributeList[3] for e in AttributeList[4]]
    	elif( NumAttributes == 6 ):
    		List = [[str(a)+str(b)+str(c)+str(d)+str(e)+str(f) for a in AttributeList[0]] for b in AttributeList[1] for c in AttributeList[2] for d in AttributeList[3] for e in AttributeList[4] for f in AttributeList[5]]
    	elif( NumAttributes == 7 ):
    		List = [[str(a)+str(b)+str(c)+str(d)+str(e)+str(f)+str(g) for a in AttributeList[0]] for b in AttributeList[1] for c in AttributeList[2] for d in AttributeList[3] for e in AttributeList[4] for f in AttributeList[5] for g in AttributeList[6]]
    	elif( NumAttributes == 8 ):
    		List = [[str(a)+str(b)+str(c)+str(d)+str(e)+str(f)+str(g)+str(h) for a in AttributeList[0]] for b in AttributeList[1] for c in AttributeList[2] for d in AttributeList[3] for e in AttributeList[4] for f in AttributeList[5] for g in AttributeList[6] for h in AttributeList[7]]
    	elif( NumAttributes == 9 ):
    		List = [[str(a)+str(b)+str(c)+str(d)+str(e)+str(f)+str(g)+str(h)+str(i) for a in AttributeList[0]] for b in AttributeList[1] for c in AttributeList[2] for d in AttributeList[3] for e in AttributeList[4] for f in AttributeList[5] for g in AttributeList[6] for h in AttributeList[7] for i in AttributeList[8]]
    	elif( NumAttributes == 10 ):
    		List = [[str(a)+str(b)+str(c)+str(d)+str(e)+str(f)+str(g)+str(h)+str(i)+str(j) for a in AttributeList[0]] for b in AttributeList[1] for c in AttributeList[2] for d in AttributeList[3] for e in AttributeList[4] for f in AttributeList[5] for g in AttributeList[6] for h in AttributeList[7] for i in AttributeList[9] for j in AttributeList[10]]
    
    	print("Im going to return the following after ive combined everything: {}".format(List))
    	return List

example input call:

List = [['a','b','c','d'],[1,2,3,4]]
CombineAttributes(List)

output of this call:

Got the following AttributeList: [['a', 'b', 'c', 'd'], ['1', '2', '3', '4']]  , it has got 2 Attributes in it and im going to Combine Everything now
Im going to return the following after ive combined everything: [['a1', 'b1', 'c1', 'd1'], ['a2', 'b2', 'c2', 'd2'], ['a3', 'b3', 'c3', 'd3'], ['a4', 'b4', 'c4', 'd4']]

I would be happy if i would be able to remove the maximum amount of Attributes (NumAttributes) and if i could remove the bunch of "if's" and "elif's" to shorten it into a couple of lines by looping through the list.

Please comment misunderstandings of my code or my question. Im curious about your answeres.

You can use itertools product here to generate your merged data. note that the pair returned will be tuple in the list rather then lists.

def CombineAttributes(data):
	print(f"Got the following AttributeList: {data} its got {len(data)} Attributes in it and im going to Combine Everything now")
	merged = [[]]
	for pair in product(*data[::-1]):
		if len(merged[-1]) == len(data[0]):
			merged.append([])
		merged[-1].append("".join(str(ele) for ele in pair[::-1]))
	merged.sort()
	print("Im going to return the following after ive combined everything:", merged)
	return merged

data = [['a', 'b', 'c', 'd'], [1, 2, 3, 4]]
CombineAttributes(data)
data1 = [['a', 'b'], [1, 2], ['W', 'X']]
CombineAttributes(data1)

OUTPUT

Got the following AttributeList: [['a', 'b', 'c', 'd'], [1, 2, 3, 4]] its got 2 Attributes in it and im going to Combine Everything now
Im going to return the following after ive combined everything: [['a1', 'b1', 'c1', 'd1'], ['a2', 'b2', 'c2', 'd2'], ['a3', 'b3', 'c3', 'd3'], ['a4', 'b4', 'c4', 'd4']]
Got the following AttributeList: [['a', 'b'], [1, 2], ['W', 'X']] its got 3 Attributes in it and im going to Combine Everything now
Im going to return the following after ive combined everything: [['a1W', 'b1W'], ['a1X', 'b1X'], ['a2W', 'b2W'], ['a2X', 'b2X']]

This is an alternative answer using itertools.product and comprehensions, which gives you almost the exact output you asked:

from pprint import pprint
from itertools import product

a = ['a', 'b', 'c', 'd']

b = ['1', '2', '3', '4']

axb = [
    [''.join(_) for _ in list(product(a, b))][_:_ + len(a)]
    for _ in range(0, len(a) * len(b), len(a))
]

pprint(axb)

Resulting in:

[['a1', 'a2', 'a3', 'a4'],
 ['b1', 'b2', 'b3', 'b4'],
 ['c1', 'c2', 'c3', 'c4'],
 ['d1', 'd2', 'd3', 'd4']]

As you see, you will need to transpose axb to get the exact output needed. That can be achieved with numpy.transpose(), for example. Look:

>>> from numpy import transpose
>>> transpose(axb)
array([['a1', 'b1', 'c1', 'd1'],
       ['a2', 'b2', 'c2', 'd2'],
       ['a3', 'b3', 'c3', 'd3'],
       ['a4', 'b4', 'c4', 'd4']], dtype='<U2')
>>> 

If you want to stick with Python's standard modules, you can transpose the result with:

axbcopy = axb.copy()
for i in range(len(axb)):
    for j in range(len(axb[0])):
        axbcopy[i][j] = axb[j][i]

Or, with a more Pythonic method:

axbt = list(map(list, zip(*axb)))

Where axbt will hold the final result.