exercicio_de_python_somando_duas_listas.py

"""
Considerando duas listas de inteiros ou floats (lista A e lista B)
Some os valores nas listas retornando uma nova lista com os valores somados:

Se uma lista for maior que a outra, a soma só vai considerar o tamanho da
menor.

Exemplo:
lista_a     = [1, 2, 3, 4, 5, 6, 7]
lista_b     = [1, 2, 3, 4]

=================== resultado
lista_soma  = [2, 4, 6, 8]
"""
lista_a = [10, 2, 3, 40, 5, 6, 7]
lista_b = [1, 2, 3, 4]
lista_soma = [x + y for x, y in zip(lista_a, lista_b)]
print(lista_soma)

# lista_soma = []
# for i in range(len(lista_b)):
#     lista_soma.append(lista_a[i] + lista_b[i])
# print(lista_soma)

# lista_soma = []
# for i, _ in enumerate(lista_b):
#     lista_soma.append(lista_a[i] + lista_b[i])
# print(lista_soma)

`lista_a = [1, 2, 3, 4, 5, 6, 7]
lista_b = [1, 2, 3, 4]

lista_soma = [i[0] + i[1] for i in zip(lista_a, lista_b)]
print(lista_soma)
`

lista_a = [2, 4, 8, 16, 32]
lista_b = [2, 4, 8, 16]
lista_c = []

limite_lista = list(zip(lista_a, lista_b))
for i in limite_lista:
soma = sum(i)
lista_c.append(soma)
print(lista_c)

Ficou complexo assim pois quis usar closure e list comprehension.

def soma_listas(lista_maior):
def soma(lista_menor):
l3 = list(zip(lista_maior, lista_menor))
l4 = [
x + y
for x, y in l3
]
return l4
return soma

lista_maior = soma_listas([1, 3, 5, 7, 9, 11, 13])
print(lista_maior([2, 4, 6, 8]))

Fiz pra treinar sobre decorators

lista_a     = [1, 2, 3, 4, 5, 6, 7, 1, 22]
lista_b     = [1, 2, 3, 4, 10, 11, 99, 0, 17, 8]

def decorator(func):
    def inner(*args):
        result = func(*args)
        return result
    return inner

#@decorator
def new_list(*args):
    size = min(len(args[0]), len(args[1]))
    return [
        args[0][sz] + args[1][sz]
        for sz in range(size)
    ]

# funciona passando pelo decorator comentado ou não, dá no mesmo
lista_soma = new_list(lista_a, lista_b)
print(f"Lista Soma: {lista_soma}")

# passando diretamente o decorator 
lista_soma2 = decorator(new_list)
print(f"Lista Soma 2: {lista_soma2(lista_a, lista_b)}")

#fui ver a resposta e achei incrível que cada pessoa teve uma forma de responder diferente e nenhuma foi igual :O. É isso ai, vamo que vamo galera!!!

lista_a = [1,2,3,4,5,6,7]
lista_b = [1,2,3,4]
lista_soma = []

def somar_lista(list1, list2):
for i in range(len(list1)):
lista_soma.append(list1[i] + list2[i])
print(lista_soma)

if len(lista_a) > len(lista_b):
print('lista A é maior!')
somar_lista(lista_b, lista_a)
else:
print('lista B é maior!')
somar_lista(lista_a, lista_b)

from itertools import zip_longest

lista_a = [10, 2, 3, 40, 5, 6, 7]
lista_b = [1, 2, 3, 4]
list_some = [x + y for x, y in zip_longest(lista_a, lista_b, fillvalue= 0)]
print(list_some)

Eu já vi a resposta antes, mas como modo de mostrar que eu aprendi msm eu decidi usar a conta de ambos as listas...

lista_a = [1, 2, 3, 4, 5, 6, 7]
lista_b = [1, 2, 3, 4]

def sum_list(l1, l2):
interval = min(len(l1), len(l2))
return [(l1[i] + l2[i]) for i in range(interval)]

v1 = sum_list(lista_a, lista_b)
print(v1)

lista_a     = [1, 2, 3, 4, 5, 6, 7]
lista_b     = [1, 2, 3, 4]

def sum_operation():
    def inner(la , lb):
        interval = min(len(la),len(lb))       
        result = []
        for i in range(interval):            
            result.append(la[i]+lb[i])
        return result
            
    return inner

soma = sum_operation()

print(soma(lista_a,lista_b))

#-------------------------------------------------------------------------------------------

la     = [1, 2, 3, 4, 5, 6, 7]
lb     = [1, 2, 3, 4]

for i in zip(la,lb):
    x, y = i
    print(f'Resultado da soma {x} + {y} é: {x + y}')

Resultados:
[2, 4, 6, 8]

Resultado da soma 1 + 1 é: 2
Resultado da soma 2 + 2 é: 4
Resultado da soma 3 + 3 é: 6
Resultado da soma 4 + 4 é: 8

