Compute binary sum with Python 3
You've got way too much code.  You are not using the built-in tools Python provides to solve this problem, making your job much, much harder.



In your check(value) function, you are checking:

if value % 2 == 0:
    # ...
elif value % 2 != 0:
    # ...


If value % 2 == 0 is False, then value % 2 != 0 is guaranteed to be True.  There is no need for the elif ...:; you could simply use an else: clause.

In both cases, you assign amount = int( ... / 2).  Python has built-in integer division operator, //, so these statements could become simply amount = ... // 2.  In the second case, because value is odd, you divide value - 1 by two.  This "subtract 1" is unnecessary.  Using integer division (or dividing and then casting to an integer) will truncate the result to an integer.

Afterwards, in the first case, when value % 2 is zero, you assign value = 0, where as in the second case, when value % 2 is one, you assign value = 1.  You could simply assign value = value % 2.

def check(value):
    amount = value // 2
    value = value % 2
    return value, amount


Or slightly shorter:

def check(value):
    return value % 2, value // 2


Or even better, use the built-in function divmod(a,b) which does the same thing.  But you will have to swap the variables you assign to, because divmod(a,b) returns the result of the division first, and the modulo remainder second:

amount, value = divmod(value, 2)




In your binary_sum(*args) function, you are given a variable number of lists, and you want to take one element from each list, then take the next element from each list, and then take the next element from each list, and so on.  In Python, this is the zip() function.  (Note: "zip" is short for "zipper", not zip-compression.)

for addends in zip(*args):
    # ...


Except we have a wrench in the works; you want to start from the end and work towards the front.  That is hard.  It is easier if each list is reversed(), so starting from the start is starting from what was the end.  We can then zip() those reversed() lists together:

for addends in zip(*map(reversed, args)):
    # ...


Except we have another wrench in the works; the lists aren't all the same length, and zip stops when any of the lists runs out of items.  You need to add 0's at the start, so they are the same length.  Except we've reversed the lists, so we need to add 0's to the end.  That's easy.  We just need itertools.zip_longest(*args, fillvalue=0) to provide the extra 0's.

from itertools import zip_longest

for addends in zip_longest(*map(reversed, args), fillvalue=0):
    # ...


Now addends is first the 1's column digits, then the 2's column digits, then the 4's column digits, and so on.  We can just sum the addends together, along with any carry from the previous column:

digits = []
carry = 0
for addends in zip_longest(*map(reversed, args), fillvalue=0):
    total = sum(addends) + carry
    carry, digit = divmod(total, 2)
    digits.append(digit)


And then, add the carry bits to end once you've run out of columns:

while carry &gt; 0:
    carry, digit = divmod(carry, 2)
    digits.append(digit)


Finally, since we've generated the result in the wrong order, you'll have to reverse it again, so the most significant digit is first.

from itertools import zip_longest

def binary_sum(*args):
    digits = []

    carry = 0
    for addends in zip_longest(*map(reversed, args), fillvalue=0):
        total = sum(addends) + carry
        carry, digit = divmod(total, 2)
        digits.append(digit)

    while carry &gt; 0:
        carry, digit = divmod(carry, 2)
        digits.append(digit)

    return digits[::-1]


A few tests:

&gt;&gt;&gt; binary_sum([1,1,1,0])
[1, 1, 1, 0]
&gt;&gt;&gt; binary_sum([1,1,1,0], [1,0])
[1, 0, 0, 0, 0]
&gt;&gt;&gt; binary_sum([1,1,1,1], [1])
[1, 0, 0, 0, 0]
&gt;&gt;&gt; binary_sum([1,1,1,1], [0,0,0,1])
[1, 0, 0, 0, 0]
&gt;&gt;&gt; binary_sum([1,1,1,1], [1,0,0,0])
[1, 0, 1, 1, 1]
&gt;&gt;&gt; binary_sum([1], [1], [1], [1], [1])
[1, 0, 1]