Como usar a função sum no Python?

[

Python’s sum(): A maneira Pythonica de somar valores

1 Comentário

A função embutida sum() do Python é uma forma eficiente e Pythonica de somar uma lista de valores numéricos. Adicionar vários números juntos é um passo intermediário comum em muitos cálculos, então o sum() é uma ferramenta bastante útil para programadores Python.

Como caso de uso adicional e interessante, você pode concatenar listas e tuplas usando o sum(), o que pode ser conveniente quando você precisa “nivelar” uma lista de listas.

Neste tutorial, você aprenderá como:

Somar valores numéricos manualmente usando técnicas gerais e ferramentas
Utilizar o sum() do Python para adicionar vários valores numéricos de maneira eficiente
Concatenar listas e tuplas com o sum()
Utilizar o sum() para abordar problemas comuns de soma
Utilizar valores apropriados para os argumentos no sum()
Decidir entre o sum() e outras ferramentas alternativas para somar e concatenar objetos

Esses conhecimentos ajudarão você a abordar e resolver de maneira eficiente problemas de soma em seu código, utilizando tanto o sum() quanto outras ferramentas alternativas e especializadas.

Compreendendo o Problema de Soma

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

1 + 2 + 3 + 4 + 5 = 15

Em termos matemáticos, essa expressão é bastante simples. Ela te guia por uma curta série de adições até encontrar a soma de todos os números.

É possível fazer esse cálculo específico manualmente, mas imagine algumas outras situações em que isso pode não ser possível. Se você tiver uma lista particularmente 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 uma situação em que o número de itens que você precisa somar muda dinamicamente ou de forma imprevisível.

Em situações como essas, seja com 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, então você pode tentar usar um loop for:

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

for number in numbers:
    total += number

print(total) # Output: 15

Aqui, você primeiro cria a variável total e a inicializa como zero. Em seguida, você percorre todos os números na lista numbers usando um loop for e os adiciona ao valor atual de total. No final, você imprime o valor final de total, que é a soma dos números.

No entanto, o Python possui uma função embutida chamada sum() que torna esse processo ainda mais simples e eficiente. Vamos explorar como utilizar o sum() para somar valores numéricos.

Começando com o `sum()` do Python

A função sum() do Python pode ser utilizada para somar os valores de uma sequência, como uma lista ou uma tupla. Sua sintaxe é a seguinte:

sum(iterable, start)

Onde iterable é a sequência de valores a serem somados e start é um valor opcional que representa o valor inicial da soma. Vamos entender como funciona cada um desses argumentos.

O Argumento Obrigatório: iterable

O argumento iterable no sum() é a sequência de valores que você deseja somar. O iterable pode ser qualquer objeto iterável do Python, como uma lista, tupla, conjunto ou até mesmo uma string.

Por exemplo, vamos usar a função sum() para somar os números de uma lista:

numbers = [1, 2, 3, 4, 5]
total = sum(numbers)

print(total) # Output: 15

Aqui, passamos a lista numbers como o argumento iterable para a função sum(). A função sum() itera sobre cada número na lista e os adiciona para obter a soma total, que é armazenada na variável total. Por fim, imprimimos o valor de total.

Além de listas, você também pode usar outras sequências como argumento iterable, como tuplas:

numbers = (1, 2, 3, 4, 5)
total = sum(numbers)

print(total) # Output: 15

Aqui, passamos a tupla numbers como argumento iterable para a função sum(), e o resultado é o mesmo que no exemplo anterior.

O Argumento Opcional: start

O argumento start no sum() é um valor opcional que representa o valor inicial da soma. Caso você não forneça esse argumento, o start será considerado como zero por padrão.

Exemplo:

numbers = [1, 2, 3, 4, 5]
start_value = 10
total = sum(numbers, start_value)

print(total) # Output: 25

Aqui, passamos a lista numbers como o argumento iterable e o valor start_value como o argumento start. A função sum() começa a soma a partir do valor start_value e, em seguida, adiciona os números da lista. O resultado é uma soma total de 25.

É importante notar que o start pode ser qualquer objeto que suporte operações de adição com os elementos do iterable. Portanto, você também pode usar uma string como o start, desde que a operação de concatenação de strings seja válida.

words = ["Olá", "mundo", "!"]
greeting = sum(words, "Cumprimentos: ")

print(greeting) # Output: Cumprimentos: Olá mundo !

Aqui, passamos a lista words como o argumento iterable e a string “Cumprimentos: ” como o argumento start. A função sum() concatena as palavras da lista com a string inicial e o resultado é uma saudação completa “Cumprimentos: Olá mundo !“.

Somando Valores Numéricos

Além de somar listas e tuplas, o sum() também pode ser utilizado para somar uma sequência de valores numéricos. Isso pode ser útil quando você tem uma lista de números que precisa somar e que não se encontra em uma única estrutura de dados.

Para somar valores numéricos com o sum(), basta passar uma lista de números como argumento iterable para a função:

numbers = [1, 2, 3, 4, 5]
total = sum(numbers)

print(total) # Output: 15

Neste exemplo, a função sum() itera sobre cada número da lista numbers e os adiciona para obter a soma total, que é armazenada na variável total. Por fim, o valor de total é impresso.

Você também pode utilizar o sum() para somar uma tupla de números:

numbers = (1, 2, 3, 4, 5)
total = sum(numbers)

print(total) # Output: 15

Aqui, a função sum() é utilizada da mesma forma, mas agora com uma tupla numbers como argumento iterable. O resultado é o mesmo, a soma total dos números.

O sum() também pode ser utilizado para somar elementos de outras estruturas de dados, desde que sejam iteráveis. Por exemplo, você pode somar os valores de um conjunto:

numbers = {1, 2, 3, 4, 5}
total = sum(numbers)

print(total) # Output: 15

Aqui, passamos o conjunto numbers como argumento iterable para a função sum(), e o resultado será a soma total dos elementos.

Em resumo, o sum() pode somar valores numericos de qualquer estrutura de dados iterável, como listas, tuplas e conjuntos. Isso ajuda a evitar a necessidade de escrever um loop manualmente para somar os valores.

Concatenando Sequências

Além de somar valores numéricos, o sum() também pode ser utilizado para concatenar sequências como listas e tuplas. Essa funcionalidade pode ser útil quando você precisa “nivelar” uma lista de listas, por exemplo.

Para concatenar sequências com o sum(), basta passar as sequências desejadas como argumento iterable para a função:

lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened_list = sum(lists, [])

print(flattened_list) # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

Neste exemplo, temos uma lista de listas chamada lists. Utilizando o sum() com uma lista vazia [] como valor inicial, podemos concatenar todas as listas em uma única lista. O resultado é uma nova lista flattened_list, que contém todos os elementos das listas originais concatenados.

A mesma lógica se aplica quando você deseja concatenar tuplas:

tuples = ((1, 2), (3, 4), (5, 6))
flattened_tuple = sum(tuples, ())

print(flattened_tuple) # Output: (1, 2, 3, 4, 5, 6)

Neste exemplo, temos uma tupla de tuplas chamada tuples. Utilizando o sum() com uma tupla vazia () como valor inicial, podemos concatenar todas as tuplas em uma única tupla. O resultado é uma nova tupla flattened_tuple, que contém todos os elementos das tuplas originais concatenados.

Em resumo, o sum() pode ser utilizado para concatenar sequências como listas e tuplas, resultando em uma única sequência que contém todos os elementos das sequências originais concatenados. Essa funcionalidade pode ser útil em situações em que você precisa “nivelar” uma lista de listas ou tuplas.

Praticando com o `sum()` do Python

Agora que você já conhece o básico sobre o sum(), vamos praticar um pouco mais com alguns exemplos adicionais de uso.

Calculando Somas Cumulativas

O sum() pode ser utilizado para calcular somas cumulativas, onde você acumula o total de valores à medida que percorre uma sequência.

Por exemplo, vamos calcular as somas cumulativas de uma lista de números:

numbers = [1, 2, 3, 4, 5]
cumulative_sums = []

for i in range(1, len(numbers) + 1):
    cumulative_sum = sum(numbers[:i])
    cumulative_sums.append(cumulative_sum)

print(cumulative_sums) # Output: [1, 3, 6, 10, 15]

Aqui, utilizamos um loop for para percorrer cada posição na lista numbers. Em cada iteração, utilizamos o sum() para calcular a soma dos números até aquela posição e adicionamos o resultado à lista cumulative_sums. No final, imprimimos a lista de somas cumulativas.

Outra forma de calcular somas cumulativas é utilizando uma list comprehension:

numbers = [1, 2, 3, 4, 5]
cumulative_sums = [sum(numbers[:i+1]) for i in range(len(numbers))]

print(cumulative_sums) # Output: [1, 3, 6, 10, 15]

Neste exemplo, utilizamos uma list comprehension para criar a lista de somas cumulativas. A list comprehension percorre cada posição i na lista numbers e utiliza o sum() para calcular a soma dos números até aquela posição.

Ambos os exemplos produzem o mesmo resultado, uma lista cumulative_sums contendo as somas cumulativas.

Calculando a Média de uma Amostra

Outro caso comum em que o sum() pode ser útil é no cálculo da média de uma amostra de valores.

Para calcular a média de uma amostra, você pode somar todos os valores e, em seguida, dividir o resultado pelo número de valores. Vamos ver como podemos fazer isso com o sum():

sample = [5, 10, 15, 20, 25]
sample_mean = sum(sample) / len(sample)

print(sample_mean) # Output: 15.0

Neste exemplo, utilizamos o sum() para somar todos os valores da lista sample e, em seguida, dividimos o resultado pelo número de valores utilizando a função len() para obter a média da amostra. O resultado é uma média de 15.0.

Encontrando o Produto Escalar de Duas Sequências

O sum() também pode ser utilizado para encontrar o produto escalar de duas sequências. O produto escalar é uma operação matemática que combina duas sequências e retorna um único valor. No caso de duas sequências numéricas, o produto escalar é calculado multiplicando cada elemento correspondente das sequências e, em seguida, somando esses produtos.

Por exemplo, vamos encontrar o produto escalar entre duas listas de números:

list1 = [1, 2, 3]
list2 = [4, 5, 6]
dot_product = sum(x * y for x, y in zip(list1, list2))

print(dot_product) # Output: 32

Aqui, utilizamos a função zip() para combinar os elementos correspondentes das listas list1 e list2. Em seguida, utilizamos uma generator expression para multiplicar os elementos correspondentes e, finalmente, utilizamos o sum() para somar esses produtos e obter o produto escalar. O resultado é um produto escalar de 32.

Nivelando uma Lista de Listas

Como mencionado anteriormente, o sum() pode ser utilizado para nivelar uma lista de listas, ou seja, transformar uma lista que contém outras listas em uma única lista.

Por exemplo, vamos nivelar a seguinte lista de listas:

list_of_lists = [[1, 2], [3, 4], [5, 6]]
flattened_list = sum(list_of_lists, [])

print(flattened_list) # Output: [1, 2, 3, 4, 5, 6]

Aqui, utilizamos o sum() com uma lista vazia [] como valor inicial para concatenar todas as listas no list_of_lists em uma única lista flattened_list. O resultado é uma nova lista que contém todos os elementos das listas originais concatenados.

Utilizando Alternativas ao `sum()`

Apesar de ser uma ferramenta poderosa e versátil para somar valores e concatenar sequências, o sum() pode não ser sempre a melhor opção para todas as situações. Existem algumas alternativas especializadas que podem ser mais eficientes e adequadas, dependendo do contexto.

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

Se você está trabalhando com números de ponto flutuante e precisa de uma precisão mais alta na soma, o math.fsum() pode ser uma alternativa mais adequada do que o sum().

A função math.fsum() é uma função do módulo math que calcula a soma de uma sequência de números de ponto flutuante com uma precisão “exata”. Isso significa que ela evita a perda de precisão que pode ocorrer com o uso do operador + ou do sum() para somar números de ponto flutuante.

Veja um exemplo de uso do math.fsum():

import math

numbers = [0.1] * 10_000
total = math.fsum(numbers)

print(total) # Output: 1000.0

Neste exemplo, utilizamos a função math.fsum() para somar uma lista de 10.000 números de ponto flutuante, cada um com o valor 0.1. Como a função math.fsum() possui uma precisão mais alta, o resultado da soma é exatamente 1000.0.

Concatenando Iteráveis com itertools.chain()

Se você precisa concatenar vários iteráveis em vez de listas ou tuplas, a biblioteca itertools oferece uma alternativa interessante ao sum(). A função itertools.chain() permite concatenar iteráveis de maneira eficiente.

Veja um exemplo de uso do itertools.chain():

import itertools

lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened_list = list(itertools.chain.from_iterable(lists))

print(flattened_list) # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

Aqui, utilizamos a função itertools.chain.from_iterable() para concatenar todas as listas em lists. Em seguida, convertemos o resultado em uma lista utilizando a função list(). O resultado é uma lista flattened_list que contém todos os elementos das listas originais concatenados.

Concatenando Strings com str.join()

Outra alternativa para concatenar sequências de strings é utilizar o método join() da classe str. Esse método permite concatenar várias strings de maneira eficiente.

Veja um exemplo de uso do str.join():

words = ["Olá", "mundo", "!"]
concatenated_string = " ".join(words)

print(concatenated_string) # Output: "Olá mundo !"

Aqui, utilizamos o método join() da string " " para concatenar as palavras da lista words. O resultado é uma única string concatenated_string que contém todas as palavras separadas por um espaço.

Conclusão

Neste tutorial, você aprendeu como utilizar o sum() do Python para somar valores numéricos e concatenar sequências como listas e tuplas. O sum() é uma ferramenta poderosa e Pythonica que ajuda a simplificar cálculos de soma e concatenação em seu código Python.

Você viu como utilizar o sum() para somar valores numéricos, calcular somas cumulativas, encontrar a média de uma amostra, calcular o produto escalar de duas sequências e nivelar listas de listas. Além disso, explorou alternativas ao sum() como o math.fsum(), itertools.chain() e str.join().

Agora você está equipado com o conhecimento necessário para utilizar o sum() de maneira eficiente e resolver diversos problemas de soma em seu código Python. Não deixe de experimentar o sum() em seus próprios projetos e aproveite sua facilidade e versatilidade!

Aprenda mais sobre Python

[E-mail](mailto:?subject=Python article for you&body=Confira este tutorial sobre Python%27s%20sum%28%29%3A%20The%20Pythonic%20Way%20to%20Sum%20Values)