Pular para o conteúdo
CodeMDD.io | Coding Tutorials

Como Usar a Função sum() do Python para Soma de Listas

[

Python’s sum(): A maneira Pythônica de somar valores

Python possui uma função interna chamada sum() que é uma forma eficiente e Pythônica de somar uma lista de valores numéricos. Somar vários números juntos é um passo intermediário comum em muitos cálculos, por isso sum() é uma ferramenta muito útil para programadores Python.

Além disso, é interessante destacar que é possível concatenar listas e tuplas usando sum(), o que pode ser conveniente quando você precisa “achatar” uma lista de listas.

Neste tutorial, você aprenderá como:

  • Somar valores numéricos manualmente usando técnicas e ferramentas gerais.
  • Usar sum() do Python para somar eficientemente vários valores numéricos.
  • Concatenar listas e tuplas com sum().
  • Resolver problemas comuns de soma usando sum().
  • Usar argumentos adequados em sum().
  • Decidir entre sum() e outras ferramentas alternativas para somar e concatenar objetos.

Esses conhecimentos irão ajudá-lo a abordar e resolver problemas de soma de forma eficiente em seu código, utilizando tanto sum() quanto outras ferramentas alternativas e especializadas.

Entendendo o problema da soma

Somar valores numéricos é um problema bastante comum na programação. Por exemplo, digamos que você tenha uma lista de números [1, 2, 3, 4, 5] e queira somá-los para calcular a soma total. Usando aritmética padrão, você faria algo como:

1 + 2 + 3 + 4 + 5 = 15

Em termos de matemática, essa expressão é bastante simples. Ela mostra uma série curta de adições que levam à soma de todos os números.

É possível fazer esse cálculo manualmente, mas imagine algumas situações em que isso pode não ser tão viável. Se você tiver uma lista especialmente longa de números, somar manualmente pode ser ineficiente e propenso a erros. E se você nem mesmo souber quantos itens estão na lista? Por fim, imagine um cenário em que o número de itens que você precisa somar muda dinamicamente ou de forma imprevisível.

Em situações como essas, independentemente de você ter uma lista longa ou curta de números, o Python pode ser bastante útil para resolver problemas de soma.

Se você deseja somar os números criando sua própria solução do zero, pode tentar usar um loop for:

numbers = [1, 2, 3, 4, 5]
total = 0


for number in numbers:
    total += number


print(total)

Aqui, você cria a variável total e a inicializa com 0. Em seguida, você itera sobre cada número da lista numbers e adiciona o número atual ao total. No final, você imprime o resultado.

Essa é uma forma manual de somar os números de uma lista, mas Python oferece uma maneira mais simples e eficiente usando a função sum().

Começando com o sum() do Python

A função sum() do Python é um método eficiente e Pythônico para somar valores numéricos. Ela recebe um argumento obrigatório, que é o iterável contendo os valores a serem somados. Um iterável é um objeto que pode ser percorrido, como uma lista, uma tupla ou um conjunto.

O Argumento Obrigatório: iterável

O argumento obrigatório para a função sum() é um iterável que contém os valores a serem somados. Vamos ver alguns exemplos para entender melhor como isso funciona.

numbers = [1, 2, 3, 4, 5]
total = sum(numbers)
print(total)  # Saída: 15


tup = (10, 20, 30)
total_tup = sum(tup)
print(total_tup)  # Saída: 60


set_numbers = {1, 2, 3, 4, 5}
total_set = sum(set_numbers)
print(total_set)  # Saída: 15

Nesses exemplos, numbers, tup e set_numbers são iteráveis que contêm os valores a serem somados. Ao passar esses iteráveis como argumento para sum(), a função retorna a soma total dos elementos.

O Argumento Opcional: start

A função sum() também possui um argumento opcional chamado start, que define um valor inicial para a soma. Por padrão, esse valor inicial é 0, mas você pode alterá-lo de acordo com suas necessidades.

numbers = [1, 2, 3, 4, 5]
total = sum(numbers, 10)
print(total)  # Saída: 25

Nesse exemplo, ao definir start como 10, a função sum() primeiro adicionará 10 ao resultado antes de somar os valores da lista numbers. Portanto, o resultado final será 25.

Somando Valores Numéricos

A função sum() não se limita apenas a listas, tuplas e conjuntos. Ela pode ser usada para somar qualquer iterável que contenha valores numéricos. Isso inclui objetos como range() e até mesmo strings.

r = range(1, 6)
total_r = sum(r)
print(total_r)  # Saída: 15


text = "12345"
total_text = sum(map(int, text))
print(total_text)  # Saída: 15

Nesses exemplos, r é um objeto range() que contém os números de 1 a 5. A função sum() consegue somar todos os números nesse intervalo. O mesmo ocorre no segundo exemplo, em que a função map() é usada para converter cada caractere da string em um número inteiro antes de serem somados com sum().

Concatenando Sequências

Uma aplicação interessante da função sum() é que ela pode ser usada para concatenar listas e tuplas. Isso pode ser útil quando você precisa “achatar” uma lista de listas ou combinar vários objetos de sequência em um único objeto.

Vamos ver um exemplo:

list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened_list = sum(list_of_lists, [])
print(flattened_list)  # Saída: [1, 2, 3, 4, 5, 6, 7, 8, 9]

Nesse exemplo, list_of_lists é uma lista de listas (ou seja, uma lista que contém outras listas). Usando sum() com um iterável vazio [] como valor inicial, a função concatena todas as listas em uma única lista. Isso cria uma nova lista chamada flattened_list que contém todos os elementos das listas internas.

Praticando com o sum() do Python

Vamos agora praticar um pouco mais com a função sum() e explorar outras aplicações possíveis.

Calculando Somas Acumuladas

Uma tarefa comum em programação é calcular somas acumuladas. Por exemplo, se você tiver uma lista de números [1, 2, 3, 4, 5], pode querer calcular as somas parciais em cada posição:

1
1 + 2 = 3
1 + 2 + 3 = 6
1 + 2 + 3 + 4 = 10
1 + 2 + 3 + 4 + 5 = 15

Podemos usar sum() juntamente com uma lista de compreensão para calcular essas somas acumuladas:

numbers = [1, 2, 3, 4, 5]
cumulative_sums = [sum(numbers[:i+1]) for i in range(len(numbers))]
print(cumulative_sums)  # Saída: [1, 3, 6, 10, 15]

Neste exemplo, usamos uma lista de compreensão para iterar sobre os índices da lista numbers. Em cada iteração, usamos a fatia numbers[:i+1] para obter uma nova lista que contém os números até o índice atual. Em seguida, usamos sum() para calcular a soma desses números. O resultado é uma lista de somas acumuladas.

Calculando a Média de uma Amostra

Você também pode usar sum() para calcular a média de uma amostra de números. Por exemplo, digamos que você tenha os seguintes números: [10, 15, 20, 25, 30]. A média desses números é calculada somando todos eles e dividindo pelo número total de elementos, que nesse caso é 5.

Podemos usar sum() e a função len() para calcular a média:

numbers = [10, 15, 20, 25, 30]
mean = sum(numbers) / len(numbers)
print(mean)  # Saída: 20.0

Neste exemplo, usamos sum() para obter a soma de todos os números e len() para obter o número total de elementos. Em seguida, dividimos a soma pelo número total de elementos para calcular a média.

Encontrando o Produto Escalar de Duas Sequências

Outra aplicação interessante de sum() é a possibilidade de calcular o produto escalar de duas sequências. O produto escalar é uma operação matemática que combina duas sequências de números e produz um único valor. Para calcular o produto escalar, você multiplica os elementos correspondentes de cada sequência e, em seguida, soma esses produtos.

Podemos usar sum() juntamente com a função zip() para calcular o produto escalar de duas listas:

list1 = [1, 2, 3]
list2 = [4, 5, 6]
dot_product = sum(x * y for x, y in zip(list1, list2))
print(dot_product)  # Saída: 32

Nesse exemplo, usamos a função zip() para combinar os elementos correspondentes de list1 e list2. Então, usamos uma expressão geradora (x * y for x, y in zip(list1, list2)) para multiplicar cada par de elementos e gerar uma sequência de produtos. Por fim, usamos sum() para somar todos os produtos e obter o resultado final.

Achatando uma Lista de Listas

Se você tiver uma lista de listas e precisar “achatar” ela em uma única lista, você pode usar sum() junto com uma lista vazia [] como valor inicial:

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened_list = sum(nested_list, [])
print(flattened_list)  # Saída: [1, 2, 3, 4, 5, 6, 7, 8, 9]

Nesse exemplo, usamos sum() com uma lista de listas nested_list e um iterável vazio [] como valor inicial. A função sum() concatena todas as listas na lista nested_list e retorna uma lista única contendo todos os elementos.

Usando Alternativas ao sum()

Embora sum() seja uma ferramenta muito útil para somar valores numéricos e concatenar sequências, existem algumas alternativas úteis que você pode considerar em determinadas situações.

Somando Números de Ponto Flutuante: math.fsum()

Se você estiver trabalhando com números de ponto flutuante, é importante levar em conta a precisão dos cálculos. Devido à forma como os números de ponto flutuante são armazenados e calculados no computador, somar uma sequência de números de ponto flutuante usando a função sum() padrão pode introduzir pequenos erros de arredondamento.

Nesses casos, você pode usar a função math.fsum() para obter uma soma mais precisa:

import math


numbers = [0.1, 0.2, 0.3, 0.4, 0.5]
total = math.fsum(numbers)
print(total)  # Saída: 1.5

Neste exemplo, usamos math.fsum() em vez de sum() para somar uma lista de números de ponto flutuante. A função math.fsum() leva em conta a precisão dos cálculos de ponto flutuante e retorna uma soma mais precisa.

Concatenando Iteráveis com itertools.chain()

Se você precisar concatenar vários iteráveis em um único objeto, sum() pode ser útil. No entanto, em alguns casos, a biblioteca padrão itertools oferece uma maneira mais elegante de fazer isso usando a função chain().

Vamos ver um exemplo:

from itertools import chain


list1 = [1, 2, 3]
list2 = [4, 5, 6]
concatenated = list(chain(list1, list2))
print(concatenated)  # Saída: [1, 2, 3, 4, 5, 6]

Nesse exemplo, usamos itertools.chain() para concatenar as listas list1 e list2 em um único objeto iterável. Em seguida, usamos a função list() para converter o objeto iterável em uma lista. O resultado é uma lista única contendo todos os elementos das duas listas.

Concatenando Strings com str.join()

Se você precisar concatenar várias strings em uma única string, a função str.join() é uma alternativa eficiente ao usar sum(). Essa função concatena todas as strings em um iterável e insere um separador entre elas.

Vamos ver um exemplo:

texts = ['Python', 'is', 'awesome']
concatenated_text = ' '.join(texts)
print(concatenated_text)  # Saída: 'Python is awesome'

Nesse exemplo, usamos str.join() para concatenar as strings da lista texts. O espaço em branco passado como argumento para join() é usado como separador entre as strings. O resultado é uma única string contendo todas as palavras concatenadas.

Conclusão

Python’s sum() é uma função muito útil e Pythônica para somar valores numéricos e concatenar sequências. Neste tutorial, você aprendeu como usar sum() para resolver problemas de soma em seu código de forma mais eficiente. Além disso, você viu algumas aplicações interessantes e alternativas para a função sum().

Agora você está pronto para utilizar sum() e aproveitar seus benefícios em suas próprias aplicações Python. Experimente usá-la em suas tarefas de soma e concatenação e veja como ela pode simplificar seu código.