def soma(lista_a, lista_b):
intervalo_max = min(len(lista_a), len(lista_b))
return [
(lista_a[indice] + lista_b[indice])
for indice in range(intervalo_max)

]

lista_a = [1, 2, 3, 4, 5, 6, 7]
lista_b = [1, 2, 3, 4]

lista_soma = soma(lista_a, lista_b)
print(lista_soma)

result = print(f'O resultado final eh: {lista_soma}')

lista_a = [1, 2, 3, 4, 5, 6, 7]
lista_b = [1, 2, 3, 4]
lista_soma = []

range_min = 1
if len(lista_a) > len(lista_b):
    range_min = len(lista_b)
else:
    range_min = len(lista_a)
for i in range(range_min):
    lista_soma.append(lista_a[i] + lista_b[i])
print(lista_soma)

lista_a = [10, 2, 3, 40, 5, 6, 7]
lista_b = [1, 2, 3, 4]

tamanhoListaA = len(lista_a)
tamanhoListaB = len(lista_b)
menorLista = 0
if tamanhoListaA < tamanhoListaB:
menorLista = tamanhoListaA
else:
menorLista = tamanhoListaB

lista_c = []
i = 0

for numero in range(menorLista):
numero_nova_lista = lista_a[i]+ lista_b[i]
lista_c.append(numero_nova_lista)
i += 1

print(lista_c)

Tentei usar decoradores, mas não consegui. Então fiz uma função simples mesmo.

lista_a = [1, 2, 3, 4, 5, 6, 7]
lista_b = [1, 2, 3, 4]


def somar_itens_lista(lista_a, lista_b):

    if len(lista_a) > len(lista_b):
        intervalo = len(lista_b)
    else:
        intervalo = len(lista_a)
    
    return [
        (lista_a[i] + lista_b[i]) for i in range(intervalo)
    ]


print(somar_itens_lista(lista_a, lista_b))

lista_a = [1, 2, 3, 4, 5, 6, 7]
lista_b = [1, 2, 3, 4]

listaZip = list(zip(lista_a, lista_b))
lista_somada = [a + b for a, b in listaZip]

print(lista_somada)

lista_a = [10, 2, 3, 40, 5, 6, 7]
lista_b = [1, 2, 3, 4]
resultado = []

listab_destrinchada = iter(lista_b)

for item in lista_a:
    try:
        item += listab_destrinchada.__next__()
        #print(item) # Propósitos de testes
        resultado.append(item)
    except StopIteration:
        #print(item) # Propósitos de testes
        resultado.append(item)

print("A soma da listaA: ")
print(lista_a)
print("+")
print("listaB: ")
print(lista_b)
print("= ")
print(resultado)

list_a = [i for i in range(1, 8)]
list_b = [i for i in range(1, 5)]

def sum_list(lst1, lst2):
interval = min(len(lst1), len(lst2))
return [
lst1[i] + lst2[i]
for i in range(interval)
]

print(sum_list(list_a, list_b))

Função que soma diversas listas

def sum_lists(*args):
return [sum(args) for args in zip(*args)]

print(sum_lists(list_a, list_b, list_c))

lista_a = [1, 2.8, 3, 4, 5, 6, 7]
lista_b = [1, 2, 3, 4]

def somando_valores(l1, l2):
menor_valor = min(len(l1), len(l2))
if len(l1) <= len(l2):
return [l1[i] + l2[i] for i in range(menor_valor)]
elif len(l2) < len(l1):
return [l2[i] + l1[i] for i in range(menor_valor)]
else:
return "Não sei como chegou aq"

print(somando_valores(lista_a, lista_b))

list_a = [1, 2, 3, 4 ,5 ,6, 7]
list_b = [1, 2, 3, 4]

def List_sum(list1, list2):
size = min(len(list1),len(list2))
return[
list1[i] + list2[i] for i in range(size)
]

print(List_sum(list_a, list_b))

l1 = [1, 2, 3, 4, 5, 6, 7]
l2 = [1, 2, 3, 4]

def sum_list(list1, list2):
    list_sum = []
    value_min = min(list1, list2)

    for x in range(len(value_min)):
        new_list = list1[x] + list2[x]
        list_sum.append(new_list)
    return list_sum

print(sum_list(l1, l2))

def criar_funcao(func):
def interna(*args, **kwargs):
for arg in args:
is_int(arg)
resultado = func(*args, **kwargs)
return resultado
return interna

def is_int(param):
if not isinstance(param, int):
raise TypeError('param deve ser um int')

@criar_funcao
def soma(a, b):
return a + b

def zipper(lista1, lista2):
intervalo = min(len(lista1), len(lista2))
return [
soma(lista1[i],lista2[i]) for i in range(intervalo)
]

lista_a = [1, 2, 3, 4, 5, 6, 7]
lista_b = [1, 2, 3, 4]
print(list(zipper(lista_a, lista_b)))